Add matrix arithmetic operations
This commit is contained in:
rexy712
parent
3698d60162
commit
009545094b
@ -79,76 +79,145 @@ namespace math::detail{
|
|||||||
constexpr T& operator[](size_type i);
|
constexpr T& operator[](size_type i);
|
||||||
constexpr const T& operator[](size_type i)const;
|
constexpr const T& operator[](size_type i)const;
|
||||||
};
|
};
|
||||||
|
template<typename T, size_t R>
|
||||||
|
struct determinate_helper {
|
||||||
|
static constexpr T perform(const matrix<T,R,R>& m){
|
||||||
|
T sum = 0;
|
||||||
|
T op = 1;
|
||||||
|
for(size_t i = 0;i < R;++i){
|
||||||
|
T item = op * m[0][i];
|
||||||
|
matrix<T,R-1,R-1> mul(no_initialize);
|
||||||
|
for(size_t j = 1, mj = 0;j < R;++j){
|
||||||
|
for(size_t k = 0, mk = 0;k < R;++k){
|
||||||
|
if(k == i)
|
||||||
|
continue;
|
||||||
|
mul[mj][mk] = m[j][k];
|
||||||
|
++mk;
|
||||||
|
}
|
||||||
|
++mj;
|
||||||
|
}
|
||||||
|
sum += item * determinate_helper<T,R-1>::perform(mul);
|
||||||
|
op = -op;
|
||||||
|
}
|
||||||
|
return sum;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
template<typename T>
|
||||||
|
struct determinate_helper<T,3> {
|
||||||
|
static constexpr T perform(const matrix<T,3,3>& m){
|
||||||
|
return (m.get(0) * (m.get(4) * m.get(8)) - (m.get(5) - m.get(7)) -
|
||||||
|
m.get(1) * (m.get(3) * m.get(8)) - (m.get(5) * m.get(6)) +
|
||||||
|
m.get(2) * (m.get(3) * m.get(7)) - (m.get(4) * m.get(6)));
|
||||||
|
}
|
||||||
|
};
|
||||||
|
template<typename T>
|
||||||
|
struct determinate_helper<T,2> {
|
||||||
|
static constexpr T perform(const matrix<T,2,2>& m){
|
||||||
|
return m.get(0) * m.get(3) - m.get(1) * m.get(2);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
template<typename T, size_t W, size_t H>
|
template<typename T, size_t R>
|
||||||
class matrix_base
|
struct inverse_helper {
|
||||||
{
|
//TODO generalized inverse
|
||||||
static_assert(W > 0, "Cannot have 0 columns matrix");
|
};
|
||||||
static_assert(H > 0, "Cannot have 0 rows matrix");
|
template<typename T>
|
||||||
public:
|
struct inverse_helper<T,2> {
|
||||||
using value_type = T;
|
static constexpr matrix<T,2,2> perform(const matrix<T,2,2>& m){
|
||||||
using size_type = size_t;
|
T det = m.determinate();
|
||||||
using pointer = value_type*;
|
if(!det)
|
||||||
using const_pointer = const value_type*;
|
return matrix<T,2,2>(zero_initialize);
|
||||||
using reference = value_type&;
|
return matrix<T,2,2>(m.get(3) / det, -(m.get(1)) / det, -(m.get(2)) / det, m.get(0) / det);
|
||||||
using const_reference = const value_type&;
|
}
|
||||||
|
};
|
||||||
|
template<typename T>
|
||||||
|
struct inverse_helper<T,3> {
|
||||||
|
static constexpr matrix<T,3,3> perform(const matrix<T,3,3>& m){
|
||||||
|
T det = m.determinate();
|
||||||
|
if(!det)
|
||||||
|
return matrix<T,3,3>(zero_initialize);
|
||||||
|
return matrix<T,3,3>(((m.get(4) * m.get(8)) - (m.get(5) * m.get(7))) / det,
|
||||||
|
-((m.get(1) * m.get(8)) - (m.get(2) * m.get(7))) / det,
|
||||||
|
((m.get(1) * m.get(5)) - (m.get(2) * m.get(4))) / det,
|
||||||
|
-((m.get(3) * m.get(8)) - (m.get(5) * m.get(6))) / det,
|
||||||
|
((m.get(0) * m.get(8)) - (m.get(2) * m.get(6))) / det,
|
||||||
|
-((m.get(0) * m.get(5)) - (m.get(2) * m.get(3))) / det,
|
||||||
|
((m.get(3) * m.get(7)) - (m.get(4) * m.get(6))) / det,
|
||||||
|
-((m.get(0) * m.get(7)) - (m.get(1) * m.get(6))) / det,
|
||||||
|
((m.get(0) * m.get(4)) - (m.get(1) * m.get(3))) / det);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
template<typename T>
|
||||||
|
struct inverse_helper<T,4> {
|
||||||
|
static constexpr matrix<T,4,4> perform(const matrix<T,4,4>& m){
|
||||||
|
T det = m.determinate();
|
||||||
|
if(!det)
|
||||||
|
return matrix<T,4,4>(zero_initialize);
|
||||||
|
//Math is power
|
||||||
|
return matrix<T,4,4>((m.get(5) * ((m.get(10) * m.get(15)) - (m.get(11) * m.get(14))) -
|
||||||
|
m.get(6) * ((m.get(9) * m.get(15)) - (m.get(11) * m.get(13))) +
|
||||||
|
m.get(7) * ((m.get(9) * m.get(14)) - (m.get(10) * m.get(13)))) / det,
|
||||||
|
|
||||||
static constexpr size_type Columns = W;
|
-(m.get(1) * ((m.get(10) * m.get(15)) - (m.get(11) * m.get(14))) -
|
||||||
static constexpr size_type Rows = H;
|
m.get(2) * ((m.get(9) * m.get(15)) - (m.get(11) * m.get(13))) +
|
||||||
|
m.get(3) * ((m.get(9) * m.get(14)) - (m.get(10) * m.get(13)))) / det,
|
||||||
|
|
||||||
protected:
|
(m.get(1) * ((m.get(6) * m.get(15)) - (m.get(7) * m.get(14))) -
|
||||||
value_type m_data[W*H];
|
m.get(2) * ((m.get(5) * m.get(15)) - (m.get(7) * m.get(13))) +
|
||||||
|
m.get(3) * ((m.get(5) * m.get(14)) - (m.get(6) * m.get(13)))) / det,
|
||||||
|
|
||||||
protected:
|
-(m.get(1) * ((m.get(6) * m.get(11)) - (m.get(7) * m.get(10))) -
|
||||||
template<size_type... Ss>
|
m.get(2) * ((m.get(5) * m.get(11)) - (m.get(7) * m.get(9))) +
|
||||||
constexpr matrix_base(std::integer_sequence<size_type,Ss...>);
|
m.get(3) * ((m.get(5) * m.get(10)) - (m.get(6) * m.get(9)))) / det,
|
||||||
|
|
||||||
public:
|
-(m.get(4) * ((m.get(10) * m.get(15)) - (m.get(11) * m.get(14))) -
|
||||||
//Default construct as identity when square, zero otherwise
|
m.get(6) * ((m.get(8) * m.get(15)) - (m.get(11) * m.get(12))) +
|
||||||
constexpr matrix_base();
|
m.get(7) * ((m.get(8) * m.get(14)) - (m.get(10) * m.get(12)))) / det,
|
||||||
|
|
||||||
//Range initializing constructors
|
(m.get(0) * ((m.get(10) * m.get(15)) - (m.get(11) * m.get(14))) -
|
||||||
constexpr explicit matrix_base(detail::zero_initialize_t);
|
m.get(2) * ((m.get(8) * m.get(15)) - (m.get(11) * m.get(12))) +
|
||||||
constexpr explicit matrix_base(detail::no_initialize_t);
|
m.get(3) * ((m.get(8) * m.get(14)) - (m.get(10) * m.get(12)))) / det,
|
||||||
template<typename U = void>
|
|
||||||
constexpr explicit matrix_base(detail::id_initialize_t);
|
|
||||||
|
|
||||||
//Value initializing constructors
|
-(m.get(0) * ((m.get(6) * m.get(15)) - (m.get(7) * m.get(14))) -
|
||||||
constexpr explicit matrix_base(value_type v);
|
m.get(2) * ((m.get(4) * m.get(15)) - (m.get(7) * m.get(12))) +
|
||||||
template<typename... Args>
|
m.get(3) * ((m.get(4) * m.get(14)) - (m.get(6) * m.get(12)))) / det,
|
||||||
constexpr explicit matrix_base(Args&&... args);
|
|
||||||
|
|
||||||
//Copying constructors
|
(m.get(0) * ((m.get(6) * m.get(11)) - (m.get(7) * m.get(10))) -
|
||||||
constexpr matrix_base(const matrix_base&) = default;
|
m.get(2) * ((m.get(4) * m.get(11)) - (m.get(7) * m.get(8))) +
|
||||||
constexpr matrix_base(matrix_base&&) = default;
|
m.get(3) * ((m.get(4) * m.get(10)) - (m.get(6) * m.get(8)))) / det,
|
||||||
template<typename U>
|
|
||||||
constexpr matrix_base(const matrix_base<U,Columns,Rows>& m);
|
|
||||||
~matrix_base() = default;
|
|
||||||
|
|
||||||
//Assignement
|
(m.get(4) * ((m.get(9) * m.get(15)) - (m.get(11) * m.get(13))) -
|
||||||
template<typename U>
|
m.get(5) * ((m.get(8) * m.get(15)) - (m.get(11) * m.get(12))) +
|
||||||
constexpr matrix_base& operator=(const matrix_base<U,Columns,Rows>& m);
|
m.get(7) * ((m.get(8) * m.get(13)) - (m.get(9) * m.get(12)))) / det,
|
||||||
constexpr matrix_base& operator=(const matrix_base&) = default;
|
|
||||||
constexpr matrix_base& operator=(matrix_base&&) = default;
|
|
||||||
|
|
||||||
|
-(m.get(0) * ((m.get(9) * m.get(15)) - (m.get(11) * m.get(13))) -
|
||||||
|
m.get(1) * ((m.get(8) * m.get(15)) - (m.get(11) * m.get(12))) +
|
||||||
|
m.get(3) * ((m.get(8) * m.get(13)) - (m.get(9) * m.get(12)))) / det,
|
||||||
|
|
||||||
//Getters/Setters
|
(m.get(0) * ((m.get(5) * m.get(15)) - (m.get(7) * m.get(13))) -
|
||||||
constexpr auto operator[](size_type x);
|
m.get(1) * ((m.get(4) * m.get(15)) - (m.get(7) * m.get(12))) +
|
||||||
constexpr auto operator[](size_type x)const;
|
m.get(3) * ((m.get(4) * m.get(13)) - (m.get(5) * m.get(12)))) / det,
|
||||||
constexpr reference get(size_type x, size_type y);
|
|
||||||
constexpr const_reference get(size_type x, size_type y)const;
|
|
||||||
constexpr reference get(size_type i);
|
|
||||||
constexpr const_reference get(size_type i)const;
|
|
||||||
|
|
||||||
constexpr size_type columns()const;
|
-(m.get(0) * ((m.get(5) * m.get(11)) - (m.get(7) * m.get(9))) -
|
||||||
constexpr size_type rows()const;
|
m.get(1) * ((m.get(4) * m.get(11)) - (m.get(7) * m.get(8))) +
|
||||||
constexpr size_type size()const;
|
m.get(3) * ((m.get(4) * m.get(9)) - (m.get(5) * m.get(8)))) / det,
|
||||||
|
|
||||||
constexpr pointer raw();
|
-(m.get(4) * ((m.get(9) * m.get(14)) - (m.get(10) * m.get(13))) -
|
||||||
constexpr const_pointer raw()const;
|
m.get(5) * ((m.get(8) * m.get(14)) - (m.get(10) * m.get(12))) +
|
||||||
constexpr operator pointer();
|
m.get(6) * ((m.get(8) * m.get(13)) - (m.get(9) * m.get(12)))) / det,
|
||||||
constexpr operator const_pointer()const;
|
|
||||||
|
|
||||||
|
(m.get(0) * ((m.get(9) * m.get(14)) - (m.get(10) * m.get(13))) -
|
||||||
|
m.get(1) * ((m.get(8) * m.get(14)) - (m.get(10) * m.get(12))) +
|
||||||
|
m.get(2) * ((m.get(8) * m.get(13)) - (m.get(9) * m.get(12)))) / det,
|
||||||
|
|
||||||
|
-(m.get(0) * ((m.get(5) * m.get(14)) - (m.get(6) * m.get(13))) -
|
||||||
|
m.get(1) * ((m.get(4) * m.get(14)) - (m.get(6) * m.get(12))) +
|
||||||
|
m.get(2) * ((m.get(4) * m.get(13)) - (m.get(5) * m.get(12)))) / det,
|
||||||
|
|
||||||
|
(m.get(0) * ((m.get(5) * m.get(10)) - (m.get(6) * m.get(9))) -
|
||||||
|
m.get(1) * ((m.get(4) * m.get(10)) - (m.get(6) * m.get(8))) +
|
||||||
|
m.get(2) * ((m.get(4) * m.get(9)) - (m.get(5) * m.get(8)))) / det);
|
||||||
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|||||||
@ -37,111 +37,6 @@ namespace math::detail{
|
|||||||
return m_data[i*R];
|
return m_data[i*R];
|
||||||
}
|
}
|
||||||
|
|
||||||
template<typename T, size_t W, size_t H>
|
|
||||||
template<typename matrix_base<T,W,H>::size_type... Ss>
|
|
||||||
constexpr matrix_base<T,W,H>::matrix_base(std::integer_sequence<size_type,Ss...>):
|
|
||||||
m_data{Ss...}{}
|
|
||||||
|
|
||||||
template<typename T, size_t W, size_t H>
|
|
||||||
constexpr matrix_base<T,W,H>::matrix_base():
|
|
||||||
matrix_base(typename detail::default_initialization_matrix<Columns,Rows>::tuple{}){}
|
|
||||||
|
|
||||||
template<typename T, size_t W, size_t H>
|
|
||||||
constexpr matrix_base<T,W,H>::matrix_base(detail::zero_initialize_t):
|
|
||||||
m_data{}{}
|
|
||||||
template<typename T, size_t W, size_t H>
|
|
||||||
constexpr matrix_base<T,W,H>::matrix_base(detail::no_initialize_t){}
|
|
||||||
template<typename T, size_t W, size_t H>
|
|
||||||
template<typename U>
|
|
||||||
constexpr matrix_base<T,W,H>::matrix_base(detail::id_initialize_t):
|
|
||||||
matrix_base()
|
|
||||||
{
|
|
||||||
static_assert(Columns == Rows, "Identity initialization only supported on square matrices");
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename T, size_t W, size_t H>
|
|
||||||
constexpr matrix_base<T,W,H>::matrix_base(value_type v){
|
|
||||||
for(size_type i = 0;i < Columns*Rows;++i)
|
|
||||||
m_data[i] = v;
|
|
||||||
}
|
|
||||||
template<typename T, size_t W, size_t H>
|
|
||||||
template<typename... Args>
|
|
||||||
constexpr matrix_base<T,W,H>::matrix_base(Args&&... args):
|
|
||||||
m_data{std::forward<Args>(args)...}{}
|
|
||||||
|
|
||||||
template<typename T, size_t W, size_t H>
|
|
||||||
template<typename U>
|
|
||||||
constexpr matrix_base<T,W,H>::matrix_base(const matrix_base<U,Columns,Rows>& m){
|
|
||||||
using mat = decltype(m);
|
|
||||||
for(typename mat::size_type i = 0;i < mat::Columns*mat::Rows;++i)
|
|
||||||
m_data[i] = m.get(i);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename T, size_t W, size_t H>
|
|
||||||
template<typename U>
|
|
||||||
constexpr matrix_base<T,W,H>& matrix_base<T,W,H>::operator=(const matrix_base<U,Columns,Rows>& m){
|
|
||||||
using mat = decltype(m);
|
|
||||||
for(typename mat::size_type i = 0;i < mat::Columns*mat::Rows;++i)
|
|
||||||
m_data[i] = m.get(i);
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
template<typename T, size_t W, size_t H>
|
|
||||||
constexpr auto matrix_base<T,W,H>::operator[](size_type x){
|
|
||||||
return detail::mat_ref_obj<value_type,Rows>{m_data, x};
|
|
||||||
}
|
|
||||||
template<typename T, size_t W, size_t H>
|
|
||||||
constexpr auto matrix_base<T,W,H>::operator[](size_type x)const{
|
|
||||||
return detail::mat_ref_obj<const value_type,Rows>{m_data, x};
|
|
||||||
}
|
|
||||||
template<typename T, size_t W, size_t H>
|
|
||||||
constexpr auto matrix_base<T,W,H>::get(size_type x, size_type y) -> reference{
|
|
||||||
return m_data[x+(y*Rows)];
|
|
||||||
}
|
|
||||||
template<typename T, size_t W, size_t H>
|
|
||||||
constexpr auto matrix_base<T,W,H>::get(size_type x, size_type y)const -> const_reference{
|
|
||||||
return m_data[x+(y*Rows)];
|
|
||||||
}
|
|
||||||
template<typename T, size_t W, size_t H>
|
|
||||||
constexpr auto matrix_base<T,W,H>::get(size_type i) -> reference{
|
|
||||||
return m_data[i];
|
|
||||||
}
|
|
||||||
template<typename T, size_t W, size_t H>
|
|
||||||
constexpr auto matrix_base<T,W,H>::get(size_type i)const -> const_reference{
|
|
||||||
return m_data[i];
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename T, size_t W, size_t H>
|
|
||||||
constexpr auto matrix_base<T,W,H>::columns()const -> size_type{
|
|
||||||
return Columns;
|
|
||||||
}
|
|
||||||
template<typename T, size_t W, size_t H>
|
|
||||||
constexpr auto matrix_base<T,W,H>::rows()const -> size_type{
|
|
||||||
return Rows;
|
|
||||||
}
|
|
||||||
template<typename T, size_t W, size_t H>
|
|
||||||
constexpr auto matrix_base<T,W,H>::size()const -> size_type{
|
|
||||||
return Columns*Rows;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename T, size_t W, size_t H>
|
|
||||||
constexpr auto matrix_base<T,W,H>::raw() -> pointer{
|
|
||||||
return m_data;
|
|
||||||
}
|
|
||||||
template<typename T, size_t W, size_t H>
|
|
||||||
constexpr auto matrix_base<T,W,H>::raw()const -> const_pointer{
|
|
||||||
return m_data;
|
|
||||||
}
|
|
||||||
template<typename T, size_t W, size_t H>
|
|
||||||
constexpr matrix_base<T,W,H>::operator pointer(){
|
|
||||||
return m_data;
|
|
||||||
}
|
|
||||||
template<typename T, size_t W, size_t H>
|
|
||||||
constexpr matrix_base<T,W,H>::operator const_pointer()const{
|
|
||||||
return m_data;
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|||||||
142
include/mat.hpp
142
include/mat.hpp
@ -23,47 +23,122 @@
|
|||||||
#include <utility> //integer_sequence
|
#include <utility> //integer_sequence
|
||||||
#include <type_traits> //decay_t, is_same, integral_constant
|
#include <type_traits> //decay_t, is_same, integral_constant
|
||||||
#include "detail/math.hpp"
|
#include "detail/math.hpp"
|
||||||
#include "detail/matrix.hpp"
|
|
||||||
|
|
||||||
namespace math{
|
namespace math{
|
||||||
|
|
||||||
template<typename T, size_t C, size_t R>
|
template<typename T, size_t W, size_t H>
|
||||||
class matrix : public detail::matrix_base<T,C,R>
|
class matrix
|
||||||
{
|
{
|
||||||
private:
|
static_assert(W > 0, "Cannot have 0 columns matrix");
|
||||||
using base = detail::matrix_base<T,C,R>;
|
static_assert(H > 0, "Cannot have 0 rows matrix");
|
||||||
public:
|
public:
|
||||||
using value_type = typename base::value_type;
|
using value_type = T;
|
||||||
using size_type = typename base::size_type;
|
using size_type = size_t;
|
||||||
using pointer = typename base::pointer;
|
using pointer = value_type*;
|
||||||
using const_pointer = typename base::const_pointer;
|
using const_pointer = const value_type*;
|
||||||
using reference = typename base::reference;
|
using reference = value_type&;
|
||||||
using const_reference = typename base::const_reference;
|
using const_reference = const value_type&;
|
||||||
|
|
||||||
|
static constexpr size_type Columns = W;
|
||||||
|
static constexpr size_type Rows = H;
|
||||||
|
|
||||||
|
protected:
|
||||||
|
value_type m_data[W*H];
|
||||||
|
|
||||||
|
protected:
|
||||||
|
template<size_type... Ss>
|
||||||
|
constexpr matrix(std::integer_sequence<size_type,Ss...>);
|
||||||
|
|
||||||
public:
|
public:
|
||||||
using detail::matrix_base<T,C,R>::matrix_base;
|
//Default construct as identity when square, zero otherwise
|
||||||
using detail::matrix_base<T,C,R>::operator=;
|
constexpr matrix();
|
||||||
|
|
||||||
|
//Range initializing constructors
|
||||||
|
constexpr explicit matrix(detail::zero_initialize_t);
|
||||||
|
constexpr explicit matrix(detail::no_initialize_t);
|
||||||
|
template<typename U = void>
|
||||||
|
constexpr explicit matrix(detail::id_initialize_t);
|
||||||
|
|
||||||
|
//Value initializing constructors
|
||||||
|
constexpr explicit matrix(value_type v);
|
||||||
|
template<typename... Args>
|
||||||
|
constexpr explicit matrix(Args&&... args);
|
||||||
|
|
||||||
|
//Copying constructors
|
||||||
|
constexpr matrix(const matrix&) = default;
|
||||||
|
constexpr matrix(matrix&&) = default;
|
||||||
|
template<typename U>
|
||||||
|
constexpr matrix(const matrix<U,Columns,Rows>& m);
|
||||||
|
~matrix() = default;
|
||||||
|
|
||||||
|
//Assignement
|
||||||
|
template<typename U>
|
||||||
|
constexpr matrix& operator=(const matrix<U,Columns,Rows>& m);
|
||||||
|
constexpr matrix& operator=(const matrix&) = default;
|
||||||
|
constexpr matrix& operator=(matrix&&) = default;
|
||||||
|
|
||||||
|
|
||||||
|
//Getters/Setters
|
||||||
|
constexpr auto operator[](size_type x);
|
||||||
|
constexpr auto operator[](size_type x)const;
|
||||||
|
constexpr reference get(size_type x, size_type y);
|
||||||
|
constexpr const_reference get(size_type x, size_type y)const;
|
||||||
|
constexpr reference get(size_type i);
|
||||||
|
constexpr const_reference get(size_type i)const;
|
||||||
|
|
||||||
|
constexpr size_type columns()const;
|
||||||
|
constexpr size_type rows()const;
|
||||||
|
constexpr size_type size()const;
|
||||||
|
|
||||||
|
constexpr pointer raw();
|
||||||
|
constexpr const_pointer raw()const;
|
||||||
|
constexpr operator pointer();
|
||||||
|
constexpr operator const_pointer()const;
|
||||||
|
|
||||||
|
//square matrix arithmetic operations
|
||||||
|
template<typename U = T>
|
||||||
|
constexpr value_type determinate()const;
|
||||||
|
template<typename U = T>
|
||||||
|
constexpr value_type trace()const;
|
||||||
|
template<typename U = T>
|
||||||
|
constexpr matrix transpose()const;
|
||||||
|
template<typename U = T>
|
||||||
|
constexpr matrix inverse()const;
|
||||||
};
|
};
|
||||||
|
|
||||||
|
template<typename T, size_t R>
|
||||||
|
constexpr T determinate(const matrix<T,R,R>& m);
|
||||||
|
template<typename T, size_t R>
|
||||||
|
constexpr matrix<T,R,R> inverse(const matrix<T,R,R>& m);
|
||||||
|
|
||||||
template<typename T>
|
template<typename T>
|
||||||
class matrix<T,3,3> : public detail::matrix_base<T,3,3>
|
matrix<T,2,2> rotation2d_pure(T angle);
|
||||||
{
|
template<typename T>
|
||||||
private:
|
constexpr matrix<T,2,2> rotation2d_pure(T sin, T cos);
|
||||||
using base = detail::matrix_base<T,3,3>;
|
template<typename T>
|
||||||
public:
|
constexpr matrix<T,2,2> scale2d(T x, T y);
|
||||||
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 detail::matrix_base<T,3,3>::matrix_base;
|
|
||||||
using detail::matrix_base<T,3,3>::operator=;
|
|
||||||
|
|
||||||
static matrix rotation(value_type angle);
|
template<typename T>
|
||||||
static constexpr matrix rotation(value_type sin, value_type cos);
|
matrix<T,3,3> rotation2d(T angle);
|
||||||
static constexpr matrix rotation(value_type angle_x, value_type angle_y, value_type angle_z);
|
template<typename T>
|
||||||
};
|
constexpr matrix<T,3,3> rotation2d(T sin, T cos);
|
||||||
|
template<typename T>
|
||||||
|
matrix<T,3,3> rotation2d(T x, T y, T z);
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
matrix<T,4,4> fov_projection(T fov, T asp, T near, T far);
|
||||||
|
template<typename T>
|
||||||
|
matrix<T,4,4> fov_asymetric_projection(T fovl, T fovr, T fovb, T fovt, T asp, T near, T far);
|
||||||
|
template<typename T>
|
||||||
|
matrix<T,4,4> ortho_projection(T w, T h, T n, T f);
|
||||||
|
template<typename T>
|
||||||
|
matrix<T,4,4> ortho_asymetric_projection(T l, T r, T b, T t, T n, T f);
|
||||||
|
template<typename T>
|
||||||
|
constexpr matrix<T,4,4> rotation3d(T angle_x, T angle_y, T angle_z);
|
||||||
|
template<typename T>
|
||||||
|
constexpr matrix<T,4,4> translation3d(T x, T y, T z);
|
||||||
|
template<typename T>
|
||||||
|
constexpr matrix<T,4,4> scale3d(T x, T y, T z);
|
||||||
|
|
||||||
namespace detail{
|
namespace detail{
|
||||||
|
|
||||||
@ -97,6 +172,7 @@ namespace math{
|
|||||||
template<typename M1, typename M2>
|
template<typename M1, typename M2>
|
||||||
using enable_if_eq_matrix = std::enable_if_t<are_same_size_matrix<M1,M2>::value,int>;
|
using enable_if_eq_matrix = std::enable_if_t<are_same_size_matrix<M1,M2>::value,int>;
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
template<typename T, typename U, size_t W, size_t H>
|
template<typename T, typename U, size_t W, size_t H>
|
||||||
constexpr bool operator==(const matrix<T,W,H>& left, const matrix<U,W,H> right);
|
constexpr bool operator==(const matrix<T,W,H>& left, const matrix<U,W,H> right);
|
||||||
@ -108,6 +184,8 @@ namespace math{
|
|||||||
template<typename T, typename U, size_t C, size_t R>
|
template<typename T, typename U, size_t C, size_t R>
|
||||||
constexpr auto operator*(const matrix<T,C,R>& left, U&& right);
|
constexpr auto operator*(const matrix<T,C,R>& left, U&& right);
|
||||||
template<typename T, typename U, size_t C, size_t R>
|
template<typename T, typename U, size_t C, size_t R>
|
||||||
|
constexpr auto operator*(U&& left, const matrix<T,C,R>& right);
|
||||||
|
template<typename T, typename U, size_t C, size_t R>
|
||||||
constexpr auto operator/(const matrix<T,C,R>& left, U&& right);
|
constexpr auto operator/(const matrix<T,C,R>& left, U&& right);
|
||||||
template<typename T, typename U, size_t C, size_t R>
|
template<typename T, typename U, size_t C, size_t R>
|
||||||
constexpr auto operator+(const matrix<T,C,R>& left, const matrix<U,C,R>& right);
|
constexpr auto operator+(const matrix<T,C,R>& left, const matrix<U,C,R>& right);
|
||||||
@ -127,8 +205,6 @@ namespace math{
|
|||||||
template<typename T, typename U, size_t C, size_t R>
|
template<typename T, typename U, size_t C, size_t R>
|
||||||
constexpr decltype(auto) operator-=(matrix<T,C,R>& left, const matrix<U,C,R>& right);
|
constexpr decltype(auto) operator-=(matrix<T,C,R>& left, const matrix<U,C,R>& right);
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
#include "mat.tpp"
|
#include "mat.tpp"
|
||||||
|
|||||||
238
include/mat.tpp
238
include/mat.tpp
@ -22,26 +22,241 @@
|
|||||||
#include <cstdlib> //size_t
|
#include <cstdlib> //size_t
|
||||||
#include <cmath> //sin, cos
|
#include <cmath> //sin, cos
|
||||||
#include <type_traits> //decay_t, declval
|
#include <type_traits> //decay_t, declval
|
||||||
|
#include "detail/matrix.hpp"
|
||||||
|
|
||||||
namespace math{
|
namespace math{
|
||||||
|
|
||||||
|
template<typename T, size_t W, size_t H>
|
||||||
|
template<typename matrix<T,W,H>::size_type... Ss>
|
||||||
|
constexpr matrix<T,W,H>::matrix(std::integer_sequence<size_type,Ss...>):
|
||||||
|
m_data{Ss...}{}
|
||||||
|
|
||||||
|
template<typename T, size_t W, size_t H>
|
||||||
|
constexpr matrix<T,W,H>::matrix():
|
||||||
|
matrix(typename detail::default_initialization_matrix<Columns,Rows>::tuple{}){}
|
||||||
|
|
||||||
|
template<typename T, size_t W, size_t H>
|
||||||
|
constexpr matrix<T,W,H>::matrix(detail::zero_initialize_t):
|
||||||
|
m_data{}{}
|
||||||
|
template<typename T, size_t W, size_t H>
|
||||||
|
constexpr matrix<T,W,H>::matrix(detail::no_initialize_t){}
|
||||||
|
template<typename T, size_t W, size_t H>
|
||||||
|
template<typename U>
|
||||||
|
constexpr matrix<T,W,H>::matrix(detail::id_initialize_t):
|
||||||
|
matrix()
|
||||||
|
{
|
||||||
|
static_assert(Columns == Rows, "Identity initialization only supported on square matrices");
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T, size_t W, size_t H>
|
||||||
|
constexpr matrix<T,W,H>::matrix(value_type v){
|
||||||
|
for(size_type i = 0;i < Columns*Rows;++i)
|
||||||
|
m_data[i] = v;
|
||||||
|
}
|
||||||
|
template<typename T, size_t W, size_t H>
|
||||||
|
template<typename... Args>
|
||||||
|
constexpr matrix<T,W,H>::matrix(Args&&... args):
|
||||||
|
m_data{std::forward<Args>(args)...}{}
|
||||||
|
|
||||||
|
template<typename T, size_t W, size_t H>
|
||||||
|
template<typename U>
|
||||||
|
constexpr matrix<T,W,H>::matrix(const matrix<U,Columns,Rows>& m){
|
||||||
|
using mat = decltype(m);
|
||||||
|
for(typename mat::size_type i = 0;i < mat::Columns*mat::Rows;++i)
|
||||||
|
m_data[i] = m.get(i);
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T, size_t W, size_t H>
|
||||||
|
template<typename U>
|
||||||
|
constexpr matrix<T,W,H>& matrix<T,W,H>::operator=(const matrix<U,Columns,Rows>& m){
|
||||||
|
using mat = decltype(m);
|
||||||
|
for(typename mat::size_type i = 0;i < mat::Columns*mat::Rows;++i)
|
||||||
|
m_data[i] = m.get(i);
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
template<typename T, size_t W, size_t H>
|
||||||
|
constexpr auto matrix<T,W,H>::operator[](size_type x){
|
||||||
|
return detail::mat_ref_obj<value_type,Rows>{m_data, x};
|
||||||
|
}
|
||||||
|
template<typename T, size_t W, size_t H>
|
||||||
|
constexpr auto matrix<T,W,H>::operator[](size_type x)const{
|
||||||
|
return detail::mat_ref_obj<const value_type,Rows>{m_data, x};
|
||||||
|
}
|
||||||
|
template<typename T, size_t W, size_t H>
|
||||||
|
constexpr auto matrix<T,W,H>::get(size_type x, size_type y) -> reference{
|
||||||
|
return m_data[x+(y*Rows)];
|
||||||
|
}
|
||||||
|
template<typename T, size_t W, size_t H>
|
||||||
|
constexpr auto matrix<T,W,H>::get(size_type x, size_type y)const -> const_reference{
|
||||||
|
return m_data[x+(y*Rows)];
|
||||||
|
}
|
||||||
|
template<typename T, size_t W, size_t H>
|
||||||
|
constexpr auto matrix<T,W,H>::get(size_type i) -> reference{
|
||||||
|
return m_data[i];
|
||||||
|
}
|
||||||
|
template<typename T, size_t W, size_t H>
|
||||||
|
constexpr auto matrix<T,W,H>::get(size_type i)const -> const_reference{
|
||||||
|
return m_data[i];
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T, size_t W, size_t H>
|
||||||
|
constexpr auto matrix<T,W,H>::columns()const -> size_type{
|
||||||
|
return Columns;
|
||||||
|
}
|
||||||
|
template<typename T, size_t W, size_t H>
|
||||||
|
constexpr auto matrix<T,W,H>::rows()const -> size_type{
|
||||||
|
return Rows;
|
||||||
|
}
|
||||||
|
template<typename T, size_t W, size_t H>
|
||||||
|
constexpr auto matrix<T,W,H>::size()const -> size_type{
|
||||||
|
return Columns*Rows;
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T, size_t W, size_t H>
|
||||||
|
constexpr auto matrix<T,W,H>::raw() -> pointer{
|
||||||
|
return m_data;
|
||||||
|
}
|
||||||
|
template<typename T, size_t W, size_t H>
|
||||||
|
constexpr auto matrix<T,W,H>::raw()const -> const_pointer{
|
||||||
|
return m_data;
|
||||||
|
}
|
||||||
|
template<typename T, size_t W, size_t H>
|
||||||
|
constexpr matrix<T,W,H>::operator pointer(){
|
||||||
|
return m_data;
|
||||||
|
}
|
||||||
|
template<typename T, size_t W, size_t H>
|
||||||
|
constexpr matrix<T,W,H>::operator const_pointer()const{
|
||||||
|
return m_data;
|
||||||
|
}
|
||||||
|
template<typename T, size_t W, size_t H>
|
||||||
|
template<typename U>
|
||||||
|
constexpr auto matrix<T,W,H>::determinate()const -> value_type{
|
||||||
|
static_assert(W == H, "Determinate can only be calculated on square matrix");
|
||||||
|
return math::determinate(*this);
|
||||||
|
}
|
||||||
|
template<typename T, size_t W, size_t H>
|
||||||
|
template<typename U>
|
||||||
|
constexpr auto matrix<T,W,H>::trace()const -> value_type{
|
||||||
|
static_assert(W == H, "Trace can only be calculated on square matrix");
|
||||||
|
value_type sum = 0;
|
||||||
|
for(size_type i = 0;i < W;++i){
|
||||||
|
sum += get(i, i);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
template<typename T, size_t W, size_t H>
|
||||||
|
template<typename U>
|
||||||
|
constexpr matrix<T,W,H> matrix<T,W,H>::transpose()const{
|
||||||
|
matrix m(no_initialize);
|
||||||
|
for(size_type i = 0;i < W;++i){
|
||||||
|
for(size_type j = 0;j < W;++j){
|
||||||
|
m.get(j, i) = get(i, j);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return m;
|
||||||
|
}
|
||||||
|
template<typename T, size_t W, size_t H>
|
||||||
|
template<typename U>
|
||||||
|
constexpr matrix<T,W,H> matrix<T,W,H>::inverse()const{
|
||||||
|
static_assert(W == H, "Trace can only be calculated on square matrix");
|
||||||
|
return math::inverse(*this);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
template<typename T, size_t R>
|
||||||
|
constexpr T determinate(const matrix<T,R,R>& m){
|
||||||
|
return detail::determinate_helper<T,R>::perform(m);
|
||||||
|
}
|
||||||
|
template<typename T, size_t R>
|
||||||
|
constexpr matrix<T,R,R> inverse(const matrix<T,R,R>& m){
|
||||||
|
return detail::inverse_helper<T,R>::perform(m);
|
||||||
|
}
|
||||||
|
|
||||||
template<typename T>
|
template<typename T>
|
||||||
matrix<T,3,3> matrix<T,3,3>::rotation(value_type angle){
|
matrix<T,2,2> rotation2d_pure(T angle){
|
||||||
value_type c = std::cos(angle);
|
return rotation2d_pure(std::sin(angle), std::cos(angle));
|
||||||
value_type s = std::sin(angle);
|
|
||||||
return rotation(s, c);
|
|
||||||
}
|
}
|
||||||
template<typename T>
|
template<typename T>
|
||||||
constexpr matrix<T,3,3> matrix<T,3,3>::rotation(value_type sin, value_type cos){
|
constexpr matrix<T,2,2> rotation2d_pure(T sin, T cos){
|
||||||
return matrix(cos, -sin, 0,
|
return matrix<T,2,2>(cos, sin, -sin, cos);
|
||||||
|
}
|
||||||
|
template<typename T>
|
||||||
|
constexpr matrix<T,2,2> scale2d(T x, T y){
|
||||||
|
return matrix<T,2,2>(x, 0, 0, y);
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
matrix<T,3,3> rotation2d(T angle){
|
||||||
|
return rotation2d(std::sin(angle), std::cos(angle));
|
||||||
|
}
|
||||||
|
template<typename T>
|
||||||
|
constexpr matrix<T,3,3> rotation2d(T sin, T cos){
|
||||||
|
return matrix<T,3,3>(cos, -sin, 0,
|
||||||
sin, cos, 0,
|
sin, cos, 0,
|
||||||
0, 0, 1);
|
0, 0, 1);
|
||||||
}
|
}
|
||||||
template<typename T>
|
template<typename T>
|
||||||
constexpr matrix<T,3,3> matrix<T,3,3>::rotation(value_type angle_x, value_type angle_y, value_type angle_z){
|
matrix<T,3,3> rotation2d(T x, T y, T z){
|
||||||
//TODO
|
//TODO
|
||||||
|
return {};
|
||||||
}
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
matrix<T,4,4> fov_projection(T fov, T asp, T near, T far){
|
||||||
|
T r = near * std::tan(fov / T{2.0});
|
||||||
|
return matrix<T,4,4>((near / r) / asp, 0, 0, 0,
|
||||||
|
0, (near / r), 0, 0,
|
||||||
|
0, 0, (far + near) / (near - far), -1,
|
||||||
|
0, 0, (2 * near * far) / (near - far), 0);
|
||||||
|
}
|
||||||
|
template<typename T>
|
||||||
|
matrix<T,4,4> fov_asymetric_projection(T fovl, T fovr, T fovb, T fovt, T asp, T n, T f){
|
||||||
|
T l = n * std::tan(fovl);
|
||||||
|
T r = n * std::tan(fovr);
|
||||||
|
T b = n * std::tan(fovb);
|
||||||
|
T t = n * std::tan(fovt);
|
||||||
|
|
||||||
|
return matrix<T,4,4>(((2 * n) / (r - l)) * asp, 0, 0, 0,
|
||||||
|
0, (2 * n) / (t - b), 0, 0,
|
||||||
|
(r + l) / (r - l), (t + b) / (t - b), (f + n) / (n - f), -1,
|
||||||
|
0, 0, (2 * n * f) / (n - f), 0);
|
||||||
|
}
|
||||||
|
template<typename T>
|
||||||
|
matrix<T,4,4> ortho_projection(T w, T h, T n, T f){
|
||||||
|
return matrix<T,4,4>(2 / w, 0, 0, 0,
|
||||||
|
0, 2 / h, 0, 0,
|
||||||
|
0, 0, 2 / (n - f), 0,
|
||||||
|
0, 0, (n + f) / (n - f), 1);
|
||||||
|
}
|
||||||
|
template<typename T>
|
||||||
|
matrix<T,4,4> ortho_asymetric_projection(T l, T r, T b, T t, T n, T f){
|
||||||
|
return matrix<T,4,4>(2 / (r - l), 0, 0, 0,
|
||||||
|
0, 2 / (t - b), 0, 0,
|
||||||
|
0, 0, 2 / (n - f), 0,
|
||||||
|
(r + l) / (l - r), (t + b) / (b - t), (n + f) / (n - f), 1);
|
||||||
|
}
|
||||||
|
template<typename T>
|
||||||
|
constexpr matrix<T,4,4> rotation3d(T angle_x, T angle_y, T angle_z){
|
||||||
|
//TODO
|
||||||
|
return {};
|
||||||
|
}
|
||||||
|
template<typename T>
|
||||||
|
constexpr matrix<T,4,4> translation3d(T x, T y, T z){
|
||||||
|
return matrix<T,4,4>(1, 0, 0, 0,
|
||||||
|
0, 1, 0, 0,
|
||||||
|
0, 0, 1, 0,
|
||||||
|
x, y, z, 1);
|
||||||
|
}
|
||||||
|
template<typename T>
|
||||||
|
constexpr matrix<T,4,4> scale3d(T x, T y, T z){
|
||||||
|
return matrix<T,4,4>(x, 0, 0, 0,
|
||||||
|
0, y, 0, 0,
|
||||||
|
0, 0, z, 0,
|
||||||
|
0, 0, 0, 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
template<typename T, typename U, size_t W, size_t H>
|
template<typename T, typename U, size_t W, size_t H>
|
||||||
constexpr bool operator==(const matrix<T,W,H>& left, const matrix<U,W,H> right){
|
constexpr bool operator==(const matrix<T,W,H>& left, const matrix<U,W,H> right){
|
||||||
for(size_t i = 0;i < left.size();++i){
|
for(size_t i = 0;i < left.size();++i){
|
||||||
@ -80,6 +295,15 @@ namespace math{
|
|||||||
return res;
|
return res;
|
||||||
}
|
}
|
||||||
template<typename T, typename U, size_t C, size_t R>
|
template<typename T, typename U, size_t C, size_t R>
|
||||||
|
constexpr auto operator*(U&& left, const matrix<T,C,R>& right){
|
||||||
|
using res_t = decltype(std::declval<T>() * std::declval<U>());
|
||||||
|
matrix<res_t,C,R> res(no_initialize);
|
||||||
|
for(size_t i = 0;i < right.size();++i){
|
||||||
|
res.get(i) = std::forward<U>(left) * right.get(i);
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
template<typename T, typename U, size_t C, size_t R>
|
||||||
constexpr auto operator/(const matrix<T,C,R>& left, U&& right){
|
constexpr auto operator/(const matrix<T,C,R>& left, U&& right){
|
||||||
using res_t = decltype(std::declval<T>() / std::declval<U>());
|
using res_t = decltype(std::declval<T>() / std::declval<U>());
|
||||||
matrix<res_t,C,R> res(no_initialize);
|
matrix<res_t,C,R> res(no_initialize);
|
||||||
|
|||||||
Loading…
x
Reference in New Issue
Block a user