Esempio n. 1
0
        public Coord newPointGZ(Coord x)
        {
            int length = x.coord.Length;

            double[] arr_p = new double[length];
            Coord    p     = new Coord(arr_p);

            points          = points % amountVar;
            p.coord[points] = Func.diff_4(y, x, points);
            p = p / p.Norma;
            LinearSearch f1  = new LinearSearch(x, p, y);
            Coord        x_2 = f1.M[3](50);

            points++;
            return(x_2);
        }
Esempio n. 2
0
        Coord newPoint(Coord x1, Coord x2, opt opt_A)
        {
            Matrix E    = Matrix.E(amountVar);
            Coord  grad = Coord.Gradient(y, x2, amountVar);

            if (k % amountVar == 1)
            {
                //if (k == 1)
                A = E;
            }
            else
            {
                A = opt_A(x1, x2);
            }
            p = -A * grad;
            LinearSearch f1 = new LinearSearch(x2, p, y);

            return(f1.M[6](50));
        }
Esempio n. 3
0
        Coord newPoint(Coord x1, Coord x2, opt OptBeta)
        {
            opt Beta = OptBeta;

            Grad = Coord.Gradient(y, x2, amountVar);
            //Если k = 1, n+1, 2n+1...
            if (k % amountVar == 1)
            {
                //if (k <= 3)
                p = -Grad;
            }
            else
            {
                double beta = Beta(x2, x1);
                p = -Grad + (beta * p);
            }

            p = p / p.Norma;
            //Запускаем линейный поиск
            LinearSearch f1 = new LinearSearch(x2, p, y);

            f1.Svenn(20);
            //f1.Svenn2();
            f1.Bolcano(20);
            //f1.Dichotomy(20);
            //f1.Bolcano2();
            f1.Davidon();
            //f1.Davidon2();
            //f1.DSK(30);
            //f1.Davidon2();
            alfa = f1.alfa_min;
            p    = p / p.Norma;
            Coord x3 = x2 + alfa * p;

            return(x3);
        }
Esempio n. 4
0
        public int Gelfond(int max)
        {
            k = 0;
            double delta = 0.01;
            Coord  _x1;
            Coord  _x2;
            Coord  d, dif;
            Coord  p, _p, p2;

            while (true)
            {
                _x1 = x[1] + delta * Coord.Ort(amountVar, 0);
                p   = -Coord.Gradient(y, x[1], amountVar);
                LinearSearch f1 = new LinearSearch(x[1], p, y);
                x[2] = f1.M[2](20);
                _p   = -Coord.Gradient(y, _x1, amountVar);
                LinearSearch f2 = new LinearSearch(_x1, _p, y);
                _x2 = f2.M[2](20);
                d   = x[2] - _x2;
                p2  = -Coord.Gradient(y, x[2], amountVar);
                LinearSearch f3 = new LinearSearch(x[2], p2, y);
                x[3] = f3.M[2](20);
                dif  = x[3] - x[2];
                k++;
                if (dif.norma() <= Eps)
                {
                    min = x[3];
                    break;
                }
                else
                {
                    x[1] = x[3];
                }
            }
            return(k);
        }
Esempio n. 5
0
        public int Koshi(int max)
        {
            k = 0;
            Coord p = -Coord.Gradient(y, x[1], amountVar);

            while (true)
            {
                LinearSearch f1 = new LinearSearch(x[1], p, y);
                x[2] = f1.M[2](20);
                Grad = Coord.Gradient(y, x[2], amountVar);
                k++;
                if (Grad.norma() <= Eps || k >= max)
                {
                    min = x[2];
                    break;
                }
                else
                {
                    x[1] = x[2];
                    p    = Grad;
                }
            }
            return(k);
        }