public override void Execute()
        {
            OneDimMethod step1 = new Extrapolation(F, Eps, 5);
            OneDimMethod step2 = new BoostedDavidon(F, Df, Eps);
            IterationCount = 0;

            //ШАГ 2
            step1.A = A;
            step1.B = B;
            step1.Execute();

            A = step1.A;
            B = step1.B;

            //ШАГ 3
            step2.A = A;
            step2.B = B;
            step2.Execute();

            A = step2.A;
            B = step2.B;
            Answer = step2.Answer;

            IterationCount += step1.IterationCount;
            IterationCount += step2.IterationCount;
        }
        public override void Execute()
        {
            if (AlphaMethod == null) AlphaMethod = new BoostedDavidon(Fh.AlphaFunction, Fh.AlphaDiffFunction);
            IterationCount = 0;
            var varCount = Fh.Point.Count;
            Vector<double> x0, d;
            do
            {
                x0 = Fh.Point;
                var xn = x0;
                for (var i = 0; i < varCount; i++)
                {
                    Fh.Point = xn;
                    Fh.Dir = Fh.MakeOneVector(varCount, i, 1);
                    AlphaMethod.SetSvenInterval();
                    AlphaMethod.Execute();
                    xn = xn + AlphaMethod.Answer*Fh.Dir;
                }
                d = xn - x0;
                if (!Kop1(d)) break;
                Fh.Point = x0;
                Fh.Dir = d;
                AlphaMethod.SetSvenInterval();
                AlphaMethod.Execute();
                x0 += AlphaMethod.Answer*d;
                Fh.Point = x0;
                IterationCount ++;
            } while (Kop1(d));

            Answer = x0;
        }
        public override void Execute()
        {
            //Подготовка
            var x1 = Fh.Point;

            if (AlphaMethod == null) AlphaMethod = new BoostedDavidon(Fh.AlphaFunction, Fh.AlphaDiffFunction, Eps);
            IterationCount = 0;

            //Основной этап
            do
            {
                //Находим x2
                Fh.Dir = -Fh.Grad();
                Fh.Normilize();

                AlphaMethod.SetSvenInterval();
                AlphaMethod.Execute();
                var alpha1 = AlphaMethod.Answer;
                if (double.IsNaN(alpha1)) break;
                var x2 = x1 + Fh.Dir.Multiply(alpha1);

                //Находим х3
                Fh.Point = x2;
                Fh.Dir = -Fh.Grad(x2);

                Fh.Normilize();
                AlphaMethod.SetSvenInterval();
                AlphaMethod.Execute();
                var alpha2 = AlphaMethod.Answer;
                if (double.IsNaN(alpha2)) break;
                var x3 = x2 + Fh.Dir.Multiply(alpha2);

                //Находим d
                var d = x3 - x1;
                d = d.Normalize(1);

                //Находим минимум
                Fh.Point = x3;
                Fh.Dir = d;
                Fh.Normilize();
                AlphaMethod.SetSvenInterval();
                AlphaMethod.Execute();
                var alpha3 = AlphaMethod.Answer;
                if (double.IsNaN(alpha3)) alpha3 = 0;
                x1 = x3 + Fh.Dir.Multiply(alpha3);
                Fh.Point = x1;
                IterationCount++;
            } while (Kop1(Fh.Grad(Fh.Point)));

            Answer = Fh.Point;
        }
        public override void Execute()
        {
            var varCount = Fh.Point.Count;

            //Подготовка
            _hessian = new DenseMatrix(varCount, varCount);
            //начальная точка
            var x1 = Fh.Point;
            Func<double[], double> castFunc = doubles => Fh.Y(new DenseVector(doubles));
            var hessianCalculator = new NumericalHessian();
            //Альфа метод
            if (AlphaMethod == null) AlphaMethod = new BoostedDavidon(Fh.AlphaFunction, Fh.AlphaDiffFunction, Eps);
            IterationCount = 0;

            //Основной этап
            do
            {
                if (!Kop1(Fh.Grad(Fh.Point))) break;
                //Находим ньютоновское направление - p TODO
                var temp = hessianCalculator.Evaluate(castFunc, x1.ToArray());
                for (var i = 0; i < varCount; i++)
                    for (var j = 0; j < varCount; j++)
                        _hessian[i, j] = temp[i, j];
                var p = -(_hessian.Inverse())*Fh.Grad(x1);
                Fh.Dir = p;

                //Альфа метод
                AlphaMethod.SetSvenInterval();
                AlphaMethod.Execute();
                var alpha1 = AlphaMethod.Answer;

                //Переходим на новую точку
                x1 = x1 + Fh.Dir*alpha1;

                Fh.Point = x1;
                IterationCount++;
            } while (Kop1(Fh.Dir) && Kop1(Fh.Grad(Fh.Point)));

            Answer = Fh.Point;
        }
Exemple #5
0
        public override void Execute()
        {
            //Альфа метод
            if (AlphaMethod == null) AlphaMethod = new BoostedDavidon(Fh.AlphaFunction, Fh.AlphaDiffFunction, 1e-25);
            IterationCount = 1;
            var curGrad = Fh.Grad(Fh.Point);
            var n = Fh.Point.Count; // количество переменных
            do
            {

                var prevGrad = curGrad; //предыдущий градиент
                var prevDir = Fh.Dir; //предыдущее направление
                curGrad = Fh.Grad(Fh.Point);
                if ((IterationCount - 1)%n == 0)
                {
                    Fh.Dir = -curGrad;
                }
                else
                {
                    var gamma = curGrad - prevGrad;
                    var beta = curGrad*gamma/(prevDir*gamma); //Math.Pow(curGrad.Norm(2), 2)/Math.Pow(prevGrad.Norm(2), 2);
                    Fh.Dir = -curGrad + prevDir*beta;
                }

                if (!Kop1(Fh.Grad(Fh.Point))) break;

                //Альфа метод
                AlphaMethod.SetSvenInterval();
                AlphaMethod.Execute();
                var alpha1 = AlphaMethod.Answer;
                Fh.Point += Fh.Dir*alpha1;
                IterationCount++;
            } while (Kop1(Fh.Dir) && Kop1(Fh.Grad(Fh.Point)));

            Answer = Fh.Point;
            IterationCount--;
        }
        public override void Execute()
        {
            //Альфа метод
            if (AlphaMethod == null) AlphaMethod = new BoostedDavidon(Fh.AlphaFunction, Fh.AlphaDiffFunction, Eps);

            _varCount = Fh.Point.Count;
            _a = new DenseMatrix(_varCount, _varCount);

            IterationCount = 1;
            var xcur = Fh.Point;
            var xprev = xcur;
            do
            {
                CalculateNextMatrix(xprev, xcur);
                var p = -_a*Fh.Grad(xcur);

                Fh.Dir = p;

                //Альфа метод
                AlphaMethod.SetSvenInterval();
                AlphaMethod.Execute();
                var alpha1 = AlphaMethod.Answer;
                if (double.IsNaN(alpha1))
                {
                    break;
                }

                xprev = xcur;
                xcur = xcur + p*alpha1;
                Fh.Point = xcur;

                IterationCount++;
            } while (Kop1(Fh.Dir) && Kop1(Fh.Grad(Fh.Point)));
            IterationCount--;
            Answer = Fh.Point;
        }