# Directory:Derek Elder/Programs/MyMatrix

## MyMatrix.h

```#pragma once
#include <iostream>
using namespace std;

class MyMatrix
{
public:
MyMatrix();
MyMatrix(const MyMatrix& m);
MyMatrix(int rows, int columns);
~MyMatrix();
MyMatrix operator+(const MyMatrix& m2) const;
MyMatrix operator-(const MyMatrix& m2) const;
MyMatrix operator=(const MyMatrix& m);
double* operator[](int i);
double* operator[](int i) const;
double getDeterminant(MyMatrix& m);
void Write(ostream& os) const;
private:
double **m_dpp;
int m_rows;
int m_columns;
};
istream& operator>>(istream& is, MyMatrix& m);
ostream& operator<<(ostream& os, const MyMatrix& m);
```

## MyMatrix.cpp

```#include <iostream>
#include <cmath>
#include "MyMatrix.h"
using namespace std;

double MyMatrix::getDeterminant(MyMatrix& m)
{
int r, c;
r = m.m_rows;
c = m.m_columns;

double determinant = 0.0;

if(r == c)
{
if(r < 1)
{
cout<<"Less than one row and/or column";
exit(1);
}
else if(r == 1)
{
return m[0][0];
}
else if(r == 2)
{
//cout<<"The determinant is: "<<((m[0][0]*m[1][1]) - (m[0][1]*m[1][0]));
determinant = ((m[0][0]*m[1][1]) - (m[1][0]*m[0][1]));
return determinant;
}
else
{
for(int columns = 0; columns < m.m_columns; columns++)
{
MyMatrix m2((m.m_rows-1),(m.m_columns-1));

for(int subRows = 1; subRows < m.m_rows; subRows++)
{
int subColumns = 0;

for(int i = 0; i < m.m_columns; i++)
{
if(i != columns)
{
m2[(subRows-1)][subColumns] = m[subRows][i];
subColumns++;
}
}
}
determinant = determinant + ((m[0][columns])*(pow(float(-1),float(columns)))*(m2.getDeterminant(m2)));
}
}
return determinant;
}
else
{
cout<<"Error, the matrix is uneven, cannot determine the matrix, exiting program.";
exit(1);
}
}
MyMatrix::MyMatrix()
{
m_rows = 0;
m_columns = 0;
m_dpp = NULL;
}
MyMatrix::MyMatrix(int rows, int columns)
{
int i, j;
double *dp;

this->m_rows = rows;
this->m_columns = columns;
dp = new double[m_rows*m_columns];
m_dpp = new double*[m_rows];

for(i = 0;i < m_rows;i++)
m_dpp[i] = dp+(i * m_columns);
for(i = 0;i < m_rows;i++)
for(j = 0;j < m_columns;j++)
m_dpp[i][j] = 0;
}
MyMatrix::MyMatrix(const MyMatrix& m)
{
int i, j;
double *dp;

this->m_rows = m.m_rows;
this->m_columns = m.m_columns;
dp = new double[m_rows*m_columns]; //Real -> m_rows*m_columns != 0
m_dpp = new double*[m_rows];

for(i = 0;i < m_rows;i++)
m_dpp[i] = dp+(i * m_columns);
for(i = 0;i < m_rows;i++)
for(j = 0;j < m_columns;j++)
m_dpp[i][j] = m.m_dpp[i][j];
}
MyMatrix::~MyMatrix()
{
if(m_dpp != NULL)
{
delete [] m_dpp[0];
delete [] m_dpp;
}
}
MyMatrix MyMatrix::operator=(const MyMatrix& m)
{
int i, j;

if(this != &m)
{
if((m.m_rows == m_rows) && (m.m_columns == m_columns))
{
for(i = 0;i < m_rows;i++)
for(j = 0;j < m_columns;j++)
m_dpp[i][j] = m.m_dpp[i][j];
return *this;
}
if(m_dpp != NULL)
{
delete [] m_dpp[0];
delete [] m_dpp;
}

double* dp;
this->m_rows = m.m_rows;
this->m_columns = m.m_columns;
dp = new double[m_rows*m_columns];
m_dpp = new double*[m_rows];

for(i = 0;i < m_rows;i++)
m_dpp[i] = dp+(i * m_columns);
for(i = 0;i < m_rows;i++)
for(j = 0;j < m_columns;j++)
m_dpp[i][j] = m.m_dpp[i][j];
}
return *this;
}
double* MyMatrix::operator[](int i)
{
if(i >= 0 && i < m_rows)
return m_dpp[i];
else
{
cout<<"Error, Out of Range. Press enter to exit the program."<<flush;
cin.get();
cin.get();
exit(1);
}
}
double* MyMatrix::operator[](int i) const
{
if(i >= 0 && i < m_rows)
return m_dpp[i];
else
{
cout<<"Error, Out of Range. Press enter to exit the program."<<flush;
cin.get();
cin.get();
exit(1);
}
}
MyMatrix MyMatrix::operator+(const MyMatrix& m2) const
{
int i, j;

if((m2.m_rows != m_rows) || (m2.m_columns != m_columns))
{
cout<<"Error, different rows and/or columns.\n"
<<"Press enter to exit the program."<<flush;
cin.get();
cin.get();
exit(1);
}
MyMatrix sum(m2.m_rows,m2.m_columns);
for(i = 0;i < sum.m_rows;i++)
for(j = 0;j < sum.m_columns;j++)
sum.m_dpp[i][j] = m_dpp[i][j] + m2.m_dpp[i][j];
return sum;
}
MyMatrix MyMatrix::operator-(const MyMatrix& m2) const
{
int i, j;

if((m2.m_rows != m_rows) || (m2.m_columns != m_columns))
{
cout<<"Error, different rows and/or columns.\n"
<<"Press enter to exit the program."<<flush;
cin.get();
cin.get();
exit(1);
}
MyMatrix sum(m2.m_rows,m2.m_columns);
for(i = 0;i < m2.m_rows;i++)
for(j = 0;j < m2.m_columns;j++)
sum.m_dpp[i][j] = m_dpp[i][j] - m2.m_dpp[i][j];
return sum;
}
{
int i, j;
int rows, columns;

if(is == cin)
{
cout<<"Enter the number of rows: "<<flush;
cin>>rows;
cout<<"Enter the number of columns: "<<flush;
cin>>columns;

if((rows == m_rows) && (columns == m_columns))
{
for(i = 0;i < m_rows;i++)
{
for(j = 0;j < m_columns;j++)
{
cout<<"m["<<i<<"]"<<"["<<j<<"] = "<<flush;
cin>>m_dpp[i][j];
}
}
}
else
{
if(m_dpp != NULL)
{
delete [] m_dpp[0];
delete [] m_dpp;
}

m_rows = rows;
m_columns = columns;

double *dp;
dp = new double[m_rows*m_columns];
m_dpp = new double*[m_rows];

for(i = 0;i < m_rows;i++)
m_dpp[i] = dp + (i * m_columns);
for(i = 0;i < m_rows;i++)
{
for(j = 0;j < m_columns;j++)
{
cout<<"m["<<i<<"]"<<"["<<j<<"] = "<<flush;
cin>>m_dpp[i][j];
}
}
}
}
else
{
is>>m_rows;
is>>m_columns;

if(m_dpp != NULL)
{
delete [] m_dpp[0];
delete [] m_dpp;
}

double *dp;
dp = new double[m_rows*m_columns];
m_dpp = new double*[m_rows];

for(i = 0;i < m_rows;i++)
m_dpp[i] = dp + (i * m_columns);
for(i = 0;i < m_rows;i++)
{
for(j = 0;j < m_columns;j++)
is>>m_dpp[i][j];
}
}
}
void MyMatrix::Write(ostream& os) const
{
int i, j;

if(os == cout)
{
if((m_rows == 0) || (m_columns == 0))
cout<<"The matrix is empty.\n";

for(i = 0;i < m_rows;i++)
{
if(i > 0)
cout<<"\n\n";

for(j = 0;j < m_columns;j++)
{
cout<<m_dpp[i][j]<<" ";
}
}
}
else
{
for(i = 0;i < m_rows;i++)
{
for(j = 0;j < m_columns;j++)
{
os<<m_dpp[i][j]<<"\n";
}
}
}
}
istream& operator>>(istream& is, MyMatrix& m)
{
return is;
}
ostream& operator<<(ostream& os, const MyMatrix& m)
{
m.Write(os);
return os;
}
```

## Main.cpp

```#include <iostream>
#include <string>
#include "MyMatrix.h"
using namespace std;

void main()
{
int rows,i,j;
double cr;
//MyMatrix m1, m2(2,3);

cout<<"How many equations would you like to solve? "<<flush;
cin>>rows;

MyMatrix m3(rows,rows); //Input matrix

for(i = 0;i < rows;i++)
{
for(j = 0;j < rows;j++)
{
cout<<"Enter the coefficent of row "<<(i + 1)
<<", column "<<(j + 1)<<": ";
cin>>m3[i][j];
}
cout<<"Enter what the row equates to: ";
cin>>m4[i][0];
}
cout<<"The determinant is: "<<m3.getDeterminant(m3)<<"\n";

MyMatrix m5(m3); //D Matrix
MyMatrix m6(1,rows); //Variable matrix

for(j = 0; j < rows;j++)
{
cr = 0;
for(i = 0;i < rows;i++)
{
m5[i][j] = m4[i][0];
}
cr = ((m5.getDeterminant(m5))/(m3.getDeterminant(m3)));
m5 = m3;
m6[0][j] = cr;
cout<<"cr"<<(j+1)<<" = "<<cr<<endl;
}
cout<<"Checking phase"<<'\n';
double var;
for(i = 0;i < rows;i++)
{
var = 0;
for(j = 0;j < rows;j++)
{
var += (m6[0][j] * m5[i][j]);
cout<<m5[i][j]<<" * "<<m6[0][j];
if(j != rows - 1)
{
cout<<" + ";
}
else
{
cout<<" = ";
}
}
cout<<var<<endl;
}
cout<<"\nHit enter to exit the program."<<endl;

/*cout<<"After:\n"
<<"MyMatrix m1, m2(2,3), m3;\n"
<<"m1:\n"<<m1
<<"\nm2:\n"<<m2
<<"\nm3:\n"<<m3;

cout<<"\n\nEnter the data for m3:\n"<<flush;
cin>>m3;
cout<<"\nThe matrix you entered follows:\n"<<m3;
cout<<"\nHit enter to continue: "<<flush;
cin.get();
cin.get();

cout<<"\nm3[0][0] = " << m3[0][0] << '\n';

m3[0][0] = 29.999;

cout<<"\nAfter:\n      m3[0][0] = 29.999;\nm3 follows:\n"<<m3;
cout<<"\nHit enter to continue: "<<flush;
cin.get();
cout<<"\n\nEnter the data for m2:\n"<<flush;
cin>>m2;
cout<<"The matrix you entered follows:\n"<<m2;
cout<<"\nHit enter to continue: "<<flush;
cin.get();

m1 = m2 + m3;

cout<<"\n\nAfter:\n      m1 = m2 + m3;\nm1 follows:\n"<<m1;
cout<<"\nHit enter to continue: "<<flush;
cin.get();

m1 = m2 - m3;

cout<<"\n\nAfter:\n      m1 = m2 - m3;\nm1 follows:\n"<<m1;
cout<<"\nHit enter to continue: "<<flush;
cin.get();

m1 = m3;

cout<<"\n\nAfter:\n      m1 = m3;\nm1 follows:\n"<<m1;
cout<<"\nHit enter to continue: "<<flush;
cin.get();

m1[0][0] = -999.876;

cout<<"\n\nAfter:\n      m1[0][0] = -999.876;\nm1 follows:\n"<<m1
<<"\n\nm3 follows:\n" <<m3<<"\n\nIs this what you expected?";
cout<<"\n\nHit enter to exit the program: "<<flush;
cin.get();*/
}
```

# With Templates

## MyMatrix.h

```#pragma once
#include <iostream>
using namespace std;

template <class T>
class MyMatrix
{
public:
MyMatrix();
MyMatrix(const MyMatrix<T>& m);
MyMatrix(int rows, int columns);
~MyMatrix();
MyMatrix operator+(const MyMatrix<T>& m2) const;
MyMatrix operator-(const MyMatrix<T>& m2) const;
MyMatrix operator=(const MyMatrix<T>& m);
T* operator[](int i);
T* operator[](int i) const;
double getDeterminant(MyMatrix<T>& m);
void Write(ostream& os) const;
private:
T **m_dpp;
int m_rows;
int m_columns;
};
template <class T>
istream& operator>>(istream& is, MyMatrix<T>& m);
template <class T>
ostream& operator<<(ostream& os, const MyMatrix<T>& m);

template <class T>
double MyMatrix<T>::getDeterminant(MyMatrix<T>& m)
{
int r, c;
r = m.m_rows;
c = m.m_columns;

double determinant = 0.0;

if(r == c)
{
if(r < 1)
{
cout<<"Less than one row and/or column";
exit(1);
}
else if(r == 1)
{
return m[0][0];
}
else if(r == 2)
{
//cout<<"The determinant is: "<<((m[0][0]*m[1][1]) - (m[0][1]*m[1][0]));
determinant = ((m[0][0]*m[1][1]) - (m[1][0]*m[0][1]));
return determinant;
}
else
{
for(int columns = 0; columns < m.m_columns; columns++)
{
MyMatrix m2((m.m_rows-1),(m.m_columns-1));

for(int subRows = 1; subRows < m.m_rows; subRows++)
{
int subColumns = 0;

for(int i = 0; i < m.m_columns; i++)
{
if(i != columns)
{
m2[(subRows-1)][subColumns] = m[subRows][i];
subColumns++;
}
}
}
determinant = determinant + ((m[0][columns])*(pow(float(-1),float(columns)))*(m2.getDeterminant(m2)));
}
}
return determinant;
}
else
{
cout<<"Error, the matrix is uneven, cannot determine the matrix, exiting program.";
exit(1);
}
}
template <class T>
MyMatrix<T>::MyMatrix()
{
m_rows = 0;
m_columns = 0;
m_dpp = NULL;
}
template <class T>
MyMatrix<T>::MyMatrix(int rows, int columns)
{
int i, j;
T *dp;

this->m_rows = rows;
this->m_columns = columns;
dp = new T[m_rows*m_columns];
m_dpp = new T*[m_rows];

for(i = 0;i < m_rows;i++)
m_dpp[i] = dp+(i * m_columns);
for(i = 0;i < m_rows;i++)
for(j = 0;j < m_columns;j++)
m_dpp[i][j] = 0;
}
template <class T>
MyMatrix<T>::MyMatrix(const MyMatrix<T>& m)
{
int i, j;
T *dp;

this->m_rows = m.m_rows;
this->m_columns = m.m_columns;
dp = new T[m_rows*m_columns];
m_dpp = new T*[m_rows];

for(i = 0;i < m_rows;i++)
m_dpp[i] = dp+(i * m_columns);
for(i = 0;i < m_rows;i++)
for(j = 0;j < m_columns;j++)
m_dpp[i][j] = m.m_dpp[i][j];
}
template <class T>
MyMatrix<T>::~MyMatrix()
{
if(m_dpp != NULL)
{
delete [] m_dpp[0];
delete [] m_dpp;
}
}
template <class T>
MyMatrix<T> MyMatrix<T>::operator=(const MyMatrix<T>& m)
{
int i, j;

if(this != &m)
{
if((m.m_rows == m_rows) && (m.m_columns == m_columns))
{
for(i = 0;i < m_rows;i++)
for(j = 0;j < m_columns;j++)
m_dpp[i][j] = m.m_dpp[i][j];
return *this;
}
if(m_dpp != NULL)
{
delete [] m_dpp[0];
delete [] m_dpp;
}

T* dp;
this->m_rows = m.m_rows;
this->m_columns = m.m_columns;
dp = new T[m_rows*m_columns];
m_dpp = new T*[m_rows];

for(i = 0;i < m_rows;i++)
m_dpp[i] = dp+(i * m_columns);
for(i = 0;i < m_rows;i++)
for(j = 0;j < m_columns;j++)
m_dpp[i][j] = m.m_dpp[i][j];
}
return *this;
}
template <class T>
MyMatrix<T> MyMatrix<T>::operator+(const MyMatrix<T>& m2) const
{
int i, j;

if((m2.m_rows != m_rows) || (m2.m_columns != m_columns))
{
cout<<"Error, different rows and/or columns.\n"
<<"Press enter to exit the program."<<flush;
cin.get();
cin.get();
exit(1);
}
MyMatrix sum(m2.m_rows,m2.m_columns);
for(i = 0;i < sum.m_rows;i++)
for(j = 0;j < sum.m_columns;j++)
sum.m_dpp[i][j] = m_dpp[i][j] + m2.m_dpp[i][j];
return sum;
}
template <class T>
MyMatrix<T> MyMatrix<T>::operator-(const MyMatrix<T>& m2) const
{
int i, j;

if((m2.m_rows != m_rows) || (m2.m_columns != m_columns))
{
cout<<"Error, different rows and/or columns.\n"
<<"Press enter to exit the program."<<flush;
cin.get();
cin.get();
exit(1);
}
MyMatrix sum(m2.m_rows,m2.m_columns);
for(i = 0;i < m2.m_rows;i++)
for(j = 0;j < m2.m_columns;j++)
sum.m_dpp[i][j] = m_dpp[i][j] - m2.m_dpp[i][j];
return sum;
}
template <class T>
T* MyMatrix<T>::operator[](int i)
{
if(i >= 0 && i < m_rows)
return m_dpp[i];
else
{
cout<<"Error, Out of Range. Press enter to exit the program."<<flush;
cin.get();
cin.get();
exit(1);
}
}
template <class T>
T* MyMatrix<T>::operator[](int i) const
{
if(i >= 0 && i < m_rows)
return m_dpp[i];
else
{
cout<<"Error, Out of Range. Press enter to exit the program."<<flush;
cin.get();
cin.get();
exit(1);
}
}
template <class T>
{
int i, j;
int rows, columns;

if(is == cin)
{
cout<<"Enter the number of rows: "<<flush;
cin>>rows;
cout<<"Enter the number of columns: "<<flush;
cin>>columns;

if((rows == m_rows) && (columns == m_columns))
{
for(i = 0;i < m_rows;i++)
{
for(j = 0;j < m_columns;j++)
{
cout<<"m["<<i<<"]"<<"["<<j<<"] = "<<flush;
cin>>m_dpp[i][j];
}
}
}
else
{
if(m_dpp != NULL)
{
delete [] m_dpp[0];
delete [] m_dpp;
}

m_rows = rows;
m_columns = columns;

T *dp;
dp = new T[m_rows*m_columns];
m_dpp = new T*[m_rows];

for(i = 0;i < m_rows;i++)
m_dpp[i] = dp + (i * m_columns);
for(i = 0;i < m_rows;i++)
{
for(j = 0;j < m_columns;j++)
{
cout<<"m["<<i<<"]"<<"["<<j<<"] = "<<flush;
cin>>m_dpp[i][j];
}
}
}
}
else
{
is>>m_rows;
is>>m_columns;

if(m_dpp != NULL)
{
delete [] m_dpp[0];
delete [] m_dpp;
}

T *dp;
dp = new T[m_rows*m_columns];
m_dpp = new T*[m_rows];

for(i = 0;i < m_rows;i++)
m_dpp[i] = dp + (i * m_columns);
for(i = 0;i < m_rows;i++)
{
for(j = 0;j < m_columns;j++)
is>>m_dpp[i][j];
}
}
}
template <class T>
void MyMatrix<T>::Write(ostream& os) const
{
int i, j;

if(os == cout)
{
if((m_rows == 0) || (m_columns == 0))
cout<<"The matrix is empty.\n";

for(i = 0;i < m_rows;i++)
{
if(i > 0)
cout<<"\n\n";

for(j = 0;j < m_columns;j++)
{
cout<<m_dpp[i][j]<<" ";
}
cout<<"\n";
}
}
else
{
for(i = 0;i < m_rows;i++)
{
for(j = 0;j < m_columns;j++)
{
os<<m_dpp[i][j]<<"\n";
}
}
}
}
template <class T>
istream& operator>>(istream& is, MyMatrix<T>& m)
{
return is;
}
template <class T>
ostream& operator<<(ostream& os, const MyMatrix<T>& m)
{
m.Write(os);
return os;
}
```

## MyMatrix.cpp

```#include <iostream>
#include <cmath>
#include "MyMatrix.h"
using namespace std;

template <class T>
T MyMatrix<T>::getDeterminant(MyMatrix& m)
{
int r, c;
r = m.m_rows;
c = m.m_columns;

T determinant = 0.0;

if(r == c)
{
if(r < 1)
{
cout<<"Less than one row and/or column";
exit(1);
}
else if(r == 1)
{
return m[0][0];
}
else if(r == 2)
{
//cout<<"The determinant is: "<<((m[0][0]*m[1][1]) - (m[0][1]*m[1][0]));
determinant = ((m[0][0]*m[1][1]) - (m[1][0]*m[0][1]));
return determinant;
}
else
{
for(int columns = 0; columns < m.m_columns; columns++)
{
MyMatrix m2((m.m_rows-1),(m.m_columns-1));

for(int subRows = 1; subRows < m.m_rows; subRows++)
{
int subColumns = 0;

for(int i = 0; i < m.m_columns; i++)
{
if(i != columns)
{
m2[(subRows-1)][subColumns] = m[subRows][i];
subColumns++;
}
}
}
determinant = determinant + ((m[0][columns])*(pow(float(-1),float(columns)))*(m2.getDeterminant(m2)));
}
}
return determinant;
}
else
{
cout<<"Error, the matrix is uneven, cannot determine the matrix, exiting program.";
exit(1);
}
}
template <class T>
MyMatrix<T>::MyMatrix()
{
m_rows = 0;
m_columns = 0;
m_dpp = NULL;
}
template <class T>
MyMatrix<T>::MyMatrix(int rows, int columns)
{
int i, j;
T *dp;

this->m_rows = rows;
this->m_columns = columns;
dp = new T[m_rows*m_columns];
m_dpp = new T*[m_rows];

for(i = 0;i < m_rows;i++)
m_dpp[i] = dp+(i * m_columns);
for(i = 0;i < m_rows;i++)
for(j = 0;j < m_columns;j++)
m_dpp[i][j] = 0;
}
template <class T>
MyMatrix<T>::MyMatrix(const MyMatrix& m)
{
int i, j;
T *dp;

this->m_rows = m.m_rows;
this->m_columns = m.m_columns;
dp = new T[m_rows*m_columns];
m_dpp = new T*[m_rows];

for(i = 0;i < m_rows;i++)
m_dpp[i] = dp+(i * m_columns);
for(i = 0;i < m_rows;i++)
for(j = 0;j < m_columns;j++)
m_dpp[i][j] = m.m_dpp[i][j];
}
template <class T>
MyMatrix<T>::~MyMatrix()
{
if(m_dpp != NULL)
{
delete [] m_dpp[0];
delete [] m_dpp;
}
}
template <class T>
MyMatrix<T> MyMatrix<T>::operator=(const MyMatrix& m)
{
int i, j;

if(this != &m)
{
if((m.m_rows == m_rows) && (m.m_columns == m_columns))
{
for(i = 0;i < m_rows;i++)
for(j = 0;j < m_columns;j++)
m_dpp[i][j] = m.m_dpp[i][j];
return *this;
}
if(m_dpp != NULL)
{
delete [] m_dpp[0];
delete [] m_dpp;
}

T* dp;
this->m_rows = m.m_rows;
this->m_columns = m.m_columns;
dp = new T[m_rows*m_columns];
m_dpp = new T*[m_rows];

for(i = 0;i < m_rows;i++)
m_dpp[i] = dp+(i * m_columns);
for(i = 0;i < m_rows;i++)
for(j = 0;j < m_columns;j++)
m_dpp[i][j] = m.m_dpp[i][j];
}
return *this;
}
template <class T>
MyMatrix<T> MyMatrix<T>::operator+(const MyMatrix& m2) const
{
int i, j;

if((m2.m_rows != m_rows) || (m2.m_columns != m_columns))
{
cout<<"Error, different rows and/or columns.\n"
<<"Press enter to exit the program."<<flush;
cin.get();
cin.get();
exit(1);
}
MyMatrix sum(m2.m_rows,m2.m_columns);
for(i = 0;i < sum.m_rows;i++)
for(j = 0;j < sum.m_columns;j++)
sum.m_dpp[i][j] = m_dpp[i][j] + m2.m_dpp[i][j];
return sum;
}
template <class T>
MyMatrix<T> MyMatrix<T>::operator-(const MyMatrix& m2) const
{
int i, j;

if((m2.m_rows != m_rows) || (m2.m_columns != m_columns))
{
cout<<"Error, different rows and/or columns.\n"
<<"Press enter to exit the program."<<flush;
cin.get();
cin.get();
exit(1);
}
MyMatrix sum(m2.m_rows,m2.m_columns);
for(i = 0;i < m2.m_rows;i++)
for(j = 0;j < m2.m_columns;j++)
sum.m_dpp[i][j] = m_dpp[i][j] - m2.m_dpp[i][j];
return sum;
}
template <class T>
T* MyMatrix<T>::operator[](int i)
{
if(i >= 0 && i < m_rows)
return m_dpp[i];
else
{
cout<<"Error, Out of Range. Press enter to exit the program."<<flush;
cin.get();
cin.get();
exit(1);
}
}
template <class T>
T* MyMatrix<T>::operator[](int i) const
{
if(i >= 0 && i < m_rows)
return m_dpp[i];
else
{
cout<<"Error, Out of Range. Press enter to exit the program."<<flush;
cin.get();
cin.get();
exit(1);
}
}
template <class T>
{
int i, j;
int rows, columns;

if(is == cin)
{
cout<<"Enter the number of rows: "<<flush;
cin>>rows;
cout<<"Enter the number of columns: "<<flush;
cin>>columns;

if((rows == m_rows) && (columns == m_columns))
{
for(i = 0;i < m_rows;i++)
{
for(j = 0;j < m_columns;j++)
{
cout<<"m["<<i<<"]"<<"["<<j<<"] = "<<flush;
cin>>m_dpp[i][j];
}
}
}
else
{
if(m_dpp != NULL)
{
delete [] m_dpp[0];
delete [] m_dpp;
}

m_rows = rows;
m_columns = columns;

T *dp;
dp = new T[m_rows*m_columns];
m_dpp = new T*[m_rows];

for(i = 0;i < m_rows;i++)
m_dpp[i] = dp + (i * m_columns);
for(i = 0;i < m_rows;i++)
{
for(j = 0;j < m_columns;j++)
{
cout<<"m["<<i<<"]"<<"["<<j<<"] = "<<flush;
cin>>m_dpp[i][j];
}
}
}
}
else
{
is>>m_rows;
is>>m_columns;

if(m_dpp != NULL)
{
delete [] m_dpp[0];
delete [] m_dpp;
}

T *dp;
dp = new T[m_rows*m_columns];
m_dpp = new T*[m_rows];

for(i = 0;i < m_rows;i++)
m_dpp[i] = dp + (i * m_columns);
for(i = 0;i < m_rows;i++)
{
for(j = 0;j < m_columns;j++)
is>>m_dpp[i][j];
}
}
}
template <class T>
void MyMatrix::Write(ostream& os) const
{
int i, j;

if(os == cout)
{
if((m_rows == 0) || (m_columns == 0))
cout<<"The matrix is empty.\n";

for(i = 0;i < m_rows;i++)
{
if(i > 0)
cout<<"\n\n";

for(j = 0;j < m_columns;j++)
{
cout<<m_dpp[i][j]<<" ";
}
}
}
else
{
for(i = 0;i < m_rows;i++)
{
for(j = 0;j < m_columns;j++)
{
os<<m_dpp[i][j]<<"\n";
}
}
}
}
template <class T>
istream& operator>>(istream& is, MyMatrix<T>& m)
{
return is;
}
template <class T>
ostream& operator<<(ostream& os, const MyMatrix<T>& m)
{
m.Write(os);
return os;
}

```

## Main.cpp

```#include <iostream>
#include <string>
#include <cmath>
using namespace std;

template <class T>
class MyMatrix
{
public:
MyMatrix();
MyMatrix(const MyMatrix<T>& m);
MyMatrix(int rows, int columns);
~MyMatrix();
MyMatrix operator+(const MyMatrix<T>& m2) const;
MyMatrix operator-(const MyMatrix<T>& m2) const;
MyMatrix operator=(const MyMatrix<T>& m);
T* operator[](int i);
T* operator[](int i) const;
T getDeterminant(MyMatrix<T>& m);
void Write(ostream& os) const;
private:
T **m_dpp;
int m_rows;
int m_columns;
};
template <class T>
istream& operator>>(istream& is, MyMatrix<T>& m);
template <class T>
ostream& operator<<(ostream& os, const MyMatrix<T>& m);
void main()
{

MyMatrix<int>m1;
MyMatrix<double>m2;
MyMatrix<float>m3;
m1.getDeterminant(m1);

cout<<"Before entering data in to MyMatrix<int>m1.\n"<<flush;
cin>>m1;
cout<<"\nPrinting out m1.\n"<<flush;
cout<<m1;
MyMatrix<int>m4(m1);
cout<<"\nAfter m4(m1).\n"<<flush;
cout<<m4;
cout<<"\nBefore entering data in to MyMatrix<double>m2.\n"<<flush;
cin>>m2;
cout<<"\nPrinting out m2.\n"<<flush;
cout<<m2;
cout<<"\nBefore entering data in to MyMatrix<float>m3.\n"<<flush;
cin>>m3;
cout<<"\nPrinting out m3.\n"<<flush;
cout<<m3;
MyMatrix<float>m6 = m3;
cout<<"\nAfter m6 = m3.\n"<<flush;
cout<<m6;
cout<<"\nEnd of program reached.\n"<<flush;
cin.get();
}

template <class T>
T MyMatrix<T>::getDeterminant(MyMatrix<T>& m)
{
int r, c;
r = m.m_rows;
c = m.m_columns;

T determinant/* = 0.0*/;

if(r == c)
{
if(r < 1)
{
cout<<"Less than one row and/or column";
exit(1);
}
else if(r == 1)
{
return m[0][0];
}
else if(r == 2)
{
//cout<<"The determinant is: "<<((m[0][0]*m[1][1]) - (m[0][1]*m[1][0]));
determinant = ((m[0][0]*m[1][1]) - (m[1][0]*m[0][1]));
return determinant;
}
else
{
for(int columns = 0; columns < m.m_columns; columns++)
{
MyMatrix m2((m.m_rows-1),(m.m_columns-1));

for(int subRows = 1; subRows < m.m_rows; subRows++)
{
int subColumns = 0;

for(int i = 0; i < m.m_columns; i++)
{
if(i != columns)
{
m2[(subRows-1)][subColumns] = m[subRows][i];
subColumns++;
}
}
}
determinant = determinant + ((m[0][columns])*(pow(float(-1),float(columns)))*(m2.getDeterminant(m2)));
}
}
return determinant;
}
else
{
cout<<"Error, the matrix is uneven, cannot determine the matrix, exiting program.";
exit(1);
}
}
template <class T>
MyMatrix<T>::MyMatrix()
{
m_rows = 0;
m_columns = 0;
m_dpp = NULL;
}
template <class T>
MyMatrix<T>::MyMatrix(int rows, int columns)
{
int i, j;
T *dp;

this->m_rows = rows;
this->m_columns = columns;
dp = new T[m_rows*m_columns];
m_dpp = new T*[m_rows];

for(i = 0;i < m_rows;i++)
m_dpp[i] = dp+(i * m_columns);
for(i = 0;i < m_rows;i++)
for(j = 0;j < m_columns;j++)
m_dpp[i][j] = 0;
}
template <class T>
MyMatrix<T>::MyMatrix(const MyMatrix<T>& m)
{
int i, j;
T *dp;

this->m_rows = m.m_rows;
this->m_columns = m.m_columns;
dp = new T[m_rows*m_columns];
m_dpp = new T*[m_rows];

for(i = 0;i < m_rows;i++)
m_dpp[i] = dp+(i * m_columns);
for(i = 0;i < m_rows;i++)
for(j = 0;j < m_columns;j++)
m_dpp[i][j] = m.m_dpp[i][j];
}
template <class T>
MyMatrix<T>::~MyMatrix()
{
if(m_dpp != NULL)
{
delete [] m_dpp[0];
delete [] m_dpp;
}
}
template <class T>
MyMatrix<T> MyMatrix<T>::operator=(const MyMatrix<T>& m)
{
int i, j;

if(this != &m)
{
if((m.m_rows == m_rows) && (m.m_columns == m_columns))
{
for(i = 0;i < m_rows;i++)
for(j = 0;j < m_columns;j++)
m_dpp[i][j] = m.m_dpp[i][j];
return *this;
}
if(m_dpp != NULL)
{
delete [] m_dpp[0];
delete [] m_dpp;
}

T* dp;
this->m_rows = m.m_rows;
this->m_columns = m.m_columns;
dp = new T[m_rows*m_columns];
m_dpp = new T*[m_rows];

for(i = 0;i < m_rows;i++)
m_dpp[i] = dp+(i * m_columns);
for(i = 0;i < m_rows;i++)
for(j = 0;j < m_columns;j++)
m_dpp[i][j] = m.m_dpp[i][j];
}
return *this;
}
template <class T>
MyMatrix<T> MyMatrix<T>::operator+(const MyMatrix<T>& m2) const
{
int i, j;

if((m2.m_rows != m_rows) || (m2.m_columns != m_columns))
{
cout<<"Error, different rows and/or columns.\n"
<<"Press enter to exit the program."<<flush;
cin.get();
cin.get();
exit(1);
}
MyMatrix sum(m2.m_rows,m2.m_columns);
for(i = 0;i < sum.m_rows;i++)
for(j = 0;j < sum.m_columns;j++)
sum.m_dpp[i][j] = m_dpp[i][j] + m2.m_dpp[i][j];
return sum;
}
template <class T>
MyMatrix<T> MyMatrix<T>::operator-(const MyMatrix<T>& m2) const
{
int i, j;

if((m2.m_rows != m_rows) || (m2.m_columns != m_columns))
{
cout<<"Error, different rows and/or columns.\n"
<<"Press enter to exit the program."<<flush;
cin.get();
cin.get();
exit(1);
}
MyMatrix difference(m2.m_rows,m2.m_columns);
for(i = 0;i < m2.m_rows;i++)
for(j = 0;j < m2.m_columns;j++)
difference.m_dpp[i][j] = m_dpp[i][j] - m2.m_dpp[i][j];
return difference;
}
template <class T>
T* MyMatrix<T>::operator[](int i)
{
if(i >= 0 && i < m_rows)
return m_dpp[i];
else
{
cout<<"Error, Out of Range. Press enter to exit the program."<<flush;
cin.get();
cin.get();
exit(1);
}
}
template <class T>
T* MyMatrix<T>::operator[](int i) const
{
if(i >= 0 && i < m_rows)
return m_dpp[i];
else
{
cout<<"Error, Out of Range. Press enter to exit the program."<<flush;
cin.get();
cin.get();
exit(1);
}
}
template <class T>
{
int i, j;
int rows, columns;

if(is == cin)
{
cout<<"Enter the number of rows: "<<flush;
cin>>rows;
cout<<"Enter the number of columns: "<<flush;
cin>>columns;

if((rows == m_rows) && (columns == m_columns))
{
for(i = 0;i < m_rows;i++)
{
for(j = 0;j < m_columns;j++)
{
cout<<"m["<<i<<"]"<<"["<<j<<"] = "<<flush;
cin>>m_dpp[i][j];
}
}
}
else
{
if(m_dpp != NULL)
{
delete [] m_dpp[0];
delete [] m_dpp;
}

m_rows = rows;
m_columns = columns;

T *dp;
dp = new T[m_rows*m_columns];
m_dpp = new T*[m_rows];

for(i = 0;i < m_rows;i++)
m_dpp[i] = dp + (i * m_columns);
for(i = 0;i < m_rows;i++)
{
for(j = 0;j < m_columns;j++)
{
cout<<"m["<<i<<"]"<<"["<<j<<"] = "<<flush;
cin>>m_dpp[i][j];
}
}
}
}
else
{
is>>m_rows;
is>>m_columns;

if(m_dpp != NULL)
{
delete [] m_dpp[0];
delete [] m_dpp;
}

T *dp;
dp = new T[m_rows*m_columns];
m_dpp = new T*[m_rows];

for(i = 0;i < m_rows;i++)
m_dpp[i] = dp + (i * m_columns);
for(i = 0;i < m_rows;i++)
{
for(j = 0;j < m_columns;j++)
is>>m_dpp[i][j];
}
}
}
template <class T>
void MyMatrix<T>::Write(ostream& os) const
{
int i, j;

if(os == cout)
{
if((m_rows == 0) || (m_columns == 0))
cout<<"The matrix is empty.\n";

for(i = 0;i < m_rows;i++)
{
if(i > 0)
cout<<"\n\n";

for(j = 0;j < m_columns;j++)
{
cout<<m_dpp[i][j]<<" ";
}
cout<<"\n";
}
}
else
{
for(i = 0;i < m_rows;i++)
{
for(j = 0;j < m_columns;j++)
{
os<<m_dpp[i][j]<<"\n";
}
}
}
}
template <class T>
istream& operator>>(istream& is, MyMatrix<T>& m)
{