M.R.U.V.

CLASE MATRIZ

public class Matriz {
public int numeroFilas;
public int numeroColumnas;
public double [][]matriz;

/**
* constructor sin parametros
*/
public Matriz(){//arreglo de filas y columnas
}

/**
* Constructor de parametros
* @param nF numero de Filas
* @param nC numero de Columnas
*/

public Matriz(int nF, int nC){

numeroFilas=nF;
numeroColumnas=nC;
matriz=new double[numeroFilas][numeroColumnas];//construyo un sitio para almacenar ceros
for(int i=0;i for(int j=0; j < numeroColumnas; j++)
matriz [i][j]=0;
}

/**
* Metodo de suma de matrices
* @param B primer sumando
* @return matriz resultado de suma
*/
public Matriz suma(Matriz b){
Matriz resultado;
//probar q el numero de fila y columnas de la primera matriz sea = al numero de
//filas y columnas de la segunda
//this referencia a un objeto que aun no esta creado pero que alguien algun momento lo va a crear
if((this.numeroFilas == b.numeroFilas)&& (this.numeroColumnas == b.numeroColumnas)){
resultado = new Matriz(this.numeroFilas, this.numeroColumnas);
for(int i=0; i < this.numeroFilas; i++)
for(int j=0; j < this.numeroColumnas; j++)
resultado.matriz[i][j] = this.matriz[i][j]+ b.matriz[i][j];
return resultado;
}
else
System.out.println("ERROR EN DIMENSIONES DE LAS MATRICES");
resultado=null;
return resultado;
}

/**
* Metodo de resta de matrices
* @return matriz resultado de resta
*/
public Matriz resta(Matriz b){
Matriz resultado;


if ((this.numeroFilas == b.numeroFilas)&(this.numeroFilas == b.numeroColumnas)){
resultado = new Matriz (this.numeroFilas,this.numeroColumnas);//construyo la caja donde almaceno el resultado
for(int i = 0;i for(int j=0;j resultado.matriz[i][j] = this.matriz[i][j]-b.matriz[i][j];
return resultado;
}

else{
System.out.println("ERROR EN DIMENSIONES DE LAS MATRICES");
resultado=null;
return resultado;
}
}


/**
* Metodo para transpuesta de una matriz
* @return
*/
//el numero de filas se cambia al numero de columnas

public Matriz Transpuesta(){
Matriz resultado;
resultado=new Matriz(this.numeroColumnas,this.numeroFilas);
for(int i=0; i < this.numeroFilas; i++)
for(int j=0; j < this.numeroColumnas; j++)
resultado.matriz[j][i]=this.matriz[i][j];
return resultado;
}

/**
* Metodo para multiplicaci�n entre matrices
* @return
*/
public Matriz Multiplicacion(Matriz b){
Matriz resultado;
if(this.numeroColumnas==b.numeroFilas){
resultado=new Matriz(this.numeroFilas, b.numeroColumnas);
for(int i=0; i < this.numeroFilas; i++){
for(int j=0; j < b.numeroColumnas; j++){
for(int k=0; k < this.numeroColumnas; k++)
resultado.matriz[i][j]+=this.matriz[i][k]*b.matriz[k][j];
}
}
return resultado;
}
else
System.out.println("ERROR EN DIMENSIONES DE LAS MATRICES");
resultado=null;
return resultado;
}


/**
* Devuelve el objeto matriz en texto
* @return
*/
public String toString(){
String aux="\n\n";
for(int i=0; i for(int j=0; j aux+=matriz[i][j]+" ";
}
aux+="\n";
}
aux+=" ";
return aux;
}

}
-----------------------------------------------------

CLASE VECTOR3D


public class Vector3D extends Matriz{

double coorX;
double coorY;
double coorZ;

public Vector3D(){//constructor de la clase
super(1,3);//llamo a la clase superior de la q estoy heredando
//es decir q llama a la clase matriz utilizando como datos
//2 parametros matriz[][]

}

public Vector3D(double x, double y, double z){
super(1,3);
this.matriz[0][0] = x;
this.matriz[0][1] = y;
this.matriz[0][2] = z;
coorX = x;
coorY = y;
coorZ = z;
}

/**
*Primer metodo para obtener la magnitud de un vector
*/

public double magnitud(){

double resultado = 0;
for(int i=0; i<3; i++){//menor a 3 por numero de coordenadas
resultado += this.matriz[0][i]*this.matriz[0][i];
}
resultado = Math.sqrt(resultado);
return resultado;
}

/**
*Segundo m�todo para obtener la magnitud de un vector
*/

public double magnitud1(){

double resultado;
resultado = Math.pow(this.coorX,2)+Math.pow(this.coorY,2)+Math.pow(this.coorZ,2);
resultado = Math.sqrt(resultado);
return resultado;
}



/**
*Obtener el unitario de un vector
*/
public Vector3D unitario(){
Vector3D unitario = new Vector3D();
for(int i=0; i<3; i++)
unitario.matriz[0][i] = this.matriz[0][i]/this.magnitud();
return unitario;
//unitario =(Vector3D)this.multiplicaEscalar(1/(this.magnitud()));
//(VECTOR3D)CASTING entre vector y matriz es valido porque son matrices
}

/**
*Producto escalar
*/

public double productoEscalar(Vector3D v){
double resultado = 0;
for(int i=0; i<3; i++)
resultado += this.matriz[0][i]*v.matriz[0][i];
return resultado;
}

/**
*Producto vectorial o cruz
*/

public Vector3D productoCruz(Vector3D v){
Vector3D resultado;
resultado = new Vector3D();
resultado.matriz[0][0] = this.matriz[0][1]*v.matriz[0][2]-this.matriz[0][2]*v.matriz[0][1];
resultado.matriz[0][1]=this.matriz[0][2]*v.matriz[0][0]-this.matriz[0][0]*v.matriz[0][2];
resultado.matriz[0][2]=this.matriz[0][0]*v.matriz[0][1]-this.matriz[0][1]*v.matriz[0][0];
return resultado;
}

public Vector3D productoVectorEscalar(double a){
Vector3D resultado;
resultado = new Vector3D();
for(int i = 0; i < 3; i++)
resultado.matriz[0][i] = this.matriz[0][i]*a;
return resultado;
}
public static void main(String args[]){

Vector3D v1 = new Vector3D(-1,1,-1);
Vector3D v2 = new Vector3D(0,2,0);


System.out.println("\nVector 1 = "+v1);
System.out.println("\nVector 2 = "+v2);
System.out.println("\nCoordenada en X= "+v1.coorX);
System.out.println("\nSuma de Vectores: "+(v1.suma(v2)));
System.out.println("\nMagnitud del Vector1 = "+v1.magnitud());
System.out.println("\nMagnitud del Vector1 = "+v1.magnitud1());
System.out.println("\nMagnitud del Vector2 = "+v2.magnitud1());
System.out.println("\nVector Unitario = "+v1.unitario());
System.out.println("\nComprobaci�n Vector Unitario = "+v1.unitario().magnitud());
System.out.println("\nProducto Escalar entre V1 y V2 = "+v1.productoEscalar(v2));
System.out.println("\nProducto Cruz entre V1 y V2 = "+v1.productoCruz(v2));

}

}

-----------------------------------------------

CLASE MRUV


public class MRUV {
Matriz posicion;//llamo a la clase matriz porq contiene las operciones q necesito
Matriz velocidad;
Matriz velocidad1;
Matriz aceleracion;
Matriz resultado;


/**
* Constructor sin parametros
*/
public MRUV(){

}

public MRUV(Vector3D pos, Vector3D vel, Vector3D ace, Vector3D res){
posicion = pos;
velocidad = vel;
aceleracion = ace;
resultado = res;

}

public void calcularPosicionMRUV(Vector3D r0, Vector3D vel, Vector3D v0,double t,Vector3D ace){

posicion = r0.suma(v0.productoVectorEscalar(t).suma(ace.productoVectorEscalar(Math.pow(t,2)/2)));

}


public void calcularVelocidadMRUV(Vector3D v0,double t,Vector3D r0,Vector3D ace){
velocidad = v0.suma(ace.productoVectorEscalar(t));
}


public static void main (String args []){
MRUV e = new MRUV();
Vector3D r0 = new Vector3D(1,0,-2);
Vector3D v0 = new Vector3D(0,1,0);//EN EL EJE Y
Vector3D v = new Vector3D(-2,0,1);
Vector3D a = new Vector3D(3,0,0);
double t = 2;

/**
*utilizando los metodos
*/
e.calcularPosicionMRUV(r0,v,v0,t,a);
e.calcularVelocidadMRUV(v0,t,r0,a);


System.out.println("Posicion a 2 segundos: "+e.posicion);
System.out.println("\nVelocidad a t = 2s\n"+e.velocidad);
System.out.println("\nAceleración = "+a);

}



}