Rotar matriz 90º. Uso de librería "Apache Commons Math".

Objetivo:

El objetivo del algoritmo es rotar una matriz o tabla de distancias 90 grados en sentido horario utilizando la librería Apache Commons Math.
La librería Apache Commons Math se utiliza para manejar eficientemente las operaciones matriciales, proporcionando una estructura de datos robusta (RealMatrix) y métodos optimizados para acceder y modificar los elementos de la matriz.

Requisitos:

- NetBeans IDE
- Apache Commons Math (versión 3.6.1)

Pasos:

1. Descarga la librería Apache Commons Math 3.6.1 desde:
   https://archive.apache.org/dist/commons/math/binaries/
2. Buscar, descargar y descomprimir el archivo "commons-math3-3.6.1-bin.zip".
3. En NetBeans, añadir la librería "commons-math3-3.6.1.jar" al proyecto.

Código Java (MatrixRotator.java):

package matrixrotator;

import org.apache.commons.math3.linear.Array2DRowRealMatrix;
import org.apache.commons.math3.linear.RealMatrix;

public class MatrixRotator {

    public static RealMatrix rotate90Degrees(RealMatrix matrix) {
        int rows = matrix.getRowDimension();
        int cols = matrix.getColumnDimension();

        RealMatrix rotatedMatrix = new Array2DRowRealMatrix(cols, rows);

        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                rotatedMatrix.setEntry(j, rows - 1 - i, matrix.getEntry(i, j));
            }
        }

        return rotatedMatrix;
    }

    public static void printMatrix(RealMatrix matrix) {
        for (int i = 0; i < matrix.getRowDimension(); i++) {
            for (int j = 0; j < matrix.getColumnDimension(); j++) {
                System.out.printf("%6d", (int) matrix.getEntry(i, j));
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        double[][] data = {
            {0, 610, 703, 319, 90, 290, 219, 564},
            {12, 0, 897, 165, 549, 786, 859, 303},
            {505, 115, 0, 535, 445, 677, 639, 44},
            {359, 366, 581, 0, 848, 322, 841, 165},
            {500, 128, 653, 500, 0, 903, 789, 449},
            {559, 93, 314, 176, 404, 0, 130, 964},
            {55, 349, 2, 787, 622, 425, 0, 58},
            {909, 447, 276, 860, 388, 624, 666, 0}
        };

        RealMatrix matrix = new Array2DRowRealMatrix(data);

        System.out.println("Matriz original:");
        printMatrix(matrix);

        RealMatrix rotatedMatrix = rotate90Degrees(matrix);

        System.out.println("\nMatriz rotada 90 grados:");
        printMatrix(rotatedMatrix);
    }
}


Resultado:

run:
Matriz original:
     0   610   703   319    90   290   219   564
    12     0   897   165   549   786   859   303
   505   115     0   535   445   677   639    44
   359   366   581     0   848   322   841   165
   500   128   653   500     0   903   789   449
   559    93   314   176   404     0   130   964
    55   349     2   787   622   425     0    58
   909   447   276   860   388   624   666     0

Matriz rotada 90 grados:
   909    55   559   500   359   505    12     0
   447   349    93   128   366   115     0   610
   276     2   314   653   581     0   897   703
   860   787   176   500     0   535   165   319
   388   622   404     0   848   445   549    90
   624   425     0   903   322   677   786   290
   666     0   130   789   841   639   859   219
     0    58   964   449   165    44   303   564
BUILD SUCCESSFUL (total time: 0 seconds)

Conversor matriz de distancias a coordenadas cartesianas(MDS) usando librería "Apache Commons Math".

 Este algoritmo implementa el algoritmo de Escalamiento Multidimensional (MDS) para transformar matrices de distancias en coordenadas cartesianas utilizando la librería "Apache Commons Math".

Requisitos:
- NetBeans IDE
- Apache Commons Math (versión 3.6.1)

Pasos:
1. Descarga la librería Apache Commons Math 3.6.1 desde:
   https://archive.apache.org/dist/commons/math/binaries/
2. Busca y descarga el archivo "commons-math3-3.6.1-bin.zip".
3. En NetBeans, añadir la librería al proyecto.



Código Java (DistanceToCoordinates.java):

package distancetocoordinates;

import org.apache.commons.math3.linear.Array2DRowRealMatrix;
import org.apache.commons.math3.linear.EigenDecomposition;
import org.apache.commons.math3.linear.RealMatrix;

public class DistanceToCoordinates {

    private final double[][] distanceMatrix;
    private final int dimensions;

    public DistanceToCoordinates(double[][] distanceMatrix) {
        this.distanceMatrix = distanceMatrix;
        this.dimensions = distanceMatrix.length;
    }

    public double[][] calculateCoordinates() {
        // Paso 1: Calcular la matriz B
        double[][] B = calculateBMatrix();

        // Paso 2: Realizar la descomposición en valores propios de B
        EigenDecomposition eigen = new EigenDecomposition(new Array2DRowRealMatrix(B));

        // Paso 3: Obtener los valores propios y vectores propios
        double[] eigenvalues = eigen.getRealEigenvalues();
        RealMatrix eigenvectors = eigen.getV();

        // Paso 4: Ordenar los valores propios en orden descendente
        Integer[] indices = new Integer[dimensions];
        for (int i = 0; i < dimensions; i++) {
            indices[i] = i;
        }
        java.util.Arrays.sort(indices, (a, b) -> Double.compare(eigenvalues[b], eigenvalues[a]));

        // Paso 5: Calcular las coordenadas
        double[][] coordinates = new double[dimensions][dimensions];
        for (int i = 0; i < dimensions; i++) {
            for (int j = 0; j < dimensions; j++) {
                coordinates[i][j] = Math.sqrt(Math.max(0, eigenvalues[indices[j]])) * eigenvectors.getEntry(i, indices[j]);
            }
        }

        return coordinates;
    }

    private double[][] calculateBMatrix() {
        double[][] B = new double[dimensions][dimensions];
        double[] rowMeans = new double[dimensions];
        double totalMean = 0;

        // Calcular los cuadrados de las distancias
        for (int i = 0; i < dimensions; i++) {
            for (int j = 0; j < dimensions; j++) {
                B[i][j] = -0.5 * distanceMatrix[i][j] * distanceMatrix[i][j];
                rowMeans[i] += B[i][j];
                totalMean += B[i][j];
            }
            rowMeans[i] /= dimensions;
        }
        totalMean /= (dimensions * dimensions);

        // Centrar la matriz B
        for (int i = 0; i < dimensions; i++) {
            for (int j = 0; j < dimensions; j++) {
                B[i][j] = B[i][j] - rowMeans[i] - rowMeans[j] + totalMean;
            }
        }

        return B;
    }

    public static void main(String[] args) {
        double[][] distanceMatrix = {
            {0, 3538196.0, 3735982.0, 6458578.0, 4011596.0, 1278244.0, 4456652.0, 7001752.0},
            {3538196.0, 0, 6073624.0, 9765551.0, 5373577.0, 8563521.0, 9075418.0, 7378972.0},
            {3735982.0, 6073624.0, 0, 4434730.0, 1077102.0, 1125242.0, 3435080.0, 2347484.0},
            {6458578.0, 9765551.0, 4434730.0, 0, 7999311.0, 3946544.0, 1846094.0, 1283370.0},
            {4011596.0, 5373577.0, 1077102.0, 7999311.0, 0, 8920411.0, 1777521.0, 7183199.0},
            {1278244.0, 8563521.0, 1125242.0, 3946544.0, 8920411.0, 0, 6221466.0, 7883823.0},
            {4456652.0, 9075418.0, 3435080.0, 1846094.0, 1777521.0, 6221466.0, 0, 2385324.0},
            {7001752.0, 7378972.0, 2347484.0, 1283370.0, 7183199.0, 7883823.0, 2385324.0, 0}
        };

        DistanceToCoordinates calculator = new DistanceToCoordinates(distanceMatrix);
        double[][] coordinates = calculator.calculateCoordinates();

        // Imprimir las coordenadas
        for (int i = 0; i < coordinates.length; i++) {
            System.out.print("Nodo " + (char) ('A' + i) + ": [ ");
            for (int j = 0; j < coordinates[i].length; j++) {
                System.out.printf("%.4f ", coordinates[i][j]);
            }
            System.out.println("]");
        }
    }
}


Resultado:

run:
Nodo A: [ -2109176,7652 -2280795,2868 943542,6755 1167238,5398 -0,0000 -0,0000 -0,0000 0,0000 ]
Nodo B: [ -5501880,3926 -340732,2628 -2558730,8576 335704,8847 -0,0000 0,0000 0,0000 0,0000 ]
Nodo C: [ 100046,1854 -133636,2798 255465,7042 -1991154,7275 -0,0000 -0,0000 -0,0000 0,0000 ]
Nodo D: [ 4430934,9160 -101468,6811 -792915,6722 616290,8194 -0,0000 0,0000 -0,0000 0,0000 ]
Nodo E: [ -2944669,9418 2839449,1084 2485778,2633 -376992,5883 -0,0000 0,0000 -0,0000 -0,0000 ]
Nodo F: [ 1720031,9254 -4810714,6137 579380,6506 -443374,3002 -0,0000 -0,0000 0,0000 -0,0000 ]
Nodo G: [ 2087917,4093 2241964,4880 1969418,4176 812990,9949 -0,0000 -0,0000 0,0000 0,0000 ]
Nodo H: [ 2216796,6634 2585933,5278 -2881939,1813 -120703,6228 -0,0000 -0,0000 -0,0000 -0,0000 ]
BUILD SUCCESSFUL (total time: 0 seconds)

Conversor matriz de distancias a coordenadas cartesianas (MDS).

El algoritmo es conocido como Escalamiento Multidimensional(MDS) y puede ser utilizado para:

   . Reconstrucción de coordenadas: A partir de las distancias entre puntos, reconstruye sus posiciones relativas en un espacio en coordenadas cartesianas.
   . Visualización de datos: Permite representar en un espacio de menor dimensión (generalmente 2D o 3D) datos que originalmente están en un espacio de mayor dimensión.


Funcionamiento:

   1. Entrada: El algoritmo toma como entrada las distancias entre cuatro puntos o nodos en un espacio tridimensional.
   2. Proceso: Utiliza estas distancias para construir una matriz de distancias, la cual se transforma y se somete a una descomposición en valores singulares (SVD).
   3. Salida: Produce las coordenadas cartesianas (x, y, z) de los cuatro puntos (en el espacio 3D).


Código Java (CalculadorCoordenadasMDS.java):

package calculadorcoordenadasmds;

public class CalculadorCoordenadasMDS {

    public static void main(String[] args) {
        // Distancias dadas entre los nodos
        double d12 = 17;
        double d13 = 40;
        double d14 = 12;
        double d23 = 64;
        double d24 = 88;
        double d34 = 12;

        try {
            double[][] coordinates = calculateCoordinates(d12, d13, d14, d23, d24, d34);
            for (int i = 0; i < coordinates.length; i++) {
                System.out.printf("Nodo %d: (%.4f, %.4f, %.4f)%n",
                        i + 1, coordinates[i][0], coordinates[i][1], coordinates[i][2]);
            }
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
        }
    }

    public static double[][] calculateCoordinates(double d12, double d13, double d14, double d23, double d24, double d34) {
        double[][] distances = {
            {0, d12, d13, d14},
            {d12, 0, d23, d24},
            {d13, d23, 0, d34},
            {d14, d24, d34, 0}
        };

        double[][] b = new double[4][4];
        // Doble centrado de la matriz de distancias
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                b[i][j] = -0.5 * (distances[i][j] * distances[i][j]);
            }
        }

        double[] rowMeans = new double[4];
        double[] colMeans = new double[4];
        double totalMean = 0.0;

        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                rowMeans[i] += b[i][j];
                colMeans[j] += b[i][j];
            }
            rowMeans[i] /= 4.0;
            totalMean += rowMeans[i];
        }
        totalMean /= 4.0;

        for (int i = 0; i < 4; i++) {
            colMeans[i] /= 4.0;
        }

        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                b[i][j] += totalMean - rowMeans[i] - colMeans[j];
            }
        }

        SVDResult svd = svd(b);
        double[][] coordinates = new double[4][3];

        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 3; j++) {
                coordinates[i][j] = svd.u[i][j] * Math.sqrt(svd.s[j]);
            }
        }

        return coordinates;
    }

    // Implementación simple de SVD
    private static SVDResult svd(double[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;
        double[][] u = new double[m][m];
        double[] s = new double[Math.min(m, n)];
        double[][] v = new double[n][n];

        // Implementación simplificada de SVD (no es una implementación completa)
        // Esta implementación asume que la matriz es simétrica y positiva semidefinida
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                u[i][j] = matrix[i][j];
            }
        }

        // Calculamos los valores propios (que serán nuestros valores singulares)
        for (int i = 0; i < s.length; i++) {
            double sum = 0;
            for (int j = 0; j < n; j++) {
                sum += matrix[i][j] * matrix[i][j];
            }
            s[i] = Math.sqrt(sum);
        }

        // Normalizamos las columnas de U
        for (int j = 0; j < m; j++) {
            double norm = 0;
            for (int i = 0; i < m; i++) {
                norm += u[i][j] * u[i][j];
            }
            norm = Math.sqrt(norm);
            if (norm > 0) {
                for (int i = 0; i < m; i++) {
                    u[i][j] /= norm;
                }
            }
        }

        return new SVDResult(u, s, v);
    }

    private static class SVDResult {

        double[][] u;
        double[] s;
        double[][] v;

        SVDResult(double[][] u, double[] s, double[][] v) {
            this.u = u;
            this.s = s;
            this.v = v;
        }
    }
}


Resultado:

run:
Nodo 1: (-10,9518, 13,1281, -18,6443)
Nodo 2: (22,3223, 37,7579, -18,2671)
Nodo 3: (-20,6027, -11,8716, 15,7343)
Nodo 4: (9,2322, -39,0143, 21,1772)
BUILD SUCCESSFUL (total time: 0 seconds)