Эффективный способ доступа к подматрицам с одним индексом

Я пытаюсь выполнить пошаговый доступ к подматрице с одним индексом. Мне это нужно для библиотеки, над которой я работаю, которая использует шаблоны выражений. Я разработал следующий класс, где доступ осуществляется перегруженным 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[]?

Заранее большое спасибо.