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>
45 #include <blaze/math/Exception.h>
47 #include <blaze/math/shims/Clear.h>
48 #include <blaze/math/shims/Reset.h>
52 #include <blaze/system/Inline.h>
53 #include <blaze/util/DisableIf.h>
54 #include <blaze/util/EnableIf.h>
55 #include <blaze/util/Types.h>
56 #include <blaze/util/Unused.h>
57 
58 
59 namespace blaze {
60 
61 //=================================================================================================
62 //
63 // CLASS DEFINITION
64 //
65 //=================================================================================================
66 
67 //*************************************************************************************************
75 template< typename PT // Type of the proxy
76  , typename MT > // Type of the dense matrix
77 class DenseMatrixProxy : public DenseMatrix< PT, IsColumnMajorMatrix<MT>::value >
78 {
79  public:
80  //**Type definitions****************************************************************************
93  //**********************************************************************************************
94 
95  //**Compilation flags***************************************************************************
97  enum : bool { simdEnabled = MT::simdEnabled };
98 
100  enum : 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  private:
148  //**Compile time checks*************************************************************************
152  //**********************************************************************************************
153 };
154 //*************************************************************************************************
155 
156 
157 
158 
159 //=================================================================================================
160 //
161 // DATA ACCESS FUNCTIONS
162 //
163 //=================================================================================================
164 
165 //*************************************************************************************************
173 template< typename PT // Type of the proxy
174  , typename MT > // Type of the dense matrix
176  DenseMatrixProxy<PT,MT>::operator()( size_t i, size_t j ) const
177 {
178  if( (~*this).isRestricted() ) {
179  BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
180  }
181 
182  return (~*this).get()(i,j);
183 }
184 //*************************************************************************************************
185 
186 
187 //*************************************************************************************************
199 template< typename PT // Type of the proxy
200  , typename MT > // Type of the dense matrix
202  DenseMatrixProxy<PT,MT>::at( size_t i, size_t j ) const
203 {
204  if( (~*this).isRestricted() ) {
205  BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
206  }
207 
208  return (~*this).get().at(i,j);
209 }
210 //*************************************************************************************************
211 
212 
213 //*************************************************************************************************
225 template< typename PT // Type of the proxy
226  , typename MT > // Type of the dense matrix
228 {
229  if( (~*this).isRestricted() ) {
230  BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
231  }
232 
233  return (~*this).get().data();
234 }
235 //*************************************************************************************************
236 
237 
238 //*************************************************************************************************
246 template< typename PT // Type of the proxy
247  , typename MT > // Type of the dense matrix
249 {
250  if( (~*this).isRestricted() ) {
251  BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
252  }
253 
254  return (~*this).get().data(i);
255 }
256 //*************************************************************************************************
257 
258 
259 //*************************************************************************************************
271 template< typename PT // Type of the proxy
272  , typename MT > // Type of the dense matrix
273 inline typename DenseMatrixProxy<PT,MT>::Iterator
275 {
276  if( (~*this).isRestricted() ) {
277  BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
278  }
279 
280  return (~*this).get().begin(i);
281 }
282 //*************************************************************************************************
283 
284 
285 //*************************************************************************************************
296 template< typename PT // Type of the proxy
297  , typename MT > // Type of the dense matrix
300 {
301  return (~*this).get().cbegin(i);
302 }
303 //*************************************************************************************************
304 
305 
306 //*************************************************************************************************
318 template< typename PT // Type of the proxy
319  , typename MT > // Type of the dense matrix
320 inline typename DenseMatrixProxy<PT,MT>::Iterator
322 {
323  if( (~*this).isRestricted() ) {
324  BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
325  }
326 
327  return (~*this).get().end(i);
328 }
329 //*************************************************************************************************
330 
331 
332 //*************************************************************************************************
343 template< typename PT // Type of the proxy
344  , typename MT > // Type of the dense matrix
347 {
348  return (~*this).get().cend(i);
349 }
350 //*************************************************************************************************
351 
352 
353 
354 
355 //=================================================================================================
356 //
357 // UTILITY FUNCTIONS
358 //
359 //=================================================================================================
360 
361 //*************************************************************************************************
366 template< typename PT // Type of the proxy
367  , typename MT > // Type of the dense matrix
368 inline size_t DenseMatrixProxy<PT,MT>::rows() const
369 {
370  return (~*this).get().rows();
371 }
372 //*************************************************************************************************
373 
374 
375 //*************************************************************************************************
380 template< typename PT // Type of the proxy
381  , typename MT > // Type of the dense matrix
382 inline size_t DenseMatrixProxy<PT,MT>::columns() const
383 {
384  return (~*this).get().columns();
385 }
386 //*************************************************************************************************
387 
388 
389 //*************************************************************************************************
399 template< typename PT // Type of the proxy
400  , typename MT > // Type of the dense matrix
401 inline size_t DenseMatrixProxy<PT,MT>::spacing() const
402 {
403  return (~*this).get().spacing();
404 }
405 //*************************************************************************************************
406 
407 
408 //*************************************************************************************************
413 template< typename PT // Type of the proxy
414  , typename MT > // Type of the dense matrix
416 {
417  return (~*this).get().capacity();
418 }
419 //*************************************************************************************************
420 
421 
422 //*************************************************************************************************
433 template< typename PT // Type of the proxy
434  , typename MT > // Type of the dense matrix
435 inline size_t DenseMatrixProxy<PT,MT>::capacity( size_t i ) const
436 {
437  return (~*this).get().capacity(i);
438 }
439 //*************************************************************************************************
440 
441 
442 //*************************************************************************************************
447 template< typename PT // Type of the proxy
448  , typename MT > // Type of the dense matrix
450 {
451  return (~*this).get().nonZeros();
452 }
453 //*************************************************************************************************
454 
455 
456 //*************************************************************************************************
467 template< typename PT // Type of the proxy
468  , typename MT > // Type of the dense matrix
469 inline size_t DenseMatrixProxy<PT,MT>::nonZeros( size_t i ) const
470 {
471  return (~*this).get().nonZeros(i);
472 }
473 //*************************************************************************************************
474 
475 
476 //*************************************************************************************************
483 template< typename PT // Type of the proxy
484  , typename MT > // Type of the dense matrix
486 {
487  using blaze::reset;
488 
489  reset( (~*this).get() );
490 }
491 //*************************************************************************************************
492 
493 
494 //*************************************************************************************************
505 template< typename PT // Type of the proxy
506  , typename MT > // Type of the dense matrix
507 inline void DenseMatrixProxy<PT,MT>::reset( size_t i ) const
508 {
509  using blaze::reset;
510 
511  reset( (~*this).get(), i );
512 }
513 //*************************************************************************************************
514 
515 
516 //*************************************************************************************************
523 template< typename PT // Type of the proxy
524  , typename MT > // Type of the dense matrix
526 {
527  using blaze::clear;
528 
529  clear( (~*this).get() );
530 }
531 //*************************************************************************************************
532 
533 
534 //*************************************************************************************************
551 template< typename PT // Type of the proxy
552  , typename MT > // Type of the dense matrix
553 inline void DenseMatrixProxy<PT,MT>::resize( size_t m, size_t n, bool preserve ) const
554 {
555  if( (~*this).isRestricted() ) {
556  BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
557  }
558 
559  (~*this).get().resize( m, n, preserve );
560 }
561 //*************************************************************************************************
562 
563 
564 //*************************************************************************************************
580 template< typename PT // Type of the proxy
581  , typename MT > // Type of the dense matrix
582 inline void DenseMatrixProxy<PT,MT>::extend( size_t m, size_t n, bool preserve ) const
583 {
584  if( (~*this).isRestricted() ) {
585  BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
586  }
587 
588  (~*this).get().extend( m, n, preserve );
589 }
590 //*************************************************************************************************
591 
592 
593 //*************************************************************************************************
603 template< typename PT // Type of the proxy
604  , typename MT > // Type of the dense matrix
605 inline void DenseMatrixProxy<PT,MT>::reserve( size_t n ) const
606 {
607  if( (~*this).isRestricted() ) {
608  BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
609  }
610 
611  (~*this).get().reserve( n );
612 }
613 //*************************************************************************************************
614 
615 
616 //*************************************************************************************************
622 template< typename PT // Type of the proxy
623  , typename MT > // Type of the dense matrix
625 {
626  if( (~*this).isRestricted() ) {
627  BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
628  }
629 
630  (~*this).get().transpose();
631 }
632 //*************************************************************************************************
633 
634 
635 //*************************************************************************************************
641 template< typename PT // Type of the proxy
642  , typename MT > // Type of the dense matrix
644 {
645  if( (~*this).isRestricted() ) {
646  BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
647  }
648 
649  (~*this).get().ctranspose();
650 }
651 //*************************************************************************************************
652 
653 
654 //*************************************************************************************************
661 template< typename PT // Type of the proxy
662  , typename MT > // Type of the dense matrix
663 template< typename Other > // Data type of the scalar value
664 inline void DenseMatrixProxy<PT,MT>::scale( const Other& scalar ) const
665 {
666  if( (~*this).isRestricted() ) {
667  BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
668  }
669 
670  (~*this).get().scale( scalar );
671 }
672 //*************************************************************************************************
673 
674 
675 
676 
677 //=================================================================================================
678 //
679 // GLOBAL FUNCTIONS
680 //
681 //=================================================================================================
682 
683 //*************************************************************************************************
686 template< typename PT, typename MT >
688  begin( const DenseMatrixProxy<PT,MT>& proxy, size_t i );
689 
690 template< typename PT, typename MT >
692  cbegin( const DenseMatrixProxy<PT,MT>& proxy, size_t i );
693 
694 template< typename PT, typename MT >
696  end( const DenseMatrixProxy<PT,MT>& proxy, size_t i );
697 
698 template< typename PT, typename MT >
700  cend( const DenseMatrixProxy<PT,MT>& proxy, size_t i );
701 
702 template< typename PT, typename MT >
703 BLAZE_ALWAYS_INLINE size_t rows( const DenseMatrixProxy<PT,MT>& proxy );
704 
705 template< typename PT, typename MT >
707 
708 template< typename PT, typename MT >
710 
711 template< typename PT, typename MT >
712 BLAZE_ALWAYS_INLINE size_t capacity( const DenseMatrixProxy<PT,MT>& proxy, size_t i );
713 
714 template< typename PT, typename MT >
716 
717 template< typename PT, typename MT >
718 BLAZE_ALWAYS_INLINE size_t nonZeros( const DenseMatrixProxy<PT,MT>& proxy, size_t i );
719 
720 template< typename PT, typename MT >
721 BLAZE_ALWAYS_INLINE void resize( const DenseMatrixProxy<PT,MT>& proxy, size_t m, size_t n, bool preserve=true );
722 
723 template< typename PT, typename MT >
725 
726 template< typename PT, typename MT >
727 BLAZE_ALWAYS_INLINE void reset( const DenseMatrixProxy<PT,MT>& proxy, size_t i );
728 
729 template< typename PT, typename MT >
732 //*************************************************************************************************
733 
734 
735 //*************************************************************************************************
748 template< typename PT // Type of the proxy
749  , typename MT > // Type of the dense matrix
751  begin( const DenseMatrixProxy<PT,MT>& proxy, size_t i )
752 {
753  return proxy.begin(i);
754 }
755 //*************************************************************************************************
756 
757 
758 //*************************************************************************************************
771 template< typename PT // Type of the proxy
772  , typename MT > // Type of the dense matrix
774  cbegin( const DenseMatrixProxy<PT,MT>& proxy, size_t i )
775 {
776  return proxy.cbegin(i);
777 }
778 //*************************************************************************************************
779 
780 
781 //*************************************************************************************************
795 template< typename PT // Type of the proxy
796  , typename MT > // Type of the dense matrix
798  end( const DenseMatrixProxy<PT,MT>& proxy, size_t i )
799 {
800  return proxy.end(i);
801 }
802 //*************************************************************************************************
803 
804 
805 //*************************************************************************************************
819 template< typename PT // Type of the proxy
820  , typename MT > // Type of the dense matrix
822  cend( const DenseMatrixProxy<PT,MT>& proxy, size_t i )
823 {
824  return proxy.cend(i);
825 }
826 //*************************************************************************************************
827 
828 
829 //*************************************************************************************************
836 template< typename PT // Type of the proxy
837  , typename MT > // Type of the dense matrix
839 {
840  return proxy.rows();
841 }
842 //*************************************************************************************************
843 
844 
845 //*************************************************************************************************
852 template< typename PT // Type of the proxy
853  , typename MT > // Type of the dense matrix
855 {
856  return proxy.columns();
857 }
858 //*************************************************************************************************
859 
860 
861 //*************************************************************************************************
868 template< typename PT // Type of the proxy
869  , typename MT > // Type of the dense matrix
871 {
872  return proxy.capacity();
873 }
874 //*************************************************************************************************
875 
876 
877 //*************************************************************************************************
890 template< typename PT // Type of the proxy
891  , typename MT > // Type of the dense matrix
892 BLAZE_ALWAYS_INLINE size_t capacity( const DenseMatrixProxy<PT,MT>& proxy, size_t i )
893 {
894  return proxy.capacity(i);
895 }
896 //*************************************************************************************************
897 
898 
899 //*************************************************************************************************
906 template< typename PT // Type of the proxy
907  , typename MT > // Type of the dense matrix
909 {
910  return proxy.nonZeros();
911 }
912 //*************************************************************************************************
913 
914 
915 //*************************************************************************************************
928 template< typename PT // Type of the proxy
929  , typename MT > // Type of the dense matrix
930 BLAZE_ALWAYS_INLINE size_t nonZeros( const DenseMatrixProxy<PT,MT>& proxy, size_t i )
931 {
932  return proxy.nonZeros(i);
933 }
934 //*************************************************************************************************
935 
936 
937 //*************************************************************************************************
954 template< typename PT // Type of the proxy
955  , typename MT > // Type of the dense matrix
957  resize_backend( const DenseMatrixProxy<PT,MT>& proxy, size_t m, size_t n, bool preserve )
958 {
959  UNUSED_PARAMETER( preserve );
960 
961  if( proxy.rows() != m || proxy.columns() != n ) {
962  BLAZE_THROW_INVALID_ARGUMENT( "Matrix cannot be resized" );
963  }
964 }
966 //*************************************************************************************************
967 
968 
969 //*************************************************************************************************
982 template< typename PT // Type of the proxy
983  , typename MT > // Type of the dense matrix
985  resize_backend( const DenseMatrixProxy<PT,MT>& proxy, size_t m, size_t n, bool preserve )
986 {
987  proxy.resize( m, n, preserve );
988 }
990 //*************************************************************************************************
991 
992 
993 //*************************************************************************************************
1007 template< typename PT // Type of the proxy
1008  , typename MT > // Type of the dense matrix
1009 BLAZE_ALWAYS_INLINE EnableIf_< And< IsResizable<MT>, IsSquare<MT> > >
1010  resize_backend( const DenseMatrixProxy<PT,MT>& proxy, size_t m, size_t n, bool preserve )
1011 {
1012  if( m != n ) {
1013  BLAZE_THROW_INVALID_ARGUMENT( "Invalid resize arguments for square matrix" );
1014  }
1015 
1016  proxy.resize( m, preserve );
1017 }
1019 //*************************************************************************************************
1020 
1021 
1022 //*************************************************************************************************
1047 template< typename PT // Type of the proxy
1048  , typename MT > // Type of the dense matrix
1049 BLAZE_ALWAYS_INLINE void resize( const DenseMatrixProxy<PT,MT>& proxy, size_t m, size_t n, bool preserve )
1050 {
1051  resize_backend( proxy, m, n, preserve );
1052 }
1053 //*************************************************************************************************
1054 
1055 
1056 //*************************************************************************************************
1065 template< typename PT // Type of the proxy
1066  , typename MT > // Type of the dense matrix
1068 {
1069  proxy.reset();
1070 }
1071 //*************************************************************************************************
1072 
1073 
1074 //*************************************************************************************************
1087 template< typename PT // Type of the proxy
1088  , typename MT > // Type of the dense matrix
1089 BLAZE_ALWAYS_INLINE void reset( const DenseMatrixProxy<PT,MT>& proxy, size_t i )
1090 {
1091  proxy.reset(i);
1092 }
1093 //*************************************************************************************************
1094 
1095 
1096 //*************************************************************************************************
1105 template< typename PT // Type of the proxy
1106  , typename MT > // Type of the dense matrix
1108 {
1109  proxy.clear();
1110 }
1111 //*************************************************************************************************
1112 
1113 } // namespace blaze
1114 
1115 #endif
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.This macro encapsulates the default way o...
Definition: Exception.h:235
Header file for auxiliary alias declarations.
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:321
Header file for the UNUSED_PARAMETER function template.
Header file for basic type definitions.
CompositeType_< MT > CompositeType
Data type for composite expression templates.
Definition: DenseMatrixProxy.h:86
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a dense, N-dimensional matrix type...
Definition: DenseMatrix.h:61
Header file for the IsColumnMajorMatrix type trait.
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:533
typename DisableIf< Condition, T >::Type DisableIf_
Auxiliary type for the DisableIf class template.The DisableIf_ alias declaration provides a convenien...
Definition: DisableIf.h:223
void scale(const Other &scalar) const
Scaling of the matrix by the scalar value scalar ( ).
Definition: DenseMatrixProxy.h:664
Reference operator()(size_t i, size_t j) const
Function call operator for the direct access to matrix elements.
Definition: DenseMatrixProxy.h:176
ReturnType_< MT > ReturnType
Return type for expression template evaluations.
Definition: DenseMatrixProxy.h:85
ResultType_< MT > ResultType
Result type for expression template evaluations.
Definition: DenseMatrixProxy.h:81
Pointer_< MT > Pointer
Pointer to a non-constant matrix value.
Definition: DenseMatrixProxy.h:89
void reset() const
Reset to the default initial value.
Definition: DenseMatrixProxy.h:485
typename T::ResultType ResultType_
Alias declaration for nested ResultType type definitions.The ResultType_ alias declaration provides a...
Definition: Aliases.h:323
Proxy backend for dense matrix types.The DenseMatrixProxy class serves as a backend for the Proxy cla...
Definition: DenseMatrixProxy.h:77
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:71
typename T::ReturnType ReturnType_
Alias declaration for nested ReturnType type definitions.The ReturnType_ alias declaration provides a...
Definition: Aliases.h:343
OppositeType_< MT > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DenseMatrixProxy.h:82
Header file for the IsSquare type trait.
Constraint on the data type.
typename T::CompositeType CompositeType_
Alias declaration for nested CompositeType type definitions.The CompositeType_ alias declaration prov...
Definition: Aliases.h:83
Iterator_< MT > Iterator
Iterator over non-constant elements.
Definition: DenseMatrixProxy.h:91
Header file for the DisableIf class template.
Pointer data() const
Low-level data access to matrix elements.
Definition: DenseMatrixProxy.h:227
typename T::Pointer Pointer_
Alias declaration for nested Pointer type definitions.The Pointer_ alias declaration provides a conve...
Definition: Aliases.h:263
Header file for the clear shim.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
#define BLAZE_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition: Inline.h:85
void transpose() const
In-place transpose of the represented matrix.
Definition: DenseMatrixProxy.h:624
size_t columns() const
Returns the current number of columns of the represented matrix.
Definition: DenseMatrixProxy.h:382
ElementType_< MT > ElementType
Type of the matrix elements.
Definition: DenseMatrixProxy.h:84
size_t rows() const
Returns the current number of rows of the represented matrix.
Definition: DenseMatrixProxy.h:368
Header file for the DenseMatrix base class.
TransposeType_< MT > TransposeType
Transpose type for expression template evaluations.
Definition: DenseMatrixProxy.h:83
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
Compile time check for square matrices.This type trait tests whether or not the given template parame...
Definition: IsSquare.h:88
ConstReference_< MT > ConstReference
Reference to a constant matrix value.
Definition: DenseMatrixProxy.h:88
ConstIterator cbegin(size_t i) const
Returns an iterator to the first element of row/column i of the represented matrix.
Definition: DenseMatrixProxy.h:299
Iterator begin(size_t i) const
Returns an iterator to the first element of row/column i of the represented matrix.
Definition: DenseMatrixProxy.h:274
Header file for the exception macros of the math module.
typename T::Reference Reference_
Alias declaration for nested Reference type definitions.The Reference_ alias declaration provides a c...
Definition: Aliases.h:283
Header file for the EnableIf class template.
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:553
void extend(size_t m, size_t n, bool preserve=true) const
Extending the size of the represented matrix.
Definition: DenseMatrixProxy.h:582
ConstIterator_< MT > ConstIterator
Iterator over constant elements.
Definition: DenseMatrixProxy.h:92
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:346
Reference_< MT > Reference
Reference to a non-constant matrix value.
Definition: DenseMatrixProxy.h:87
void clear() const
Clearing the represented matrix.
Definition: DenseMatrixProxy.h:525
Header file for the reset shim.
Compile time type negation.The Not class template negates the given compile time condition. In case the given condition would evaluate to true, the nested member enumeration is set to false and vice versa:
Definition: Not.h:70
size_t spacing() const
Returns the spacing between the beginning of two rows/columns of the represented matrix.
Definition: DenseMatrixProxy.h:401
typename EnableIf< Condition, T >::Type EnableIf_
Auxiliary alias declaration for the EnableIf class template.The EnableIf_ alias declaration provides ...
Definition: EnableIf.h:223
typename T::OppositeType OppositeType_
Alias declaration for nested OppositeType type definitions.The OppositeType_ alias declaration provid...
Definition: Aliases.h:243
typename T::Iterator Iterator_
Alias declaration for nested Iterator type definitions.The Iterator_ alias declaration provides a con...
Definition: Aliases.h:183
size_t capacity() const
Returns the maximum capacity of the represented matrix.
Definition: DenseMatrixProxy.h:415
typename T::ConstPointer ConstPointer_
Alias declaration for nested ConstPointer type definitions.The ConstPointer_ alias declaration provid...
Definition: Aliases.h:123
typename T::ConstReference ConstReference_
Alias declaration for nested ConstReference type definitions.The ConstReference_ alias declaration pr...
Definition: Aliases.h:143
typename T::ConstIterator ConstIterator_
Alias declaration for nested ConstIterator type definitions.The ConstIterator_ alias declaration prov...
Definition: Aliases.h:103
ConstPointer_< MT > ConstPointer
Pointer to a constant matrix value.
Definition: DenseMatrixProxy.h:90
void resize(size_t m, size_t n, bool preserve=true) const
Changing the size of the represented matrix.
Definition: DenseMatrixProxy.h:553
void ctranspose() const
In-place conjugate transpose of the represented matrix.
Definition: DenseMatrixProxy.h:643
typename T::TransposeType TransposeType_
Alias declaration for nested TransposeType type definitions.The TransposeType_ alias declaration prov...
Definition: Aliases.h:403
void UNUSED_PARAMETER(const Args &...)
Suppression of unused parameter warnings.
Definition: Unused.h:81
void reserve(size_t n) const
Setting the minimum capacity of the represented matrix.
Definition: DenseMatrixProxy.h:605
Header file for the IsResizable type trait.
Reference at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: DenseMatrixProxy.h:202
System settings for the inline keywords.
size_t nonZeros() const
Returns the number of non-zero elements in the represented matrix.
Definition: DenseMatrixProxy.h:449