Blaze 3.9
Classes | Public Types | Public Member Functions | Static Public Attributes | Static Private Attributes | List of all members
blaze::DynamicMatrix< Type, SO, Alloc, Tag > Class Template Reference

Efficient implementation of a dynamic $ M \times N $ matrix. More...

#include <DynamicMatrix.h>

Inherits blaze::DenseMatrix< DynamicMatrix< Type, SO, Alloc, Tag >, SO >.

Classes

struct  Rebind
 Rebind mechanism to obtain a DynamicMatrix with different data/element type. More...
 
struct  Resize
 Resize mechanism to obtain a DynamicMatrix with different fixed dimensions. More...
 
struct  Uninitialized
 Definition of the nested auxiliary struct Uninitialized. More...
 

Public Types

using This = DynamicMatrix< Type, SO, Alloc, Tag >
 Type of this DynamicMatrix instance.
 
using BaseType = DenseMatrix< This, SO >
 Base type of this DynamicMatrix instance.
 
using ResultType = This
 Result type for expression template evaluations.
 
using OppositeType = DynamicMatrix< Type,!SO, Alloc, Tag >
 Result type with opposite storage order for expression template evaluations.
 
using TransposeType = DynamicMatrix< Type,!SO, Alloc, Tag >
 Transpose type for expression template evaluations.
 
using ElementType = Type
 Type of the matrix elements.
 
using SIMDType = SIMDTrait_t< ElementType >
 SIMD type of the matrix elements.
 
using AllocatorType = AlignedAllocator< Type >
 Allocator type of this DynamicMatrix instance.
 
using TagType = Tag
 Tag type of this DynamicMatrix instance.
 
using ReturnType = const Type &
 Return type for expression template evaluations.
 
using CompositeType = const This &
 Data type for composite expression templates.
 
using Reference = Type &
 Reference to a non-constant matrix value.
 
using ConstReference = const Type &
 Reference to a constant matrix value.
 
using Pointer = Type *
 Pointer to a non-constant matrix value.
 
using ConstPointer = const Type *
 Pointer to a constant matrix value.
 
using Iterator = DenseIterator< Type, align >
 Iterator over non-constant elements.
 
using ConstIterator = DenseIterator< const Type, align >
 Iterator over constant elements.
 
using MatrixType = DynamicMatrix< Type, SO, Alloc, Tag >
 Type of the matrix.
 

Public Member Functions

template<typename Other , size_t Rows, size_t Cols>
DynamicMatrix< Type, SO, Alloc, Tag > & operator= (const Other(&array)[Rows][Cols]) &
 Array assignment to all matrix elements. More...
 
template<typename Other , size_t Rows, size_t Cols>
DynamicMatrix< Type, SO, Alloc, Tag > & operator= (const std::array< std::array< Other, Cols >, Rows > &array) &
 Array assignment to all matrix elements. More...
 
template<typename MT , bool SO2>
DynamicMatrix< Type, SO, Alloc, Tag > & operator= (const Matrix< MT, SO2 > &rhs) &
 Assignment operator for different matrices. More...
 
template<typename MT , bool SO2>
DynamicMatrix< Type, SO, Alloc, Tag > & operator+= (const Matrix< MT, SO2 > &rhs) &
 Addition assignment operator for the addition of a matrix ( $ A+=B $). More...
 
template<typename MT , bool SO2>
DynamicMatrix< Type, SO, Alloc, Tag > & operator-= (const Matrix< MT, SO2 > &rhs) &
 Subtraction assignment operator for the subtraction of a matrix ( $ A-=B $). More...
 
template<typename MT , bool SO2>
DynamicMatrix< Type, SO, Alloc, Tag > & operator%= (const Matrix< MT, SO2 > &rhs) &
 Schur product assignment operator for the multiplication of a matrix ( $ A\circ=B $). More...
 
template<typename Other >
DynamicMatrix< Type, SO, Alloc, Tag > & scale (const Other &scalar)
 Scaling of the matrix by the scalar value scalar ( $ A=B*s $). More...
 
Destructor
 ~DynamicMatrix ()
 The destructor for DynamicMatrix.
 
Data access functions
Reference operator() (size_t i, size_t j) noexcept
 2D-access to the matrix elements. More...
 
ConstReference operator() (size_t i, size_t j) const noexcept
 2D-access to the matrix elements. More...
 
Reference at (size_t i, size_t j)
 Checked access to the matrix elements. More...
 
ConstReference at (size_t i, size_t j) const
 Checked access to the matrix elements. More...
 
Pointer data () noexcept
 Low-level data access to the matrix elements. More...
 
ConstPointer data () const noexcept
 Low-level data access to the matrix elements. More...
 
Pointer data (size_t i) noexcept
 Low-level data access to the matrix elements of row/column i. More...
 
ConstPointer data (size_t i) const noexcept
 Low-level data access to the matrix elements of row/column i. More...
 
Iterator begin (size_t i) noexcept
 Returns an iterator to the first element of row/column i. More...
 
ConstIterator begin (size_t i) const noexcept
 Returns an iterator to the first element of row/column i. More...
 
ConstIterator cbegin (size_t i) const noexcept
 Returns an iterator to the first element of row/column i. More...
 
Iterator end (size_t i) noexcept
 Returns an iterator just past the last element of row/column i. More...
 
ConstIterator end (size_t i) const noexcept
 Returns an iterator just past the last element of row/column i. More...
 
ConstIterator cend (size_t i) const noexcept
 Returns an iterator just past the last element of row/column i. More...
 
Assignment operators
DynamicMatrixoperator= (const Type &rhs) &
 Homogenous assignment to all matrix elements. More...
 
DynamicMatrixoperator= (initializer_list< initializer_list< Type > > list) &
 List assignment to all matrix elements. More...
 
template<typename Other , size_t Rows, size_t Cols>
DynamicMatrixoperator= (const Other(&array)[Rows][Cols]) &
 
template<typename Other , size_t Rows, size_t Cols>
DynamicMatrixoperator= (const std::array< std::array< Other, Cols >, Rows > &array) &
 
DynamicMatrixoperator= (const DynamicMatrix &rhs) &
 Copy assignment operator for DynamicMatrix. More...
 
DynamicMatrixoperator= (DynamicMatrix &&rhs) &noexcept
 
template<typename MT , bool SO2>
DynamicMatrixoperator= (const Matrix< MT, SO2 > &rhs) &
 
template<typename MT , bool SO2>
DynamicMatrixoperator+= (const Matrix< MT, SO2 > &rhs) &
 
template<typename MT , bool SO2>
DynamicMatrixoperator-= (const Matrix< MT, SO2 > &rhs) &
 
template<typename MT , bool SO2>
DynamicMatrixoperator%= (const Matrix< MT, SO2 > &rhs) &
 
Debugging functions
bool isIntact () const noexcept
 Returns whether the invariants of the dynamic matrix are intact. More...
 
Expression template evaluation functions
template<typename Other >
bool canAlias (const Other *alias) const noexcept
 Returns whether the matrix can alias with the given address alias. More...
 
template<typename Other >
bool isAliased (const Other *alias) const noexcept
 Returns whether the matrix is aliased with the given address alias. More...
 
bool isAligned () const noexcept
 Returns whether the matrix is properly aligned in memory. More...
 
bool canSMPAssign () const noexcept
 Returns whether the matrix can be used in SMP assignments. More...
 
BLAZE_ALWAYS_INLINE SIMDType load (size_t i, size_t j) const noexcept
 Load of a SIMD element of the matrix. More...
 
BLAZE_ALWAYS_INLINE SIMDType loada (size_t i, size_t j) const noexcept
 Aligned load of a SIMD element of the matrix. More...
 
BLAZE_ALWAYS_INLINE SIMDType loadu (size_t i, size_t j) const noexcept
 Unaligned load of a SIMD element of the matrix. More...
 
BLAZE_ALWAYS_INLINE void store (size_t i, size_t j, const SIMDType &value) noexcept
 Store of a SIMD element of the matrix. More...
 
BLAZE_ALWAYS_INLINE void storea (size_t i, size_t j, const SIMDType &value) noexcept
 Aligned store of a SIMD element of the matrix. More...
 
BLAZE_ALWAYS_INLINE void storeu (size_t i, size_t j, const SIMDType &value) noexcept
 Unaligned store of a SIMD element of the matrix. More...
 
BLAZE_ALWAYS_INLINE void stream (size_t i, size_t j, const SIMDType &value) noexcept
 Aligned, non-temporal store of a SIMD element of the matrix. More...
 
template<typename MT >
auto assign (const DenseMatrix< MT, SO > &rhs) -> DisableIf_t< VectorizedAssign_v< MT > >
 Default implementation of the assignment of a row-major dense matrix. More...
 
template<typename MT >
auto assign (const DenseMatrix< MT, SO > &rhs) -> EnableIf_t< VectorizedAssign_v< MT > >
 
template<typename MT >
void assign (const DenseMatrix< MT,!SO > &rhs)
 Default implementation of the assignment of a column-major dense matrix. More...
 
template<typename MT >
void assign (const SparseMatrix< MT, SO > &rhs)
 Default implementation of the assignment of a row-major sparse matrix. More...
 
template<typename MT >
void assign (const SparseMatrix< MT,!SO > &rhs)
 Default implementation of the assignment of a column-major sparse matrix. More...
 
template<typename MT >
auto addAssign (const DenseMatrix< MT, SO > &rhs) -> DisableIf_t< VectorizedAddAssign_v< MT > >
 Default implementation of the addition assignment of a row-major dense matrix. More...
 
template<typename MT >
auto addAssign (const DenseMatrix< MT, SO > &rhs) -> EnableIf_t< VectorizedAddAssign_v< MT > >
 
template<typename MT >
void addAssign (const DenseMatrix< MT,!SO > &rhs)
 Default implementation of the addition assignment of a column-major dense matrix. More...
 
template<typename MT >
void addAssign (const SparseMatrix< MT, SO > &rhs)
 Default implementation of the addition assignment of a row-major sparse matrix. More...
 
template<typename MT >
void addAssign (const SparseMatrix< MT,!SO > &rhs)
 Default implementation of the addition assignment of a column-major sparse matrix. More...
 
template<typename MT >
auto subAssign (const DenseMatrix< MT, SO > &rhs) -> DisableIf_t< VectorizedSubAssign_v< MT > >
 Default implementation of the subtraction assignment of a row-major dense matrix. More...
 
template<typename MT >
auto subAssign (const DenseMatrix< MT, SO > &rhs) -> EnableIf_t< VectorizedSubAssign_v< MT > >
 
template<typename MT >
void subAssign (const DenseMatrix< MT,!SO > &rhs)
 Default implementation of the subtraction assignment of a column-major dense matrix. More...
 
template<typename MT >
void subAssign (const SparseMatrix< MT, SO > &rhs)
 Default implementation of the subtraction assignment of a row-major sparse matrix. More...
 
template<typename MT >
void subAssign (const SparseMatrix< MT,!SO > &rhs)
 Default implementation of the subtraction assignment of a column-major sparse matrix. More...
 
template<typename MT >
auto schurAssign (const DenseMatrix< MT, SO > &rhs) -> DisableIf_t< VectorizedSchurAssign_v< MT > >
 Default implementation of the Schur product assignment of a row-major dense matrix. More...
 
template<typename MT >
auto schurAssign (const DenseMatrix< MT, SO > &rhs) -> EnableIf_t< VectorizedSchurAssign_v< MT > >
 
template<typename MT >
void schurAssign (const DenseMatrix< MT,!SO > &rhs)
 Default implementation of the Schur product assignment of a column-major dense matrix. More...
 
template<typename MT >
void schurAssign (const SparseMatrix< MT, SO > &rhs)
 Default implementation of the Schur product assignment of a row-major sparse matrix. More...
 
template<typename MT >
void schurAssign (const SparseMatrix< MT,!SO > &rhs)
 Default implementation of the Schur product assignment of a column-major sparse matrix. More...
 
Conversion operators
BLAZE_ALWAYS_INLINE constexpr DynamicMatrix< Type, SO, Alloc, Tag > & operator~ () noexcept
 CRTP-based conversion operation for non-constant matrices. More...
 
BLAZE_ALWAYS_INLINE constexpr const DynamicMatrix< Type, SO, Alloc, Tag > & operator~ () const noexcept
 CRTP-based conversion operation for constant matrices. More...
 
constexpr DynamicMatrix< Type, SO, Alloc, Tag > & operator* () noexcept
 CRTP-based conversion operation for non-constant matrices. More...
 
constexpr const DynamicMatrix< Type, SO, Alloc, Tag > & operator* () const noexcept
 CRTP-based conversion operation for constant matrices. More...
 

Static Public Attributes

static constexpr bool simdEnabled = IsVectorizable_v<Type>
 Compilation flag for SIMD optimization. More...
 
static constexpr bool smpAssignable = !IsSMPAssignable_v<Type>
 Compilation flag for SMP assignments. More...
 
static constexpr bool storageOrder
 Storage order of the matrix.
 

Private Attributes

Member variables
size_t m_
 The current number of rows of the matrix.
 
size_t n_
 The current number of columns of the matrix.
 
size_t nn_
 The alignment adjusted number of columns.
 
size_t capacity_
 The maximum capacity of the matrix.
 
Type *BLAZE_RESTRICT v_
 The dynamically allocated matrix elements. More...
 
BLAZE_NO_UNIQUE_ADDRESS Alloc alloc_
 The allocator of the matrix.
 

Static Private Attributes

static constexpr AlignmentFlag align = ( usePadding ? aligned : unaligned )
 Compilation switch for the choice of alignment.
 

Numeric functions

static constexpr size_t SIMDSIZE = SIMDTrait<ElementType>::size
 The number of elements packed within a single SIMD element.
 
DynamicMatrixtranspose ()
 In-place transpose of the matrix. More...
 
DynamicMatrixctranspose ()
 In-place conjugate transpose of the matrix. More...
 
template<typename Other >
DynamicMatrixscale (const Other &scalar)
 

Constructors

 DynamicMatrix (const Alloc &alloc=Alloc{}) noexcept
 The (default) constructor for DynamicMatrix. More...
 
 DynamicMatrix (size_t m, size_t n, const Alloc &alloc=Alloc{})
 Constructor for a matrix of size $ m \times n $. For built-in types no initialization is performed! More...
 
 DynamicMatrix (size_t m, size_t n, const Type &init, const Alloc &alloc=Alloc{})
 Constructor for a homogenous initialization of all $ m \times n $ matrix elements. More...
 
 DynamicMatrix (initializer_list< initializer_list< Type > > list, const Alloc &alloc=Alloc{})
 List initialization of all matrix elements. More...
 
template<typename Other >
 DynamicMatrix (size_t m, size_t n, const Other *array, const Alloc &alloc=Alloc{})
 Array initialization of all matrix elements. More...
 
template<typename Other , size_t Rows, size_t Cols>
 DynamicMatrix (const Other(&array)[Rows][Cols], const Alloc &alloc=Alloc{})
 Array initialization of all matrix elements. More...
 
template<typename Other , size_t Rows, size_t Cols>
 DynamicMatrix (const std::array< std::array< Other, Cols >, Rows > &array, const Alloc &alloc=Alloc{})
 Initialization of all matrix elements from the given std::array. More...
 
 DynamicMatrix (const DynamicMatrix &m)
 The copy constructor for DynamicMatrix. More...
 
 DynamicMatrix (DynamicMatrix &&m) noexcept
 The move constructor for DynamicMatrix. More...
 
template<typename MT , bool SO2>
 DynamicMatrix (const Matrix< MT, SO2 > &m)
 Conversion constructor from different matrices. More...
 
 DynamicMatrix (size_t m, size_t n, size_t nn, const Alloc &alloc, Uninitialized)
 Auxiliary constructor for DynamicMatrix. More...
 
 DynamicMatrix (size_t m, size_t n, size_t nn, size_t capa, const Alloc &alloc, Uninitialized)
 Auxiliary constructor for DynamicMatrix. More...
 

Utility functions

size_t rows () const noexcept
 Returns the current number of rows of the matrix. More...
 
size_t columns () const noexcept
 Returns the current number of columns of the matrix. More...
 
size_t spacing () const noexcept
 Returns the spacing between the beginning of two rows/columns. More...
 
size_t capacity () const noexcept
 Returns the maximum capacity of the matrix. More...
 
size_t capacity (size_t i) const noexcept
 Returns the current capacity of the specified row/column. More...
 
size_t nonZeros () const
 Returns the total number of non-zero elements in the matrix. More...
 
size_t nonZeros (size_t i) const
 Returns the number of non-zero elements in the specified row/column. More...
 
void reset ()
 Reset to the default initial values. More...
 
void reset (size_t i)
 Reset the specified row/column to the default initial values. More...
 
void clear ()
 Clearing the $ M \times N $ matrix. More...
 
void resize (size_t m, size_t n, bool preserve=true)
 Changing the size of the matrix. More...
 
void extend (size_t m, size_t n, bool preserve=true)
 Extending the size of the matrix. More...
 
void reserve (size_t elements)
 Setting the minimum capacity of the matrix. More...
 
void shrinkToFit ()
 Requesting the removal of unused capacity. More...
 
void swap (DynamicMatrix &m) noexcept
 Swapping the contents of two matrices. More...
 
size_t addPadding (size_t value) const noexcept
 Add the necessary amount of padding to the given value. More...
 

Detailed Description

template<typename Type, bool SO, typename Alloc, typename Tag>
class blaze::DynamicMatrix< Type, SO, Alloc, Tag >

Efficient implementation of a dynamic $ M \times N $ matrix.

The DynamicMatrix class template is the representation of an arbitrary sized matrix with $ M \times N $ dynamically allocated elements of arbitrary type. The type of the elements, the storage order, the type of the allocator, and the group tag of the matrix can be specified via the four template parameters:

namespace blaze {
template< typename Type, bool SO, typename Alloc, typename Tag >
} // namespace blaze
DynamicMatrix(const Alloc &alloc=Alloc{}) noexcept
The (default) constructor for DynamicMatrix.
Definition: DynamicMatrix.h:637

Depending on the storage order, the matrix elements are either stored in a row-wise fashion or in a column-wise fashion. Given the 2x3 matrix

                      \f[\left(\begin{array}{*{3}{c}}
                      1 & 2 & 3 \\
                      4 & 5 & 6 \\
                      \end{array}\right)\f]\n

in case of row-major order the elements are stored in the order

                      \f[\left(\begin{array}{*{6}{c}}
                      1 & 2 & 3 & 4 & 5 & 6. \\
                      \end{array}\right)\f]

In case of column-major order the elements are stored in the order

                      \f[\left(\begin{array}{*{6}{c}}
                      1 & 4 & 2 & 5 & 3 & 6. \\
                      \end{array}\right)\f]

The use of DynamicMatrix is very natural and intuitive. All operations (addition, subtraction, multiplication, scaling, ...) can be performed on all possible combinations of row-major and column-major dense and sparse matrices with fitting element types. The following example gives an impression of the use of DynamicMatrix:

DynamicMatrix<double,rowMajor> A( 2, 3 ); // Default constructed, non-initialized, row-major 2x3 matrix
A(0,0) = 1.0; A(0,1) = 2.0; A(0,2) = 3.0; // Initialization of the first row
A(1,0) = 4.0; A(1,1) = 5.0; A(1,2) = 6.0; // Initialization of the second row
DynamicMatrix<float,columnMajor> B( 2, 3 ); // Default constructed column-major single precision 2x3 matrix
B(0,0) = 1.0; B(0,1) = 3.0; B(0,2) = 5.0; // Initialization of the first row
B(1,0) = 2.0; B(1,1) = 4.0; B(1,2) = 6.0; // Initialization of the second row
CompressedMatrix<float> C( 2, 3 ); // Empty row-major sparse single precision matrix
DynamicMatrix<float> D( 3, 2, 4.0F ); // Directly, homogeneously initialized single precision 3x2 matrix
DynamicMatrix<double,rowMajor> E( A ); // Creation of a new row-major matrix as a copy of A
DynamicMatrix<double,columnMajor> F; // Creation of a default column-major matrix
E = A + B; // Matrix addition and assignment to a row-major matrix
F = A - C; // Matrix subtraction and assignment to a column-major matrix
F = A * D; // Matrix multiplication between two matrices of different element types
A *= 2.0; // In-place scaling of matrix A
E = 2.0 * B; // Scaling of matrix B
F = D * 2.0; // Scaling of matrix D
E += A - B; // Addition assignment
E -= A + C; // Subtraction assignment
F *= A * D; // Multiplication assignment
Efficient implementation of a compressed matrix.
Definition: CompressedMatrix.h:239
Efficient implementation of a dynamic matrix.
Definition: DynamicMatrix.h:242
constexpr bool rowMajor
Storage order flag for row-major matrices.
Definition: StorageOrder.h:71
constexpr bool columnMajor
Storage order flag for column-major matrices.
Definition: StorageOrder.h:99

Constructor & Destructor Documentation

◆ DynamicMatrix() [1/12]

template<typename Type , bool SO, typename Alloc , typename Tag >
blaze::DynamicMatrix< Type, SO, Alloc, Tag >::DynamicMatrix ( const Alloc &  alloc = Alloc{})
inlinenoexcept

The (default) constructor for DynamicMatrix.

Parameters
allocAllocator for all memory allocations of this matrix.

◆ DynamicMatrix() [2/12]

template<typename Type , bool SO, typename Alloc , typename Tag >
blaze::DynamicMatrix< Type, SO, Alloc, Tag >::DynamicMatrix ( size_t  m,
size_t  n,
const Alloc &  alloc = Alloc{} 
)
inline

Constructor for a matrix of size $ m \times n $. For built-in types no initialization is performed!

Parameters
mThe number of rows of the matrix.
nThe number of columns of the matrix.
allocAllocator for all memory allocations of this matrix.
Note
This constructor is only responsible to allocate the required dynamic memory. For built-in types no initialization of the elements is performed!

◆ DynamicMatrix() [3/12]

template<typename Type , bool SO, typename Alloc , typename Tag >
blaze::DynamicMatrix< Type, SO, Alloc, Tag >::DynamicMatrix ( size_t  m,
size_t  n,
const Type &  init,
const Alloc &  alloc = Alloc{} 
)
inline

Constructor for a homogenous initialization of all $ m \times n $ matrix elements.

Parameters
mThe number of rows of the matrix.
nThe number of columns of the matrix.
initThe initial value of the matrix elements.
allocAllocator for all memory allocations of this matrix.

All matrix elements are initialized with the specified value.

◆ DynamicMatrix() [4/12]

template<typename Type , bool SO, typename Alloc , typename Tag >
blaze::DynamicMatrix< Type, SO, Alloc, Tag >::DynamicMatrix ( initializer_list< initializer_list< Type > >  list,
const Alloc &  alloc = Alloc{} 
)
inline

List initialization of all matrix elements.

Parameters
listThe initializer list.
allocAllocator for all memory allocations of this matrix.

This constructor provides the option to explicitly initialize the elements of the matrix by means of an initializer list:

{ 4, 5 },
{ 7, 8, 9 } };

The matrix is sized according to the size of the initializer list and all its elements are (copy) assigned the values of the given initializer list. Missing values are initialized as default (as e.g. the value 6 in the example).

◆ DynamicMatrix() [5/12]

template<typename Type , bool SO, typename Alloc , typename Tag >
template<typename Other >
blaze::DynamicMatrix< Type, SO, Alloc, Tag >::DynamicMatrix ( size_t  m,
size_t  n,
const Other *  array,
const Alloc &  alloc = Alloc{} 
)
inline

Array initialization of all matrix elements.

Parameters
mThe number of rows of the matrix.
nThe number of columns of the matrix.
arrayDynamic array for the initialization.
allocAllocator for all memory allocations of this matrix.

This constructor offers the option to directly initialize the elements of the matrix with a dynamic array:

int* array = new int[20];
// ... Initialization of the dynamic array
delete[] array;

The matrix is sized according to the given size of the array and initialized with the values from the given array. Note that it is expected that the given array has at least m by n elements. Providing an array with less elements results in undefined behavior!

◆ DynamicMatrix() [6/12]

template<typename Type , bool SO, typename Alloc , typename Tag >
template<typename Other , size_t Rows, size_t Cols>
blaze::DynamicMatrix< Type, SO, Alloc, Tag >::DynamicMatrix ( const Other(&)  array[Rows][Cols],
const Alloc &  alloc = Alloc{} 
)
inline

Array initialization of all matrix elements.

Parameters
arrayStatic array for the initialization.
allocAllocator for all memory allocations of this matrix.

This constructor offers the option to directly initialize the elements of the matrix with a static array:

const int init[3][3] = { { 1, 2, 3 },
{ 4, 5 },
{ 7, 8, 9 } };

The matrix is sized according to the size of the static array and initialized with the values from the given static array. Missing values are initialized with default values (as e.g. the value 6 in the example).

◆ DynamicMatrix() [7/12]

template<typename Type , bool SO, typename Alloc , typename Tag >
template<typename Other , size_t Rows, size_t Cols>
blaze::DynamicMatrix< Type, SO, Alloc, Tag >::DynamicMatrix ( const std::array< std::array< Other, Cols >, Rows > &  array,
const Alloc &  alloc = Alloc{} 
)
inline

Initialization of all matrix elements from the given std::array.

Parameters
arrayThe given std::array for the initialization.
allocAllocator for all memory allocations of this matrix.

This constructor offers the option to directly initialize the elements of the matrix with a std::array:

const std::array<std::array<int,3UL>,3UL> init{ { { 1, 2, 3 },
{ 4, 5 },
{ 7, 8, 9 } } };

The matrix is sized according to the size of the std::array and initialized with the values from the given std::array. Missing values are initialized with default values (as e.g. the value 6 in the example).

◆ DynamicMatrix() [8/12]

template<typename Type , bool SO, typename Alloc , typename Tag >
blaze::DynamicMatrix< Type, SO, Alloc, Tag >::DynamicMatrix ( const DynamicMatrix< Type, SO, Alloc, Tag > &  m)
inline

The copy constructor for DynamicMatrix.

Parameters
mMatrix to be copied.

The copy constructor is explicitly defined due to the required dynamic memory management and in order to enable/facilitate NRV optimization.

◆ DynamicMatrix() [9/12]

template<typename Type , bool SO, typename Alloc , typename Tag >
blaze::DynamicMatrix< Type, SO, Alloc, Tag >::DynamicMatrix ( DynamicMatrix< Type, SO, Alloc, Tag > &&  m)
inlinenoexcept

The move constructor for DynamicMatrix.

Parameters
mThe matrix to be move into this instance.

◆ DynamicMatrix() [10/12]

template<typename Type , bool SO, typename Alloc , typename Tag >
template<typename MT , bool SO2>
blaze::DynamicMatrix< Type, SO, Alloc, Tag >::DynamicMatrix ( const Matrix< MT, SO2 > &  m)
inline

Conversion constructor from different matrices.

Parameters
mMatrix to be copied.

◆ DynamicMatrix() [11/12]

template<typename Type , typename Alloc , typename Tag >
blaze::DynamicMatrix< Type, Alloc, Tag >::DynamicMatrix ( size_t  m,
size_t  mm,
size_t  n,
const Alloc &  alloc,
Uninitialized   
)
inlineprivate

Auxiliary constructor for DynamicMatrix.

Parameters
mThe number of rows of the matrix.
nThe number of columns of the matrix.
nnThe alignment adjusted number of columns.
allocAllocator for all memory allocations of this matrix.
Exceptions
std::bad_allocAllocation failed.
Parameters
mThe number of rows of the matrix.
mmThe alignment adjusted number of rows.
nThe number of columns of the matrix.
allocAllocator for all memory allocations of this matrix.
Exceptions
std::bad_allocAllocation failed.

◆ DynamicMatrix() [12/12]

template<typename Type , typename Alloc , typename Tag >
blaze::DynamicMatrix< Type, Alloc, Tag >::DynamicMatrix ( size_t  m,
size_t  mm,
size_t  n,
size_t  capa,
const Alloc &  alloc,
Uninitialized   
)
inlineprivate

Auxiliary constructor for DynamicMatrix.

Parameters
mThe number of rows of the matrix.
nThe number of columns of the matrix.
nnThe alignment adjusted number of columns.
capaThe initial capacity of the matrix.
allocAllocator for all memory allocations of this matrix.
Exceptions
std::bad_allocAllocation failed.
Parameters
mThe number of rows of the matrix.
mmThe alignment adjusted number of rows.
nThe number of columns of the matrix.
capaThe initial capacity of the matrix.
allocAllocator for all memory allocations of this matrix.
Exceptions
std::bad_allocAllocation failed.

Member Function Documentation

◆ addAssign() [1/4]

template<typename Type , bool SO, typename Alloc , typename Tag >
template<typename MT >
auto blaze::DynamicMatrix< Type, SO, Alloc, Tag >::addAssign ( const DenseMatrix< MT, SO > &  rhs) -> DisableIf_t< VectorizedAddAssign_v<MT> >
inline

Default implementation of the addition assignment of a row-major dense matrix.

SIMD optimized implementation of the addition assignment of a row-major dense matrix.

Parameters
rhsThe right-hand side dense matrix to be added.
Returns
void

This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

◆ addAssign() [2/4]

template<typename Type , bool SO, typename Alloc , typename Tag >
template<typename MT >
void blaze::DynamicMatrix< Type, SO, Alloc, Tag >::addAssign ( const DenseMatrix< MT,!SO > &  rhs)
inline

Default implementation of the addition assignment of a column-major dense matrix.

Parameters
rhsThe right-hand side dense matrix to be added.
Returns
void

This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

◆ addAssign() [3/4]

template<typename Type , bool SO, typename Alloc , typename Tag >
template<typename MT >
void blaze::DynamicMatrix< Type, SO, Alloc, Tag >::addAssign ( const SparseMatrix< MT, SO > &  rhs)
inline

Default implementation of the addition assignment of a row-major sparse matrix.

Parameters
rhsThe right-hand side sparse matrix to be added.
Returns
void

This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

◆ addAssign() [4/4]

template<typename Type , bool SO, typename Alloc , typename Tag >
template<typename MT >
void blaze::DynamicMatrix< Type, SO, Alloc, Tag >::addAssign ( const SparseMatrix< MT,!SO > &  rhs)
inline

Default implementation of the addition assignment of a column-major sparse matrix.

Parameters
rhsThe right-hand side sparse matrix to be added.
Returns
void

This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

◆ addPadding()

template<typename Type , bool SO, typename Alloc , typename Tag >
size_t blaze::DynamicMatrix< Type, SO, Alloc, Tag >::addPadding ( size_t  value) const
inlineprivatenoexcept

Add the necessary amount of padding to the given value.

Parameters
valueThe value to be padded.
Returns
The padded value.

This function increments the given value by the necessary amount of padding based on the vector's data type Type.

◆ assign() [1/4]

template<typename Type , bool SO, typename Alloc , typename Tag >
template<typename MT >
auto blaze::DynamicMatrix< Type, SO, Alloc, Tag >::assign ( const DenseMatrix< MT, SO > &  rhs) -> DisableIf_t< VectorizedAssign_v<MT> >
inline

Default implementation of the assignment of a row-major dense matrix.

SIMD optimized implementation of the assignment of a row-major dense matrix.

Parameters
rhsThe right-hand side dense matrix to be assigned.
Returns
void

This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

◆ assign() [2/4]

template<typename Type , bool SO, typename Alloc , typename Tag >
template<typename MT >
void blaze::DynamicMatrix< Type, SO, Alloc, Tag >::assign ( const DenseMatrix< MT,!SO > &  rhs)
inline

Default implementation of the assignment of a column-major dense matrix.

Parameters
rhsThe right-hand side dense matrix to be assigned.
Returns
void

This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

◆ assign() [3/4]

template<typename Type , bool SO, typename Alloc , typename Tag >
template<typename MT >
void blaze::DynamicMatrix< Type, SO, Alloc, Tag >::assign ( const SparseMatrix< MT, SO > &  rhs)
inline

Default implementation of the assignment of a row-major sparse matrix.

Parameters
rhsThe right-hand side sparse matrix to be assigned.
Returns
void

This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

◆ assign() [4/4]

template<typename Type , bool SO, typename Alloc , typename Tag >
template<typename MT >
void blaze::DynamicMatrix< Type, SO, Alloc, Tag >::assign ( const SparseMatrix< MT,!SO > &  rhs)
inline

Default implementation of the assignment of a column-major sparse matrix.

Parameters
rhsThe right-hand side sparse matrix to be assigned.
Returns
void

This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

◆ at() [1/2]

template<typename Type , bool SO, typename Alloc , typename Tag >
DynamicMatrix< Type, SO, Alloc, Tag >::Reference blaze::DynamicMatrix< Type, SO, Alloc, Tag >::at ( size_t  i,
size_t  j 
)
inline

Checked access to the matrix elements.

Parameters
iAccess index for the row. The index has to be in the range $[0..M-1]$.
jAccess index for the column. The index has to be in the range $[0..N-1]$.
Returns
Reference to the accessed value.
Exceptions
std::out_of_rangeInvalid matrix access index.

In contrast to the subscript operator this function always performs a check of the given access indices.

◆ at() [2/2]

template<typename Type , bool SO, typename Alloc , typename Tag >
DynamicMatrix< Type, SO, Alloc, Tag >::ConstReference blaze::DynamicMatrix< Type, SO, Alloc, Tag >::at ( size_t  i,
size_t  j 
) const
inline

Checked access to the matrix elements.

Parameters
iAccess index for the row. The index has to be in the range $[0..M-1]$.
jAccess index for the column. The index has to be in the range $[0..N-1]$.
Returns
Reference to the accessed value.
Exceptions
std::out_of_rangeInvalid matrix access index.

In contrast to the subscript operator this function always performs a check of the given access indices.

◆ begin() [1/2]

template<typename Type , bool SO, typename Alloc , typename Tag >
DynamicMatrix< Type, SO, Alloc, Tag >::ConstIterator blaze::DynamicMatrix< Type, SO, Alloc, Tag >::begin ( size_t  i) const
inlinenoexcept

Returns an iterator to the first element of row/column i.

Parameters
iThe row/column index.
Returns
Iterator to the first element of row/column i.

This function returns a row/column iterator to the first element of row/column i. In case the storage order is set to rowMajor the function returns an iterator to the first element of row i, in case the storage flag is set to columnMajor the function returns an iterator to the first element of column i.

◆ begin() [2/2]

template<typename Type , bool SO, typename Alloc , typename Tag >
DynamicMatrix< Type, SO, Alloc, Tag >::Iterator blaze::DynamicMatrix< Type, SO, Alloc, Tag >::begin ( size_t  i)
inlinenoexcept

Returns an iterator to the first element of row/column i.

Parameters
iThe row/column index.
Returns
Iterator to the first element of row/column i.

This function returns a row/column iterator to the first element of row/column i. In case the storage order is set to rowMajor the function returns an iterator to the first element of row i, in case the storage flag is set to columnMajor the function returns an iterator to the first element of column i.

◆ canAlias()

template<typename Type , bool SO, typename Alloc , typename Tag >
template<typename Other >
bool blaze::DynamicMatrix< Type, SO, Alloc, Tag >::canAlias ( const Other *  alias) const
inlinenoexcept

Returns whether the matrix can alias with the given address alias.

Parameters
aliasThe alias to be checked.
Returns
true in case the alias corresponds to this matrix, false if not.

This function returns whether the given address can alias with the matrix. In contrast to the isAliased() function this function is allowed to use compile time expressions to optimize the evaluation.

◆ canSMPAssign()

template<typename Type , bool SO, typename Alloc , typename Tag >
bool blaze::DynamicMatrix< Type, SO, Alloc, Tag >::canSMPAssign
inlinenoexcept

Returns whether the matrix can be used in SMP assignments.

Returns
true in case the matrix can be used in SMP assignments, false if not.

This function returns whether the matrix can be used in SMP assignments. In contrast to the smpAssignable member enumeration, which is based solely on compile time information, this function additionally provides runtime information (as for instance the current number of rows and/or columns of the matrix).

◆ capacity() [1/2]

template<typename Type , bool SO, typename Alloc , typename Tag >
size_t blaze::DynamicMatrix< Type, SO, Alloc, Tag >::capacity
inlinenoexcept

Returns the maximum capacity of the matrix.

Returns
The capacity of the matrix.

◆ capacity() [2/2]

template<typename Type , bool SO, typename Alloc , typename Tag >
size_t blaze::DynamicMatrix< Type, SO, Alloc, Tag >::capacity ( size_t  i) const
inlinenoexcept

Returns the current capacity of the specified row/column.

Parameters
iThe index of the row/column.
Returns
The current capacity of row/column i.

This function returns the current capacity of the specified row/column. In case the storage order is set to rowMajor the function returns the capacity of row i, in case the storage flag is set to columnMajor the function returns the capacity of column i.

◆ cbegin()

template<typename Type , bool SO, typename Alloc , typename Tag >
DynamicMatrix< Type, SO, Alloc, Tag >::ConstIterator blaze::DynamicMatrix< Type, SO, Alloc, Tag >::cbegin ( size_t  i) const
inlinenoexcept

Returns an iterator to the first element of row/column i.

Parameters
iThe row/column index.
Returns
Iterator to the first element of row/column i.

This function returns a row/column iterator to the first element of row/column i. In case the storage order is set to rowMajor the function returns an iterator to the first element of row i, in case the storage flag is set to columnMajor the function returns an iterator to the first element of column i.

◆ cend()

template<typename Type , bool SO, typename Alloc , typename Tag >
DynamicMatrix< Type, SO, Alloc, Tag >::ConstIterator blaze::DynamicMatrix< Type, SO, Alloc, Tag >::cend ( size_t  i) const
inlinenoexcept

Returns an iterator just past the last element of row/column i.

Parameters
iThe row/column index.
Returns
Iterator just past the last element of row/column i.

This function returns an row/column iterator just past the last element of row/column i. In case the storage order is set to rowMajor the function returns an iterator just past the last element of row i, in case the storage flag is set to columnMajor the function returns an iterator just past the last element of column i.

◆ clear()

template<typename Type , bool SO, typename Alloc , typename Tag >
void blaze::DynamicMatrix< Type, SO, Alloc, Tag >::clear
inline

Clearing the $ M \times N $ matrix.

Returns
void

After the clear() function, the size of the matrix is 0.

◆ columns()

template<typename Type , bool SO, typename Alloc , typename Tag >
size_t blaze::DynamicMatrix< Type, SO, Alloc, Tag >::columns
inlinenoexcept

Returns the current number of columns of the matrix.

Returns
The number of columns of the matrix.

◆ ctranspose()

template<typename Type , bool SO, typename Alloc , typename Tag >
DynamicMatrix< Type, SO, Alloc, Tag > & blaze::DynamicMatrix< Type, SO, Alloc, Tag >::ctranspose
inline

In-place conjugate transpose of the matrix.

Returns
Reference to the transposed matrix.

◆ data() [1/4]

template<typename Type , bool SO, typename Alloc , typename Tag >
DynamicMatrix< Type, SO, Alloc, Tag >::ConstPointer blaze::DynamicMatrix< Type, SO, Alloc, Tag >::data
inlinenoexcept

Low-level data access to the matrix elements.

Returns
Pointer to the internal element storage.

This function returns a pointer to the internal storage of the dynamic matrix. Note that you can NOT assume that all matrix elements lie adjacent to each other! The dynamic matrix may use techniques such as padding to improve the alignment of the data. Whereas the number of elements within a row/column are given by the rows() and columns() member functions, respectively, the total number of elements including padding is given by the spacing() member function.

◆ data() [2/4]

template<typename Type , bool SO, typename Alloc , typename Tag >
DynamicMatrix< Type, SO, Alloc, Tag >::Pointer blaze::DynamicMatrix< Type, SO, Alloc, Tag >::data
inlinenoexcept

Low-level data access to the matrix elements.

Returns
Pointer to the internal element storage.

This function returns a pointer to the internal storage of the dynamic matrix. Note that you can NOT assume that all matrix elements lie adjacent to each other! The dynamic matrix may use techniques such as padding to improve the alignment of the data. Whereas the number of elements within a row/column are given by the rows() and columns() member functions, respectively, the total number of elements including padding is given by the spacing() member function.

◆ data() [3/4]

template<typename Type , bool SO, typename Alloc , typename Tag >
DynamicMatrix< Type, SO, Alloc, Tag >::ConstPointer blaze::DynamicMatrix< Type, SO, Alloc, Tag >::data ( size_t  i) const
inlinenoexcept

Low-level data access to the matrix elements of row/column i.

Parameters
iThe row/column index.
Returns
Pointer to the internal element storage.

This function returns a pointer to the internal storage for the elements in row/column i.

◆ data() [4/4]

template<typename Type , bool SO, typename Alloc , typename Tag >
DynamicMatrix< Type, SO, Alloc, Tag >::Pointer blaze::DynamicMatrix< Type, SO, Alloc, Tag >::data ( size_t  i)
inlinenoexcept

Low-level data access to the matrix elements of row/column i.

Parameters
iThe row/column index.
Returns
Pointer to the internal element storage.

This function returns a pointer to the internal storage for the elements in row/column i.

◆ end() [1/2]

template<typename Type , bool SO, typename Alloc , typename Tag >
DynamicMatrix< Type, SO, Alloc, Tag >::ConstIterator blaze::DynamicMatrix< Type, SO, Alloc, Tag >::end ( size_t  i) const
inlinenoexcept

Returns an iterator just past the last element of row/column i.

Parameters
iThe row/column index.
Returns
Iterator just past the last element of row/column i.

This function returns an row/column iterator just past the last element of row/column i. In case the storage order is set to rowMajor the function returns an iterator just past the last element of row i, in case the storage flag is set to columnMajor the function returns an iterator just past the last element of column i.

◆ end() [2/2]

template<typename Type , bool SO, typename Alloc , typename Tag >
DynamicMatrix< Type, SO, Alloc, Tag >::Iterator blaze::DynamicMatrix< Type, SO, Alloc, Tag >::end ( size_t  i)
inlinenoexcept

Returns an iterator just past the last element of row/column i.

Parameters
iThe row/column index.
Returns
Iterator just past the last element of row/column i.

This function returns an row/column iterator just past the last element of row/column i. In case the storage order is set to rowMajor the function returns an iterator just past the last element of row i, in case the storage flag is set to columnMajor the function returns an iterator just past the last element of column i.

◆ extend()

template<typename Type , bool SO, typename Alloc , typename Tag >
void blaze::DynamicMatrix< Type, SO, Alloc, Tag >::extend ( size_t  m,
size_t  n,
bool  preserve = true 
)
inline

Extending the size of the matrix.

Parameters
mNumber of additional rows.
nNumber of additional columns.
preservetrue if the old values of the matrix should be preserved, false if not.
Returns
void

This function increases the matrix size by m rows and n columns. During this operation, new dynamic memory may be allocated in case the capacity of the matrix is too small. Therefore this function potentially changes all matrix elements. In order to preserve the old matrix values, the preserve flag can be set to true. However, new matrix elements of built-in type are not initialized!

◆ isAliased()

template<typename Type , bool SO, typename Alloc , typename Tag >
template<typename Other >
bool blaze::DynamicMatrix< Type, SO, Alloc, Tag >::isAliased ( const Other *  alias) const
inlinenoexcept

Returns whether the matrix is aliased with the given address alias.

Parameters
aliasThe alias to be checked.
Returns
true in case the alias corresponds to this matrix, false if not.

This function returns whether the given address is aliased with the matrix. In contrast to the canAlias() function this function is not allowed to use compile time expressions to optimize the evaluation.

◆ isAligned()

template<typename Type , bool SO, typename Alloc , typename Tag >
bool blaze::DynamicMatrix< Type, SO, Alloc, Tag >::isAligned
inlinenoexcept

Returns whether the matrix is properly aligned in memory.

Returns
true in case the matrix is aligned, false if not.

This function returns whether the matrix is guaranteed to be properly aligned in memory, i.e. whether the beginning and the end of each row/column of the matrix are guaranteed to conform to the alignment restrictions of the element type Type.

◆ isIntact()

template<typename Type , bool SO, typename Alloc , typename Tag >
bool blaze::DynamicMatrix< Type, SO, Alloc, Tag >::isIntact
inlinenoexcept

Returns whether the invariants of the dynamic matrix are intact.

Returns
true in case the dynamic matrix's invariants are intact, false otherwise.

This function checks whether the invariants of the dynamic matrix are intact, i.e. if its state is valid. In case the invariants are intact, the function returns true, else it will return false.

◆ load()

template<typename Type , bool SO, typename Alloc , typename Tag >
BLAZE_ALWAYS_INLINE DynamicMatrix< Type, SO, Alloc, Tag >::SIMDType blaze::DynamicMatrix< Type, SO, Alloc, Tag >::load ( size_t  i,
size_t  j 
) const
noexcept

Load of a SIMD element of the matrix.

Parameters
iAccess index for the row. The index has to be in the range [0..M-1].
jAccess index for the column. The index has to be in the range [0..N-1].
Returns
The loaded SIMD element.

This function performs a load of a specific SIMD element of the dense matrix. The row index must be smaller than the number of rows and the column index must be smaller then the number of columns. Additionally, the column index (in case of a row-major matrix) or the row index (in case of a column-major matrix) must be a multiple of the number of values inside the SIMD element. This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors.

◆ loada()

template<typename Type , bool SO, typename Alloc , typename Tag >
BLAZE_ALWAYS_INLINE DynamicMatrix< Type, SO, Alloc, Tag >::SIMDType blaze::DynamicMatrix< Type, SO, Alloc, Tag >::loada ( size_t  i,
size_t  j 
) const
noexcept

Aligned load of a SIMD element of the matrix.

Parameters
iAccess index for the row. The index has to be in the range [0..M-1].
jAccess index for the column. The index has to be in the range [0..N-1].
Returns
The loaded SIMD element.

This function performs an aligned load of a specific SIMD element of the dense matrix. The row index must be smaller than the number of rows and the column index must be smaller than the number of columns. Additionally, the column index (in case of a row-major matrix) or the row index (in case of a column-major matrix) must be a multiple of the number of values inside the SIMD element. This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors.

◆ loadu()

template<typename Type , bool SO, typename Alloc , typename Tag >
BLAZE_ALWAYS_INLINE DynamicMatrix< Type, SO, Alloc, Tag >::SIMDType blaze::DynamicMatrix< Type, SO, Alloc, Tag >::loadu ( size_t  i,
size_t  j 
) const
noexcept

Unaligned load of a SIMD element of the matrix.

Parameters
iAccess index for the row. The index has to be in the range [0..M-1].
jAccess index for the column. The index has to be in the range [0..N-1].
Returns
The loaded SIMD element.

This function performs an unaligned load of a specific SIMD element of the dense matrix. The row index must be smaller than the number of rows and the column index must be smaller than the number of columns. Additionally, the column index (in case of a row-major matrix) or the row index (in case of a column-major matrix) must be a multiple of the number of values inside the SIMD element. This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors.

◆ nonZeros() [1/2]

template<typename Type , bool SO, typename Alloc , typename Tag >
size_t blaze::DynamicMatrix< Type, SO, Alloc, Tag >::nonZeros
inline

Returns the total number of non-zero elements in the matrix.

Returns
The number of non-zero elements in the dense matrix.

This function returns the number of non-zero elements in the matrix (i.e. the elements that compare unequal to their default value). Note that the number of non-zero elements is always less than or equal to the total number of elements in the matrix.

◆ nonZeros() [2/2]

template<typename Type , bool SO, typename Alloc , typename Tag >
size_t blaze::DynamicMatrix< Type, SO, Alloc, Tag >::nonZeros ( size_t  i) const
inline

Returns the number of non-zero elements in the specified row/column.

Parameters
iThe index of the row/column.
Returns
The number of non-zero elements of row/column i.

This function returns the current number of non-zero elements in the specified row/column (i.e. the elements that compare unequal to their default value). In case the storage order is set to rowMajor the function returns the number of non-zero elements in row i, in case the storage flag is set to columnMajor the function returns the number of non-zero elements in column i.

◆ operator%=()

template<typename Type , bool SO, typename Alloc , typename Tag >
template<typename MT , bool SO2>
DynamicMatrix< Type, SO, Alloc, Tag > & blaze::DynamicMatrix< Type, SO, Alloc, Tag >::operator%= ( const Matrix< MT, SO2 > &  rhs) &
inline

Schur product assignment operator for the multiplication of a matrix ( $ A\circ=B $).

Parameters
rhsThe right-hand side matrix for the Schur product.
Returns
Reference to the matrix.
Exceptions
std::invalid_argumentMatrix sizes do not match.

In case the current sizes of the two matrices don't match, a std::invalid_argument exception is thrown.

◆ operator()() [1/2]

template<typename Type , bool SO, typename Alloc , typename Tag >
DynamicMatrix< Type, SO, Alloc, Tag >::ConstReference blaze::DynamicMatrix< Type, SO, Alloc, Tag >::operator() ( size_t  i,
size_t  j 
) const
inlinenoexcept

2D-access to the matrix elements.

Parameters
iAccess index for the row. The index has to be in the range $[0..M-1]$.
jAccess index for the column. The index has to be in the range $[0..N-1]$.
Returns
Reference to the accessed value.

This function only performs an index check in case BLAZE_USER_ASSERT() is active. In contrast, the at() function is guaranteed to perform a check of the given access indices.

◆ operator()() [2/2]

template<typename Type , bool SO, typename Alloc , typename Tag >
DynamicMatrix< Type, SO, Alloc, Tag >::Reference blaze::DynamicMatrix< Type, SO, Alloc, Tag >::operator() ( size_t  i,
size_t  j 
)
inlinenoexcept

2D-access to the matrix elements.

Parameters
iAccess index for the row. The index has to be in the range $[0..M-1]$.
jAccess index for the column. The index has to be in the range $[0..N-1]$.
Returns
Reference to the accessed value.

This function only performs an index check in case BLAZE_USER_ASSERT() is active. In contrast, the at() function is guaranteed to perform a check of the given access indices.

◆ operator*() [1/2]

BLAZE_ALWAYS_INLINE constexpr const DynamicMatrix< Type, SO, Alloc, Tag > & blaze::Matrix< DynamicMatrix< Type, SO, Alloc, Tag > , SO >::operator*
constexprnoexceptinherited

CRTP-based conversion operation for constant matrices.

Returns
Constant reference of the actual type of the matrix.

This operator performs the CRTP-based type-safe downcast to the actual type MT of the matrix. It will return a constant reference to the actual type MT.

◆ operator*() [2/2]

BLAZE_ALWAYS_INLINE constexpr DynamicMatrix< Type, SO, Alloc, Tag > & blaze::Matrix< DynamicMatrix< Type, SO, Alloc, Tag > , SO >::operator*
constexprnoexceptinherited

CRTP-based conversion operation for non-constant matrices.

Returns
Mutable reference of the actual type of the matrix.

This operator performs the CRTP-based type-safe downcast to the actual type MT of the matrix. It will return a mutable reference to the actual type MT.

◆ operator+=()

template<typename Type , bool SO, typename Alloc , typename Tag >
template<typename MT , bool SO2>
DynamicMatrix< Type, SO, Alloc, Tag > & blaze::DynamicMatrix< Type, SO, Alloc, Tag >::operator+= ( const Matrix< MT, SO2 > &  rhs) &
inline

Addition assignment operator for the addition of a matrix ( $ A+=B $).

Parameters
rhsThe right-hand side matrix to be added to the matrix.
Returns
Reference to the matrix.
Exceptions
std::invalid_argumentMatrix sizes do not match.

In case the current sizes of the two matrices don't match, a std::invalid_argument exception is thrown.

◆ operator-=()

template<typename Type , bool SO, typename Alloc , typename Tag >
template<typename MT , bool SO2>
DynamicMatrix< Type, SO, Alloc, Tag > & blaze::DynamicMatrix< Type, SO, Alloc, Tag >::operator-= ( const Matrix< MT, SO2 > &  rhs) &
inline

Subtraction assignment operator for the subtraction of a matrix ( $ A-=B $).

Parameters
rhsThe right-hand side matrix to be subtracted from the matrix.
Returns
Reference to the matrix.
Exceptions
std::invalid_argumentMatrix sizes do not match.

In case the current sizes of the two matrices don't match, a std::invalid_argument exception is thrown.

◆ operator=() [1/6]

template<typename Type , bool SO, typename Alloc , typename Tag >
DynamicMatrix< Type, SO, Alloc, Tag > & blaze::DynamicMatrix< Type, SO, Alloc, Tag >::operator= ( const DynamicMatrix< Type, SO, Alloc, Tag > &  rhs) &
inline

Copy assignment operator for DynamicMatrix.

Parameters
rhsMatrix to be copied.
Returns
Reference to the assigned matrix.

The matrix is resized according to the given $ M \times N $ matrix and initialized as a copy of this matrix.

◆ operator=() [2/6]

template<typename Type , bool SO, typename Alloc , typename Tag >
template<typename MT , bool SO2>
DynamicMatrix< Type, SO, Alloc, Tag > & blaze::DynamicMatrix< Type, SO, Alloc, Tag >::operator= ( const Matrix< MT, SO2 > &  rhs) &
inline

Assignment operator for different matrices.

Parameters
rhsMatrix to be copied.
Returns
Reference to the assigned matrix.

The matrix is resized according to the given $ M \times N $ matrix and initialized as a copy of this matrix.

◆ operator=() [3/6]

template<typename Type , bool SO, typename Alloc , typename Tag >
template<typename Other , size_t Rows, size_t Cols>
DynamicMatrix< Type, SO, Alloc, Tag > & blaze::DynamicMatrix< Type, SO, Alloc, Tag >::operator= ( const Other(&)  array[Rows][Cols]) &
inline

Array assignment to all matrix elements.

Parameters
arrayStatic array for the assignment.
Returns
Reference to the assigned matrix.

This assignment operator offers the option to directly set all elements of the matrix:

const int init[3][3] = { { 1, 2, 3 },
{ 4, 5 },
{ 7, 8, 9 } };
A = init;

The matrix is resized according to the size of the static array and assigned the values of the given static array. Missing values are initialized with default values (as e.g. the value 6 in the example).

◆ operator=() [4/6]

template<typename Type , bool SO, typename Alloc , typename Tag >
template<typename Other , size_t Rows, size_t Cols>
DynamicMatrix< Type, SO, Alloc, Tag > & blaze::DynamicMatrix< Type, SO, Alloc, Tag >::operator= ( const std::array< std::array< Other, Cols >, Rows > &  array) &
inline

Array assignment to all matrix elements.

Parameters
arrayThe given std::array for the assignment.
Returns
Reference to the assigned matrix.

This assignment operator offers the option to directly set all elements of the matrix:

const std::array<std::array<int,3UL>,3UL> init{ { { 1, 2, 3 },
{ 4, 5 },
{ 7, 8, 9 } } };
A = init;

The matrix is resized according to the size of the std::array and assigned the values of the given std::array. Missing values are initialized with default values (as e.g. the value 6 in the example).

◆ operator=() [5/6]

template<typename Type , bool SO, typename Alloc , typename Tag >
DynamicMatrix< Type, SO, Alloc, Tag > & blaze::DynamicMatrix< Type, SO, Alloc, Tag >::operator= ( const Type &  rhs) &
inline

Homogenous assignment to all matrix elements.

Parameters
rhsScalar value to be assigned to all matrix elements.
Returns
Reference to the assigned matrix.

◆ operator=() [6/6]

template<typename Type , bool SO, typename Alloc , typename Tag >
DynamicMatrix< Type, SO, Alloc, Tag > & blaze::DynamicMatrix< Type, SO, Alloc, Tag >::operator= ( initializer_list< initializer_list< Type > >  list) &
inline

List assignment to all matrix elements.

Parameters
listThe initializer list.

This assignment operator offers the option to directly assign to all elements of the matrix by means of an initializer list:

A = { { 1, 2, 3 },
{ 4, 5 },
{ 7, 8, 9 } };

The matrix is resized according to the given initializer list and all its elements are (copy) assigned the values from the given initializer list. Missing values are initialized as default (as e.g. the value 6 in the example).

◆ operator~() [1/2]

BLAZE_ALWAYS_INLINE constexpr const DynamicMatrix< Type, SO, Alloc, Tag > & blaze::Matrix< DynamicMatrix< Type, SO, Alloc, Tag > , SO >::operator~
constexprnoexceptinherited

CRTP-based conversion operation for constant matrices.

Parameters
matrixThe matrix to be downcast.
Returns
Constant reference of the actual type of the matrix.

This operator performs the CRTP-based type-safe downcast to the actual type MT of the matrix. It will return a constant reference to the actual type MT.

◆ operator~() [2/2]

BLAZE_ALWAYS_INLINE constexpr DynamicMatrix< Type, SO, Alloc, Tag > & blaze::Matrix< DynamicMatrix< Type, SO, Alloc, Tag > , SO >::operator~
constexprnoexceptinherited

CRTP-based conversion operation for non-constant matrices.

Parameters
matrixThe matrix to be downcast.
Returns
Mutable reference of the actual type of the matrix.

This operator performs the CRTP-based type-safe downcast to the actual type MT of the matrix. It will return a mutable reference to the actual type MT.

◆ reserve()

template<typename Type , bool SO, typename Alloc , typename Tag >
void blaze::DynamicMatrix< Type, SO, Alloc, Tag >::reserve ( size_t  elements)
inline

Setting the minimum capacity of the matrix.

Parameters
elementsThe new minimum capacity of the dense matrix.
Returns
void

This function increases the capacity of the dense matrix to at least elements elements. The current values of the matrix elements are preserved.

◆ reset() [1/2]

template<typename Type , bool SO, typename Alloc , typename Tag >
void blaze::DynamicMatrix< Type, SO, Alloc, Tag >::reset
inline

Reset to the default initial values.

Returns
void

◆ reset() [2/2]

template<typename Type , bool SO, typename Alloc , typename Tag >
void blaze::DynamicMatrix< Type, SO, Alloc, Tag >::reset ( size_t  i)
inline

Reset the specified row/column to the default initial values.

Parameters
iThe index of the row/column.
Returns
void

This function resets the values in the specified row/column to their default value. In case the storage order is set to rowMajor the function resets the values in row i, in case the storage order is set to columnMajor the function resets the values in column i. Note that the capacity of the row/column remains unchanged.

◆ resize()

template<typename Type , bool SO, typename Alloc , typename Tag >
void blaze::DynamicMatrix< Type, SO, Alloc, Tag >::resize ( size_t  m,
size_t  n,
bool  preserve = true 
)

Changing the size of the matrix.

Parameters
mThe new number of rows of the matrix.
nThe new number of columns of the matrix.
preservetrue if the old values of the matrix should be preserved, false if not.
Returns
void

This function resizes the matrix using the given size to $ m \times n $. During this operation, new dynamic memory may be allocated in case the capacity of the matrix is too small. Note that this function may invalidate all existing views (submatrices, rows, columns, ...) on the matrix if it is used to shrink the matrix. Additionally, the resize operation potentially changes all matrix elements. In order to preserve the old matrix values, the preserve flag can be set to true. However, new matrix elements of built-in type are not initialized!

The following example illustrates the resize operation of a $ 2 \times 4 $ matrix to a $ 4 \times 2 $ matrix. The new, uninitialized elements are marked with x:

                          \f[
                          \left(\begin{array}{*{4}{c}}
                          1 & 2 & 3 & 4 \\
                          5 & 6 & 7 & 8 \\
                          \end{array}\right)

                          \Longrightarrow

                          \left(\begin{array}{*{2}{c}}
                          1 & 2 \\
                          5 & 6 \\
                          x & x \\
                          x & x \\
                          \end{array}\right)
                          \f]

◆ rows()

template<typename Type , bool SO, typename Alloc , typename Tag >
size_t blaze::DynamicMatrix< Type, SO, Alloc, Tag >::rows
inlinenoexcept

Returns the current number of rows of the matrix.

Returns
The number of rows of the matrix.

◆ scale()

template<typename Type , bool SO, typename Alloc , typename Tag >
template<typename Other >
DynamicMatrix< Type, SO, Alloc, Tag > & blaze::DynamicMatrix< Type, SO, Alloc, Tag >::scale ( const Other &  scalar)
inline

Scaling of the matrix by the scalar value scalar ( $ A=B*s $).

Parameters
scalarThe scalar value for the matrix scaling.
Returns
Reference to the matrix.

This function scales the matrix by applying the given scalar value scalar to each element of the matrix. For built-in and complex data types it has the same effect as using the multiplication assignment operator:

// ... Resizing and initialization
A *= 4; // Scaling of the matrix
A.scale( 4 ); // Same effect as above

◆ schurAssign() [1/4]

template<typename Type , bool SO, typename Alloc , typename Tag >
template<typename MT >
auto blaze::DynamicMatrix< Type, SO, Alloc, Tag >::schurAssign ( const DenseMatrix< MT, SO > &  rhs) -> DisableIf_t< VectorizedSchurAssign_v<MT> >
inline

Default implementation of the Schur product assignment of a row-major dense matrix.

SIMD optimized implementation of the Schur product assignment of a row-major dense matrix.

Parameters
rhsThe right-hand side dense matrix for the Schur product.
Returns
void

This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

◆ schurAssign() [2/4]

template<typename Type , bool SO, typename Alloc , typename Tag >
template<typename MT >
void blaze::DynamicMatrix< Type, SO, Alloc, Tag >::schurAssign ( const DenseMatrix< MT,!SO > &  rhs)
inline

Default implementation of the Schur product assignment of a column-major dense matrix.

Parameters
rhsThe right-hand side dense matrix for the Schur product.
Returns
void

This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

◆ schurAssign() [3/4]

template<typename Type , bool SO, typename Alloc , typename Tag >
template<typename MT >
void blaze::DynamicMatrix< Type, SO, Alloc, Tag >::schurAssign ( const SparseMatrix< MT, SO > &  rhs)
inline

Default implementation of the Schur product assignment of a row-major sparse matrix.

Parameters
rhsThe right-hand side sparse matrix for the Schur product.
Returns
void

This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

◆ schurAssign() [4/4]

template<typename Type , bool SO, typename Alloc , typename Tag >
template<typename MT >
void blaze::DynamicMatrix< Type, SO, Alloc, Tag >::schurAssign ( const SparseMatrix< MT,!SO > &  rhs)
inline

Default implementation of the Schur product assignment of a column-major sparse matrix.

Parameters
rhsThe right-hand side sparse matrix for the Schur product.
Returns
void

This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

◆ shrinkToFit()

template<typename Type , bool SO, typename Alloc , typename Tag >
void blaze::DynamicMatrix< Type, SO, Alloc, Tag >::shrinkToFit
inline

Requesting the removal of unused capacity.

Returns
void

This function minimizes the capacity of the matrix by removing unused capacity. Please note that due to padding the capacity might not be reduced exactly to rows() times columns(). Please also note that in case a reallocation occurs, all iterators (including end() iterators), all pointers and references to elements of this matrix are invalidated.

◆ spacing()

template<typename Type , bool SO, typename Alloc , typename Tag >
size_t blaze::DynamicMatrix< Type, SO, Alloc, Tag >::spacing
inlinenoexcept

Returns the spacing between the beginning of two rows/columns.

Returns
The spacing between the beginning of two rows/columns.

This function returns the spacing between the beginning of two rows/columns, i.e. the total number of elements of a row/column. In case the storage order is set to rowMajor the function returns the spacing between two rows, in case the storage flag is set to columnMajor the function returns the spacing between two columns.

◆ store()

template<typename Type , bool SO, typename Alloc , typename Tag >
BLAZE_ALWAYS_INLINE void blaze::DynamicMatrix< Type, SO, Alloc, Tag >::store ( size_t  i,
size_t  j,
const SIMDType value 
)
noexcept

Store of a SIMD element of the matrix.

Parameters
iAccess index for the row. The index has to be in the range [0..M-1].
jAccess index for the column. The index has to be in the range [0..N-1].
valueThe SIMD element to be stored.
Returns
void

This function performs a store of a specific SIMD element of the dense matrix. The row index must be smaller than the number of rows and the column index must be smaller than the number of columns. Additionally, the column index (in case of a row-major matrix) or the row index (in case of a column-major matrix) must be a multiple of the number of values inside the SIMD element. This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors.

◆ storea()

template<typename Type , bool SO, typename Alloc , typename Tag >
BLAZE_ALWAYS_INLINE void blaze::DynamicMatrix< Type, SO, Alloc, Tag >::storea ( size_t  i,
size_t  j,
const SIMDType value 
)
noexcept

Aligned store of a SIMD element of the matrix.

Parameters
iAccess index for the row. The index has to be in the range [0..M-1].
jAccess index for the column. The index has to be in the range [0..N-1].
valueThe SIMD element to be stored.
Returns
void

This function performs an aligned store of a specific SIMD element of the dense matrix. The row index must be smaller than the number of rows and the column index must be smaller than the number of columns. Additionally, the column index (in case of a row-major matrix) or the row index (in case of a column-major matrix) must be a multiple of the number of values inside the SIMD element. This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors.

◆ storeu()

template<typename Type , bool SO, typename Alloc , typename Tag >
BLAZE_ALWAYS_INLINE void blaze::DynamicMatrix< Type, SO, Alloc, Tag >::storeu ( size_t  i,
size_t  j,
const SIMDType value 
)
noexcept

Unaligned store of a SIMD element of the matrix.

Parameters
iAccess index for the row. The index has to be in the range [0..M-1].
jAccess index for the column. The index has to be in the range [0..N-1].
valueThe SIMD element to be stored.
Returns
void

This function performs an unaligned store of a specific SIMD element of the dense matrix. The row index must be smaller than the number of rows and the column index must be smaller than the number of columns. Additionally, the column index (in case of a row-major matrix) or the row index (in case of a column-major matrix) must be a multiple of the number of values inside the SIMD element. This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors.

◆ stream()

template<typename Type , bool SO, typename Alloc , typename Tag >
BLAZE_ALWAYS_INLINE void blaze::DynamicMatrix< Type, SO, Alloc, Tag >::stream ( size_t  i,
size_t  j,
const SIMDType value 
)
noexcept

Aligned, non-temporal store of a SIMD element of the matrix.

Parameters
iAccess index for the row. The index has to be in the range [0..M-1].
jAccess index for the column. The index has to be in the range [0..N-1].
valueThe SIMD element to be stored.
Returns
void

This function performs an aligned, non-temporal store of a specific SIMD element of the dense matrix. The row index must be smaller than the number of rows and the column index must be smaller than the number of columns. Additionally, the column index (in case of a row-major matrix) or the row index (in case of a column-major matrix) must be a multiple of the number of values inside the SIMD element. This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors.

◆ subAssign() [1/4]

template<typename Type , bool SO, typename Alloc , typename Tag >
template<typename MT >
auto blaze::DynamicMatrix< Type, SO, Alloc, Tag >::subAssign ( const DenseMatrix< MT, SO > &  rhs) -> DisableIf_t< VectorizedSubAssign_v<MT> >
inline

Default implementation of the subtraction assignment of a row-major dense matrix.

SIMD optimized implementation of the subtraction assignment of a row-major dense matrix.

Parameters
rhsThe right-hand side dense matrix to be subtracted.
Returns
void

This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

◆ subAssign() [2/4]

template<typename Type , bool SO, typename Alloc , typename Tag >
template<typename MT >
void blaze::DynamicMatrix< Type, SO, Alloc, Tag >::subAssign ( const DenseMatrix< MT,!SO > &  rhs)
inline

Default implementation of the subtraction assignment of a column-major dense matrix.

Parameters
rhsThe right-hand side dense matrix to be subtracted.
Returns
void

This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

◆ subAssign() [3/4]

template<typename Type , bool SO, typename Alloc , typename Tag >
template<typename MT >
void blaze::DynamicMatrix< Type, SO, Alloc, Tag >::subAssign ( const SparseMatrix< MT, SO > &  rhs)
inline

Default implementation of the subtraction assignment of a row-major sparse matrix.

Parameters
rhsThe right-hand side sparse matrix to be subtracted.
Returns
void

This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

◆ subAssign() [4/4]

template<typename Type , bool SO, typename Alloc , typename Tag >
template<typename MT >
void blaze::DynamicMatrix< Type, SO, Alloc, Tag >::subAssign ( const SparseMatrix< MT,!SO > &  rhs)
inline

Default implementation of the subtraction assignment of a column-major sparse matrix.

Parameters
rhsThe right-hand side sparse matrix to be subtracted.
Returns
void

This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

◆ swap()

template<typename Type , bool SO, typename Alloc , typename Tag >
void blaze::DynamicMatrix< Type, SO, Alloc, Tag >::swap ( DynamicMatrix< Type, SO, Alloc, Tag > &  m)
inlinenoexcept

Swapping the contents of two matrices.

Parameters
mThe matrix to be swapped.
Returns
void

◆ transpose()

template<typename Type , bool SO, typename Alloc , typename Tag >
DynamicMatrix< Type, SO, Alloc, Tag > & blaze::DynamicMatrix< Type, SO, Alloc, Tag >::transpose
inline

In-place transpose of the matrix.

Returns
Reference to the transposed matrix.

Member Data Documentation

◆ simdEnabled

template<typename Type , bool SO, typename Alloc , typename Tag >
constexpr bool blaze::DynamicMatrix< Type, SO, Alloc, Tag >::simdEnabled = IsVectorizable_v<Type>
staticconstexpr

Compilation flag for SIMD optimization.

The simdEnabled compilation flag indicates whether expressions the matrix is involved in can be optimized via SIMD operations. In case the element type of the matrix is a vectorizable data type, the simdEnabled compilation flag is set to true, otherwise it is set to false.

◆ smpAssignable

template<typename Type , bool SO, typename Alloc , typename Tag >
constexpr bool blaze::DynamicMatrix< Type, SO, Alloc, Tag >::smpAssignable = !IsSMPAssignable_v<Type>
staticconstexpr

Compilation flag for SMP assignments.

The smpAssignable compilation flag indicates whether the matrix can be used in SMP (shared memory parallel) assignments (both on the left-hand and right-hand side of the assignment).

◆ v_

template<typename Type , bool SO, typename Alloc , typename Tag >
Type* BLAZE_RESTRICT blaze::DynamicMatrix< Type, SO, Alloc, Tag >::v_
private

The dynamically allocated matrix elements.

Access to the matrix elements is gained via the function call operator. In case of row-major order the memory layout of the elements is

\[\left(\begin{array}{*{5}{c}} 0 & 1 & 2 & \cdots & N-1 \\ N & N+1 & N+2 & \cdots & 2 \cdot N-1 \\ \vdots & \vdots & \vdots & \ddots & \vdots \\ M \cdot N-N & M \cdot N-N+1 & M \cdot N-N+2 & \cdots & M \cdot N-1 \\ \end{array}\right)\]

.


The documentation for this class was generated from the following file: