Hey everyone!

I have been trying to implement a Matrix class that contains the operations required frequently when facing problems of that domain.

So here it is : Link

I would like to invite everyone to use this for their convenience.

The implementation is to best of my knowledge but I am sure it's not perfect or complete. So if you can think of any improvements or additions please comment or DM or add a pull request!

I also intend to add templates regarding other topics as well. Please suggest me a few topics to work on.

Thank You! :)

EDIT1 : Hey everyone! Sorry I was unavailable for a couple of months and was not able to include the feed-backs I received from you guys! I will start working on them ASAP.

EDIT2 : Hey! I have made quite a few changes and added more operators & functions. Please checkout! :D

PS: Add watching to the repository to find out latest updates. Also I'll be adding other templates as well! Star the repository if you find it helpful! Thanks :)

I think, method to calculate determinant for square matrices can be useful.

Will work on that. Thanks! :)

Nice work bro

Thanks bro! :D

In your template, all operations are being computed modulo $$$mod$$$, but unary $$$-$$$ is not. So, that will be an issue.

Updated! Thanks :D

For large matrices this is fine, but for small (2x2 for example) matrices the cost of allocating and deallocating memory on the heap would be significant. I usually use

`template<int N, int M> struct Matrix { std::array<std::array<int, M>, N> A; }`

, or even`template<int N, int M> struct Matrix : std::array<std::array<int, M>, N> { }`

(the latter way has the advantage of having`operator ==`

and`operator []`

implemented).One of the most useful and well written templates I have seen. mridul1809

Thanks! :D

Better overload the assignment operations, i.e.

`+=`

,`-=`

,`*=`

and`^=`

, and implement them without creating a new matrix in order to save time and memory. And what about other operations like`transpose`

?Hey! I have added the suggested functionalities! Please checkout :D

Great work bro.

Thanks bro! :D

How about determinant and inverse matrix?

Will work on that! Thanks for suggestion :D

Because of using vector, you can also use

`swap(this->A, C.A);`

(which is constant complexity) instead of`this->A = C.A`

There is a trick for such matrix multiplication that you should use last

`for-loop`

for last dimention, in your case, swapping`j-loop`

with`k-loop`

is friendly cache and work fasterIn matrix multiplication, you should reduce the amount of modulo you use