diff --git a/otros/README.md b/otros/README.md new file mode 100644 index 0000000..5401651 --- /dev/null +++ b/otros/README.md @@ -0,0 +1,211 @@ +# Actividad: **Práctica Calculadora Básica en Python** + +**ID actividad:** PROG-2425-PRUEBA-U1-U2 + +**Agrupamiento de la actividad**: Individual + +--- + +### Descripción: + +La actividad consiste en completar y corregir el desarrollo de una calculadora "algo especial" en Python, aplicando los conceptos estudiados en las Unidades 1 y 2. El código que debéis analizar y modificar está en "src/calculadora_alumnos.py". También existe una copia que no debéis modificar, "src/calculadora_alumnos_original.py", es un backup del programa, por si realizáis muchos cambios y necesitáis consultar el problema que se os propuso originalmente. + +La calculadora permitirá realizar operaciones aritméticas básicas y deberá cumplir con el principio de "Separación de Responsabilidades" (SRP). Debéis leer y analizar el código provisto, corregir errores y desarrollar las partes incompletas, asegurando la gestión de excepciones. + +### Objetivo: + +- Leer y analizar la documentación del código para comprender su funcionamiento y aplicar correcciones o completar las partes faltantes de la aplicación. +- Planificar y desarrollar un programa interactivo en Python, estructurando las funciones de manera que cada una tenga una única responsabilidad. +- Aplicar estructuras de control condicional y bucles para resolver problemas de forma eficiente. +- Implementar el manejo de excepciones para asegurar el correcto funcionamiento del programa y prevenir errores en su ejecución. +- Ejecutar pruebas unitarias para validar el comportamiento de las funciones, comprobando que cumplen con los requerimientos establecidos. +- Depurar y revisar el código para mejorar su claridad, consistencia y funcionalidad, y asegurar una documentación adecuada. + +### Trabajo a realizar: + +1. **Completar las funciones** siguientes, aplicando la documentación y estructura indicadas en el código inicial: + - **limpiar_pantalla()**: Debe limpiar la pantalla según el sistema operativo. + - **pausa()**: Pausar la ejecución con un mensaje. + - **mostrar_error()**: Muestra errores específicos gestionando `IndexError` y otras excepciones. + - **es_resultado_negativo()**: Verifica si el resultado de la operación debe ser negativo. + - **multiplicar()** y **dividir()**: Realizan operaciones usando solo sumas y restas. + - **potencia()**: Calcula el exponente de un número usando multiplicaciones sucesivas. Soporta los operadores `**` y `exp`. + - **calcular_operacion()**: Llama a las funciones específicas para realizar las operaciones aritméticas. + - **realizar_calculo()**: Permite realizar operaciones en secuencia, capturando números y operadores del usuario. + - **sumar()** y **restar()**: Desarrollo completo con documentación para funciones que reciben dos números `float` y devuelven el resultado de la suma o resta de estos. + - **test para la función es_resultado_negativo()**: Crear las pruebas unitarias para comprobar el buen funcionamiento de la función `es_resultado_negativo()`. + +2. **Organización del Código y Documentación**: + - Todos los programas deben tener la función `main()` para organizar el flujo del programa. + - Utilizar `DocStrings` para documentar cada función. Puedes usar el formato que prefieras (Google, reStructuredText, NumPy, o Epytext). + +3. **Organización del Repositorio en GitHub**: + - Los archivos de código se encuentran ubicados en la carpeta `src`. + - Las pruebas unitarias están en la carpeta `tests`. + +4. **Pruebas Unitarias**: + - Ejecutar pruebas unitarias para verificar el correcto funcionamiento de las funciones **realizar_calculo()**, **multiplicar()**, **dividir()**, **potencia()**, y **es_resultado_negativo()**. + +5. **IMPORTANTE: Aclaraciones sobre las operaciones de Multiplicar, Dividir y Potencia**: + + - ***No será posible la utilización de los operadores de Python para multiplicar, dividir o realizar la exponenciación de un número***. Deben ser cálculos realizados con **sumas y restas EXCLUSIVAMENTE**. + + - Habrá que ***tener en cuenta el signo*** de los números con los que se realiza el cálculo para proporcionar un resultado final correcto. + + - Las funciones recibirán argumentos de tipo float, pero ***trabajarán internamente con los números convertidos a enteros***, previamente realizando un **redondeo**: + + * Si recibe un número de 6.78, pasará a ser 7 para realizar los cálculos. + * Si recibe un número de 1.48, pasará a ser 1 para realizar los cálculos. + + - Tras lo comentado anteriormente, remarcar que las 3 funciones ***reciben argumentos tipo `float`***, trabajan internamente solo con tipos `int` y ***retornan un número tipo `int`***. + + - Para la potencia, como premisa de funcionamiento para simplificar la programación, aunque lejos de la realidad matemática, ***si recibe un exponente negativo, el resultado será 0***. + + - También cabe destacar que ***cualquier número elevado a 0 dará como resultado 1***. + + - Ejemplo de cálculo de multiplicaciones: + + * 17.88 x 3.44 => 18 x 3 => 18 + 18 + 18 = **54** + * 4.77 x -125.09 => 5 x -125 => - (125 + 125 + 125 + 125 + 125) = **-625** (cuidado con el signo que previamente debéis gestionarlo) + - Para realizar las divisiones, debemos ir restando el dividendo por el divisor, mientras el resultado sea mayor que el dividendo: + + * 25.77 : 6.02 => 26 : 6 => 26 - 6 = 20; 20 - 6 = 14; 14 - 6 = 8; 8 - 6 = 2 => el resultado de la división es **4**. + * 25.77 : -6.02 => 26 : 6 => 26 - 6 = 20; 20 - 6 = 14; 14 - 6 = 8; 8 - 6 = 2 => el resultado de la división es **-4** (cuidado con el signo que previamente debéis gestionarlo). + + - Para realizar las potencias será OBLIGATORIO el uso de la función multiplicar(), que previamente habréis desarrollado. + + * 2.33 ** 3.9996 => 2 ** 4 => 2 * 2 * 2 * 2 = **16**. + * -2.33 ** 3.9996 => 2 ** 4 => 2 * 2 * 2 * 2 = **-16** (cuidado con el signo que previamente debéis gestionarlo). + * -2.33 ** 0 => **1**. + * -2.33 ** -6 => **0**. + +7. **BONUS extra** *(opcional)*: + - *IMPORTANTE*: Este cambio debéis realizarlo en un archivo nuevo que debéis llamar `calculadora_alumnos_bonus.py`. + - De manera opcional, si termináis todo, podéis modificar el programa para que se muestre un menú, en vez de usar comandos en línea. Por ejemplo: + + ``` + Menú + 1. Realizar un cálculo secuencial. + 2. Lista de operaciones disponibles para el cálculo. + 3. Reiniciar resultado (CE). + 4. Configurar número de decimales. + 5. Salir. + ``` + + La opción 1, entraría en el cálculo secuencial directamente (lo que antes hacíamos mediante el comando `calculo`): + + ``` + ## Ingrese número, operador, 'resultado', 'cancelar' o para finalizar el cálculo ## + + (Cálculo = 0.00) >> + ``` + + La opción 2 mostraría las operaciones disponibles (lo que antes ejecutaba el comando `lista`). Pero solo deberá mostrar las operaciones y comandos disponibles dentro del cálculo secuencial (ya que los comandos `calculo`, `ce`, `decimales ` y `cadena vacía + ` ya estarían integrados en el menú al realizar la modificación que os solicitamos en el BONUS y su lógica anterior debe ser eliminada): + + ``` + Operaciones disponibles: + + => Suma + - => Resta + x o * => Multiplicación + / o : => División + ** exp => Potencia + cancelar => vovler sin actualizar el resultado de la calculadora + cadena vacía + => volver al menú actualizando el resultado de la calculadora + ``` + + La opción 3 reinicia a 0 el resultado de la calculadora *(lo que hacía anteriormente el comando `ce`)*. + + La opción 4 configura el número de decimales con el que se muestra el RESULTADO almacenado de la calculadora y los cálculos intermedios *(lo que hacía anteriormente el comando `decimales `)*. + + La opción 5 sale de la aplicación *(lo que hacíamos previamente con `cadena vacía + `)*. +--- + +### Manual de uso de la aplicación explicado con ejemplos + + - [Manual de uso de la calculadora](manual_de_uso_con_ejemplos.md) + +--- + +### Recursos + +- [U1: Introducción a la programación en Python](https://revilofe.github.io/section1/u01/). +- [U2: Sentencias condicionales y repetitivas](https://revilofe.github.io/section1/u02/). + +--- + +### Evaluación y calificación + +**Conlleva presentación**: SI + +--- + +### Rúbrica de Evaluación: + +| **Función** | **Dificultad (1-5)** | **Descripción de la Dificultad** | **0** | **1** | **2** | **3** | **4** | **5** | **Criterios de Evaluación Aplicables** | +|-------------------------|----------------------|----------------------------------------------------------------------------------------------------------|-------|-------|-------|-------|-------|-------|----------------------------------------------------------------| +| `limpiar_pantalla` | 1 | Desarrollo parcial. Corregir implementación y gestionar las excepciones. | | | | | | | | +| `pausa` | 1 | Desarrollo completo para pausar el programa con el mensaje `Presione ENTER para continuar...` | | | | | | | | +| `mostrar_error` | 3 | Corregir errores y completar el código gestionando las excepciones `IndexError` y `Exception`. | | | | | | | RA3.d, RA3.h | +| `sumar` | 2 | Desarrollo completo, incluida la documentación; recibe dos números `float` y retorna la suma de ambos. | | | | | | | RA3.g | +| `restar` | 2 | Desarrollo completo, incluida la documentación; recibe dos números `float` y retorna la resta de ambos. | | | | | | | RA3.g | +| `es_resultado_negativo` | 1 | Desarrollo completo. Verifica si el resultado de una operación debe ser negativo. | | | | | | | RA3.g | +| `multiplicar` | 5 | Desarrollo completo. Realiza multiplicación usando sumas sucesivas y ajusta el signo para el resultado. | | | | | | | RA1.d, RA1.e, RA1.g, RA1.i, RA3.a, RA3.b, RA3.e | +| `dividir` | 5 | Desarrollo completo. Realiza división usando restas sucesivas, maneja excepción división entre cero. | | | | | | | RA1.d, RA1.e, RA1.g, RA1.i, RA3.a, RA3.b, RA3.e, RA3.h | +| `potencia` | 5 | Desarrollo completo y documentación. Calcula potencias usando multiplicaciones. | | | | | | | RA1.d, RA1.e, RA1.g, RA1.i, RA3.a, RA3.b, RA3.e, RA3.g | +| `pedir_entrada` | 1 | Desarrollo parcial para eliminar espacios por delante y por detrás y conversión a minúsculas. | | | | | | | | +| `calcular_operacion` | 3 | Desarrollo parcial. Realiza operaciones llamando a funciones específicas según el operador. | | | | | | | RA1.g, RA3.a | +| `obtener_operaciones` | 1 | Desarrollo parcial. Devuelve una cadena con la lista de operaciones disponibles en la calculadora. | | | | | | | | +| `realizar_calculo` | 5 | Corregir errores y desarrollo parcial. Realiza el cálculo secuencial. | | | | | | | RA1.d, RA1.e, RA1.g, RA3.a, RA3.b, RA3.d, RA3.e | +| `main` | 5 | Corrige los errores y desarrollo parcial. Organiza el flujo principal del programa. | | | | | | | RA1.d, RA1.e, RA1.g, RA3.a, RA3.b, RA3.d, RA3.e | +| Uso de `mostrar_error` | 2 | Corrige los errores y desarrollo parcial. Organiza el flujo principal del programa. | | | | | | | | +| Uso de `return` único | 3 | Controla que cada función tenga un único `return` para simplificar el flujo y la legibilidad. | | | | | | | RA3.c | +| Uso de `constantes` | 1 | Usar adecuadamente las constantes dentro del código. | | | | | | | RA1.f | +| Cálculo de `decimales` | 2 | Implementar la lógica de actualización de las posiciones decimales del resultado y el cálculo intermedio.| | | | | | | RA1.a, RA3.g | +| `Pruebas unitarias` | 5 | Comprobación del cumplimiento correcto de las pruebas unitarias. | | | | | | | RA3.i | +| Creación de un `test` | 2 | Controla el uso de constantes predefinidas (`MENSAJES_ERROR`, `OPERADORES`) en toda la aplicación. | | | | | | | RA3.i | + +--- + +### Condiciones de entrega + +> **La entrega tiene que cumplir las condiciones de entrega para poder ser calificada. En caso de no cumplirlas podría calificarse como no entregada.** + +- Cumple la fecha y hora de entrega. +- **Entrega en GitHub Classroom**: La actividad se debe entregar utilizando el assignment creado en GitHub Classroom, que está basado en el siguiente repositorio de plantilla: [DAM-DAWB-PROG-2425_Prueba_U1-U2_Calculadora](https://github.com/dcanoIESRafaelAlberti/DAM-DAWB-PROG-2425_Prueba_U1-U2_Calculadora.git). + - El repositorio ya incluye la estructura base con carpetas como `src` y `tests`. Los estudiantes deben añadir sus soluciones en la carpeta correspondiente. + - Asegúrate de que el profesor tiene permisos para acceder a tu repositorio. Si no se puede acceder, es equivalente a no haber entregado la actividad. +- **Estructura del repositorio**: + - **Carpeta `src`**: Contendrá los programas correspondientes a los ejercicios solicitados. + - **Carpeta `tests`**: Contendrá las pruebas unitarias para verificar el correcto funcionamiento de las soluciones. + - **Carpeta `.github/workflows`**: No debe eliminarse ni modificarse su contenido. + - **Fichero `requirements.txt`**: No debe eliminarse ni modificarse su contenido. +- **Id del documento a entregar:** El nombre del repositorio será generado automáticamente por GitHub Classroom, por lo que no es necesario que los estudiantes lo modifiquen. + +--- + +### Ten en cuenta + +**Custodia** de tu documentación: + +- Es responsabilidad del alumnado la custodia y guarda de los trabajos, documentos, y cualquier otro material que realice durante las prácticas o en clase, por tanto, tendrán que asegurarse que quedan a salvo siempre que abandonen el aula, no siendo responsabilidad del profesorado la perdida de este material. +- Asegúrate de mantener copias seguras en servicios como Google Drive, GitHub, GitLab, Bitbucket, etc. + +**Fecha y defensa** de las entregas de prácticas/trabajos/ejercicios: + +- Las prácticas tendrán una fecha de entrega clara, **que no se podrá cambiar bajo ninguna circunstancia**. Quedando a elección del profesor posibles excepciones justificadas. +- Como norma general, la entrega consistirá en: + 1. Subida a la plataforma (por defecto) en fecha. + 2. Defensa en clase (si se solicita). Como regla general: + - Los ejercicios individuales se corregirán en clase delante del profesor, defendiendo el trabajo. + - Los ejercicios en grupo se podrán presentar en grupo o un componente del grupo de forma aleatoria. El método será elegido por el profesor.Corrección de las actividades. Como regla general: + +**Causas para no corregir** una entrega (ejercicio, práctica, examen): + +- No se cumplen las condiciones de entrega. +- Se ha detectado la posibilidad de copiado de todo o parte de la prueba. Esto incluye textos (total o parcial) de internet y/o sin hacer referencia a la fuente. + - **Atención** OJO con Chat GPT, Copilot, etc. -> Asegurate de saber que haces. +- Se entrega fuera de plazo (aunque sean unos segundos). +- En caso de entrega a través de GitHub: + - Añadir en el archivo `README.md` instrucciones para compilar y ejecutar el código, descripción de la aplicación, autoría y referencias. +- En caso de código: + - Si el código no compila. diff --git a/otros/calculadora.md b/otros/calculadora.md deleted file mode 100644 index 8f4ecb4..0000000 --- a/otros/calculadora.md +++ /dev/null @@ -1,41 +0,0 @@ -# Prueba Práctica U1 y U2 - Calculadora Básica en Python - -## Objetivo: -Completar el desarrollo de una calculadora que permite realizar operaciones básicas de manera interactiva en la consola. Este ejercicio integra conceptos de las Unidades 1 y 2. - -## Descripción: -Tienes un código de una calculadora en Python parcialmente desarrollado. Algunas funciones están incompletas, y otras necesitan corrección. El objetivo es que completes el código y asegures su correcto funcionamiento siguiendo las pautas y completando los comentarios indicados en el código. - -## Instrucciones: -1. **Revisa el Código Inicial**: Observa el archivo y revisa los comentarios y documentación para entender cada función y la estructura general. - -2. **Funciones Principales a Desarrollar y Completar**: - - **limpiar_pantalla()**: Debe limpiar la pantalla en función del sistema operativo (Windows, Linux/macOS). Implementa el manejo de excepciones adecuado. - - **pausa()**: Pausa la ejecución con el mensaje `"\nPresione ENTER para continuar..."`. - - **mostrar_error()**: Completa la función para manejar errores de forma profesional. Debe gestionar: - - **IndexError**: Mostrar "\n*ERROR* Mensaje de error no definido.\n". - - **Excepciones generales**: Captura cualquier otro tipo de excepción y muestra el mensaje "\n*ERROR* Problemas al mostrar error!\n{e}\n". - - **es_resultado_negativo()**: Esta función verifica si el resultado de una operación debe ser negativo. - - **multiplicar()** y **dividir()**: Completa el código de estas funciones para que realicen operaciones enteras usando sumas y restas, redondeando los números recibidos a enteros. - - **pedir_entrada()**: Debe limpiar y convertir a minúsculas cualquier entrada de usuario. - - **calcular_operacion()**: Realiza operaciones matemáticas específicas llamando a las funciones adecuadas. - - **obtener_operaciones()**: Esta función debe mostrar una lista de las operaciones que el programa puede realizar. - - **realizar_calculo()**: Implementa el cálculo secuencial, manejando adecuadamente operadores y números, guiando al usuario para introducir la información paso a paso. - -3. **Condiciones Especiales**: - - **Error Handling**: Todos los mensajes de error deben mostrarse usando `mostrar_error()`; no se permite utilizar `print()` directamente para errores. - - **Funciones de una Sola Salida**: Asegúrate de que cada función tenga **solo una instrucción `return`**. - -4. **Ejecución Principal**: - - Corrige y completa el flujo de `main()` según lo descrito en su documentación. - - Al ejecutar el programa en `main`, asegúrate de que funcione sin errores y siga el flujo especificado en el comentario de la función `main`. - -## Evaluación: -1. **Corrección y Completitud**: Cada función debe cumplir con su objetivo y la documentación provista. -2. **Control de Errores**: Los errores deben gestionarse adecuadamente a través de `mostrar_error`. -3. **Pruebas Unitarias**: La implementación debe cumplir las pruebas para verificar su funcionalidad, especialmente para `es_resultado_negativo()`, `multiplicar()`, y `dividir()`. - -## Puntos Adicionales: -- Se evaluará la claridad y la limpieza del código, así como la precisión en el uso de funciones y flujo de control. - -**Entrega**: Subir el archivo Python completo y funcional en el sistema indicado antes de la fecha límite. \ No newline at end of file diff --git a/otros/calculadora.py b/otros/calculadora.py index db9248b..60f2d2e 100644 --- a/otros/calculadora.py +++ b/otros/calculadora.py @@ -145,7 +145,7 @@ def potencia(base: float, exponente: float) -> int: Args: base (float): La base que se va a elevar. - exponente (int): El exponente al que se elevará la base. + exponente (float): El exponente al que se elevará la base. Returns: int: El resultado de elevar la base al exponente. diff --git a/otros/calculadora_enunciado.md b/otros/calculadora_enunciado.md deleted file mode 100644 index a7decea..0000000 --- a/otros/calculadora_enunciado.md +++ /dev/null @@ -1,79 +0,0 @@ -# Actividad: **Práctica Calculadora Básica en Python** - -**ID actividad:** PROG-2425-PRUEBA-U1-U2 - -**Agrupamiento de la actividad**: Individual - ---- - -### Descripción: - -La actividad consiste en completar y corregir el desarrollo de una calculadora en Python aplicando los conceptos estudiados en las Unidades 1 y 2. La calculadora permitirá realizar operaciones aritméticas básicas y deberá cumplir con el principio de "Separación de Responsabilidades". Los estudiantes deberán leer y analizar el código provisto, corregir errores y desarrollar las partes incompletas, asegurando la gestión de excepciones. - -### Objetivo: - -- Leer y analizar la documentación del código para comprender su funcionamiento y aplicar correcciones o completar las partes faltantes de la aplicación. -- Planificar y desarrollar un programa interactivo en Python, estructurando las funciones de manera que cada una tenga una única responsabilidad. -- Aplicar estructuras de control condicional y bucles para resolver problemas de forma eficiente. -- Implementar el manejo de excepciones para asegurar el correcto funcionamiento del programa y prevenir errores en su ejecución. -- Ejecutar pruebas unitarias para validar el comportamiento de las funciones, comprobando que cumplen con los requerimientos establecidos. -- Depurar y revisar el código para mejorar su claridad, consistencia y funcionalidad, y asegurar una documentación adecuada. - -### Trabajo a realizar: - -1. **Completar las funciones** siguientes, aplicando la documentación y estructura indicadas en el código inicial: - - **limpiar_pantalla()**: Debe limpiar la pantalla según el sistema operativo. - - **pausa()**: Pausar la ejecución con un mensaje. - - **mostrar_error()**: Muestra errores específicos gestionando `IndexError` y otras excepciones. - - **es_resultado_negativo()**: Verifica si el resultado de la operación debe ser negativo. - - **multiplicar()** y **dividir()**: Realizan operaciones usando solo sumas y restas. - - **potencia()**: Calcula el exponente de un número usando multiplicaciones sucesivas. Soporta los operadores `**` y `exp`. - - **calcular_operacion()**: Llama a las funciones específicas para realizar las operaciones aritméticas. - - **realizar_calculo()**: Permite realizar operaciones en secuencia, capturando números y operadores del usuario. - - **sumar()** y **restar()**: Desarrollo completo con documentación para funciones que reciben dos números `float` y devuelven el resultado de la suma o resta de estos. - -2. **Organización del Código y Documentación**: - - Todos los programas deben tener la función `main()` para organizar el flujo del programa. - - Utilizar `DocStrings` para documentar cada función. Puedes usar el formato que prefieras (Google, reStructuredText, NumPy, o Epytext). - -3. **Organización del Repositorio en GitHub**: - - Colocar todos los archivos de código en la carpeta `src`. - - Colocar las pruebas unitarias en la carpeta `tests`, nombrando cada prueba de acuerdo con el ejercicio correspondiente (por ejemplo, `test_calculadora.py`). - -4. **Pruebas Unitarias**: - - Ejecutar pruebas unitarias para verificar el correcto funcionamiento de las funciones **realizar_calculo()**, **multiplicar()**, **dividir()**, **potencia()**, y **es_resultado_negativo()**. - ---- - -### Recursos - -- [U1: Introducción a la programación en Python](https://revilofe.github.io/section1/u01/). -- [U2: Sentencias condicionales y repetitivas](https://revilofe.github.io/section1/u02/). -- Temario de clase. - ---- - -### Evaluación y calificación - -**Conlleva presentación**: NO - ---- - -### Rúbrica de Evaluación: - -| **Función** | **Dificultad (1-5)** | **Descripción de la Dificultad** | **0** | **1** | **2** | **3** | **4** | **5** | **Criterios de Evaluación Aplicables** | -|-------------------------|----------------------|----------------------------------------------------------------------------------------------------------|-------|-------|-------|-------|-------|-------|----------------------------------------------------------------| -| `limpiar_pantalla` | 1 | Desarrollo parcial. Control básico de errores en la función de limpieza. | | | | | | | RA1.a, RA1.e, RA3.a | -| `pausa` | 1 | Desarrollo completo. Implementación de pausa mediante `input()` para detener la ejecución. | | | | | | | RA1.a, RA3.a | -| `mostrar_error` | 2 | Implementación de gestión de excepciones y mensajes de error usando `IndexError` | | | | | | | RA1.f, RA1.g, RA3.a | -| `es_resultado_negativo` | 2 | Verifica si el resultado de una operación debe ser negativo | | | | | | | RA1.a, RA3.d, RA3.h | -| `sumar` | 2 | Desarrollo completo, incluida la documentación; recibe dos números `float` y retorna la suma de ambos. | | | | | | | RA1.a, RA3.g, RA3.h | -| `restar` | 2 | Desarrollo completo, incluida la documentación; recibe dos números `float` y retorna la resta de ambos. | | | | | | | RA1.a, RA3.g, RA3.h | -| `multiplicar` | 4 | Realiza multiplicación usando sumas sucesivas y ajusta el signo para el resultado | | | | | | | RA1.e, RA3.a, RA3.d | -| `dividir` | 5 | Realiza división usando restas sucesivas, maneja excepciones para división entre cero | | | | | | | RA1.e, RA1.f, RA3.a, RA3.d | -| `potencia` | 5 | Calcula potencias usando multiplicaciones y ajusta el signo para el resultado | | | | | | | RA1.e, RA1.g, RA3.a, RA3.d, RA3.h | -| `calcular_operacion` | 3 | Realiza operaciones llamando a funciones específicas según el operador | | | | | | | RA1.a, RA1.g, RA3.b | -| `realizar_calculo` | 5 | Realiza cálculo secuencial, guiando al usuario y validando las entradas y operadores | | | | | | | RA1.d, RA1.e, RA1.f, RA1.g, RA3.a, RA3.b, RA3.e | -| `main` | 4 | Organiza el flujo principal del programa, invocando funciones y gestionando el menú de opciones | | | | | | | RA1.a, RA1.g, RA3.b, RA3.e | -| **Uso único de `return` en funciones** | 3 | Controla que cada función tenga un único `return` para simplificar el flujo y la legibilidad. | | | | | | | RA1.a, RA3.g | -| **Uso adecuado de constantes** | 1 | Controla el uso de constantes predefinidas (`MENSAJES_ERROR`, `OPERADORES`) en toda la aplicación. | | | | | | | RA1.a \ No newline at end of file diff --git a/otros/manual_de_uso_con_ejemplos.md b/otros/manual_de_uso_con_ejemplos.md new file mode 100644 index 0000000..adc9e24 --- /dev/null +++ b/otros/manual_de_uso_con_ejemplos.md @@ -0,0 +1,177 @@ + +# **Manual de uso - Calculadora Interactiva** + +## **1. Inicio de la calculadora** +Cuando se inicia el programa, se muestra el nombre de la aplicación y se solicita una entrada o comando de operación: + +``` +### CALCULADORA ### + ----------- + +Operación (RES => 0.00) >> +``` + +### **2. Ver la lista de operaciones disponibles** +Escribe `lista` para ver todas las operaciones que puedes realizar con esta calculadora. El sistema mostrará la siguiente información: + +``` +Operación (RES => 0.00) >> lista + +Operaciones disponibles: + ce => Reiniciar resultado a 0 + decimales => Establecer decimales en resultado + cadena vacía + => Pregunta si desea salir + calculo => Iniciar cálculo secuencial + + => Suma + - => Resta + x o * => Multiplicación + / o : => División + ** exp => Potencia + cancelar => volver sin actualizar resultado de la calculadora + cadena vacía + => volver actualizando resultado de la calculadora + +Presione ENTER para continuar... +``` + +### **3. Cambiar el número de decimales** +Para configurar el número de decimales que se mostrarán en el resultado, ingresa `decimales` seguido del número de decimales deseado. Ejemplo: + +``` +Operación (RES => 0.00) >> decimales 3 +Decimales configurados a 3. + +Presione ENTER para continuar... +``` + +después de pulsar ENTER, el resultado de formateará con tres decimales: + +``` +Operación (RES => 0.000) >> +``` + +Esta configuración de decimales también afectará a los resultados intermedios que se produzcan en los cálculos secuenciales *(dentro de la opción `calculo`)* + +### **4. Reiniciar el resultado a cero** +Para restablecer el valor almacenado a 0, usa el comando `ce`: + +``` +Operación (RES => 18.24) >> ce +Resultado reiniciado a 0. + +Presione ENTER para continuar... +``` + +Después de pulsar ENTER, el resultado almacenado de la calculadora será 0: + +``` +Operación (RES => 0.00) >> +``` + +### **5. Secuencia de cálculos con el comando `calculo`** +Para iniciar una secuencia de cálculos, escribe `calculo`: + +``` +Operación (RES => 1.00) >> calculo + +## Ingrese número, operador, 'resultado', 'cancelar' o para finalizar el cálculo ## + + (Cálculo = 0) >> 5 + (Cálculo = 5) >> + + (Cálculo = 5) >> 3 + (Cálculo = 8) >> * + (Cálculo = 8) >> resultado + (Cálculo = 8) >> ** 2 + (Cálculo = 64) >> +``` + +5.1. **Realizar operaciones secuenciales**: + - La calculadora permite realizar cálculos secuenciales con los operadores disponibles, como `+`, `-`, `x`, `*`, `/`, `:`, `**` o `exp`. + - En el ejemplo anterior, se ingresan 5 y se suma 3, luego se multiplica el cálculo realizado por el valor almacenado en la calculadora (con `resultado`... observad que es 1... *Operación (RES => 1.00)*), y finalmente se eleva al cuadrado con `** 2`. + +5.2. **Opciones para terminar o cancelar la secuencia**: + - **Cancelar**: Para salir sin actualizar el resultado final, escribe `cancelar` y presiona . + - **Actualizar resultado**: Deja la entrada en blanco y presiona para finalizar y actualizar el resultado en la calculadora. + +5.3. **Ejemplo de salida al cancelar:** + +Si escribimas `cancelar`: + +``` +Operación (RES => 1.00) >> calculo + +## Ingrese número, operador, 'resultado', 'cancelar' o para finalizar el cálculo ## + + (Cálculo = 0) >> 5 + (Cálculo = 5) >> + + (Cálculo = 5) >> 3 + (Cálculo = 8) >> * + (Cálculo = 8) >> resultado + (Cálculo = 8) >> ** 2 + (Cálculo = 64) >> cancelar +Secuencia cancelada. Resultado almacenado sin cambios. + +Presione ENTER para continuar... +``` + +Al pulsar ENTER y volver, el resultado de la calculadora no se debe haber actualizado: + +``` +Operación (RES => 1.00) >> +``` + +5.3. **Ejemplo de salida al terminar para actualizar el resultado:** + +Si solo dejamos la entrada vacía y pulsamos ENTER: + +``` +Operación (RES => 1.00) >> calculo + +## Ingrese número, operador, 'resultado', 'cancelar' o para finalizar el cálculo ## + + (Cálculo = 0) >> 5 + (Cálculo = 5) >> + + (Cálculo = 5) >> 3 + (Cálculo = 8) >> * + (Cálculo = 8) >> resultado + (Cálculo = 8) >> ** 2 + (Cálculo = 64) >> + +Presione ENTER para continuar... +``` + +Al pulsar ENTER y volver, el resultado de la calculadora se debe haber actualizado: + +``` +Operación (RES => 64.00) >> +``` + +### **6. Salir de la calculadora** +Para cerrar la aplicación, ingresa una entrada vacía y presiona `ENTER`. La calculadora preguntará si deseas salir: + +``` +Operación (RES => 64.00) >> +¿Desea salir de la calculadora? (s/n) s +``` + +Después de contestar 's' y pulsar `ENTER`, se debe limpiar la consola y mostrar un mensaje de despedida, finalizando la aplicación: + +``` + + +Bye, bye... + + +``` + +Si contesta cualquier otra cosa, limpia la pregunta y vuelve al prompt a la espera de un comando: + +``` +Operación (RES => 64.00) >> +¿Desea salir de la calculadora? (s/n) noooo +``` + +Después de contestar 'noooo' y pulsar `ENTER` vuelve al prompt: + +``` +Operación (RES => 64.00) >> +```