/// <summary>
 /// Returns true if all constraints in constraint system are equal
 /// </summary>
 public bool AreAllConstraintsEqual(LppForSimplexMethod problem)
 {
     foreach (var constraint in problem.ConstraintSystem)
         if (constraint.Sign != "=")
             return false;
     return true;
 }
 /// <summary>
 /// Returns true if problem can be solved by simplex-method
 /// </summary>
 public new bool IsNormalized(LppForSimplexMethod problem)
 {
     return IsTargetFunctionMinimized(problem)
         && AreAllConstraintsEqual(problem)
         && DoAllConstraintsHaveBasisVariable(problem)
         && DoAllVariablesHaveZeroConstraint(problem);
 }
        /// <summary>
        /// Variant of 4th step of normalizing(should be used if constraint system has more than(>=) and equal(=) constraints, 
        /// except less than constraints, which were changed on previous step)
        /// </summary>
        /// <param name="problem">Initial problem</param>
        /// <returns>Changed problem(new object)</returns>
        public LppForSimplexMethod ChangeBothTypesOfConstraints(LppForSimplexMethod problem)
        {
            var problemCopy = new LppForSimplexMethod(problem);

            //1.
            var maxIndex = EqualConstraintWithBiggestFreeCoefficient(problemCopy);
            //2.
            for (var i = 0; i < problemCopy.ConstraintCount; i++)
            {
                var currConstraint = problemCopy.GetConstraint(i);
                if (problemCopy.LessThanConstraintsIndexes.Contains(i) || currConstraint.Sign != ">=")
                    continue;

                var constraintWithMaxCoef = problemCopy.GetConstraint(maxIndex);

                while (currConstraint.RightSide >= constraintWithMaxCoef.RightSide)
                    currConstraint.Divide(2);

                currConstraint.Multiply(-1);
                problemCopy.AddAdditionalVariable(i);

                currConstraint.Add(constraintWithMaxCoef);
            }
            //3.
            for (var i = 0; i < problemCopy.ConstraintCount; i++)
                if (problemCopy.GetBasisVariableLabel(i) == null)
                    problemCopy.AddArtificialVariable(i);

            return problemCopy;
        }
        /// <summary>
        /// Gets result of solving
        /// </summary>
        public new LppResult GetResult(SimplexTable table, LppForSimplexMethod problem)
        {
            if (!HaveNegativeFreeCoefficients(table))
                return GetInitialProblemResult(table, problem);

            return HaveNegativeRowsWithoutNegativeElements(table) ? new LppResult(null, null) : null;
        }
        private Dictionary<int, MaxCoefficient> _targetFunctionCoefficients; //Dictionary<variableId, coefficient>

        #endregion Fields

        #region Constructors

        //======================================================================================
        /// <summary>
        /// Represents symplex-table
        /// </summary>
        public SimplexTable(LppForSimplexMethod problem)
        {
            SetVariables(problem);
            SetBasis(problem);
            SetCoeffientsMatrix(problem);
            SetTargetFunctionCoefficints(problem);
        }
 /// <summary>
 /// Returns true if all free coefficients are more than or equal zero
 /// </summary>
 public bool AreFreeCoefficientsNonNegative(LppForSimplexMethod problem)
 {
     foreach (var constraint in problem.ConstraintSystem)
         if (constraint.RightSide < 0)
             return false;
     return true;
 }
        /// <summary>
        /// 2nd step of normalizing
        /// </summary>
        /// <param name="problem">Initial problem</param>
        /// <returns>Changed problem(new object)</returns>
        public LppForSimplexMethod ConstraintsToLessThanForm(LppForSimplexMethod problem)
        {
            var problemCopy = new LppForSimplexMethod(problem);

            foreach (var lim in problemCopy.ConstraintSystem)
                if (lim.Sign == ">=")
                    lim.Multiply(-1);

            return problemCopy;
        }
        public new LppForSimplexMethod Normalize(LppForSimplexMethod problem)
        {
            var problemCopy = new LppForSimplexMethod(problem);

            problemCopy = TargetToMinimize(problemCopy);
            problemCopy = ConstraintsToLessThanForm(problemCopy);
            problemCopy = ChangeLessThanConstraints(problemCopy);
            problemCopy = ChangeEqualConstraints(problemCopy);
            problemCopy = ReplaceVariablesWithoutZeroConstraints(problemCopy);

            return problemCopy;
        }
 /// <summary>
 /// Represents linear programming problem for symplex-method
 /// </summary>
 /// <param name="problem">Initial problem</param>
 public LppForSimplexMethod(LppForSimplexMethod problem)
     : base(problem.TargetFunction, problem.ConstraintSystem, problem.ZeroConstraints)
 {
     InitializeComponents();
     InitialProblem = new LinearProgrammingProblem(problem.InitialProblem);
     VariablesWithMaxCoefficient.AddRange(problem.VariablesWithMaxCoefficient);
     LessThanConstraintsIndexes.AddRange(problem.LessThanConstraintsIndexes);
     foreach (var replacement in problem.Replacements)
         Replacements.Add(replacement.Key,
                          new KeyValuePair<string, string>(replacement.Value.Key, replacement.Value.Value));
     IsTargetWasChanged = problem.IsTargetWasChanged;
 }
        /// <summary>
        /// Solving by simplex-method
        /// </summary>
        public new LppResult Solve(LppForSimplexMethod problem)
        {
            if (!IsNormalized(problem))
                throw new FormatException("Problem must be normalized");

            var table = MakeFirstSimplexTable(problem);

            while (!IsEnd(table))
            {
                table = CalculateRatings(table);

                var solvingElement = GetSolvingElement(table);

                table = ChangeBasis(table, solvingElement);
            }

            return GetResult(table, problem);
        }
        /// <summary>
        /// Returns index of constraint with biggest free coefficient
        /// </summary>
        private int EqualConstraintWithBiggestFreeCoefficient(LppForSimplexMethod problem)
        {
            var maxIndex = -1;
            for (var i = 0; i < problem.ConstraintCount; i++)
            {
                var currConstraint = problem.GetConstraint(i);

                if (currConstraint.Sign != "=" || problem.LessThanConstraintsIndexes.Contains(i)) continue;

                if (maxIndex == -1)
                {
                    maxIndex = i;
                    continue;
                }

                if (currConstraint.RightSide > problem.GetConstraint(maxIndex).RightSide)
                    maxIndex = i;
            }
            return maxIndex;
        }
        /// <summary>
        /// 1st step of normalizing
        /// </summary>
        /// <param name="problem">Initial problem</param>
        /// <returns>Changed problem(new object)</returns>
        public LppForSimplexMethod TargetToMinimize(LppForSimplexMethod problem)
        {
            var problemCopy = new LppForSimplexMethod(problem);

            if (problemCopy.TargetFunction.Target != "min")
            {
                problemCopy.TargetFunction.ChangeTarget();
                problemCopy.IsTargetWasChanged = true;
            }

            return problemCopy;
        }
 /// <summary>
 /// Returns true if constraint system contains constraints with such sign
 /// </summary>
 private bool ContainsSuchConstraints(LppForSimplexMethod problem, string sign)
 {
     for (var i = 0; i < problem.ConstraintCount; i++)
     {
         if (problem.LessThanConstraintsIndexes.Contains(i)) continue;
         if (problem.GetConstraint(i).Sign == sign)
             return true;
     }
     return false;
 }
 /// <summary>
 /// Returns true if problem have more than zero constraint
 /// </summary>
 public bool DoProblemHaveMoreThanZeroConstraint(LppForSimplexMethod problem)
 {
     foreach (var constraint in problem.ConstraintSystem)
         if (constraint.Sign == ">=" && constraint.RightSide == 0)
             return true;
     return false;
 }
        /// <summary>
        /// 5th step of normalizing
        /// </summary>
        /// <param name="problem">Initial problem</param>
        /// <returns>Changed problem(new object)</returns>
        public LppForSimplexMethod ReplaceVariablesWithoutZeroConstraints(LppForSimplexMethod problem)
        {
            var problemCopy = new LppForSimplexMethod(problem);

            var needReplacement = new List<string>();
            foreach (var tFuncArgument in problemCopy.TargetFunction.Arguments)
            {
                var containedZeroConstraint = false;
                foreach (var zeroConstraint in problemCopy.ZeroConstraints)
                    if (zeroConstraint.LeftSide.ElementAt(0).Label == tFuncArgument)
                    {
                        containedZeroConstraint = true;
                        break;
                    }
                if (!containedZeroConstraint)
                    needReplacement.Add(tFuncArgument);
            }

            foreach (var label in needReplacement)
                problemCopy.AddVariableReplacement(label, label + "'", label + "''");

            return problemCopy;
        }
 /// <summary>
 /// Makes first simplex table(without ratings)
 /// </summary>
 public SimplexTable MakeFirstSimplexTable(LppForSimplexMethod problem)
 {
     return new SimplexTable(problem);
 }
Example #17
0
 /// <summary>
 /// Gets initial problem result
 /// </summary>
 public LppResult GetInitialProblemResult(SimplexTable lastTable, LppForSimplexMethod normalizedForSimplexProblem)
 {
     return _simplex.GetInitialProblemResult(lastTable, normalizedForSimplexProblem);
 }
 /// <summary>
 /// Represents linear programming problem for symplex-method
 /// </summary>
 /// <param name="problem">Initial problem</param>
 public ProblemForGomory(LppForSimplexMethod problem)
     : base(problem)
 {
     InitializeComponents();
 }
 /// <summary>
 /// Returns true if all variables have constraint 'more than zero'
 /// </summary>
 public bool DoAllVariablesHaveZeroConstraint(LppForSimplexMethod problem)
 {
     var zeroConstraintedVariables = new List<string>();
     foreach (var zeroConstraint in problem.ZeroConstraints)
         zeroConstraintedVariables.Add(zeroConstraint.LeftSide.ElementAt(0).Label);
     foreach (var argument in problem.TargetFunctionArguments)
         if (!zeroConstraintedVariables.Contains(argument))
             return false;
     return true;
 }
        /// <summary>
        /// Gets result of solving
        /// </summary>
        public LppResult GetResult(SimplexTable table, LppForSimplexMethod problem)
        {
            if (!HavePositiveRatings(table))
                return GetInitialProblemResult(table, problem);

            return HavePositiveCellsWithoutPositiveElements(table) ? new LppResult(null, null) : null;
        }
 /// <summary>
 /// Gets acceptable solution of normalixed problem
 /// </summary>
 public LppResult GetNormalizedProblemResult(SimplexTable table, LppForSimplexMethod problem)
 {
     return problem.GetNormalizedProblemResult(table);
 }
 /// <summary>
 /// Gets acceptable solution of initial problem
 /// </summary>
 public LppResult GetInitialProblemResult(SimplexTable table, LppForSimplexMethod problem)
 {
     return problem.GetInitialProblemResult(table);
 }
Example #23
0
        /// <summary>
        /// Solves weakened problem(without whole constraints) by simplex-method
        /// </summary>
        /// <param name="problem">Initial problem</param>
        /// <param name="normalizedProblem"></param>
        /// <param name="lastSimplexTable">Last simplex-table(optimal plan)</param>
        /// <returns></returns>
        public LppResult SolveInitialWeekenedProblem(ProblemForGomory problem,
            out LppForSimplexMethod normalizedProblem, out SimplexTable lastSimplexTable)
        {
            normalizedProblem = _simplex.Normalize(problem);
            lastSimplexTable = _simplex.MakeFirstSimplexTable(normalizedProblem);
            lastSimplexTable = _simplex.Solve(lastSimplexTable);

            return _simplex.GetNormalizedProblemResult(lastSimplexTable, normalizedProblem);
        }
        /// <summary>
        /// 2nd step of normalizing(can be after or befor changing of more than zero constraints)
        /// </summary>
        /// <param name="problem">Initial problem</param>
        /// <returns>Changed problem(new object)</returns>
        public LppForSimplexMethod MakeFreeCoefficientsNonNegative(LppForSimplexMethod problem)
        {
            var problemCopy = new LppForSimplexMethod(problem);

            foreach (var constraint in problemCopy.ConstraintSystem)
                if (constraint.RightSide < 0)
                    constraint.Multiply(-1);

            return problemCopy;
        }
Example #25
0
 /// <summary>
 /// Solves weakened problem(without whole constraints) by dual simplex-method
 /// </summary>
 public LppResult SolveWeekenedProblemWithCutoff(LppForSimplexMethod problem, SimplexTable firstTable, out SimplexTable lastTable)
 {
     lastTable = _dualSimplex.Solve(firstTable);
     return _dualSimplex.GetNormalizedProblemResult(lastTable, problem);
 }
        /// <summary>
        /// Nomalizing for simplex-method
        /// </summary>
        public LppForSimplexMethod Normalize(LppForSimplexMethod problem)
        {
            var problemCopy = new LppForSimplexMethod(problem);

            problemCopy = TargetToMinimize(problemCopy);
            problemCopy = MakeFreeCoefficientsNonNegative(problemCopy);
            problemCopy = ChangeMoreThanZeroConstraints(problemCopy);
            problemCopy = ChangeLessThanConstraints(problemCopy);
            problemCopy = ChangeMoreThanAndEqualConstraints(problemCopy);
            problemCopy = ReplaceVariablesWithoutZeroConstraints(problemCopy);

            return problemCopy;
        }
        private UiDescription SolveOrNormalizeChoiceStep(UiDescription userData)
        {
            CurrentProblem = new LppForSimplexMethod(((LinearProgrammingProblem)userData["LPP"].Value));

            //CurrentProblem = _simplex.Normalize(CurrentProblem);
            //CurrentSimplexTable = _simplex.MakeFirstSimplexTable(CurrentProblem);
            //CurrentSimplexTable = _simplex.Solve(CurrentSimplexTable);
            //return NormalizedProblemResultEnteringStep(userData);

            var nextStep = SolveOrNormalizing();
            SetNextStep(nextStep == SolveLabel ? (Step)MakeFirstSimplexTableStep : NormalizeActionChoiceStep);
            return new UiDescription
                       {
                           {"LppView", "LPP", "", CurrentProblem, false, false},
                           {"Label", "lab", null, "Виберіть наступний крок:", false, false},
                           {"StepsContainer", "NextSteps", SolveOrNormalizeVariants, new StepVariants(new[] {nextStep}), true, true}
                       };
        }
 /// <summary>
 /// Returns true if problem have less than constraints
 /// </summary>
 public bool DoProblemHaveLessThanConstraint(LppForSimplexMethod problem)
 {
     foreach (var constraint in problem.ConstraintSystem)
         if (constraint.Sign == "<=")
             return true;
     return false;
 }
 /// <summary>
 /// Represents linear programming problem for symplex-method
 /// </summary>
 /// <param name="problem">Initial problem</param>
 /// <param name="wholeConstraints"> </param>
 public ProblemForGomory(LppForSimplexMethod problem, IEnumerable<string> wholeConstraints)
     : base(problem)
 {
     InitializeComponents();
     WholeConstraints.AddRange(wholeConstraints);
 }
 /// <summary>
 /// Returns true if target in problem's target function is min
 /// </summary>
 public bool IsTargetFunctionMinimized(LppForSimplexMethod problem)
 {
     return problem.TargetFunction.Target == "min";
 }