Matrices???

Carlos
15 de Septiembre del 2004
Hola quisiera ver si alguien me podría hechar la mano con estos metodos que necesito;
PASAR UNA MATRIZ COMO ARGUMENTO A UN MÉTODO
MÉTODO QUE RETORNA UNA MATRIZ

De antemano gracias.

karim
15 de Septiembre del 2004
package matriz;
import java.util.*;


public class Matriz implements Cloneable{
public int n; //dimensión
private double[][] x;
public Matriz(int n) {
this.n=n;
x=new double[n][n];
for(int i=0; i<n; i++){
for(int j=0; j<n; j++){
x[i][j]=0.0;
}
}
}
public Matriz(double[][] x) {
this.x=x;
n=x.length;
}
public Object clone(){
Matriz obj=null;
try{
obj=(Matriz)super.clone();
}catch(CloneNotSupportedException ex){
System.out.println(" no se puede duplicar");
}
//aquí está la clave para clonar la matriz bidimensional
obj.x=(double[][])obj.x.clone();
for(int i=0; i<obj.x.length; i++){
obj.x[i]=(double[])obj.x[i].clone();
}
return obj;
}

double traza(){
double tr=0.0;
for(int i=0; i<n; i++){
tr+=x[i][i];
}
return tr;
}
//suma de dos matrices
static Matriz suma(Matriz a, Matriz b){
Matriz resultado=new Matriz(a.n);
for(int i=0; i<a.n; i++){
for(int j=0; j<a.n; j++){
resultado.x[i][j]=a.x[i][j]+b.x[i][j];
}
}
return resultado;
}
//producto de dos matrices
static Matriz producto(Matriz a, Matriz b){
Matriz resultado=new Matriz(a.n);
for(int i=0; i<a.n; i++){
for(int j=0; j<a.n; j++){
for(int k=0; k<a.n; k++){
resultado.x[i][j]+=a.x[i][k]*b.x[k][j];
}
}
}
return resultado;
}
//producto de una matriz por un escalar
static Matriz producto(Matriz a, double d){
Matriz resultado=new Matriz(a.n);
for(int i=0; i<a.n; i++){
for(int j=0; j<a.n; j++){
resultado.x[i][j]=a.x[i][j]*d;
}
}
return resultado;
}
//producto de un escalar por una matriz
static Matriz producto(double d, Matriz a){
Matriz resultado=new Matriz(a.n);
for(int i=0; i<a.n; i++){
for(int j=0; j<a.n; j++){
resultado.x[i][j]=a.x[i][j]*d;
}
}
return resultado;
}
//producto de un vector fila por una matriz da un vector fila (1xn) (nxn)= (1xn)
static Vector producto(Vector v, Matriz a){
Vector b=new Vector(v*n);
int n=v*n; //dimensión
for(int j=0; j<n; j++){
for(int k=0; k<n; k++){
b.x[j]+=v.x[k]*a.x[k][j];
}
}
return b;
}
//producto de una matriz por un vector columna (nxn) (nx1)= (nx1)
static Vector producto(Matriz a, Vector v){
int n=v*n; //dimensión
Vector b=new Vector(n);
for(int i=0; i<n; i++){
for(int k=0; k<n; k++){
b.x[i]+=a.x[i][k]*v.x[k];
}
}
return b;
}

//determinante de una matriz
double determinante(){
Matriz a=(Matriz)clone();
for(int k=0; k<n-1; k++){
for(int i=k+1; i<n; i++){
for(int j=k+1; j<n; j++){
a.x[i][j]-=a.x[i][k]*a.x[k][j]/a.x[k][k];
}
}
}
double deter=1.0;
for(int i=0; i<n; i++){
deter*=a.x[i][i];
}
return deter;
}
//matriz inversa
static Matriz inversa(Matriz d){
int n=d.n; //dimensión de la matriz
Matriz a=(Matriz)d.clone();
Matriz b=new Matriz(n); //matriz de los términos independientes
Matriz c=new Matriz(n); //matriz de las incógnitas
//matriz unidad
for(int i=0; i<n; i++){
b.x[i][i]=1.0;
}
//transformación de la matriz y de los términos independientes
for(int k=0; k<n-1; k++){
for(int i=k+1; i<n; i++){
//términos independientes
for(int s=0; s<n; s++){
b.x[i][s]-=a.x[i][k]*b.x[k][s]/a.x[k][k];
}
//elementos de la matriz
for(int j=k+1; j<n; j++){
a.x[i][j]-=a.x[i][k]*a.x[k][j]/a.x[k][k];
}
}
}
//cálculo de las incógnitas, elementos de la matriz inversa
for(int s=0; s<n; s++){
c.x[n-1][s]=b.x[n-1][s]/a.x[n-1][n-1];
for(int i=n-2; i>=0; i--){
c.x[i][s]=b.x[i][s]/a.x[i][i];
for(int k=n-1; k>i; k--){
c.x[i][s]-=a.x[i][k]*c.x[k][s]/a.x[i][i];
}
}
}
return c;
}
//matriz traspuesta
static Matriz traspuesta(Matriz a){
int n=a.n; //dimensión
Matriz d=new Matriz(a.n);
for(int i=0; i<n; i++){
for(int j=0; j<n; j++){
d.x[i][j]=a.x[j][i];
}
}
return d;
}
//polinomio característico

public double[] polCaracteristico(){
Matriz pot=new Matriz(n);
//matriz unidad
for(int i=0; i<n; i++){
pot.x[i][i]=1.0;
}
double[] p=new double[n+1];
double[] s=new double[n+1];
for(int i=1; i<=n; i++){
pot=Matriz.producto(pot, this);
s[i]=pot.traza();
}
p[0]=1.0;
p[1]=-s[1];
for(int i=2; i<=n; i++){
p[i]=-s[i]/i;
for(int j=1; j<i; j++){
p[i]-=s[i-j]*p[j]/i;
}
}
return p;
}

public Matriz valoresPropios(double[] valores, int maxIter)throws ValoresExcepcion{
final double CERO=1e-8;
double maximo, tolerancia, sumsq;
double x, y, z, c, s;
int contador=0;
int i, j, k, l;
Matriz a=(Matriz)clone(); //matriz copia
Matriz p=new Matriz(n);
Matriz q=new Matriz(n);
//matriz unidad
for(i=0; i<n; i++){
q.x[i][i]=1.0;
}
do{
k=0; l=1;
maximo=Math.abs(a.x[k][1]);
for(i=0; i<n-1; i++){
for(j=i+1; j<n; j++){
if(Math.abs(a.x[i][j])>maximo){
k=i; l=j;
maximo=Math.abs(a.x[i][j]);
}
}
}
sumsq=0.0;
for(i=0; i<n; i++){
sumsq+=a.x[i][i]*a.x[i][i];
}
tolerancia=0.0001*Math.sqrt(sumsq)/n;
if(maximo<tolerancia) break;
//calcula la matriz ortogonal de p
//inicialmente es la matriz unidad
for(i=0; i<n; i++){
for(j=0; j<n; j++){
p.x[i][j]=0.0;
}
}
for(i=0; i<n; i++){
p.x[i][i]=1.0;
}
y=a.x[k][k]-a.x[l][l];
if(Math.abs(y)<CERO){
c=s=Math.sin(Math.PI/4);
}else{
x=2*a.x[k][l];
z=Math.sqrt(x*x+y*y);
c=Math.sqrt((z+y)/(2*z));
s=signo(x/y)*Math.sqrt((z-y)/(2*z));
}
p.x[k][k]=c;
p.x[l][l]=c;
p.x[k][l]=s;
p.x[l][k]=-s;
a=Matriz.producto(p, Matriz.producto(a, Matriz.traspuesta(p)));
q=Matriz.producto(q, Matriz.traspuesta(p));
contador++;
}while(contador<maxIter);

if(contador==maxIter){
throw new ValoresExcepcion("No se han podido calcular los valores propios");
}
//valores propios
//double[] valores=new double[n];
for(i=0; i<n; i++){
valores[i]=(double)Math.round(a.x[i][i]*1000)/1000;
}
//vectores propios
return q;
}

private int signo(double x){
return (x>0 ? 1 : -1);
}

public String toString(){
String texto="\n";
for(int i=0; i<n; i++){
for(int j=0; j<n; j++){
texto+="\t "+(double)Math.round(1000*x[i][j])/1000;
}
texto+="\n";
}
texto+="\n";
return texto;
}

}

class ValoresExcepcion extends Exception {

public ValoresExcepcion() {
super();
}
public ValoresExcepcion(String s) {
super(s);
}
}