MatrixDenseBase.hpp

Go to the documentation of this file.

// This code is based on Jet framework.
// Copyright (c) 2018 Doyub Kim
// CubbyFlow is voxel-based fluid simulation engine for computer games.
// Copyright (c) 2020 CubbyFlow Team
// Core Part: Chris Ohk, Junwoo Hwang, Jihong Sin, Seungwoo Yoo
// AI Part: Dongheon Cho, Minseo Kim
// We are making my contributions/submissions to this project solely in our
// personal capacity and are not conveying any rights to any intellectual
// property of any third parties.
 
#ifndef CUBBYFLOW_MATRIX_DENSE_BASE_HPP
#define CUBBYFLOW_MATRIX_DENSE_BASE_HPP
 
#include <Core/Matrix/MatrixExpression.hpp>
 
namespace CubbyFlow
{
// Derived type should be constructible.
template <typename T, size_t Rows, size_t Cols, typename Derived>
class MatrixDenseBase
{
 public:
    using ValueType = T;
    using Reference = T&;
    using ConstReference = const T&;
 
    template <size_t R, size_t C, typename E>
    void CopyFrom(const MatrixExpression<T, R, C, E>& expression);
 
    void SetDiagonal(ConstReference val);
 
    void SetOffDiagonal(ConstReference val);
 
    template <size_t R, size_t C, typename E>
    void SetRow(size_t i, const MatrixExpression<T, R, C, E>& row);
 
    template <size_t R, size_t C, typename E>
    void SetColumn(size_t j, const MatrixExpression<T, R, C, E>& col);
 
    void Normalize();
 
    void Transpose();
 
    void Invert();
 
    Reference operator()(size_t i, size_t j);
 
    ConstReference operator()(size_t i, size_t j) const;
 
    template <size_t R, size_t C, typename E>
    MatrixDenseBase& operator=(const MatrixExpression<T, R, C, E>& expression);
 
    template <typename D = Derived>
    static std::enable_if_t<IsMatrixSizeStatic<Rows, Cols>(), D> MakeZero();
 
    template <typename D = Derived>
    static std::enable_if_t<IsMatrixSizeDynamic<Rows, Cols>(), D> MakeZero(
        size_t rows, size_t cols);
 
    template <typename D = Derived>
    static std::enable_if_t<IsMatrixSizeStatic<Rows, Cols>(), D> MakeConstant(
        ValueType val);
 
    template <typename D = Derived>
    static std::enable_if_t<IsMatrixSizeDynamic<Rows, Cols>(), D> MakeConstant(
        size_t rows, size_t cols, ValueType val);
 
    template <typename D = Derived>
    static std::enable_if_t<IsMatrixStaticSquare<Rows, Cols>(), D>
    MakeIdentity();
 
    template <typename D = Derived>
    static std::enable_if_t<IsMatrixSizeDynamic<Rows, Cols>(), D> MakeIdentity(
        size_t rows);
 
    template <typename... Args, typename D = Derived>
    static std::enable_if_t<IsMatrixStaticSquare<Rows, Cols>(), D>
    MakeScaleMatrix(ValueType first, Args... rest);
 
    template <size_t R, size_t C, typename E, typename D = Derived>
    static std::enable_if_t<IsMatrixStaticSquare<Rows, Cols>(), D>
    MakeScaleMatrix(const MatrixExpression<T, R, C, E>& expression);
 
    template <typename D = Derived>
    static std::enable_if_t<IsMatrixStaticSquare<Rows, Cols>() && (Rows == 2),
                            D>
    MakeRotationMatrix(T rad);
 
    template <size_t R, size_t C, typename E, typename D = Derived>
    static std::enable_if_t<
        IsMatrixStaticSquare<Rows, Cols>() && (Rows == 3 || Rows == 4), D>
    MakeRotationMatrix(const MatrixExpression<T, R, C, E>& axis, T rad);
 
    template <size_t R, size_t C, typename E, typename D = Derived>
    static std::enable_if_t<IsMatrixStaticSquare<Rows, Cols>() && (Rows == 4),
                            D>
    MakeTranslationMatrix(const MatrixExpression<T, R, C, E>& t);
 
 protected:
    MatrixDenseBase() = default;
 
 private:
    [[nodiscard]] constexpr size_t GetRows() const;
 
    [[nodiscard]] constexpr size_t GetCols() const;
 
    [[nodiscard]] auto begin();
 
    [[nodiscard]] constexpr auto begin() const;
 
    [[nodiscard]] auto end();
 
    [[nodiscard]] constexpr auto end() const;
 
    Reference operator[](size_t i);
 
    ConstReference operator[](size_t i) const;
 
    [[nodiscard]] Derived& GetDerived();
 
    [[nodiscard]] const Derived& GetDerived() const;
};
}  // namespace CubbyFlow
 
#include <Core/Matrix/MatrixDenseBase-Impl.hpp>
 
#endif