示例#1
0
        public Vector Start()
        {
            int k = 1;

            Vector X1 = _X0;

            List <Vector> P = new List <Vector>(); // Направления

            for (int i = 0; i < count; i++)
            {
                Vector tempV = new Vector(this.count);
                tempV.NullInit();
                tempV.ch[i] = 1;
                P.Add(tempV);
            }

            double alpha = 0;
            Lab3   labs;

            Vector curX = X1; Vector X2 = X1;

            while (true)
            {
                curX = X1;

                Position.Add(curX);

                for (int i = 0; i < P.Count; i++)
                {
                    Console.Write("P" + i + P[i].printVector());
                }
                for (int i = 0; i < P.Count; i++)
                {
                    labs  = new Lab3();
                    alpha = labs.Start(this._func, curX, P[i], this._eps); // Находим вектор
                    curX  = labs.Point(curX, alpha);                       // Перходим в новую точку
                    Position.Add(curX);
                }


                Vector dk = curX - X1; // Находим вектор

                labs  = new Lab3();
                alpha = labs.Start(this._func, curX, dk, this._eps); // Ищем щё один вектор
                curX  = labs.Point(curX, alpha);                     // Переходим в точку X(n+2);
                Position.Add(curX);

                if (k >= count)
                {
                    break;
                }
                else
                {
                    k++;
                    X1 = curX;

                    P.RemoveAt(0);
                    P.Add(dk);
                }
            }

            this._count    = k;
            this.MinVector = curX;
            return(curX);
        }
示例#2
0
        public Vector Start()
        {
            Vector[] A = new Vector[this._count];
            Vector[] B = new Vector[this._count];
            Vector[] d = new Vector[this._count];


            // Задаём вектор направлений
            Vector[] P = new Vector[this._count];
            for (int i = 0; i < this._count; i++)
            {
                P[i] = new Vector(this._count);
                P[i].NullInit();
                P[i].ch[i] = 1;
            }

            int  count = 0;
            Lab3 labs;

            do
            {
                Console.WriteLine("Итерация: " + count);
                Vector curX = _X0;

                /*Console.WriteLine();
                 * Console.WriteLine();
                 * Console.WriteLine("_________________________________");
                 * Console.WriteLine();
                 * Console.WriteLine();
                 *
                 *
                 * Console.WriteLine("Векторы P: ");
                 * for (int i = 0; i < this._count; i++) Console.Write("P" + i + P[i].printVector());*/

                Vector alpha = new Vector(this._count); alpha.NullInit();

                Vector tempX = curX;
                // Console.Write("Вектор X до цпс: " + curX.printVector());

                for (int i = 0; i < this._count; i++)
                {
                    //Console.Write("Func = " + this._func + " TempX = " + tempX.printVector() + "P = " + P[i].printVector());
                    labs        = null;
                    labs        = new Lab3();
                    alpha.ch[i] = labs.Start(this._func, tempX, P[i], _eps); // Запоминаем альфа
                    tempX       = labs.Point(tempX, alpha.ch[i]);            // Переходим в след точку???
                    //Console.WriteLine("    Новый вектор" + i + tempX.printVector());
                }

                curX = tempX;

                /*Console.Write("Вектор X после цпс " + curX.printVector());
                 *
                 * Console.WriteLine();
                 * Console.Write("Alpha: " + alpha.printVector());*/

                //Console.ReadLine();

                if (curX.Norm() <= this._eps)
                {
                    break;
                }
                else
                {
                    for (int i = 0; i < this._count; i++)
                    {
                        if (Math.Abs(alpha.ch[i]) <= this._eps)
                        {
                            A[i] = P[i];
                        }
                        else
                        {
                            Vector tempV = new Vector(this._count);
                            tempV.NullInit();

                            for (int k = i; k < this._count; k++)
                            {
                                tempV += alpha.ch[k] * P[k];
                            }
                            A[i] = tempV;
                        }

                        if (i == 0)
                        {
                            B[i] = A[i];
                        }
                        else
                        {
                            Vector tempV = new Vector(this._count); tempV.NullInit();
                            for (int k = 0; k < i; k++)
                            {
                                tempV += (A[i] * d[k]) * d[k];
                            }
                            B[i] = A[i] - tempV;
                        }

                        d[i] = B[i];
                        d[i].Normilize();
                    }
                }

                for (int i = 0; i < this._count; i++)
                {
                    P[i] = d[i];
                }

                _X0 = curX;

                count++; if (count >= 15)
                {
                    break;
                }
            } while (true);

            return(this._X0);
        }
示例#3
0
        public Vector Start()
        {
            int k = 1;

            Vector X1 = _X0;

            List <Vector> P = new List <Vector>(); // Направления

            for (int i = 0; i < count; i++)
            {
                Vector tempV = new Vector(this.count);
                tempV.NullInit();
                tempV.ch[i] = 1;
                P.Add(tempV);
            }
            P.Add(P[0]); // Теперь имеем {e1, e2...e1};


            double alpha;
            Lab3   labs;

            Vector curX = X1; Vector X2 = X1;


            while (true)
            {
                Console.WriteLine("X1: " + X1.printVector());
                curX = X1; X2 = X1;


                // Совершаем n поисков
                for (int i = 0; i < P.Count; i++)
                {
                    labs = new Lab3();

                    alpha = labs.Start(this._func, curX, P[i], this._eps); // Находим вектор


                    curX = labs.Point(curX, alpha); // Перходим в новую точку

                    if (i == 0)
                    {
                        X2 = curX;         // Если точка X2
                    }
                }


                Vector dk = curX - X2; // Находим вектор
                //curX = X4;

                if (k >= this.count - 1)
                {
                    labs  = new Lab3();
                    alpha = labs.Start(this._func, curX, dk, this._eps);

                    curX = labs.Point(curX, alpha);

                    return(curX);
                }
                else
                {
                    P.RemoveAt(0); // Первый сдвигается
                    P[0] = dk;
                    P.Add(dk);

                    X1 = curX;
                    k++;
                }
            }
        }
示例#4
0
        public void Run()
        {
            Position = new List <Vector>();


            Vector[] A = new Vector[this._count];
            Vector[] B = new Vector[this._count];
            Vector[] d = new Vector[this._count];


            Vector[] P = new Vector[this._count];
            for (int i = 0; i < this._count; i++)
            {
                P[i] = new Vector(this._count);
                P[i].NullInit();
                P[i].ch[i] = 1;
            }

            int  iter = 0;
            Lab3 lab3;

            do
            {
                Vector curX = _X0;
                Position.Add(_X0);

                Vector alpha = new Vector(this._count); alpha.NullInit();

                Vector tempX = curX;

                for (int i = 0; i < this._count; i++)
                {
                    lab3        = null;
                    lab3        = new Lab3();
                    alpha.ch[i] = lab3.Start(this._func, tempX, P[i], _eps);
                    tempX       = lab3.Point(tempX, alpha.ch[i]);
                    Position.Add(tempX);
                }

                curX = tempX;

                if (alpha.Norm() <= this._eps)
                {
                    break;
                }
                else
                {
                    for (int i = 0; i < this._count; i++)
                    {
                        if (Math.Abs(alpha.ch[i]) <= this._eps)
                        {
                            A[i] = P[i];
                        }
                        else
                        {
                            Vector tempV = new Vector(this._count);
                            tempV.NullInit();

                            for (int k = i; k < this._count; k++)
                            {
                                tempV += alpha.ch[k] * P[k];
                            }
                            A[i] = tempV;
                        }



                        if (i == 0)
                        {
                            B[i] = A[i];
                        }
                        else
                        {
                            Vector tempV = new Vector(this._count); tempV.NullInit();
                            for (int k = 0; k < i; k++)
                            {
                                tempV += (A[i] * d[k]) * d[k];
                            }
                            B[i] = A[i] - tempV;
                        }

                        d[i] = B[i];
                        d[i].Normilize();

                        P[i] = d[i];
                    }

                    _X0 = curX;

                    iter++; if (iter >= 30)
                    {
                        break;
                    }
                }
            } while (true);

            ResultVector = this._X0;
            _count       = iter;
        }
示例#5
0
        public Vector Start()
        {
            Parser temp = new Parser();
            int    k    = 1;

            Vector X1 = _X0;

            List <Vector> P = new List <Vector>(); // Направления

            for (int i = 0; i < count; i++)
            {
                Vector tempV = new Vector(this.count);
                tempV.NullInit();
                tempV.ch[i] = 1;
                P.Add(tempV);
            }

            double alpha = 0;
            Lab3   labs;

            Vector curX  = X1;
            Vector tempX = X1;

            double a, b;

            while (true)
            {
                List <double> A = new List <double>(); // Сохраняет альфы
                List <double> M = new List <double>(); // Сохраняет М
                List <double> Y = new List <double>(); // Значения функции в точке

                curX = X1;

                Y.Add(Convert.ToDouble(temp.Parse(this._func, curX.ch)));

                Position.Add(curX);

                for (int i = 0; i < P.Count; i++)
                {
                    tempX = curX;
                    labs  = new Lab3();
                    alpha = labs.Start(this._func, curX, P[i], this._eps); // Находим вектор
                    curX  = labs.Point(curX, alpha);                       // Перходим в новую точку
                    Position.Add(curX);
                    Y.Add(Convert.ToDouble(temp.Parse(this._func, curX.ch)));

                    A.Add(alpha);

                    a = Convert.ToDouble(temp.Parse(this._func, tempX.ch));
                    b = Convert.ToDouble(temp.Parse(this._func, curX.ch));

                    M.Add(a - b);
                }

                tempX = curX;

                Vector dk = curX - X1; // Находим вектор
                dk.Normilize();

                labs  = new Lab3();
                alpha = labs.Start(this._func, curX, dk, this._eps); // Ищем щё один вектор
                curX  = labs.Point(curX, alpha);                     // Переходим в точку X(n+2);
                Position.Add(curX);


                if ((alpha <= _eps) && ((Math.Abs(Y.Last() - Y[0]) / Y.Last())) <= this._eps)
                {
                    break;
                }
                else
                {
                    X1 = curX;
                    k++;

                    if (k >= 25)
                    {
                        break;
                    }

                    int mmax = GetMaxIndex(M);

                    a = Convert.ToDouble(temp.Parse(this._func, tempX.ch));
                    b = Convert.ToDouble(temp.Parse(this._func, curX.ch));
                    M.Add(a - b);
                    A.Add(alpha);
                    Y.Add(Convert.ToDouble(temp.Parse(this._func, curX.ch)));


                    if (uslzv(M, Y, mmax) == true)
                    {
                        P.RemoveAt(mmax);
                    }
                    else
                    {
                        P.RemoveAt(0);
                    }

                    P.Add(dk);
                }
            }

            this._count    = k;
            this.MinVector = curX;
            return(curX);
        }
示例#6
0
        public Vector Start()
        {
            int k = 1;

            Vector X1 = _X0;

            List <Vector> P = new List <Vector>(); // Направления

            for (int i = 0; i < count; i++)
            {
                Vector tempV = new Vector(this.count);
                tempV.NullInit();
                tempV.ch[i] = 1;
                P.Add(tempV);
            }

            double alpha = 0;
            Lab3   labs;

            Vector curX = X1; Vector X2 = X1;

            while (true)
            {
                curX = X1;
                Console.WriteLine("Итерация: " + k);
                Console.Write("Стартовая точка: " + curX.printVector());
                Console.WriteLine("Векторы P:");
                for (int i = 0; i < P.Count; i++)
                {
                    Console.Write("P" + i + P[i].printVector());
                }
                Console.WriteLine();

                Console.WriteLine("Начинаем поиски");
                // Совершаем n поисков
                for (int i = 0; i < P.Count; i++)
                {
                    labs = new Lab3();

                    Console.Write("X = " + curX.printVector());
                    Console.Write("P = " + P[i].printVector());

                    alpha = labs.Start(this._func, curX, P[i], this._eps); // Находим вектор

                    Console.WriteLine("Alpha = " + alpha);

                    curX = labs.Point(curX, alpha); // Перходим в новую точку

                    Console.Write("Новая точка: " + curX.printVector());
                }
                Console.WriteLine();
                Console.WriteLine("Находим Dk");
                Console.Write("CurX: " + curX.printVector());
                Console.Write("X1 - " + X1.printVector());


                Vector dk = curX - X1; // Находим вектор

                Console.Write("DK = " + dk.printVector());

                //curX = X1;
                Console.WriteLine();
                Console.WriteLine("Переход в точку 4");

                labs = new Lab3();
                Console.Write("CurX - " + curX.printVector());
                Console.Write("P - " + dk.printVector());

                alpha = labs.Start(this._func, curX, dk, this._eps); // Ищем щё один вектор

                Console.WriteLine("Alpha = " + alpha);

                curX = labs.Point(curX, alpha); // Переходим в точку X(n+2);

                Console.WriteLine("Переход в нову точку: " + curX.printVector());

                if (k >= count)
                {
                    break;
                }
                else
                {
                    k++;
                    X1 = curX;

                    P.RemoveAt(0);
                    P.Add(dk);

                    Console.WriteLine();
                    Console.WriteLine("_________________");
                    Console.WriteLine();
                }
            }

            Console.WriteLine("Минимум: " + curX.printVector());
            return(curX);
        }