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