MRUV (vectorialmente)

package mruv;

/**
*
* @author VICTOR
*/

public class Particula {
private Matriz DesplazamientoRealizado;
private Matriz velocidadInicial;
private Matriz aceleracion;

public Particula(){}

public Particula(Matriz dR, Matriz vI, Matriz a){
DesplazamientoRealizado = dR;
velocidadInicial = vI;
aceleracion = a;
}

public Matriz getDesplazamientoRealizado(){
return DesplazamientoRealizado;
}

public void setDesplazamientoRealizado(Matriz dR){
DesplazamientoRealizado = dR;
}

public Matriz getAceleracion(){
return aceleracion;
}

public void setAceleracion(Matriz a){
aceleracion = a;
}

public Matriz getVelocidadInicial(){
return velocidadInicial;
}

public void setVelocidadInicial(Matriz vI){
velocidadInicial = vI;
}



}


package mruv;

/**
*
* @author VICTOR
*/
public class MRUV {
public Particula particula;

public MRUV(){}

public MRUV(Matriz x0, Matriz v0, Matriz a){
particula = new Particula();
particula.setDesplazamientoRealizado(x0);
particula.setVelocidadInicial(v0);
particula.setAceleracion(a);
}

public Matriz calcularDesplazamiento(double t){
Matriz posicion;
Matriz x0, v0, a;
x0 = this.particula.getDesplazamientoRealizado();
posicion = new Matriz(x0.numeroFilas,x0.numeroColumnas);
v0 = this.particula.getVelocidadInicial();
a = this.particula.getAceleracion();

posicion = x0.suma(v0.multiplicaEscalar(t));

return posicion;
}

public Matriz calculoVelocidad(double t){
Matriz velocidad = particula.getVelocidadInicial();
return velocidad;
}

public Matriz calculoAceleracion(double t){
Matriz aceleracion = new Matriz(1,this.particula.getDesplazamientoRealizado().numeroColumnas);;
for(int i = 0; i < aceleracion.numeroFilas; i++)
for(int j = 0; j < aceleracion.numeroColumnas; j++)
aceleracion.matriz[i][j] = 0;
return aceleracion;
}

public static void main(String args[]){
Matriz x0 = new Matriz(1,3);
x0.matriz[0][0]=5; x0.matriz[0][1]=0; x0.matriz[0][2]=-5;

Matriz v0 = new Matriz(1,3);
v0.matriz[0][0]=13.61; v0.matriz[0][1]=15.83; v0.matriz[0][2]=0;

Matriz a = new Matriz(1,3);
a.matriz[0][0]=0; a.matriz[0][1]=0; a.matriz[0][2]=0;
MRUV m = new MRUV(x0,v0,a);

Matriz x;
x = m.calcularDesplazamiento(2);
Matriz v;
v = m.calculoVelocidad(2);
Matriz ac;
ac = m.calculoAceleracion(2);

System.out.println("la posicion inicial\n"+x0.imprimir());
System.out.println("la posicion final\n"+x.imprimir());
System.out.println("la velocidad inicial\n"+v0.imprimir());


}

}

MRUV

public class Particula {
private double distanciaRecorrida;
private double velocidadInicial;
private double velocidadFinal;
private double velocidadMedia;
//private static final double aceleracion=0.5;
private double aceleracion;


public Particula(){}

public Particula(double dR, double vM, double a){
distanciaRecorrida = dR;
velocidadMedia = vM;
aceleracion = a;
}

public double getdistanciaRecorrida(){
return distanciaRecorrida;
}

public void setdistanciaRecorrida(double pI){
distanciaRecorrida = pI;
}

public double getAceleracion(){
return aceleracion;
}

public void setAceleracion(double a){
aceleracion = a;
}

public double getVelocidadMedia(){
return velocidadMedia;
}

public void setVelocidadMedia(double vM){
velocidadMedia = vM;
}

public double getVelocidadInicial(){
return velocidadInicial;
}

public void setVelocidadInicial(double vI){
velocidadInicial = vI;
}

public double getVelocidadFinal(){
return velocidadFinal;
}

public void setVelocidadFinal(double vF){
velocidadFinal = vF;
}
}



public class MovRecUNi {
public Particula particula;

public MovRecUNi(){}

public MovRecUNi(double x0, double v0, double a, double vI){
particula.setdistanciaRecorrida(x0);
particula.setVelocidadMedia(v0);
particula.setAceleracion(a);
particula.setVelocidadInicial(vI);

}


public double calculoAceleracion(double t){
double aceleracion = particula.getVelocidadFinal()/t;
return aceleracion;
}

public double calculoVelocidad(double t){
double velocidad = particula.getVelocidadFinal()/2;
return velocidad;
}
public double calcularDistancia(double t){
double Distancia;
Distancia = particula.getVelocidadInicial()*t +particula.getAceleracion()*t*t*0.5;
return Distancia;
}


}


public class Prueba {
public static void main(String args[]){
Particula p = new Particula(0.0,0.0,0);
System.out.println(p.getdistanciaRecorrida());
p.setVelocidadInicial(0);
p.setVelocidadFinal(20.87);

System.out.println("Velocidad Inicial = "+p.getVelocidadInicial());
System.out.println("Velocidad final = "+p.getVelocidadFinal());

System.out.println("\n");
MovRecUNi m = new MovRecUNi();
m.particula=p;

System.out.println("Cuando t=120 segundos\n");
System.out.println("Aceleracion = "+m.calculoAceleracion(120));
System.out.println("Velocidad = "+m.calculoVelocidad(120));
System.out.println("La Distancia = "+m.calcularDistancia(120));


}

}

MRU

public class Prueba {
public static void main(String args[]){
Particula p = new Particula(0.0,0.0,0);
System.out.println(p.getPosicionInicial());
p.setVelocidadInicial(5);
p.setPosicionInicial(3);
p.setAceleracion(4);
System.out.println("Velocidad inicial = "+p.getVelocidadInicial());
System.out.println("Posicion inicial = "+p.getPosicionInicial());
System.out.println("Aceleracion = "+p.getAceleracion());
System.out.println("\n");
MovRecUNi m = new MovRecUNi();
m.particula=p;

System.out.println("Cuando t=5\n");
System.out.println("La Posicion = "+m.calcularPosicion(5));
System.out.println("Velocidad = "+m.calculoVelocidad(5));
System.out.println("Aceleracion = "+m.calculoAceleracion(5));




public class Particula {
private double posicionInicial;
private double velocidadInicial;
//private static final double aceleracion=0.5;
private double aceleracion;

public Particula(){}

public Particula(double pI, double vI, double a){
posicionInicial = pI;
velocidadInicial = vI;
aceleracion = a;
}

public double getPosicionInicial(){
return posicionInicial;
}

public void setPosicionInicial(double pI){
posicionInicial = pI;
}

public double getAceleracion(){
return aceleracion;
}

public void setAceleracion(double a){
aceleracion = a;
}

public double getVelocidadInicial(){
return velocidadInicial;
}

public void setVelocidadInicial(double vI){
velocidadInicial = vI;
}

}




public class MovRecUNi {
public Particula particula;

public MovRecUNi(){}

public MovRecUNi(double x0, double v0, double a){
particula.setPosicionInicial(x0);
particula.setVelocidadInicial(v0);
particula.setAceleracion(a);
}

public double calcularPosicion(double t){
double posicion;
posicion = particula.getPosicionInicial()+particula.getVelocidadInicial()*t +particula.getAceleracion()*t*t*0.5;
return posicion;
}

public double calculoVelocidad(double t){
double velocidad = particula.getVelocidadInicial()+ particula.getAceleracion()*t;
return velocidad;
}

public double calculoAceleracion(double t){
double aceleracion = particula.getAceleracion();
return aceleracion;
}

}

prueba

respuestas:

1.- x1= -1.0 ; x2= 2.0 ; x3= -3.0

2.- x1= 1.0 ; x2= 0.0 ; x3= 1.0 ; x4= 0.0 ; x5= 0.0 ;

3.- a + b = 4.0 + 2.0 + 4.0 ;

4.- a - b = 0.0 + 4.0 + 4.0 ;

5.- a'b = 4.0 -2.0 0.0
6.0 -3.0 0.0
8.0 -4.0 0.0

Sistema de Ecuaciones

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

public Matriz(){}

public Matriz(int nF, int nC){
numeroFilas = nF;
numeroColumnas = nC;
matriz = new double[numeroFilas][numeroColumnas];

for(int i = 0; i < numeroFilas; i++)
for(int j = 0; j < numeroColumnas; j++)
matriz[i][j] = 0;
}

public String imprimir1(){
String aux ="";

for(int i = 0; i < numeroFilas; i++){
for(int j = 0; j < numeroColumnas; j++){
aux = aux + matriz[i][j] +" ";
}
aux = aux + "\n";
}

return aux;
}

public String imprimir2(){
String aux ="";
aux=aux+"x1="+ matriz[0][0];
aux=aux+"\n";
aux=aux+"x2="+matriz[1][0];
return aux;
}


public Matriz multiplicacion(Matriz B){
if(this.numeroFilas==B.numeroColumnas){
Matriz r =new Matriz(this.numeroFilas,this.numeroColumnas);
int j;
int k;
for(int i=0;i

for(j=0;j
for(k=0;k

r.matriz[i][j]+=this.matriz[i][k]*B.matriz[k][j];

return r;
}
else{
Matriz r=new Matriz(1,1);
System.out.println("No esta definida la multiplicacion de estas matrices");
return r;
}
}
}

public Matriz inversa(){
Matriz result=new Matriz(this.numeroFilas,this.numeroColumnas);
double tmp;//variable temporal
Matriz I=new Matriz(this.numeroFilas,this.numeroColumnas*2);
for(int i=0;i
for(int j=0;j
I.matriz[i][j]=0.0;

for(int i=0;i
for(int j=0;j
I.matriz[i][j]=this.matriz[i][j];
if (i==j)
I.matriz[i][j+this.numeroFilas]=1.0;
}
}
for(int i=0;i
tmp=I.matriz[i][i];
for(int j=0;j<(this.numeroColumnas*2);j++)
I.matriz[i][j]/=tmp;
for(int k=0;k
if(k!=i){
tmp=I.matriz[k][i];
for(int j=0;j<(this.numeroColumnas*2);j++)
I.matriz[k][j]-=tmp*I.matriz[i][j];
}
}
}
for(int i=0;i
for(int j=0;j
result.matriz[i][j]=I.matriz[i][j+this.numeroColumnas];
return result;
}

public static void main(String args[]){

Matriz a=new Matriz(2,2);
a.matriz[0][0]=1;a.matriz[0][1]=1;
a.matriz[1][0]=-1;a.matriz[1][1]=2;
System.out.println("la matriz a es:");
System.out.println(a.imprimir1());

Matriz b=new Matriz(2,2);
b.matriz[0][0]=1;
b.matriz[1][0]=0;
System.out.println("la matriz b es:");
System.out.println(b.imprimir1());


Matriz resultado;

resultado=a.inversa();
System.out.println("la matriz inversa de a es:");
System.out.println(resultado.imprimir1());

resultado=a.inversa().multiplicacion(b);
System.out.println("las soluciones del sistema:");
System.out.println(" X1+ X2=1");
System.out.println("-X1+2X2=0");
System.out.println("son:");
System.out.println(resultado.imprimir2());
}

}

matriz inversa

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


public Matriz(int nF, int nC){
numeroFilas = nF;
numeroColumnas = nC;
matriz = new double[numeroFilas][numeroColumnas];
for(int i = 0; i < numeroFilas; i++)
for(int j = 0; j < numeroColumnas; j++)
matriz[i][j] = 0;

}

public String imprimir(){
String aux ="";
for(int i = 0; i < numeroFilas; i++){
for(int j = 0; j < numeroColumnas; j++){
aux = aux + matriz[i][j] +" "; }
aux = aux + "\n"; }
return aux; }


public Matriz inversa(){

Matriz c=new Matriz(this.numeroColumnas,this.numeroFilas);
c.matriz[1][0]=(((this.matriz[1][0]/this.matriz[1][0])*(this.matriz[0][0]))-(this.matriz[0][0]));
c.matriz[1][1]=(((this.matriz[1][1]/this.matriz[1][0])*(this.matriz[0][1]))-(this.matriz[0][1]));
c.matriz[0][1]=(((this.matriz[0][1]/this.matriz[0][1])*(this.matriz[1][1]))-(this.matriz[1][1]));
c.matriz[0][0]=(((this.matriz[0][0]/this.matriz[0][1])*(this.matriz[1][1]))-(this.matriz[0][0]));
return c;
}
public Matriz inversa2(){
Matriz d=new Matriz(this.numeroColumnas,this.numeroFilas);
d.matriz[1][0]=(((this.matriz[1][0]/this.matriz[1][0])*(this.matriz[0][0]))-(this.matriz[0][0]));
d.matriz[1][1]=(((this.matriz[1][1]/this.matriz[1][0])*(this.matriz[0][1]))-(this.matriz[0][1]));
d.matriz[0][1]=(((this.matriz[0][1]/this.matriz[0][1])*(this.matriz[1][1]))-(this.matriz[1][1]));
d.matriz[0][0]=(((this.matriz[0][0]/this.matriz[0][1])*(this.matriz[1][1]))-(this.matriz[0][0]));
return d;
}
public Matriz multiplicacion(Matriz e){

if((this.numeroFilas == e.numeroFilas)&(this.numeroColumnas == e.numeroColumnas)){
Matriz c = new Matriz(this.numeroFilas,this.numeroColumnas);
int j;
for(int i=0; ifor(j=0; jc.matriz[i][j]= this.matriz[i][j]*e.matriz[i][j];
return e;
} else{
Matriz r = new Matriz (1,1);
System.out.println("No se pueden multiplicar las matrices");
return r;
}

}

public Object clone(){
Matriz obj=null;
try{
obj=(Matriz)super.clone();
}catch(CloneNotSupportedException ex){
System.out.println(" no se puede duplicar");
}
obj.a=(int[][])obj.c.clone();
for(int i=0; i obj.c[i]=(int[])obj.c[i].clone();
}
return obj;
}

public static void main(String args[]){


Matriz a = new Matriz(2, 2);
a.matriz[0][0]=1;a.matriz[0][1]=-1;
a.matriz[1][0]=2;a.matriz[1][1]=1;

System.out.println("la matriz a es:");
System.out.println(a.imprimir());

Matriz b = new Matriz(2, 2);
b.matriz[0][0]=1;
b.matriz[1][1]=1;

System.out.println("la matriz b es:");
System.out.println(a.imprimir());

Matriz e = new Matriz(1, 1);
e.matriz[0][0]=3;
e.matriz[0][1]=4;

System.out.println("la matriz e es:");
System.out.println(a.imprimir());

}

}