// <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;
}
}
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>
/// 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);
}
