Aplicacion para la solucion de modelos lineales a

partir del metodo Simplex Revisado.

Andres Camilo Santacruz Borda, Andres Felipe Molina Cruz.
7 de abril de 2015
Los modelos son productos de la abstraccion de sistemas; es decir que, se
realizan suposiciones pertinentes eliminando complejidades con el fin de aplicar
tecnicas matem
aticas que permitan la representacion simbolica del mismo. Los
modelos matem
aticos constan por lo menos de tres elementos:
Variables de decisi
on: Las variables de decision son incognitas que se deben
encontrar mediante la solucion del modelo.
Restricciones: Las restricciones no son mas que relaciones entre las variables de decisi
on y constantes. En el caso de la investigacion operativa
limitan o acotan los recursos disponibles.
Funci
on Objetivo: La funcion objetivo es una relacion matematica entre las
variables de decisi
on y una magnitud que representa el objetivo o producto
del sistema. Por ejemplo si se modelara una situacion en donde se requiere
maximizar la ganancia de un negocio, la funcion objetivo representa la
relaci
on entre la utilidad y las variables de decision.
Para la soluci
on de dichos modelos existen diversos metodos que son aplicados a conveniencia del modelo y de quien lo soluciona. Entre dichos metodos se
encuentra el Simplex Revisado que consiste en operaciones entre vectores y/o
matrices asociados a las variables no basicas guardando en memoria u
nicamente
lo relevante para las variables basicas.
Entonces, se presenta una aplicacion desarrollada en Java que permite dar
soluci
on a modelos lineales en su forma estandar. Para ello se establecieron dos
clases:
Ejecucion
Ecuaciones
La clase Ecuaciones como su nombre lo indica es la que posee la funcion objetivo, las restricciones y el tablero en donde se registran los datos. Los metodos
de dicha clase son los que representan las operaciones matriciales y actualizacion
de la informaci
on. Por otra parte Ejecucion es la clase principal y en la cual se
crea una instancia de Ecuaciones para llamar a los metodos y dar solucion al
modelo introducido.

1.

Clase Ecuaciones
Ecuaciones
entra
sale
varDecision
restr
tableroPrincipal
Vb
C,A,b,B,Bn,Cb
fil
col
interaccion
DefinirNumeroDeciRestri
DefinirTama
noTablero
IngresarDatosTablero1
DefinirVectorC
EscribirC
DefinirVectorA
EscribirA
DefinirVectorb
Escribirb
InicializarVb
DEfinirVectorB
InicializarB
DefinirVectorCb
InicializarCb
DefinirVectorBn
InicializarBn
DefinirVarriableEntrante
DefinirVarriableSaliente
ActualizarVb
ActualizarB
ActualizarCb
determinante
SubMatriz
AdjuntaMatriz
TranspuestaMatriz
InverzaB
Multiplicacion
restaMatrices
BnA
CbBn
CbBnb
Bnb
CbBnAMenosC
ActualizarTablero
VerificaParada
Respuestas

1.1.

DefinirNumeroDeciRestri

public void DefinirNumeroDeciRestri(int d,int r)

{
varDecision=d;
restr=r;
}
Este metodo apermite almacenar en las variables varDecision y restr
el n
umero de variables de decision y restricciones del modelo que se pretende
solucionar. Dichos datos pasan por valor desde la clase Ejecucion en donde
previamente se han declarado las variables correspondientes y el objeto de tipo
Ecuaciones.

1.2.

DefinirTama
noTablero

public void DefinirTama

noTablero()
{
fil=restr+1;
col=((restr+varDecision)+1);
tableroPrincipal = new double [fil][col];
}
Como en este caso el metodo Simplex Revisado solo es aplicable para restricciones de = las filas del tablero en donde se almacenan los datos corresponden
a los renglones reservados para la funcion objetivo y las variables basicas. La
cantidad de variables b
asicas es igual al n
umero de restricciones o variables de
holgura, por eso la variable fil es igual a la variable restr +1. Por otra parte el
n
umero de columnas corresponde a la cantidad de variables de decision mas las
variables de holgura y una columna extra para registrar los resultados de cada
rengl
on asi que la cantidad de columnas es igual a varDecision + restr +1.
1.2.1.

IngresarDatosTablero1

System.out.println(Funcion Objetivo-);
for(int i=0;i=0;i++)
{
for(int j=0;jvarDecision;j++)
{
System.out.println(Ingrese el coeficiente de x-(j+1));
tableroPrincipal[i][j]=e.nextInt();
tableroPrincipal[i][j]=tableroPrincipal[i][j]*-1;
}
}
Este fragmento de c
odigo lo que le indica al programa es que pida los coeficientes de la funci
on objetivo y los almacene en el tablero. Hay que tener en
cuenta que la funci
on objetivo se registra estando igualada a cero, es por ello
que se multiplica al dato por -1.

System.out.println(Restricciones-);
for(int i=1;ifil;i++)
{
System.out.println();
System.out.println(Restriccion -i);
System.out.println();
for(int j=0;jvarDecision;j++)
{
System.out.println(Ingrese el coeficiente de x-(j+1));
tableroPrincipal[i][j]=e.nextDouble();
tableroIterativo[i][j]=tableroPrincipal[i][j];
}
}
Por otra parte, para registrar el valor de los coeficientes de las restricciones
en el tablero se usa este fragmento de codigo. Teniendo en cuenta que el primer
rengl
on del tablero corresponde a la funcion objetivo se hace necesario indicarle
que parta desde i = 1 y que termine en fil-1. Hay que recordar que en la mayora de los lenguajes de programacion las posiciones de las matrices o arreglos
se manejan desde 0; es decir que la columna 1 para el lenguaje seria la columna 0.
int interaccion;
int antej=varDecision-1;
for(int i=1;ifil;i++)
{ interaccion=0;
for(int j=varDecision;jcol;j++)
{
if(interaccion==0 && jantej)
{ tableroPrincipal[i][j]=1;
interaccion++;
antej=j;
}
}
}
Como cada restricci
on tiene una variable de holgura con coeficiente 1 tambien es necesario registrar esto en el tablero y para ello se hace uso de este codigo.
for(int i=1;ifil;i++) {
System.out.println();
System.out.println(Resultado de la Restriccion -i);
System.out.println();
System.out.println(Ingrese el resultado );
tableroPrincipal[i][j]=e.nextInt();
}
Igual que en el caso de los coeficientes de las restricciones se hace necesario
que ciclo for parta desde i = 1 para ingresar el resultado de las mismas. Hay que
notar que el tablero siempre se mantiene en la u
ltima columna y lo que vara

son las filas.

System.out.println(*********Tablero Inicial********);
for(int i=0;ifil;i++)
{
System.out.print();
for(int j=0;jcol;j++)
{
System.out.print (tableroPrincipal[i][j]);
if (j!=tableroPrincipal[i].length-1)

System.out.print();
}
System.out.println();
}
}
Ac
a solo se imprime el tablero con todos los datos ya registrados.

1.3.

DefinirVectorC

public void DefinirVectorC ()

{
C= new double [1][varDecision];
}
El Vector C almacena los coeficientes de las variables de decision en la funcion
objetivo; por ello se crea con una fila y tantas columnas como variables de
decisi
on.

1.4.

EscribirC

public void EscribirC()

{
for(int i=0;i=0;i++)
{ for(int j=0;jvarDecision;j++)
{
C[i][j]=tableroPrincipal[i][j]*-1;
}
}
}
Se le esta asignando al vector C los valores que estan almacenados en el
tablero y corresponden a los coeficientes de la funcion objetivo. Se multiplican
por -1 porque en este caso la funcion no debe estar igualada a 0.

1.5.

DefinirVectorA

public void DefinirVectorA ()

{
A=new double[restr][varDecision];
5

}
La matriz A hace referencia a los coeficientes de las variables de decision en
las restricciones. Este fragmento de codigo crea una matriz con una cantidad
de columnas igual a la cantidad de variables de decision y una cantidad de filas
igual a la cantidad de restricciones.

1.6.

EscribirA

public void EscribirA () {

for(int i=0;ifil-1;i++)
{
for(int j=0;jvarDecision;j++)
{
A[i][j]=tableroPrincipal[i+1][j];
}
}
Adquiere dichos valores del tablero principal y los guarda en la matriz A.

1.7.

DefinirVectorb

public void DefinirVectorb ()

{
b=new double[restr][1];
}
El vector b almacena el resultado o lado derecho de las restricciones as que
sus dimensiones es de una columna y filas igual a la cantidad de restricciones .

1.8.

Escribirb

public void Escribirb()

{
for(int i=0;irestr;i++)
{
for(int j=0;j=0;j++)
{
b[i][j]=tableroPrincipal[i+1][col-1];
}
}
Igual que en el caso anterior adquiere los datos requeridos del tablero principal.

1.9.

InicializarVb

public void InicializarVb()

{
Vb=new double[restr];

int i=restr-1;
int j=col-2;
while(i=0 && j=varDecision)
{
Vb[i]=j;
i;
j;
}
}
Aunque en el metodo Simplex Revisado no figura ning
un vector Vb este
se declara y se usa con el fin de almacenar los identificadores de las variables
b
asicas en el tablero principal; es decir, se usa para guardar la posicion de las
variables b
asicas y es actualizado cada vez que una sale y otra entra.

1.10.

DEfinirVectorB

public void DEfinirVectorB ()

{
B = new double[restr][restr];
}
La matriz B almacena los coeficientes de las variables basicas en las restricciones es por ello que se crea con una cantidad de columnas igual a las
restricciones y una igual cantidad de filas

1.11.

InicializarB

public void InicializarB() {

for(int x=0;xrestr;x++)
{
for(int j=0;jrestr;j++)
{
B[x][j]=tableroPrincipal[x+1][j+varDecision];
}
}
}
Extrae los datos del tablero principal.
DefinirVectorCb public void DefinirVectorCb()
{
Cb=new double [1][restr];
}
El vector Cb almacena los coeficientes de las variables basicas en la funcion
objetivo; es por ello que se declara con una sola fila y una cantidad de columnas
igual a las restricciones.

1.12.

InicializarCb

public void InicializarCb()

{
for(int i=0;irestr;i++)
{
Cb[0][i]=tableroPrincipal[0][i+varDecision];
}
Este fragmento extrae la informacion correspondiente del tablero principal.

1.13.

DefinirVectorBn

public void DefinirVectorBn()

{
Bn =new double [restr][restr];
}
Bn es una matriz que hace referencia a la inversa de la matriz B; es por ello
que lleva las mismas dimensiones.

1.14.

InicializarBn

public void InicializarBn()

{
for(int i=0;irestr;i++)
{
for(int j =0; jrestr;j++)
{
Bn[i][j]=B[i][j];
}
}
}
En un principio, es decir antes de empezar las iteraciones B es = a Bn por
ello se est
an igualando ambas matrices.

1.15.

DefinirVarriableEntrante

public void DefinirVarriableEntrante()

{
double neg=0; // controla el mas negativo
for(int i=0; icol;i++)
{
if(tableroPrincipal[0][i]neg)
{
neg=tableroPrincipal[0][i];
entra=i;
}
}

System.out.println();
System.out.println(Variable que entra es x-(entra+1));
}
La variable que entra siempre sera la mas negativa en el renglon que corresponde a la funci
on objetivo en el tablero principal. Para ello se hace un recorrido
por todo el rengl
on almacenando en la variable llamada neg el valor 0 que se
encuentre. De igual forma por medio del condicional if se verifica si el valor
actual es menor al que se encuentra almacenado en neg, de ser as el valor de
neg es reemplazado por este nuevo dato. Cada vez que sucede esto es guardada
en la variable entra dicha posicion.

1.16.

DefinirVarriableSaliente

public void DefinirVarriableSaliente()

{
double menor=0;// controla el menor en arreglo control
double[] control =new double[restr];// controla cual es el menor en la fila
for(int i=0;irestr;i++)
{
if(tableroPrincipal[i+1][entra]0)
{ control[i]=(tableroPrincipal[i+1][col-1]/tableroPrincipal[i+1][entra]);
}
}
menor=111111111;
for(int m=0;mrestr;m++)
{
if(control[m]menor && control[m]!=0 )
{
menor=control[m];
sale=m; }
}
System.out.println(Variable que sale es x-(Vb[sale]+1));
}
Al haber encontrado la variable entrante el siguiente paso es verificar en
las filas de dicha columna los valores mayores a 0 y dividir el lado derecho
correspondiente en este valor. El valor mas cercano a cero sera el que indique la
variable saliente. En el caso de esta aplicacion se crea un vector local llamado
control que almacenara el resultado de dichas divisiones. Despues de ello se pasa
a control por una verificaci
on para encontrar el menor n
umero entre todos los all
almacenados. Es importante resaltar que dicho control no permite seleccionar
el cero por obvias razones.

1.17.

ActualizarVb

public void ActualizarVb()

{
Vb[sale]=entra;

}
Como ya se explic
o el vector Vb almacena la posicion de las variables basicas.
Ya definidas la variable entrante y la saliente es necesario actualizarlo y para
ello se aprovecha que el vector local control es de la misma dimension. En la
posici
on sale de Vb se ingresa el valor de la variable entra. Hay que recordar
que en este momento entra almacena la posicion e la variable entrante.

1.18.

ActualizarB

public void ActualizarB ()

{
for(int i=0;irestr;i++)
{
B[i][sale]=tableroPrincipal[i+1][entra];
}
}
Tambien es necesario actualizar la matriz B. Para ello tambien se hace uso
de la variable sale y el proceso es muy parecido al anterior.

1.19.

ActualizarCb

public void ActualizarCb()

{
Cb[0][sale]=tableroPrincipal[0][entra]*-1;
}
Al igual que los dos procesos anteriores se actualiza el vector Cb haciendo
uso de las variables entra y sale.

1.20.

determinante, SubMatriz, AdjuntaMatriz & TranspuestaMatriz

La inversa de una matriz se puede encontrar mediante diferentes metodos;

unos m
as complejos que otros. Aca se hace uso del metodo por Determinantes o
cofactores que es aplicable para matrices de orden inferior y de orden superior.
Adem
as este metodo es mucho mas facil de programar que otros metodos como
el de Gauss.
Por practicidad y restricciones con el recurso tiempo se hace uso del algoritmo propuesto en el canal de YouTube Rland terraza. A dicho algoritmo se
le realizaron peque
nas modificaciones para encontrar la inversa de matrices 2x2
ya que presentaba algunos errores.
Para hallar el determinante:
public double determinante (int i,double [][] matriz) [1]
{
double deter=0;
if(matriz.length==2)
10

{
deter = matriz[0][0]*matriz[1][1];
deter=deter-matriz[0][1]*matriz[1][0];
}
else
{
for(int j=0;jmatriz.length;j++)
{
double [][] temp =this.SubMatriz(i,j,matriz);
deter=deter+Math.pow(-1, i+j)*matriz[i][j]*this.determinante(i, temp);
}
}
return deter;
}
private double [][]SubMatriz(int i, int j, double [][] matriz)
{
double [][] temp = new double [matriz.length-1] [matriz.length-1];
int count1=0,count2=0;
for(int k=0;kmatriz.length;k++)
{
if(k!=i)
{
count2=0;
for (int l=0;lmatriz.length;l++)
{
if(l!=j)
{
temp[count1][count2]=matriz[k][l];
count2++; }
}
count1++;
}
}
return temp;
}
Para hallar la matriz adjunta:
public double[][] AdjuntaMatriz(double[][] matriz)[2]
{
double [][] tempAdjunta = new double [matriz.length][matriz.length];
if(matriz.length==2)
{
tempAdjunta[0][0]=matriz[1][1];
tempAdjunta[1][1]=matriz[0][0];
tempAdjunta[0][1]=matriz[0][1];
tempAdjunta[1][0]=matriz[1][0];
}
else
11

{
for(int i=0;itempAdjunta.length;i++)
{
for(int j=0;jtempAdjunta.length;j++)
{
double [][] temp= this.SubMatriz(i,j,matriz);
double elementoAdjunto =Math.pow(-1, i+j)*this.determinante(0, temp);
tempAdjunta[i][j]=elementoAdjunto; }
}
}
return tempAdjunta;
}
Para hallar la traspuesta de la adjunta:

public double[][] TranspuestaMatriz(double[][] matriz)[3]

{
double [][] tempTranspuesta = new double [matriz.length][matriz.length];
if(matriz.length==2)
{
tempTranspuesta[0][0]=matriz[0][0]; tempTranspuesta[1][1]=matriz[1][1]; tempTranspuesta[0][1]=matriz[0
1; tempTranspuesta[1][0]=matriz[1][0]*-1; }
else
{
for(int i=0;itempTranspuesta.length;i++)
{
for(int j=0;jtempTranspuesta.length;j++)
{
tempTranspuesta[i][j]=matriz[j][i]; }
}
}
return tempTranspuesta;
}

1.21.

InverzaB

public void InverzaB()

{
col=restr;
double deter=determinante(0,B);
double [][] adjunta= AdjuntaMatriz(B);
double [][] transpuesta= TranspuestaMatriz(adjunta);
for(int i=0;itranspuesta.length;i++)
{
for(int j=0;jtranspuesta.length;j++)
{
Bn[i][j]=transpuesta[i][j]*(1/deter);
}
}

12

}
Para actualizar a Bn se crean una variable y dos matrices locales que almacenaran los datos retornados por los cuatro metodos anteriores. Se llaman
estos metodos y se envan como parametros a B y a la matriz Adjunta con el
fin de hallar todos los elementos necesarios para llevar a cabo el metodo por
Determinantes.

1.22.

Multiplicacion

public double [][] Multiplicacion (double A[][], double B[][])

{
int fila1=A.length;
int Columna1=A[0].length;
int Columna2=B[0].length;
double [][] resultado= new double [fila1][Columna2];
for(int i=0;ifila1;i++)
{
for(int j=0;jColumna2;j++)
{
for(int k=0;kColumna1;k++)
{
resultado[i][j] += A[i][k]* B[k][j];
}
}
}
return resultado;
}
Nuevamente se declara un metodo p
ublico que retorne un valor; en este caso
el resultado e la multiplicaci
on de 2 matrices o vectores. Puede decirse que
este metodo es el m
as importante de la aplicacion ya que el Simplex Revisado
consiste precisamente en eso, operaciones entre matrices en las cuales predomina
la multiplicaci
on.

1.23.

restaMatrices

public double [][] restaMatrices (double [][] a,double [][]b)

{
double [][] resultado =new double[1][varDecision];
for(int i=0;ia.length;i++)
{
for(int j=0;jvarDecision;j++)
{
resultado[i][j]= a[i][j]-b[i][j];
}
}
return resultado;
}

13

1.24.

BnA,CbBn,CbBnb,Bnb,CbBnAMenosC

El c
odigo presentado a continuacion permite realizar las operaciones correspondientes entra las distintas matrices haciendo uso de los metodos Multiplicaci
on y Resta.
public double [][] BnA (double [][] a,double [][]b)
{
double [][] BnA= Multiplicacion(a,b);
return BnA;
}
public double [][] CbBn (double [][] a,double [][]b)
{
double [][] CbBn= Multiplicacion(a,b);
return CbBn;
}
public double [][] CbBnb (double [][] a,double [][]b,double [][]c)
{
double [][] Asosiativa = CbBn(a,b);
double [][] CbBnb= Multiplicacion(Asosiativa,c);
return CbBnb;
}
public double [][] Bnb (double [][] a,double [][]b) {
double [][] Bnb= Multiplicacion(a,b);
return Bnb;
}
public double [][] CbBnAMenosC (double [][] a,double [][]b,double [][] c,double
[][]d)
{
double [][] CbBnnA= CbBnb(a,b,c);
double [][] resul= restaMatrices(CbBnnA,d);
return resul; }

1.25.

ActualizarTablero

Este metodo actualiza paso por paso el tablero principal dejandolo listo para
una nueva verificaci
on y si es necesario otra iteracion. Se crean matrices locales que tomaran el valor retornado por los metodos encargados de hacer las
operaciones correspondientes. Son estas matrices las que se usan para dicha actualizaci
on.
public void ActualizarTablero ()
fil=restr+1; col=((restr+varDecision)+1);
double [][] CbBnAMenosCAct = CbBnAMenosC(Cb,Bn,A,C);
double [][] BnAAct = BnA(Bn,A);
double [][] CbBnAct = CbBn(Cb,Bn);

14

double [][] CbBnbAct = CbBnb(Cb,Bn,b);

double [][] BnbAct = Bnb(Bn,b);
// Introducioendo datos al tablero inicial
//CbBnAMenosC
for(int i=0;i=0;i++)
{
for(int j=0;jvarDecision;j++)
{
tableroPrincipal[i][j]=CbBnAMenosCAct[i][j];
}
}
//BnA
for(int i=1;ifil;i++)
{
for(int j=0;jvarDecision;j++ )
{
tableroPrincipal[i][j]=BnAAct [i-1][j];
}
}
//CbBn
int control=0;
//System.out.print (C
bBn es );
for(int i=0;i=0;i++)
{
for(int j=varDecision;jcol-1;j++ )
{
tableroPrincipal[i][j]=CbBnAct[i][control];
control++;
}
}
// CbBnb
tableroPrincipal[0][col-1]=CbBnbAct[0][0];
//Bnb
int cont=varDecision+restr;
for(int i=1;ifil;i++)
{
for(int j=cont;j=cont;j++)
{
tableroPrincipal[i][j]=BnbAct [i-1][0];
}
}
//Bn
int coll=0;
for(int i=1;ifil;i++)
{
coll=0;
for(int j=varDecision;jcol-1;j++)
{
tableroPrincipal[i][j]=Bn[i-1][coll];
coll++;
15

}
}
}

1.26.

VerificaParada

public boolean VerificaParada ()

{ boolean parada = false;
for(int i=0;i=0;i++)
{
for(int j=0;jcol-1;j++)
{
if(tableroPrincipal[i][j]0)
{
parada = true;
}
}
}
return parada; }
Este metodo de tipo booleano verifica si a
un existen valores negativos en
el rengl
on de la funci
on objetivo. De ser as toma el valor true el cual le dira
al algoritmo que debe volver a realizar el procedimiento desde encontrar una
variable entrante.

1.27.

Respuestas

public void Respuestas()

{
for(int m=0;mrestr;m++)
{
System.out.println(Variable basica son =);
System.out.println(x-(Vb[m]+1));
}
System.out.println(Sus respuestas son respectivamente :);
for(int i=1;ifil;i++)
{ System.out.println(tableroPrincipal[i][col-1]);
}
System.out.println(Z = -tableroPrincipal[0][col-1]);
}
En caso de que el valor que retorne VerificaParada sea igual a false el algoritmo saltara a este metodo para darla solucion al modelo; es decir las variables
b
asicas finales con su respectivo valor y el valor que tomara la funcion objetivo
con ellas.

16

2.

Clase Ejecucion
Ejecucion
d
r
intera
parada

La clase Ejecucion al ser la principal declara al objeto de tipo Ecuaciones y

contiene algunas variables que le permiten a dicho objeto invocar los metodos
propios de su clase para poder resolver el modelo. Tambien contiene un clico
repetitivo que controla las iteraciones hasta que se determine que ya no hay
valores negativos en el rengl
on correspondiente a la funcion objetivo.
import java.io.IOException;
import java.util.Scanner;
import Jama.*;
import java.util.Date;
public class Ejecucion
static int d=0; // Para preguntar cuantas Vd y Rc hay.
static int r=0;
static int intera=0;
static boolean parada;
public static void main(String[] args) throws IOException
Scanner h= new Scanner(System.in);
Ecuaciones objEcua = new Ecuaciones();
System.out.println(Ingrese el numero de variables de decision: );
d=h.nextInt();
System.out.println(Ingrese el numero de Restricciones );
r=h.nextInt();
objEcua.DefinirNumeroDeciRestri(d, r);
objEcua.DefinirTama
noTablero();
objEcua.IngresarDatosTablero1();
objEcua.InicializarVb();
objEcua.DefinirVectorC();
objEcua.EscribirC();
objEcua.DefinirVectorA();
objEcua.EscribirA();
objEcua.DefinirVectorb();
objEcua.Escribirb();
objEcua.DEfinirVectorB();
objEcua.InicializarB();
objEcua.DefinirVectorCb();
objEcua.InicializarCb();
objEcua.DefinirVectorBn();
objEcua.InicializarBn();
// Los anteriores parametros son fijos, ahora empiezan las interacciones;
parada=objEcua.VerificaParada();
while(parada==true)
{ intera++;
17

System.out.println();
System.out.println();
System.out.println(Interaccion -intera+);
objEcua.DefinirVarriableEntrante(); // variable que entra
objEcua.DefinirVarriableSaliente();
objEcua.ActualizarVb();
objEcua.ActualizarB();
objEcua.ActualizarCb();
objEcua.InverzaB();
//objEcua.Control();
objEcua.ActualizarTablero();
parada=objEcua.VerificaParada(); }
//System.out.println(.Ejercicio resuelto.);
objEcua.Respuestas();
}
}

Referencias
[1] Rland
terrazaDeterminante
matriz
nxn
https://www.youtube.com/watch?v=a4Nt6MCjoLc. 2014.

en

java

[2] Rland
terrazaInversa
matriz
nxn
https://www.youtube.com/watch?v=PeT-vaIkw. 2014.

en

java

[3] Rland
terrazaInversa
matriz
nxn
https://www.youtube.com/watch?v=PeT-vaIkw. 2014.

en

java

18