Blaze 3.9
DenseMatrixProxy.h
Go to the documentation of this file.
1//=================================================================================================
33//=================================================================================================
34
35#ifndef _BLAZE_MATH_PROXY_DENSEMATRIXPROXY_H_
36#define _BLAZE_MATH_PROXY_DENSEMATRIXPROXY_H_
37
38
39//*************************************************************************************************
40// Includes
41//*************************************************************************************************
42
43#include <blaze/math/Aliases.h>
52#include <blaze/system/Inline.h>
53#include <blaze/util/EnableIf.h>
55#include <blaze/util/Types.h>
56
57
58namespace blaze {
59
60//=================================================================================================
61//
62// CLASS DEFINITION
63//
64//=================================================================================================
65
66//*************************************************************************************************
74template< typename PT // Type of the proxy
75 , typename MT > // Type of the dense matrix
77 : public DenseMatrix< PT, IsColumnMajorMatrix_v<MT> >
78{
79 public:
80 //**Type definitions****************************************************************************
93 //**********************************************************************************************
94
95 //**Compilation flags***************************************************************************
97 static constexpr bool simdEnabled = MT::simdEnabled;
98
100 static constexpr bool smpAssignable = MT::smpAssignable;
101 //**********************************************************************************************
102
103 //**Data access functions***********************************************************************
106 inline Reference operator()( size_t i, size_t j ) const;
107 inline Reference at( size_t i, size_t j ) const;
108
109 inline Pointer data () const;
110 inline Pointer data ( size_t i ) const;
111 inline Iterator begin ( size_t i ) const;
112 inline ConstIterator cbegin( size_t i ) const;
113 inline Iterator end ( size_t i ) const;
114 inline ConstIterator cend ( size_t i ) const;
116 //**********************************************************************************************
117
118 //**Utility functions***************************************************************************
121 inline size_t rows() const;
122 inline size_t columns() const;
123 inline size_t spacing() const;
124 inline size_t capacity() const;
125 inline size_t capacity( size_t i ) const;
126 inline size_t nonZeros() const;
127 inline size_t nonZeros( size_t i ) const;
128 inline void reset() const;
129 inline void reset( size_t i ) const;
130 inline void clear() const;
131 inline void resize( size_t m, size_t n, bool preserve=true ) const;
132 inline void extend( size_t m, size_t n, bool preserve=true ) const;
133 inline void reserve( size_t n ) const;
135 //**********************************************************************************************
136
137 //**Numeric functions***************************************************************************
140 inline void transpose() const;
141 inline void ctranspose() const;
142
143 template< typename Other > inline void scale( const Other& scalar ) const;
145 //**********************************************************************************************
146
147 protected:
148 //**Special member functions********************************************************************
151 DenseMatrixProxy() = default;
152 DenseMatrixProxy( const DenseMatrixProxy& ) = default;
153 DenseMatrixProxy( DenseMatrixProxy&& ) = default;
154 ~DenseMatrixProxy() = default;
155 DenseMatrixProxy& operator=( const DenseMatrixProxy& ) = default;
156 DenseMatrixProxy& operator=( DenseMatrixProxy&& ) = default;
158 //**********************************************************************************************
159
160 private:
161 //**Compile time checks*************************************************************************
165 //**********************************************************************************************
166};
167//*************************************************************************************************
168
169
170
171
172//=================================================================================================
173//
174// DATA ACCESS FUNCTIONS
175//
176//=================================================================================================
177
178//*************************************************************************************************
186template< typename PT // Type of the proxy
187 , typename MT > // Type of the dense matrix
189 DenseMatrixProxy<PT,MT>::operator()( size_t i, size_t j ) const
190{
191 if( (**this).isRestricted() ) {
192 BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
193 }
194
195 return (**this).get()(i,j);
196}
197//*************************************************************************************************
198
199
200//*************************************************************************************************
212template< typename PT // Type of the proxy
213 , typename MT > // Type of the dense matrix
215 DenseMatrixProxy<PT,MT>::at( size_t i, size_t j ) const
216{
217 if( (**this).isRestricted() ) {
218 BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
219 }
220
221 return (**this).get().at(i,j);
222}
223//*************************************************************************************************
224
225
226//*************************************************************************************************
238template< typename PT // Type of the proxy
239 , typename MT > // Type of the dense matrix
241{
242 if( (**this).isRestricted() ) {
243 BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
244 }
245
246 return (**this).get().data();
247}
248//*************************************************************************************************
249
250
251//*************************************************************************************************
259template< typename PT // Type of the proxy
260 , typename MT > // Type of the dense matrix
262{
263 if( (**this).isRestricted() ) {
264 BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
265 }
266
267 return (**this).get().data(i);
268}
269//*************************************************************************************************
270
271
272//*************************************************************************************************
284template< typename PT // Type of the proxy
285 , typename MT > // Type of the dense matrix
288{
289 if( (**this).isRestricted() ) {
290 BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
291 }
292
293 return (**this).get().begin(i);
294}
295//*************************************************************************************************
296
297
298//*************************************************************************************************
309template< typename PT // Type of the proxy
310 , typename MT > // Type of the dense matrix
313{
314 return (**this).get().cbegin(i);
315}
316//*************************************************************************************************
317
318
319//*************************************************************************************************
331template< typename PT // Type of the proxy
332 , typename MT > // Type of the dense matrix
335{
336 if( (**this).isRestricted() ) {
337 BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
338 }
339
340 return (**this).get().end(i);
341}
342//*************************************************************************************************
343
344
345//*************************************************************************************************
356template< typename PT // Type of the proxy
357 , typename MT > // Type of the dense matrix
360{
361 return (**this).get().cend(i);
362}
363//*************************************************************************************************
364
365
366
367
368//=================================================================================================
369//
370// UTILITY FUNCTIONS
371//
372//=================================================================================================
373
374//*************************************************************************************************
379template< typename PT // Type of the proxy
380 , typename MT > // Type of the dense matrix
381inline size_t DenseMatrixProxy<PT,MT>::rows() const
382{
383 return (**this).get().rows();
384}
385//*************************************************************************************************
386
387
388//*************************************************************************************************
393template< typename PT // Type of the proxy
394 , typename MT > // Type of the dense matrix
396{
397 return (**this).get().columns();
398}
399//*************************************************************************************************
400
401
402//*************************************************************************************************
412template< typename PT // Type of the proxy
413 , typename MT > // Type of the dense matrix
415{
416 return (**this).get().spacing();
417}
418//*************************************************************************************************
419
420
421//*************************************************************************************************
426template< typename PT // Type of the proxy
427 , typename MT > // Type of the dense matrix
429{
430 return (**this).get().capacity();
431}
432//*************************************************************************************************
433
434
435//*************************************************************************************************
446template< typename PT // Type of the proxy
447 , typename MT > // Type of the dense matrix
448inline size_t DenseMatrixProxy<PT,MT>::capacity( size_t i ) const
449{
450 return (**this).get().capacity(i);
451}
452//*************************************************************************************************
453
454
455//*************************************************************************************************
460template< typename PT // Type of the proxy
461 , typename MT > // Type of the dense matrix
463{
464 return (**this).get().nonZeros();
465}
466//*************************************************************************************************
467
468
469//*************************************************************************************************
480template< typename PT // Type of the proxy
481 , typename MT > // Type of the dense matrix
482inline size_t DenseMatrixProxy<PT,MT>::nonZeros( size_t i ) const
483{
484 return (**this).get().nonZeros(i);
485}
486//*************************************************************************************************
487
488
489//*************************************************************************************************
496template< typename PT // Type of the proxy
497 , typename MT > // Type of the dense matrix
499{
500 using blaze::reset;
501
502 reset( (**this).get() );
503}
504//*************************************************************************************************
505
506
507//*************************************************************************************************
518template< typename PT // Type of the proxy
519 , typename MT > // Type of the dense matrix
520inline void DenseMatrixProxy<PT,MT>::reset( size_t i ) const
521{
522 using blaze::reset;
523
524 reset( (**this).get(), i );
525}
526//*************************************************************************************************
527
528
529//*************************************************************************************************
536template< typename PT // Type of the proxy
537 , typename MT > // Type of the dense matrix
539{
540 using blaze::clear;
541
542 clear( (**this).get() );
543}
544//*************************************************************************************************
545
546
547//*************************************************************************************************
564template< typename PT // Type of the proxy
565 , typename MT > // Type of the dense matrix
566inline void DenseMatrixProxy<PT,MT>::resize( size_t m, size_t n, bool preserve ) const
567{
568 if( (**this).isRestricted() ) {
569 BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
570 }
571
572 (**this).get().resize( m, n, preserve );
573}
574//*************************************************************************************************
575
576
577//*************************************************************************************************
593template< typename PT // Type of the proxy
594 , typename MT > // Type of the dense matrix
595inline void DenseMatrixProxy<PT,MT>::extend( size_t m, size_t n, bool preserve ) const
596{
597 if( (**this).isRestricted() ) {
598 BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
599 }
600
601 (**this).get().extend( m, n, preserve );
602}
603//*************************************************************************************************
604
605
606//*************************************************************************************************
616template< typename PT // Type of the proxy
617 , typename MT > // Type of the dense matrix
618inline void DenseMatrixProxy<PT,MT>::reserve( size_t n ) const
619{
620 if( (**this).isRestricted() ) {
621 BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
622 }
623
624 (**this).get().reserve( n );
625}
626//*************************************************************************************************
627
628
629//*************************************************************************************************
635template< typename PT // Type of the proxy
636 , typename MT > // Type of the dense matrix
638{
639 if( (**this).isRestricted() ) {
640 BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
641 }
642
643 (**this).get().transpose();
644}
645//*************************************************************************************************
646
647
648//*************************************************************************************************
654template< typename PT // Type of the proxy
655 , typename MT > // Type of the dense matrix
657{
658 if( (**this).isRestricted() ) {
659 BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
660 }
661
662 (**this).get().ctranspose();
663}
664//*************************************************************************************************
665
666
667//*************************************************************************************************
678template< typename PT // Type of the proxy
679 , typename MT > // Type of the dense matrix
680template< typename Other > // Data type of the scalar value
681inline void DenseMatrixProxy<PT,MT>::scale( const Other& scalar ) const
682{
683 if( (**this).isRestricted() ) {
684 BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
685 }
686
687 (**this).get().scale( scalar );
688}
689//*************************************************************************************************
690
691
692
693
694//=================================================================================================
695//
696// GLOBAL FUNCTIONS
697//
698//=================================================================================================
699
700//*************************************************************************************************
703template< typename PT, typename MT >
705 begin( const DenseMatrixProxy<PT,MT>& proxy, size_t i );
706
707template< typename PT, typename MT >
709 cbegin( const DenseMatrixProxy<PT,MT>& proxy, size_t i );
710
711template< typename PT, typename MT >
713 end( const DenseMatrixProxy<PT,MT>& proxy, size_t i );
714
715template< typename PT, typename MT >
717 cend( const DenseMatrixProxy<PT,MT>& proxy, size_t i );
718
719template< typename PT, typename MT >
720size_t rows( const DenseMatrixProxy<PT,MT>& proxy );
721
722template< typename PT, typename MT >
723size_t columns( const DenseMatrixProxy<PT,MT>& proxy );
724
725template< typename PT, typename MT >
726size_t capacity( const DenseMatrixProxy<PT,MT>& proxy );
727
728template< typename PT, typename MT >
729size_t capacity( const DenseMatrixProxy<PT,MT>& proxy, size_t i );
730
731template< typename PT, typename MT >
732size_t nonZeros( const DenseMatrixProxy<PT,MT>& proxy );
733
734template< typename PT, typename MT >
735size_t nonZeros( const DenseMatrixProxy<PT,MT>& proxy, size_t i );
736
737template< typename PT, typename MT >
738void resize( const DenseMatrixProxy<PT,MT>& proxy, size_t m, size_t n, bool preserve=true );
740//*************************************************************************************************
741
742
743//*************************************************************************************************
756template< typename PT // Type of the proxy
757 , typename MT > // Type of the dense matrix
759 begin( const DenseMatrixProxy<PT,MT>& proxy, size_t i )
760{
761 return proxy.begin(i);
762}
763//*************************************************************************************************
764
765
766//*************************************************************************************************
779template< typename PT // Type of the proxy
780 , typename MT > // Type of the dense matrix
782 cbegin( const DenseMatrixProxy<PT,MT>& proxy, size_t i )
783{
784 return proxy.cbegin(i);
785}
786//*************************************************************************************************
787
788
789//*************************************************************************************************
803template< typename PT // Type of the proxy
804 , typename MT > // Type of the dense matrix
806 end( const DenseMatrixProxy<PT,MT>& proxy, size_t i )
807{
808 return proxy.end(i);
809}
810//*************************************************************************************************
811
812
813//*************************************************************************************************
827template< typename PT // Type of the proxy
828 , typename MT > // Type of the dense matrix
830 cend( const DenseMatrixProxy<PT,MT>& proxy, size_t i )
831{
832 return proxy.cend(i);
833}
834//*************************************************************************************************
835
836
837//*************************************************************************************************
844template< typename PT // Type of the proxy
845 , typename MT > // Type of the dense matrix
847{
848 return proxy.rows();
849}
850//*************************************************************************************************
851
852
853//*************************************************************************************************
860template< typename PT // Type of the proxy
861 , typename MT > // Type of the dense matrix
863{
864 return proxy.columns();
865}
866//*************************************************************************************************
867
868
869//*************************************************************************************************
876template< typename PT // Type of the proxy
877 , typename MT > // Type of the dense matrix
879{
880 return proxy.capacity();
881}
882//*************************************************************************************************
883
884
885//*************************************************************************************************
898template< typename PT // Type of the proxy
899 , typename MT > // Type of the dense matrix
901{
902 return proxy.capacity(i);
903}
904//*************************************************************************************************
905
906
907//*************************************************************************************************
914template< typename PT // Type of the proxy
915 , typename MT > // Type of the dense matrix
917{
918 return proxy.nonZeros();
919}
920//*************************************************************************************************
921
922
923//*************************************************************************************************
936template< typename PT // Type of the proxy
937 , typename MT > // Type of the dense matrix
939{
940 return proxy.nonZeros(i);
941}
942//*************************************************************************************************
943
944
945//*************************************************************************************************
962template< typename PT // Type of the proxy
963 , typename MT > // Type of the dense matrix
964BLAZE_ALWAYS_INLINE DisableIf_t< IsResizable_v<MT> >
965 resize_backend( const DenseMatrixProxy<PT,MT>& proxy, size_t m, size_t n, bool preserve )
966{
967 MAYBE_UNUSED( preserve );
968
969 if( proxy.rows() != m || proxy.columns() != n ) {
970 BLAZE_THROW_INVALID_ARGUMENT( "Matrix cannot be resized" );
971 }
972}
974//*************************************************************************************************
975
976
977//*************************************************************************************************
990template< typename PT // Type of the proxy
991 , typename MT > // Type of the dense matrix
992BLAZE_ALWAYS_INLINE EnableIf_t< IsResizable_v<MT> && !IsSquare_v<MT> >
993 resize_backend( const DenseMatrixProxy<PT,MT>& proxy, size_t m, size_t n, bool preserve )
994{
995 proxy.resize( m, n, preserve );
996}
998//*************************************************************************************************
999
1000
1001//*************************************************************************************************
1015template< typename PT // Type of the proxy
1016 , typename MT > // Type of the dense matrix
1017BLAZE_ALWAYS_INLINE EnableIf_t< IsResizable_v<MT> && IsSquare_v<MT> >
1018 resize_backend( const DenseMatrixProxy<PT,MT>& proxy, size_t m, size_t n, bool preserve )
1019{
1020 if( m != n ) {
1021 BLAZE_THROW_INVALID_ARGUMENT( "Invalid resize arguments for square matrix" );
1022 }
1023
1024 proxy.resize( m, preserve );
1025}
1027//*************************************************************************************************
1028
1029
1030//*************************************************************************************************
1055template< typename PT // Type of the proxy
1056 , typename MT > // Type of the dense matrix
1057BLAZE_ALWAYS_INLINE void resize( const DenseMatrixProxy<PT,MT>& proxy, size_t m, size_t n, bool preserve )
1058{
1059 resize_backend( proxy, m, n, preserve );
1060}
1061//*************************************************************************************************
1062
1063} // namespace blaze
1064
1065#endif
Header file for auxiliary alias declarations.
typename T::ConstReference ConstReference_t
Alias declaration for nested ConstReference type definitions.
Definition: Aliases.h:170
typename T::CompositeType CompositeType_t
Alias declaration for nested CompositeType type definitions.
Definition: Aliases.h:110
typename T::Pointer Pointer_t
Alias declaration for nested Pointer type definitions.
Definition: Aliases.h:330
typename T::ReturnType ReturnType_t
Alias declaration for nested ReturnType type definitions.
Definition: Aliases.h:470
typename T::ResultType ResultType_t
Alias declaration for nested ResultType type definitions.
Definition: Aliases.h:450
typename T::ElementType ElementType_t
Alias declaration for nested ElementType type definitions.
Definition: Aliases.h:190
typename T::Iterator Iterator_t
Alias declaration for nested Iterator type definitions.
Definition: Aliases.h:210
typename T::OppositeType OppositeType_t
Alias declaration for nested OppositeType type definitions.
Definition: Aliases.h:310
typename T::ConstIterator ConstIterator_t
Alias declaration for nested ConstIterator type definitions.
Definition: Aliases.h:130
typename T::Reference Reference_t
Alias declaration for nested Reference type definitions.
Definition: Aliases.h:390
typename T::TransposeType TransposeType_t
Alias declaration for nested TransposeType type definitions.
Definition: Aliases.h:550
typename T::ConstPointer ConstPointer_t
Alias declaration for nested ConstPointer type definitions.
Definition: Aliases.h:150
Header file for the EnableIf class template.
Header file for the IsColumnMajorMatrix type trait.
Header file for the IsResizable type trait.
Header file for the IsSquare type trait.
Header file for the MAYBE_UNUSED function template.
Proxy backend for dense matrix types.
Definition: DenseMatrixProxy.h:78
ElementType_t< MT > ElementType
Type of the matrix elements.
Definition: DenseMatrixProxy.h:84
void clear() const
Clearing the represented matrix.
Definition: DenseMatrixProxy.h:538
size_t columns() const
Returns the current number of columns of the represented matrix.
Definition: DenseMatrixProxy.h:395
Iterator end(size_t i) const
Returns an iterator just past the last element of row/column i of the represented matrix.
Definition: DenseMatrixProxy.h:334
TransposeType_t< MT > TransposeType
Transpose type for expression template evaluations.
Definition: DenseMatrixProxy.h:83
ResultType_t< MT > ResultType
Result type for expression template evaluations.
Definition: DenseMatrixProxy.h:81
void reset() const
Reset to the default initial value.
Definition: DenseMatrixProxy.h:498
void extend(size_t m, size_t n, bool preserve=true) const
Extending the size of the represented matrix.
Definition: DenseMatrixProxy.h:595
Pointer data() const
Low-level data access to matrix elements.
Definition: DenseMatrixProxy.h:240
size_t rows() const
Returns the current number of rows of the represented matrix.
Definition: DenseMatrixProxy.h:381
Pointer_t< MT > Pointer
Pointer to a non-constant matrix value.
Definition: DenseMatrixProxy.h:89
void reserve(size_t n) const
Setting the minimum capacity of the represented matrix.
Definition: DenseMatrixProxy.h:618
Reference_t< MT > Reference
Reference to a non-constant matrix value.
Definition: DenseMatrixProxy.h:87
static constexpr bool simdEnabled
Compilation flag for SIMD optimization.
Definition: DenseMatrixProxy.h:97
Reference at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: DenseMatrixProxy.h:215
void transpose() const
In-place transpose of the represented matrix.
Definition: DenseMatrixProxy.h:637
ConstIterator cend(size_t i) const
Returns an iterator just past the last element of row/column i of the represented matrix.
Definition: DenseMatrixProxy.h:359
static constexpr bool smpAssignable
Compilation flag for SMP assignments.
Definition: DenseMatrixProxy.h:100
size_t spacing() const
Returns the spacing between the beginning of two rows/columns of the represented matrix.
Definition: DenseMatrixProxy.h:414
Iterator begin(size_t i) const
Returns an iterator to the first element of row/column i of the represented matrix.
Definition: DenseMatrixProxy.h:287
ConstIterator_t< MT > ConstIterator
Iterator over constant elements.
Definition: DenseMatrixProxy.h:92
CompositeType_t< MT > CompositeType
Data type for composite expression templates.
Definition: DenseMatrixProxy.h:86
Reference operator()(size_t i, size_t j) const
Function call operator for the direct access to matrix elements.
Definition: DenseMatrixProxy.h:189
Iterator_t< MT > Iterator
Iterator over non-constant elements.
Definition: DenseMatrixProxy.h:91
ConstPointer_t< MT > ConstPointer
Pointer to a constant matrix value.
Definition: DenseMatrixProxy.h:90
void scale(const Other &scalar) const
Scaling of the matrix by the scalar value scalar ( ).
Definition: DenseMatrixProxy.h:681
void resize(size_t m, size_t n, bool preserve=true) const
Changing the size of the represented matrix.
Definition: DenseMatrixProxy.h:566
size_t nonZeros() const
Returns the number of non-zero elements in the represented matrix.
Definition: DenseMatrixProxy.h:462
size_t capacity() const
Returns the maximum capacity of the represented matrix.
Definition: DenseMatrixProxy.h:428
ReturnType_t< MT > ReturnType
Return type for expression template evaluations.
Definition: DenseMatrixProxy.h:85
ConstReference_t< MT > ConstReference
Reference to a constant matrix value.
Definition: DenseMatrixProxy.h:88
void ctranspose() const
In-place conjugate transpose of the represented matrix.
Definition: DenseMatrixProxy.h:656
OppositeType_t< MT > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DenseMatrixProxy.h:82
ConstIterator cbegin(size_t i) const
Returns an iterator to the first element of row/column i of the represented matrix.
Definition: DenseMatrixProxy.h:312
Base class for dense matrices.
Definition: DenseMatrix.h:82
Constraint on the data type.
Header file for the DenseMatrix base class.
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_MATRIX_TYPE(T)
Constraint on the data type.
Definition: DenseMatrix.h:61
BLAZE_ALWAYS_INLINE void resize(const DenseMatrixProxy< PT, MT > &proxy, size_t m, size_t n, bool preserve)
Changing the size of the represented matrix.
Definition: DenseMatrixProxy.h:1057
BLAZE_ALWAYS_INLINE DenseMatrixProxy< PT, MT >::Iterator begin(const DenseMatrixProxy< PT, MT > &proxy, size_t i)
Returns an iterator to the first element of row/column i of the represented matrix.
Definition: DenseMatrixProxy.h:759
BLAZE_ALWAYS_INLINE size_t rows(const DenseMatrixProxy< PT, MT > &proxy)
Returns the current number of rows of the represented matrix.
Definition: DenseMatrixProxy.h:846
BLAZE_ALWAYS_INLINE DenseMatrixProxy< PT, MT >::ConstIterator cbegin(const DenseMatrixProxy< PT, MT > &proxy, size_t i)
Returns an iterator to the first element of row/column i of the represented matrix.
Definition: DenseMatrixProxy.h:782
BLAZE_ALWAYS_INLINE DenseMatrixProxy< PT, MT >::Iterator end(const DenseMatrixProxy< PT, MT > &proxy, size_t i)
Returns an iterator just past the last element of row/column i of the represented matrix.
Definition: DenseMatrixProxy.h:806
BLAZE_ALWAYS_INLINE DenseMatrixProxy< PT, MT >::ConstIterator cend(const DenseMatrixProxy< PT, MT > &proxy, size_t i)
Returns an iterator just past the last element of row/column i of the represented matrix.
Definition: DenseMatrixProxy.h:830
BLAZE_ALWAYS_INLINE size_t capacity(const DenseMatrixProxy< PT, MT > &proxy, size_t i)
Returns the current capacity of the specified row/column of the represented matrix.
Definition: DenseMatrixProxy.h:900
BLAZE_ALWAYS_INLINE size_t nonZeros(const DenseMatrixProxy< PT, MT > &proxy, size_t i)
Returns the number of non-zero elements in the specified row/column of the represented matrix.
Definition: DenseMatrixProxy.h:938
BLAZE_ALWAYS_INLINE size_t columns(const DenseMatrixProxy< PT, MT > &proxy)
Returns the current number of columns of the represented matrix.
Definition: DenseMatrixProxy.h:862
constexpr void clear(Matrix< MT, SO > &matrix)
Clearing the given matrix.
Definition: Matrix.h:960
constexpr void reset(Matrix< MT, SO > &matrix)
Resetting the given matrix.
Definition: Matrix.h:806
#define BLAZE_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition: Inline.h:85
constexpr void MAYBE_UNUSED(const Args &...)
Suppression of unused parameter warnings.
Definition: MaybeUnused.h:81
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.
Definition: Exception.h:235
Header file for the exception macros of the math module.
Header file for the clear shim.
Header file for the reset shim.
System settings for the inline keywords.
Header file for basic type definitions.