Calculadora de números complejos en C

Más ejercicios resueltos

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

El diseño de una calculadora de números complejos es un ejercicio básico que permite entender el funcionamiento de las condicionales anidadas y selectivas múltiples. En este artículo analizamos con bastante detalle este ejercicio poniendo énfasis en la lógica de programación y en la estructura selectiva anidada y múltiple empleando como herramienta PSeInt. Si deseas conocer con más detalle el enunciado del ejercicio calculadora de números complejos, haz click en el siguiente enlace.

El análisis de este ejercicio se encuentra sintetizado en el vídeo «Selectivas Anidadas en C» en nuestro canal de YouTube. Te invitamos a que lo visites.

Lectura de datos

La lectura de datos en ANSI C la realizaremos con la función \texttt{scanf}. Recuerde que para poder usar esta función, se debe incluir el archivo de cabecera \texttt{stdio.h} (Standard Input Output). Usaremos la variable \texttt{operacion} para leer la operación aritmética. Para leer el primer número complejo usaremos las variables \texttt{par\_real1} y \texttt{par\_imag1}. De forma análoga, para leer el segundo número complejo usaremos las variables \texttt{par\_real2} y \texttt{par\_imag2}.

#include <stdio.h>

int main() {
    char operacion;
    double par_real1, par_imag1, par_real2, par_imag2;

    printf("Ingrese operación (+,-,*,/):");
    scanf("%c", &operacion);
    printf("Ingrese parte real del número 1: ");
    scanf("%lf", &par_real1);
    printf("Ingrese parte imaginaria del número 1: ");
    scanf("%lf", &par_imag1);
    printf("Ingrese parte real del número 2: ");
    scanf("%lf", &par_real2);
    printf("Ingrese parte imaginaria del número 2: ");
    scanf("%lf", &par_imag2);

    return 0;
} 

Control de flujo para las operaciones aritméticas

Para el control de flujo usaremos la instrucción \texttt{switch}. El selector será la variable \texttt{operacion} y cada flujo alternativo lo etiquetamos con la cláusula \texttt{case}.

Para almacenar el resultado usaremos las variables \texttt{par\_real} y \texttt{par\_imag}. La idea es calcular el valor de estas variables en cada flujo alternativo de acuerdo a la regla de cada operación.

#include <stdio.h>

int main() {
    char operacion;
    double par_real1, par_imag1, par_real2, par_imag2;

    printf("Ingrese operación (+,-,*,/):");
    scanf("%c", &operacion);
    printf("Ingrese parte real del número 1: ");
    scanf("%lf", &par_real1);
    printf("Ingrese parte imaginaria del número 1: ");
    scanf("%lf", &par_imag1);
    printf("Ingrese parte real del número 2: ");
    scanf("%lf", &par_real2);
    printf("Ingrese parte imaginaria del número 2: ");
    scanf("%lf", &par_imag2);

    double par_real, par_imag, denominador;
    switch (operacion) {
        case '+':
            break;
        case '-':
            break;
        case '*':
            break;
        case '/':
            break;
    }
    printf("El resultado es: %.3lf + %.3lfi\n", par_real, par_imag);
    return 0;
} 

Calculando el resultado

El siguiente paso corresponde al cálculo de la operación propiamente dicha. Se realizarán 4 cálculos, uno en cada camino alternativo (\texttt{+}, \texttt{-}, \texttt{*}, \texttt{/}). Recuerde que la función \texttt{pow} permite elevar un número a cualquier potencia. Para poder usar esta función, se debe incluir el archivo de cabecera \texttt{math.h}

#include <stdio.h>
#include <math.h>

int main() {
    char operacion;
    double par_real1, par_imag1, par_real2, par_imag2;

    printf("Ingrese operación (+,-,*,/):");
    scanf("%c", &operacion);
    printf("Ingrese parte real del número 1: ");
    scanf("%lf", &par_real1);
    printf("Ingrese parte imaginaria del número 1: ");
    scanf("%lf", &par_imag1);
    printf("Ingrese parte real del número 2: ");
    scanf("%lf", &par_real2);
    printf("Ingrese parte imaginaria del número 2: ");
    scanf("%lf", &par_imag2);

    double par_real, par_imag, denominador;
    switch (operacion) {
        case '+':
            par_real = par_real1 + par_real2;
            par_imag = par_imag1 + par_imag2;
            break;
        case '-':
            par_real = par_real1 - par_real2;
            par_imag = par_imag1 - par_imag2;
            break;
        case '*':
            par_real = par_real1 * par_real2 - par_imag1*par_imag2;
            par_imag = par_real1 * par_imag2 + par_imag1*par_real2;
            break;
        case '/':
            denominador = pow(par_real2, 2) + pow(par_imag2, 2);
            par_real = par_real1 * par_real2 + par_imag1*par_imag2;
            par_real /= denominador;
            par_imag = par_imag1 * par_real2 - par_real1*par_imag2;
            par_imag /= denominador;
            break;
    }
    printf("El resultado es: %.3lf + %.3lfi\n", par_real, par_imag);
    return 0;
} 

Validando la operación leída

Para validar la operación leída usaremos una bandera. Inicializamos la variable \texttt{operación\_valida}  con el valor de 1, que en ANSI C representa el valor de «verdadero». «Bajamos» la bandera cuando la instrucción \texttt{switch} detecta una operación no reconocida. Para esto usamos la cláusula \texttt{default}. Antes de imprimir el resultado, verificamos si la bandera está «levantada», lo que significa que la operación es válida.

#include <stdio.h>
#include <math.h>

int main() {
    char operacion;
    double par_real1, par_imag1, par_real2, par_imag2;

    printf("Ingrese operación (+,-,*,/):");
    scanf("%c", &operacion);
    printf("Ingrese parte real del número 1: ");
    scanf("%lf", &par_real1);
    printf("Ingrese parte imaginaria del número 1: ");
    scanf("%lf", &par_imag1);
    printf("Ingrese parte real del número 2: ");
    scanf("%lf", &par_real2);
    printf("Ingrese parte imaginaria del número 2: ");
    scanf("%lf", &par_imag2);

    int operacion_valida = 1;
    double par_real, par_imag, denominador;
    switch (operacion) {
        case '+':
            par_real = par_real1 + par_real2;
            par_imag = par_imag1 + par_imag2;
            break;
        case '-':
            par_real = par_real1 - par_real2;
            par_imag = par_imag1 - par_imag2;
            break;
        case '*':
            par_real = par_real1 * par_real2 - par_imag1*par_imag2;
            par_imag = par_real1 * par_imag2 + par_imag1*par_real2;
            break;
        case '/':
            denominador = pow(par_real2, 2) + pow(par_imag2, 2);
            par_real = par_real1 * par_real2 + par_imag1*par_imag2;
            par_real /= denominador;
            par_imag = par_imag1 * par_real2 - par_real1*par_imag2;
            par_imag /= denominador;
            break;
        default:
            operacion_valida = 0;
            printf("La operación no es válida\n");
    }
    if (operacion_valida)
        printf("El resultado es: %.3lf + %.3lfi\n", par_real, par_imag);
    return 0;
} 

Validando división entre cero

El último paso corresponde con la validación de la división entre cero. También usaremos una bandera para este caso. Estamos definiendo la variable \texttt{division\_por\_cero} la cual inicializamos con 0. Cuando al operar una división, notemos que el segundo número es cero, «levantamos» esta bandera.

#include <stdio.h>
#include <math.h>

int main() {
    char operacion;
    double par_real1, par_imag1, par_real2, par_imag2;

    printf("Ingrese operación (+,-,*,/):");
    scanf("%c", &operacion);
    printf("Ingrese parte real del número 1: ");
    scanf("%lf", &par_real1);
    printf("Ingrese parte imaginaria del número 1: ");
    scanf("%lf", &par_imag1);
    printf("Ingrese parte real del número 2: ");
    scanf("%lf", &par_real2);
    printf("Ingrese parte imaginaria del número 2: ");
    scanf("%lf", &par_imag2);

    int division_por_cero = 0;
    int operacion_valida = 1;
    double par_real, par_imag, denominador;
    switch (operacion) {
        case '+':
            par_real = par_real1 + par_real2;
            par_imag = par_imag1 + par_imag2;
            break;
        case '-':
            par_real = par_real1 - par_real2;
            par_imag = par_imag1 - par_imag2;
            break;
        case '*':
            par_real = par_real1 * par_real2 - par_imag1*par_imag2;
            par_imag = par_real1 * par_imag2 + par_imag1*par_real2;
            break;
        case '/':
            denominador = pow(par_real2, 2) + pow(par_imag2, 2);
            if (denominador == 0)
                division_por_cero = 1;
            else {
                par_real = par_real1 * par_real2 + par_imag1*par_imag2;
                par_real /= denominador;
                par_imag = par_imag1 * par_real2 - par_real1*par_imag2;
                par_imag /= denominador;
            }
            break;
        default:
            operacion_valida = 0;
            printf("La operación no es válida\n");
    }
    if (operacion_valida)
        if (division_por_cero)
            printf("No se puede dividir entre cero\n");
        else
            printf("El resultado es: %.3lf + %.3lfi\n", par_real, par_imag);
    return 0;
} 

Conclusión

Hemos presentado en este artículo, una propuesta de solución al diseño de una calculadora de operaciones aritméticas de números complejos en ANSI C. Se ha utilizado para el control de flujo una estructura selectiva múltiple. 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 PSeInt y en otros lenguajes de programación. Te invitamos a leer los siguientes artículos de iterando++

Si quieres profundizar en el lenguaje ANSI C, no hay mejor libro que C Programming Language de Brian Kernighan  y Dennis Ritchie. Es un libro clásico escrito por el creador del lenguaje C. Uno de los libros favoritos de los que inician en ANSI C es  C Programming Absolute Beginner’s Guide de Greg Perry y Dean Miller.

Deja una respuesta

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