/* -*- coding: utf-8 -*- */
package demo1;

import java.util.Random;

/**
 * Example code for the course "Tietokonegrafiikan perusteet" 2012
 * and 2013. Likely not useful for "production use".
 * 
 * Exercise 1: preliminary vector, matrix, and image classes.
 * 
 * @author Paavo Nieminen
 * 
 */

/** A class for 4x4 square matrices. */
public class Mat4 {
	private static final int N_ROWS = 4;
	private static final int N_ELEMS = N_ROWS * N_ROWS;
	
    /* For initial experimentation.. */
	private static Random generator = new Random();
	

	/** Computes a linear index into the storage array */
	private static int pos(int i, int j){ return i*N_ROWS + j; }

	private double value[] = null;

	private Mat4(double[] shallowElementArray){
		this.value = shallowElementArray;
	}

	/** By default, become an array of zeros. */
	public Mat4(){value = new double[N_ELEMS];}

	/** Sets the value of the (i, j):th element */
	public void set(int i, int j, double val){ value[pos(i,j)] = val; }

	/** Returns the (i, j):th element */
	public double at(int i, int j){ return value[pos(i,j)]; }

	/** Sets all elements to the same scalar value. */
	public void allToConst(double val){
		for(int i=0; i<value.length; i++){value[i]=val;}
	}

	/** Sets diagonal elements to the same scalar value. */
	public void diagToConst(double val){
		for(int i=0; i<N_ROWS; i++){
			value[pos(i,i)] = val;
		}
	}

	/** Multiplies all elements by a scalar. */
	public void mul(double val){
		for(int i=0; i<value.length; i++){
			value[i] *= val;
		}
	}

	/** private helper; multiplies the internal matrix representation. */
	private static double[] arrmul(Mat4 A, Mat4 B){
		double[] replacement = new double[N_ELEMS];
		for(int i=0; i<N_ROWS; i++){
			for(int j=0; j<N_ROWS; j++){
				for(int k=0; k<N_ROWS; k++){
					replacement[pos(i,j)] += A.at(i,k) * B.at(k,j);
				}
			}
		}
		return replacement;
	}

	/** Multiply by another matrix from right. */
	public void mulR(Mat4 other){ value = arrmul(this, other); }

	/** Multiply by another matrix from left. */
	public void mulL(Mat4 other){ value = arrmul(other, this); }

	/** Returns a new matrix that is the matrix product of A and B */
	public static Mat4 matmul(Mat4 A, Mat4 B){ return new Mat4(arrmul(A,B)); }

	/** Transpose in-place. */
	public void transp(){
		for(int i=0; i<N_ROWS; i++){
			for(int j=i+1; j<N_ROWS; j++){
				double tmp = at(i,j);
				value[pos(i,j)] = at(j,i);
				value[pos(j,i)] = tmp;
			}
		}
	}

	/** Add another matrix elementwise. */
	public void add(Mat4 other){
		for(int i=0; i<value.length; i++){
			value[i] += other.value[i];
		}
	}

	/** Set all elements to zero. */
	public void zero(){
		allToConst(0.0);
	}

	/** Become the identity matrix. */
	public void identity(){
		zero();
		diagToConst(1.0);
	}

	public Mat4 clone(){
		Mat4 res = new Mat4();
		System.arraycopy(this.value, 0, res.value, 0, N_ELEMS);
		return res;
	}

	/** A nicely formatted but unprecise printout. */
	public void prettyPrint(java.io.PrintStream ps){
		for (int i=0; i<N_ROWS; i++){
			for (int j=0; j<N_ROWS; j++){
				ps.printf("%6.2f ",at(i,j));
			}
			ps.printf("%n");
		}
	}

	/** Returns a new identity matrix. */
	public static Mat4 buildIdentity() {
		Mat4 res = new Mat4();
		res.diagToConst(1.0);
		return res;
	}

	/** Returns a random matrix, drawn from [a,b]. For experimentation.. */
	public static Mat4 buildRandom(double a, double b) {
		Mat4 res = new Mat4();
		for(int i=0;i<N_ELEMS;i++){
			res.value[i] = a+generator.nextDouble()*(b-a);
		}
		return res;
	}

	/* ... other builders (for translations, rotates, etc.. ) 
	 * could go here ... in future exercises, we'll be making those.
	 */

}