import java.util.Random;

public class MatrixFactorization {

    /**
     * @param args
     */

    public static double[][] FactorizeMatrix(double[][] array, double[][] P, double[][] Q, int K , int steps, double alpha, double beta)
    {
        double[][] QTranspose = TransposeMatrix(Q);
        for (int step=0; step < steps; step++){
            for (int i =0; i < array.length; i++){
                for (int j=0; j<array[i].length; j++){
                    if (array[i][j] > 0.0){

                        double dotPQ = 0.0;
                        for (int z = 0; z < P[i].length; z++)
                            dotPQ += P[i][z] * QTranspose[z][j];

                        double eij = array[i][j] - dotPQ;

                        for (int k = 0; k< K; k++){
                            P[i][k] += alpha * (2 * eij * QTranspose[k][j] - beta * P[i][k]);
                            QTranspose[k][j] += alpha * (2 * eij * P[i][k] - beta * QTranspose[k][j]);
                        }
                    }
                }
            }
            double e= 0.0;
            for (int i=0; i< array.length; i++){
                for (int j=0; j<array[i].length; j++){
                    if (array[i][j] > 0.0){

                        double dotPQ = 0.0;
                        for (int z = 0; z < P[i].length; z++)
                            dotPQ += P[i][z] * QTranspose[z][j];

                        e += Math.pow( ( array[i][j] - dotPQ) ,2);

                        for (int k = 0; k< K; k++){
                            e += (beta/2) * ( Math.pow(P[i][k],2) + Math.pow(QTranspose[k][j],2));
                        }
                    }
                }
            }

            if (e < 0.001)
                break;

        }
        //Debug(transposeArray);
        System.out.println("Matrix R:");
        Debug(array);
        System.out.println("Factorized Matrix R':");
        Debug(MultiplyMatrices(P, QTranspose));
        return P;
    }

    private static double[][] MultiplyMatrices(double A[][], double B[][])
    {
        int rows = A.length;
        int cols = B[0].length;
        double C[][] = new double[rows][cols];
        for (int i=0; i<rows; i++) {
            for (int j=0; j<cols; j++) {
                double val = 0.0;
                for (int k=0; k<A[0].length; k++) {
                    val += A[i][k] * B[k][j];
                }
            C[i][j] = val;
            }
        }
        return C;
    }

    private static double[][] TransposeMatrix(double array[][])
    {
        int rows = array.length;
        int columns = array[0].length;
        double[][] transposeArray = new double[columns][rows];
        for (int i =0; i < rows; i++)
            for (int j=0; j< columns; j++)
                transposeArray[j][i] = array[i][j];

        return transposeArray;
    }

    private static void Debug(double[][] array)
    {
        for ( int i =0; i < array.length; i++){
            for (int j = 0; j < array[0].length; j++){
                    System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }
    }
    public static void main(String[] args) {

        double[][] array = {{5,3,0,1},
                            {4,0,0,1},
                            {1,1,0,5},
                            {1,0,0,4},
                            {0,1,5,4}
                        };

        int N = array.length;
        int M = array[0].length;
        int K =2;

        double[][] P = new double[N][K];
        double[][] Q = new double[M][K];

        Random generator = new Random();

        for ( int i =0; i < N; i++){
            for (int j = 0; j < K; j++){
                P[i][j]= generator.nextDouble();
            }
        }

        for ( int i =0; i < M; i++){
            for (int j = 0; j < K; j++){
                Q[i][j]= generator.nextDouble();
            }
        }

        FactorizeMatrix(array, P, Q, K, 2500, 0.0002, 0.02);


    }

}