Aplicación de la Clase MathPara resolver Ecuaciones

Cuadráticas

PROGRAMACIÓN DE ALGORITMOS

Clase Math¿Qué es la clase Math?  

Math es una clase definida en Java en donde se encuentran las funciones de cálculo matemático.  La funciones con las que se cuenta son las siguientes:  

+ Math.E, Es la constante de la base de logaritmo natural, 2.718281828...   Ejercicio: Escribe y evalúa las

siguientes instrucciones:   double  m; 

  m = Math.E;    

+ Math.PI, Es la constante 3.1415926...   Ejercicio: Escribe y evalúa la siguiente instrucción:   m = Math.PI;    

+ Math.abs(x), Obtiene el valor absoluto de x.   Ejercicio: Escribe y evalúa las siguientes instrucciones:     m = Math.abs(-9); 

  m = Math.abs(9);    

+ Math.ceil(x), Obtiene el siguiente valor entero de x.   Ejercicio: Escribe y evalúa las siguientes instrucciones:   int  k; 

  k = Math.ceil(11.4);    

+ Math.floor(x), Obtiene el valor entero anterior a x.   Ejercicio: Escribe y evalúa la siguiente instrucción:   k = Math.floor(11.78);    

Clase Math+ Math.round(x),

Obtiene el valor entero más cercano a x.   Ejercicio: Escribe y evalúa las siguientes instrucciones:   k= Math.round(9.75); 

  k = Math.round(9.15); 

+ Math.cos(x), Obtiene el coseno de x (x en radianes).   Ejercicio: Escribe y evalúa las siguientes instrucciones:     m = Math.cos(1.0); 

  m = Math.cos(Math.PI);     

+ Math.sin(x), Obtiene el seno de x  (x en radianes).   Ejercicio: Escribe y evalúa las siguientes instrucciones:   m = Math.sin(1.0); 

  m = Math.sin(Math.PI);     

+ Math.tan(x), Obtiene la tangente de x  (x en radianes).   Ejercicio: Escribe y evalúa la siguiente instrucción:  

m = Math.tan (0.0);    

+ Math.log(x), Obtiene el logaritmo natural de x. (x debe ser mayor que 0).   Ejercicio: Escribe y evalúa las siguientes

instrucciones:   m = Math.log(1024.0); 

  m = Math.log(Math.E);  

+ Math.exp(x), Regresa  , en donde e representa Math.E.   Ejercicio: Escribe y evalúa las siguientes instrucciones:     m = Math.exp( 3.0 ); 

  m = Math.exp(Math.log(1024.0));  

+ Math.pow(x,y), Obtiene el resultado de elevar x a la potencia y:  .  x debe ser mayor que 0.   Ejercicio: Escribe y evalúa las siguientes instrucciones:     m = Math.pow (2, 3); 

  m = Math.pow(9, 0.5);    

+ Math.sqrt(x), Obtiene la raíz cuadrada de x.   Ejercicio: Escribe y evalúa la siguiente instrucción:   m = Math.sqrt (16);    

+ Math.max(x,y), Obtiene el número mayor entre x y y.   Ejercicio: Escribe y evalúa las siguientes instrucciones:     m= Math.max(9.75, 13.54); 

  m = Math.max(8.16, 9.15);    

+ Math.min(x,y), Obtiene el número menor entre x y y.   Ejercicio: Escribe y evalúa las siguientes instrucciones:   m= Math.min(9.75, 13.54); 

  m = Math.min(8.16, 9.15);   

+ Math.random( ), Regresa un número aleatorio entre 0 y 1, con una distribución uniforme.   Ejercicio: Escribe y evalúa las siguientes instrucciones:   m= Math.random( ); 

  m = Math.random(

Clase Math

Aplicación//INICIO// Para iniciar la siguiente aplicación es necesario importar la librería import

javax.swing.JOptionPane; import javax.swing.JOptionPane;

// Escribimos el nombre de la clase que se prevee desarrollar, por lo general esta empieza con mayúscula, si posee mas de dos palabras es recomendable que la siguiente también lo sea.

public class FuncionesCuadráticas {

public static void main(String args[]) { // Declaración de Variables String datoEntrada; // Esta variable es de tipo string por que cuando se pide los datos de

los coeficientes de la ecuación mas adelante, estos son leídos como caracteres y esta variable será útil en su conversión a entero.

double a=0, b=0, c=0; // Se han declarado variables de tipo double, por la existencia de double raizUnica, parteReal, parteImaginaria; // trabajar con números decimales, además

de double raizReal1, raizReal2; //los resultados posibles a presentar.

//La siguiente linea, muestra Tema de la aplicación, JOptionPane.showMessageDialog permite

mostrar mensajes en una ventana de dialogo asi:

JOptionPane.showMessageDialog(null,"REALIZA CALCULOS CON LA ECUACION CUADRATICA");

// Las sentencias Try y Catch, que en español significan tratar y atrapar, tienen la función de tratar los datos de entrada, y atrapar alguna excepción. Siempre van juntos, sino no funcionarían correctamente.

try {//JOptionPane.showInputDialog es el Método que mostrará la ventana de ingreso de datos, y

solo recepta variables de tipo string, Así:

datoEntrada = JOptionPane.showInputDialog("Teclee Coeficiente A: ");//En esta linea se convierte el dato string a un entero, en caso de ingresar una letra

mostrará un excepción. a = Double.parseDouble(datoEntrada);

datoEntrada = JOptionPane.showInputDialog("Teclee Coeficiente B: "); b = Double.parseDouble(datoEntrada);

datoEntrada = JOptionPane.showInputDialog("Teclee Coeficiente C: "); c = Double.parseDouble(datoEntrada); } catch (NumberFormatException nfe) // Existen algunas excepsiones entre las mas

conocidas se encuentran : InputMismatchException, Exception, ArithmeticException, etc. { JOptionPane.showMessageDialog(null,"Error, ha ingresado una letra, el valor no es

válido"); //Si se produce el error al convertir el dato a entero se mostrará una ventana similar

a esta:

}

Código Utilizado

//Verifica si los datos ingresados coinciden con raíces únicas, raíces complejas o reales, utilizando la clase math.pow podemos obtener fácilmente la potencia a la n de cualquier valor. Recordemos siempre que primero colocamos la base y luego el exponente así: Math.pow(base,exponente)

if ((Math.pow(b,2)-4*a*c) == 0) { raizUnica = b/(2*a); //Cuando presentamos mensajes o mostramos resultados en ventanas es muy común

usar saltos de líneas \n. Tambien mostrar resultados finales asi: “+result+”.

JOptionPane.showMessageDialog(null,"Tiene raíz única\nLa Raíz es : " + raizUnica);

//El resultado de la línea anterior resulta:

//Si la anterior condición no se cumplió se pasa a la siguiente, la cual nos calcula raíces complejas . } else if ((Math.pow(b,2)-4*a*c) < 0) { parteReal = -b/(2*a);

//Con el método math.sqrt podemos obtener la raíz de un numero , en cambio con math.abs calculamos su valor absoluto.

parteImaginaria = Math.sqrt(Math.abs(Math.pow(b,2)-4*a*c))/(2*a); JOptionPane.showMessageDialog(null,"Tiene raices complejas\n PARTE REAL + PARTE IMAGINARIA\

n"+parteReal + " + " + parteImaginaria+"\n"+parteReal + " - " + parteImaginaria); } //El resultado sería:

Código Utilizado

//Si por casualidad no se cumple ninguna condición anterior se procede al último caso contrario, el cual calcula las dos raíces reales de la ecuación.

else {//Aquí hemos aplicado los metodos ya conocidos estableciendo una estructura similar a la fórmula:

raizReal1 = (-b + Math.sqrt(Math.pow(b,2)-4*a*c))/(2*a); raizReal2 = (-b - Math.sqrt(Math.pow(b,2)-4*a*c))/(2*a); JOptionPane.showMessageDialog(null,"Tiene raices reales\nRaiz real 1 =

"+raizReal1+"\nRaiz real 2= "+raizReal2);

//La ventana de resultados nos mostraría:

} }//Es importante recordar que las llaves dentro de la lógica del programa son fundamentales//FIN

Código Utilizado

Recursos Utilizados:

1. Libro Precálculo.2. Libro Programación de

Algoritmos.3. Manual java netbeans.

http://mygnet.com

Aporte 1er Bimestre