Question

我正在尝试使用单个索引执行对子矩阵的跨步访问。我需要这个我正在使用的库，它使用表达式模板。我已经制定了以下类，其中访问是由重载的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[]？

提前多多感谢。

Answer 1

你可以获得加速的唯一方法是，如果你现在是编译时的矩阵和子矩阵的大小。然后使用template / constexpr可以加快速度。例如，如果在编译时已知大小为2的幂，则编译器将能够按shift替换除法。

使用单个索引访问子矩阵的有效方法

1 个答案: