Matrix functions for C++

Build and run

make
./program

Quick start

#include "lib/matrix/matrix.hpp"
#include "lib/matrix/matrix-double-value.hpp"

int main() {
	MatrixClass<MatrixDoubleValue>::srand(1234);

	auto *A = MatrixClass<MatrixDoubleValue>::create_matrix(MatrixType::NORMAL, 2, 2);
	A->set(0, 0, MatrixDoubleValue(1.0));
	A->set(0, 1, MatrixDoubleValue(2.0));
	A->set(1, 0, MatrixDoubleValue(3.0));
	A->set(1, 1, MatrixDoubleValue(4.0));

	A->print();

	auto det = A->determinent();
	det.print();
	printf("\n");

	A->inverse()->print()->destroy();
	A->destroy();
}

Create and fill

#include "lib/matrix/matrix.hpp"
#include "lib/matrix/matrix-int-value.hpp"

// Empty matrix then set values
auto *M = MatrixClass<MatrixIntValue>::create_matrix(MatrixType::NORMAL, 3, 3);
for (size_t i = 0; i < 3; ++i)
  for (size_t j = 0; j < 3; ++j)
	M->set(i, j, MatrixIntValue((int)(i*3 + j)));

// Matrix filled with a constant
auto *K = MatrixClass<MatrixIntValue>::create_matrix_with(MatrixType::NORMAL, 3, 3, MatrixIntValue(7));

// Random matrix
MatrixClass<MatrixIntValue>::srand(42);
auto *R = MatrixClass<MatrixIntValue>::create_matrix_random(MatrixType::NORMAL, 3, 3);

M->print();
K->print();
R->print();

M->destroy();
K->destroy();
R->destroy();

Basic operations

#include "lib/matrix/matrix.hpp"
#include "lib/matrix/matrix-double-value.hpp"

auto *A = MatrixClass<MatrixDoubleValue>::create_matrix_with(MatrixType::NORMAL, 2, 2, MatrixDoubleValue(2.0));
auto *B = MatrixClass<MatrixDoubleValue>::create_matrix_with(MatrixType::NORMAL, 2, 2, MatrixDoubleValue(3.0));

// Element-wise operations
A->operator+(B)->print()->destroy();
A->operator-(B)->print()->destroy();
A->operator*(B)->print()->destroy();
A->operator/(B)->print()->destroy();

// With a scalar value (use the value type)
A->operator+(MatrixDoubleValue(1.5))->print()->destroy();
A->operator*(MatrixDoubleValue(10.0))->print()->destroy();

// Transpose and inverse
A->transpose()->print()->destroy();
A->inverse()->print()->destroy();

// Determinant and trace
auto det = A->determinent();
det.print();
printf("\n");

auto tr = A->trace();
tr.print();
printf("\n");

// Matrix multiplication (dot)
auto *C = MatrixClass<MatrixDoubleValue>::matrix_multiplication(A, B);
C->print();

A->destroy();
B->destroy();
C->destroy();

Map and reduce

#include "lib/matrix/matrix.hpp"
#include "lib/matrix/matrix-double-value.hpp"

auto *M = MatrixClass<MatrixDoubleValue>::create_matrix_random(MatrixType::NORMAL, 2, 3);

// Map: add 1.0 to every element
M->map(MatrixType::NORMAL, [](size_t i, size_t j, MatrixDoubleValue v) {
	return MatrixDoubleValue(v.data + 1.0);
}, true /* inplace */)->print();

// Reduce: sum of all elements (Reducer returns float)
float sum = M->reduce(MatrixType::NORMAL, [](float acc, size_t i, size_t j, MatrixDoubleValue v) {
	return acc + (float)v.data;
}, 0.0f);
printf("sum=%f\n", sum);

M->destroy();

Convolution (1D/2D)

#include "lib/matrix/matrix.hpp"
#include "lib/math/math.hpp"
#include "lib/matrix/matrix-double-value.hpp"

// 2D convolution example
auto *img = MatrixClass<MatrixDoubleValue>::create_matrix(MatrixType::NORMAL, 3, 3);
img->set(0,0, {1}); img->set(0,1, {2}); img->set(0,2, {3});
img->set(1,0, {4}); img->set(1,1, {5}); img->set(1,2, {6});
img->set(2,0, {7}); img->set(2,1, {8}); img->set(2,2, {9});

auto *kernel = MatrixClass<MatrixDoubleValue>::create_matrix(MatrixType::NORMAL, 3, 3);
kernel->set(0,0, {0}); kernel->set(0,1, {-1}); kernel->set(0,2, {0});
kernel->set(1,0, {-1}); kernel->set(1,1, {5}); kernel->set(1,2, {-1});
kernel->set(2,0, {0}); kernel->set(2,1, {-1}); kernel->set(2,2, {0});

auto *out = matrix_convolution<MatrixDoubleValue>(img, kernel);
out->print();

img->destroy();
kernel->destroy();
out->destroy();

Memory management

auto *M = MatrixClass<MatrixDoubleValue>::create_matrix_random(MatrixType::NORMAL, 2, 2);
// ... use M ...
M->destroy();