#include #include #include using namespace std; /* Multidimensional matrix library with compile time optimizations using OOP. This is the barebones of a library used to make calculations using multidimensional matrices. The implemented operations are: -operator* (matrix multiplication) -operator+= (elementwise addition) Usage: You need to specify 3 arguments at compile time to create a matrix: 1-The data type of its elements 2-The width of the matrix 3-The height of the matrix Note: Here there are two special kinds of matrix, a 1x1 matrix, called singleton (represented with the class S), and a matrix that contain singletons, called base matrices(the types of these start with a "B"). Matrices that are not matrices of matrices should be base matrices instead of directly making a matrix with certain data type. This is because the way multiplication and printing is handled. Examples: -To create a 3x4(width x height) base matrix of integers: Mat, 3,4> myMat; or BMat myMat; -To create a 3x3 matrix of 2x2 base matrices of doubles: Mat, 2,2>, 3,3> myMat; or Mat, 3,3> myMat; */ template class Mat; // Singleton(1x1 matrix) template using S = Mat; // Types of general matrices template using SqMat = Mat; template using ColVec = Mat; template using RowVec = Mat; // Helper base matrix classes template using BMat = Mat, w, h>; template using BSqMat = SqMat, s>; template using BColVec = ColVec, h>; template using BRowVec = RowVec, w>; // This class is used to get recursively // at compile time the type of a // matrix multiplication result. template struct _MatDot { using type = Mat< typename _MatDot::type, T::width, Q::height>; }; // First argument has preference in type // in singletons. template struct _MatDot, S> { using type = S; }; // Getting rid of typename and ::type template using MatDot = typename _MatDot::type; // Main matrix class template class Mat { static constexpr const size_t datalen = w*h; // Data is stored in row-first mode // i.e. 1st row 3rd column // would always be data[2]. std::array data; public: using dtype = T; static constexpr size_t width = w; static constexpr size_t height = h; Mat(); Mat(const T&); Mat(const std::array&); T& get(size_t, size_t); template MatDot, Mat> operator*(Mat mat); template Mat& operator+=(Mat); template friend ostream& operator<<(ostream&, Mat); }; template Mat::Mat() : data{} {} template Mat::Mat(const T& val) : data{} { for(auto& el : data) el = val; } template Mat::Mat(const std::array& val) : data{val} {} template T& Mat::get(size_t x, size_t y) { if(0 <= x && x < w && 0 <= y && y < h) return data[y * w + x]; throw runtime_error("Index out range"); } template template MatDot, Mat> Mat::operator*(Mat mat) { MatDot, Mat> res; for(size_t x = 0; x < w; ++x) for(size_t y = 0; y < h2; ++y) for(size_t k = 0; k < h; ++k) res.get(x, y) += this->get(x, k) * mat.get(k, y); return res; } template template Mat& Mat::operator+=(Mat mat) { for(size_t x = 0; x < w; ++x) for(size_t y = 0; y < h; ++y) get(x, y) += mat.get(x, y); return *this; } template ostream& operator<<(ostream& os, Mat mat) { os << '{'; for(size_t y = 0; y < h; ++y) { os << '{'; for(size_t x = 0; x < w; ++x) { os << mat.get(x,y); if(x != w-1) os << ','; } os << '}'; if(y != h-1) os << ','; } os << '}'; return os; } // Singleton specialization template<> template class Mat { static constexpr size_t datalen = 1; T data; public: using dtype = T; static constexpr size_t width = 1; static constexpr size_t height = 1; Mat(); Mat(const T&); Mat(const std::array&); T& get(size_t, size_t); template S operator*(S mat); template S& operator+=(S); template friend ostream& operator<<(ostream&, S); }; template Mat::Mat() : data{} {} template Mat::Mat(const T& val) : data{val} {} template Mat::Mat(const std::array& val) : data{val[0]} {} template T& Mat::get(size_t x, size_t y) { if(!x && !y) return data; throw runtime_error("Index out range"); } template template S Mat::operator*(S mat) { return data * mat.get(0,0); } template template S& Mat::operator+=(S mat) { data += mat.get(0,0); return *this; } template ostream& operator<<(ostream& os, S mat) { os << mat.data; return os; } int main() { // Create a base column vector BColVec v{{ 1,2,3 }}; // Create a base 3x4 matrix BMat M{{ 1,2,3,4,5,6,7,8,9,10,11,12 }}; // Matrix multiplication inversely goes // from left to right. cout << M << '.' << v << '=' << v * M << endl << endl; // Show differences between // rows and columns. cout << ColVec, 2>() << endl; cout << RowVec, 2>() << endl << endl; // Multiplication of multidimensional // arrays with different order. cout << ColVec, 2>() * RowVec, 2>() << endl; cout << RowVec, 2>() * ColVec, 2>() << endl; // Singletons are formatted correctly // even when they are nested. cout << S>>>() << endl; // To initialize nested singletons // with more than two levels // you need two less curly braces // than the nest level. cout << S>>({1}) << endl; cout << S>>>({{2}}) << endl; return 0; }

OOP multidimensional matrix library