1

我正在尝试对具有单个索引的子矩阵执行跨步访问。对于我正在使用的使用表达式模板的库，我需要这个。我已经制定了以下类，其中访问由重载执行operator[]，见下文：

template <class A, class Type>
class SubMatrixExpr
{
    private:
        int Rows_;              // Rows of the SubMatrix
        int Columns_;           // Columns of the SubMatrix
        int Rows_up_;               // Rows of the original Matrix
        int Columns_up_;            // Columns of the original Matrix
        int a_, c_;                 // Starting indices of the SubMatrix as evaluated in the original Matrix
        int rowstep_, columnstep_;      // Stride along rows and columns for the original matrix
        A M_;

    public:
        SubMatrixExpr(A &M, int Rows_up, int Columns_up, int Rows, int Columns, int a, int rowstep, int c, int columnstep) : 
           a_(a), c_(c), M_(M), 
           Rows_(Rows), 
           Columns_(Columns), 
           Rows_up_(Rows_up), Columns_up_(Columns_up), 
           rowstep_(rowstep), columnstep_(columnstep) { }

           inline const Type& operator[](const int i) const
           {
               const int LocalRow = i/Columns_;         
               const int LocalColumn = i%Columns_;      
               const int GlobalRow = a_+rowstep_*LocalRow;          
               const int GlobalColumn = c_+columnstep_*LocalColumn;
               return M_[IDX2R(GlobalRow,GlobalColumn,Columns_up_)];
           }

           inline Type& operator[](const int i) 
           {
              // Similar to above   
           }

 };

在哪里

#define IDX2R(i,j,N) (((i)*(N))+(j))

重载operator[]可以正常工作，但计算成本非常高。

有没有办法更好地实现重载operator[]？

提前非常感谢。

4

1 回答 1

0

获得加速的唯一方法是，如果您现在在编译时调整矩阵和子矩阵的大小。然后使用 template / constexpr 可能会加快速度。例如，如果在编译时知道大小是 2 的幂，编译器将能够用移位替换除法。

于 2013-07-21T20:44:39.260 回答