Calculadora de números complejos en Java

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 Java» en nuestro canal de YouTube. Te invitamos a que lo visites.

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{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}.

Para leer un caracter en Java, usamos el método \texttt{next} y tomamos el primer caracter leído, esto lo conseguimos con el método \texttt{charAt}. Para las demás variables usamos el método \texttt{nextDouble}.

package calculadora_complejos;

import java.util.Scanner;

public class Calculadora_Complejos {

    public static void main(String[] args) {
        char operacion;
        double par_real1, par_imag1, par_real2, par_imag2;

        Scanner reader = new Scanner(System.in);
        System.out.printf("Ingrese operación (+,-,*,/):");
        operacion = reader.next().charAt(0);
        System.out.printf("Ingrese parte real del número 1: ");
        par_real1 = reader.nextDouble();
        System.out.printf("Ingrese parte imaginaria del número 1: ");
        par_imag1 = reader.nextDouble();
        System.out.printf("Ingrese parte real del número 2: ");
        par_real2 = reader.nextDouble();
        System.out.printf("Ingrese parte imaginaria del número 2: ");
        par_imag2 = reader.nextDouble();
    }
} 

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.

package calculadora_complejos;

import static java.lang.Double.NaN;
import java.util.Scanner;

public class Calculadora_Complejos {

    public static void main(String[] args) {
        char operacion;
        double par_real1, par_imag1, par_real2, par_imag2;

        Scanner reader = new Scanner(System.in);
        System.out.printf("Ingrese operación (+,-,*,/):");
        operacion = reader.next().charAt(0);
        System.out.printf("Ingrese parte real del número 1: ");
        par_real1 = reader.nextDouble();
        System.out.printf("Ingrese parte imaginaria del número 1: ");
        par_imag1 = reader.nextDouble();
        System.out.printf("Ingrese parte real del número 2: ");
        par_real2 = reader.nextDouble();
        System.out.printf("Ingrese parte imaginaria del número 2: ");
        par_imag2 = reader.nextDouble();

        double par_real = NaN, par_imag = NaN, denominador;
        switch (operacion) {
            case '+':
                break;
            case '-':
                break;
            case '*':
                break;
            case '/':
                break;
        }
        System.out.printf("El resultado es: %.3f + %.3fi%n", par_real, par_imag);
    }
} 

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 el método \texttt{pow} 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}.

package calculadora_complejos;

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

public class Calculadora_Complejos {

    public static void main(String[] args) {
        char operacion;
        double par_real1, par_imag1, par_real2, par_imag2;

        Scanner reader = new Scanner(System.in);
        System.out.printf("Ingrese operación (+,-,*,/):");
        operacion = reader.next().charAt(0);
        System.out.printf("Ingrese parte real del número 1: ");
        par_real1 = reader.nextDouble();
        System.out.printf("Ingrese parte imaginaria del número 1: ");
        par_imag1 = reader.nextDouble();
        System.out.printf("Ingrese parte real del número 2: ");
        par_real2 = reader.nextDouble();
        System.out.printf("Ingrese parte imaginaria del número 2: ");
        par_imag2 = reader.nextDouble();

        double par_real = NaN, par_imag = NaN, 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;
        }
        System.out.printf("El resultado es: %.3f + %.3fi%n", par_real, par_imag);
    }
} 

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 \texttt{true}. «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.

package calculadora_complejos;

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

public class Calculadora_Complejos {

    public static void main(String[] args) {
        char operacion;
        double par_real1, par_imag1, par_real2, par_imag2;

        Scanner reader = new Scanner(System.in);
        System.out.printf("Ingrese operación (+,-,*,/):");
        operacion = reader.next().charAt(0);
        System.out.printf("Ingrese parte real del número 1: ");
        par_real1 = reader.nextDouble();
        System.out.printf("Ingrese parte imaginaria del número 1: ");
        par_imag1 = reader.nextDouble();
        System.out.printf("Ingrese parte real del número 2: ");
        par_real2 = reader.nextDouble();
        System.out.printf("Ingrese parte imaginaria del número 2: ");
        par_imag2 = reader.nextDouble();

        boolean operacion_valida = true;
        double par_real = NaN, par_imag = NaN, 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 = false;
                System.out.printf("La operación no es válida%n");
        }
        if (operacion_valida) 
            System.out.printf("El resultado es: %.3f + %.3fi%n", par_real, par_imag);
    }
} 

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 false. Cuando al operar una división, notemos que el segundo número es cero, «levantamos» esta bandera.

package calculadora_complejos;

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

public class Calculadora_Complejos {

    public static void main(String[] args) {
        char operacion;
        double par_real1, par_imag1, par_real2, par_imag2;

        Scanner reader = new Scanner(System.in);
        System.out.printf("Ingrese operación (+,-,*,/):");
        operacion = reader.next().charAt(0);
        System.out.printf("Ingrese parte real del número 1: ");
        par_real1 = reader.nextDouble();
        System.out.printf("Ingrese parte imaginaria del número 1: ");
        par_imag1 = reader.nextDouble();
        System.out.printf("Ingrese parte real del número 2: ");
        par_real2 = reader.nextDouble();
        System.out.printf("Ingrese parte imaginaria del número 2: ");
        par_imag2 = reader.nextDouble();

        boolean division_por_cero = false;
        boolean operacion_valida = true;
        double par_real = NaN, par_imag = NaN, 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 = true;
                } 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 = false;
                System.out.printf("La operación no es válida%n");
        }
        if (operacion_valida) {
            if (division_por_cero) {
                System.out.printf("No se puede dividir entre cero%n");
            } else {
                System.out.printf("El resultado es: %.3f + %.3fi%n", par_real, par_imag);
            }
        }
    }
} 

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 Java. 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 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 *