MRUV

package vectorial;
public class MRUVari{
public Particula particula;

public MRUVari(){}
public MRUVari(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());
}
}
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;
}}
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 String imprimir4(){
String aux ="";
aux="("+aux+ matriz[0][0]+"i"+" ";
aux=aux+matriz[0][1]+"j"+" ";
aux=aux+matriz[0][2]+"k"+")";
return aux;
}

MRU

package capsula;

/**
*
* @author Operador
*/

public class Particula {

private double distanciaRecorrida;
private double velocidadInicial;
private double velocidadFinal;
private double velocidadMedia;
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;
}
}
package capsula;

/**
*
* @author Operador
*/

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

Respuestas:

respuestas:
x1 + 2x2 + x3 =0
x1 +x2 = 1
-x1 -2x2= -3


x1= -1
x2= 2
x3= 3.

2.- x1= 1
x2= 0
x3= 1
x4= 0
x5= 0

3.- a + b = 4 + 2 + 4 ;

4.- a - b = 0 + 4 + 4 ;

5.- a transpuesta b = 4 -2 0
6 -3 0
8 -4 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 SE PUEDE OPERAR");
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 x=new Matriz(2,2);
x.matriz[0][0]=1;x.matriz[0][1]=1;
x.matriz[1][0]=-1;x.matriz[1][1]=2;
System.out.println("la matriz x es:");
System.out.println(x.imprimir1());
Matriz y=new Matriz(2,2);
y.matriz[0][0]=1;
y.matriz[1][0]=0;
System.out.println("la matriz y es:");
System.out.println(y.imprimir1());

matriz resultado;
resultado=x.inversa();
System.out.println("la matriz inversa de x es:");
System.out.println(resultado.imprimir1());
resultado=y.inversa().multiplicacion(y);
System.out.println("las soluciones del sistema:");
System.out.printlin();
System.out.println(resultado.imprimir2());
}

}