#pragma once

#include "./core/omp_config.h"
#include "detail/greater_or_less_serial.h"


namespace numerics{


	//
	// ---------------- Greater - Vectors ----------------
	//
	template <typename T>
	inline void inplace_greater(utils::Vector<T>& v, const T c) {
		detail::inplace_greater_serial(v, c);
	}
	template <typename T>
	inline utils::Vector<T> greater(const utils::Vector<T>& v, const T c) {
		utils::Vector<T> out = v;
		inplace_greater(out, c);
		return out;
	}


	template <typename T>
	inline void inplace_greater(utils::Vector<T>& v, const utils::Vector<T>& p) {
		detail::inplace_greater_serial(v, p);
	}
	template <typename T>
	inline utils::Vector<T> greater(const utils::Vector<T>& v, const utils::Vector<T>& p) {
		utils::Vector<T> out = v;
		inplace_greater(out, p);
		return out;
	}


	//
	// ---------------- Greater - Matrices  ----------------
	//
	template <typename T>
	inline void inplace_greater(utils::Matrix<T>& A, const T c) {
		detail::inplace_greater_serial(A, c);
	}
	template <typename T>
	inline utils::Matrix<T> greater(const utils::Matrix<T>& A, const T c) {
		utils::Matrix<T> out = A;
		inplace_greater(out, c);
		return out;
	}

	template <typename T>
	inline void inplace_greater_rowwise(utils::Matrix<T>& A, const utils::Vector<T> v) {
		detail::inplace_greater_rowwise_serial(A, v);
	}
	template <typename T>
	inline utils::Matrix<T> greater_rowwise(const utils::Matrix<T>& A, const utils::Vector<T> v) {
		utils::Matrix<T> out = A;
		inplace_greater_rowwise(out, v);
		return out;
	}

	template <typename T>
	inline void inplace_greater_colwise(utils::Matrix<T>& A, const utils::Vector<T> v) {
		detail::inplace_greater_colwise_serial(A, v);
	}
	template <typename T>
	inline utils::Matrix<T> greater_colwise(const utils::Matrix<T>& A, const utils::Vector<T> v) {
		utils::Matrix<T> out = A;
		inplace_greater_colwise(out, v);
		return out;
	}

	template <typename T>
	inline void inplace_greater(utils::Matrix<T>& A, const utils::Matrix<T> B) {
		detail::inplace_greater_serial(A, B);
	}
	template <typename T>
	inline utils::Matrix<T> greater(const utils::Matrix<T>& A, const utils::Matrix<T> B) {
		utils::Matrix<T> out = A;
		inplace_greater(out, B);
		return out;
	}


	//
	// ---------------- Greater or Equal - Vectors ----------------
	//
	template <typename T>
	inline void inplace_greater_equal(utils::Vector<T>& v, const T c) {
		detail::inplace_greater_equal_serial(v, c);
	}
	template <typename T>
	inline utils::Vector<T> greater_equal(const utils::Vector<T>& v, const T c) {
		utils::Vector<T> out = v;
		inplace_greater_equal(out, c);
		return out;
	}


	template <typename T>
	inline void inplace_greater_equal(utils::Vector<T>& v, const utils::Vector<T>& p) {
		detail::inplace_greater_equal_serial(v, p);
	}
	template <typename T>
	inline utils::Vector<T> greater_equal(const utils::Vector<T>& v, const utils::Vector<T>& p) {
		utils::Vector<T> out = v;
		inplace_greater_equal(out, p);
		return out;
	}


	//
	// ---------------- Greater or Equal - Matrices  ----------------
	//
	template <typename T>
	inline void inplace_greater_equal(utils::Matrix<T>& A, const T c) {
		detail::inplace_greater_equal_serial(A, c);
	}
	template <typename T>
	inline utils::Matrix<T> greater_equal(const utils::Matrix<T>& A, const T c) {
		utils::Matrix<T> out = A;
		inplace_greater_equal(out, c);
		return out;
	}

	template <typename T>
	inline void inplace_greater_equal_rowwise(utils::Matrix<T>& A, const utils::Vector<T> v) {
		detail::inplace_greater_equal_rowwise_serial(A, v);
	}
	template <typename T>
	inline utils::Matrix<T> greater_equal_rowwise(const utils::Matrix<T>& A, const utils::Vector<T> v) {
		utils::Matrix<T> out = A;
		inplace_greater_equal_rowwise(out, v);
		return out;
	}

	template <typename T>
	inline void inplace_greater_equal_colwise(utils::Matrix<T>& A, const utils::Vector<T> v) {
		detail::inplace_greater_equal_colwise_serial(A, v);
	}
	template <typename T>
	inline utils::Matrix<T> greater_equal_colwise(const utils::Matrix<T>& A, const utils::Vector<T> v) {
		utils::Matrix<T> out = A;
		inplace_greater_equal_colwise(out, v);
		return out;
	}

	template <typename T>
	inline void inplace_greater_equal(utils::Matrix<T>& A, const utils::Matrix<T> B) {
		detail::inplace_greater_equal_serial(A, B);
	}
	template <typename T>
	inline utils::Matrix<T> greater_euqal(const utils::Matrix<T>& A, const utils::Matrix<T> B) {
		utils::Matrix<T> out = A;
		inplace_greater_equal(out, B);
		return out;
	}


	//
	// ---------------- Less - Vectors ----------------
	//
	template <typename T>
	inline void inplace_less(utils::Vector<T>& v, const T c) {
		detail::inplace_less_serial(v, c);
	}
	template <typename T>
	inline utils::Vector<T> less(const utils::Vector<T>& v, const T c) {
		utils::Vector<T> out = v;
		inplace_less(out, c);
		return out;
	}


	template <typename T>
	inline void inplace_less(utils::Vector<T>& v, const utils::Vector<T>& p) {
		detail::inplace_less_serial(v, p);
	}
	template <typename T>
	inline utils::Vector<T> less(const utils::Vector<T>& v, const utils::Vector<T>& p) {
		utils::Vector<T> out = v;
		inplace_less(out, p);
		return out;
	}




	//
	// ---------------- Less - Matrices  ----------------
	//
	template <typename T>
	inline void inplace_less(utils::Matrix<T>& A, const T c) {
		detail::inplace_less_serial(A, c);
	}
	template <typename T>
	inline utils::Matrix<T> less(const utils::Matrix<T>& A, const T c) {
		utils::Matrix<T> out = A;
		inplace_less(out, c);
		return out;
	}

	template <typename T>
	inline void inplace_less_rowwise(utils::Matrix<T>& A, const utils::Vector<T> v) {
		detail::inplace_less_rowwise_serial(A, v);
	}
	template <typename T>
	inline utils::Matrix<T> less_rowwise(const utils::Matrix<T>& A, const utils::Vector<T> v) {
		utils::Matrix<T> out = A;
		inplace_less_rowwise(out, v);
		return out;
	}

	template <typename T>
	inline void inplace_less_colwise(utils::Matrix<T>& A, const utils::Vector<T> v) {
		detail::inplace_less_colwise_serial(A, v);
	}
	template <typename T>
	inline utils::Matrix<T> less_colwise(const utils::Matrix<T>& A, const utils::Vector<T> v) {
		utils::Matrix<T> out = A;
		inplace_less_colwise(out, v);
		return out;
	}

	template <typename T>
	inline void inplace_less(utils::Matrix<T>& A, const utils::Matrix<T> B) {
		detail::inplace_less_serial(A, B);
	}
	template <typename T>
	inline utils::Matrix<T> less(const utils::Matrix<T>& A, const utils::Matrix<T> B) {
		utils::Matrix<T> out = A;
		inplace_less(out, B);
		return out;
	}


	//
	// ---------------- Less or Equal - Vectors ----------------
	//
	template <typename T>
	inline void inplace_less_equal(utils::Vector<T>& v, const T c) {
		detail::inplace_less_equal_serial(v, c);
	}
	template <typename T>
	inline utils::Vector<T> less_equal(const utils::Vector<T>& v, const T c) {
		utils::Vector<T> out = v;
		inplace_less_equal(out, c);
		return out;
	}


	template <typename T>
	inline void inplace_less_equal(utils::Vector<T>& v, const utils::Vector<T>& p) {
		detail::inplace_less_equal_serial(v, p);
	}
	template <typename T>
	inline utils::Vector<T> less_equal(const utils::Vector<T>& v, const utils::Vector<T>& p) {
		utils::Vector<T> out = v;
		inplace_less_equal(out, p);
		return out;
	}


	//
	// ---------------- Less or Equal - Matrices  ----------------
	//
	template <typename T>
	inline void inplace_less_equal(utils::Matrix<T>& A, const T c) {
		detail::inplace_less_equal_serial(A, c);
	}
	template <typename T>
	inline utils::Matrix<T> less_equal(const utils::Matrix<T>& A, const T c) {
		utils::Matrix<T> out = A;
		inplace_less_equal(out, c);
		return out;
	}

	template <typename T>
	inline void inplace_less_equal_rowwise(utils::Matrix<T>& A, const utils::Vector<T> v) {
		detail::inplace_less_equal_rowwise_serial(A, v);
	}
	template <typename T>
	inline utils::Matrix<T> less_equal_rowwise(const utils::Matrix<T>& A, const utils::Vector<T> v) {
		utils::Matrix<T> out = A;
		inplace_less_equal_rowwise(out, v);
		return out;
	}

	template <typename T>
	inline void inplace_less_equal_colwise(utils::Matrix<T>& A, const utils::Vector<T> v) {
		detail::inplace_less_equal_colwise_serial(A, v);
	}
	template <typename T>
	inline utils::Matrix<T> less_equal_colwise(const utils::Matrix<T>& A, const utils::Vector<T> v) {
		utils::Matrix<T> out = A;
		inplace_less_equal_colwise(out, v);
		return out;
	}

	template <typename T>
	inline void inplace_less_equal(utils::Matrix<T>& A, const utils::Matrix<T> B) {
		detail::inplace_less_equal_serial(A, B);
	}
	template <typename T>
	inline utils::Matrix<T> less_euqal(const utils::Matrix<T>& A, const utils::Matrix<T> B) {
		utils::Matrix<T> out = A;
		inplace_less_equal(out, B);
		return out;
	}






}