public bool ReducirColumnas(ref Tableau tabla, KeyValuePair <string, double> pivote, string variableMinima)
{
bool siCorrecto = false;
if (tabla != null && !string.IsNullOrEmpty(pivote.Key) && !string.IsNullOrEmpty(variableMinima))
{
OperacionesVectoriales op = new OperacionesVectoriales();
List <VectorEquation> resultado = new List <VectorEquation>();
VectorEquation evreferencia = tabla.StandardConstraint.Where(r => r.Nombre == pivote.Key).FirstOrDefault();
evreferencia = new VectorEquation(evreferencia.Nombre, evreferencia.NombresVariables, op.OperacionV1parametro(evreferencia.CuerpoNum, "/", pivote.Value), evreferencia.TerminoIndependiente / pivote.Value);
foreach (VectorEquation ev in tabla.StandardConstraint)
{
if (ev.Nombre == pivote.Key)
{
resultado.Add(evreferencia);
}
else if (ev.Nombre != pivote.Key)
{
double pivoteev = ev.CuerpoVector.Where(r => r.Key == variableMinima).FirstOrDefault().Value;
resultado.Add(new VectorEquation(ev.Nombre, ev.NombresVariables, op.OperacionV1parametroV2(ev.CuerpoNum, "-", pivoteev, evreferencia.CuerpoNum), op.OperacionV1parametroV2(ev.TerminoIndependiente, Constantes.Resta, pivoteev, evreferencia.TerminoIndependiente)));
}
}
double pivotefo = tabla.FuncionObjetivo.CuerpoVector.Where(r => r.Key == variableMinima).FirstOrDefault().Value;
ObjectiveFunction fo = new ObjectiveFunction(tabla.FuncionObjetivo.NombresVariables, op.OperacionV1parametroV2(tabla.FuncionObjetivo.CuerpoNum, "-", pivotefo, evreferencia.CuerpoNum), op.OperacionV1parametroV2(tabla.FuncionObjetivo.TerminoIndependiente, Constantes.Resta, pivotefo, evreferencia.TerminoIndependiente), tabla.FuncionObjetivo.SiMaximizar);
tabla.FuncionObjetivo = fo;
tabla.StandardConstraint = resultado;
siCorrecto = ActualizarBaseTabla(ref tabla, evreferencia.Nombre, new KeyValuePair <string, double>(variableMinima, evreferencia.TerminoIndependiente));
}
return(siCorrecto);
}
public bool Pivoting(ref FuzzyTableau tableau, out KeyValuePair <string, double> refVar, out KeyValuePair <string, double> pivot)
{
bool isCorrect = false;
refVar = new KeyValuePair <string, double>("", double.MinValue);
if (tableau.FuzzyZRow.IsMax)
{
refVar = new KeyValuePair <string, double>("", double.MaxValue);
}
pivot = new KeyValuePair <string, double>();
VectorEquation Zrow = tableau.ZRow;
if (tableau != null)
{
foreach (KeyValuePair <string, double> kv in tableau.ZRow.CuerpoVector)
{
if (tableau.FuzzyZRow.IsMax && kv.Value != 0 && kv.Value < refVar.Value)
{
refVar = kv;
}
else if (!tableau.FuzzyZRow.IsMax && kv.Value != 0 && kv.Value > refVar.Value)
{
refVar = kv;
}
}
pivot = GetPivot(refVar, ref tableau);
isCorrect = true;
tableau.isSolution = true;
}
return(isCorrect);
}
public VectorEquation CalculateVectorConstantOperations(VectorEquation vector, EOperation operation, double number)
{
VectorEquation result = new VectorEquation(new Dictionary <string, double>(), 0);
if (vector != null && vector.VectorBody.Count > 0)
{
List <string> vars = vector.VectorBody.Keys.ToList();
foreach (string var in vars)
{
switch (operation)
{
case EOperation.Addition:
result.VectorBody.Add(var, vector.VectorBody[var] + number);
break;
case EOperation.Subtraction:
result.VectorBody.Add(var, vector.VectorBody[var] - number);
break;
case EOperation.Multiplication:
result.VectorBody.Add(var, vector.VectorBody[var] * number);
break;
case EOperation.Division:
result.VectorBody.Add(var, vector.VectorBody[var] / number);
break;
}
}
result.Constant = CalculateOperations(vector.Constant, operation, number);
}
return(result);
}
public void CalculateVectorConstantOperationsTest()
{
VectorHelper vectorHelper = new VectorHelper();
VectorOperations vectorOperations = new VectorOperations(vectorHelper);
List <VectorEquation> vectors = new List <VectorEquation>();
VectorEquation eq1 = new VectorEquation(new Dictionary <string, double> {
{ "x1", 2 },
{ "x2", 4 }
}, 3);
double pivot = 5;
VectorEquation resultAdd = vectorOperations.CalculateVectorConstantOperations(eq1, EOperation.Addition, pivot);
Assert.Equal(resultAdd.Constant, eq1.Constant + pivot);
VectorEquation resultSubt = vectorOperations.CalculateVectorConstantOperations(eq1, EOperation.Subtraction, pivot);
Assert.Equal(resultSubt.Constant, eq1.Constant - pivot);
VectorEquation resultMult = vectorOperations.CalculateVectorConstantOperations(eq1, EOperation.Multiplication, pivot);
Assert.Equal(resultMult.Constant, eq1.Constant * pivot);
VectorEquation resultDiv = vectorOperations.CalculateVectorConstantOperations(eq1, EOperation.Division, pivot);
Assert.Equal(resultDiv.Constant, eq1.Constant / pivot);
}
public void TrazaEcuacionVectorialVertical(VectorEquation ev)
{
if (ev != null && ev.CuerpoVector.Count() > 0)
{
StreamWriter mytxt = File.AppendText(Path);
mytxt.WriteLine("");
foreach (KeyValuePair <string, double> valor in ev.CuerpoVector)
{
mytxt.WriteLine("{0} --> {1}", valor.Key, valor.Value.ToString());
}
mytxt.WriteLine("");
mytxt.WriteLine("Termino Independiente: {0}", ev.TerminoIndependiente.ToString());
mytxt.WriteLine("");
mytxt.Close();
}
}
public void isEqualDimensionVectorsTest()
{
VectorHelper vectorHelper = new VectorHelper();
List <VectorEquation> vectors = new List <VectorEquation>();
VectorEquation eq1 = new VectorEquation(new Dictionary <string, double> {
{ "x1", 1 },
{ "x2", 2 }
}, 0);
VectorEquation eq2 = new VectorEquation(new Dictionary <string, double>
{
{ "x1", 1 },
{ "x2", 1 }
}, 0);
vectors.Add(eq1);
vectors.Add(eq2);
Assert.True(vectorHelper.isEqualVariableVectors(vectors));
}
public VectorEquation CalculateVectorsOperations(VectorEquation vector1, EOperation operation, VectorEquation vector2)
{
VectorEquation result = new VectorEquation(new Dictionary <string, double>(), 0);
if (vectorHelper.isEqualVariableVectors(new List <VectorEquation> {
vector1, vector2
}))
{
List <string> vars = vector1.VectorBody.Keys.ToList();
foreach (string var in vars)
{
switch (operation)
{
case EOperation.Addition:
result.VectorBody.Add(var, vector1.VectorBody[var] + vector2.VectorBody[var]);
break;
case EOperation.Subtraction:
result.VectorBody.Add(var, vector1.VectorBody[var] - vector2.VectorBody[var]);
break;
case EOperation.Multiplication:
result.VectorBody.Add(var, vector1.VectorBody[var] * vector2.VectorBody[var]);
break;
case EOperation.Division:
result.VectorBody.Add(var, vector1.VectorBody[var] / vector2.VectorBody[var]);
break;
}
}
result.Constant = CalculateOperations(vector1.Constant, operation, vector2.Constant);
}
return(result);
}
public VectorEquation OrderDictionaryByVariable(VectorEquation equation)
{
return(new VectorEquation(equation.Nombre, OrderDictionaryByVariable(equation.CuerpoVector), equation.TerminoIndependiente));
}
public bool ReduceRows(ref SimplexTable table, KeyValuePair <string, double> refCol, KeyValuePair <string, double> refRow)
{
bool isCorrect = false;
List <VectorEquation> result = new List <VectorEquation>();
if (table != null && !string.IsNullOrEmpty(refCol.Key) && !string.IsNullOrEmpty(refCol.Key))
{
VectorEquation eqRef = _vectorOperations.CalculateVectorConstantOperations(
table.StandardConstraint.FirstOrDefault(c => c.Name.Equals(refRow.Key)),
EOperation.Division,
refRow.Value);
foreach (VectorEquation equation in table.StandardConstraint)
{
if (equation.Name.Equals(refRow.Key))
{
eqRef.Name = equation.Name;
result.Add(eqRef);
}
else
{
VectorEquation redEqu = _vectorOperations.CalculateVectorsOperations(
equation,
EOperation.Subtraction,
_vectorOperations.CalculateVectorConstantOperations(
eqRef,
EOperation.Multiplication,
equation.VectorBody[refCol.Key])
);
redEqu.Name = equation.Name;
result.Add(redEqu);
}
}
double pivotFO = table.ObjectiveFunction.VectorBody.FirstOrDefault(f => f.Key == refCol.Key).Value;
ObjectiveFunction ofResult = null;
if (pivotFO != 0)
{
VectorEquation redEqu = _vectorOperations.CalculateVectorsOperations(
table.ObjectiveFunction,
EOperation.Subtraction,
_vectorOperations.CalculateVectorConstantOperations(
eqRef,
EOperation.Multiplication,
pivotFO));
ofResult = new ObjectiveFunction(
redEqu,
table.ObjectiveFunction.isMaximice);
}
else
{
ofResult = table.ObjectiveFunction;
}
table.StandardConstraint = result;
table.ObjectiveFunction = ofResult;
if (table.Base != null && table.Base.Count() > 0)
{
table.Base = refreshBase(table.Base, refRow.Key, refCol.Key);
}
isCorrect = true;
}
return(isCorrect);
}
