Ejemplo n.º 1
0
        private void SimplexGrid_CellEndEdit(object sender, DataGridViewCellEventArgs e)
        {
            currentSimplexTable = SimplexTables.Count - 1;
            SimplexTable cursmptbl = SimplexTables[currentSimplexTable];

            SimplexTable smptbl = new SimplexTable(cursmptbl.N, cursmptbl.M);

            smptbl.Assign(cursmptbl);

            SimplexTables.Clear();
            SimplexTables.Add(smptbl);

            if (smptbl.FillTable(SimplexGrid))
            {
                IsNewTask = false;

                smptbl.Solved     = false;
                smptbl.Infinity   = false;
                smptbl.Unsolvable = false;

                smptbl.ResetbaseVector();

                CanonicalN = smptbl.N;
                CanonicalM = smptbl.M;

                for (int i = 0; i < CanonicalM; i++)
                {
                    CanonicalSign[i] = 2;
                }

                CanonicalTaskType = TaskTypeComboBox.SelectedIndex;

                smptbl.FillVectorb(CanonicalVectorb);
                smptbl.FillVectorc(CanonicalVectorc);
                smptbl.FillMatrixA(CanonicalMatrixA);

                PrintSolveLog(TaskInfotextBox);

                toolStripStatusLabel.Text = "Итерация: ";
            }
        }
Ejemplo n.º 2
0
        private void RecalcSimplexTableToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if ((currentSimplexTable >= 0) & (currentSimplexTable < SimplexTables.Count))
            {
                SimplexTable currentsmptbl = SimplexTables[currentSimplexTable];

                if (currentsmptbl.FillTable(SimplexGrid))
                {
                    // Итеративно решаем задачу симплекс-методом
                    if ((!currentsmptbl.Solved) & (!currentsmptbl.Unsolvable) & (!currentsmptbl.Infinity))
                    {
                        // Проверяем, имеет ли задача бесконечное множество решений
                        if (currentsmptbl.TestForInfinity())
                        {
                            currentsmptbl.Infinity    = true;
                            toolStripStatusLabel.Text = "Задача не имеет бесконечное множество решений!";
                        }

                        // Проверяем, является ли решение допустимым
                        if (currentsmptbl.TestForUnsolvable())
                        {
                            currentsmptbl.Unsolvable  = true;
                            toolStripStatusLabel.Text = "Задача не имеет допустимых решений!";
                        }

                        // Проверяем, является ли решение оптимальным
                        if (currentsmptbl.TestForSolved())
                        {
                            // Проверяем получившееся решение на целочисленность
                            if (currentsmptbl.TestForInteger())
                            {
                                currentsmptbl.Solved      = true;
                                toolStripStatusLabel.Text = "Задача решена!";
                            }
                            else
                            {
                                currentsmptbl.NonIntegerSolved = true;
                                currentsmptbl.PivotRow         = currentsmptbl.MaxDoubleIndex();

                                SimplexTable smptbl = new SimplexTable(currentsmptbl.N, currentsmptbl.M);
                                smptbl.Assign(currentsmptbl);
                                smptbl.FillTable(SimplexGrid);

                                smptbl.AddNewRest();
                                smptbl.PivotRow = smptbl.PivotRow + 1;

                                SimplexTables.Add(smptbl);
                                currentSimplexTable = SimplexTables.Count - 1;
                                currentsmptbl       = SimplexTables[currentSimplexTable];

                                UpdateSimplexGrid();
                                PrintSolveLog(TaskInfotextBox);

                                return;
                            }
                        }

                        if (currentsmptbl.FindOptimalStep())
                        {
                            SimplexTable smptbl = new SimplexTable(currentsmptbl.N, currentsmptbl.M);
                            smptbl.Assign(currentsmptbl);
                            smptbl.FillTable(SimplexGrid);

                            SimplexTables.Add(smptbl);
                            currentSimplexTable       = SimplexTables.Count - 1;
                            toolStripStatusLabel.Text = " Итерация: " + currentSimplexTable.ToString();

                            smptbl.PivotRow = smptbl.PivotRow + 1;
                            smptbl.RecalcTable();
                            smptbl.PivotRow = -1;
                            smptbl.PivotCol = -1;

                            UpdateSimplexGrid();
                        }
                    }
                }
            }

            PrintSolveLog(TaskInfotextBox);
        }