Mov Rect Unif Variado(mov de una particula)

package mruvescalar;

/**
*
* @author PaulLozada
*/
public class MruvEsc {
public Particula particula;

public MruvEsc (){}

public MruvEsc(double x0, double v0, double a){
particula.setPosicionInicial(x0);
particula.setVelocidadInicial(v0);
particula.setAceleracion(a);
}
public double calculoPosicion(double t){
double a;
a=particula.getPosicionInicial()+(particula.getVelocidadInicial()*t)+((particula.getAceleracion()/2));
return a;

}
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;
}
public static void main(String args[]){
Particula p=new Particula (0.0,0.0,0.0);

System.out.println("posicion inicial\n"+p.getPosicionInicial());
System.out.println("velocidad inicial\n"+p.getVelocidadInicial());
System.out.println("aceleracion\n"+p.getAceleracion());

p.setPosicionInicial(6);
p.setVelocidadInicial(4);
p.setAceleracion(5);
System.out.println("posicion inicial (modificada)\n"+p.getPosicionInicial());
System.out.println("velocidad inicial (modificada)\n"+p.getVelocidadInicial());
System.out.println("aceleracion (modificada)\n"+p.getAceleracion());

MruvEsc m = new MruvEscalar();

m.particula=p;
System.out.println("Posicion a; con t = 10\n"+m.calculoPosicion(10));
System.out.println("Velocidad a; con t = 10\n"+m.calculoVelocidad(10));
System.out.println("Aceleracion a; con t = 10\n"+m.calculoAceleracion(10));


}
}

//MRUV vectorial


/**
*
* @author PaulLozada
*/
public class CalcMruvVect {
public Particula particula;

public CalcMruvVect(){}

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

public Matriz calcularPosicion(double t){
Matriz aux,aux1,aux2,aux3,aux4;
aux=this.particula.getPosicionInicial();
aux1=this.particula.getVelocidadInicial();
aux2=aux1.clonar();
aux3=new Matriz(aux.numeroColumnas,aux.numeroFilas);
for(int i=0;i for(int j=0;j aux2.matriz[i][j]=aux2.matriz[i][j]*t;
}
}
aux3=aux.suma(aux2);
aux4=this.particula.getAceleracion();
aux2=aux4.clonar();
for(int i=0;i for(int j=0;j aux2.matriz[i][j]=(aux2.matriz[i][j]*t)/2;

}
}
aux3=aux3.suma(aux2);
return aux3;
}

public Matriz calculoVelocidad(double t){
Matriz velocidad = this.particula.getVelocidadInicial();
Matriz velocidad1 = this.particula.getAceleracion();
Matriz velocidad3;
Matriz velocidad2=velocidad.clonar();
for(int i=0;i for(int j=0;j velocidad2.matriz[i][j]=velocidad2.matriz[i][j]*t;
}
}
velocidad3=velocidad.suma(velocidad2);
return velocidad3;
}

public Matriz calculoAceleracion(double t){
Matriz aceleracion=particula.getAceleracion();
return aceleracion;
}
public static void main(String args []){
Particula p = new Particula();
Matriz ini = new Matriz(1,3);
Matriz ini1 = new Matriz(1,3);
Matriz ini2 = new Matriz(1,3);
Matriz r;

ini.matriz[0][0]=2;
ini.matriz[0][1]=2;
ini.matriz[0][2]=2;
p.setPosicionInicial(ini);
r=p.getPosicionInicial();
System.out.println("posicion inicial=\n"+r.imprimir());

ini1.matriz[0][0]=4;
ini1.matriz[0][1]=5;
ini1.matriz[0][2]=6;
p.setVelocidadInicial(ini1);
r=p.getVelocidadInicial();
System.out.println("velicidad inicial=\n"+r.imprimir());

ini2.matriz[0][0]=4;
ini2.matriz[0][1]=4;
ini2.matriz[0][2]=4;
p.setAceleracion(ini2);
r=p.getAceleracion();
System.out.println("aceleracion =\n"+r.imprimir());

CalcMruvVect m = new CalcMruvVect(ini,ini1,ini2);
Matriz a;
a=m.calcularPosicion(5);
System.out.println("posicion final\n"+a.imprimir());

a=m.calculoVelocidad(2);
System.out.println("velocidad final\n"+a.imprimir());
}
}

//MRU escalar

package mruescalar;

/**
*
* @author PaulLozada
*/
public class MruEscalar {


public Particula particula;

public MruEscalar (){}

public MruEscalar(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;
return posicion;
}

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

public double calculoAceleracion(double t){
double aceleracion = 0;
return aceleracion;
}

}

//MRU vectorial

package mruescalar;

/**
*
* @author Administrador
*/
public class Prueba {
public static void main(String args[]){
Particula p=new Particula (0.0,0.0,0.0);

System.out.println("posicion inicial\n"+p.getPosicionInicial());
System.out.println("velocidad inicial\n"+p.getVelocidadInicial());
System.out.println("aceleracion\n"+p.getAceleracion());

p.setPosicionInicial(6);
p.setVelocidadInicial(4);
p.setAceleracion(5);
System.out.println("posicion inicial (modificada)\n"+p.getPosicionInicial());
System.out.println("velocidad inicial (modificada)\n"+p.getVelocidadInicial());
System.out.println("aceleracion (modificada)\n"+p.getAceleracion());

MruEscalar m = new MruEscalar();

m.particula=p;
System.out.println("Posicion a; con t = 10\n"+m.calcularPosicion(10));
System.out.println("Velocidad a; con t = 10\n"+m.calculoVelocidad(10));
System.out.println("Acwlwracion a; con t = 10\n"+m.calculoAceleracion(10));


}

}

mov de una particula

public class Prueb {
public static void main(String args[]){
Particula p=new Particula(0.0,0.0,0.0);
//System.out.println(p.getPosicionInicial());
p.setVelocidadInicial(5);
p.setPosicionInicial(2.5);
p.setAceleracion(0);
System.out.println("Velocidad Inicial\n"+p.getVelocidadInicial());
System.out.println("Posicion Inicial\n"+p.getPosicionInicial());

MovRecUni m= new MovRecUni();
m.particula=p;
System.out.println("Posición final a t=5 \n"+m.calcularPosicion(5));
System.out.println("Velocidad a t=5\n"+m.calculoVelocidad(5));
System.out.println("aceleracion a t=5\n"+m.calcularAceleracion(5));

p.setVelocidadInicial(10);
p.setPosicionInicial(5);
p.setAceleracion(10);
System.out.println("Velocidad Inicial\n"+p.getVelocidadInicial());
System.out.println("Posicion Inicial\n"+p.getPosicionInicial());


MovRuv n= new MovRuv();
n.particula=p;
System.out.println("POSICION final a t=5 \n"+n.calcularPosicionFinal(5));
System.out.println("Velocidad final a t=5\n"+n.calculoVelocidadFinal(5));
System.out.println("aceleracion a t=5\n"+n.calcularAceleracion(5));



}


}









public class Particula {
private double posicionInicial;
private double velocidadInicial;



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;
}



}


//MRU

public class MovRecUni {

public Particula particula;
public MovRecUni(){}
public MovRecUni(double x0,double v0,double a){

//estos valores cargo a la particula p
particula.setPosicionInicial(x0);
particula.setVelocidadInicial(v0);
particula.setAceleracion(a);
}
public double calcularPosicion(double t){
double posicion;
posicion=particula.getPosicionInicial()+particula.getVelocidadInicial()*t;
return posicion;
}
public double calculoVelocidad(double t){
double velocidad=particula.getVelocidadInicial();
return velocidad;
}



public double calcularAceleracion(double t){
double aceleracion=0;

return aceleracion;}





}



//MRUV



public class MovRuv {
public Particula particula;
public MovRuv(){}
public MovRuv(double x0,double v0,double a){

//estos valores cargo a la particula p
particula.setPosicionInicial(x0);
particula.setVelocidadInicial(v0);
particula.setAceleracion(a);
}
public double calcularPosicionFinal(double t){
double posicion;
posicion=particula.getPosicionInicial()+particula.getVelocidadInicial()*t+(0.5*particula.getAceleracion()*t*t);
return posicion;
}
public double calculoVelocidadFinal(double t){
double velocidad=particula.getVelocidadInicial()+particula.getAceleracion()*t;
return velocidad;
}



public double calcularAceleracion(double t){
double aceleracion=particula.getAceleracion();

return aceleracion;}





}

resultados prueba

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


a+b.- 4.0 2.0 4.0

a-b.- 0.0 4.0 4.0

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

resolucion de ecuacion(matriz)

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

/**
*
* @author Paul Lozada
*/
public class Ecuacion {
int numeroFilas;
int numeroColumnas;
double [][] ecuacion;

public Ecuacion(){}

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

}

public String print(){
String aux="";
for(int i=0;i for(int j=0;j aux=aux+" "+ecuacion[i][j]+"";
}
aux=aux+"\n";
}
return aux;
}

public Ecuacion EcuacionSistema(){
Ecuacion resul=new Ecuacion(1, 1);
double aux=1,aux2=1;
for(int i=0;i for(int j=0;j if(i==j)
aux=this.ecuacion[i][j]*aux;
if(i!=j)
aux2=this.ecuacion[i][j]*aux2;
}

}
resul.ecuacion[0][0]=aux-aux2;
return resul;

}

public Ecuacion EcuacionX1(Ecuacion B){
Ecuacion resul= new Ecuacion(this.numeroFilas,this.numeroColumnas);
for(int i=0;i for(int j=0;j resul.ecuacion[i][j]=this.ecuacion[i][j];
}
for(int i=0;i for(int j=0;j<1;j++){
resul.ecuacion[i][j]=B.ecuacion[i][j];
}
return resul;
}

public Ecuacion EcuacionX2(Ecuacion B){
Ecuacion resul= new Ecuacion(this.numeroFilas,this.numeroColumnas);
for(int i=0;i for(int j=0;j resul.ecuacion[i][j]=this.ecuacion[i][j];
}
for(int i=0;i for(int j=1;j<2;j++){
resul.ecuacion[i][j]=B.ecuacion[i][0];
}
return resul;
}
public Ecuacion calcular(Ecuacion respuesta){
double aux;
Ecuacion r=new Ecuacion(1, 1);
r.ecuacion[0][0]=this.ecuacion[0][0]/respuesta.ecuacion[0][0];
return r;
}


public static void main(String args[]){
Ecuacion a=new Ecuacion(2, 2);
Ecuacion resultado;
Ecuacion respuesta;

a.ecuacion[0][0]=1;
a.ecuacion[0][1]=1;
a.ecuacion[1][0]=-1;
a.ecuacion[1][1]=2;
Ecuacion b=new Ecuacion(2,1);
b.ecuacion[0][0]=1;
b.ecuacion[1][0]=0;

System.out.println("este prgrama resuelve el siguiente sistema de ecuaciones\n X1 + X2 = 0" +
"\n-X1 + 2 X2 = 0");
resultado=a.EcuacionSistema();
System.out.println("sistema de ecuaciones (coeficientes numéicos):\n"+a.print());
System.out.println(" respuesta="+resultado.print());
respuesta=resultado;

resultado=a.EcuacionX1(b);
System.out.println("determinante del sitema en funcion de x1");
System.out.println(resultado.print());
resultado=resultado.EcuacionSistema();
System.out.println(" respuesta="+resultado.print());
resultado=resultado.calcular(respuesta);
System.out.println("la variable X1 es igual a: "+resultado.print());

resultado=a.EcuacionX2(b);
System.out.println("determinante del sitema en funcion de x2");
System.out.println(resultado.print());
resultado=resultado.EcuacionSistema();
System.out.println(" respuesta="+resultado.print());
resultado=resultado.calcular(respuesta);
System.out.println("la variable X2 es igual a: "+resultado.print());
System.out.println("");



author Paul Lozada



}

}

Para resolver ecuaciones (Matrices)

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 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 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 r=new Matriz(this.numeroColumnas,this.numeroFilas);
r.matriz[0][0]=this.matriz[1][1]/((this.matriz[0][0]*this.matriz[1][1])-(this.matriz[0][1]*this.matriz[1][0]));

r.matriz[0][1]=-1*this.matriz[0][1]/((this.matriz[0][0]*this.matriz[1][1])-(this.matriz[0][1]*this.matriz[1][0]));

r.matriz[1][0]=-1*this.matriz[1][0]/((this.matriz[0][0]*this.matriz[1][1])-(this.matriz[0][1]*this.matriz[1][0]));

r.matriz[1][1]=this.matriz[0][0]/((this.matriz[0][0]*this.matriz[1][1])-(this.matriz[0][1]*this.matriz[1][0]));

return r;
}

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 c=new Matriz(2,2);
c.matriz[0][0]=3;c.matriz[1][0]=-4;
System.out.println("la matriz C es:");
System.out.println(c.imprimir());

Matriz resultado;
System.out.println(resultado.imprimir());

/* Impresion de resultados-------

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

resultado=a.multiplicacion(c);
System.out.println("la matriz producto axc es:");
System.out.println(resultado.imprimir());

resultado=a.inversa().multiplicacion(c);
System.out.println("las soluciones del sistema son:");
System.out.println(resultado.imprimir());
}
}