matrix_mxn.h

Go to the documentation of this file.

// Copyright (c) 2018 Doyub Kim
//
// I am making my contributions/submissions to this project solely in my
// personal capacity and am not conveying any rights to any intellectual
// property of any third parties.
 
#ifndef INCLUDE_JET_MATRIX_MXN_H_
#define INCLUDE_JET_MATRIX_MXN_H_
 
#include <jet/array2.h>
#include <jet/matrix_expression.h>
#include <jet/vector_n.h>
 
namespace jet {
 
// MARK: MatrixMxN
 
template <typename T>
class MatrixMxN final : public MatrixExpression<T, MatrixMxN<T>> {
 public:
    static_assert(
        std::is_floating_point<T>::value,
        "MatrixMxN only can be instantiated with floating point types");
 
    typedef Array2<T> ContainerType;
    typedef typename ContainerType::Iterator Iterator;
    typedef typename ContainerType::ConstIterator ConstIterator;
 
    // MARK: Constructors
 
    MatrixMxN();
 
    MatrixMxN(size_t m, size_t n, const T& s = T(0));
 
    MatrixMxN(const std::initializer_list<std::initializer_list<T>>& lst);
 
    template <typename E>
    MatrixMxN(const MatrixExpression<T, E>& other);
 
    MatrixMxN(size_t m, size_t n, const T* arr);
 
    MatrixMxN(const MatrixMxN& other);
 
    MatrixMxN(MatrixMxN&& other);
 
    // MARK: Basic setters
 
    void resize(size_t m, size_t n, const T& s = T(0));
 
    void set(const T& s);
 
    void set(const std::initializer_list<std::initializer_list<T>>& lst);
 
    template <typename E>
    void set(const MatrixExpression<T, E>& other);
 
    void set(size_t m, size_t n, const T* arr);
 
    void setDiagonal(const T& s);
 
    void setOffDiagonal(const T& s);
 
    template <typename E>
    void setRow(size_t i, const VectorExpression<T, E>& row);
 
    template <typename E>
    void setColumn(size_t j, const VectorExpression<T, E>& col);
 
    // MARK: Basic getters
    template <typename E>
    bool isEqual(const MatrixExpression<T, E>& other) const;
 
    template <typename E>
    bool isSimilar(const MatrixExpression<T, E>& other,
                   double tol = std::numeric_limits<double>::epsilon()) const;
 
    bool isSquare() const;
 
    Size2 size() const;
 
    size_t rows() const;
 
    size_t cols() const;
 
    T* data();
 
    const T* const data() const;
 
    Iterator begin();
 
    ConstIterator begin() const;
 
    Iterator end();
 
    ConstIterator end() const;
 
    // MARK: Binary operator methods - new instance = this instance (+) input
 
    MatrixScalarAdd<T, MatrixMxN> add(const T& s) const;
 
    template <typename E>
    MatrixAdd<T, MatrixMxN, E> add(const E& m) const;
 
    MatrixScalarSub<T, MatrixMxN> sub(const T& s) const;
 
    template <typename E>
    MatrixSub<T, MatrixMxN, E> sub(const E& m) const;
 
    MatrixScalarMul<T, MatrixMxN> mul(const T& s) const;
 
    template <typename VE>
    MatrixVectorMul<T, MatrixMxN, VE> mul(
        const VectorExpression<T, VE>& v) const;
 
    template <typename E>
    MatrixMul<T, MatrixMxN, E> mul(const E& m) const;
 
    MatrixScalarDiv<T, MatrixMxN> div(const T& s) const;
 
    // MARK: Binary operator methods - new instance = input (+) this instance
    MatrixScalarAdd<T, MatrixMxN> radd(const T& s) const;
 
    template <typename E>
    MatrixAdd<T, MatrixMxN, E> radd(const E& m) const;
 
    MatrixScalarRSub<T, MatrixMxN> rsub(const T& s) const;
 
    template <typename E>
    MatrixSub<T, MatrixMxN, E> rsub(const E& m) const;
 
    MatrixScalarMul<T, MatrixMxN> rmul(const T& s) const;
 
    template <typename E>
    MatrixMul<T, E, MatrixMxN> rmul(const E& m) const;
 
    MatrixScalarRDiv<T, MatrixMxN> rdiv(const T& s) const;
 
    // MARK: Augmented operator methods - this instance (+)= input
 
    void iadd(const T& s);
 
    template <typename E>
    void iadd(const E& m);
 
    void isub(const T& s);
 
    template <typename E>
    void isub(const E& m);
 
    void imul(const T& s);
 
    template <typename E>
    void imul(const E& m);
 
    void idiv(const T& s);
 
    // MARK: Modifiers
 
    void transpose();
 
    void invert();
 
    // MARK: Complex getters
    T sum() const;
 
    T avg() const;
 
    T min() const;
 
    T max() const;
 
    T absmin() const;
 
    T absmax() const;
 
    T trace() const;
 
    T determinant() const;
 
    MatrixDiagonal<T, MatrixMxN> diagonal() const;
 
    MatrixDiagonal<T, MatrixMxN> offDiagonal() const;
 
    MatrixTriangular<T, MatrixMxN> strictLowerTri() const;
 
    MatrixTriangular<T, MatrixMxN> strictUpperTri() const;
 
    MatrixTriangular<T, MatrixMxN> lowerTri() const;
 
    MatrixTriangular<T, MatrixMxN> upperTri() const;
 
    MatrixMxN transposed() const;
 
    MatrixMxN inverse() const;
 
    template <typename U>
    MatrixTypeCast<U, MatrixMxN, T> castTo() const;
 
    // MARK: Setter operators
 
    template <typename E>
    MatrixMxN& operator=(const E& m);
 
    MatrixMxN& operator=(const MatrixMxN& other);
 
    MatrixMxN& operator=(MatrixMxN&& other);
 
    MatrixMxN& operator+=(const T& s);
 
    template <typename E>
    MatrixMxN& operator+=(const E& m);
 
    MatrixMxN& operator-=(const T& s);
 
    template <typename E>
    MatrixMxN& operator-=(const E& m);
 
    MatrixMxN& operator*=(const T& s);
 
    template <typename E>
    MatrixMxN& operator*=(const E& m);
 
    MatrixMxN& operator/=(const T& s);
 
    // MARK: Getter operators
 
    T& operator[](size_t i);
 
    const T& operator[](size_t i) const;
 
    T& operator()(size_t i, size_t j);
 
    const T& operator()(size_t i, size_t j) const;
 
    template <typename E>
    bool operator==(const MatrixExpression<T, E>& m) const;
 
    template <typename E>
    bool operator!=(const MatrixExpression<T, E>& m) const;
 
    // MARK: Helpers
 
    template <typename Callback>
    void forEach(Callback func) const;
 
    template <typename Callback>
    void forEachIndex(Callback func) const;
 
    template <typename Callback>
    void parallelForEach(Callback func);
 
    template <typename Callback>
    void parallelForEachIndex(Callback func) const;
 
    // MARK: Builders
 
    static MatrixConstant<T> makeZero(size_t m, size_t n);
 
    static MatrixIdentity<T> makeIdentity(size_t m);
 
 private:
    ContainerType _elements;
};
 
typedef MatrixMxN<float> MatrixMxNF;
 
typedef MatrixMxN<double> MatrixMxND;
 
}  // namespace jet
 
#include "detail/matrix_mxn-inl.h"
 
#endif  // INCLUDE_JET_MATRIX_MXN_H_