UNIVERSIDAD PRIVADA FRANZ TAMAYO

NOMBRES: Morato Caero Noelia

Rodríguez Valdiviezo Christian
Sarabia Martínez José Brayan
MATERIA: Investigación Operativa
CARRERA: Ingeniería De Sistemas
SEDE: Cochabamba
NÚMERO DE GRUPO: 4
HITO: 2

2022

1
 TABLA DE CONTENIDO
RESUMEN………………………………………………………………………………. 1
INTRODUCCIÓN…………………………………………………………………….…. 2
OBJETIVO GENERAL...……………………………………………………………….. 3
OBJETIVOS ESPECÍFICOS…………………………………………………… 3
PLANTEAMIENTO DE PROBLEMA……………………………………………...…. 3
ANÁLISIS Y DESARROLLO..…………………………………………………………..3
DISEÑO DE CLASES Y MÉTODOS QUE IMPLETAN PARA LA
SOLUCIÓN DE PROBLEMAS………………………………………………….3

CÓDIGO FUENTE……………………………………………………………….4

CAPTURAS………………………………………………………………………18
RESULTADOS…………………………………………………………………………..20
CONCLUSIONES Y RECOMENDACIONES………………………………………..21
BIBLIOGRAFÍA…………………………………………………………………………22

2
 RESUMEN

Este proyecto se centra en desarrollar una aplicación que resuelva un problema de

programación lineal mediante la implementación de algoritmos del método simplex.
Para realizar un problema de programación lineal se debe seguir una serie de pasos,
antes de hallar el resultado, primero debes encontrar los métodos que se deben utilizar en el
problema a solucionar. La realización manual de este problema nos toma tiempo y somos
propensos a cometer errores debido a la serie de pasos que se debe seguir.
Nuestro propósito es conseguir desarrollar un sistema que nos ayude con la
realización de problemas de programación lineal según el método que se deba usar en este
caso utilizamos el método simplex.
Basado en el lenguaje de C# encontramos una manera de acortar el trabajo manual
que se realiza al tener un problema de programación lineal, consiguiendo tener resultados
prontos y precisos, esto gracias a las herramientas que tiene el lenguaje de C# para aplicar
vectores y matrices.
Finalmente, el desarrollo de la aplicación para resolver problemas de programación
lineal es eficiente y eficaz a la hora de resolver iteraciones bajo el método simplex,
llegando a obtener las iteraciones necesarias o hasta que el resultado sea igual a 0 o algún
resultado tengan un número negativo.

INTRODUCCIÓN
3
La programación lineal es un método mediante el cual se optimiza, ya sea maximizando o
minimizando, una función objetivo, donde las variables están elevadas a la potencia 1. Esto,
tomando en cuenta distintas restricciones dadas.
Existen diferentes métodos para solucionar la programación lineal como ser el método
gráfico ⁵⅝ o el método de penalización, el método que usaremos y estudiaremos será el
método simplex.
El método Simplex es un procedimiento iterativo que permite mejorar la solución de la
función objetivo en cada paso. El proceso concluye cuando no es posible continuar
mejorando dicho valor, es decir, se ha alcanzado la solución óptima.
Para lograr la automatización del método simplex estudiamos C# que es un lenguaje de
programación desarrollado por Microsoft, orientado a objetos que ha sido diseñado para
compilar diversas aplicaciones que se ejecutan en .NET es un lenguaje simple, eficaz y con
seguridad.
En este proyecto combinamos ambas ramas tanto la investigación operativa como
programación, para conseguir una aplicación que nos automatice las iteraciones del método
simplex, y como conclusión tenemos una aplicación que nos optimiza tanto la
programación lineal como el tiempo que demora hacerlo de manera manual y los errores
causados por simple escritura o de simple razonamiento matemático.

OBJETIVO GENERAL

4
Desarrollar una aplicación para automatizar el proceso de un problema de programación
lineal bajo el método simplex.
OBJETIVOS ESPECIFICOS
 Estudiar el método simplex tabular
 Diseñar algoritmos del problema
 Comprender el correcto uso de vectores y matrices
 Aprender a diseñar una interfaz en base a Windows forms
PLANTEAMIENTO DEL PROBLEMA
Por mucho tiempo los problemas de programación lineal se resolvieron a partir de hoja y
lápiz por lo que causa demora y errores de escritura.
¿Cómo automatizar el procedimiento para la optimización del método simplex?
ANÁLISIS Y DESARROLLO
DISEÑO DE CLASES Y MÉTODOS QUE IMPLEMENTAN PARA LA SOLUCIÓN
DEL PROBLEMA
DIAGRAMA DE FLUJO GAUSS-JORDAN

CÓDIGO FUENTE

5
Namespace Metodo_Simplex
{
Public partial class Form1 : Form
{
Public Form1()
{
InitializeComponent();
}
Int V = 0;
Int ren = 1, col = 0;
Int var, rest, Dmenor = 0, g;
Int Colpivote = 0;
Bool M;

Private void button1_Click(object sender, EventArgs e)

{
Application.Exit();
}

Private void btncreartabla_Click(object sender, EventArgs e)

{
Try // bloque try encapsula todas las operaciones
{
Btnrenycol.Enabled = true; // para que se habilite al cargar el formulario
(primer pivote)
Dgv2.Rows.Clear(); // borra la colección de filas y columnas
Dgv1.Columns.Clear();
Dgv2.Rows.Clear();

6
 Dgv2.Columns.Clear();
Dgv1.Rows.Clear();
Int v = Convert.ToInt32(cmbvari.Text);
Int r = Convert.ToInt32(cmbres.Text);
Dgv2.ColumnCount = v;
Dgv2.RowCount = r + 1;

For (int i = 0; i < v; i++)

Dgv2.Columns[i].Name = (“X” + (i + 1)); //se establecen las columnas de las
equis
Dgv2.Rows[0].HeaderCell.Value = (“FUNCIÓN: = “); //se establece la fila de
la F.O.

DataGridViewComboBoxColumn cmb = new

DataGridViewComboBoxColumn();
Cmb.Items.Add(“<=”); //para seleccionar los mayor, menor o igual que
Cmb.Items.Add(“>=”);
Cmb.Items.Add(“=”);
Cmb.HeaderText = “”;
Cmb.Width = 50; // muestra el ancho de la columna

Dgv2.Columns.Add(cmb);
For (int i = 1; i <= r; i++) // para las restricciones
Dgv2.Rows[i].HeaderCell.Value = (“R” + i +”: “); //se establecen las filas
de las restricciones
For (int i = 0; i < v; i++) // para el lado derecho L.D.
Dgv2.Columns[i].Width = 50;
Dgv2.RowHeadersWidth = 90;
Dgv2.Columns.Add(“RESULTADO”, “RESULTADO”);

7
 Dgv2.Rows[0].Cells[v + 1].Style.BackColor = Color.Blue; // para no poder
ingresar datos de la F.O. en el L.D.
Dgv2.Rows[0].Cells[v].ReadOnly = true;
For (int i = 1; i <= r; i++) //para que nos muestre en pantalla lo ingresado es
decir: <=
Dgv2.Rows[i].Cells[v].Value = “<=”;
}
Catch //bloque catch para capturar los errores generados por el try
{
MessageBox.Show(“POR FAVOR INGRESA LOS VALORES”);
}
}

Private void btnrenycol_Click(object sender, EventArgs e)

{
Try
{
Dgv1.Rows.Clear(); // borra la colección de filas
Btnsiguiente.Enabled = true; // para que se habilite al cargar el formulario
Var = Convert.ToInt32(cmbvari.Text);
Rest = Convert.ToInt32(cmbres.Text);
Dgv1.ColumnCount = (1 + var + rest + 1);
Dgv1.Columns[0].Name = (“Z”);

For (int i = 1; i <= var; i++)

Dgv1.Columns[i].Name = (“X” + i); //para que X aumente

For (int i = 1; i <= rest; i++)

8
 Dgv1.Columns[i + var].Name = (“H” + i); //para que las holguras
aumenten
Dgv1.Columns[var + rest + 1].Name = (“LD”); //para que los datos se
ingresen a L.D.
Dgv1.RowCount = rest + 1;
Dgv1.Rows[0].HeaderCell.Value = “Z”;

For (int i = 1; i <= rest; i++)

Dgv1.Rows[i].HeaderCell.Value = “H” + i; //para que las holguras
aumenten en el lado izquierdo

For (int i = 0; i <= rest + var; i++) //Para el tamaño de columnas, pixeles
Dgv1.Columns[i].Width = 40;
Dgv1.Columns[var + rest + 1].Width = 55;
Dgv1.RowHeadersWidth = 50;

Int[] z = new int[var]; //creamos un vector para llenar las filas

For (int i = 0; i < var; i++)
Z[i] = (Convert.ToInt32(dgv2.Rows[0].Cells[i].Value) * -1);
Dgv1.Rows[0].Cells[0].Value = 1;
//empezamos con la primera resolución para el ejercicio
For (int i = 0; i < var; i++)
{
Dgv1[i + 1, 0].Value = z[i];
}
For (int i = (var + 1); i < (rest + var + 2); i++)
{
Dgv1[i, 0].Value = 0;
}

9
For (int i = 0; i < rest; i++)
{
For (int j = 0; j < var; j++)
{
Dgv1[j + 1, i + 1].Value = dgv2[j, i + 1].Value;
}
}
For (int i = 0; i < rest; i++)
{
Dgv1[0, i + 1].Value = 0;
}

For (int i = 0; i < rest; i++)

{
For (int j = 0; j < rest; j++)
{
If (i == j)
Dgv1[j + (var + 1), i + 1].Value = 1;
Else
Dgv1[j + (var + 1), i + 1].Value = 0;
}
}
For (int i = 0; i < rest; i++)
{
Dgv1[var + rest + 1, i + 1].Value = dgv2[var + 1, i + 1].Value;
}
Dmenor = 999;
Int num;

10
 For (int i = 0; i < (rest + var + 2); i++)
{
Num = Convert.ToInt32(dgv1[i, 0].Value);
If (num < Dmenor)
Dmenor = num;
}
For (int i = 0; i < (rest + var + 2); i++)
{
If (Convert.ToInt32(dgv1[i, 0].Value) == Dmenor)
{
Dgv1.Columns[i].DefaultCellStyle.BackColor = Color.Red; //para
distinguir el pivote
Break;
}
Colpivote++;
Col++;
}
Int R = rest + var + 1;
Int n1, n2, S = 0;
For (int i = 0; i < rest + 1; i++)
{
N1 = Convert.ToInt32(dgv1[R, i].Value);
N2 = Convert.ToInt32(dgv1[col, i].Value);
If (n1 > 0 & n2 > 0)
S++;
}
Double[] comp = new double[S];
Int M = 0;
Double ra = 0.0, r2 = 0.0;

11
 For (int i = 0; i < rest + 1; i++)
{
Ra = Convert.ToDouble(dgv1[R, i].Value);
R2 = Convert.ToDouble(dgv1[col, i].Value);
If (ra > 0 & r2 > 0)
{
Comp[M] = ra / r2;
M++;
}
}
Double and = 999999;
For (int i = 0; i < comp.Length; i++)
{
If (comp[i] < and)
{
And = comp[i];
}
}
G = 1;
For (int i = 0; i < (rest + 1); i++) //para la fila pivote
{
If (comp[i] == and)
{
Dgv1.Rows[g].DefaultCellStyle.BackColor = Color.SkyBlue; //para
distinguir la fila pivote
Break;
}
G++;
Ren++;

12
 }
Dgv1.Rows[ren].Cells[col].Style.BackColor = Color.Red; //para distinguir el
pivote
}
Catch (Exception)
{
MessageBox.Show(“INGRESA LOS VALORES”);
}
}

Private void btnNRP_Click(object sender, EventArgs e)

{
Btntt.Enabled = true; //para que se habilite al cargar el formulario (finalizar
tabla)
Btnrenycol.Enabled = false; //para que se desabilite al cargar el formulario
(primer pivote)
Double ele;
Double elpib = Convert.ToDouble(dgv1[col, ren].Value);
For (int i = 0; i < rest + var + 2; i++) // para encontrar el siguiente elemento
pivote
{
Ele = Convert.ToInt32(dgv1[i, ren].Value);
Dgv1[i, ren].Value = (ele / elpib).ToString(“0.##”);
}
}

Private void btntt_Click(object sender, EventArgs e)

{

13
 Btnsiguiente.Enabled = false; //para que se deshabilite al cargar el formulario
(siguiente)
Dmenor *= -1;
Int nColumnas = dgv1.ColumnCount;
Int nRenglo = dgv1.RowCount;
Double[] rPiv = new double[nColumnas];
For (int i = 0; i < nColumnas; i++)
rPiv[i] = Convert.ToDouble(dgv1[i, ren].Value) * Dmenor;
for (int i = 0; i < nColumnas; i++)
dgv1[i, 0].Value = Convert.ToDouble(dgv1[i, 0].Value) + rPiv[i];

double[] Checar = new double[nColumnas];

double[] colPivo = new double[nRenglo];
double[] nrenPivo = new double[nColumnas];
//realizamos el suiguiente procedimiento para la resolución del ejercicio
For (int i = 0; i < nRenglo; i++)
{
colPivo[i] = Convert.ToDouble(dgv1.Rows[i].Cells[col].Value);
}
For (int i = 0; i < nColumnas; i++)
{
nrenPivo[i] = Convert.ToDouble(dgv1.Rows[ren].Cells[i].Value);
}
Double nrpiv = 0;
Int conta = 1;
Int y = 0;
Double elePiv = Convert.ToDouble(dgv1[col, ren].Value);
For (int i = 1; i < nRenglo; i++)
{

14
 Y = 0;
For (int j = 0; j < nColumnas; j++)
{
If (i ¡= ren)
{
Nrpiv = colPivo[i] * -1;
Checar[y] = nrpiv * nrenPivo[y];
Dgv1[j, i].Value = Checar[y] + Convert.ToDouble(dgv1[j, i].Value);
Y++;
}
}
Conta++;
}
Double numero = 0.0;
For (int i = 0; i < nColumnas; i++)
{
Numero = Convert.ToDouble(dgv1.Rows[0].Cells[i].Value);
If (numero < 0)
{
M = true;
Break;
}
V++;
}
btnValop.Enabled = true;
}

15
 Private void btnValop_Click(object sender, EventArgs e)
{

listBox1.Items.Clear();
double[] nuevaCpivote = new double[dgv1.RowCount]; // creamos vectores
para llenar los resultados
double[] sol = new double[dgv1.RowCount];
double[] resultado = new double[dgv1.RowCount];
if (M == true) //si se cumple todo
{
For (int i = 0; i < dgv1.RowCount; i++)
{
For (int j = 0; j < dgv1.ColumnCount; j++)
{
Dgv1.Rows[i].Cells[j].Style.BackColor = Color.SkyBlue;
}
}
For (int i = 0; i < dgv1.RowCount; i++) //para pivote
{
nuevaCpivote[i] = Convert.ToDouble(dgv1.Rows[i].Cells[V].Value);
}
For (int i = 0; i < dgv1.RowCount; i++) //para diferenciar fila pivote
{
Dgv1.Rows[i].Cells[V].Style.BackColor = Color.SkyBlue;
}
For (int i = 0; i < sol.Length; i++) //para la solución
{
Sol[i] = Convert.ToDouble(dgv1.Rows[i].Cells[dgv1.ColumnCount –
1].Value);

16
 }
For (int i = 0; i < resultado.Length; i++) //para el resultado
{
Resultado[i] = sol[i] / nuevaCpivote[i]; //resultado es igual a la solución
sobre el nuevo pivote
}
Double peque = 999999.99;
For (int i = 1; i < resultado.Length; i++)
{
If (resultado[i] < peque)
{
Peque = resultado[i];
}
}
Int t;
For (t = 0; t < dgv1.RowCount; t++)
{
If (peque == resultado[t])
Break;
}
For (int i = 0; i < dgv1.ColumnCount; i++)
{
Dgv1.Rows[t].Cells[i].Style.BackColor = Color.SkyBlue;
}
Dgv1.Rows[t].Cells[V].Style.BackColor = Color.Red;
Double nElementoPivote = Convert.ToDouble(dgv1.Rows[t].Cells[V].Value);
Int z = 0;
Int ncdt = dgv1.ColumnCount;
Int nrdt = dgv1.RowCount;

17
 Double vari;
For (int i = 0; i < ncdt; i++) //para resolver la fila del pivote
{
Vari = Convert.ToDouble(dgv1.Rows[t].Cells[i].Value);
Dgv1.Rows[t].Cells[i].Value = (vari / nElementoPivote).ToString(“0.##”);
}
Double ch;
Double[] Pri = new double[dgv1.ColumnCount];
Double[] Jir = new double[dgv1.ColumnCount];
For (int i = 0; i < Jir.Length; i++)
{
Jir[i] = Convert.ToDouble(dgv1.Rows[t].Cells[i].Value);
}
For (int i = 0; i < dgv1.RowCount; i++)
{
Z = 0;
For (int j = 0; j < dgv1.ColumnCount; j++)
{
If (i ¡= t)
{
Ch = nuevaCpivote[i] * -1;
Pri[z] = ch * Jir[z];
Dgv1[j, i].Value = (Pri[z] + Convert.ToDouble(dgv1[j,
i].Value)).ToString(“0.##”);
Z++;
}
}
}

18
 listBox1.Items.Add(“Z= “ + dgv1.Rows[0].Cells[dgv1.ColumnCount –
1].Value);
for (int i = 1; i < (var + 1); i++)
{
listBox1.Items.Add(“X” + i + “= “ +
dgv1.Rows[i].Cells[dgv1.ColumnCount – 1].Value);
}
}
Else
{
listBox1.Items.Add(“Z= “ + dgv1.Rows[0].Cells[dgv1.ColumnCount –
1].Value);
for (int i = 1; i < (var + 1); i++)
{
listBox1.Items.Add(“X” + i + “= “ +
dgv1.Rows[i].Cells[dgv1.ColumnCount – 1].Value);
}
}
}

Private void btnlimpiar_Click(object sender, EventArgs e)

{
//para limpiar e ingresar nuevo ejercicio
Cmbvari.SelectedIndex = 0;
Cmbres.SelectedIndex = 0;
Dgv1.Columns.Clear();
Dgv2.Rows.Clear();
Dgv2.Columns.Clear();
Dgv1.Rows.Clear();

19
 Ren = 1;
Col = 0;
Var = 0;
Rest = 0;
V = 0;
listBox1.Items.Clear();
}

CAPTURAS

20
21
RESULTADOS
Comprobamos el resultado con la calculadora PHPSimplex y de manera manuscrita

CONCLUSIONES Y RECOMENDACIONES
Concluido el proyecto se determinan las siguientes conclusiones:
 Es posible desarrollar una aplicación para la solución de
optimización.
 Podemos concluir que la base del proyecto es el estudio de
investigación operativa y programación

22
  Se puede evitar errores de escritura y lógica matemática bajo la
eficiencia de la aplicación

Se recomienda:
 Estudiar otros lenguajes de programación
 Implementar una versión de aplicación que reconozca diferentes
métodos de solución
 Estudiar a detalle los diferentes métodos de optimización

BIBLIOGRAFIA
Gimena Arnez (2020) clase del método simplex tabular
https://drive.google.com/drive/u/2/folders/1547Blfe7ad6MLeGe4vrNRzH4_RTOrtqy
Hamdy Abdelaziz Taha (1971) investigación operativa

23