问题

Question

我在这里尝试在O（1）中转置矩阵。所以现在我有这样的事情：

#include <vector>

template <class T>
class Matrix {  //intended for math matrix
public:
    Matrix(int Rows, int Cols){matrix = vector<vector<T> >(Rows, vector<T>(Cols,0)); transpose = false; cols = Cols; rows = Rows;}
    Matrix(const Matrix<T> &M){matrix = M.matrix; transpose = M.transpose; cols = M.cols; rows = M.rows;}
    ~Matrix(){}

    void t(){
        transpose = !transpose; 
        swap(cols,rows);
    }

    T& operator()(int row, int col){
        if(transpose) 
            return matrix[col][row]; 
        else 
            return matrix[row][col];
    }

private:
    vector<vector<T> > matrix;
    bool transpose;
    int cols;
    int rows;
};

在那段代码中我有我想要的东西：t（）是O（1）而operator（）也是O（1）。但是operator（）被大量使用，我想带走if 因此，为了验证我是否可以提高性能，我想要这样的东西：

#include <vector>

template <class T>
class Matrix {  //intended for math matrix
public:
    Matrix(int Rows, int Cols){matrix = vector<vector<T> >(Rows, vector<T>(Cols,0)); transpose = false; cols = Cols; rows = Rows;}
    Matrix(const Matrix<T> &M){matrix = M.matrix; transpose = M.transpose; cols = M.cols; rows = M.rows;}
    ~Matrix(){}

    T& originalShape(int row, int col){return matrix[row][col];}
    T& transposedMatrix(int row, int col){return matrix[col][row];}
    void t(){
        transpose = !transpose;
        swap(cols,rows);

        if(transpose)
            &operator() = &transposedMatrix;
        else
            &operator() = &originalShape;
    }
    T& operator()(int row, int col){return matrix[row][col];}

private:
    vector<vector<T> > matrix;
    bool transpose;
    int cols;
    int rows;
};

当然，这不起作用。我没有发现任何有用的情况。

有关t（）和operator（）的性能影响的更多信息：

我读到一些库都使用O（1）和O（行* cols）中的t（），根据矩阵的用途。但是在O（1）中执行t（）似乎是一个很好的第一步。如果那时我调用一个我知道它会逐行访问的方法，那么我可以在那一刻进行复制转置。

获取if：我们的想法是将操作的所有权重放在t()中并获得最快operator()，因为t()会被调用偶尔和operator()很多。我也想知道如何做到这一点，因为它可能会在另一种情况下有所帮助。

问题

也许我缺乏足够的英语来说明这一点：问题的目标是找到改变operator()行为的好方法。不改进Matrix()（建议非常感激），也不放弃改变operator()行为的任何方式，只因为可能不比{{1}更好}}。最终，我将分析，编码和发布在我拥有的和我得到的答案之间具有最佳性能的那个。但要知道什么有更好的性能，我需要那些代码/算法/模式/无论如何，我认为这可能有助于处于不同但类似情况的其他人。

Answer 1

如果将矩阵存储为单个向量，则可以编写索引函数，如下所示：

val args =  arrayOf("--debug") + tasks

最初T& operator()(int row, int col){ return matrix[col*colstep + row*rowstep]; }为1，rowstep为colstep。转置运算符交换这两个值和大小。

你确实有一个额外的乘法，你必须衡量它是否比额外的rows更好或更差。请注意，如果在循环中访问许多/所有矩阵元素，分支预测将在大多数情况下猜测。

您仍然会遇到以非最佳顺序访问数据的问题，考虑到存储顺序，编写算法是值得的。

如何在c ++中修改运行时的方法？

有关t（）和operator（）的性能影响的更多信息：

问题

1 个答案: