Implementing a 3D Matrix in C++ using Nested std::vector - c++

Question

I have a 3D Matrix with the MxNxL elements. Both M and N are known at the compile time. Whereas, L is variable and depends on user's input. But it will be provided at the beginning of the program and will never change during the life time of the program. I want to implement this Matrix in C++11 and I want to give the user the flexibility to rotate the 3D Matrix along both the the 1st and 2nd dimension of the matrix.
I would like to know what is the best and most efficient design option to implement this Matrix?
I have seen the below solution which uses std::vector. With std::vector the user can rotate any dimension using std::rotate. The solution is taken from this thread. However, vsoftco mentions that it is not good to use nested vector but rather make it linear. But since I have the requirement of rotating across dimension, having linear array will make the processing hard.
#include <vector>
#define M_SIZE 360
#define N_SIZE 180
template<typename T>
using vec = std::vector<T>;
int main()
{
uint16_t L;
std::cin << L;
vec<vec<vec<double>>> v{M_SIZE, vec<vec<double>>{N_SIZE, vec<double>{L}}};
}
Again, using dynamic c array is a possible solution but std::rotate would only work on the last dimension of the 3D Matrix.
Note: I would prefer to do this without relying on a third party library.

Answer 1

I don't know if this will help you to achieve what you are after but this is a Matrix class that I have started to build using modern C++ features; such as variadic templates. The Matrix Class is self contained into a single header file.
#ifndef MATRIX_H
#define MATRIX_H
#include <cstddef> // std::size_t
#include <numeric> // std::accumulate
#include <vector>
namespace /*Your namespace name here*/ {
template<typename Type, std::size_t... Dims>
class Matrix {
public:
static const std::size_t numDims_ = sizeof...(Dims);
private:
std::size_t numElements_;
std::vector<Type> elements_;
std::vector<std::size_t> strides_;
public:
Matrix() noexcept;
template<typename... Args>
Matrix(Args&&... args) noexcept;
const Type& operator[](std::size_t idx) const;
std::size_t numElements() const { return elements_.size(); }
const std::vector<std::size_t>& strides() const { return strides_; }
const std::vector<Type>& elements() const { return elements_; }
};
template<typename Type, std::size_t... Dims>
Matrix<Type, Dims...>::Matrix() noexcept :
strides_({ Dims... }) {
using std::begin;
using std::end;
auto mult = std::accumulate(begin(strides_), end(strides_), 1, std::multiplies<>());
numElements_ = mult;
elements_.resize(numElements_);
}
template<typename Type, std::size_t... Dims>
template<typename... Args>
Matrix<Type, Dims...>::Matrix(Args&&... args) noexcept :
elements_({ args... }),
strides_({ Dims... }) {
numElements_ = elements_.size();
}
template<typename T, std::size_t... d>
const T& Matrix<T, d...>::operator[](std::size_t idx) const {
if (idx > numElements_)
throw std::runtime_error("Invalid index");
return elements_[idx];
}
} // Your namespace name here
#endif MATRIX_H
And a small sample program using it:
#include <iostream>
#include <exception>
#include "Matrix.h"
int main() {
try {
using /*your namespace name here*/;
Matrix<double, 2, 2, 2> mat( 1.0 ,1.1, 1.2, 1.3,
1.4, 1.5, 1.6, 1.7 );
// Print the elements from the use of getting the vector
for (auto& e : mat.elements()) {
std::cout << e << " ";
}
std::cout << '\n';
// Print the elements from the use of using operator[]
for ( std::size_t n = 0; n < mat.numElements(); n++ ) {
std::cout << mat[n] << " ";
}
std::cout << '\n';
// Print out the strides
std::cout << "Number of strides: " << mat.numDims_ << '\n';
for (auto& s : mat.strides()) {
std::cout << s << " ";
}
std::cout << '\n';
} catch ( std::exception& e ) {
std::cerr << e.what();
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
-Output-
1 1.1 1.2 1.3 1.4 1.5 1.6 1.7
1 1.1 1.2 1.3 1.4 1.5 1.6 1.7
Number of strides: 3
2 2 2
This class is far from complete as it is only just the containing shell of any arbitrary Dimensional Size of Any MxNx...Zx... Matrix. In the template argument list it expects a single Type: int, float, char, user defined etc. The variadic arguments for the tempale arguments after the Type determines how many Dimensions this matrix has, and the dimensional size of each dimension. Examples:
Matrix<type,1> = a 1 matrix which in essence would be a scalar
Matrix<type,1,2> = a 1x2 matrix and would be considered a vector
Matrix<type,3,1> = a 3x1 matrix and would be considered a vector
Matrix<type,2,2> = a 2x2 matrix
Matrix<type,3,4> = a 3x4 matrix
Matrix<type,3,3,3> = a 3x3x3 Matrix (3D-Matrix) and has 27 elements
Matrix<type,3,4,5,3,2> = a 3x4x5x3x2 (5D - Matrix) and has 360 elements
// The number of elements will always equal the product of all of the strides.
// When creating an arbitrary matrix size; careful consideration needs to be taken
// when it comes to how many dimensions and the size of that dimension. Even lower
// dimensional matrices can explode in the amount of elements...
Matrix<type, 128, 356, 242> = a 128x356x242 (3D - Matrix) but has 11,027,456 elements
// It is the Matrix's user defined variadic constructor that the number of arguments
// in the parameter list that has to equal the total amount of elements defined by
// the product of all of its strides.
When working with higher dimensional matrices it is hard to visualize them, but they can easily be managed with the use of the strides vector. We can use these for proper indexing.
The challenging aspect of this design approach is being able to implement the actual arithmetic-computational operators. For this if we have two different matrices that have different strides, they will be treated as different types... and this is just with simple matrix arithmetic; when it comes to matrix multiplication things even get harder because the edges of Matrix A and Matrix B have to be of the same size. Ex: 4x2 * 2x3 would give a 4x3 Matrix. And this is only a 2D matrix issue, when getting into 3D, 4D, ... ND matrices the notation even gets harder. However this template approach does allow the code to be more generic and readable to be self contained into a single class as opposed to having many different matrix classes for various matrix sizes...