|
|||||||
|
|
|
|||||
|
|
|||||||
|
|||||||
|
|
|
|||||
|
|
|||||||
En general en cinemática, se trabaja con vectores en función del tiempo.
Frecuentemente los vectores velocidad y posición cumplen con ésta característica, ya que muchas veces la aceleración
es constante.
En consecuencia, se diseñó un objeto que realizara operaciones básicas de un vector espacial, pensado para resolver algunos problemas de cinemática.
Básicamente, se maneja un arreglo de tipo Polinomio y otro de tipo double (ambos de tamaño tres) para administrar cálculo simbólico y numérico.
Constructor
Internamente crea dos arreglos , uno de tipo Polinomio y el otro de tipo double.public VectorEspacial( )
Constantes estáticas
Se definen cuatro constantes, que representan las dimensiones del vector espacial (tres) y la posición dentro del vector de las componentes genéricas : x , y , z.
public final static int DIMENSIONES = 3; public final static int X = 0; public final static int Y = 1; public final static int Z = 2;
Métodos
Estos tres primeros métodos se encargan se asignar y obtener los polinomios, según la posición de éstos dentro del vector.
public void asignarPolinomio(double coef[ ] , int posicion)
public Polinomio obtenerPolinomio(int posicion)
public void asignarPolinomio(Polinomio aux, int posicion)
Ej :
VectorEspacial aceleracion = new VectorEspacial();
double coefX[ ] = {0.0};
double coefY[ ] = {0.0};
double coefZ[ ] = {-9.8};
aceleracion.asignarPolinomio(coefX,aceleracion.X);
aceleracion.asignarPolinomio(coefY,aceleracion.Y);
aceleracion.asignarPolinomio(coefZ,aceleracion.Z);
Polinomio acel_X = aceleracion.obtenerPolinomio(aceleracion.X)
El método evaluar hace que se evalúen los tres polinomios en función de un valor pasado como parámetro. El método obtenerEvaluación retorna la referencia del arreglo que contiene los valores de la evaluación.
public void evaluar(double t) public double [ ]obtenerEvaluacion( )
Siendo consecuentes con la integración polinomial, aquí se extiende para los tres polinomios del vector.
public static VectorEspacial integrar(VectorEspacial ve , double cte[ ])
Algo muy importante que calcular en los vectores (numéricos) es su norma.
Para ello implementamos
dos métodos que realizan el cálculo, basado en un algoritmo eficiente , que evita problemas de
desbordamiento.
Ejemplo
Supongamos que tenemos el vector : { 450000 , 500000 , 800000 } . Si aplicamos la conocida
fórmula de la raíz cuadrada de la suma de los componentes al cuadrado , nos exponemos a un
overflow.
En cambio, éste algoritmo empieza buscando la mayor componente. Continúa formando las divisiones de los componentes
por el mayor elemento :
{ 450000 / 800000 , 500000 / 800000 , 800000/ 800000 }
{ 0.5625 , 0.625 , 1 }
Luego realiza la suma de los componentes al cuadrado y extrae raíz ( 1.3065 ). El cálculo finaliza multiplicando éste factor por el componente mayor ( 1045200 ).
private int coord_mayor( )
public double norma( )
Ej :
VectorEspacial aceleracion = new VectorEspacial( );
double coefX[ ] = {0.0};
double coefY[ ] = {0.0};
double coefZ[ ] = {-9.8};
aceleracion.asignarPolinomio(coefX,aceleracion.X);
aceleracion.asignarPolinomio(coefY,aceleracion.Y);
aceleracion.asignarPolinomio(coefZ,aceleracion.Z);
aceleracion.evaluar(0.56);
System.out.println("\n norma : " + aceleracion.norma( ));
Por último dos métodos que imprimen en pantalla el vector en forma polinómica o numérica.
public String toString(String var) public String toString( )
Implementación
class VectorEspacial
{
public final static int DIMENSIONES = 3;
public final static int X = 0;
public final static int Y = 1;
public final static int Z = 2;
private Polinomio p[ ];
private double arr[ ];
public VectorEspacial( )
{
p = new Polinomio[DIMENSIONES];
arr = new double[DIMENSIONES];
}
public void evaluar(double t)
{
for(int i = 0; i < DIMENSIONES ; i++)
arr[i] = p[i].evaluar(t);
}
public double [ ]obtenerEvaluacion( )
{
return arr;
}
public void asignarPolinomio(double coef[ ] , int posicion)
{
p[posicion] = new Polinomio(coef);
}
public Polinomio obtenerPolinomio(int posicion)
{
return p[posicion];
}
public void asignarPolinomio(Polinomio aux, int posicion)
{
p[posicion] = aux;
}
public static VectorEspacial integrar(VectorEspacial ve , double cte[ ])
{
VectorEspacial tmp = new VectorEspacial( );
for(int i = 0; i < DIMENSIONES; i++)
{
Polinomio aux = ve.obtenerPolinomio(i);
aux = Polinomio.integrar( aux , cte[i] );
tmp.asignarPolinomio(aux,i);
}
return tmp;
}
private int coord_mayor( )
{
int pos = X;
double mayor = arr[X];
for(int i = 1; i < DIMENSIONES; i++)
if (arr[i] > mayor)
{
mayor = arr[i];
pos = i;
}
return pos;
}
public double norma( )
{
double s = 1.0;
int mayor = coord_mayor( );
switch(mayor)
{
case X :
s += Math.pow(arr[Y] / arr[X],2);
s += Math.pow(arr[Z] / arr[X],2);
break;
case Y :
s += Math.pow(arr[X] / arr[Y],2);
s += Math.pow(arr[Z] / arr[Y],2);
break;
case Z :
s += Math.pow(arr[X] / arr[Z],2);
s += Math.pow(arr[Y] / arr[Z],2);
break;
}
return Math.sqrt(s) * Math.abs(arr[mayor]);
}
public String toString(String var)
{
String s = "( ";
for(int i = 0; i < DIMENSIONES; i++)
{
s += p[i].toString(var);
if (i == DIMENSIONES - 1)
s += " )";
else
s += " , ";
}
return s;
}
public String toString( )
{
String s = "( ";
for(int i = 0; i < DIMENSIONES; i++)
{
s += Double.toString(arr[i]);
if (i == DIMENSIONES - 1)
s += " )";
else
s += " , ";
}
return s;
}
/* --------------------------------------------- */
public static void main(String arg[ ])
{
VectorEspacial v = new VectorEspacial( );
double coefX[ ] = {3.5 , 2.0};
double coefY[ ] = {1.0 , 0.0 , 3.0};
double coefZ[ ] = {2.0 , 1.0};
v.asignarPolinomio(coefX ,v.X);
v.asignarPolinomio(coefY ,v.Y);
v.asignarPolinomio(coefZ ,v.Z);
System.out.println("\n\tPROGRAMA DE PRUEBA \n");
System.out.println("\tVector");
System.out.println("\t------");
System.out.println("\t" + v.toString("t"));
System.out.println("\n\tevaluaciones\t\t\t\tnorma");
System.out.println("\t------------\t\t\t\t-----");
for(int i = 0; i <= 10 ; i += 2)
{
v.evaluar(i);
System.out.print("\n\tP(" + i + ") = " + v.toString( ));
System.out.print("\t\t" + v.norma( ));
}
double coef[ ] = {-1.0,3.0,4.0};
v = v.integrar(v,coef);
System.out.println("\n\tIntegral");
System.out.println("\t--------");
System.out.println("\t" + v.toString("t"));
System.out.println( );
}
}
Bajar archivos