Matrix.hpp

#ifndef KINEMATICS_MATRIX_HPP
#define KINEMATICS_MATRIX_HPP

#include <array>
#include <initializer_list>
#include <iostream>
#include <optional>
#include <type_traits>

namespace HLR
{
namespace Kinematics
{
template<typename T, std::size_t m, std::size_t n>
class Matrix
{
    static_assert(std::is_arithmetic<T>::value,
                  "Matrix can only be declared with a type where "
                  "std::is_arithmetic is true.");

public:
    static constexpr Matrix<T, m, n> get_identity() noexcept;

    Matrix() = default;

    ~Matrix() = default;

    Matrix(const Matrix<T, m, n>& mat) = default;

    Matrix(Matrix<T, m, n>&& mat) = default;

    Matrix<T, m, n>& operator=(const Matrix<T, m, n>& mat) = default;

    Matrix<T, m, n>& operator=(Matrix<T, m, n>&& mat) = default;

    constexpr Matrix(
        std::initializer_list<std::initializer_list<T>> matrix_data);

    constexpr std::size_t get_m() const noexcept;

    constexpr std::size_t get_n() const noexcept;

    constexpr std::array<T, n>& operator[](std::size_t pos) noexcept;

    constexpr const std::array<T, n>& operator[](std::size_t pos) const
        noexcept;

    constexpr std::array<T, n>& at(std::size_t pos);

    constexpr const std::array<T, n>& at(std::size_t pos) const;

    constexpr bool fuzzy_equal(const Matrix<T, m, n>& mat, T fuzz) const
        noexcept;

    constexpr bool operator==(const Matrix<T, m, n>& mat) noexcept;

    constexpr bool operator!=(const Matrix<T, m, n>& mat) noexcept;

    constexpr void operator+=(T scalar) noexcept;

    constexpr void operator-=(T scalar) noexcept;

    constexpr void operator*=(T scalar) noexcept;
    constexpr void operator/=(T scalar) noexcept;

    constexpr void operator+=(const Matrix<T, m, n>& mat) noexcept;

    constexpr void operator-=(const Matrix<T, m, n>& mat) noexcept;

    constexpr Matrix<T, m, n> operator+(const Matrix<T, m, n>& mat) const
        noexcept;

    constexpr Matrix<T, m, n> operator-(const Matrix<T, m, n>& mat) const
        noexcept;

    template<std::size_t p>
    constexpr Matrix<T, m, p> operator*(const Matrix<T, n, p>& mat) const
        noexcept;

    template<std::size_t p>
    constexpr Matrix<T, m, n + p> horizontal_augment(
        const Matrix<T, m, p>& mat) const noexcept;

    template<std::size_t p>
    constexpr Matrix<T, m + p, n> vertical_augment(
        const Matrix<T, p, n>& mat) const noexcept;

    template<std::size_t y, std::size_t x, std::size_t p, std::size_t q>
    constexpr Matrix<T, p, q> slice() const noexcept;

    constexpr Matrix<T, n, m> transpose() const noexcept;

    constexpr std::optional<Matrix<T, m, n>> inverse() const noexcept;

    constexpr T get_magnitude() const noexcept;

    std::string str() const;

private:
    std::array<std::array<T, n>, m> data{};
};

template<typename T, std::size_t m, std::size_t n>
constexpr Matrix<T, m, n> operator+(const Matrix<T, m, n>& lhs, T rhs) noexcept;

template<typename T, std::size_t m, std::size_t n>
constexpr Matrix<T, m, n> operator+(T lhs, const Matrix<T, m, n>& rhs) noexcept;

template<typename T, std::size_t m, std::size_t n>
constexpr Matrix<T, m, n> operator-(const Matrix<T, m, n>& lhs, T rhs) noexcept;

template<typename T, std::size_t m, std::size_t n>
constexpr Matrix<T, m, n> operator-(T lhs, const Matrix<T, m, n>& rhs) noexcept;

template<typename T, std::size_t m, std::size_t n>
constexpr Matrix<T, m, n> operator*(const Matrix<T, m, n>& lhs, T rhs) noexcept;

template<typename T, std::size_t m, std::size_t n>
constexpr Matrix<T, m, n> operator*(T lhs, const Matrix<T, m, n>& rhs) noexcept;

template<typename T, std::size_t m, std::size_t n>
constexpr Matrix<T, m, n> operator/(const Matrix<T, m, n>& lhs, T rhs) noexcept;

template<typename T, std::size_t m, std::size_t n>
constexpr Matrix<T, m, n> operator/(T lhs, const Matrix<T, m, n>& rhs) noexcept;

template<typename T, std::size_t m, std::size_t n>
std::ostream& operator<<(std::ostream& os, const Matrix<T, m, n>& mat);

} // namespace Kinematics
} // namespace HLR

#include "Matrix.ipp"

#endif