package calculations;

/**
 * This program shows how a repetitive vector-matrix-multiplication can converge to a fixed point.
 * Such a calculation is mentioned in the lecture during the topic of the random web-surfer.  
 * @author Felix & Lars
 */
public class VectorMatrixMultiplication {

	/**
	 * Multiplies a vector times a matrix. 
	 * @param v Input vector to be multiplied (from the left hand side) with the matrix. 
	 * @param m Input matrix to be multiplied (from the right hand side) with the vector.
	 * Since matrix multiplications aren't commutative, it's important to specify that the 
	 * this method multiplies the vector times the matrix and not vice-versa. 
	 * Otherwise the result would again be a matrix and not a vector!  
	 */
	public static double[] multiply(double[] v, double[][] m) {
        assert (v.length == m.length); // vector length must be equal so matrix height
        double[] res = new double[m.length]; // result vector
        for (int j=0; j < m[0].length; ++j) { // for every row of the matrix
        	res[j] = 0; // initial value (actually also done by the java VM)
            for (int i=0; i<v.length; ++i) // for every element of the vector
            	res[j] += m[i][j] * v[i]; // += adds the product to res[j] 
        }
        return res;
    }

	/**
	 * Prints the given vector. 
	 * @param v Some arbitrary vector to print. 
	 */
	public static void show(double[] v) {
		for (int i=0; i<v.length; ++i)
			System.out.print(v[i]+" ");
		System.out.println();
	}

	/**
	 * Iterates the calculation of v times m for the given number. 
	 * @param v The input vector
	 * @param m The input matrix
	 * @param The number of times the calculation should be repeated
	 * @return Returns the result vector of the calculation. 
	 */
	public static double[] calculate(double[] v, double[][] m, int times) {
		for (int i=0; i<=times; ++i)
			v = multiply(v, m);
		return v;
	}
	
	/**
	 * Runs the calculation for different number of times. 
	 * Therefore it can be seen how the calculation converges.  
	 * @param args: Command line parameters (not used)
	 */
	public static void main(String[] args) {
		double[] v = {1,0,0,0,0}; // starting state
		double[][] m = { // transition probabilities 
				{0.1,0.3,0.2,0.1,0.3},
				{0.1,0.2,0.1,0.3,0.3},
				{0.3,0.1,0.3,0.2,0.1},
				// {0,0,0.0,0.0,0.0},
				{0.5,0.5,0.0,0.0,0.0},
				{0.9,0.0,0.0,0.1,0.0}};

		double testV[] = {1,2};
		double testM[][] = {{1,2},{3,4}};
		show(multiply(testV,testM));

		show(calculate(v,m,0));
		show(calculate(v,m,1));
		show(calculate(v,m,2));
		show(calculate(v,m,5));
		show(calculate(v,m,10));
		show(calculate(v,m,100));
		show(calculate(v,m,1000));
		show(calculate(v,m,10000));
		show(calculate(v,m,100000));
		show(calculate(v,m,1000000));
		show(calculate(v,m,10000000));
	}

}