Обобщенный алгоритм методов: деформированного многогранника и равномерного поиска.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
 
    
 
namespace TPR
{
    /// <summary>
    /// Логика взаимодействия для MainWindow.xaml
    /// </summary>
    /// 
 
 
    public partial class MainWindow : Window
    {
        const int N_DIM = 2;
 
        public struct Vertex
        {
            public double x, y;
 
            //public Vertex()
            //{
            //    x = y = 0;
            //}
 
            public Vertex(double X, double Y)
            {
                x = X;
                y = Y;
            }
 
            public static Vertex operator/(Vertex v, double q)
            {
                return new Vertex(v.x / q, v.y / q);
            }
 
            public static Vertex operator+(Vertex v1, Vertex v2)
            {
                return new Vertex(v1.x + v2.x, v1.y + v2.y);
            }
 
            public static Vertex operator-(Vertex v1, Vertex v2)
            {
                return new Vertex(v1.x - v2.x, v1.y - v2.y);
            }
 
            public static Vertex operator *(Vertex v, double d)
            {
                return new Vertex(v.x * d, v.y * d);
            }
 
            public static double Dist(Vertex v1, Vertex v2)
            {
                return Math.Sqrt((v1.x - v2.x) * (v1.x - v2.x) + (v1.y - v2.y) * (v1.y - v2.y));
            }
 
            public void Out()
            {
            }
 
        };
 
        static class Simplex
        {
 
            public static double Func(Vertex v)
            {
                return 100* (v.y - v.x * v.x) * (v.y - v.x * v.x) + (1 - v.x) * (1 - v.x);
            }
 
            public static bool QuitCase(Vertex[] v)
            {
                bool flag = false;
                for (int i = 0; i <= 2; i++)
                {
                    for (int j = 0; j <= 2; j++)
                    {
                        if (i != j)
                        {
                            if (Vertex.Dist(v[i], v[j]) > 0.01)
                            {
                                flag = false;
                            }
                            else
                            {
                                flag = true;
                                break;
                            }
                        }
                    }
                }
                return flag;
            }
 
        }
 
 
        public MainWindow()
        {
            InitializeComponent();
        }
 
        private void button1_Click(object sender, RoutedEventArgs e)
        {
            double alpha=1.0; 
            double beta=0.5;
            double gamma = 2.0;
 
            double[] f = new double[N_DIM+1];
            double f_h, f_g, f_l, f_r, f_e, f_s, tempD;
            Vertex x_h, x_g, x_l, x_r, x_e, x_s, x_c, tempV;
            double fmin;
            Vertex vmin;
 
 
            Vertex[] v = new Vertex[3];
            v[0] = new Vertex(50, 50);
            v[1] = new Vertex(10, -2);
            v[2] = new Vertex(21, 1);
            for (int i = 0; i <= 2; i++)
            {
                f[i] = Simplex.Func(v[i]);
                textBlock1.Text += f[i].ToString() + "  ";
            }
 
            while (!Simplex.QuitCase(v))
            {
                fmin = f[0];
                // Шаг 1. Сортировка 
                //Найдем наибольшее значение функции fh, 
                //следующее за наибольшим значением функции fg
                //наименьшее значение функции fl и соответствующие им точки xh, xg, xl.
                for (int i = 0; i <= N_DIM; i++)
                {
                    for (int j = 0; j <= N_DIM - 1; j++)
                    {
                        if (f[j+1]<f[j])
                        {
                            fmin = f[j + 1];
                            vmin = v[j + 1];
                            f[j + 1] = f[j];
                            v[j + 1] = v[j];
                            f[j] = fmin;
                            v[j] = vmin;
                        }
                    }
                }
                x_h = v[N_DIM]; f_h = f[N_DIM];
                x_g = v[N_DIM - 1]; f_g = f[N_DIM - 1];
                x_l = v[N_DIM - 2]; f_l = f[N_DIM - 2];
 
                // Шаг 2. Вычисление центра тяжести симплекса
                //за исключением точки хh
                x_c.x = x_c.y = 0;
                for (int i = 0; i <= N_DIM - 1; i++) x_c += v[i];
                x_c = x_c / N_DIM;
 
 
                // 3Шаг . Отражение
                x_r = x_c * (1 + alpha) - x_h * alpha;
                f_r = Simplex.Func(x_r);
 
                // Шаг 4. Сравним значения функций fr и fl.
                if (f_r <= f_l)
                {//Шаг 4а. Если fr < fl, то мы получили наименьшее значение функции. 
                 //Направление из точки x0 в точку xr наиболее удобно для перемещения. 
                 //производим растяжение в этом направлении и находим точку xe и значение функции fe = f(xe). 
                    x_e = x_c * (1 - gamma) + x_r * gamma;
                    f_e = Simplex.Func(x_e);
                    if (f_e < f_l)
                    {
                        v[N_DIM] = x_e;
                        f[N_DIM] = f_e;
                    }
                    else
                    {
                        v[N_DIM] = x_r;
                        f[N_DIM] = f_r;
                    }
                }
 
                if ((f_l < f_r) && (f_r <= f_g))
                {//Шаг 4b.
                    v[N_DIM] = x_r;
                    f[N_DIM] = f_r;
                }
                bool flag = false;
                if ((f_h >= f_r) && (f_r > f_g))
                {//Шаг 4c.
                    flag = true;
                    tempD = f_h;
                    tempV = x_h;
                    v[N_DIM] = x_r;
                    f[N_DIM] = f_r;
                    x_r = tempV;
                    f_r = tempD;
                }
                //Шаг 4d.
                if (f_r > f_h)
                {
                    flag = true;
                }
                if (flag)
                {//Шаг 5 Сжатие
                    x_s = x_h * beta + x_c * (1 - beta);
                    f_s = Simplex.Func(x_s);
                    if (f_s < f_h)
                    {//Шаг 6.
                        tempD = f_h;
                        tempV = x_h;
                        v[N_DIM] = x_s;
                        f[N_DIM] = f_s;
                        x_s = tempV;
                        f_s = tempD;
                    }
                    else
                    {//Шаг 7. Глобальное сжатие
                        for (int i = 0; i <= N_DIM; i++)
                        {
                            v[i] = x_l + (v[i] - x_l) / 2;
                        }
                    }
                }
                textBlock1.Text = f_l.ToString();
            }
        }
    }
}