Implementing a Constant-Sized Matrix

2017-11-03 09:05:03

Problem

You want an efficient matrix implementation where the dimensions (i.e., number of rows and columns) are constants known at compile time.

Solution

When the dimensions of a matrix are known at compile time, the compiler can more easily optimize an implementation that accepts the row and columns as template parameters as shown in Example 11-30.

Example 11-30. kmatrix.hpp

#ifndef KMATRIX_HPP #define KMATRIX_HPP #include "kvector.hpp" #include "kstride_iter.hpp" template class kmatrix { public: // public typedefs typedef Value_T value_type; typedef kmatrix self; typedef Value_T* iterator; typedef const Value_T* const_iterator; typedef kstride_iter row_type; typedef kstride_iter col_type; typedef kstride_iter const_row_type; typedef kstride_iter const_col_type; // public constants static const int nRows = Rows_N; static const int nCols = Cols_N; // constructors kmatrix( ) { m = Value_T( ); } kmatrix(const self& x) { m = x.m; } explicit kmatrix(Value_T& x) { m = x.m; } // public functions static int rows( ) { return Rows_N; } static int cols( ) { return Cols_N; } row_type row(int n) { return row_type(begin( ) + (n * Cols_N)); } col_type col(int n) { return col_type(begin( ) + n); } const_row_type row(int n) const { return const_row_type(begin( ) + (n * Cols_N)); } const_col_type col(int n) const { return const_col_type(begin( ) + n); } iterator begin( ) { return m.begin( ); } iterator end( ) { return m.begin( ) + size( ); } const_iterator begin( ) const { return m; } const_iterator end( ) const { return m + size( ); } static int size( ) { return Rows_N * Cols_N; } // operators row_type operator[](int n) { return row(n); } const_row_type operator[](int n) const { return row(n); } // assignment operations self& operator=(const self& x) { m = x.m; return *this; } self& operator=(value_type x) { m = x; return *this; } self& operator+=(const self& x) { m += x.m; return *this; } self& operator-=(const self& x) { m -= x.m; return *this; } self& operator+=(value_type x) { m += x; return *this; } self& operator-=(value_type x) { m -= x; return *this; } self& operator*=(value_type x) { m *= x; return *this; } self& operator/=(value_type x) { m /= x; return *this; } self operator-( ) { return self(-m); } // friends friend self operator+(self x, const self& y) { return x += y; } friend self operator-(self x, const self& y) { return x -= y; } friend self operator+(self x, value_type y) { return x += y; } friend self operator-(self x, value_type y) { return x -= y; } friend self operator*(self x, value_type y) { return x *= y; } friend self operator/(self x, value_type y) { return x /= y; } friend bool operator==(const self& x, const self& y) { return x != y; } friend bool operator!=(const self& x, const self& y) { return x.m != y.m; } private: kvector m; }; #endif

Example 11-31 shows a program that demonstrates how to use the kmatrix template class.

Example 11-31. Using kmatrix

#include "kmatrix.hpp" #include using namespace std; template void outputRowOrColumn(Iter_T iter, int n) { for (int i=0; i < n; ++i) { cout << iter[i] << " "; } cout << endl; } template void initializeMatrix(Matrix_T& m) { int k = 0; for (int i=0; i < m.rows( ); ++i) { for (int j=0; j < m.cols( ); ++j) { m[i][j] = k++; } } } template void outputMatrix(Matrix_T& m) { for (int i=0; i < m.rows( ); ++i) { cout << "Row " << i << " = "; outputRowOrColumn(m.row(i), m.cols( )); } for (int i=0; i < m.cols( ); ++i) { cout << "Column " << i << " = "; outputRowOrColumn(m.col(i), m.rows( )); } } int main( ) { kmatrix m; initializeMatrix(m); m *= 2; outputMatrix(m); }

The program in Example 11-31 produces the following output:

Row 0 = 0 2 4 6 Row 1 = 8 10 12 14 Column 0 = 0 8 Column 1 = 2 10 Column 2 = 4 12 Column 3 = 6 14

Discussion

This design and usage for the kmatrix class template in Example 11-30 and Example 11-31 is very similar to the matrix class template presented in Recipe 11.14. The only significant difference is that to declare an instance of a kmatrix you pass the dimensions as template parameters, as follows:

kmatrix m; // declares a matrix with five rows and six columns

It is common for many kinds of applications requiring matricies that the dimensions are known at compile-time. Passing the row and column size as template parameters enables the compiler to more easily apply common optimizations such as loop-unrolling, function inlining, and faster indexing.

Like the constant-sized vector template presented earlier (kvector), the kmatrix template is particularly effective when using small matrix sizes.

Категории