/*
 * Toolbox.hh
 *
 *  Created on: Jun 23, 2018
 *      Author: benjamin
 */

#ifndef TOOLBOX_HH_
#define TOOLBOX_HH_

#include "ParamData.hh"

namespace AMDA {
namespace Parameters {
namespace StatisticFunctions {

template <typename Type>
Type min(Type a, Type b) {
	if (!std::isfinite(a) || isNAN(a))
		return b;
	if (!std::isfinite(b) || isNAN(b))
		return a;
	return std::min(a,b);
}

template <typename Type>
std::vector<Type> min(std::vector<Type> a, std::vector<Type> b) {
	std::vector<Type> res = a;
	if (a.size() != b.size()) {
		BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_OPER_NOT_ALLOWED) << AMDA::ex_msg("Vectors don't have the same size"));
	}
	for (unsigned int i = 0; i < a.size(); ++i) {
		res[i] = StatisticFunctions::min(a[i],b[i]);
	}
        return res;
}

template <typename Type>
Tab2DData<Type> min(Tab2DData<Type> a, Tab2DData<Type> b) {
	Tab2DData<Type> res(a);
	if (a.getDim1Size() != b.getDim1Size() || a.getDim2Size() != b.getDim2Size()) {
                BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_OPER_NOT_ALLOWED) << AMDA::ex_msg("Tab2DData don't have the same dimensions"));
        }
        for (int i = 0; i < a.getDim1Size(); ++i) {
		for (int j = 0; j < a.getDim2Size(); ++j) {
			res[i][j] = StatisticFunctions::min(a[i][j],b[i][j]);
		}
	}
	return res;
}

template <typename Type>
Type max(Type a, Type b) {
	if (!std::isfinite(a) || isNAN(a))
		return b;
	if (!std::isfinite(b) || isNAN(b))
		return a;
	return std::max(a,b);
}

template <typename Type>
std::vector<Type> max(std::vector<Type> a, std::vector<Type> b) {
	std::vector<Type> res = a;
	if (a.size() != b.size()) {
		BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_OPER_NOT_ALLOWED) << AMDA::ex_msg("Vectors don't have the same size"));
	}
	for (unsigned int i = 0; i < a.size(); ++i) {
		res[i] = StatisticFunctions::max(a[i],b[i]);
	}
	return res;
}

template <typename Type>
Tab2DData<Type> max(Tab2DData<Type> a, Tab2DData<Type> b) {
	Tab2DData<Type> res(a);
	if (a.getDim1Size() != b.getDim1Size() || a.getDim2Size() != b.getDim2Size()) {
		BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_OPER_NOT_ALLOWED) << AMDA::ex_msg("Tab2DData don't have the same dimensions"));
	}
	for (int i = 0; i < a.getDim1Size(); ++i) {
		for (int j = 0; j < a.getDim2Size(); ++j) {
			res[i][j] = StatisticFunctions::max(a[i][j],b[i][j]);
		}
	}
	return res;
}

template <typename Type>
Type pow(Type a, double exp) {
	return std::pow(a,exp);
}

template <typename Type>
std::vector<Type> pow(std::vector<Type> a, double exp) {
	std::vector<Type> res = a;
	for (unsigned int i = 0; i < a.size(); ++i) {
		res[i] = StatisticFunctions::pow(a[i],exp);
	}
	return res;
}

template <typename Type>
Tab2DData<Type> pow(Tab2DData<Type> a, double exp) {
	Tab2DData<Type> res = a;
	for (int i = 0; i < a.getDim1Size(); ++i) {
		for (int j = 0; j < a.getDim2Size(); ++j) {
			res[i][j] = StatisticFunctions::pow(a[i][j],exp);
		}
	}
	return res;
}

template <typename Type>
Type square(Type a) {
	return StatisticFunctions::pow(a,2);
}

template <typename Type>
std::vector<Type> square(std::vector<Type> a) {
	return StatisticFunctions::pow(a,2);
}

template <typename Type>
Tab2DData<Type> square(Tab2DData<Type> a) {
	return StatisticFunctions::pow(a,2);
}

template <typename Type>
Type root_square(Type a) {
	if (isNAN(a) || a < 0) {
		Type res;
		res << NotANumber();
		return res;
	}
	return std::sqrt(a);
}

template <typename Type>
std::vector<Type> root_square(std::vector<Type> a) {
	std::vector<Type> res = a;
	for (unsigned int i = 0; i < a.size(); ++i) {
		res[i] = StatisticFunctions::root_square(a[i]);
	}
	return res;
}

template <typename Type>
Tab2DData<Type> root_square(Tab2DData<Type> a) {
	Tab2DData<Type> res = a;
	for (int i = 0; i < a.getDim1Size(); ++i) {
		for (int j = 0; j < a.getDim2Size(); ++j) {
			res[i][j] = StatisticFunctions::root_square(a[i][j]);
		}
	}
	return res;
}

template <typename Type>
Type div(Type a, Type b) {
        if (isNAN(a) || isNAN(b) || (b == 0)) {
                Type res;
                res << NotANumber();
                return res;
        }
        return a/b;
}

template <typename Type>
std::vector<Type> div(std::vector<Type> a, std::vector<Type> b) {
	std::vector<Type> res = a;
	if (a.size() != b.size()) {
		BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_OPER_NOT_ALLOWED) << AMDA::ex_msg("Vectors don't have the same size"));
	}
	for (unsigned int i = 0; i < a.size(); ++i) {
		res[i] = StatisticFunctions::div(a[i],b[i]);
	}
	return res;
}

template <typename Type>
Tab2DData<Type> div(Tab2DData<Type> a, Tab2DData<Type> b) {
	Tab2DData<Type> res(a);
	if (a.getDim1Size() != b.getDim1Size() || a.getDim2Size() != b.getDim2Size()) {
		BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::errno_code(AMDA_OPER_NOT_ALLOWED) << AMDA::ex_msg("Tab2DData don't have the same dimensions"));
	}
	for (int i = 0; i < a.getDim1Size(); ++i) {
		for (int j = 0; j < a.getDim2Size(); ++j) {
			res[i][j] = StatisticFunctions::div(a[i][j],b[i][j]);
		}
	}
	return res;
}

} /* namespace StatisticFunctions */
} /* namespace Parameters */
} /* namespace AMDA */
#endif /* TOOLBOX_HH_ */