SUMA MATRICES

package javaapplication1;

/**
*
*
*/
import javax.swing.JOptionPane;
import java.text.DecimalFormat;

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

public Matriz(){
}

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 < numeroFilas;i++)
for(int j=0; j < numeroColumnas; j++)
matriz [i][j]=0;
}

public Matriz suma(Matriz b){
Matriz resultado;
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 < 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 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;
}

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

public void leer(){
String aux;
for(int i=0; i < this.numeroFilas; i++){
for(int j=0; j < this.numeroColumnas; j++){
aux = JOptionPane.showInputDialog(null,"INGRESO DE VALORES","INGRESE EL VALOR: "+(i+1)+","+(j+1),JOptionPane.DEFAULT_OPTION);
this.matriz[i][j]=Double.parseDouble(aux);
}
}
}

public String toString(){

String aux="\n";
DecimalFormat df = new DecimalFormat("0.0000");
for(int i=0; i < numeroFilas; i++){
for(int j=0; j < numeroColumnas; j++){
aux+=df.format(matriz[i][j])+" ";
}
aux+="\n";
}
aux+=" ";
return aux;
}
}

_____________________________________________________________________________________

public class Matriz {
public int numeroFilas;
public int numeroColumnas;
public double [][]matriz;
public Matriz(){}//nF es el numero de filas//nc es el numero de columnas
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;}//metodo de suma de matricespublic Matriz suma(Matriz b){Matriz resultado;//primero revisamos que las filas y las columnas sean iguales//
this referencia a un objeto que au 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<= b.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 multiplicacion de matrices//retorna una matriz resultado resta

public Matriz multiplicacion(Matriz b) {
Matriz resultado;
if(this.numeroFilas == b.numeroColumnas){

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 para poderlo imprimir
}
public String toString(){
String aux="\n[\n";
for(int i=0; i<= this.numeroFilas; i++)
for(int j=0; j<= this.numeroColumnas; j++)
aux += matriz[i][j]+" ";
aux +="\n";aux+= "]";return aux;}
}

MOVIMIENTO RECTLINEO UNFORMEMENTE VARIADO

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

/**
*
* @author program
*/
public class MovRecUniVar {

Matriz posicion;
Matriz velocidad;
Matriz aceleracion;

public MovRecUniVar(){

}

public MovRecUniVar(Vector3D pos, Vector3D velo, Vector3D ace){
posicion = pos;
velocidad = velo;
aceleracion = ace;
}

public void calculaPosición(Vector3D r0, Vector3D vel,Vector3D a,double t){
posicion = r0.suma(vel.productoVectorEscalar(t)).suma(a.productoVectorEscalar(Math.pow(t,2)/2));

}

public void calculaVelocidad(Vector3D vel0, Vector3D a, double t){
velocidad = vel0.suma(a.productoVectorEscalar(t));

}

public void calculaAceleracion(Vector3D vel, Vector3D vel0, double t){

//aceleracion = a;
aceleracion = (vel.productoVectorEscalar(Math.pow(1,1)/2)).resta(vel0.productoVectorEscalar(Math.pow(1,1)/2));
}
public static void main(String args[]){
MovRecUniVar m = new MovRecUniVar();
Vector3D r0 = new Vector3D(5,0,0);
Vector3D v0 = new Vector3D(0,0,0);
Vector3D a = new Vector3D(3,0,0);
Vector3D v = new Vector3D(10,0,0);
double t = 2;

m.calculaPosición(r0, v0, a, t);
m.calculaVelocidad(v0,a, t);
m.calculaAceleracion(v,v0,t);

System.out.println("Posicion a los 2s para r0 = \n " +m.posicion+
"\nvelocidad a t = 2s\n"+m.velocidad+"\n aceleracion\n"+m.aceleracion );
}

}

APPLETS

El applet es una aplicación que puede ser ejecutada dentro de otro programa como por ejemplo en una pagina web. Para poder ejecutarse debe existir un contenedor o un programa anfitrion o algun dispositivo que soporte la programacion de applet como por ejemplo telefonos moviles.
Un ejemplo de applet son los Java applets que son aplicaciones escritas en lenguaje java y pueden ser ejecutados desde cualquier programa que soporte java como el Internet Explorer o Mozilla Firefox y que utilicen el Java Viertual Machine.
El Java applet es un subprograma que puede ser escrito para que cualquier usuario lo utilice con solo cargar un apagina web, ya que esta aplicación puede ser incrustado dentro de un documento HTML.
Las ventajas que tiene un applet es que puede ejecutarse en cuanlquier sistema operativo, utiliza cualquier version de java, se ejecuta en la mayoria de naveadores web, su velocidad es comparable con la de otros programas que son compilados como C.

CICLO DE VIDA

Para que un applet se inicie se llama los siguientes metodos en el siguiente orden:
1. Init: Aquí estan almacenadas las instrucciones para inicializar el applet.
2. Start: al igual que init tambien tiene instrucciones pa inicializar pero tambien es llamada cuando se reinicia el applet.
3. Paint: muestra en pantalla los contenidos del applet, cada vez que se redibuja en la pantalla es llamado este metodo.
4. Stop: se llama cuando se detiene el programa o se ha dejado de utilizar en algun tiempo. Detiene las tareas que arranca start.
5. Destroy: Se usa para liberar espacio y recursos cuando ya no se va a utilizar el applet. Se llama cuando se ha cerrado el navegador.

PRODUCTO CRUZ

* @author JAVIER ILVAY
*/
public class Vector3D extends Matriz{
double coorX;
double coorY;
double coorZ;

public Vector3D (){
super(1,3);
}
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] = x;
coorX=x;
coorY=y;
coorZ=z;

}

public double magnitud(){
double resultado = 0;
//double suma;
for(int i = 0; i < 3;i++){
resultado+=this.matriz[0][i]*this.matriz[0][i];
}
resultado = Math.sqrt(resultado);
return resultado;
}

public double magnitud1(){
double resultado;
resultado = this.coorX*this.coorX+this.coorY*this.coorY+this.coorZ*this.coorZ;
resultado= Math.sqrt(resultado);
return resultado;
}

public Vector3D unitario(){
Vector3D unitario = new Vector3D();
//unitario = (Vector3D)this.multiplicacionEscalar(1/(this.magnitud()));
for (int i = 0 ; i < 3; i++){
unitario.matriz[0][i] = this.matriz[0][i]/this.magnitud();
}
return unitario;
}

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;
}
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 static void main(String args[]){
Vector3D v1 = new Vector3D(-1,1,-1);
Vector3D v2 = new Vector3D(0,2,0);
System.out.println(v1);
System.out.println(v1+"\n"+v2+"\n suma "+(v1.suma(v2)));
System.out.println("Coordenada en x "+v1.coorX);
System.out.println(v1.magnitud()+"\n"+v1.magnitud1());
System.out.println(v1.unitario());
System.out.println(v1.productoEscalar(v2));
System.out.println(v1.productoCruz(v2));
}

}

PRUEBA

************CLASE MATRIZ*************
* @author JAVIER ILVAY
*/
public class Matriz1 {
public int numeroFilas;
public int numeroColumnas;
public double [][] matriz;

public Matriz1(){
}
/**
* Constructor con parametros
* @param nF numero de filas
* @param nC numero de columnas
*/
public Matriz1(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;

}



/**
* metodo para transpuesta matriz
* @return
*/
public Matriz1 transpuesta(){
Matriz1 resultado;
resultado= new Matriz1(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;

}
public Matriz1 multiplicacion(Matriz1 b){
Matriz1 resultado;

if(this.numeroColumnas == b.numeroFilas){
resultado=new Matriz1(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;
}


public String toString(){
String aux="";
for (int i=0; i< numeroFilas; i++){
for( int j=0; j< numeroColumnas;j++) {

aux += matriz[i][j]+" ";
}
aux += "\n";
}
aux +=" ";
return aux;
}
}

*********************CLASE PRUEBA*******************************

* @author JAVIER ILVAY
*/
public class Prueba {
public static void main(String args[]){
Matriz1 C = new Matriz1 (2,3);
C.matriz[0][0]=2;
C.matriz[0][1]=2;
C.matriz[0][2]=1;
C.matriz[1][0]=3;
C.matriz[1][1]=-1;
C.matriz[1][2]=0;

System.out.println(C.toString());

Matriz1 B = new Matriz1 (5,3);
B.matriz[0][0]=6;
B.matriz[0][1]=-2;
B.matriz[0][2]=5;
B.matriz[1][0]=4;
B.matriz[1][1]=2;
B.matriz[1][2]=-1;
B.matriz[2][0]=0;
B.matriz[2][1]=1;
B.matriz[2][2]=1;
B.matriz[3][0]=-2;
B.matriz[3][1]=-2;
B.matriz[3][2]=0;
B.matriz[4][0]=1;
B.matriz[4][1]=0;
B.matriz[4][2]=-1;
System.out.println(B.toString());

Matriz1 E= new Matriz1 (3,3);
E.matriz[0][0]=-1;
E.matriz[0][1]=0;
E.matriz[0][2]=-1;
E.matriz[1][0]=1;
E.matriz[1][1]=0;
E.matriz[1][2]=1;
E.matriz[2][0]=-1;
E.matriz[2][1]=1;
E.matriz[2][2]=-1;
System.out.println(E.toString());

Matriz1 A= new Matriz1 (1,5);
A.matriz[0][0]=1;
A.matriz[0][1]=-1;
A.matriz[0][2]=0;
A.matriz[0][3]=1;
A.matriz[0][4]=1;
System.out.println(A.toString());




Matriz1 r;
r=B.transpuesta();
Matriz1 R;
R=C.multiplicacion(E);
Matriz1 R1;
R1=R.multiplicacion(r);
System.out.println("la multiplicacion C*E*B^t\n"+R1.toString());

R1=(A.multiplicacion(B)).multiplicacion(E);
System.out.println("la multiplicacion CEB^t\n"+R1.toString());


R1=(E.multiplicacion(r)).multiplicacion(A.transpuesta());
System.out.println("la multiplicacion CEB^t\n"+R1.toString());

}

}
*********************RESPUESTAS**************************************



la multiplicacion C*E*B^T
[-13.0 -1.0 0.0 0.0 0.0
-44.0 -12.0 -4.0 8.0 0.0 ]

la multiplicacion ABE

[-12.0 5.0 -12.0 ]

la multiplicacion E*B^T*A^T
[-6.0
6.0
-12.0 ]

FIGURAS (CUADRADO, TRIANGULO)

FIGURAS
* @author JAVIER ILVAY
*/
public class Figuras {
public int numeroLados;


public Figuras(){

}
public void setFiguras(int nL){
numeroLados=nL;

}
public Figuras(int nL){
setFiguras(nL);
}
public int getNumeroLados(){//el usuario pueda ver las coordenadas
return numeroLados; //get: obtiene valores

}

}

CUADRADO*****************************************************************

* @author JAVIER ILVAY
*/
public class Cuadrado extends Figuras {
private double valorLado;


public Cuadrado(){

}

public Cuadrado(int nL, double vL){
super(nL);
setValorLado(vL);
}

public void setValorLado(double vL){
valorLado = vL;

}

public double getValorLado(){
return valorLado;
}
public static void main(String args[]){
Cuadrado t1 = new Cuadrado(4,4);
System.out.println("EL LADO DEL CUADRADO ES: "+t1.getValorLado());

}


}

TRIANGULO*******************************************************************
* @author JAVIER ILVAY
*/
public class Triangulo extends Figuras{
private double valorLado;
private double valorAltura;


public Triangulo(){

}

public Triangulo(int nL, double vL, double vA){
super(nL);
setValorLado(vL);
setValorAltura(vA);
}

public void setValorLado(double vL){
valorLado = vL;

}

public double getValorLado(){
return valorLado;
}
public void setValorAltura(double vA){
valorAltura = vA;

}

public double getValorAltura(){
return valorAltura;
}
public static void main(String args[]){
Triangulo t1 = new Triangulo(3,4,2);
System.out.println("EL LADO DEL TRIANGULO ES: "+t1.getValorLado());
System.out.println("EL VALOR DE LA ALTURA DEL TRIANGULO ES: "+t1.getValorAltura());

}


}

MULTIPLICACION DE MATRICES

public class Matriz {
public int numeroFilas;
public int numeroColumnas;
public double [][] matriz;
/**
* Constructor sin parametros
*/
public Matriz(){

}
/**
* constructor con 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];

for(int i=0;i for(int j=0; j matriz[i][j]=0;
}

/**
* Metodo de suma de matrices
* @param B= sumando
* @return= una matriz resultado de sumar dos matrices
*/
public Matriz suma(Matriz B){
Matriz resultado;
if(this.numeroFilas==B.numeroFilas
&this.numeroColumnas==B.numeroColumnas){

resultado=new Matriz(this.numeroFilas,this.numeroColumnas);
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 la dimension de las matrices");
resultado=null;
return resultado;

}

}
/**
* METODO RESTA DE MATRICES
* @param B SUSTRAENDO
* @return
*/
public Matriz resta(Matriz B){
Matriz resultado;
if(this.numeroFilas==B.numeroFilas
&this.numeroColumnas==B.numeroColumnas){

resultado=new Matriz(this.numeroFilas,this.numeroColumnas);
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 la dimension de las matrices");
resultado=null;
return resultado;

}
}
public Matriz Multiplicacion(Matriz D){
Matriz mult;
if(this.numeroFilas==D.numeroColumnas){
mult=new Matriz(this.numeroColumnas,D.numeroFilas);
for(int i=0; i for(int j=0; j mult.matriz[i][j]=0.0;
for(int k=0;k mult.matriz[i][j]+=this.matriz[i][k]*D.matriz[k][j];
}

}
}
return mult;
}
else{
System.out.println("Error en la dimension de las matrices");
mult=null;
return mult;
}
}
/**
* devulelve el objeto matriz en texto
* @return
*/
public String toString(){
String aux = "[";
for(int i=0; i for(int j=0; j aux+=matriz[i][j]+" ";
}
aux+="\n";
}
aux+= "]";
return aux;
}