/* Lab16.java (c) 2007 adolfo@di-mare.com */

/**
    @(#)Lab16.java 2007
    Muestra como imprimir una Matriz por filas y columnas.
    @author Adolfo Di Mare <adolfo@di-mare.com>
*/

import java.io.*; // Clases para leer desde el teclado
import java.util.*; // Random

/** Almacena una Matriz rectangular de números de punto flotante. */
class Matriz {
    /** Esta es la Matriz */
    private double m_Mat[][]; // Rep

    /** Constructor por defecto. */
    public Matriz() {
        this.m_Mat = new double[1][1];
    }
    /** Construye una Matriz de dimensiones {@code NxM}. */
    public Matriz( int N, int M ) {
        m_Mat = new double[ N ][ M ];
    }
    /** Constructor a partir de otra Matriz. */
    public Matriz( double M[][] ) {
        m_Mat = M;
    }
    /** Cantida de filas de la Matriz. */
    public int filas( ) {
        return this.m_Mat.length;
    }
    
    /** Cantida de columnas de la Matriz. */
    public int cols( ) {
        return m_Mat[0].length;
    }
    
    /** Acceso al elemento {@code M[i,j]} de la Matriz. */
    public double at( int i, int j ) {
        return m_Mat[i][j];
    }
    /** Sinónimo de {@code at(i,j)}. */
    public double get( int i, int j ) {
        return m_Mat[i][j];
    }
    /** Modifica el valor {@code M[i,j]} para que almacene {@code d}. */
    public void set( int i, int j , double d ) {
        m_Mat[i][j] = d;
    }

    /** Calcula y retorna la multiplicación {@code A * B} y la almacena.
        <li> {@code A} es una Matriz de dimensiones {@code A.filas() x A.cols()}.
        <li> {@code B} es una Matriz de dimensiones {@code B.filas() x B.cols()}.
        <li> Las dimensiones la Matriz resultado después de la multipliación son
             {@code A.filas() x B.cols()}.
        <li> Si las matrices no tienen dimensiones compatibles retorna una Matriz
              nula (sin instanciar).
    <pre>
               A[3,4]                  B[4,5]
          /               \     /        ___        \
          | 1   8   0   0 |     | 0   1 | 1 | 5   0 |
      [1]_|_0___9___9___1_|  X  | 0   3 | 5 | 8   7 |
          | 5   6   9   6 |     | 6   0 | 2 | 4   6 |
          \               /     | 0   8 |_0_| 0   0 |
                                \        [2]        /

                    Resultado Res[3,5]
                  /                    \
               0  |  0  25  41  69  56 |
         ===> [1] | 54  35  63 108 117 |
               2  | 54  71  53 109  96 |
                  \          |         /
                     0   1  [2]  3   4

          Res[1][2] == 0*1 + 9*5 + 9*2 + 1*0 == 63
    </pre>

        <br><strong>Precondiciones</strong>
        <li> {@code A} y {@code B} deben tener dimensiones compatibles.
        <li> <code> A.cols() == B.filas() </code>.
        <li> La multiplicación se hace [Fila x Columna], lo que implica que la
          cantidad de valores en la columnas de \c "A" debe ser igual a la
          cantidad de filas de \c "B".

        <br><strong>Complejidad</strong>
        <li>  O( {@code  A.cols() * B.cols() * A.cols() } )
    */
    static Matriz Multiplique( Matriz A, Matriz B ) {  // versión "método estático" de la operación
        double[][] Res = null;
        if (! ( A.cols() == B.filas() ) ) {
            return new Matriz( Res );
        }
        Res = new double [ A.filas() ] [ B.cols() ];

        for (int i=0; i<A.filas(); i++) {
            for (int j=0; j<B.cols(); j++) {
                double sum = 0;
                for (int k=0; k<A.cols(); k++) {
                    sum = sum + A.m_Mat[i][k] * B.at(k,j); // A[i,k] ==> error !!!
                }
                Res[i][j] = sum;
            }
        }
        return new Matriz( Res );
    }

    /** Retorna el producto de la Matriz por {@code B}. 
        <li> Sinónimo de {@code Multiplique( this, B )}.
        <br><strong>Precondiciones</strong>
        <li> Las mismas de {@code Multiplique( this, B )}.
    */
    Matriz Multiplique( Matriz B ) {  // versión "método" de la operación
        return Multiplique( this, B );
    }
    
    /** Retorna la suma de la Matriz con {@code B}. 
        <li> Sinónimo de {@code Multiplique( this, B )}.
        <li> Si las matrices no tienen dimensiones compatibles retorna una Matriz
              nula (sin instanciar).
    */
    Matriz Sume( Matriz B ) {  // versión "método" de la operación
        double[][] Res = null;
        if (! ( ( filas() == B.filas() ) && ( cols() == B.cols() ) ) ) {
            return new Matriz( Res );
        }

        Res = new double [ filas() ] [ cols() ];
        for (int i=0; i<filas(); i++) {
            for (int j=0; j<B.cols(); j++) {
                Res[i][j] = at(i,j) + B.m_Mat[i][j];
            }
        }
        return new Matriz( Res );
    }
    
    /** Imprime la Matriz {@code M}.
        <li> si {@code porFilas} es {@code true} la imprime por filas.
        <li> en caso contrario la imprime por columnas.
    */
    static void grabaMatriz( String nombre, double M[][], boolean porFilas ) {
        // M.length    ==> número total de filas
        // M[i].length ==> número de columnas (en la fila i)

        System.out.print( nombre + "[" + (M.length) + "][" + (M[0].length)+ "]");
        if ( porFilas ) {
            System.out.println( " (por filas)" );
            for (int i=0; i<M.length; ++i) {
                for (int j=0; j<M[i].length; ++j) {
                    System.out.print( " " + (M[i][j]) );
                }
                System.out.println( );
            }
        } 
        else { // graba por columnas
            System.out.println( " (por columnas)" );
            for (int j=0; j<M[0].length; ++j) {
                for (int i=0; i<M.length; ++i) {
                    System.out.print( " " + (M[i][j]) );
                }
                System.out.println( );
            }
        }

    }

    /** Imprime la Matriz {@code Matriz}.
        <li> si {@code porFilas} es {@code true} la imprime por filas.
        <li> en caso contrario la imprime por columnas.
    */
    void grabaMatriz( String nombre, boolean porFilas ) {
        Matriz.grabaMatriz( nombre, this.m_Mat, porFilas );
    }

    /** Llena la Matriz {@code M} de valores, por filas, comenzando en uno. */
    static void llenarValores( double M[][] ) {
        int n = 0;
        for (int i=0; i<M.length; ++i) {
            for (int j=0; j<M[i].length; ++j) {
                M[i][j] = n;
                ++n;
            }
        }
    }
}

/**  Clase que contiene el programa principal. */
public class Lab16 {
    /** Programa principal. */
    public static void main( String args[] ) throws IOException {
        main_imprime( args );
        main_mult( args );
    }
   
    /** Graba una Matriz por filas y por columnas. */
    public static void main_imprime( String args[] ) throws IOException {
        BufferedReader CIN = new BufferedReader( new InputStreamReader(System.in) );
        int N,M; // la Matrizotota tiene dimensiones NxM
        // N = (int) CIN.read(); // lee la cantidad de filas de la Matriz
        // M = (int) CIN.read(); // lee la cantidad de columnas de la Matriz
        N = 3; M = 4;

        double Mat[][]; // La Matrizotota
        Mat = new double[ N ][ M ]; // Matrizota de tamaño NxM

        Matriz.llenarValores( Mat );
        Matriz.grabaMatriz( "Mat" , Mat, true );
        Matriz.grabaMatriz( "Mat" , Mat, false ); 
    }

    /** Efectúa la multiplicación {@code Res = A x B}.
    */
    public static void main_mult( String args[] ) throws IOException {
        Matriz A,B, Res;
        A = new Matriz( 3 , 4 );
        B = new Matriz( 4 , 5 );

        Random rand = new Random( 1492 ); // inicializa la semilla aleatoria
        for (int i=0; i < A.filas(); i++) {
            for (int j=0; j < A.cols(); j++) {
                A.set(i,j, (double)( (rand.nextInt( 4 ) > 0) ? rand.nextInt( 10 ) : 0 ) );
            }                   // 25% de ceros en la Matriz
        }
        A.grabaMatriz( "A", true );

        for (int i=0; i < B.filas(); i++) {
            for (int j=0; j < B.cols(); j++) {
                B.set(i,j, (double)( (rand.nextInt( 4 ) > 0) ? rand.nextInt( 10 ) : 0 ) );
            }                   // 25% de ceros en la Matriz
        }
        B.grabaMatriz( "B", true );

        Res = Matriz.Multiplique( A, B );
        Res.grabaMatriz( "Res", true );

        Res = A.Multiplique( B );
        Res.grabaMatriz( "Res", true );
        return;
    }
}

// EOF: lab16.cpp