Programación en Java: Matrices, Números Complejos y Serie de Fibonacci con Ejemplos de Código

Matrices bidimensionales en Java: eliminación de filas y columnas

Una matriz bidimensional es una estructura de datos organizada en filas y columnas, equivalente a una matriz matemática. A continuación se muestran métodos para eliminar una fila o una columna de una matriz de tipo double.

a) Eliminar la n-ésima fila

El siguiente método devuelve una nueva matriz sin la fila indicada por el índice n:

public static double[][] quitarFila(double[][] m, int n) {
    if (!esMatriz(m)) {
        return null;
    }
    if (n >= m.length || n < 0) {
        return null;
    }
    double[][] res = new double[m.length - 1][m[0].length];
    for (int i = 0; i < res.length; i++) {
        for (int j = 0; j < res[i].length; j++) {
            if (i < n) {
                res[i][j] = m[i][j];
            } else if (i >= n && i + 1 < m.length) {
                res[i][j] = m[i + 1][j];
            }
        }
    }
    return res;
}

b) Eliminar una columna en lugar de una fila

Para eliminar una columna se define el método quitarCol, cuya firma es la siguiente:

public static double[][] quitarCol(double[][] m, int n)

Obtención de la submatriz menor (getMC)

El método getMC combina ambas operaciones para obtener el menor complementario de un elemento de la matriz, eliminando la fila i y la columna j:

public static double[][] getMC(double[][] m, int i, int j) {
    double[][] res = quitarFila(m, i);
    if (res == null) {
        return null;
    }
    res = quitarCol(res, j);
    if (res == null) {
        return null;
    }
    return res;
}

Números complejos: construcción a partir de coordenadas polares y cartesianas

Un número complejo puede representarse en forma polar, mediante su módulo y su argumento, o en forma cartesiana, mediante su parte real e imaginaria. La clase Complejos permite trabajar con ambas representaciones.

a) Definición de la clase Complejos

public class Complejos {
    private double modulo;
    private double argumento;

    // Constructor en forma polar
    public Complejos(double mod, double arg) {
        modulo = mod;
        argumento = arg;
    }

    // Constructor en forma cartesiana
    public Complejos(char cartesianas, double pReal, double pIm) {
        actualizaPolares(pReal, pIm);
    }

    private void actualizaPolares(double pRe, double pIm) {
        modulo = Math.sqrt(pRe * pRe + pIm * pIm);
        argumento = Math.atan(pIm / pRe);
    }

    public double getModulo() { return modulo; }
    public double getArgumento() { return argumento; }

    public void setModulo(double mod) { modulo = mod; }
    public void setArgumento(double arg) { argumento = arg; }

    // Multiplicación: se multiplican los módulos y se suman los argumentos
    public Complejos multiplicar(Complejos c) {
        return new Complejos(modulo * c.getModulo(), argumento + c.getArgumento());
    }

    // División: se dividen los módulos y se restan los argumentos
    public Complejos dividir(Complejos c) {
        return new Complejos(modulo / c.getModulo(), argumento - c.getArgumento());
    }

    // Potencia: el módulo se eleva a n y el argumento se multiplica por n
    public Complejos potencia(double n) {
        return new Complejos(Math.pow(modulo, n), n * argumento);
    }
}

b) Método main: multiplicación de dos complejos en forma polar

El siguiente programa solicita por teclado el módulo y el argumento de dos números complejos y muestra el resultado de su multiplicación:

public static void main(String[] args) {
    System.out.print("Introduzca módulo del complejo 1: ");
    double M1 = Teclado.readDouble();
    System.out.print("Introduzca argumento del complejo 1: ");
    double A1 = Teclado.readDouble();
    System.out.print("Introduzca módulo del complejo 2: ");
    double M2 = Teclado.readDouble();
    System.out.print("Introduzca argumento del complejo 2: ");
    double A2 = Teclado.readDouble();

    Complejos c1 = new Complejos(M1, A1);
    Complejos c2 = new Complejos(M2, A2);
    Complejos multiplicacion = c1.multiplicar(c2);

    System.out.println("Módulo de multiplicación: " + multiplicacion.getModulo());
    System.out.println("Argumento de multiplicación: " + multiplicacion.getArgumento());
}

Serie de Fibonacci: implementación iterativa

La serie de Fibonacci es una sucesión en la que cada término es la suma de los dos anteriores. El siguiente método calcula el n-ésimo término de forma iterativa, lo que evita el coste exponencial de la versión recursiva:

public static int fibonacciI(int n) {
    if (n < 0) return -1;
    if (n == 0 || n == 1) return 1;
    int f_1 = 1, f_2 = 1, f = 0;
    for (int i = 2; i <= n; i++) {
        f = f_1 + f_2;
        f_2 = f_1;
        f_1 = f;
    }
    return f;
}

Conclusiones

Los ejemplos presentados muestran cómo aplicar en Java conceptos fundamentales de álgebra matricial, números complejos y algoritmos iterativos, habituales en asignaturas de Informática y Telecomunicaciones.