Operaciones con una Matriz

[aux_code language=»javascript» theme=»tomorrow» title=»Operaciones con una Matriz» extra_classes=»»]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    /**
     * Variable global que establece el tamaño de las matrices
     */

    private static int TAMANNO_MATRIZ = 4;

    /**
     * author Jon Xu
     * @param args generales del main
     */

    public static void main(String[] args) {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        double[][] matriz = new double[TAMANNO_MATRIZ][TAMANNO_MATRIZ];
        double[][] matriz2 = new double[TAMANNO_MATRIZ][TAMANNO_MATRIZ];

        for (int x = 0; x < matriz.length; x++) {
            for (int y = 0; y < matriz[x].length; y++) {
                matriz[x][y] = Math.random() * 50;
                matriz2[x][y] = Math.random() * 50;
            }
        }
        try{
            System.out.println("Indica el escalar, será siempre positivo:");
            double esc = Double.parseDouble(br.readLine());
            esc = Math.abs(esc);
            visualizarMatriz("Los datos de la matriz 1 son:", matriz);
            visualizarMatriz("Los datos de la matriz 2 son:", matriz2);
            visualizarMatriz("Los resultados de la suma de las 2 matrices son:", sumar(matriz, matriz2));
            visualizarMatriz("Los resultados del escalar " + esc + " son:", escalar(esc, matriz));
            visualizarMatriz("Los resultados del producto matriz1 y matriz2 son:", producto(matriz, matriz2));
            visualizarMatriz("Los resultados de la traspuesta de la matriz1 a la matriz2 como resultado son:", trasponer(matriz, matriz2));
        } catch (NumberFormatException | IOException e) {
            System.out.println("La entrada no es correcta, me cierro.");
        }
    }

    /**
     * Reemplaza los datos de la matriz2 por la matriz
     * @param matriz valor array double, primera matriz NxN
     * @param matriz2 valor array double, segunda matriz NxN
     * @return matriz2 valor array double, segunda matriz NxN
     */
    private static double[][] trasponer(double[][] matriz, double[][] matriz2) {
        for (int x=0; x < matriz.length; x++) {
            for (int y=0; y < matriz[x].length; y++) {
                matriz2[y][x] = matriz[x][y];
            }
        }
        return matriz2;
    }

    /**
     * Calcula el producto de las 2 matrices en una única
     * @param matriz valor array double, primera matriz NxN
     * @param matriz2 valor array double, segunda matriz NxN
     * @return prod valor array double, devuelve la matriz operada al producto de sus 2 originales
     */
    private static double[][] producto(double[][] matriz, double[][] matriz2) {
        double[][] prod = new double[TAMANNO_MATRIZ][TAMANNO_MATRIZ];
        if (matriz[0].length == matriz2.length) {
            for (int x = 0; x < matriz.length; x++) {
                for (int y = 0; y < matriz2[0].length; y++) {
                    for (int k = 0; k < matriz[0].length; k++) {
                        prod[x][y] += matriz[x][k] * matriz2[k][y];
                    }
                }
            }
        }
        return prod;
    }

    /**
     * Calcula el escalar de la matriz recibida elevando al número de veces
     * @param esc valor double, escalar
     * @param matriz valor array double, matriz NxN
     * @return resul valor array double, devuelve la matriz operada al escalar
     */
    private static double[][] escalar(double esc, double[][] matriz) {
        double[][] resul = new double[TAMANNO_MATRIZ][TAMANNO_MATRIZ];
        for (int x = 0; x < resul.length; x++) {
            for (int y = 0; y < matriz[x].length; y++) {
                resul[x][y] = matriz[x][y] * esc;
            }
        }
        return resul;
    }

    /**
     * Realiza la suma de las 2 matrices y la devuelve sumada en otra matriz
     * @param m1 valor double, primera matriz NxN
     * @param m2 valor double, segunda matriz NxN
     * @return suma valor array double, resultado de la suma de las 2 matrices
     */
    private static double[][] sumar(double [][] m1, double[][] m2){
        double[][] suma = new double[TAMANNO_MATRIZ][TAMANNO_MATRIZ];
        for (int x = 0; x < suma.length; x++) {
            for (int y = 0; y < m2[x].length; y++) {
                suma[x][y] = m1[x][y] + m2[x][y];
            }
        }
        return suma;
    }

    /**
     * Visualizar por pantalla los datos contenidos en una matriz
     * @param tit valor string, título pre-muestra de datos
     * @param sumar valor double, matriz cuadrada de NxN
     */
    private static void visualizarMatriz(String tit, double[][] sumar) {
        System.out.println(tit);
        for (double[] doubles : sumar) {
            for (double aDouble : doubles) {
                System.out.format("%20.2f", aDouble);
            }
            System.out.println(" ");
        }
    }
}
[/aux_code]
Etiquetas: Sin etiquetas

Añadir un comentario

Debes estar conectado para publicar un comentario