/* libsegl - Sebas Extended GL Library
 *           Collection of Opengl/3D-Math helpers
 *
 *      Copyright (c) 2008 by Sebastian Lohff, seba@seba-geek.de
 *      http://www.seba-geek.de
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 * 
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
 * Boston, MA  02110-1301, USA.
 */

#include "matrix.h"

namespace segl {

Matrix::Matrix(int _m, int _n) {
	m = _m;
	n = _n;
	allocate();
}

Matrix::Matrix(int _m, int _n, const float **src) {
	m = _m;
	n = _n;
	allocate();
	copyFromSource(src);
}

Matrix::Matrix(Punkt3D d) {
	m = 3;
	n = 1;
	allocate();
	c[0][0] = d.x;
	c[1][0] = d.y;
	c[2][0] = d.z;
}

Matrix::Matrix(const Matrix& mat) {
	m = mat.m;
	n = mat.n;
	allocate();
	copyFromSource(mat.getMatrix());
}

void Matrix::allocate() {
	c = new float*[m];
	for(int i=0; i<m; i++) {
		c[i] = new float[n];
		for(int t=0; t<n; t++)
			c[i][t] = 0;
	}
}

void Matrix::copyFromSource(const float** src) {
	for(int i=0; i<m; i++) {
		for(int t=0; t<n; t++)
			c[i][t] = src[i][t];
	}
}

const float **Matrix::getMatrix() const {
	return (const float**)c;
}

bool Matrix::set(float d, int _m, int _n) {
	if(_m>=m||_n>=n)
		return false;
	c[_m][_n] = d;
	return true;
}

float Matrix::get(int _m, int _n) {
	if(_m>=m||_n>=n)
		return 0.0f;
		
	return c[_m][_n];
}

Matrix Matrix::operator*(const Matrix &d) {
	
	if(n!=d.m)
		return Matrix(1,1);
	Matrix erg(m, d.n);
	
	
	for(int a=0; a<m; a++) {
		for(int b=0; b<d.n; b++) {
			float zerg = 0.0f;
			for(int _c=0; _c<n; _c++) {
				zerg += c[a][_c] * d.c[_c][b];
			}
			erg.c[a][b] = zerg;
		}
	}

	return erg;
}

Matrix& Matrix::operator=(const Matrix& mat) {
	if(mat.m<=m&&mat.n<=n) {
		copyFromSource(mat.getMatrix());
	}
	return *this;
}

Matrix Matrix::operator+(const float &f) {
	Matrix tmp(*this);
	for(int i=0; i<m; i++) {
		for(int j=0; j<n; j++) {
			tmp.c[i][j] += f;
		}
	}
	return tmp;
}

Matrix Matrix::operator-(const float &f) {
	Matrix tmp(*this);
	for(int i=0; i<m; i++) {
		for(int j=0; j<n; j++) {
			tmp.c[i][j] -= f;
		}
	}
	return tmp;
}

Matrix Matrix::operator*(const float &f) {
	Matrix tmp(*this);
	for(int i=0; i<m; i++) {
		for(int j=0; j<n; j++) {
			tmp.c[i][j] *= f;
		}
	}
	return tmp;
}

Matrix Matrix::operator/(const float &f) {
	Matrix tmp(*this);
	for(int i=0; i<m; i++) {
		for(int j=0; j<n; j++) {
			tmp.c[i][j] /= f;
		}
	}
	return tmp;
}

int Matrix::getM() const {
	return m;
}

int Matrix::getN() const {
	return n;
}

void Matrix::print(std::string s) const {
	std::cout << "Matrix " << s << "(" << m << "," << n << ")" << std::endl;
	for(int a=0; a<m; a++) {
		for(int b=0; b<n; b++) {
			std::cout << std::setw(15) << c[a][b];
		}
		std::cout << std::endl;
	}
}

Matrix::~Matrix() {
	for(int i=0; i<m; i++) {
		delete[](c[i]);
	}
	delete[](c);
}

} // namespace segl