e elevado a la x en Java

Más ejercicios resueltos

Si deseas revisar más ejercicios resueltos, haz click en el siguiente botón. 

A continuación presentamos la solución al problema del cálculo de e^x en Java. Si deseas ver el enunciado del problema, haz click en el siguiente enlace.

Lectura de datos

La lectura de datos en Java la realizaremos con la clase \texttt{Scanner}. Instanciamos el objeto  \texttt{reader} de dicha clase y procedemos a la lectura. Usaremos la variable \texttt{x} para leer el valor de x. Para leer el valor de n usaremos la variable \texttt{n}. Para leer la variable \texttt{x} usamos el método \texttt{nextDouble}. Para la variable \texttt{n} usaremos el método \texttt{nextInt}.

package e_elevado_a_la_x;

import java.util.Scanner;

public class E_Elevado_a_la_X {

    public static void main(String[] args) {
        double x;
        int n;
        Scanner reader = new Scanner(System.in);
        System.out.printf("Ingrese el valor de x: ");
        x = reader.nextDouble();
        System.out.printf("Ingrese la cantidad de términos: ");
        n = reader.nextInt();
    }
} 

Validación de datos de entrada

Para implementar la validación del valor de \texttt{x} usaremos una selectiva doble. Colocaremos como condición del \texttt{if}, \texttt{n>=23}. En realidad en el enunciado indica que debe ser \texttt{n>=24}, pero en el caso de Java debe ser 23.

package e_elevado_a_la_x;

import java.util.Scanner;

public class E_Elevado_a_la_X {

    public static void main(String[] args) {
        double x;
        int n;
        Scanner reader = new Scanner(System.in);
        System.out.printf("Ingrese el valor de x: ");
        x = reader.nextDouble();
        System.out.printf("Ingrese la cantidad de términos: ");
        n = reader.nextInt();

        if (n >= 23) {
            System.out.printf("La cantidad de términos debe ser menor a 23%n");
        } else {

        }
    }
} 

Control de flujo de la iteración

Para el control de la iteración usaremos un ciclo iterativo con salida controlada. La variable de control será \texttt{i}, la cual ha sido inicializada con \texttt{0}. Para el caso del incremento, se ha usado el operador unario \texttt{++}. \texttt{i++} equivale a la instrucción \texttt{i=i+1}.

package e_elevado_a_la_x;

import java.util.Scanner;

public class E_Elevado_a_la_X {

    public static void main(String[] args) {
        double x;
        int n;
        Scanner reader = new Scanner(System.in);
        System.out.printf("Ingrese el valor de x: ");
        x = reader.nextDouble();
        System.out.printf("Ingrese la cantidad de términos: ");
        n = reader.nextInt();

        if (n >= 23) {
            System.out.printf("La cantidad de términos debe ser menor a 23%n");
        } else {
            int i = 0;
            do {

                i++;
            } while (i < n);
            System.out.printf("e^x = %f%n", sumatoria);
        }
    }
} 

Inicialización de la sumatoria​

Para acumular los valores de la sumatoria usaremos la variable \texttt{sumatoria}, la cual la hemos definido como un real de doble precisión (\texttt{double}). La inicializamos con el valor de \texttt{0}.

package e_elevado_a_la_x;

import java.util.Scanner;

public class E_Elevado_a_la_X {

    public static void main(String[] args) {
        double x;
        int n;
        Scanner reader = new Scanner(System.in);
        System.out.printf("Ingrese el valor de x: ");
        x = reader.nextDouble();
        System.out.printf("Ingrese la cantidad de términos: ");
        n = reader.nextInt();

        if (n >= 23) {
            System.out.printf("La cantidad de términos debe ser menor a 23%n");
        } else {
            int i = 0;
            double sumatoria = 0;
            do {

                i++;
            } while (i < n);
            System.out.printf("e^x = %f%n", sumatoria);
        }
    }
} 

Calculando el factorial

Procedemos ahora a calcular el factorial. A pesar que el factorial por su definición es un número natural, la hemos representado como un número real de doble precisión (\texttt{double}). ¿Por qué hemos hecho esto? Pues el real de doble precisión tiene más rango de representación que el entero (\texttt{int}) y el entero largo (\texttt{long}). 

Para la productoria en la variable \texttt{factorial}, se ha usado el operador de asignación \texttt{*=}. \texttt{factorial*=i} equivale a la instrucción \texttt{factorial=factorial*i}.

package e_elevado_a_la_x;

import java.util.Scanner;

public class E_Elevado_a_la_X {

    public static void main(String[] args) {
        double x;
        int n;
        Scanner reader = new Scanner(System.in);
        System.out.printf("Ingrese el valor de x: ");
        x = reader.nextDouble();
        System.out.printf("Ingrese la cantidad de términos: ");
        n = reader.nextInt();

        if (n >= 23) {
            System.out.printf("La cantidad de términos debe ser menor a 23%n");
        } else {
            int i = 0;
            double sumatoria = 0;
            double factorial = 1;
            do {
                if (i != 0) {
                    factorial *= i;
                }
                i++;
            } while (i < n);
            System.out.printf("e^x = %f%n", sumatoria);
        }
    }
} 

Acumulando la sumatoria

Para calcular el término de la sumatoria usamos la expresión \texttt{pow(x,i)/factorial}. Recuerde que el método \texttt{pow} (disminutivo de power en inglés) permite elevar un número a cualquier potencia. Para poder usar este método, se debe importar el mismo desde \texttt{java.lang.Math.pow}.

Para la acumulación en la variable \texttt{sumatoria}, se ha usado el operador de asignación \texttt{+=}. \texttt{sumatoria += pow(x,i)/factorial} equivale a la instrucción \texttt{sumatoria = sumatoria + pow(x,i)/factorial}.

package e_elevado_a_la_x;

import static java.lang.Math.pow;
import java.util.Scanner;

public class E_Elevado_a_la_X {

    public static void main(String[] args) {
        double x;
        int n;
        Scanner reader = new Scanner(System.in);
        System.out.printf("Ingrese el valor de x: ");
        x = reader.nextDouble();
        System.out.printf("Ingrese la cantidad de términos: ");
        n = reader.nextInt();

        if (n >= 23) {
            System.out.printf("La cantidad de términos debe ser menor a 23%n");
        } else {
            int i = 0;
            double sumatoria = 0;
            double factorial = 1;
            do {
                if (i != 0) {
                    factorial *= i;
                }
                sumatoria += pow(x, i) / factorial;
                i++;
            } while (i < n);
        }
    }
} 

Mostrando el resultado final

Finalmente presentamos el valor de la sumatoria calculada, al finalizar el ciclo iterativo.

package e_elevado_a_la_x;

import static java.lang.Math.pow;
import java.util.Scanner;

public class E_Elevado_a_la_X {

    public static void main(String[] args) {
        double x;
        int n;
        Scanner reader = new Scanner(System.in);
        System.out.printf("Ingrese el valor de x: ");
        x = reader.nextDouble();
        System.out.printf("Ingrese la cantidad de términos: ");
        n = reader.nextInt();

        if (n >= 23) {
            System.out.printf("La cantidad de términos debe ser menor a 23%n");
        } else {
            int i = 0;
            double sumatoria = 0;
            double factorial = 1;
            do {
                if (i != 0) {
                    factorial *= i;
                }
                sumatoria += pow(x, i) / factorial;
                i++;
            } while (i < n);
            System.out.printf("e^x = %f%n", sumatoria);
        }
    }
} 

Conclusión

Hemos presentado en este artículo, una propuesta de solución al cálculo de la e elevado a la x en Java. Se ha utilizado para el control de flujo la estructura iterativa y realizándose el control mediante un ciclo con salida controlada. Podrá descargar las soluciones propuestas en el repositorio GitHub de iterando++ a través del siguiente enlace

Hemos preparado otros artículos adicionales en donde describimos al detalle la implementación de este problema en PSeInt y otros lenguajes de programación. Te invitamos a leer los siguientes artículos de iterando++

Si te interesa profundizar en Java, el mejor libro que hay es Effective Java de Joshua Bloch. Uno de los libros favoritos de los que se inician en Java es Java: Learn Java in One Day and Learn It Well de  Jamie Chan.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *