package ejemplos;

/**
* <p>Title: Matrices Dispersas
* <p>Description: Realiza las operaciones basicas con matrices</p>
* <p>Copyright: Copyright (c) 2003</p>
* <p>Company: UMSNH</p>
* @author Dr. Felix Calderon Solorio
* @version 1.0
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
class Nodo
{
float dato;
int col;
Nodo sig;
Nodo (float d, int r, Nodo s)
{
dato = d;
col = r;
sig = s;
}
}
class Lista
{
Nodo inicio;
Nodo fin;
Lista ()
{
inicio = fin = null;
}
void agrega(float d, int r)
{
Nodo aux = new Nodo(d, r, inicio);
inicio = aux;
if(fin == null) fin = aux;
}
}
class MatrizD
{
Lista []a;
int n, m;
MatrizD(int nr, int nc)
{
int i;
n = nr;
m = nc;
a = new Lista[n];

for(i=0; i<n; i++) a[i] = new Lista();

}
// *******************************************************************
public void agrega(float d, int r, int c)
{
Nodo e;
if(r > n || r < 0 || c > m || m < 0)
{
JOptionPane.showMessageDialog(null, "No se puede insertar el elemento ["+
c+","+r+"]",
"ERROR", JOptionPane.INFORMATION_MESSAGE);
return;
}
e = elemento(r,c);
if(e == null)
{
if(d != 0) a[r].agrega(d, c);
}
else e.dato = d;
}
// *******************************************************************
private Nodo elemento(int r, int c)
{
Nodo aux;
for(aux = a[r].inicio; aux != null; aux=aux.sig)
if(aux.col == c) break;
return aux;
}
// *******************************************************************
private float valor(int r, int c)
{
Nodo aux;
for(aux = a[r].inicio; aux != null; aux=aux.sig)
if(aux.col == c) break;
if(aux == null) return 0;
else
return aux.dato;
}
// *******************************************************************
public void imprime(String msg)
{
String salida;
Nodo e;
salida = msg + "\n";

int i, j;
for(i=0; i<n; i++)
{
for(j=0; j<m; j++)
{
e = elemento(i,j);
if(e != null) salida += e.dato;
else
salida += 0.0;
salida += "\t";
}
salida += "\n";
}
System.out.println(salida);
}
// *******************************************************************
static public void suma (MatrizD resul, MatrizD m1, MatrizD m2)
{
int i, j;
float suma;
int nr, nc;
nr = m1.n; nc = m1.m;
if(m1.n != m2.n || m1.m != m2.m || resul == null || nr != resul.n || nc !=
resul.m)
{
JOptionPane.showMessageDialog(null, "Error sums: las dimesiones de la matr
iz no son iguales",
"ERROR", JOptionPane.INFORMATION_MESSAGE);
return;
}
if(resul == null || nr != resul.n || nc != resul.m) return;
for(i=0; i<nr; i++)
for(j=0; j<nc; j++)
{
suma = m1.valor(i,j) + m2.valor(i,j);
resul.agrega(suma, i, j);
}
}
// *******************************************************************
static public void resta (MatrizD resul, MatrizD m1, MatrizD m2)
{
int i, j;
float suma;
int nr, nc;
nr = m1.n; nc = m1.m;
if(m1.n != m2.n || m1.m != m2.m || resul == null || nr != resul.n || nc !=
resul.m)
{
JOptionPane.showMessageDialog(null, "Error resta: las dimesiones de la mat
riz no son iguales",

"ERROR", JOptionPane.INFORMATION_MESSAGE);
return;
}
for(i=0; i<nr; i++)
for(j=0; j<nc; j++)
{
suma = m1.valor(i,j) - m2.valor(i,j);
resul.agrega(suma, i, j);
}
}
// *******************************************************************
static public void multiplica (MatrizD resul, MatrizD m1, MatrizD m2)
{
int i, j, k;
float suma;
int nr, nc;
nr = m1.n; nc = m2.m;
if(m1.m != m2.n || resul == null || nr != resul.n || nc != resul.m)
{
JOptionPane.showMessageDialog(null, "Error multiplica: las dimesiones de l
a matriz no son iguales",
"ERROR", JOptionPane.INFORMATION_MESSAGE);
return;
}
for(i=0; i<nr; i++)
for(j=0; j<nc; j++)
{
suma = 0;
for(k=0; k<m1.m; k++)
suma += m1.valor(i,k) * m2.valor(k,j);
resul.agrega(suma, i, j);
}
}
// *******************************************************************
static public void multiplica (MatrizD resul, float fac, MatrizD a)
{
int i, j;
int nr, nc;
nr = a.n;
nc = a.m;
if(resul == null || nr != resul.n || nc != resul.m)
{
JOptionPane.showMessageDialog(null, "Error multiplica: las dimesiones de l
a matriz no son iguales",
"ERROR", JOptionPane.INFORMATION_MESSAGE);
return;
}
for(i=0; i<a.n; i++)
for(j=0; j<a.m; j++)

resul.agrega(a.valor(i,j)*fac, i, j);
}
// *******************************************************************
public static void transpuesta(MatrizD at, MatrizD a) {
int nr, nc, i, j;
nr = a.m; nc = a.n;
if( at == null || nr != at.n || nc != at.m)
{
JOptionPane.showMessageDialog(null, "Error transpuesta: las dimesiones de
la matriz no son iguales",
"ERROR", JOptionPane.INFORMATION_MESSAGE);
return;
}
for (i = 0; i < nr; i++)
for (j = 0; j < nc; j++)
at.agrega(a.valor(j,i),i,j);
}
// *******************************************************************
public static void Gradiente_conjugado(MatrizD A, MatrizD x, MatrizD b)
{
if(A.n != A.m || A.n != x.n || A.n != b.n)
{
JOptionPane.showMessageDialog(null,
"Error Grafinte_conjugado: las dimesiones de la matriz no son iguales"
,
"ERROR", JOptionPane.INFORMATION_MESSAGE);
return;
}
float alpha, beta, rr0, rr1;
int MaxIter = A.n;
MatrizD rr
MatrizD pAp

= new MatrizD(1,1);
= new MatrizD(1,1);

MatrizD
MatrizD
MatrizD
MatrizD
MatrizD
MatrizD

=
=
=
=
=
=

Ap
r
rT
p
aux1
aux2

new
new
new
new
new
new

MatrizD(A.n, 1);
MatrizD(A.n, 1);
MatrizD(1, A.n);
MatrizD(A.n, 1);
MatrizD(1, A.n);
MatrizD(A.n, 1);

MatrizD.multiplica(Ap, A, x);
MatrizD.resta(r, Ap, b);
MatrizD.transpuesta(aux1, r);
MatrizD.multiplica(rr, aux1, r);
rr0 = rr.valor(0,0);
MatrizD.multiplica(p, -1f, r);

for(int it =1; it <= MaxIter; it++)

{
MatrizD.multiplica(Ap, A, p);
MatrizD.transpuesta(aux1, p);
MatrizD.multiplica(pAp, aux1, Ap);
alpha = rr0/pAp.valor(0,0);
MatrizD.multiplica(aux2, alpha, p);
MatrizD.suma(x,x,aux2);
MatrizD.multiplica(aux2, alpha, Ap);
MatrizD.suma(r, r, aux2);
MatrizD.transpuesta(aux1, r);
MatrizD.multiplica(rr, aux1, r);
beta = rr.valor(0,0)/rr0;
MatrizD.multiplica(aux2, beta, p);
MatrizD.resta(p, aux2, r);
rr0 = rr.valor(0,0);
x.imprime("En la iteracion " + it + " la solucion es x = ");
}
}
}