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/mpl/And.h>
56 #include <blaze/util/mpl/Not.h>
57 #include <blaze/util/Types.h>
58 #include <blaze/util/Unused.h>
59 
60 
61 namespace blaze {
62 
63 //=================================================================================================
64 //
65 // CLASS DEFINITION
66 //
67 //=================================================================================================
68 
69 //*************************************************************************************************
77 template< typename PT // Type of the proxy
78  , typename MT > // Type of the dense matrix
80  : public DenseMatrix< PT, IsColumnMajorMatrix<MT>::value >
81 {
82  public:
83  //**Type definitions****************************************************************************
96  //**********************************************************************************************
97 
98  //**Compilation flags***************************************************************************
100  enum : bool { simdEnabled = MT::simdEnabled };
101 
103  enum : bool { smpAssignable = MT::smpAssignable };
104  //**********************************************************************************************
105 
106  //**Data access functions***********************************************************************
109  inline Reference operator()( size_t i, size_t j ) const;
110  inline Reference at( size_t i, size_t j ) const;
111 
112  inline Pointer data () const;
113  inline Pointer data ( size_t i ) const;
114  inline Iterator begin ( size_t i ) const;
115  inline ConstIterator cbegin( size_t i ) const;
116  inline Iterator end ( size_t i ) const;
117  inline ConstIterator cend ( size_t i ) const;
119  //**********************************************************************************************
120 
121  //**Utility functions***************************************************************************
124  inline size_t rows() const;
125  inline size_t columns() const;
126  inline size_t spacing() const;
127  inline size_t capacity() const;
128  inline size_t capacity( size_t i ) const;
129  inline size_t nonZeros() const;
130  inline size_t nonZeros( size_t i ) const;
131  inline void reset() const;
132  inline void reset( size_t i ) const;
133  inline void clear() const;
134  inline void resize( size_t m, size_t n, bool preserve=true ) const;
135  inline void extend( size_t m, size_t n, bool preserve=true ) const;
136  inline void reserve( size_t n ) const;
138  //**********************************************************************************************
139 
140  //**Numeric functions***************************************************************************
143  inline void transpose() const;
144  inline void ctranspose() const;
145 
146  template< typename Other > inline void scale( const Other& scalar ) const;
148  //**********************************************************************************************
149 
150  private:
151  //**Compile time checks*************************************************************************
155  //**********************************************************************************************
156 };
157 //*************************************************************************************************
158 
159 
160 
161 
162 //=================================================================================================
163 //
164 // DATA ACCESS FUNCTIONS
165 //
166 //=================================================================================================
167 
168 //*************************************************************************************************
176 template< typename PT // Type of the proxy
177  , typename MT > // Type of the dense matrix
179  DenseMatrixProxy<PT,MT>::operator()( size_t i, size_t j ) const
180 {
181  if( (~*this).isRestricted() ) {
182  BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
183  }
184 
185  return (~*this).get()(i,j);
186 }
187 //*************************************************************************************************
188 
189 
190 //*************************************************************************************************
202 template< typename PT // Type of the proxy
203  , typename MT > // Type of the dense matrix
205  DenseMatrixProxy<PT,MT>::at( size_t i, size_t j ) const
206 {
207  if( (~*this).isRestricted() ) {
208  BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
209  }
210 
211  return (~*this).get().at(i,j);
212 }
213 //*************************************************************************************************
214 
215 
216 //*************************************************************************************************
228 template< typename PT // Type of the proxy
229  , typename MT > // Type of the dense matrix
231 {
232  if( (~*this).isRestricted() ) {
233  BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
234  }
235 
236  return (~*this).get().data();
237 }
238 //*************************************************************************************************
239 
240 
241 //*************************************************************************************************
249 template< typename PT // Type of the proxy
250  , typename MT > // Type of the dense matrix
252 {
253  if( (~*this).isRestricted() ) {
254  BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
255  }
256 
257  return (~*this).get().data(i);
258 }
259 //*************************************************************************************************
260 
261 
262 //*************************************************************************************************
274 template< typename PT // Type of the proxy
275  , typename MT > // Type of the dense matrix
276 inline typename DenseMatrixProxy<PT,MT>::Iterator
278 {
279  if( (~*this).isRestricted() ) {
280  BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
281  }
282 
283  return (~*this).get().begin(i);
284 }
285 //*************************************************************************************************
286 
287 
288 //*************************************************************************************************
299 template< typename PT // Type of the proxy
300  , typename MT > // Type of the dense matrix
303 {
304  return (~*this).get().cbegin(i);
305 }
306 //*************************************************************************************************
307 
308 
309 //*************************************************************************************************
321 template< typename PT // Type of the proxy
322  , typename MT > // Type of the dense matrix
323 inline typename DenseMatrixProxy<PT,MT>::Iterator
325 {
326  if( (~*this).isRestricted() ) {
327  BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
328  }
329 
330  return (~*this).get().end(i);
331 }
332 //*************************************************************************************************
333 
334 
335 //*************************************************************************************************
346 template< typename PT // Type of the proxy
347  , typename MT > // Type of the dense matrix
350 {
351  return (~*this).get().cend(i);
352 }
353 //*************************************************************************************************
354 
355 
356 
357 
358 //=================================================================================================
359 //
360 // UTILITY FUNCTIONS
361 //
362 //=================================================================================================
363 
364 //*************************************************************************************************
369 template< typename PT // Type of the proxy
370  , typename MT > // Type of the dense matrix
371 inline size_t DenseMatrixProxy<PT,MT>::rows() const
372 {
373  return (~*this).get().rows();
374 }
375 //*************************************************************************************************
376 
377 
378 //*************************************************************************************************
383 template< typename PT // Type of the proxy
384  , typename MT > // Type of the dense matrix
385 inline size_t DenseMatrixProxy<PT,MT>::columns() const
386 {
387  return (~*this).get().columns();
388 }
389 //*************************************************************************************************
390 
391 
392 //*************************************************************************************************
402 template< typename PT // Type of the proxy
403  , typename MT > // Type of the dense matrix
404 inline size_t DenseMatrixProxy<PT,MT>::spacing() const
405 {
406  return (~*this).get().spacing();
407 }
408 //*************************************************************************************************
409 
410 
411 //*************************************************************************************************
416 template< typename PT // Type of the proxy
417  , typename MT > // Type of the dense matrix
419 {
420  return (~*this).get().capacity();
421 }
422 //*************************************************************************************************
423 
424 
425 //*************************************************************************************************
436 template< typename PT // Type of the proxy
437  , typename MT > // Type of the dense matrix
438 inline size_t DenseMatrixProxy<PT,MT>::capacity( size_t i ) const
439 {
440  return (~*this).get().capacity(i);
441 }
442 //*************************************************************************************************
443 
444 
445 //*************************************************************************************************
450 template< typename PT // Type of the proxy
451  , typename MT > // Type of the dense matrix
453 {
454  return (~*this).get().nonZeros();
455 }
456 //*************************************************************************************************
457 
458 
459 //*************************************************************************************************
470 template< typename PT // Type of the proxy
471  , typename MT > // Type of the dense matrix
472 inline size_t DenseMatrixProxy<PT,MT>::nonZeros( size_t i ) const
473 {
474  return (~*this).get().nonZeros(i);
475 }
476 //*************************************************************************************************
477 
478 
479 //*************************************************************************************************
486 template< typename PT // Type of the proxy
487  , typename MT > // Type of the dense matrix
489 {
490  using blaze::reset;
491 
492  reset( (~*this).get() );
493 }
494 //*************************************************************************************************
495 
496 
497 //*************************************************************************************************
508 template< typename PT // Type of the proxy
509  , typename MT > // Type of the dense matrix
510 inline void DenseMatrixProxy<PT,MT>::reset( size_t i ) const
511 {
512  using blaze::reset;
513 
514  reset( (~*this).get(), i );
515 }
516 //*************************************************************************************************
517 
518 
519 //*************************************************************************************************
526 template< typename PT // Type of the proxy
527  , typename MT > // Type of the dense matrix
529 {
530  using blaze::clear;
531 
532  clear( (~*this).get() );
533 }
534 //*************************************************************************************************
535 
536 
537 //*************************************************************************************************
554 template< typename PT // Type of the proxy
555  , typename MT > // Type of the dense matrix
556 inline void DenseMatrixProxy<PT,MT>::resize( size_t m, size_t n, bool preserve ) const
557 {
558  if( (~*this).isRestricted() ) {
559  BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
560  }
561 
562  (~*this).get().resize( m, n, preserve );
563 }
564 //*************************************************************************************************
565 
566 
567 //*************************************************************************************************
583 template< typename PT // Type of the proxy
584  , typename MT > // Type of the dense matrix
585 inline void DenseMatrixProxy<PT,MT>::extend( size_t m, size_t n, bool preserve ) const
586 {
587  if( (~*this).isRestricted() ) {
588  BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
589  }
590 
591  (~*this).get().extend( m, n, preserve );
592 }
593 //*************************************************************************************************
594 
595 
596 //*************************************************************************************************
606 template< typename PT // Type of the proxy
607  , typename MT > // Type of the dense matrix
608 inline void DenseMatrixProxy<PT,MT>::reserve( size_t n ) const
609 {
610  if( (~*this).isRestricted() ) {
611  BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
612  }
613 
614  (~*this).get().reserve( n );
615 }
616 //*************************************************************************************************
617 
618 
619 //*************************************************************************************************
625 template< typename PT // Type of the proxy
626  , typename MT > // Type of the dense matrix
628 {
629  if( (~*this).isRestricted() ) {
630  BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
631  }
632 
633  (~*this).get().transpose();
634 }
635 //*************************************************************************************************
636 
637 
638 //*************************************************************************************************
644 template< typename PT // Type of the proxy
645  , typename MT > // Type of the dense matrix
647 {
648  if( (~*this).isRestricted() ) {
649  BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
650  }
651 
652  (~*this).get().ctranspose();
653 }
654 //*************************************************************************************************
655 
656 
657 //*************************************************************************************************
668 template< typename PT // Type of the proxy
669  , typename MT > // Type of the dense matrix
670 template< typename Other > // Data type of the scalar value
671 inline void DenseMatrixProxy<PT,MT>::scale( const Other& scalar ) const
672 {
673  if( (~*this).isRestricted() ) {
674  BLAZE_THROW_INVALID_ARGUMENT( "Invalid access to restricted element" );
675  }
676 
677  (~*this).get().scale( scalar );
678 }
679 //*************************************************************************************************
680 
681 
682 
683 
684 //=================================================================================================
685 //
686 // GLOBAL FUNCTIONS
687 //
688 //=================================================================================================
689 
690 //*************************************************************************************************
693 template< typename PT, typename MT >
695  begin( const DenseMatrixProxy<PT,MT>& proxy, size_t i );
696 
697 template< typename PT, typename MT >
699  cbegin( const DenseMatrixProxy<PT,MT>& proxy, size_t i );
700 
701 template< typename PT, typename MT >
703  end( const DenseMatrixProxy<PT,MT>& proxy, size_t i );
704 
705 template< typename PT, typename MT >
707  cend( const DenseMatrixProxy<PT,MT>& proxy, size_t i );
708 
709 template< typename PT, typename MT >
710 BLAZE_ALWAYS_INLINE size_t rows( const DenseMatrixProxy<PT,MT>& proxy );
711 
712 template< typename PT, typename MT >
714 
715 template< typename PT, typename MT >
717 
718 template< typename PT, typename MT >
719 BLAZE_ALWAYS_INLINE size_t capacity( const DenseMatrixProxy<PT,MT>& proxy, size_t i );
720 
721 template< typename PT, typename MT >
723 
724 template< typename PT, typename MT >
725 BLAZE_ALWAYS_INLINE size_t nonZeros( const DenseMatrixProxy<PT,MT>& proxy, size_t i );
726 
727 template< typename PT, typename MT >
728 BLAZE_ALWAYS_INLINE void resize( const DenseMatrixProxy<PT,MT>& proxy, size_t m, size_t n, bool preserve=true );
729 
730 template< typename PT, typename MT >
732 
733 template< typename PT, typename MT >
734 BLAZE_ALWAYS_INLINE void reset( const DenseMatrixProxy<PT,MT>& proxy, size_t i );
735 
736 template< typename PT, typename MT >
739 //*************************************************************************************************
740 
741 
742 //*************************************************************************************************
755 template< typename PT // Type of the proxy
756  , typename MT > // Type of the dense matrix
758  begin( const DenseMatrixProxy<PT,MT>& proxy, size_t i )
759 {
760  return proxy.begin(i);
761 }
762 //*************************************************************************************************
763 
764 
765 //*************************************************************************************************
778 template< typename PT // Type of the proxy
779  , typename MT > // Type of the dense matrix
781  cbegin( const DenseMatrixProxy<PT,MT>& proxy, size_t i )
782 {
783  return proxy.cbegin(i);
784 }
785 //*************************************************************************************************
786 
787 
788 //*************************************************************************************************
802 template< typename PT // Type of the proxy
803  , typename MT > // Type of the dense matrix
805  end( const DenseMatrixProxy<PT,MT>& proxy, size_t i )
806 {
807  return proxy.end(i);
808 }
809 //*************************************************************************************************
810 
811 
812 //*************************************************************************************************
826 template< typename PT // Type of the proxy
827  , typename MT > // Type of the dense matrix
829  cend( const DenseMatrixProxy<PT,MT>& proxy, size_t i )
830 {
831  return proxy.cend(i);
832 }
833 //*************************************************************************************************
834 
835 
836 //*************************************************************************************************
843 template< typename PT // Type of the proxy
844  , typename MT > // Type of the dense matrix
846 {
847  return proxy.rows();
848 }
849 //*************************************************************************************************
850 
851 
852 //*************************************************************************************************
859 template< typename PT // Type of the proxy
860  , typename MT > // Type of the dense matrix
862 {
863  return proxy.columns();
864 }
865 //*************************************************************************************************
866 
867 
868 //*************************************************************************************************
875 template< typename PT // Type of the proxy
876  , typename MT > // Type of the dense matrix
878 {
879  return proxy.capacity();
880 }
881 //*************************************************************************************************
882 
883 
884 //*************************************************************************************************
897 template< typename PT // Type of the proxy
898  , typename MT > // Type of the dense matrix
899 BLAZE_ALWAYS_INLINE size_t capacity( const DenseMatrixProxy<PT,MT>& proxy, size_t i )
900 {
901  return proxy.capacity(i);
902 }
903 //*************************************************************************************************
904 
905 
906 //*************************************************************************************************
913 template< typename PT // Type of the proxy
914  , typename MT > // Type of the dense matrix
916 {
917  return proxy.nonZeros();
918 }
919 //*************************************************************************************************
920 
921 
922 //*************************************************************************************************
935 template< typename PT // Type of the proxy
936  , typename MT > // Type of the dense matrix
937 BLAZE_ALWAYS_INLINE size_t nonZeros( const DenseMatrixProxy<PT,MT>& proxy, size_t i )
938 {
939  return proxy.nonZeros(i);
940 }
941 //*************************************************************************************************
942 
943 
944 //*************************************************************************************************
961 template< typename PT // Type of the proxy
962  , typename MT > // Type of the dense matrix
964  resize_backend( const DenseMatrixProxy<PT,MT>& proxy, size_t m, size_t n, bool preserve )
965 {
966  UNUSED_PARAMETER( preserve );
967 
968  if( proxy.rows() != m || proxy.columns() != n ) {
969  BLAZE_THROW_INVALID_ARGUMENT( "Matrix cannot be resized" );
970  }
971 }
973 //*************************************************************************************************
974 
975 
976 //*************************************************************************************************
989 template< typename PT // Type of the proxy
990  , typename MT > // Type of the dense matrix
992  resize_backend( const DenseMatrixProxy<PT,MT>& proxy, size_t m, size_t n, bool preserve )
993 {
994  proxy.resize( m, n, preserve );
995 }
997 //*************************************************************************************************
998 
999 
1000 //*************************************************************************************************
1014 template< typename PT // Type of the proxy
1015  , typename MT > // Type of the dense matrix
1016 BLAZE_ALWAYS_INLINE EnableIf_< And< IsResizable<MT>, IsSquare<MT> > >
1017  resize_backend( const DenseMatrixProxy<PT,MT>& proxy, size_t m, size_t n, bool preserve )
1018 {
1019  if( m != n ) {
1020  BLAZE_THROW_INVALID_ARGUMENT( "Invalid resize arguments for square matrix" );
1021  }
1022 
1023  proxy.resize( m, preserve );
1024 }
1026 //*************************************************************************************************
1027 
1028 
1029 //*************************************************************************************************
1054 template< typename PT // Type of the proxy
1055  , typename MT > // Type of the dense matrix
1056 BLAZE_ALWAYS_INLINE void resize( const DenseMatrixProxy<PT,MT>& proxy, size_t m, size_t n, bool preserve )
1057 {
1058  resize_backend( proxy, m, n, preserve );
1059 }
1060 //*************************************************************************************************
1061 
1062 
1063 //*************************************************************************************************
1072 template< typename PT // Type of the proxy
1073  , typename MT > // Type of the dense matrix
1075 {
1076  proxy.reset();
1077 }
1078 //*************************************************************************************************
1079 
1080 
1081 //*************************************************************************************************
1094 template< typename PT // Type of the proxy
1095  , typename MT > // Type of the dense matrix
1096 BLAZE_ALWAYS_INLINE void reset( const DenseMatrixProxy<PT,MT>& proxy, size_t i )
1097 {
1098  proxy.reset(i);
1099 }
1100 //*************************************************************************************************
1101 
1102 
1103 //*************************************************************************************************
1112 template< typename PT // Type of the proxy
1113  , typename MT > // Type of the dense matrix
1115 {
1116  proxy.clear();
1117 }
1118 //*************************************************************************************************
1119 
1120 } // namespace blaze
1121 
1122 #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:324
Header file for the UNUSED_PARAMETER function template.
Header file for basic type definitions.
Iterator_< MT > Iterator
Iterator over non-constant elements.
Definition: DenseMatrixProxy.h:94
#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:588
typename DisableIf< Condition, T >::Type DisableIf_
Auxiliary type for the DisableIf class template.The DisableIf_ alias declaration provides a convenien...
Definition: DisableIf.h:224
Header file for the And class template.
Reference_< MT > Reference
Reference to a non-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:671
Reference operator()(size_t i, size_t j) const
Function call operator for the direct access to matrix elements.
Definition: DenseMatrixProxy.h:179
CompositeType_< MT > CompositeType
Data type for composite expression templates.
Definition: DenseMatrixProxy.h:89
void reset() const
Reset to the default initial value.
Definition: DenseMatrixProxy.h:488
typename T::ResultType ResultType_
Alias declaration for nested ResultType type definitions.The ResultType_ alias declaration provides a...
Definition: Aliases.h:343
ResultType_< MT > ResultType
Result type for expression template evaluations.
Definition: DenseMatrixProxy.h:84
Proxy backend for dense matrix types.The DenseMatrixProxy class serves as a backend for the Proxy cla...
Definition: DenseMatrixProxy.h:79
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:80
typename T::ReturnType ReturnType_
Alias declaration for nested ReturnType type definitions.The ReturnType_ alias declaration provides a...
Definition: Aliases.h:363
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
Pointer_< MT > Pointer
Pointer to a non-constant matrix value.
Definition: DenseMatrixProxy.h:92
Header file for the DisableIf class template.
Pointer data() const
Low-level data access to matrix elements.
Definition: DenseMatrixProxy.h:230
typename T::Pointer Pointer_
Alias declaration for nested Pointer type definitions.The Pointer_ alias declaration provides a conve...
Definition: Aliases.h:283
Header file for the clear shim.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:58
#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:627
size_t columns() const
Returns the current number of columns of the represented matrix.
Definition: DenseMatrixProxy.h:385
size_t rows() const
Returns the current number of rows of the represented matrix.
Definition: DenseMatrixProxy.h:371
Header file for the DenseMatrix base class.
Header file for the Not class template.
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
ReturnType_< MT > ReturnType
Return type for expression template evaluations.
Definition: DenseMatrixProxy.h:88
OppositeType_< MT > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DenseMatrixProxy.h:85
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:91
ConstIterator cbegin(size_t i) const
Returns an iterator to the first element of row/column i of the represented matrix.
Definition: DenseMatrixProxy.h:302
Iterator begin(size_t i) const
Returns an iterator to the first element of row/column i of the represented matrix.
Definition: DenseMatrixProxy.h:277
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:303
Header file for the EnableIf class template.
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:608
ConstIterator_< MT > ConstIterator
Iterator over constant elements.
Definition: DenseMatrixProxy.h:95
TransposeType_< MT > TransposeType
Transpose type for expression template evaluations.
Definition: DenseMatrixProxy.h:86
void extend(size_t m, size_t n, bool preserve=true) const
Extending the size of the represented matrix.
Definition: DenseMatrixProxy.h:585
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:349
void clear() const
Clearing the represented matrix.
Definition: DenseMatrixProxy.h:528
Header file for the reset shim.
Compile time type negation.The Not alias declaration negates the given compile time condition...
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:404
typename EnableIf< Condition, T >::Type EnableIf_
Auxiliary alias declaration for the EnableIf class template.The EnableIf_ alias declaration provides ...
Definition: EnableIf.h:224
typename T::OppositeType OppositeType_
Alias declaration for nested OppositeType type definitions.The OppositeType_ alias declaration provid...
Definition: Aliases.h:263
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:418
ElementType_< MT > ElementType
Type of the matrix elements.
Definition: DenseMatrixProxy.h:87
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:93
void resize(size_t m, size_t n, bool preserve=true) const
Changing the size of the represented matrix.
Definition: DenseMatrixProxy.h:556
void ctranspose() const
In-place conjugate transpose of the represented matrix.
Definition: DenseMatrixProxy.h:646
typename T::TransposeType TransposeType_
Alias declaration for nested TransposeType type definitions.The TransposeType_ alias declaration prov...
Definition: Aliases.h:423
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:608
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:205
System settings for the inline keywords.
size_t nonZeros() const
Returns the number of non-zero elements in the represented matrix.
Definition: DenseMatrixProxy.h:452