Example #1
0
        private void StartButton_Click(object sender, EventArgs e)
        {
            int control = 1;

            outputData.Text = "";

            int control_1 = rightStringInt(variablesNumber.Text, 1);

            if (control_1 == 1 && variablesNumber.Text != "")
            {
                variables = Convert.ToInt32(variablesNumber.Text.Trim());
            }
            else
            {
                control_1        = 0;
                outputData.Text += "\n\n Check Total Variables Data";
            }


            int control_2 = rightStringInt(constraintsNumber.Text, 1);

            if (control_2 == 1 && constraintsNumber.Text != "")
            {
                restrictions = Convert.ToInt32(constraintsNumber.Text.Trim());
            }
            else
            {
                control_2        = 0;
                outputData.Text += "\n\n Check Total Constraints Data";
            }


            if (control_1 == 1 && control_2 == 1)
            {
                if (checkMax.Checked == true)
                {
                    maximize = 1;
                }
                if (checkMin.Checked == true)
                {
                    minimize = 1;
                }

                if (checkMax.Checked != true && checkMin.Checked != true)
                {
                    outputData.Text += "\n Please select Operation ";
                    control          = 0;
                }


                string[] inputObjectives = objectiveFunction.Text.Trim().Split(' ');
                if (variables == inputObjectives.Length)
                {
                    int k = 0;
                    while (k < inputObjectives.Length)
                    {
                        if (rightDouble(inputObjectives[k]) == 0)
                        {
                            outputData.Text += "\n\n Incorrect value " + Convert.ToString(k + 1) + "\n    in Objectiv Function";
                            control          = 0;
                        }

                        k++;
                    }

                    objectiveValues = new double[inputObjectives.Length];
                    for (int i = 0; i < inputObjectives.Length && control == 1; i++)
                    {
                        NumberFormatInfo formatProvider = new NumberFormatInfo();
                        formatProvider.NumberDecimalSeparator = ".";
                        objectiveValues[i] = Convert.ToDouble(inputObjectives[i], formatProvider);
                    }
                }
                else
                {
                    outputData.Text += "\n\n Check Objective Function Data";
                    control          = 0;
                }


                var inputLines = inputData.Text.Split('\n');
                equationValues = new double[inputLines.Length][];

                if (restrictions == inputLines.Length)
                {
                    int k = 0;
                    int t = 0;
                    foreach (var line in inputLines)
                    {
                        t++;
                        string[] stringValues = line.Trim().Split(' ');

                        if (variables == stringValues.Length)
                        {
                            int w = 0;
                            while (w < stringValues.Length)
                            {
                                if (rightDouble(stringValues[w]) == 0)
                                {
                                    outputData.Text += "\n\n Incorrect value " + Convert.ToString(w + 1) + " in constraint " + Convert.ToString(t);
                                    control          = 0;
                                }
                                w++;
                            }
                            double[] intValues = new double[stringValues.Length];

                            for (int i = 0; i < stringValues.Length && control == 1; i++)
                            {
                                NumberFormatInfo formatProvider = new NumberFormatInfo();
                                formatProvider.NumberDecimalSeparator = ".";
                                intValues[i] = Convert.ToDouble(stringValues[i], formatProvider);
                            }
                            equationValues[k] = intValues;
                            k++;
                        }
                        else
                        {
                            outputData.Text += "\n\n Check number of parametres  \n                  in Constraint " + Convert.ToString(k + 1);
                            control          = 0;
                            break;
                        }
                    }
                }
                else
                {
                    outputData.Text += "\n\n Check Subject to Constraints";
                    control          = 0;
                }



                string[] inputSigns = inputSign.Text.Trim().Split('\n');
                equationSignes = new string[inputSigns.Length];

                if (restrictions == inputSigns.Length)
                {
                    int k = 0;
                    while (k < inputSigns.Length)
                    {
                        if (rightSign(inputSigns[k]) == 0)
                        {
                            outputData.Text += "\n\n Incorrect Sign " + Convert.ToString(k + 1);
                            control          = 0;
                        }

                        k++;
                    }


                    for (int i = 0; i < inputSigns.Length && control == 1; i++)
                    {
                        int j = 0;

                        while (j < inputSigns[i].Length)
                        {
                            if (inputSigns[i][j] == '=')
                            {
                                equationSignes[i] += inputSigns[i][j];
                            }
                            else if (inputSigns[i][j] == '>' || inputSigns[i][j] == '<')
                            {
                                equationSignes[i] += inputSigns[i][j];
                            }

                            j++;
                        }
                    }
                }
                else
                {
                    outputData.Text += "\n\n Check the number of Signs";
                    control          = 0;
                }



                var inputBB = inputB.Text.Trim().Split('\n');
                equationRezults = new double[inputBB.Length];

                if (restrictions == inputBB.Length)
                {
                    int k = 0;
                    while (k < inputBB.Length)
                    {
                        if (rightDouble(inputBB[k]) == 0)
                        {
                            outputData.Text += "\n\n Incorrect Free Term " + Convert.ToString(k + 1);
                            control          = 0;
                        }

                        k++;
                    }

                    for (int i = 0; i < inputBB.Length && control == 1; i++)
                    {
                        NumberFormatInfo formatProvider = new NumberFormatInfo();
                        formatProvider.NumberDecimalSeparator = ".";
                        equationRezults[i] = Convert.ToDouble(inputBB[i], formatProvider);
                    }
                }
                else
                {
                    outputData.Text += "\n\n Check the number of Free Terms";
                    control          = 0;
                }

                if (control == 1)
                {
                    if (maximize == 1)
                    {
                        Simplex a = new Simplex(variables, restrictions, equationSignes, objectiveValues, equationRezults, equationValues, -1);
                        a.SimplexAlgorithm();

                        double[] solutionVector = new double[variables];

                        for (int i = 0; i < a.nrRestrictions; i++)
                        {
                            if (a.basis[i] <= variables)
                            {
                                solutionVector[a.basis[i] - 1] = a.simplexTableau[i][0];
                            }
                        }

                        if (a.err == 0)
                        {
                            outputData.Text += "\nx = ( ";

                            for (int i = 0; i < variables; i++)
                            {
                                outputData.Text += Convert.ToString(solutionVector[i]);
                                if (i < variables - 1)
                                {
                                    outputData.Text += " , ";
                                }
                            }

                            outputData.Text += " )\nMax( z ) = " + Convert.ToString(-1 * a.simplexTableau[a.nrRestrictions][0]) + "\n";
                        }
                        else if (a.err == 1)
                        {
                            outputData.Text += "\n\nConflicting restrictions!";
                        }
                        else if (a.err == 2)
                        {
                            outputData.Text += "\n\nThere are auxiliary \n  variabiles in the basis, \n    the phase 2 can't be executed!";
                        }
                        else if (a.err == 3)
                        {
                            outputData.Text += "\n\nThe problem is unbounded!";
                        }
                    }
                    maximize = 0;

                    if (minimize == 1)
                    {
                        Simplex a = new Simplex(variables, restrictions, equationSignes, objectiveValues, equationRezults, equationValues);
                        a.SimplexAlgorithm();

                        double[] solutionVector = new double[variables];

                        for (int i = 0; i < a.nrRestrictions; i++)
                        {
                            if (a.basis[i] <= variables)
                            {
                                solutionVector[a.basis[i] - 1] = a.simplexTableau[i][0];
                            }
                        }

                        if (a.err == 0)
                        {
                            outputData.Text += "\nx = ( ";
                            for (int i = 0; i < variables; i++)
                            {
                                outputData.Text += Convert.ToString(solutionVector[i]);
                                if (i < variables - 1)
                                {
                                    outputData.Text += " , ";
                                }
                            }

                            outputData.Text += " )\nMin( z ) = " + Convert.ToString(a.simplexTableau[a.nrRestrictions][0]);
                        }
                        else if (a.err == 1)
                        {
                            outputData.Text += "\n\nConflicting restrictions!";
                        }
                        else if (a.err == 2)
                        {
                            outputData.Text += "\n\nThere are auxiliary \n  variabiles in the basis, \n    the phase 2 can't be executed!";
                        }
                        else if (a.err == 3)
                        {
                            outputData.Text += "\n\nThe problem is unbounded!";
                        }
                    }
                    minimize = 0;
                }
            }
        }