- Main Page
- Modules
- Namespaces
- Classes
- Files

- Class List
- Class Members

# Matrix< Type > Class Template Reference

Matrix class implements a template for operations on matrices. More...

`#include <Matrix.h>`

List of all members.

## Public Member Functions
| Matrix (Integer rows=0, Integer cols=0)
| Default constructor.
| Matrix (Const Matrix &m)
| Copy constructor.
Void | SetSize (Integer rows, Integer cols)
| Set the size of a matrix.
List< Type > & | operator[] (Integer index)
| Indexing operator for matrix.
Matrix & | operator= (Const Matrix &m)
| Assignment/copy operator for matrix.
Bool | operator== (Const Matrix &m)
| Equality of two matrices.
Bool | operator!= (Const Matrix &m)
| Inequality of two matrices.
Const Matrix | operator+ (Const Matrix &m)
| Add two identical matrices.
Const Matrix | operator- (Const Matrix &m)
| Subtract two identical matrices.
Const Matrix | operator * (Const Integer R)
| Multiply matrix by a constant Integer.
Const Matrix | operator * (Const Real R)
| Multiply matrix by a constant Real.
Const Matrix | operator+ (Const Integer R)
| Add constant Integer to matrix.
Const Matrix | operator+ (Const Real R)
| Add constant Real to matrix.
Const Matrix | operator- (Const Integer R)
| Subtract constant Integer from matrix.
Const Matrix | operator- (Const Real R)
| Subtract constant Real from matrix.
Const Matrix | operator * (Matrix &m)
| Matrix multiplication. Columns of first matrix must be same size as rows of second.
Void | print (String s=0)
| Print a row of a matrix.
Type | rows ()
| Return the number of rows in the Matrix.
Type | cols ()
| Return the number of columns in the Matrix.
Void | length (Integer &r, Integer &c)
| Return the number of rows and columns in the Matrix by reference.
## Friends
ostream & | operator<< (ostream &os, Const Matrix &m)
| Print a matrix to stdout.
istream & | operator>> (istream &is, Matrix &m)
| Scan a matrix from stdin.

## Detailed Description

### template<class Type>
class Matrix< Type >

Matrix class implements a template for operations on matrices.

Definition at line 28 of file Matrix.h.

## Constructor & Destructor Documentation

template<class Type>

Matrix< Type >::Matrix | ( | Integer | rows = `0`,
|  | Integer | cols = `0` |
| ) |  |  | `[inline]`

Default constructor.

Definition at line 51 of file Matrix.h.

References Matrix< Type >::cols(), Matrix< Type >::rows(), and Matrix< Type >::SetSize().

    00051                                           : m_matrix(NULL) {
    00052         SetSize(rows,cols);
    00053     }

template<class Type>

Matrix< Type >::Matrix | ( | Const Matrix< Type > & | m | ) | `[inline]`

Copy constructor.

Definition at line 56 of file Matrix.h.

References Matrix< Type >::SetSize().

    00056                            : m_matrix(NULL) {
    00057         SetSize(m.m_lenRow, m.m_lenCol);
    00058         for (Integer r=0; r < m_lenRow; r++)
    00059             m_matrix[r]=List<Type>(m.m_matrix[r]);
    00060     }

## Member Function Documentation

template<class Type>

Type Matrix< Type >::cols | ( |  | ) | `[inline]`

Return the number of columns in the Matrix.

Definition at line 222 of file Matrix.h.

References Return.

Referenced by Matrix< Type >::length(), and Matrix< Type >::Matrix().

    00222 { Return m_lenCol; }

template<class Type>

Void Matrix< Type >::length | ( | Integer & | r,
|  | Integer & | c |
| ) |  |  | `[inline]`

Return the number of rows and columns in the Matrix by reference.

Parameters:

  | r | Number of rows, returned by reference
  | c | Number of columns, returned by reference

Definition at line 227 of file Matrix.h.

References Matrix< Type >::cols(), and Matrix< Type >::rows().

    00227 { r = rows(); c = cols(); }

template<class Type>

Const Matrix Matrix< Type >::operator * | ( | Matrix< Type > & | m | ) | `[inline]`

Matrix multiplication. Columns of first matrix must be same size as rows of second.

Definition at line 194 of file Matrix.h.

References Matrix< Type >::m_lenCol, Matrix< Type >::m_lenRow, and Return.

    00194                                           {
    00195         assert(m_lenCol==m.m_lenRow);
    00196         Matrix newMatrix(m_lenRow,m.m_lenCol);
    00197         for (Integer r = 0; r < m_lenRow; r++) {
    00198             for (Integer c = 0; c < m.m_lenCol; c++) {
    00199                 for (Integer i = 0; i < m_lenCol; i++) {
    00200                     newMatrix[r][c]+= m_matrix[r][i] * m[i][c];
    00201                 }
    00202             }
    00203         }
    00204         Return newMatrix;
    00205     }

template<class Type>

Const Matrix Matrix< Type >::operator * | ( | Const Real | R | ) | `[inline]`

Multiply matrix by a constant Real.

Definition at line 149 of file Matrix.h.

References For, and Return.

    00149                                              {
    00150         Matrix newMatrix(m_lenRow, m_lenCol);
    00151                 For (Integer r = 0; r < m_lenRow; r++)
    00152             for (Integer c = 0; c < m_lenCol; c++)
    00153                 newMatrix[r][c] = m_matrix[r][c] * R;
    00154         Return newMatrix;
    00155     }

template<class Type>

Const Matrix Matrix< Type >::operator * | ( | Const Integer | R | ) | `[inline]`

Multiply matrix by a constant Integer.

Definition at line 140 of file Matrix.h.

References For, and Return.

    00140                                                 {
    00141         Matrix newMatrix(m_lenRow, m_lenCol);
    00142                 For (Integer r = 0; r < m_lenRow; r++)
    00143             for (Integer c = 0; c < m_lenCol; c++)
    00144                 newMatrix[r][c] = m_matrix[r][c] * R;
    00145         Return newMatrix;
    00146     }

template<class Type>

Bool Matrix< Type >::operator!= | ( | Const Matrix< Type > & | m | ) | `[inline]`

Inequality of two matrices.

Definition at line 113 of file Matrix.h.

References Return.

    00113                                          {
    00114                 Return( ! (*this == m) );
    00115         }

template<class Type>

Const Matrix Matrix< Type >::operator+ | ( | Const Real | R | ) | `[inline]`

Add constant Real to matrix.

Definition at line 167 of file Matrix.h.

References For, and Return.

    00167                                              {
    00168         Matrix newMatrix(m_lenRow, m_lenCol);
    00169                 For (Integer r = 0; r < m_lenRow; r++)
    00170             for (Integer c = 0; c < m_lenCol; c++)
    00171                 newMatrix[r][c] = m_matrix[r][c] + R;
    00172         Return newMatrix;
    00173     }

template<class Type>

Const Matrix Matrix< Type >::operator+ | ( | Const Integer | R | ) | `[inline]`

Add constant Integer to matrix.

Definition at line 158 of file Matrix.h.

References For, and Return.

    00158                                                 {
    00159         Matrix newMatrix(m_lenRow, m_lenCol);
    00160                 For (Integer r = 0; r < m_lenRow; r++)
    00161             for (Integer c = 0; c < m_lenCol; c++)
    00162                 newMatrix[r][c] = m_matrix[r][c] + R;
    00163         Return newMatrix;
    00164     }

template<class Type>

Const Matrix Matrix< Type >::operator+ | ( | Const Matrix< Type > & | m | ) | `[inline]`

Add two identical matrices.

Performs element-by-element addition

Definition at line 119 of file Matrix.h.

References And, For, and Return.

    00119                                                 {
    00120         assert(m_lenCol == m.m_lenCol  And m_lenRow == m.m_lenRow);
    00121         Matrix newMatrix(m_lenRow, m_lenCol);
    00122                 For (Integer r=0; r < m_lenRow; r++)
    00123             for (Integer c=0; c < m_lenCol;c++)
    00124                 newMatrix[r][c] = m_matrix[r][c] + m.m_matrix[r][c];
    00125         Return newMatrix;
    00126     }

template<class Type>

Const Matrix Matrix< Type >::operator- | ( | Const Real | R | ) | `[inline]`

Subtract constant Real from matrix.

Definition at line 185 of file Matrix.h.

References For, and Return.

    00185                                              {
    00186         Matrix newMatrix(m_lenRow, m_lenCol);
    00187                 For (Integer r = 0; r < m_lenRow; r++)
    00188             for (Integer c = 0; c < m_lenCol; c++)
    00189                 newMatrix[r][c] = m_matrix[r][c] - R;
    00190         Return newMatrix;
    00191     }

template<class Type>

Const Matrix Matrix< Type >::operator- | ( | Const Integer | R | ) | `[inline]`

Subtract constant Integer from matrix.

Definition at line 176 of file Matrix.h.

References For, and Return.

    00176                                                 {
    00177         Matrix newMatrix(m_lenRow, m_lenCol);
    00178                 For (Integer r = 0; r < m_lenRow; r++)
    00179             for (Integer c = 0; c < m_lenCol; c++)
    00180                 newMatrix[r][c] = m_matrix[r][c] - R;
    00181         Return newMatrix;
    00182     }

template<class Type>

Const Matrix Matrix< Type >::operator- | ( | Const Matrix< Type > & | m | ) | `[inline]`

Subtract two identical matrices.

Performs element-by-element subtraction

Definition at line 130 of file Matrix.h.

References And, For, and Return.

    00130                                                 {
    00131         assert(m_lenCol == m.m_lenCol  And m_lenRow == m.m_lenRow);
    00132         Matrix newMatrix(m_lenRow, m_lenCol);
    00133                 For (Integer r = 0; r < m_lenRow; r++)
    00134             for (Integer c = 0; c < m_lenCol; c++)
    00135                 newMatrix[r][c] = m_matrix[r][c] - m.m_matrix[r][c];
    00136         Return newMatrix;
    00137     }

template<class Type>

Matrix& Matrix< Type >::operator= | ( | Const Matrix< Type > & | m | ) | `[inline]`

Assignment/copy operator for matrix.

Definition at line 88 of file Matrix.h.

References If, Return, and Matrix< Type >::SetSize().

    00088                                        {
    00089                 If (this == &m)
    00090                         Return *this;
    00091         SetSize(m.m_lenRow, m.m_lenCol);
    00092                 for (Integer r=0; r < m_lenRow; r++) {
    00093             m_matrix[r] = List<Type>(m.m_matrix[r]);
    00094                 }
    00095         Return *this;
    00096     }

template<class Type>

Bool Matrix< Type >::operator== | ( | Const Matrix< Type > & | m | ) | `[inline]`

Equality of two matrices.

Definition at line 99 of file Matrix.h.

References False, For, If, Return, and True.

    00099                                          {
    00100                 // Must have same dimensions
    00101                 If (m_lenRow != m.m_lenRow || m_lenCol != m.m_lenCol)
    00102                         Return False;
    00103
    00104                 // All rows must match
    00105                 For (Integer r=0; r < m_lenRow; r++) {
    00106                         If (m_matrix[r] != m.m_matrix[r])
    00107                                 Return False;
    00108                 }
    00109                 Return( True );
    00110         }

template<class Type>

List<Type>& Matrix< Type >::operator[] | ( | Integer | index | ) | `[inline]`

Indexing operator for matrix.

Definition at line 82 of file Matrix.h.

References Return.

    00082                                               {
    00083         assert(index < m_lenRow);
    00084         Return m_matrix[index];
    00085     }

template<class Type>

Void Matrix< Type >::print | ( | String | s = `0` | ) | `[inline]`

Print a row of a matrix.

Parameters:

  | s | String to prefix to matrix

Definition at line 209 of file Matrix.h.

References For, and If.

    00209                                  {
    00210                 If (s)
    00211                         printf(s);
    00212                 cout << "{\n";
    00213                 For (Integer i = 0; i < m_lenRow; i++)
    00214                         cout << m_matrix[i];
    00215                 cout << "}\n";
    00216         }

template<class Type>

Type Matrix< Type >::rows | ( |  | ) | `[inline]`

Return the number of rows in the Matrix.

Definition at line 219 of file Matrix.h.

References Return.

Referenced by Matrix< Type >::length(), and Matrix< Type >::Matrix().

    00219 { Return m_lenRow; }

template<class Type>

Void Matrix< Type >::SetSize | ( | Integer | rows,
|  | Integer | cols |
| ) |  |  | `[inline]`

Set the size of a matrix.

Parameters:

  | rows | Number of rows
  | cols | Number of columns

Definition at line 65 of file Matrix.h.

References And, Else, and If.

Referenced by Matrix< Type >::Matrix(), and Matrix< Type >::operator=().

    00065                                              {
    00066                 If (m_matrix != 0) {
    00067                         delete[] m_matrix;
    00068                         m_matrix = 0;
    00069                 }
    00070         If (cols > 0  And rows > 0) {
    00071             m_matrix = new List<Type>[rows];
    00072             for (Integer i = 0; i < rows; i++)
    00073                 m_matrix[i].SetListSize(cols);
    00074         }
    00075         Else
    00076             rows = 0;
    00077         m_lenCol = cols;
    00078                 m_lenRow = rows;
    00079     }

## Friends And Related Function Documentation

template<class Type>

ostream& operator<< | ( | ostream & | os,
|  | Const Matrix< Type > & | m |
| ) |  |  | `[friend]`

Print a matrix to stdout.

Definition at line 31 of file Matrix.h.

    00031                                                                 {
    00032                 // os << m.m_lenRow << " " << m.m_lenCol << " " <<endl;
    00033                 for (Integer r = 0; r < m.m_lenRow; r++)
    00034                         cout << m.m_matrix[r];
    00035                 Return os;
    00036         }

template<class Type>

istream& operator>> | ( | istream & | is,
|  | Matrix< Type > & | m |
| ) |  |  | `[friend]`

Scan a matrix from stdin.

Definition at line 39 of file Matrix.h.

    00039                                                            {
    00040                 Integer rows,cols;
    00041                 is >> rows >> cols;
    00042                 m.SetSize(rows, cols);
    00043                 for (Integer r = 0; r < rows; r++)
    00044                         for (Integer c = 0; c < cols; c++)
    00045                                 is >> m[r][c];
    00046                 Return is;
    00047                 }

The documentation for this class was generated from the following file:

- C:/Musimathics_local/Musimat/include/Matrix.h