From f79a3cc9bde94d70b63473d052ee4d6092d0b8f1 Mon Sep 17 00:00:00 2001
From: rexy712 <rexerton.rexy@tutamail.com>
Date: Sun, 16 Aug 2020 08:20:47 -0700
Subject: [PATCH] Add vector class

---
 include/vec.hpp |  68 +++++++++++++++++++++++++
 include/vec.tpp | 130 ++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 198 insertions(+)
 create mode 100644 include/vec.hpp
 create mode 100644 include/vec.tpp

diff --git a/include/vec.hpp b/include/vec.hpp
new file mode 100644
index 0000000..023327a
--- /dev/null
+++ b/include/vec.hpp
@@ -0,0 +1,68 @@
+#ifndef REXY_VEC_HPP
+#define REXY_VEC_HPP
+
+#include "mat.hpp"
+
+namespace math{
+
+	template<class T, size_t R>
+	class vector : public matrix_base<T,R,1>
+	{
+	private:
+		using base = matrix_base<T,R,1>;
+	public:
+		using value_type = typename base::value_type;
+		using size_type = typename base::size_type;
+		using pointer = typename base::pointer;
+		using const_pointer = typename base::const_pointer;
+		using reference = typename base::reference;
+		using const_reference = typename base::const_reference;
+
+	public:
+		using base::base;
+
+		constexpr vector(const vector&) = default;
+		constexpr vector(vector&&) = default;
+		~vector() = default;
+
+		//Assignement
+		constexpr vector& operator=(const vector&) = default;
+		constexpr vector& operator=(vector&&) = default;
+		template<typename U>
+		constexpr vector& operator=(const vector<U,R>& m);
+
+		constexpr reference operator[](size_type i);
+		constexpr const_reference operator[](size_type i)const;
+	};
+
+
+	template<typename T, typename U, size_t C, size_t R>
+	constexpr auto operator*(const matrix<U,R,C>& left, const vector<T,C>& right);
+	template<typename T, typename U, size_t R>
+	constexpr auto operator*(const vector<T,R>& left, const vector<U,R>& right);
+	template<typename T, typename U, size_t R, std::enable_if_t<!is_matrix<U>::value,int> = 0>
+	constexpr auto operator*(const vector<T,R>& left, U&& right);
+	template<typename T, typename U, size_t R, std::enable_if_t<!is_matrix<U>::value,int> = 0>
+	constexpr auto operator*(U&& left, const vector<T,R>& right);
+	template<typename T, typename U, size_t R, std::enable_if_t<!is_matrix<U>::value,int> = 0>
+	constexpr auto operator/(const vector<T,R>& left, U&& right);
+	template<typename T, typename U, size_t R>
+	constexpr auto operator+(const vector<T,R>& left, const vector<U,R>& right);
+	template<typename T, typename U, size_t R>
+	constexpr auto operator-(const vector<T,R>& left, const vector<U,R>& right);
+	template<typename T, typename U, size_t R>
+	constexpr auto operator-(const vector<T,R>& left);
+
+	template<typename T, typename U, size_t R, std::enable_if_t<!is_matrix<U>::value,int> = 0>
+	constexpr decltype(auto) operator*=(vector<T,R>& left, U&& right);
+	template<typename T, typename U, size_t R, std::enable_if_t<!is_matrix<U>::value,int> = 0>
+	constexpr decltype(auto) operator/=(vector<T,R>& left, U&& right);
+	template<typename T, typename U, size_t R>
+	constexpr decltype(auto) operator+=(vector<T,R>& left, const vector<U,R>& right);
+	template<typename T, typename U, size_t R>
+	constexpr decltype(auto) operator-=(vector<T,R>& left, const vector<U,R>& right);
+}
+
+#include "vec.tpp"
+
+#endif
diff --git a/include/vec.tpp b/include/vec.tpp
new file mode 100644
index 0000000..7e0b907
--- /dev/null
+++ b/include/vec.tpp
@@ -0,0 +1,130 @@
+#ifndef REXY_VEC_TPP
+#define REXY_VEC_TPP
+
+namespace math{
+
+	template<typename T, size_t R>
+	template<typename U>
+	constexpr vector<T,R>& vector<T,R>::operator=(const vector<U,R>& m){
+		base::operator=(m);
+		return *this;
+	}
+	template<typename T, size_t R>
+	constexpr auto vector<T,R>::operator[](size_type i) -> reference{
+		return this->m_data[i];
+	}
+	template<typename T, size_t R>
+	constexpr auto vector<T,R>::operator[](size_type i)const -> const_reference{
+		return this->m_data[i];
+	}
+
+	template<typename T, typename U, size_t C, size_t R>
+	constexpr auto operator*(const matrix<U,R,C>& left, const vector<T,C>& right){
+		using res_t = decltype(std::declval<T>() * std::declval<U>());
+		vector<res_t,R> res(zero_initialize);
+		size_t index = 0;
+		//columns == rows
+		for(size_t i = 0;i < R;++i){
+			for(size_t k = 0;k < C;++k){
+				res.get(index) += left[i][k] * right[k];
+			}
+			++index;
+		}
+		return res;
+	}
+	template<typename T, typename U, size_t R>
+	constexpr auto operator*(const vector<T,R>& left, const vector<U,R>& right){
+		using res_t = decltype(std::declval<T>() * std::declval<U>());
+		res_t res = 0;
+		for(size_t i = 0;i < R;++i){
+			res += left[i] * right[i];
+		}
+		return res;
+	}
+	template<typename T, typename U, size_t R, std::enable_if_t<!is_matrix<U>::value,int>>
+	constexpr auto operator*(const vector<T,R>& left, U&& right){
+		using res_t = decltype(std::declval<T>() * std::declval<U>());
+		vector<res_t,R> res(zero_initialize);
+		for(size_t i = 0;i < R;++i){
+			res[i] = left[i] * std::forward<U>(right);
+		}
+		return res;
+	}
+	template<typename T, typename U, size_t R, std::enable_if_t<!is_matrix<U>::value,int>>
+	constexpr auto operator*(U&& left, const vector<T,R>& right){
+		using res_t = decltype(std::declval<U>() * std::declval<T>());
+		vector<res_t,R> res(zero_initialize);
+		for(size_t i = 0;i < R;++i){
+			res[i] = std::forward<U>(right) * left[i];
+		}
+		return res;
+	}
+	template<typename T, typename U, size_t R, std::enable_if_t<!is_matrix<U>::value,int>>
+	constexpr auto operator/(const vector<T,R>& left, U&& right){
+		using res_t = decltype(std::declval<T>() / std::declval<U>());
+		vector<res_t,R> res(zero_initialize);
+		for(size_t i = 0;i < R;++i){
+			res[i] = left[i] / std::forward<U>(right);
+		}
+		return res;
+	}
+	template<typename T, typename U, size_t R>
+	constexpr auto operator+(const vector<T,R>& left, const vector<U,R>& right){
+		using res_t = decltype(std::declval<T>() + std::declval<U>());
+		vector<res_t,R> res(zero_initialize);
+		for(size_t i = 0;i < R;++i){
+			res[i] = left[i] + right[i];
+		}
+		return res;
+	}
+	template<typename T, typename U, size_t R>
+	constexpr auto operator-(const vector<T,R>& left, const vector<U,R>& right){
+		using res_t = decltype(std::declval<T>() - std::declval<U>());
+		vector<res_t,R> res(zero_initialize);
+		for(size_t i = 0;i < R;++i){
+			res[i] = left[i] - right[i];
+		}
+		return res;
+	}
+	template<typename T, typename U, size_t R>
+	constexpr auto operator-(const vector<T,R>& left){
+		using res_t = decltype(-std::declval<U>());
+		vector<res_t,R> res(zero_initialize);
+		for(size_t i = 0;i < R;++i){
+			res[i] = -left[i];
+		}
+		return res;
+	}
+
+	template<typename T, typename U, size_t R, std::enable_if_t<!is_matrix<U>::value,int>>
+	constexpr decltype(auto) operator*=(vector<T,R>& left, U&& right){
+		for(size_t i = 0;i < R;++i){
+			left[i] *= right;
+		}
+		return left;
+	}
+	template<typename T, typename U, size_t R, std::enable_if_t<!is_matrix<U>::value,int>>
+	constexpr decltype(auto) operator/=(vector<T,R>& left, U&& right){
+		for(size_t i = 0;i < R;++i){
+			left[i] /= right;
+		}
+		return left;
+	}
+	template<typename T, typename U, size_t R>
+	constexpr decltype(auto) operator+=(vector<T,R>& left, const vector<U,R>& right){
+		for(size_t i = 0;i < R;++i){
+			left[i] += right[i];
+		}
+		return left;
+	}
+	template<typename T, typename U, size_t R>
+	constexpr decltype(auto) operator-=(vector<T,R>& left, const vector<U,R>& right){
+		for(size_t i = 0;i < R;++i){
+			left[i] -= right[i];
+		}
+		return left;
+	}
+
+}
+
+#endif