// <summary> /// Description constructor /// </summary> /// <param name="Fr">Function to be solved delegate</param> /// <param name="xa">Value of low bound</param> /// <param name="xb">Value of high bound</param> /// <param name="x">Intermediate value</param> /// <param name="iter">Amount divisions of segment</param> // public HordMetod(FunctionOne Fr, double xa, double xb, ref double x, ref int iter) public HordMetod(FunctionOne Fr, double xa, double xb, int iter) { double xlast; double x = 0; double e = 1f; if (Fr(xa) * Fr(xb) >= 0) { result[0, 0] = 0; result[1, 0] = 0; // return 0; } iter = 0; do { xlast = x; x = xb - Fr(xb) * (xb - xa) / (Fr(xb) - Fr(xa)); if (Fr(x) * Fr(xa) > 0) { xa = x; } else { xb = x; } iter++; }while (Math.Abs(x - xlast) > e); result[0, 0] = x; result[1, 0] = iter; // return 1; }
public SecantLinear(int step_number, double point1, double point2, FunctionOne f) { double p2, p1, p0, prec = .0001f; //set precision to .0001 int i; p0 = f(point1); p1 = f(point2); p2 = p1 - f(p1) * (p1 - p0) / (f(p1) - f(p0)); //secant formula for (i = 0; System.Math.Abs(p2) > prec && i < step_number; i++) //iterate till precision goal is not met or the maximum //number of steps is reached { p0 = p1; p1 = p2; p2 = p1 - f(p1) * (p1 - p0) / (f(p1) - f(p0)); } if (i <= step_number) { this.Solution = p2; this.HasSolution = true; } else { this.HasSolution = false; } }
/// <summary> /// Default constructor /// </summary> /// <param name="f">Function to be solved delegate.</param> /// <param name="left">Left border of the set interval.</param> /// <param name="right">Right border of the set interval.</param> /// <param name="eps">Exactness conducting of calculations.</param> public ApproximationBase(FunctionOne f, double left, double right, double eps = 0.00001) { this.function = f; this.left = left; this.right = right; this.epsilon = eps; }
public Simpson(FunctionOne f, double a, double b, int pointsNum) { double num2 = 0.0; int num4 = 0; double num3 = 0.014999999664723873; this.result = new double[2, pointsNum + 1]; for (int i = 0; i < pointsNum; i++) { double x = a + num3; do { if ((num4 % 2) == 0) { num2 += 2.0 * f(x); } else { num2 += 4.0 * f(x); } x += num3; num4++; } while (x < b); num2 = (num2 + f(a)) + f(b); num2 *= num3 / 3.0; this.result[0, i] = num2; this.result[1, i] = num3; num2 = 0.0; num3 += 0.0010000000474974513; } }
public Simpson(FunctionOne f, double a, double b, int pointsNum) { double fi, I = 0; double h; int j = 0; h = 0.015f; result = new double[2, pointsNum + 1]; for (int i = 0; i < pointsNum; i++) { fi = a + h; do { if (j % 2 == 0) { I = I + 2 * f(fi); } else { I = I + 4 * f(fi); } fi = fi + h; j = j + 1; } while (fi < b); I = I + f(a) + f(b); I = I * (h / 3); result[0, i] = I; result[1, i] = h; I = 0; h += 0.001f; } }
/// <summary> /// Description constructor /// </summary> /// <param name="Fr">Function to be solved delegate</param> /// <param name="xa">Value of low bound</param> /// <param name="xb">Value of high bound</param> /// <param name="x">Intermediate value</param> /// <param name="iter">Amount divisions of segment</param> // public HordMetod(FunctionOne Fr, double xa, double xb, ref double x, ref int iter) public HordMetod(FunctionOne Fr, double xa, double xb, int iter) { double xlast; double x = 0; double e = 1f; if (Fr(xa) * Fr(xb) >= 0) { result[0, 0] = 0; result[1, 0] = 0; // return 0; } iter = 0; do { xlast = x; x = xb - Fr(xb) * (xb - xa) / (Fr(xb) - Fr(xa)); if (Fr(x) * Fr(xa) > 0) xa = x; else xb = x; iter++; } while (System.Math.Abs(x - xlast) > e); result[0, 0] = x; result[1, 0] = iter; // return 1; }
/// <summary> /// Default constructor /// </summary> /// <param name="function">Function to be solved delegate</param> public Simpson(FunctionOne f, double a, double b, int pointsNum) { double fi, I=0; double h; int j=0; h = 0.015f; result = new double[2, pointsNum+1]; for (int i = 0; i < pointsNum; i++) { fi = a + h; do { if (j % 2 == 0) { I = I + 2 * f(fi); } else { I = I + 4 * f(fi); } fi = fi + h; j = j + 1; } while (fi < b); I = I + f(a) + f(b); I = I * (h / 3); result[0, i] = I; result[1, i] = h; I = 0; h += 0.001f; } }
/// <summary> /// Default constructor /// </summary> /// <param name="function">Function to be solved delegate</param> /// <param name="Left">Left border of the set interval</param> /// <param name="Right">Right border of the set interval</param> /// <param name="epsilon">Exactness conducting of calculations</param> public Bisection(FunctionOne f, double Left, double Right, double epsilon) { bool blnError = false; double c; do { c = (Left + Right) / 2; if (f(Left) * f(c) < 0) { Right = c; } else { Left = c; } if (f(c) == 0) { blnError = (f(c - epsilon / 2) * f(c + epsilon / 2) < 0) ? false : true; break; } }while ((f(c)) > epsilon || (Right - Left) > epsilon); if (blnError == false) { result = c; } }
public Simpson2(FunctionOne f,double a, double b, int step_number) { double sum = 0; double step_size = (b - a) / step_number; for (int i = 0; i < step_number; i = i + 2) //Simpson algorithm samples the integrand in several point which significantly improves //precision. sum = sum + (f(a + i * step_size) + 4 * f(a + (i + 1) * step_size) + f(a + (i + 2) * step_size)) * step_size / 3; //divide the area under f(x) //into step_number rectangles and sum their areas this.Sum = sum; }
public void BisectionTest1() { FunctionOne f = new FunctionOne(x => 4 * Math.Pow(x, 3) + 3 * Math.Pow(x, 2) - 4 * x - 5); double eps = 0.001; Bisection b = new Bisection(f, -0.1, 1.9, eps); Assert.AreEqual(true, Math.Abs(1.125 - b.Result) <= eps); }
public void BisectionTest2() { FunctionOne f = new FunctionOne(x => Math.Pow(x, 2)); double eps = 0.00001; Bisection b = new Bisection(f, -1, 1, eps); Assert.AreEqual(0, b.Result); Assert.AreEqual(1, b.IterationsNumber); }
//const double delta = 0.0001f; /// <summary> /// Description constructor /// </summary> /// <param name="function">Function to be solved delegate</param> public Secant(FunctionOne Fr, double shag, double delta) { for (double i = 0; i <= 10; i = i + dl) { if (Fr(i) * Fr(i + dl) < 0) { SecantMethod(i + dl, Fr, shag, delta); } } }
//const double delta = 0.0001f; /// <summary> /// Description constructor /// </summary> /// <param name="function">Function to be solved delegate</param> public Secant(FunctionOne Fr,double shag, double delta) { for (double i = 0; i <= 10; i = i + dl) { if (Fr(i) * Fr(i + dl) < 0) { SecantMethod(i + dl, Fr, shag,delta); } } }
public Simpson2(FunctionOne f, double a, double b, int step_number) { double num = 0.0; double num2 = (b - a) / ((double) step_number); for (int i = 0; i < step_number; i += 2) { num += (((f(a + (i * num2)) + (4.0 * f(a + ((i + 1) * num2)))) + f(a + ((i + 2) * num2))) * num2) / 3.0; } this.Sum = num; }
public Simpson2(FunctionOne f, double a, double b, int step_number) { double sum = 0; double step_size = (b - a) / step_number; for (int i = 0; i < step_number; i = i + 2) //Simpson algorithm samples the integrand in several point which significantly improves //precision. { sum = sum + (f(a + i * step_size) + 4 * f(a + (i + 1) * step_size) + f(a + (i + 2) * step_size)) * step_size / 3; //divide the area under f(x) //into step_number rectangles and sum their areas } this.Sum = sum; }
private double ChebushevMethod(double A, double B, FunctionOne f) { double[] numArray = new double[] { 0.0, -0.832498, -0.37451300024986267, 0.0, 0.374513, 0.832498 }; double num3 = 0.0; for (int i = 1; i <= 5; i++) { double x = ((A + B) / 2.0) + (((B - A) * numArray[i]) / 2.0); num3 += f(x); } return ((num3 * (B - A)) / 5.0); }
public void RungeKutta4Test1() { Function f = new Function((t, y) => y - t); RungeKutta4 rk4 = new RungeKutta4(f, 0, 0.6, 1.5, 10); FunctionOne f1 = new FunctionOne(t => 0.5 * Math.Pow(Math.E, t) + t + 1); Assert.AreEqual(f1(0.0), rk4.Result[0, 1]); Assert.AreEqual(true, false); var ss1 = f1(0.2); var ss2 = f1(0.4); var ss3 = f1(0.6); }
/// <summary> /// Default constructor /// </summary> /// <param name="function">Function to be solved delegate</param> /// <param name="Left">Left border of the set interval</param> /// <param name="Right">Right border of the set interval</param> /// <param name="x0">Starting condition</param> /// <param name="epsilon">Exactness conducting of calculations</param> public Newton(FunctionOne function, FunctionOne df, double Left, double Right, double x0, double epsilon) { const double m = 2.41064f; const double M = 20.0828f; double xk; xk = x0; do { x0 = xk; xk = x0 - (function(x0) / df(x0)); }while (Math.Abs(xk - x0) > Math.Sqrt(Math.Abs(2f * epsilon * m / M))); result = x0; }
/// <summary> /// Description SecantMethod /// </summary> /// <param name="x0">Initial value</param> /// <param name="Fr">Function to be solved delegate</param> void SecantMethod(double x0, FunctionOne Fr, double shag, double delta) { int j=0; double x1; x1 = x0 - Fr(x0) / fsh(x0,Fr,shag); while (System.Math.Abs(x1 - x0) <= delta) { x1 = x0 - Fr(x0) / fsh(x0,Fr,shag); if (System.Math.Abs(x1 - x0) > delta) x0 = x1; } result[0, 0] = x1; result[1, 0] = j; }
double ChebushevMethod(double A, double B, FunctionOne f) { double[] t = { 0, -0.832498, -0.374513f, 0, 0.374513, 0.832498 }; int k; double x, reten; reten = 0; for (k = 1; k <= 5; k++) { x = (double)(A + B) / 2 + (double)(B - A) * (double)t[k] / 2; reten += f(x); } reten = reten * (B - A) / 5; return reten; }
// <summary> /// Description constructor /// </summary> /// <param name="function">Function to be solved delegate</param> public NewtonMethod(FunctionOne Fr, double x, double d) { int t = 0; double x1, y; do { t++; x1 = x - Fr(x) / Fr1(x, d, Fr); x = x1; y = Fr(x); }while (Math.Abs(y) >= d); result[0, 0] = x; result[1, 0] = t; }
double ChebushevMethod(double A, double B, FunctionOne f) { double[] t = { 0, -0.832498, -0.374513f, 0, 0.374513, 0.832498 }; int k; double x, reten; reten = 0; for (k = 1; k <= 5; k++) { x = (double)(A + B) / 2 + (double)(B - A) * (double)t[k] / 2; reten += f(x); } reten = reten * (B - A) / 5; return(reten); }
// <summary> /// Description constructor /// </summary> /// <param name="function">Function to be solved delegate</param> public NewtonMethod(FunctionOne Fr, double x, double d) { int t = 0; double x1, y; do { t++; x1 = x - Fr(x) / Fr1(x, d,Fr); x = x1; y = Fr(x); } while (System.Math.Abs(y) >= d); result[0,0] = x; result[1, 0] = t; }
/// <summary> /// Default constructor /// </summary> /// <param name="function">Function to be solved delegate</param> /// <param name="df">Function to be solved delegate</param> /// <param name="Left">Left border of the set interval</param> /// <param name="Right">Right border of the set interval</param> /// <param name="x0">Starting condition</param> /// <param name="epsilon">Exactness conducting of calculations</param> public Сhord(FunctionOne function, FunctionOne df, double Left, double Right, double x0, double epsilon) { double xl; const double m = 2.41064f; const double M = 20.0828f; double xk; xk = x0 - (function(x0) / df(x0)); do { xl = xk - function(xk) * (xk - x0) / (function(xk) - function(x0)); x0 = xk; xk = xl; }while (Math.Abs(xk - x0) > Math.Sqrt(Math.Abs(2f * epsilon * m / M))); result = x0; }
public Chebishev(FunctionOne f, double a, double b, int pointsNum) { int num4 = 4; this.result = new double[2, pointsNum + 1]; for (int i = 0; i <= pointsNum; i++) { double num = (b - a) / ((double) num4); num4 += 4; double num3 = 0.0; for (double j = a; j <= b; j += num) { num3 += this.ChebushevMethod(j, j + num, f); } this.result[0, i] = num3; this.result[1, i] = num; } }
/// <summary> /// Description SecantMethod /// </summary> /// <param name="x0">Initial value</param> /// <param name="Fr">Function to be solved delegate</param> void SecantMethod(double x0, FunctionOne Fr, double shag, double delta) { int j = 0; double x1; x1 = x0 - Fr(x0) / fsh(x0, Fr, shag); while (Math.Abs(x1 - x0) <= delta) { x1 = x0 - Fr(x0) / fsh(x0, Fr, shag); if (Math.Abs(x1 - x0) > delta) { x0 = x1; } } result[0, 0] = x1; result[1, 0] = j; }
/// <summary> /// Default constructor /// </summary> /// <param name="function">Function to be solved delegate</param> /// <param name="Left">Left border of the set interval</param> /// <param name="Right">Right border of the set interval</param> /// <param name="x0">Starting condition</param> /// <param name="epsilon">Exactness conducting of calculations</param> public IterationMethod(FunctionOne function, double Left, double Right, double x0, double epsilon) { double xk; do { xk = g(x0, function); if (Math.Abs(xk - x0) < epsilon) { break; } else { x0 = xk; } }while (Math.Abs(Left - x0) > epsilon && Math.Abs(Right - x0) > epsilon); result = xk; }
public Trapezium(FunctionOne f, double a, double b, int pointsNum) { int num4 = 4; this.result = new double[2, pointsNum + 1]; for (int i = 0; i <= pointsNum; i++) { double num = (b - a) / ((double) num4); num4 += 4; double num3 = f(a) + f(b); for (double j = a + num; j < b; j += num) { num3 += 2.0 * f(j); } num3 = (num3 * num) / 2.0; this.result[0, i] = num3; this.result[1, i] = num; } }
/// <summary> /// Description constructor /// </summary> /// <param name="Fr">Function to be solved delegate</param> /// <param name="x0">Interval start point value</param> /// <param name="x1">Interval end point value</param> /// <param name="d">Amount divisions of segment</param> public HalfDivision(FunctionOne Fr,double x0, double x1, double d) { int t=0; int j = 0; double x2; double y = System.Math.Abs(x0 - x1); while (y > d) { t++; x2 = (x0 + x1) / 2; if (Fr(x0) * Fr(x2) > 0) x0 = x2; else x1 = x2; y = System.Math.Abs(x0 - x1); } result[0 , j] = x1; result[1 , j] = t; }
/// <summary> /// Default constructor /// </summary> /// <param name="function">Function to be solved delegate</param> public Chebishev(FunctionOne f, double a, double b, int pointsNum) { double h; double j; double rez; int she = 4; //int[] she = { 4, 5, 10, 20, 30,40,50,60,70,80,90,100,110,120 }; result = new double[2, pointsNum+1]; for (int i = 0; i <= pointsNum; i++) { h = (b - a) / (double)she; she += 4; rez = 0; for (j = a; j <= b; j = j + h) { rez = rez + ChebushevMethod(j, j + h, f); } result[0, i] = rez; result[1, i] = h; } }
/// <summary> /// Default constructor /// </summary> /// <param name="function">Function to be solved delegate</param> public Chebishev(FunctionOne f, double a, double b, int pointsNum) { double h; double j; double rez; int she = 4; //int[] she = { 4, 5, 10, 20, 30,40,50,60,70,80,90,100,110,120 }; result = new double[2, pointsNum + 1]; for (int i = 0; i <= pointsNum; i++) { h = (b - a) / (double)she; she += 4; rez = 0; for (j = a; j <= b; j = j + h) { rez = rez + ChebushevMethod(j, j + h, f); } result[0, i] = rez; result[1, i] = h; } }
/// <summary> /// Default constructor /// </summary> /// <param name="function">Function to be solved delegate</param> public Trapezium(FunctionOne f, double a, double b, int pointsNum) { double h; double j; double rez; int she = 4; //int[] she = { 4, 5, 10, 20, 30, }; result = new double[2, pointsNum+1]; for (int i = 0; i <= pointsNum; i++) { h = (double)(b - a) / (double)she; she += 4; rez = f(a) + f(b); for (j = a + h; j < b; j = j + h) { rez = rez + 2 * f(j); } rez = rez * h / 2; result[0,i] = rez; result[1,i] = h; } }
/************************************************************************* * Процедура минимизации значения функции методом золотого сечения. * * Оптимизирует функцию одного переменного F. * * Параметры: * A,B - отрезок [A,B], на котором ищется минимум функции F. * N - число шагов метода * * После выхода переменные A и B содержат границы отрезка, на котором * находится решение задачи. * * Алгоритм проводит 2+N вычислений функции F. *************************************************************************/ public GoldenSection(FunctionOne f, double a, double b, int n) { int i = 0; double s1 = 0; double s2 = 0; double u1 = 0; double u2 = 0; double fu1 = 0; double fu2 = 0; s1 = (3 - Math.Sqrt(5)) / 2; s2 = (Math.Sqrt(5) - 1) / 2; u1 = a + s1 * (b - a); u2 = a + s2 * (b - a); fu1 = f(u1); fu2 = f(u2); for (i = 1; i <= n; i++) { if (fu1 <= fu2) { b = u2; u2 = u1; fu2 = fu1; u1 = a + s1 * (b - a); fu1 = f(u1); } else { a = u1; u1 = u2; fu1 = fu2; u2 = a + s2 * (b - a); fu2 = f(u2); } } resultA = a; resultB = b; }
/// <summary> /// Default constructor /// </summary> /// <param name="function">Function to be solved delegate</param> public Trapezium(FunctionOne f, double a, double b, int pointsNum) { double h; double j; double rez; int she = 4; //int[] she = { 4, 5, 10, 20, 30, }; result = new double[2, pointsNum + 1]; for (int i = 0; i <= pointsNum; i++) { h = (double)(b - a) / (double)she; she += 4; rez = f(a) + f(b); for (j = a + h; j < b; j = j + h) { rez = rez + 2 * f(j); } rez = rez * h / 2; result[0, i] = rez; result[1, i] = h; } }
public Simpson(FunctionOne f, double a, double b, int pointsNum) { double I = 0; int j = 0; double h = 0.015f; result = new double[2, pointsNum + 1]; for (int i = 0; i < pointsNum; i++) { double fi = a + h; // Search loop do { if (j % 2 == 0) I = I + 2 * f (fi); else I = I + 4 * f (fi); fi = fi + h; j = j + 1; } while (fi < b); // Calculations I = I + f (a) + f (b); I = I * (h / 3); // Save results result[0, i] = I; result[1, i] = h; I = 0; h += 0.001f; } }
// <summary> /// Description constructor /// </summary> /// <param name="Fr">Function to be solved delegate</param> /// <param name="x0">Interval start point value</param> /// <param name="x1">Interval end point value</param> /// <param name="d">Amount divisions of segment</param> public HalfDivision(FunctionOne Fr, double x0, double x1, double d) { int t = 0; int j = 0; double x2; double y = Math.Abs(x0 - x1); while (y > d) { t++; x2 = (x0 + x1) / 2; if (Fr(x0) * Fr(x2) > 0) { x0 = x2; } else { x1 = x2; } y = Math.Abs(x0 - x1); } result[0, j] = x1; result[1, j] = t; }
/// <summary> /// Description Fr1 /// </summary> /// <param name="x">Initial value</param> /// <param name="d">Amount divisions of segment</param> /// <param name="Fr">Function to be solved delegate</param> public double Fr1(double x, double d, FunctionOne Fr) { return((Fr(x + d) - Fr(x)) / d); }
/************************************************************************* * Минимизация функции методом Брента * * Входные параметры: * a - левая граница отрезка, на котором ищется минимум * b - правая граница отрезка, на котором ищется минимум * Epsilon - абсолютная точность, с которой находится расположение * минимума * * Выходные параметры: * XMin - точка найденного минимума * * Результат: * значение функции в найденном минимуме *************************************************************************/ public Brentopt(FunctionOne f, double a, double b, double epsilon) { double ia = 0; double ib = 0; double bx = 0; double d = 0; double e = 0; double etemp = 0; double fu = 0; double fv = 0; double fw = 0; double fx = 0; int iter = 0; double p = 0; double q = 0; double r = 0; double u = 0; double v = 0; double w = 0; double x = 0; double xm = 0; double cgold = 0; cgold = 0.3819660; bx = 0.5 * (a + b); if (a < b) { ia = a; } else { ia = b; } if (a > b) { ib = a; } else { ib = b; } v = bx; w = v; x = v; e = 0.0; fx = f(x); fv = fx; fw = fx; for (iter = 1; iter <= 100; iter++) { xm = 0.5 * (ia + ib); if (Math.Abs(x - xm) <= epsilon * 2 - 0.5 * (ib - ia)) { break; } if (Math.Abs(e) > epsilon) { r = (x - w) * (fx - fv); q = (x - v) * (fx - fw); p = (x - v) * q - (x - w) * r; q = 2 * (q - r); if (q > 0) { p = -p; } q = Math.Abs(q); etemp = e; e = d; if (!(Math.Abs(p) >= Math.Abs(0.5 * q * etemp) | p <= q * (ia - x) | p >= q * (ib - x))) { d = p / q; u = x + d; if (u - ia < epsilon * 2 | ib - u < epsilon * 2) { d = mysign(epsilon, xm - x); } } else { if (x >= xm) { e = ia - x; } else { e = ib - x; } d = cgold * e; } } else { if (x >= xm) { e = ia - x; } else { e = ib - x; } d = cgold * e; } if (Math.Abs(d) >= epsilon) { u = x + d; } else { u = x + mysign(epsilon, d); } fu = f(u); if (fu <= fx) { if (u >= x) { ia = x; } else { ib = x; } v = w; fv = fw; w = x; fw = fx; x = u; fx = fu; } else { if (u < x) { ia = u; } else { ib = u; } if (fu <= fw | w == x) { v = w; fv = fw; w = u; fw = fu; } else { if (fu <= fv | v == x | v == 2) { v = u; fv = fu; } } } } resultMin = x; result = fx; }
double g(double x, FunctionOne function) { return(0.1 * function(x) + x); }
/************************************************************************* ��������� ����������� �������� ������� ������� ��������� (�������). ���������: A,B - ������� [A,B], �� ������� ������ �����. N - ����� ����� ������, >0; L - ��������� ������� ��� ������� F, >0 ���������: �������� ������ ����� �� ���������. �������� ��������� �������� ������� N+2 ����. *************************************************************************/ public Pijavsky(FunctionOne f, double a, double b, double l, int n) { double[] points = new double[0]; double[] values = new double[0]; double[] ratings = new double[0]; int i = 0; int j = 0; double t = 0; double maxrating = 0; int maxratingpos = 0; double minpoint = 0; double minvalue = 0; points = new double[n + 1 + 1]; values = new double[n + 1 + 1]; ratings = new double[n + 1 + 1]; points[0] = a; points[1] = b; values[0] = f(a); values[1] = f(b); for (i = 2; i <= n + 1; i++) { for (j = 1; j <= i - 1; j++) { ratings[j] = l / 2 * (points[j] - points[j - 1]) - (double)(1) / (double)(2) * (values[j] + values[j - 1]); } maxrating = ratings[1]; maxratingpos = 1; for (j = 2; j <= i - 1; j++) { if (ratings[j] > maxrating) { maxratingpos = j; maxrating = ratings[j]; } } points[i] = (double)(1) / (double)(2) * (points[maxratingpos] + points[maxratingpos - 1]) - (double)(1) / (double)(2) / l * (values[maxratingpos] - values[maxratingpos - 1]); values[i] = f(points[i]); for (j = i; j >= 2; j--) { if (points[j] < points[j - 1]) { t = points[j]; points[j] = points[j - 1]; points[j - 1] = t; t = values[j]; values[j] = values[j - 1]; values[j - 1] = t; } else { break; } } } minpoint = points[0]; minvalue = values[0]; for (i = 1; i <= n + 1; i++) { if (values[i] < minvalue) { minvalue = values[i]; minpoint = points[i]; } } result = minpoint; }
/************************************************************************* * Процедура минимизации значения функции методом Пиявского (ломаных). * * Параметры: * A,B - отрезок [A,B], на котором ведётся поиск. * N - число шагов поиска, >0; * L - константа Липшица для функции F, >0 * * Результат: * Абсцисса лучшей точки из найденных. * * Алгоритм вычисляет значение функции N+2 раза. *************************************************************************/ public Pijavsky(FunctionOne f, double a, double b, double l, int n) { double[] points = new double[0]; double[] values = new double[0]; double[] ratings = new double[0]; int i = 0; int j = 0; double t = 0; double maxrating = 0; int maxratingpos = 0; double minpoint = 0; double minvalue = 0; points = new double[n + 1 + 1]; values = new double[n + 1 + 1]; ratings = new double[n + 1 + 1]; points[0] = a; points[1] = b; values[0] = f(a); values[1] = f(b); for (i = 2; i <= n + 1; i++) { for (j = 1; j <= i - 1; j++) { ratings[j] = l / 2 * (points[j] - points[j - 1]) - (double)(1) / (double)(2) * (values[j] + values[j - 1]); } maxrating = ratings[1]; maxratingpos = 1; for (j = 2; j <= i - 1; j++) { if (ratings[j] > maxrating) { maxratingpos = j; maxrating = ratings[j]; } } points[i] = (double)(1) / (double)(2) * (points[maxratingpos] + points[maxratingpos - 1]) - (double)(1) / (double)(2) / l * (values[maxratingpos] - values[maxratingpos - 1]); values[i] = f(points[i]); for (j = i; j >= 2; j--) { if (points[j] < points[j - 1]) { t = points[j]; points[j] = points[j - 1]; points[j - 1] = t; t = values[j]; values[j] = values[j - 1]; values[j - 1] = t; } else { break; } } } minpoint = points[0]; minvalue = values[0]; for (i = 1; i <= n + 1; i++) { if (values[i] < minvalue) { minvalue = values[i]; minpoint = points[i]; } } result = minpoint; }
public Bisection(FunctionOne f, double left, double right, double eps) : base(f, left, right, eps) { this.Calculate(); }
/// <summary> /// Description fsh /// </summary> /// <param name="x">Initial value</param> /// <param name="Fr">Function to be solved delegate</param> double fsh(double x, FunctionOne Fr, double shag) { return (Fr(x + shag) - Fr(x)) / shag; }
/// <summary> /// Description Fr1 /// </summary> /// <param name="x">Initial value</param> /// <param name="d">Amount divisions of segment</param> /// <param name="Fr">Function to be solved delegate</param> public double Fr1(double x, double d, FunctionOne Fr) { return (Fr(x + d) - Fr(x)) / d; }
/// <summary> /// Description fsh /// </summary> /// <param name="x">Initial value</param> /// <param name="Fr">Function to be solved delegate</param> double fsh(double x, FunctionOne Fr, double shag) { return((Fr(x + shag) - Fr(x)) / shag); }