mat.h

Go to the documentation of this file.

// Copyright 2018-2023 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#ifndef _dspm_mat_h_
#define _dspm_mat_h_
#include <iostream>

namespace dspm {
class Mat {
public:
 
    int rows;               
    int cols;               
    int stride;             
    int padding;            
    float *data;            
    int length;             
    static float abs_tol;   
    bool ext_buff;          
    bool sub_matrix;        

    struct Rect {
        int x;              
        int y;              
        int width;          
        int height;         

        Rect(int x = 0, int y = 0, int width = 0, int height = 0);

        void resizeRect(int x, int y, int width, int height);

        int areaRect(void);
    };

    Mat(int rows, int cols);
    Mat(float *data, int rows, int cols);

    Mat(float *data, int rows, int cols, int stride);

    Mat();
    virtual ~Mat();

    Mat(const Mat &src);

    Mat getROI(int startRow, int startCol, int roiRows, int roiCols);

    Mat getROI(int startRow, int startCol, int roiRows, int roiCols, int stride);

    Mat getROI(const Mat::Rect &rect);

    void Copy(const Mat &src, int row_pos, int col_pos);

    void CopyHead(const Mat &src);

    void PrintHead(void);

    Mat Get(int row_start, int row_size, int col_start, int col_size);

    Mat Get(const Mat::Rect &rect);

    Mat &operator=(const Mat &src);

    inline float &operator()(int row, int col)
    {
        return data[row * this->stride + col];
    }

    inline const float &operator()(int row, int col) const
    {
        return data[row * this->stride + col];
    }

    Mat &operator+=(const Mat &A);

    Mat &operator+=(float C);
    Mat &operator-=(const Mat &A);

    Mat &operator-=(float C);

    Mat &operator*=(const Mat &A);
    Mat &operator*=(float C);
    Mat &operator/=(float C);
    Mat &operator/=(const Mat &B);
    Mat  operator^(int C);

    void swapRows(int row1, int row2);
    Mat t();

    static Mat eye(int size);

    static Mat ones(int size);

    static Mat ones(int rows, int cols);

    Mat block(int startRow, int startCol, int blockRows, int blockCols);

    void normalize(void);

    float norm(void);

    void clear(void);

    static Mat solve(Mat A, Mat b);
    static Mat bandSolve(Mat A, Mat b, int k);
    static Mat roots(Mat A, Mat y);

    static float dotProduct(Mat A, Mat B);

    static Mat augment(Mat A, Mat B);
    Mat gaussianEliminate();

    Mat rowReduceFromGaussian();

    Mat inverse();

    Mat pinv();

    float det(int n);
private:
    Mat cofactor(int row, int col, int n);
    Mat adjoint();
 
    void allocate(); // Allocate buffer
    Mat expHelper(const Mat &m, int num);
};

std::ostream &operator<<(std::ostream &os, const Mat &m);

std::ostream &operator<<(std::ostream &os, const Mat::Rect &rect);

std::istream &operator>>(std::istream &is, Mat &m);

Mat operator+(const Mat &A, const Mat &B);
Mat operator+(const Mat &A, float C);

Mat operator-(const Mat &A, const Mat &B);
Mat operator-(const Mat &A, float C);

Mat operator*(const Mat &A, const Mat &B);

Mat operator*(const Mat &A, float C);

Mat operator*(float C, const Mat &A);

Mat operator/(const Mat &A, float C);

Mat operator/(const Mat &A, const Mat &B);

bool operator==(const Mat &A, const Mat &B);
 
}
#endif //_dspm_mat_h_