/**
This file is a part of our_dick
Copyright (C) 2020 rexy712
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program 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 Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
*/
#ifndef REXY_VEC_TPP
#define REXY_VEC_TPP
namespace math{
template
template
constexpr vector& vector::operator=(const vector& m){
base::operator=(m);
return *this;
}
template
constexpr auto vector::operator[](size_type i) -> reference{
return this->m_data[i];
}
template
constexpr auto vector::operator[](size_type i)const -> const_reference{
return this->m_data[i];
}
template
constexpr auto vector::x() -> reference{
return this->m_data[0];
}
template
constexpr auto vector::x()const -> const_reference{
return this->m_data[0];
}
template
template
constexpr auto vector::y() -> reference{
static_assert(R > 1, "Vector does not contain a 2nd element");
return this->m_data[1];
}
template
template
constexpr auto vector::y()const -> const_reference{
static_assert(R > 1, "Vector does not contain a 2nd element");
return this->m_data[1];
}
template
template
constexpr auto vector::z() -> reference{
static_assert(R > 2, "Vector does not contain a 3rd element");
return this->m_data[2];
}
template
template
constexpr auto vector::z()const -> const_reference{
static_assert(R > 2, "Vector does not contain a 3rd element");
return this->m_data[2];
}
template
template
constexpr auto vector::w() -> reference{
static_assert(R > 3, "Vector does not contain a 4th element");
return this->m_data[3];
}
template
template
constexpr auto vector::w()const -> const_reference{
static_assert(R > 3, "Vector does not contain a 4th element");
return this->m_data[3];
}
template
constexpr auto operator*(const matrix& left, const vector& right){
using res_t = decltype(std::declval() * std::declval());
vector 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
constexpr auto operator*(const vector& left, const vector& right){
using res_t = decltype(std::declval() * std::declval());
res_t res = 0;
for(size_t i = 0; i < R; ++i){
res += left[i] * right[i];
}
return res;
}
template::value,int>>
constexpr auto operator*(const vector& left, U&& right){
using res_t = decltype(std::declval() * std::declval());
vector res(zero_initialize);
for(size_t i = 0; i < R; ++i){
res[i] = left[i] * std::forward(right);
}
return res;
}
template::value,int>>
constexpr auto operator*(U&& left, const vector& right){
using res_t = decltype(std::declval() * std::declval());
vector res(zero_initialize);
for(size_t i = 0; i < R; ++i){
res[i] = std::forward(right) * left[i];
}
return res;
}
template::value,int>>
constexpr auto operator/(const vector& left, U&& right){
using res_t = decltype(std::declval() / std::declval());
vector res(zero_initialize);
for(size_t i = 0; i < R; ++i){
res[i] = left[i] / std::forward(right);
}
return res;
}
template
constexpr auto operator+(const vector& left, const vector& right){
using res_t = decltype(std::declval() + std::declval());
vector res(zero_initialize);
for(size_t i = 0; i < R; ++i){
res[i] = left[i] + right[i];
}
return res;
}
template
constexpr auto operator-(const vector& left, const vector& right){
using res_t = decltype(std::declval() - std::declval());
vector res(zero_initialize);
for(size_t i = 0; i < R; ++i){
res[i] = left[i] - right[i];
}
return res;
}
template
constexpr auto operator-(const vector& left){
using res_t = decltype(-std::declval());
vector res(zero_initialize);
for(size_t i = 0; i < R; ++i){
res[i] = -left[i];
}
return res;
}
template::value,int>>
constexpr decltype(auto) operator*=(vector& left, U&& right){
for(size_t i = 0; i < R; ++i){
left[i] *= right;
}
return left;
}
template::value,int>>
constexpr decltype(auto) operator/=(vector& left, U&& right){
for(size_t i = 0; i < R; ++i){
left[i] /= right;
}
return left;
}
template
constexpr decltype(auto) operator+=(vector& left, const vector& right){
for(size_t i = 0; i < R; ++i){
left[i] += right[i];
}
return left;
}
template
constexpr decltype(auto) operator-=(vector& left, const vector& right){
for(size_t i = 0; i < R; ++i){
left[i] -= right[i];
}
return left;
}
}
#endif