matrix-wrapper.h

#pragma once
#include <cstdint>
#include <matrix-types.h>
#include <ostream>
#include <string>
#include <vector>
 
namespace snowboy {
    class VectorBase;
    struct SubMatrix;
    struct MatrixBase {
        size_t m_rows{0};
        size_t m_cols{0};
        size_t m_stride{0};
        float* m_data{nullptr};
 
        size_t rows() const noexcept { return m_rows; }
        size_t cols() const noexcept { return m_cols; }
        size_t stride() const noexcept { return m_stride; }
        float* data() const noexcept { return m_data; }
        float* data(size_t row) const noexcept { return m_data + (row * stride()); }
        float& operator()(size_t row, size_t col) const noexcept { return m_data[row * m_stride + col]; }
        bool empty() const noexcept { return rows() == 0 || cols() == 0; }
 
        void AddMat(float alpha, const MatrixBase& A, MatrixTransposeType transA);
        void AddMatMat(float, const MatrixBase&, MatrixTransposeType, const MatrixBase&, MatrixTransposeType, float);
        void AddVecToRows(float, const VectorBase&);
        void AddVecVec(float, const VectorBase&, const VectorBase&);
        void ApplyFloor(float);
        SubMatrix ColRange(size_t, size_t) const;
        void CopyColFromVec(const VectorBase&, size_t);
        void CopyCols(const MatrixBase&, const std::vector<ssize_t>&);
        void CopyColsFromVec(const VectorBase&);
        void CopyDiagFromVec(const VectorBase&);
        void CopyFromMat(const MatrixBase&, MatrixTransposeType transposeType);
        void CopyRowFromVec(const VectorBase&, size_t);
        void CopyRows(const MatrixBase&, const std::vector<ssize_t>&);
        void CopyRowsFromVec(const VectorBase&);
        bool IsDiagonal(float) const;
        bool IsSymmetric(float) const;
        bool IsUnit(float) const;
        // Implementation does a Max and checks that against cutoff
        // We can probably cancel early if the current value is above cutoff
        bool IsZero(float cutoff = 0.00001) const;
        void MulColsVec(const VectorBase&);
        void MulRowsVec(const VectorBase&);
        SubMatrix Range(size_t, size_t, size_t, size_t) const;
        void Read(bool, bool, std::istream*);
        void Read(bool, std::istream*); // Read(p1, false, p2);
        SubMatrix RowRange(size_t, size_t) const;
        void Scale(float factor);
        void Set(float value);
        void SetRandomGaussian();
        void SetRandomUniform();
        void SetUnit();
        void Transpose();
        void Write(bool, std::ostream*) const;
        bool HasNan() const;
        bool HasInfinity() const;
    };
    struct Matrix : MatrixBase {
        Matrix() {}
        Matrix(const Matrix& other) {
            Resize(other.m_rows, other.m_cols, MatrixResizeType::kUndefined);
            CopyFromMat(other, MatrixTransposeType::kNoTrans);
        }
        Matrix(const MatrixBase& other) {
            Resize(other.m_rows, other.m_cols, MatrixResizeType::kUndefined);
            CopyFromMat(other, MatrixTransposeType::kNoTrans);
        }
        Matrix(Matrix&& other) {
            m_rows = other.m_rows;
            m_cols = other.m_cols;
            m_stride = other.m_stride;
            m_data = other.m_data;
            other.m_rows = 0;
            other.m_data = nullptr;
            other.m_stride = 0;
            other.m_cols = 0;
        }
        void Resize(size_t rows, size_t cols, MatrixResizeType resize = MatrixResizeType::kSetZero);
        void AllocateMatrixMemory(size_t rows, size_t cols);
        void ReleaseMatrixMemory(); // NOTE: Called destroy in kaldi
        ~Matrix() { ReleaseMatrixMemory(); }
 
        Matrix& operator=(const Matrix& other);
        Matrix& operator=(const MatrixBase& other);
        Matrix& operator=(Matrix&& other) {
            Swap(&other);
            return *this;
        }
 
        void RemoveRow(size_t row);
        void Read(bool, bool, std::istream*);
        void Read(bool, std::istream*);
        void Swap(Matrix* other);
        void Transpose();
 
        static void PrintAllocStats(std::ostream&);
        static void ResetAllocStats();
    };
    struct SubMatrix : MatrixBase {
        SubMatrix(const MatrixBase& parent, size_t rowoffset, size_t rows, size_t coloffset, size_t cols);
    };
 
    std::ostream& operator<<(std::ostream&, const MatrixBase&);
} // namespace snowboy