public FuzzyObjectiveFunction ReduceArtificialVar(FuzzyObjectiveFunction foArtificial, IEnumerable <FuzzyVectorEquation> constraints) { FuzzyObjectiveFunction newFO = foArtificial; TRFN pivotefo = new TRFN(Constantes.NDType.AlfaBetaType, 1, 1, 0, 0); TRFNOperation fop = new TRFNOperation(); if (foArtificial != null && foArtificial.FuzzyVector.Count() > 0) { foreach (string varName in foArtificial.Header) { FuzzyVectorEquation vectorRef = null; if (varName.Contains("A")) { vectorRef = constraints.Where(c => c.Vector.Any(v => v.Key == varName && v.Value == 1)).FirstOrDefault(); } if (vectorRef != null && vectorRef.Vector.Count() > 0) { newFO = new FuzzyObjectiveFunction(foArtificial.Header, fop.AdditionFuzzyRows(newFO.FuzzyNums, fop.OperateFuzzyConstant(vectorRef.Numbers, Constantes.Multiplicacion, pivotefo)), fop.Addition(newFO.IndependentTerm, fop.Multiplication(pivotefo, vectorRef.IndependentTerm)), foArtificial.IsMax); } } } return(newFO); }
public bool StandardizeObjectiveFunction(IEnumerable <FuzzyVectorEquation> constraint, ref FuzzyObjectiveFunction fo) { TRFNOperation op = new TRFNOperation(); bool isCorrect = false; if (constraint != null && constraint.Count() > 0 && fo != null && fo.FuzzyVector != null) { Dictionary <string, TRFN> valoresFO = new Dictionary <string, TRFN>(fo.FuzzyVector); foreach (KeyValuePair <string, TRFN> cv in valoresFO) { fo.FuzzyVector[cv.Key] = op.MakeNegative(cv.Value); } int indexA = 1; foreach (FuzzyVectorEquation r in constraint) { if (!r.Name.Contains("e")) { fo.FuzzyVector.Add(r.Name, new TRFN(0)); } else if (r.Name.Contains("e") && r.Vector != null) { fo.FuzzyVector.Add(r.Name, new TRFN(0)); fo.FuzzyVector.Add(string.Format("A{0}", indexA.ToString()), new TRFN(Constantes.NDType.AlfaBetaType, 1, 1, 0, 0)); indexA++; } } isCorrect = true; } return(isCorrect); }
public bool Check(ref FuzzyTableau tableau) { bool isSolution = false; FuzzyTableau initialTableau = null; FuzzyPrimalSimplexService service = new FuzzyPrimalSimplexService(); TRFNOperation fuzzyOperator = new TRFNOperation(); DataManagement dataManagement = new DataManagement(); if (tableau.FuzzyZRow != null && tableau.FuzzyStandardConstraint.Count() > 0 && tableau.FuzzyZRow.FuzzyVector.Any(v => v.Key.Contains("A"))) { Dictionary <string, TRFN> newFO = new Dictionary <string, TRFN>(); foreach (KeyValuePair <string, TRFN> varFO in tableau.FuzzyZRow.FuzzyVector) { if (varFO.Key.Contains("A")) { newFO.Add(varFO.Key, fuzzyOperator.MakeNegative(varFO.Value)); } else { newFO.Add(varFO.Key, new TRFN(0)); } } List <FuzzyVectorEquation> newConstraint = new List <FuzzyVectorEquation>(); int indexA = 1; foreach (FuzzyVectorEquation eqItem in tableau.FuzzyStandardConstraint) { if (eqItem.Name.Contains("e")) { newConstraint.Add(new FuzzyVectorEquation(string.Format("A{0}", indexA.ToString()), eqItem.Vector, eqItem.IndependentTerm)); indexA++; } else { newConstraint.Add(eqItem); } } FuzzyObjectiveFunction initialProblemFO = new FuzzyObjectiveFunction(tableau.FuzzyZRow.Name, dataManagement.OrderDictionaryByVariable(newFO), tableau.FuzzyZRow.IndependentTerm, false); initialTableau = new FuzzyTableau(newConstraint, ReduceArtificialVar(initialProblemFO, newConstraint)); //Se reduce las variables artificiales de la función objetivo. --> Falta colocar bien la base para la reducción while (!service.CheckEnd(initialTableau)) { service.Pivoting(ref initialTableau, out KeyValuePair <string, double> minvar, out KeyValuePair <string, double> pivot); service.ReduceColumns(ref initialTableau, pivot, minvar.Key); } } if (initialTableau != null && fuzzyOperator.IsZero(initialTableau.FuzzyZRow.IndependentTerm)) { tableau = EliminateArtificialColum(new FuzzyTableau(initialTableau.FuzzyStandardConstraint, ReduceBaseVar(tableau.FuzzyZRow, initialTableau.FuzzyStandardConstraint))); isSolution = true; } return(!tableau.FuzzyZRow.FuzzyVector.Any(v => v.Key.Contains("A")) || isSolution); }
public bool ReduceColumns(ref FuzzyTableau tableau, KeyValuePair <string, double> pivot, string minVar) { bool siCorrecto = false; if (tableau != null && !string.IsNullOrEmpty(pivot.Key) && !string.IsNullOrEmpty(minVar)) { OperacionesVectoriales op = new OperacionesVectoriales(); TRFNOperation fop = new TRFNOperation(); List <FuzzyVectorEquation> resultado = new List <FuzzyVectorEquation>(); FuzzyVectorEquation evreferencia = tableau.FuzzyStandardConstraint.Where(r => r.Name == pivot.Key).FirstOrDefault(); evreferencia = new FuzzyVectorEquation(evreferencia.Name, evreferencia.Header, op.OperacionV1parametro(evreferencia.Numbers, "/", pivot.Value), fop.OperateConstant(evreferencia.IndependentTerm, Constantes.Division, pivot.Value)); double varValue = evreferencia.Vector.Where(v => v.Key == minVar).FirstOrDefault().Value; foreach (FuzzyVectorEquation ev in tableau.FuzzyStandardConstraint) { if (ev.Name == pivot.Key) { resultado.Add(evreferencia); } else if (ev.Name != pivot.Key) { double pivoteev = ev.Vector.Where(r => r.Key == minVar).FirstOrDefault().Value; //string opPivot = (pivoteev > 0 && varValue > 0 || pivoteev < 0 && varValue < 0) ? "-" : "+"; if (pivoteev != 0) { resultado.Add(new FuzzyVectorEquation(ev.Name, ev.Header, op.OperacionV1parametroV2(ev.Numbers, "-", pivoteev, evreferencia.Numbers), fop.Subtraction(ev.IndependentTerm, fop.OperateConstant(evreferencia.IndependentTerm, Constantes.Multiplicacion, pivoteev)))); } else { resultado.Add(ev); } } } TRFN pivotefo = tableau.FuzzyZRow.FuzzyVector.Where(r => r.Key == minVar).FirstOrDefault().Value; FuzzyObjectiveFunction fo = null; if (!fop.IsZero(pivotefo)) { fo = new FuzzyObjectiveFunction(tableau.FuzzyZRow.Header, fop.ReduceFuzzyRows(tableau.FuzzyZRow.FuzzyNums, fop.OperateFuzzyConstant(evreferencia.Numbers, Constantes.Multiplicacion, pivotefo)), fop.Addition(tableau.FuzzyZRow.IndependentTerm, fop.Multiplication(fop.MakeNegative(pivotefo), evreferencia.IndependentTerm)), tableau.FuzzyZRow.IsMax); } else { fo = tableau.FuzzyZRow; } //Actualizamos nombre pivote en ecuación tableau = new FuzzyTableau(resultado, fo, RefreshBase(tableau.Base, minVar, pivot.Key)); tableau.FuzzyStandardConstraint.Where(c => c.Name.Contains(pivot.Key)).FirstOrDefault().Name = minVar; tableau.isSolution = true; } return(siCorrecto); }
public void FuzzyOperationsFO() { TRFNOperation fop = new TRFNOperation(); TRFN n1 = new TRFN(Constantes.NDType.AlfaBetaType, 15, 17, 2, 2); TRFN n2 = new TRFN(Constantes.NDType.AlfaBetaType, 460, 480, 8, 8); n2 = fop.OperateConstant(n2, Constantes.Division, 13); //n2 = fop.MakeNegative(n2); TRFN result = fop.Multiplication(n1, n2); //result = fop.OperateConstant(result, Constantes.Division, 13); //result = fop.MakeNegative(result); }
public void FuzzyOperationsBody() { TRFNOperation fop = new TRFNOperation(); List <TRFN> L1 = new List <TRFN> { new TRFN(Constantes.NDType.AlfaBetaType, -15, -13, 2, 2), new TRFN(Constantes.NDType.AlfaBetaType, -14, -12, 3, 3), new TRFN(Constantes.NDType.AlfaBetaType, -17, -15, 2, 2) }; List <double> L2 = new List <double> { 1.076923077, 0, 1, 0, 0.07692307692, 0 }; TRFN referencia = new TRFN(Constantes.NDType.AlfaBetaType, -17, -15, 2, 2); List <TRFN> L3 = fop.OperateFuzzyConstant(L2, Constantes.Multiplicacion, referencia).ToList(); List <TRFN> result = fop.ReduceFuzzyRows(L1, L3).ToList(); }
public FuzzyObjectiveFunction ReduceBaseVar(FuzzyObjectiveFunction foArtificial, IEnumerable <FuzzyVectorEquation> constraints) { FuzzyObjectiveFunction newFO = foArtificial; TRFNOperation fop = new TRFNOperation(); if (foArtificial != null && foArtificial.FuzzyVector.Count() > 0) { foreach (string varName in constraints.Select(x => x.Name)) { FuzzyVectorEquation vectorRef = constraints.Where(c => c.Vector.Any(v => v.Key == varName && v.Value == 1)).FirstOrDefault(); TRFN pivotefo = foArtificial.FuzzyVector.Where(r => r.Key == varName).FirstOrDefault().Value; if (!fop.IsZero(pivotefo)) { newFO = new FuzzyObjectiveFunction(foArtificial.Header, fop.ReduceFuzzyRows(newFO.FuzzyNums, fop.OperateFuzzyConstant(vectorRef.Numbers, Constantes.Multiplicacion, pivotefo)), fop.Addition(newFO.IndependentTerm, fop.Multiplication(fop.MakeNegative(pivotefo), vectorRef.IndependentTerm)), newFO.IsMax); } } } return(newFO); }
public bool GetEquations(string path, string[,] data, int numRow, int numCol, out List <string> header, out List <FuzzyConstraint> fuzzyEquations, out FuzzyObjectiveFunction fuzzyObjectiveFunction, out List <Constraint> equations, out ObjectiveFunction objectiveFunction) { equations = new List <Constraint>(); fuzzyEquations = new List <FuzzyConstraint>(); header = new List <string>(); fuzzyObjectiveFunction = null; objectiveFunction = null; Config _config = new Config(); if (data != null && !Decimal.TryParse(data[0, 0], out decimal num)) { for (int i = 0; i < numRow; i++) { bool ifPassOperator = false; bool isMax = false; string nameEV = string.Empty; string op = string.Empty; List <double> valuesN = new List <double>(); List <TRFN> valuesFuzzy = new List <TRFN>(); double terminoIndepe = Double.NaN; TRFN fuzzyIndependtTerm = null; if (i == 0) { for (int j = 1; j < numCol; j++) { header.Add(data[i, j]); } } else { for (int j = 0; j < numCol; j++) { double numA = Double.NaN; TRFN numT = null; if (j == 0) { nameEV = data[i, j]; } else if (Double.TryParse(data[i, j], out numA) && !ifPassOperator) { valuesN.Add(numA); } else if (!Double.TryParse(data[i, j], out numA) && !GetFuzzyNumber(data[i, j], out numT) && !ifPassOperator) { op = data[i, j]; ifPassOperator = true; } else if (Double.TryParse(data[i, j], out numA) && ifPassOperator) { terminoIndepe = numA; } else if (!Double.TryParse(data[i, j], out numA) && !GetFuzzyNumber(data[i, j], out numT) && ifPassOperator) { if (data[i, j] == Constantes.Maximizar) { isMax = true; } } else if (GetFuzzyNumber(data[i, j], out numT) && !ifPassOperator) { valuesFuzzy.Add(numT); } else if (GetFuzzyNumber(data[i, j], out numT) && ifPassOperator) { fuzzyIndependtTerm = numT; } } if (op != Constantes.IgualQue && fuzzyIndependtTerm == null) { equations.Add(new Constraint(nameEV, header, valuesN, op, terminoIndepe)); } if (op != Constantes.IgualQue && fuzzyIndependtTerm != null && valuesFuzzy.Count == 0) { fuzzyEquations.Add(new FuzzyConstraint(nameEV, header, valuesN, op, fuzzyIndependtTerm)); } if (op != Constantes.IgualQue && fuzzyIndependtTerm != null && valuesFuzzy.Count > 0) { fuzzyEquations.Add(new FuzzyConstraint(nameEV, header, valuesFuzzy, op, fuzzyIndependtTerm)); } else if (op == Constantes.IgualQue && valuesFuzzy.Count == 0) { objectiveFunction = new ObjectiveFunction(header, valuesN, isMax); } else if (op == Constantes.IgualQue && valuesFuzzy.Count > 0) { fuzzyObjectiveFunction = new FuzzyObjectiveFunction(header, valuesFuzzy, new TRFN(0), isMax); } } } if (_config.AnyFuzzyParameter && fuzzyObjectiveFunction != null && GetFuzzyParameter(path, _config.FuzzyParameterName, out List <FuzzyParameter> parameters)) { TRFNOperation fuzzyOperation = new TRFNOperation(); fuzzyObjectiveFunction = new FuzzyObjectiveFunction(fuzzyObjectiveFunction.Header, fuzzyOperation.MultiplicationFuzzyConstant(fuzzyObjectiveFunction.FuzzyNums, parameters.Select(p => p.Value).ToList()), fuzzyObjectiveFunction.IndependentTerm, fuzzyObjectiveFunction.IsMax); } } return((header.Count > 0 && fuzzyEquations.Count > 0 && fuzzyObjectiveFunction != null) || (header.Count > 0 && equations.Count > 0 && objectiveFunction != null)); }