|
|||||||
|
|
|
|||||
|
|
|||||||
|
|||||||
|
|
|
|||||
|
|
|||||||
Para la construcción y el manejo de polinomios de grado N, se usó en ésta implementación
un arreglo de tamaño (N + 1).
La idea principal es que en cada posición, se almacena el coeficiente correspondiente al grado
de la variable.
Por ejemplo, el polinomio que vemos en el programa de prueba , tiene asignado como arreglo
lo siguiente : { -3.0 , 6.0 , 9.0 , 4.0 }.
Constructores
Se implementaron dos constructores, que básicamente manejaran la asignación de coeficientes o creación del arreglo. El constructor recomendado , es el que recibe como parámetro un arreglo de coeficientes de tipo double. En cambio, si se usa el primero, se tendrá que llamar al método asignarCoeficientes para hacer la asignación.
public Polinomio(int grado)
public Polinomio(double coef[])
Ej :
Polinomio p = new Polinomio(5);
double coeficientes[] = { 4.0 , -2.0 , 1.5 };
Polinomio b = new Polinomio(coeficientes);
Métodos
El primer método asigna los coeficientes del
polinomio a través de un arreglo.
A través del segundo método, obtenemos la referencia al arreglo (privado)
de coeficientes del objeto.
public void asignarCoeficientes(double coef[])
public double []obtenerCoeficientes()
Ej :
double coef[] = { -2.0 , -5.3 , 0.6 };
Polinomio c = new Polinomio(2);
c.asignarCoeficientes(coef);
double aux[] = c.obtenerCoeficientes();
for(int i = 0; i < aux.length ; i++)
System.out.print("\t" + aux[i]);
Los dos siguientes métodos, asignan y obtienen los elementos, en función de la posición del arreglo.
public double obtenerCoef(int posicion)
public void asignarCoef(int posicion, double valor)
Ej :
Polinomio c = new Polinomio(1);
c.asignarCoef(0 , 3.0);
c.asignarCoef(1 , -4.5 );
System.out.println("primer coeficiente : " + c.obtenerCoef(0));
Una de las operaciones fundamentales que se realizan sobre polinomios, es el de evaluarlo. Para ésto se implementó un método que recibe como parámetro un valor de tipo double.
public double evaluar(double t)
Ej :
double coef[] = { -5.0 , 7.0 };
Polinomio d = new Polinomio(coef);
System.out.println("p(4.0) : " + d.evaluar(4.0));
Para recorrer todos los elementos del arreglo en forma externa , hay que usar un índice que comience en cero y se incremente mientras sea menor o igual al grado del polinomio. Justamente para conocer ese grado , se implementa el siguiente método :
public int obtenerGrado()
Ej :
Polinomio s = new Polinomio(3);
for(int i = 0; i <= s.obtenerGrado(); i++)
s.asignarCoef( i , (double) i*10);
Otra operación común que se realiza sobre un polinomio, es el de la integración.
Para esto se implementa el método estático integrar que requiere de un objeto de tipo
Polinomio (que no se altera como parámetro) y un valor constante (necesario en procesos de integración numérica).
Este método, retorna un nuevo objeto (referencia) de tipo Polinomio, razón por la cual se implementó como
estático.
public static Polinomio integrar(Polinomio c, double cte)
Ej :
double coefs[ ] = { 3.5 , 2.5 , -7.5 , 1.0 };
Polinomio p = new Polinomio(coefs);
Polinomio i = p.integrar(p,5.0);
Polinomio t = Polinomio.integrar(p,3.0);
Ya que implementamos un método para integrar, también lo hacemos para derivar.
public static Polinomio derivar(Polinomio c)
Ej :
double coefs[ ] = { 3.5 , 2.5 , -7.5 , 1.0 };
Polinomio p = new Polinomio(coefs);
Polinomio d = p.derivar(p);
Por último, y aunque no era fundamentalmente necesario, se implementó un método que retorna el string correspondiente al polinomio. El usuario final de la clase, podrá asignar como parámetro , el String que represente a la variable.
public String toString(String var)
Ej :
double coefs[ ] = { 3.0 , 1.4 , 2.9 };
Polinomio p = new Polinomio(coefs);
System.out.println("p(t) : " + p.toString("t"));
Implementación
class Polinomio
{
private double arr[];
public Polinomio(int grado)
{
arr = new double[grado + 1];
}
public Polinomio(double coef[])
{
this(coef.length - 1);
for(int i = 0; i < coef.length; i++)
arr[i] = coef[i];
}
public void asignarCoeficientes(double coef[])
{
for(int i = 0; i < coef.length; i++)
arr[i] = coef[i];
}
public double []obtenerCoeficientes()
{
return arr;
}
public double obtenerCoef(int posicion)
{
return arr[posicion];
}
public void asignarCoef(int posicion, double valor)
{
arr[posicion] = valor;
}
public double evaluar(double t)
{
double s = 0.0;
for(int i = 0; i < arr.length; i++)
s += arr[i] * Math.pow(t,i);
return s;
}
public int obtenerGrado()
{
return arr.length - 1;
}
public static Polinomio integrar(Polinomio c, double cte)
{
Polinomio tmp = new Polinomio(c.obtenerGrado() + 1);
tmp.asignarCoef(0,cte);
for(int i = 1; i <= tmp.obtenerGrado() ; i++)
tmp.asignarCoef(i , c.obtenerCoef(i-1) / i );
return tmp;
}
public static Polinomio derivar(Polinomio c)
{
Polinomio tmp = new Polinomio(c.obtenerGrado() - 1);
for(int i = 0; i <= tmp.obtenerGrado() ; i++)
tmp.asignarCoef(i , c.obtenerCoef(i+1) * (i+1) );
return tmp;
}
public String toString(String var)
{
String s = Double.toString(arr[0]);
for(int i = 1; i <= obtenerGrado(); i++)
if (arr[i] != 0.0)
{
if (arr[i] < 0.0 ) s += " - ";
else s += " + ";
s += Double.toString( Math.abs(arr[i]));
s += var;
if (i > 1)
{
s += "^";
s += Integer.toString(i);
}
}
return s;
}
/* metodo de prueba */
public static void main(String arg[])
{
double coefs[] = { -3.0 , 6.0 , 9.0 , 4.0 };
System.out.println("\n\tPrograma de prueba : POLINOMIO");
System.out.println("\t------------------------------");
Polinomio p = new Polinomio(coefs);
System.out.println("\n\tpolinomio(x) : " + p.toString("x"));
System.out.println("\tgrado : " + p.obtenerGrado());
System.out.println("\n\tpolinomio(0.0) : " + p.evaluar(0.0));
System.out.println("\tpolinomio(0.5) : " + p.evaluar(0.5));
System.out.println("\tpolinomio(1.0) : " + p.evaluar(1.0));
Polinomio i = p.integrar(p,9);
System.out.println("\n\tintegral : " + i.toString("x"));
System.out.println("\tgrado : " + i.obtenerGrado());
System.out.println();
Polinomio d = p.derivar(p);
System.out.println("\n\tderivada : " + d.toString("x"));
System.out.println("\tgrado : " + d.obtenerGrado());
System.out.println();
}
}
Bajar archivo