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
		// TODO: Add code here
        // Perform the multiplication of the vector times the matrix. 
        // http://de.wikipedia.org/wiki/Falksches_Schema
        // for ...
        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.5,0.5,0.0,0.0,0.0},
				{0.9,0.0,0.0,0.1,0.0}};
		show(calculate(v,m,0)); // the input data
		show(calculate(v,m,1)); // one single multiplication
		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));
	}

}