e elevado a la x en PSeInt

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 PSeInt. Si deseas ver el enunciado del problema, haz click en el siguiente enlace.

Lectura de datos

Y empezamos con el primer paso, la lectura de los datos de entrada. Primero realizamos la lectura del valor de x. Para esto usamos la instrucción \texttt{Leer} asignando el valor leído en la variable \texttt{x}. Posteriormente, realizamos la lectura del valor de n,  asignando el valor leído en la variable \texttt{n}. Esta variable representará la cantidad de veces que debemos sumar términos en la sumatoria. Será fundamental para el control de flujo de la iteración.

Es una buena práctica que los valores de la variables, en la medida de lo posible, sean los mismos nombres que las variables usadas en la definición del problema. Esto ayuda en la lectura posterior del código fuente.

pseudocódigo e elevador a la x v1
Lectura de datos

Validación de datos de entrada

Procedemos a realizar la validación del valor de \texttt{n}.  Por definición del problema, \texttt{n} debe ser menor que 24.

Pero, ¿por qué nos piden esta validación un tanto extraña?, ¿por qué justo menor que 24? Pues porque los computadores usan los bits para representar los números en el computador. Dependiendo del tamaño del bit y de la forma de representación, existirá un rango de valores permitido. Resulta pues que el factorial es una operación que suele tener números muy grandes. De una ojeada a los factoriales de los 25 primeros números naturales al fin de esta sub sección. Por esta razón, si pretendemos calcular el factorial de 23, desbordaremos el rango permitido de PSeInt. Lo mismo ocurrirá con los lenguajes de programación.

Entonces nuestro algoritmo deberá tomar una decisión. Si la cantidad de términos leída es mayor que 24, deberemos emitir un mensaje informativo al usuario. Como ya hemos visto anteriormente, la instrucción que permite que un algoritmo tome decisiones sobre qué flujo ejecutar es la estructura algorítmica selectiva. Usaremos una selectiva doble pues tenemos dos posibles caminos a seguir: o emitimos un mensaje de error o realizamos las operaciones del cálculo. La condición a usar será \texttt{n>=24}, si esta condición se cumple, se debe emitir el mensaje de error.

pseudocódigo e elevador a la x v2
Validación de datos de entrada

Lista de los 25 primeros números naturales factoriales

 

0! = 1
1! = 1
2! = 2
3! = 6
4! = 24
5! = 120
6! = 720
7! = 5040
8! = 40320
9! = 362880
10! = 3628800
11! = 39916800
12! = 479001600
13! = 6227020800
14! = 87178291200
15! = 1307674368000
16! = 20922789888000
17! = 355687428096000
18! = 6402373705728000
19! = 121645100408832000
20! = 2432902008176640000
21! = 51090942171709440000
22! = 1124000727777607680000
23! = 25852016738884976640000
24! = 620448401733239439360000
25! = 15511210043330985984000000

Control de flujo de la iteración

Procederemos ahora a realizar el control de flujo de la iteración, usaremos para ello un ciclo iterativo con salida controlada. Usaremos un control por variable el cual se configura usando los siguientes pasos:

  1. Inicializamos la variable de control. En este caso hemos definido la variable de control \texttt{i} y la hemos inicializado con el valor de \texttt{0}. La inicializamos con este valor por las condiciones del problema. Si revisa la definición del problema, verá que el índice de la sumatoria, inicia en \texttt{0}
  2. Controlamos el flujo usando la variable de control. Como queremos que existan \texttt{n} términos en la sumatoria, la variable de control \texttt{i} debe actualizarse con  \texttt{n} valores, desde \texttt{0}, su valor inicial, hasta \texttt{n-1}, su valor final. Por lo tanto la condición de repetición es \texttt{i<n}. Mientras esto sea verdad, se seguirá repitiendo. A diferencia de la entrada controlada, en la salida el control del flujo se realizará al finalizar la iteración, por lo que el conjunto de instrucciones se ejecutará por lo menos una vez. Si \texttt{n} tuviera el valor de 0, el algoritmo propuesta respondería con el valor del primer término. Pruebe este comportamiento cuando finalice el algoritmo. Luego podría corregir la condición con la expresión \texttt{n>0\ y\ n<=24}. Si hace esto, no se olvide de modificar el mensaje de advertencia al usuario.
  3. Actualizamos el valor de la variable de control. Debemos cambiar la variable de control para que el ciclo iterativo no se haga infinito. Debemos garantizar que en algún momento en el tiempo, la condición se evalúe como falsa. Por lo tanto debemos incrementar \texttt{i} para que llegue a ser igual a \texttt{n} y el ciclo termine. Por condiciones del problema, se incrementará en 1 a esta variable.
pseudocódigo e elevador a la x v3
Control de flujo de la iteración

Inicialización de la sumatoria​

Una vez controlado el flujo de la iteración, procedemos a resolver el problema. Debemos calcular el valor de una sumatoria, debemos acumular todos los términos en una sola variable. Debido a esto, creamos una variable para este fin en específico, la identificaremos con el nombre \texttt{sumatoria}. Como a toda variable le debemos de dar un valor inicial, la inicializaremos con el valor de \texttt{0}, pues \texttt{0} es el elemento neutro para al suma.

pseudocódigo e elevador a la x v4
Inicialización de la sumatoria​

Calculando el factorial

En este paso, calcularemos el factorial que usaremos luego para calcular el término de la sumatoria. El factorial no es más que una productoria. En nuestro algoritmo, hemos creado la variable \texttt{factorial} que como su propio nombre indica, almacenará el valor del factorial de \texttt{i}.

Pero, ¿cómo hacemos una productoria? Primero, antes que nada, debemos inicializar dicha variable. Inicializamos \texttt{factorial}  con el valor de 1, dado que 1 es el elemento neutro para la multiplicación. No podemos inicializarlo con 0 pues al multiplicarlo, el producto daría siempre 0.

Una vez inicializado, en cada iteración, lo multiplicamos por el valor de \texttt{i}. De este modo, en la primera iteración, cuando \texttt{i} vale 0, el \texttt{factorial} no se modifica. Para esto usamos una selectiva simple. En la segunda iteración, cuando \texttt{i} vale 1, el \texttt{factorial} se multiplica por 1 dando como resultado 1, que es el valor de 1!. En la tercera iteración, cuando \texttt{i} vale 2, el \texttt{factorial} se multiplica por 2 dando como resultado 1 \times 2, que es el valor de 2!. En la cuarta iteración, cuando \texttt{i} vale 3, el \texttt{factorial} se multiplica por 3 dando como resultado 1 \times 2 \times 3, que es el valor de 3!. Y así, obtenemos el factorial de \texttt{i}

pseudocódigo e elevador a la x v5
Calculando el factorial

Acumulando la sumatoria

Ahora vamos a acumular los términos a la variable \texttt{sumatoria}. Esto lo realizaremos dentro de la iteración. Tiene que ser así por que esta es la acción repetitiva (sumar los términos) que hace que usemos una estructura iterativa. Aprovechamos el hecho que la variable de control \texttt{i} cambia a largo de la iteración y la usamos para calcular el término. El término es muy simple, lo calculamos mediante la expresión \texttt{x}^\texttt{i}/\texttt{factorial}

La primera vez, \texttt{i} vale \texttt{0} por lo que \texttt{x}^\texttt{i}/\texttt{factorial} equivale a 1. La segunda vez,  \texttt{i} vale \texttt{1} por lo que \texttt{x}^\texttt{i}/\texttt{factorial} equivale a x. La tercera vez,  \texttt{i} vale \texttt{2} por lo que \texttt{x}^\texttt{i}/\texttt{factorial} equivale a x^2/2. Y así sucesivamente. 

Recuerde que el operador ^ permite elevar un número a cualquier potencia. 

pseudocódigo e elevador a la x v6
Acumulando la sumatoria

Mostrando el resultado final

Finalmente presentamos el valor de la sumatoria. Como el valor se va a obtener al finalizar la iteración, la impresión debe realizarse una vez finalizada el ciclo iterativo.

pseudocódigo e elevador a la x v7
Mostrando el resultado final

Diseño algorítmico en diagrama de flujo​​​

A continuación se presenta la solución en diagrama de flujo. La secuencia de pasos usada para su construcción ha sido la misma que para el pseudocódigo.

diagrama de flujo e elevador a la x
Diseño algorítmico en diagrama de flujo​​​

Conclusión

Hemos presentado en este artículo, una propuesta de solución al cálculo de la e elevado a la x. Se ha utilizado para el control de flujo la estructura iterativa y realizándose el control mediante un ciclo con salida controlada. Podrá descargar la solución propuesta 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 lenguajes de programación. Te invitamos a leer los siguientes artículos de iterando++

Si te interesa profundizar más sobre diseño algorítmico, te recomendamos el libro Foundations of Programming Languages de Kent D. D. Lee. En este libro encontrarás además información detallada sobre la programación orientada a objetos, funcional y lógica.

Deja una respuesta

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