# data[].attributes.body
Se incluyen las bibliotecas necesarias para el programa:

<iostream>: Proporciona funcionalidades básicas de entrada/salida, como la lectura y escritura en la consola.

<algorithm>: Contiene funciones para realizar operaciones en contenedores, como buscar, ordenar y manipular elementos.

<string>: Permite trabajar con cadenas de caracteres y realizar operaciones como concatenación, búsqueda y manipulación de caracteres.

<cmath>: Proporciona funciones matemáticas comunes, como cálculos trigonométricos, exponenciales y logarítmicos.

<sstream>: Permite trabajar con flujos de entrada/salida de cadenas, lo que facilita la conversión entre diferentes tipos de datos.

<vector>: Proporciona una implementación de un contenedor dinámico llamado vector, que permite almacenar y manipular una secuencia de elementos.

<iomanip>: Contiene herramientas para manipular el formato de salida, como establecer la precisión decimal y el ancho de campo.

Se utiliza la declaración using namespace std; para evitar tener que escribir std:: delante de las funciones y clases de la biblioteca estándar de C++. Esto permite acceder directamente a las funciones y clases de la biblioteca estándar sin tener que especificar su espacio de nombres.

1. La función `esOperador` es una función que toma un carácter como argumento y devuelve un valor booleano. Su propósito es determinar si el carácter dado es un operador matemático válido.

2. La declaración `bool` al inicio de la función indica que el valor de retorno de la función será un valor booleano, es decir, será `true` o `false`.

3. El cuerpo de la función está delimitado por llaves `{}`. Todo el código dentro de estas llaves forma parte del cuerpo de la función.

4. Dentro del cuerpo de la función, hay una sola instrucción: `return (c '+' || c '-' || c '*' || c '/' || c == '^');`. Esta instrucción utiliza una expresión de comparación para determinar si el carácter `c` es un operador válido.

5. La expresión `(c '+' || c '-' || c '*' || c '/' || c '^')` es una condición que se evalúa para decidir si el carácter `c` es un operador. Esta condición está compuesta por varias comparaciones utilizando el operador de igualdad (``) y el operador lógico OR (`||`).

6. Cada comparación en la condición verifica si el carácter `c` es igual a uno de los operadores matemáticos válidos. Por ejemplo, `c == '+'` verifica si `c` es igual al carácter '+'. Del mismo modo, las otras comparaciones verifican si `c` es igual a '-', '*', '/', o '^' respectivamente.

7. Si alguna de las comparaciones en la condición es verdadera, la expresión completa se evaluará como `true`. Esto significa que el carácter `c` es un operador válido y la función devolverá `true`.

8. Si ninguna de las comparaciones en la condición es verdadera, la expresión completa se evaluará como `false`. Esto significa que el carácter `c` no es un operador válido y la función devolverá `false`.

9. La palabra clave `return` se utiliza para devolver el resultado de la condición. Si la condición es verdadera, es decir, `c` es un operador válido, la función devuelve `true` usando `return true;`. Si la condición es falsa, es decir, `c` no es un operador válido, la función devuelve `false` usando `return false;`.

# data[].attributes.body
1. La función `esDigito` es una función que toma un carácter como argumento y devuelve un valor booleano. Su propósito es determinar si el carácter dado es un dígito numérico o el carácter de punto decimal.

2. La declaración `bool` al inicio de la función indica que el valor de retorno de la función será un valor booleano, es decir, será `true` o `false`.

3. El cuerpo de la función está delimitado por llaves `{}`. Todo el código dentro de estas llaves forma parte del cuerpo de la función.

4. Dentro del cuerpo de la función, hay una sola instrucción: `return (c >= '0' && c <= '9') || (c == '.');`. Esta instrucción utiliza una expresión de comparación para determinar si el carácter `c` es un dígito numérico o el carácter de punto decimal.

5. La expresión `(c >= '0' && c <= '9')` es la primera parte de la condición. Verifica si el carácter `c` se encuentra en el rango de caracteres numéricos. La comparación `c >= '0'` verifica si `c` es mayor o igual que el carácter '0', que representa el dígito 0. La comparación `c <= '9'` verifica si `c` es menor o igual que el carácter '9', que representa el dígito 9. En resumen, esta parte de la condición verifica si `c` es un dígito numérico.

6. La expresión `(c == '.')` es la segunda parte de la condición. Verifica si el carácter `c` es igual al carácter de punto decimal, representado por '.'. Esta parte de la condición verifica si `c` es el carácter de punto decimal.

7. El operador lógico OR (`||`) se utiliza para combinar las dos partes de la condición. Si alguna de las partes de la condición es verdadera, es decir, si `c` es un dígito numérico o el carácter de punto decimal, la condición completa se evalúa como `true`.

8. La palabra clave `return` se utiliza para devolver el resultado de la condición. Si la condición es verdadera, es decir, `c` es un dígito numérico o el carácter de punto decimal, la función devuelve `true` usando `return true;`. Si la condición es falsa, es decir, `c` no es un dígito numérico ni el carácter de punto decimal, la función devuelve `false` usando `return false;`.

En resumen, la función `esDigito` verifica si un carácter dado es un dígito numérico o el carácter de punto decimal. Devuelve `true` si el carácter es un dígito numérico o el punto decimal, y `false` si no lo es.

# data[].attributes.body
1. La función `operar` es una función que realiza una operación matemática entre dos operandos utilizando el operador especificado. Toma tres argumentos: `operand1`, `operand2` y `operador`. Ambos operandos son cadenas de texto (`string`) y el operador es un carácter (`char`).

2. La función tiene un tipo de retorno `string`, lo que significa que devuelve una cadena de texto como resultado de la operación.

3. Dentro de la función, se declaran tres variables de tipo `double`: `numero1`, `numero2` y `resultado`. Estas variables se utilizan para almacenar los valores numéricos de los operandos y el resultado de la operación, respectivamente.

4. Se utiliza la función `stod` para convertir las cadenas `operand1` y `operand2` en números de tipo `double`. La función `stod` es parte de la biblioteca estándar de C++ y se utiliza para convertir una cadena de texto en su equivalente numérico de tipo `double`.

5. Después de la conversión, los valores de `operand1` y `operand2` se almacenan en las variables `numero1` y `numero2`, respectivamente.

6. Se utiliza un `switch` para realizar diferentes acciones según el valor del `operador`. El `switch` evalúa el valor de `operador` y ejecuta el caso correspondiente.

7. En cada caso del `switch`, se realiza la operación matemática correspondiente utilizando los valores de `numero1` y `numero2`, y se asigna el resultado a la variable `resultado`. Los casos del `switch` representan diferentes operaciones matemáticas: suma, resta, multiplicación, división y potenciación.

8. En el caso de `'+': resultado = numero1 + numero2;`, se suma `numero1` y `numero2` y se asigna el resultado a `resultado`.

9. En el caso de `'-': resultado = numero1 - numero2;`, se resta `numero2` de `numero1` y se asigna el resultado a `resultado`.

10. En el caso de `'*': resultado = numero1 * numero2;`, se multiplica `numero1` por `numero2` y se asigna el resultado a `resultado`.

11. En el caso de `'/': resultado = numero1 / numero2;`, se divide `numero1` entre `numero2` y se asigna el resultado a `resultado`.

12. En el caso de `'^': resultado = pow(numero1, numero2);`, se utiliza la función `pow` de la biblioteca estándar de C++ para calcular `numero1` elevado a la potencia `numero2`, y se asigna el resultado a `resultado`.

13. Después del `switch`, se utiliza la función `to_string` para convertir el resultado de tipo `double` en una cadena de texto de tipo `string`. La función `to_string` es parte de la biblioteca estándar de C++ y se utiliza para convertir un número en su representación de cadena de texto.

14. Finalmente, se devuelve el resultado de la operación como una cadena de texto utilizando la palabra clave `return`.

# data[].attributes.body
1. La función `evaluarEcuacion` toma una ecuación matemática representada como una cadena de texto (`string`) y devuelve el resultado de evaluarla como un número de tipo `double`.

2. Dentro de la función, se declaran dos vectores: `operandos` y `operadores`. Estos vectores se utilizan para almacenar los operandos y operadores de la ecuación, respectivamente.

3. Se utiliza un bucle `for` para iterar a través de cada carácter de la ecuación.

4. En cada iteración, se obtiene el carácter actual de la ecuación y se almacena en la variable `c`.

5. Si el carácter es un espacio en blanco, se omite y se continúa con la siguiente iteración del bucle.

6. Si el carácter es un dígito, se inicia un proceso para obtener el número completo al que pertenece. Se declara una variable `numero` como una cadena de texto vacía y se inicia un bucle `while` que se ejecuta mientras el carácter actual y los siguientes sean dígitos.

7. Dentro del bucle `while`, se agrega cada carácter dígito a la cadena `numero`, y se incrementa el índice `i` para pasar al siguiente carácter.

8. Una vez que se obtiene el número completo, se agrega al vector `operandos`. Luego, se decrementa el índice `i` en 1 para compensar el incremento adicional en la iteración principal del bucle `for`.

9. Si el carácter es un operador, se realiza una serie de evaluaciones para determinar si es necesario realizar operaciones anteriores antes de agregar el operador actual al vector `operadores`.

10. Se verifica si hay operadores anteriores en el vector `operadores` y si el operador anterior no es un paréntesis de apertura ('('). Además, se verifica si la prioridad del operador actual es menor o igual a la prioridad del operador anterior.

11. Si se cumplen estas condiciones, se extraen dos operandos y un operador del final de los vectores `operandos` y `operadores`. Luego, se utiliza la función `operar` con estos operandos y operador para obtener el resultado y se agrega al vector `operandos`.

12. Después de evaluar las operaciones anteriores, se agrega el operador actual al final del vector `operadores`.

13. Si el carácter es un paréntesis de apertura ('('), se agrega al final del vector `operadores`.

14. Si el carácter es un paréntesis de cierre (')'), se realizan operaciones hasta encontrar el paréntesis de apertura correspondiente en el vector `operadores`. Se extraen dos operandos y un operador del final de los vectores `operandos` y `operadores`, se utiliza la función `operar` para obtener el resultado y se agrega al vector `operandos`.

15. Si el vector `operadores` no está vacío y el último operador es un paréntesis de apertura, se elimina del vector.

16. Después de completar el bucle `for`, es posible que aún queden operaciones pendientes en los vectores `operadores` y `operandos`. Se realiza un bucle `while` para ejecutar operaciones hasta que el vector `operadores` esté vacío.

17. Dentro del bucle `while`, se extraen dos operandos y un operador del final de los vectores `operandos` y `operadores`, se utiliza la función `operar` para obtener el resultado y se agrega al vector `operandos`.

18. Finalmente, se devuelve el último elemento del vector `operandos` después de evaluar todas las operaciones como el resultado de la ecuación, utilizando la función `stod` para convertirlo de `string` a `double`.

# data[].attributes.body
1. La función `doubleToString` toma un número de tipo `double` llamado `valor` y devuelve una representación en forma de cadena de ese número.

2. Se comienza declarando un objeto `ostringstream` llamado `oss`. El objeto `ostringstream` se utiliza para construir una cadena de texto a partir de diferentes tipos de datos, en este caso, el número `valor`.

3. Se utiliza el operador de inserción `<<` para agregar el número `valor` al objeto `oss`. Antes de hacerlo, se establecen dos modificadores: `fixed` y `setprecision(10)`. `fixed` indica que el número debe mostrarse en formato de punto fijo, y `setprecision(10)` establece que se deben mostrar hasta 10 dígitos después del punto decimal.

4. Después de la inserción, se llama al método `str()` del objeto `oss` para obtener la cadena de texto resultante y se almacena en la variable `str`.

5. A continuación, se busca el último carácter distinto de '0' en la cadena `str` utilizando la función `find_last_not_of('0')`. Esto se hace para eliminar los ceros finales innecesarios después del punto decimal.

6. Si se encuentra un carácter distinto de '0', se realiza una verificación adicional. Si ese carácter es un punto decimal '.', se devuelve una subcadena de `str` que va desde el inicio hasta el carácter encontrado (excluyendo el carácter encontrado).

7. Si el carácter encontrado no es un punto decimal, se devuelve una subcadena de `str` que va desde el inicio hasta el carácter encontrado más uno (incluyendo el carácter encontrado).

8. Si no se encuentra ningún carácter distinto de '0', se devuelve la cadena `str` sin modificaciones.

9. En resumen, la función `doubleToString` convierte un número de tipo `double` en una cadena de texto, aplicando un formato de punto fijo y eliminando los ceros finales innecesarios después del punto decimal.

# data[].attributes.body
1. En la función `main`, se declaran varias variables: `ecuacion1` y `ecuacion2` de tipo `string` para almacenar las ecuaciones, `r1`, `r2`, `r3`, y `r4` de tipo `int` para almacenar los límites de los rangos.

2. Se muestra por pantalla un mensaje pidiendo al usuario que ingrese la primera ecuación (`f(x)`), y se guarda en la variable `ecuacion1` utilizando la función `cin`.

3. Se muestra por pantalla un mensaje pidiendo al usuario que ingrese el límite inferior del primer rango, y se guarda en la variable `r1` utilizando la función `cin`.

4. Se muestra por pantalla un mensaje pidiendo al usuario que ingrese el límite superior del primer rango, y se guarda en la variable `r2` utilizando la función `cin`.

5. Se muestra por pantalla un mensaje pidiendo al usuario que ingrese la segunda ecuación (`f(x)`), y se guarda en la variable `ecuacion2` utilizando la función `cin`.

6. Se muestra por pantalla un mensaje pidiendo al usuario que ingrese el límite inferior del segundo rango, y se guarda en la variable `r3` utilizando la función `cin`.

7. Se muestra por pantalla un mensaje pidiendo al usuario que ingrese el límite superior del segundo rango, y se guarda en la variable `r4` utilizando la función `cin`.

8. Se calcula el tamaño de los arreglos `x`, `w`, `y` y `z` utilizando las fórmulas `(r2 - r1) / 5 + 1` y `(r4 - r3) / 5 + 1`. Estos arreglos se utilizan para almacenar los valores de `x`, `w`, `y` y `z` respectivamente.

9. Se inicia un bucle `for` para llenar los arreglos `x` y `y`. En cada iteración, se calcula el valor de `x[i]` utilizando la función `doubleToString` con el valor de `r1 + i * 5`, y se asigna `ecuacion1` a `y[i]`.

10. Se inicia otro bucle `for` para llenar los arreglos `w` y `z`. En cada iteración, se calcula el valor de `w[i]` utilizando la función `doubleToString` con el valor de `r3 + i * 5`, y se asigna `ecuacion2` a `z[i]`.

11. Se declara una variable `letra` de tipo `char` y se le asigna el valor `'x'`.

12. Se inicia un bloque `try` para manejar cualquier excepción que pueda ocurrir durante la ejecución del código.

13. Dentro del bloque `try`, se inicia un bucle `for` para reemplazar todas las apariciones de `'x'` en los elementos del arreglo `y` utilizando el valor correspondiente en `x`. Se utiliza la función `find` para buscar la posición de `'x'`, y luego se utiliza la función `replace` para reemplazarlo por el valor de `x[i]`. El bucle se repite hasta que no se encuentren más apariciones de `'x'` en el elemento de `y[i]`.

14. Se repite el mismo proceso del paso anterior para los elementos del arreglo `z` utilizando los valores correspondientes en `w`.

15. Se declara una variable `max_x_length` de tipo `size_t` y se inicializa en `0`. Esta variable se utiliza para almacenar la longitud máxima de los valores en el arreglo `w`.

16. Se inicia un bucle `for` para encontrar la longitud máxima de los valores en el arreglo `w`. En cada iteración, se compara la longitud de `w[i]` con el valor actual de `max_x_length` utilizando la función `max`, y el resultado se asigna nuevamente a `max_x_length`.

17. Se muestra por pantalla un encabezado para la tabla de valores.

18. Se muestra por pantalla una línea separadora.

19. Se muestra por pantalla los encabezados de las columnas "x" y "f(x)" utilizando `setw` para establecer un ancho fijo para la columna "x" basado en la longitud máxima de los valores en el arreglo `w`.

20. Se muestra por pantalla una línea separadora.

21. Se inicia un bucle `for` para mostrar los valores de `x` y los resultados de evaluar `y[i]` utilizando la función `evaluarEcuacion(y[i])`. Se utiliza `setw` para establecer un ancho fijo para la columna "x" basado en la longitud máxima de los valores en el arreglo `w`.

22. Se repite el mismo proceso del paso anterior para mostrar los valores de `w` y los resultados de evaluar `z[i]`.

23. Se muestra por pantalla una línea separadora.

24. Se muestra por pantalla un mensaje pidiendo al usuario que ingrese una opción del menú para resolver otro límite, y se guarda en la variable `menu` utilizando la función `cin`.

25. Si el valor de `menu` es igual a "S", se llama a la función `main()` de forma recursiva para resolver otro límite.

26. Si el valor de `menu` no es igual a "S", se muestra por pantalla el mensaje "Adiós :3" y se retorna 0 para finalizar el programa.