/***************************************
	Auteur : Pierre Aubert
	Mail : aubertp7@gmail.com
	Licence : CeCILL-C
****************************************/

#ifndef __PMIN_MAX_IMPL_H__
#define __PMIN_MAX_IMPL_H__

#include "pMinMax.h"

///fonction qui renvoie la plus petite valeurs entre a et b
/**	@param a : valeur
 * 	@param b : valeur
 * 	@return petite valeurs entre a et b
*/
template<typename T>
T pmin(const T & a, const T & b){
	return (a < b)? a:b;
}

///fonction qui renvoie la plus grande valeurs entre a et b
/**	@param a : valeur
 * 	@param b : valeur
 * 	@return grande valeurs entre a et b
*/
template<typename T>
T pmax(const T & a, const T & b){
	return (a > b)? a:b;
}

///renvoie le minimum entre x, y, z et t
/**	@param x : nombre
	@param y : nombre
	@param z : nombre
	@param t : nombre
	@return minimum entre x, y, z et t
*/
template <class T>
T pmin4(const T & x, const T & y, const T & z, const T & t){
	if(x < y){
		if(x < z){
			if(x < t) return x;
			else return t;
		}else{
			if(z < t) return z;
			else return t;
		}
	}else{
		if(y < z){
			if(y < t) return y;
			else return t;
		}else{
			if(z < t) return z;
			else return t;
		}
	}
}

///renvoie le maximum entre x, y, z et t
/**	@param x : nombre
	@param y : nombre
	@param z : nombre
	@param t : nombre
	@return maximum entre x, y, z et t
*/
template <class T>
T pmax4(const T & x, const T & y, const T & z, const T & t){
	if(x > y){
		if(x > z){
			if(x > t) return x;
			else return t;
		}else{
			if(z > t) return z;
			else return t;
		}
	}else{
		if(y > z){
			if(y > t) return y;
			else return t;
		}else{
			if(z > t) return z;
			else return t;
		}
	}
}

///fonction qui renvoie le minimum d'un tableau
/**	@param tab : tableau dont on veut le minimum
 * 	@param size : taille du tableau
 * 	@return minimum du tableau
*/
template<typename T>
T pminTab(const T* tab, size_t size){
	if(tab == NULL || size == 0lu) return 0.0;
	T res = tab[0];
	if(size == 1lu) return res;
	size_t i;
	for(i = 1lu; i < size; ++i){
		if(tab[i] < res) res = tab[i];
	}
	return res;
}

///fonction qui renvoie la position du minimum d'un tableau
/**	@param tab : tableau dont on veut le minimum
 * 	@param size : taille du tableau
 * 	@return position du minimum du tableau
*/
template<typename T>
size_t pminTabPos(const T* tab, size_t size){
	if(tab == NULL || size == 0lu) return 0lu;
	T res = tab[0];
	if(size == 1lu) return 0lu;
	size_t i, pos(0lu);
	for(i = 1lu; i < size; ++i){
		if(tab[i] < res){
			res = tab[i];
			pos = i;
		}
	}
	return pos;
}

///fonction qui renvoie la position du minimum d'un tableau
/**	@param[out] minVal : minimum value
 * 	@param tab : tableau dont on veut le minimum
 * 	@param size : taille du tableau
 * 	@return position du minimum du tableau
*/
template<typename T>
size_t pminTabPos(T & minVal, const T* tab, size_t size){
	if(tab == NULL || size == 0lu) return 0lu;
	minVal = tab[0];
	if(size == 1lu) return 0lu;
	size_t i, pos(0lu);
	for(i = 1lu; i < size; ++i){
		if(tab[i] < minVal){
			minVal = tab[i];
			pos = i;
		}
	}
	return pos;
}

///fonction qui renvoie le maximum d'un tableau
/**	@param tab : tableau dont on veut le maximum
 * 	@param size : taille du tableau
 * 	@return maximum du tableau
*/
template<typename T>
T pmaxTab(const T* tab, size_t size){
	if(tab == NULL || size == 0lu) return 0.0;
	T res = tab[0];
	if(size == 1lu) return res;
	size_t i;
	for(i = 1lu; i < size; ++i){
		if(tab[i] > res) res = tab[i];
	}
	return res;
}

///fonction qui renvoie la position du maximum d'un tableau
/**	@param tab : tableau dont on veut le maximum
 * 	@param size : taille du tableau
 * 	@return position du maximum du tableau
*/
template<typename T>
size_t pmaxTabPos(const T* tab, size_t size){
	if(tab == NULL || size == 0lu) return 0lu;
	T res = tab[0];
	if(size == 1lu) return 0lu;
	size_t i, pos(0lu);
	for(i = 1lu; i < size; ++i){
		if(tab[i] > res){
			res = tab[i];
			pos = i;
		}
	}
	return pos;
}

///fonction qui renvoie la position du maximum d'un tableau
/**	@param[out] maxVal : minimum value
 * 	@param tab : tableau dont on veut le minimum
 * 	@param size : taille du tableau
 * 	@return position du maximum du tableau
*/
template<typename T>
size_t pmaxTabPos(T & maxVal, const T* tab, size_t size){
	if(tab == NULL || size == 0lu) return 0lu;
	maxVal = tab[0];
	if(size == 1lu) return 0lu;
	size_t i, pos(0lu);
	for(i = 1lu; i < size; ++i){
		if(tab[i] > maxVal){
			maxVal = tab[i];
			pos = i;
		}
	}
	return pos;
}

///Gets the minimum and maximum values in a table
/**	@param[out] xmin : minimum value in the table
 * 	@param[out] xmax : maximum value in the table
 * 	@param tab : table we want min and max
 * 	@param size : number of elements in the table
*/
template<typename T>
void pminmaxTab(T & xmin, T & xmax, const T* tab, size_t size){
	if(tab == NULL || size == 0lu) return;
	xmin = tab[0];
	xmax = xmin;
	if(size == 1lu) return;
	size_t i;
	T tmp;
	for(i = 1; i < size; ++i){
		tmp = tab[i];
		if(tmp > xmax) xmax = tmp;
		else{xmin = tmp;}
	}
}

///Compute the miminum of two tables
/**	@param[out] vecMin : vector of the minimum element of tab1 and tab2
 * 	@param tab1 : table
 * 	@param tab2 : table
 * 	@param size : number of element in each table
*/
template<typename T>
void pminVec(T * vecMin, const T* tab1, const T * tab2, size_t size){
	for(size_t i(0lu); i < size; ++i){
		vecMin[i] = pmin(tab1[i], tab2[i]);
	}
}

///Compute the miminum of two tables
/**	@param[out] vecMax : vector of the maximum element of tab1 and tab2
 * 	@param tab1 : table
 * 	@param tab2 : table
 * 	@param size : number of element in each table
*/
template<typename T>
void pmaxVec(T * vecMax, const T* tab1, const T * tab2, size_t size){
	for(size_t i(0lu); i < size; ++i){
		vecMax[i] = pmax(tab1[i], tab2[i]);
	}
}

///Gets the minimum and maximum values in a matrix
/**	@param[out] tabMin : minimum value in the matrix for each column
 * 	@param[out] tabMax : maximum value in the matrix for each column
 * 	@param nbCol : number of columns in the matrix (and number of elements in the tabXmin and tabXmax table)
 * 	@param matrix : table we want min and max
 * 	@param nbRow : number of rows in the matrix
*/
template<typename T>
void pminmaxMatrix(T * tabMin, T * tabMax, size_t nbCol, const T* matrix, size_t nbRow){
	if(tabMax == NULL || tabMin == NULL || nbCol == 0lu || matrix == NULL || nbRow == 0lu) return;
	memcpy(tabMin, matrix, sizeof(T)*nbCol);
	memcpy(tabMax, tabMin, sizeof(T)*nbCol);
	if(nbRow == 1lu) return;
	T tmp;
	for(size_t i(0lu); i < nbRow; ++i){
		for(size_t j(0lu); j < nbCol; ++j){
			tmp = matrix[i*nbCol + j];
			if(tmp > tabMax[j]) tabMax[j] = tmp;
			else if(tmp < tabMin[j]) tabMin[j] = tmp;
		}
	}
}

///Get the minimum and maximum value in a Matrix pitch
/**	@param [out] xmin : minimum value in the Matrix pitch
 * 	@param[out] xmax : maximum value in the Matrix pitch
 * 	@param mat : input matrix
 * 	@param nbRow : number of rows in the matrix pitch
 * 	@param nbCol : number of columns in the matrix pitch
 * 	@param pitch : number of extra columns used to aligned the first element of each line of the matrix (so it is a matrix pitch)
*/
template<typename T>
void pminmaxMatrixPitch(T & xmin, T & xmax, const T* mat, size_t nbRow, size_t nbCol, size_t pitch){
	if(mat == NULL || nbRow == 0lu || nbCol == 0lu) return;
	xmin = mat[0];
	xmax = xmin;
	T tmp;
	for(size_t i(0lu); i < nbRow; ++i){
		for(size_t j(0lu); j < nbCol; ++j){
			tmp = mat[i*(nbCol + pitch) + j];
			if(tmp > xmax) xmax = tmp;
			else if(tmp < xmin) xmin = tmp;
		}
	}
}

///Fonction qui calcule le minimum et le maximum des paires de valeurs dans un tableaux à une dimension
/**	@param xmin : valeur minimale de x
 * 	@param xmax : valeur maximale de x
 * 	@param ymin : valeur minimale de y
 * 	@param ymax : valeur maximale de y
 * 	@param tab : tableau de valeurs de XY
 * 	@param sizeNbPair : nombre de paires (moitié de la taille du tableau de XY totale)
*/
template<typename T>
void pminmaxTabXY(T & xmin, T & xmax, T & ymin, T & ymax, const T * tab, size_t sizeNbPair){
	if(tab == NULL || sizeNbPair == 0lu) return;
	xmin = tab[0lu];
	xmax = tab[0lu];
	ymin = tab[1lu];
	ymax = tab[1lu];
	if(sizeNbPair > 1lu){
		for(size_t i(0lu); i < sizeNbPair; ++i){
			if(xmin > tab[2lu*i]) xmin = tab[2lu*i];
			if(xmax < tab[2lu*i]) xmax = tab[2lu*i];
			if(ymin > tab[2lu*i + 1lu]) ymin = tab[2lu*i + 1lu];
			if(ymax < tab[2lu*i + 1lu]) ymax = tab[2lu*i + 1lu];
		}
	}
}

///Converts a table of couple (x,y) in a table of (x-y) values
/**	@param tabX : table of (x-y) values
 * 	@param tabXY : table of couple (x,y)
 * 	@param sizeTabX : size of the tabX table and half-size of the tabXY one
*/
template<typename T>
void tabXYtoTabXmY(T* tabX, const T* tabXY, size_t sizeTabX){
	if(tabX == NULL || tabXY == NULL || sizeTabX == 0lu) return;
	for(size_t i(0lu); i < sizeTabX; ++i){
		tabX[i] = tabXY[2lu*i] - tabXY[2lu*i + 1lu];
	}
}

///Converts a table of couple (x,y) in a table of (x-y) values
/**	@param tabX : table of (x-y) values
 * 	@param tabXY : table of couple (x,y)
 * 	@param sizeTabX : size of the tabX table and half-size of the tabXY one
*/
template<typename T>
void tabXYtoTabXmYonX(T* tabX, const T* tabXY, size_t sizeTabX){
	if(tabX == NULL || tabXY == NULL || sizeTabX == 0lu) return;
	for(size_t i(0lu); i < sizeTabX; ++i){
		if(fabs(tabXY[2lu*i]) > 0.00001f) tabX[i] = (tabXY[2lu*i] - tabXY[2lu*i + 1lu])/tabXY[2lu*i];
		else tabX[i] = 0.0f;
	}
}

///Get the number of diffrents value in a table
/**	@param tab : table of value
 * 	@param size : number of elements in the table
 * 	@param threshold : considers the minimal distance between to values
 * 	@return number of diffrents value in a table
*/
template<typename T>
size_t getNumberOfDiffrentValues(const T * tab, size_t size, float threshold){
	if(tab == NULL || size == 0lu) return 0lu;
	size_t nb(1lu);
	float max(tab[0]);
	for(size_t i(1lu); i < size; ++i){
		if(max + threshold < tab[i]){
			++nb;
			max = tab[i];
		}
	}
	return nb;
}

#endif