Gaussian Elimination: Inverse 4x4 Matrix - c++

Question

Question
The following will give me an identity matrix for the variable "cur", and will attempt to give me the inverse for the variable "tmp", but will fail. Can anyone tell me what I did wrong?
P.S. The matrix is column major.
Matrix Input
1 | 0 | 0 | 0
0 | -4.37114e-08 | 1 | 0
0 | -1 | -4.37114e-08 | 0
0 | 0 | 0 | 1
Matrix Output
1 | 0 | 0 | 0
0 | 0 | 0 | 0
0 | 1 | 0 | 0
0 | 0 | 0 | 1
Desired Output
1 | 0 | 0 | 0
0 | -4.3711399999999916e-8 | -0.9999999999999981 | 0
0 | 0.999999999999998 | -4.3711399999999916e-8 | 0
0 | 0 | 0 | 1
#include <iostream>
template <typename T>
class Matrix
{
public:
T matrix[4][4];
Matrix(T matrix[4][4])
: matrix()
{
for (unsigned int y = 0; y < 4; ++y)
{
for (unsigned int x = 0; x < 4; ++x)
{
this->matrix[y][x] = matrix[y][x];
}
}
}
Matrix()
: matrix()
{
T zero = static_cast<T>(0);
T one = static_cast<T>(1);
matrix[0][0] = one;
matrix[1][0] = zero;
matrix[2][0] = zero;
matrix[3][0] = zero;
matrix[0][1] = zero;
matrix[1][1] = one;
matrix[2][1] = zero;
matrix[3][1] = zero;
matrix[0][2] = zero;
matrix[1][2] = zero;
matrix[2][2] = one;
matrix[3][2] = zero;
matrix[0][3] = zero;
matrix[1][3] = zero;
matrix[2][3] = zero;
matrix[3][3] = one;
}
Matrix<T> GetInverse() const
{
T zero = static_cast<T>(0);
T one = static_cast<T>(1);
Matrix<T> tmp;
Matrix<T> cur;
for (unsigned int y = 0; y < 4; ++y)
{
for (unsigned int x = 0; x < 4; ++x)
{
cur.matrix[y][x] = matrix[y][x];
}
}
cur.Print();
for (unsigned int x = 0; x < 4; x++)
{
if (cur.matrix[x][x] != zero)
{
T denominator = cur.matrix[x][x];
for (unsigned int a = x; a < 4; ++a)
{
cur.matrix[x][a] = cur.matrix[x][a] / denominator;
}
for (unsigned int a = 0; a < 4; ++a)
{
tmp.matrix[x][a] = tmp.matrix[x][a] / denominator;
}
}
for (unsigned int y = 0; y < 4; ++y)
{
if (y != x && cur.matrix[y][x] != 0)
{
T difference = cur.matrix[y][x];
for (unsigned int a = x; a < 4; ++a)
{
cur.matrix[y][a] = (cur.matrix[y][a] - difference) * cur.matrix[x][a];
}
for (unsigned int a = 0; a < 4; ++a)
{
tmp.matrix[y][a] = (tmp.matrix[y][a] - difference) * tmp.matrix[x][a];
}
}
}
}
cur.Print();
tmp.Print();
return tmp;
}
void Print()
{
for (unsigned int y = 0; y < 4; ++y)
{
for (unsigned int x = 0; x < 4; ++x)
{
std::cout << matrix[y][x];
if (x < 3)
std::cout << " | ";
}
std::cout << std::endl;
}
std::cout << std::endl;
}
}
int main()
{
float matrix[4][4];
matrix[0][0] = 1.0f;
matrix[0][1] = 0.0f;
matrix[0][2] = 0.0f;
matrix[0][3] = 0.0f;
matrix[1][0] = 0.0f;
matrix[1][1] = -4.37114e-08;
matrix[1][2] = 1.0f;
matrix[1][3] = 0.0f;
matrix[2][0] = 0.0f;
matrix[2][1] = -1.0f;
matrix[2][2] = -4.37114e-08;
matrix[2][3] = 0.0f;
matrix[3][0] = 0.0f;
matrix[3][1] = 0.0f;
matrix[3][2] = 0.0f;
matrix[3][3] = 1.0f;
Matrix<float> inverseMatrix(matrix);
inverseMatrix.GetInverse();
return 0;
}

Answer 1

First of all, your class is not a proper class. Before you go trying to figure out algorithmic or operational errors, you can turn it into far more sensible code that will be much easier to debug.
Right now, your Matrix class doesn't define an object really, but just a set of operations to be used on 2D arrays. A good object has attributes and data, and then special functions to work from that data. I would read a bit of an introduction at https://en.wikipedia.org/wiki/Object-oriented_programming
What you want is something like
// Matrix.h
template <typename T>
class Matrix {
public:
// exactly how you choose to construct the object is up to you
// i.e. if you want to pass a 2d array as a parameter or something
Matrix(T inputMatrix[4][4]) {
for (int column = 0; column < 4; ++column) {
for (int row = 0; row < 4; ++row) {
matrix[column][row] = inputMatrix[column][row];
}
}
}
Matrix reduce() {
// will return a new Matrix object
. . .
}
Matrix inverse() {
// probably will end up calling reduce()
. . .
}
void print() {
. . .
}
// any other operations you want to do on matrices
private:
T matrix[4][4];
};
So that when you want do your operations, it is really easy and straightforward:
#include "Matrix.h"
int main() {
float matrix[4][4] = {
{ 1.0f, 0.0f, 0.0f, 0.0f },
{ 0.0f, -4.37114e-08, 1.0f, 0.0f },
{ 0.0f, -1.0f, -4.37114e-08, 0.0f },
{ 0.0f, 0.0f, 0.0f, 0.0f };
Matrix<float> A = Matrix<float>(matrix);
Matrix<float> B = A.inverse();
B.print();
return 0;
}