All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
NumericProxy.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_ADAPTORS_SYMMETRICMATRIX_NUMERICPROXY_H_
36 #define _BLAZE_MATH_ADAPTORS_SYMMETRICMATRIX_NUMERICPROXY_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <ostream>
49 #include <blaze/math/shims/Clear.h>
51 #include <blaze/math/shims/Reset.h>
57 #include <blaze/util/InvalidType.h>
58 #include <blaze/util/mpl/If.h>
59 #include <blaze/util/Types.h>
61 
62 
63 namespace blaze {
64 
65 //=================================================================================================
66 //
67 // CLASS DEFINITION
68 //
69 //=================================================================================================
70 
71 //*************************************************************************************************
90 template< typename MT > // Type of the adapted matrix
92 {
93  private:
94  //**struct BuiltinType**************************************************************************
98  template< typename T >
99  struct BuiltinType { typedef INVALID_TYPE Type; };
101  //**********************************************************************************************
102 
103  //**struct ComplexType**************************************************************************
107  template< typename T >
108  struct ComplexType { typedef typename T::value_type Type; };
110  //**********************************************************************************************
111 
112  public:
113  //**Type definitions****************************************************************************
114  typedef typename MT::ElementType RepresentedType;
115  typedef typename MT::Reference Reference;
118  typedef const NumericProxy* ConstPointer;
119 
121  typedef typename If< IsComplex<RepresentedType>
122  , ComplexType<RepresentedType>
123  , BuiltinType<RepresentedType> >::Type::Type ValueType;
124  //**********************************************************************************************
125 
126  //**Constructors********************************************************************************
129  explicit inline NumericProxy( MT& matrix, size_t row, size_t column );
130  inline NumericProxy( const NumericProxy& np );
132  //**********************************************************************************************
133 
134  //**Destructor**********************************************************************************
135  // No explicitly declared destructor.
136  //**********************************************************************************************
137 
138  //**Assignment operators************************************************************************
141  inline NumericProxy& operator= ( const NumericProxy& sp );
142  template< typename T > inline NumericProxy& operator= ( const T& value );
143  template< typename T > inline NumericProxy& operator+=( const T& value );
144  template< typename T > inline NumericProxy& operator-=( const T& value );
145  template< typename T > inline NumericProxy& operator*=( const T& value );
146  template< typename T > inline NumericProxy& operator/=( const T& value );
148  //**********************************************************************************************
149 
150  //**Access operators****************************************************************************
153  inline Pointer operator->();
154  inline ConstPointer operator->() const;
156  //**********************************************************************************************
157 
158  //**Utility functions***************************************************************************
161  inline void reset() const;
162  inline void clear() const;
163 
164  inline ConstReference get() const;
166  //**********************************************************************************************
167 
168  //**Conversion operator*************************************************************************
171  inline operator ConstReference() const;
173  //**********************************************************************************************
174 
175  //**Complex data access functions***************************************************************
178  inline ValueType real() const;
179  inline void real( ValueType value ) const;
180  inline ValueType imag() const;
181  inline void imag( ValueType value ) const;
183  //**********************************************************************************************
184 
185  private:
186  //**Member variables****************************************************************************
189  MT& matrix_;
190  size_t row_;
191  size_t column_;
192 
193  //**********************************************************************************************
194 
195  //**Compile time checks*************************************************************************
208  //**********************************************************************************************
209 };
210 //*************************************************************************************************
211 
212 
213 
214 
215 //=================================================================================================
216 //
217 // CONSTRUCTORS
218 //
219 //=================================================================================================
220 
221 //*************************************************************************************************
228 template< typename MT > // Type of the adapted matrix
229 inline NumericProxy<MT>::NumericProxy( MT& matrix, size_t row, size_t column )
230  : matrix_( matrix ) // Reference to the adapted matrix
231  , row_ ( row ) // Row index of the accessed matrix element
232  , column_( column ) // Column index of the accessed matrix element
233 {}
234 //*************************************************************************************************
235 
236 
237 //*************************************************************************************************
242 template< typename MT > // Type of the adapted matrix
244  : matrix_( np.matrix_ ) // Reference to the adapted matrix
245  , row_ ( np.row_ ) // Row index of the accessed matrix element
246  , column_( np.column_ ) // Column index of the accessed matrix element
247 {}
248 //*************************************************************************************************
249 
250 
251 
252 
253 //=================================================================================================
254 //
255 // OPERATORS
256 //
257 //=================================================================================================
258 
259 //*************************************************************************************************
265 template< typename MT > // Type of the adapted matrix
267 {
268  matrix_(row_,column_) = np.matrix_(np.row_,np.column_);
269  matrix_(column_,row_) = np.matrix_(np.row_,np.column_);
270 
271  return *this;
272 }
273 //*************************************************************************************************
274 
275 
276 //*************************************************************************************************
282 template< typename MT > // Type of the adapted matrix
283 template< typename T > // Type of the right-hand side value
285 {
286  matrix_(row_,column_) = value;
287  if( row_ != column_ )
288  matrix_(column_,row_) = value;
289 
290  return *this;
291 }
292 //*************************************************************************************************
293 
294 
295 //*************************************************************************************************
301 template< typename MT > // Type of the adapted matrix
302 template< typename T > // Type of the right-hand side value
304 {
305  matrix_(row_,column_) += value;
306  if( row_ != column_ )
307  matrix_(column_,row_) += value;
308 
309  return *this;
310 }
311 //*************************************************************************************************
312 
313 
314 //*************************************************************************************************
320 template< typename MT > // Type of the adapted matrix
321 template< typename T > // Type of the right-hand side value
323 {
324  matrix_(row_,column_) -= value;
325  if( row_ != column_ )
326  matrix_(column_,row_) -= value;
327 
328  return *this;
329 }
330 //*************************************************************************************************
331 
332 
333 //*************************************************************************************************
339 template< typename MT > // Type of the adapted matrix
340 template< typename T > // Type of the right-hand side value
342 {
343  matrix_(row_,column_) *= value;
344  if( row_ != column_ )
345  matrix_(column_,row_) *= value;
346 
347  return *this;
348 }
349 //*************************************************************************************************
350 
351 
352 //*************************************************************************************************
358 template< typename MT > // Type of the adapted matrix
359 template< typename T > // Type of the right-hand side value
361 {
362  matrix_(row_,column_) /= value;
363  if( row_ != column_ )
364  matrix_(column_,row_) /= value;
365 
366  return *this;
367 }
368 //*************************************************************************************************
369 
370 
371 
372 
373 //=================================================================================================
374 //
375 // ACCESS OPERATORS
376 //
377 //=================================================================================================
378 
379 //*************************************************************************************************
384 template< typename MT > // Type of the adapted matrix
386 {
387  return this;
388 }
389 //*************************************************************************************************
390 
391 
392 //*************************************************************************************************
397 template< typename MT > // Type of the adapted matrix
399 {
400  return this;
401 }
402 //*************************************************************************************************
403 
404 
405 
406 
407 //=================================================================================================
408 //
409 // UTILITY FUNCTIONS
410 //
411 //=================================================================================================
412 
413 //*************************************************************************************************
420 template< typename MT > // Type of the adapted matrix
421 inline void NumericProxy<MT>::reset() const
422 {
423  using blaze::reset;
424 
425  reset( matrix_(row_,column_) );
426  if( row_ != column_ )
427  reset( matrix_(column_,row_) );
428 }
429 //*************************************************************************************************
430 
431 
432 //*************************************************************************************************
439 template< typename MT > // Type of the adapted matrix
440 inline void NumericProxy<MT>::clear() const
441 {
442  using blaze::clear;
443 
444  clear( matrix_(row_,column_) );
445  if( row_ != column_ )
446  clear( matrix_(column_,row_) );
447 }
448 //*************************************************************************************************
449 
450 
451 //*************************************************************************************************
456 template< typename MT > // Type of the adapted matrix
458 {
459  return const_cast<const MT&>( matrix_ )(row_,column_);
460 }
461 //*************************************************************************************************
462 
463 
464 
465 
466 //=================================================================================================
467 //
468 // CONVERSION OPERATOR
469 //
470 //=================================================================================================
471 
472 //*************************************************************************************************
477 template< typename MT > // Type of the adapted matrix
479 {
480  return get();
481 }
482 //*************************************************************************************************
483 
484 
485 
486 
487 //=================================================================================================
488 //
489 // COMPLEX DATA ACCESS FUNCTIONS
490 //
491 //=================================================================================================
492 
493 //*************************************************************************************************
501 template< typename MT > // Type of the adapted matrix
503 {
504  return matrix_(row_,column_).real();
505 }
506 //*************************************************************************************************
507 
508 
509 //*************************************************************************************************
517 template< typename MT > // Type of the adapted matrix
518 inline void NumericProxy<MT>::real( ValueType value ) const
519 {
520  matrix_(row_,column_).real( value );
521  if( row_ != column_ )
522  matrix_(column_,row_).real( value );
523 }
524 //*************************************************************************************************
525 
526 
527 //*************************************************************************************************
535 template< typename MT > // Type of the adapted matrix
537 {
538  return matrix_(row_,column_).imag();
539 }
540 //*************************************************************************************************
541 
542 
543 //*************************************************************************************************
552 template< typename MT > // Type of the adapted matrix
553 inline void NumericProxy<MT>::imag( ValueType value ) const
554 {
555  matrix_(row_,column_).imag( value );
556  if( row_ != column_ )
557  matrix_(column_,row_).imag( value );
558 }
559 //*************************************************************************************************
560 
561 
562 
563 
564 //=================================================================================================
565 //
566 // GLOBAL OPERATORS
567 //
568 //=================================================================================================
569 
570 //*************************************************************************************************
573 template< typename MT1, typename MT2 >
574 inline bool operator==( const NumericProxy<MT1>& lhs, const NumericProxy<MT2>& rhs );
575 
576 template< typename MT, typename T >
577 inline bool operator==( const NumericProxy<MT>& lhs, const T& rhs );
578 
579 template< typename T, typename MT >
580 inline bool operator==( const T& lhs, const NumericProxy<MT>& rhs );
581 
582 template< typename MT1, typename MT2 >
583 inline bool operator!=( const NumericProxy<MT1>& lhs, const NumericProxy<MT2>& rhs );
584 
585 template< typename MT, typename T >
586 inline bool operator!=( const NumericProxy<MT>& lhs, const T& rhs );
587 
588 template< typename T, typename MT >
589 inline bool operator!=( const T& lhs, const NumericProxy<MT>& rhs );
590 
591 template< typename MT1, typename MT2 >
592 inline bool operator<( const NumericProxy<MT1>& lhs, const NumericProxy<MT2>& rhs );
593 
594 template< typename MT, typename T >
595 inline bool operator<( const NumericProxy<MT>& lhs, const T& rhs );
596 
597 template< typename T, typename MT >
598 inline bool operator<( const T& lhs, const NumericProxy<MT>& rhs );
599 
600 template< typename MT1, typename MT2 >
601 inline bool operator>( const NumericProxy<MT1>& lhs, const NumericProxy<MT2>& rhs );
602 
603 template< typename MT, typename T >
604 inline bool operator>( const NumericProxy<MT>& lhs, const T& rhs );
605 
606 template< typename T, typename MT >
607 inline bool operator>( const T& lhs, const NumericProxy<MT>& rhs );
608 
609 template< typename MT1, typename MT2 >
610 inline bool operator<=( const NumericProxy<MT1>& lhs, const NumericProxy<MT2>& rhs );
611 
612 template< typename MT, typename T >
613 inline bool operator<=( const NumericProxy<MT>& lhs, const T& rhs );
614 
615 template< typename T, typename MT >
616 inline bool operator<=( const T& lhs, const NumericProxy<MT>& rhs );
617 
618 template< typename MT1, typename MT2 >
619 inline bool operator>=( const NumericProxy<MT1>& lhs, const NumericProxy<MT2>& rhs );
620 
621 template< typename MT, typename T >
622 inline bool operator>=( const NumericProxy<MT>& lhs, const T& rhs );
623 
624 template< typename T, typename MT >
625 inline bool operator>=( const T& lhs, const NumericProxy<MT>& rhs );
626 
627 template< typename MT >
628 inline std::ostream& operator<<( std::ostream& os, const NumericProxy<MT>& proxy );
630 //*************************************************************************************************
631 
632 
633 //*************************************************************************************************
641 template< typename MT1, typename MT2 >
642 inline bool operator==( const NumericProxy<MT1>& lhs, const NumericProxy<MT2>& rhs )
643 {
644  return ( lhs.get() == rhs.get() );
645 }
646 //*************************************************************************************************
647 
648 
649 //*************************************************************************************************
657 template< typename MT, typename T >
658 inline bool operator==( const NumericProxy<MT>& lhs, const T& rhs )
659 {
660  return ( lhs.get() == rhs );
661 }
662 //*************************************************************************************************
663 
664 
665 //*************************************************************************************************
673 template< typename T, typename MT >
674 inline bool operator==( const T& lhs, const NumericProxy<MT>& rhs )
675 {
676  return ( lhs == rhs.get() );
677 }
678 //*************************************************************************************************
679 
680 
681 //*************************************************************************************************
689 template< typename MT1, typename MT2 >
690 inline bool operator!=( const NumericProxy<MT1>& lhs, const NumericProxy<MT2>& rhs )
691 {
692  return ( lhs.get() != rhs.get() );
693 }
694 //*************************************************************************************************
695 
696 
697 //*************************************************************************************************
705 template< typename MT, typename T >
706 inline bool operator!=( const NumericProxy<MT>& lhs, const T& rhs )
707 {
708  return ( lhs.get() != rhs );
709 }
710 //*************************************************************************************************
711 
712 
713 //*************************************************************************************************
721 template< typename T, typename MT >
722 inline bool operator!=( const T& lhs, const NumericProxy<MT>& rhs )
723 {
724  return ( lhs != rhs.get() );
725 }
726 //*************************************************************************************************
727 
728 
729 //*************************************************************************************************
737 template< typename MT1, typename MT2 >
738 inline bool operator<( const NumericProxy<MT1>& lhs, const NumericProxy<MT2>& rhs )
739 {
740  return ( lhs.get() < rhs.get() );
741 }
742 //*************************************************************************************************
743 
744 
745 //*************************************************************************************************
753 template< typename MT, typename T >
754 inline bool operator<( const NumericProxy<MT>& lhs, const T& rhs )
755 {
756  return ( lhs.get() < rhs );
757 }
758 //*************************************************************************************************
759 
760 
761 //*************************************************************************************************
769 template< typename T, typename MT >
770 inline bool operator<( const T& lhs, const NumericProxy<MT>& rhs )
771 {
772  return ( lhs < rhs.get() );
773 }
774 //*************************************************************************************************
775 
776 
777 //*************************************************************************************************
785 template< typename MT1, typename MT2 >
786 inline bool operator>( const NumericProxy<MT1>& lhs, const NumericProxy<MT2>& rhs )
787 {
788  return ( lhs.get() > rhs.get() );
789 }
790 //*************************************************************************************************
791 
792 
793 //*************************************************************************************************
801 template< typename MT, typename T >
802 inline bool operator>( const NumericProxy<MT>& lhs, const T& rhs )
803 {
804  return ( lhs.get() > rhs );
805 }
806 //*************************************************************************************************
807 
808 
809 //*************************************************************************************************
817 template< typename T, typename MT >
818 inline bool operator>( const T& lhs, const NumericProxy<MT>& rhs )
819 {
820  return ( lhs > rhs.get() );
821 }
822 //*************************************************************************************************
823 
824 
825 //*************************************************************************************************
833 template< typename MT1, typename MT2 >
834 inline bool operator<=( const NumericProxy<MT1>& lhs, const NumericProxy<MT2>& rhs )
835 {
836  return ( lhs.get() <= rhs.get() );
837 }
838 //*************************************************************************************************
839 
840 
841 //*************************************************************************************************
849 template< typename MT, typename T >
850 inline bool operator<=( const NumericProxy<MT>& lhs, const T& rhs )
851 {
852  return ( lhs.get() <= rhs );
853 }
854 //*************************************************************************************************
855 
856 
857 //*************************************************************************************************
865 template< typename T, typename MT >
866 inline bool operator<=( const T& lhs, const NumericProxy<MT>& rhs )
867 {
868  return ( lhs <= rhs.get() );
869 }
870 //*************************************************************************************************
871 
872 
873 //*************************************************************************************************
881 template< typename MT1, typename MT2 >
882 inline bool operator>=( const NumericProxy<MT1>& lhs, const NumericProxy<MT2>& rhs )
883 {
884  return ( lhs.get() >= rhs.get() );
885 }
886 //*************************************************************************************************
887 
888 
889 //*************************************************************************************************
897 template< typename MT, typename T >
898 inline bool operator>=( const NumericProxy<MT>& lhs, const T& rhs )
899 {
900  return ( lhs.get() >= rhs );
901 }
902 //*************************************************************************************************
903 
904 
905 //*************************************************************************************************
913 template< typename T, typename MT >
914 inline bool operator>=( const T& lhs, const NumericProxy<MT>& rhs )
915 {
916  return ( lhs >= rhs.get() );
917 }
918 //*************************************************************************************************
919 
920 
921 //*************************************************************************************************
929 template< typename MT >
930 inline std::ostream& operator<<( std::ostream& os, const NumericProxy<MT>& proxy )
931 {
932  return os << proxy.get();
933 }
934 //*************************************************************************************************
935 
936 
937 
938 
939 //=================================================================================================
940 //
941 // GLOBAL FUNCTIONS
942 //
943 //=================================================================================================
944 
945 //*************************************************************************************************
948 template< typename MT >
949 inline void reset( const NumericProxy<MT>& proxy );
950 
951 template< typename MT >
952 inline void clear( const NumericProxy<MT>& proxy );
953 
954 template< typename MT >
955 inline bool isDefault( const NumericProxy<MT>& proxy );
957 //*************************************************************************************************
958 
959 
960 //*************************************************************************************************
970 template< typename MT >
971 inline void reset( const NumericProxy<MT>& proxy )
972 {
973  proxy.reset();
974 }
975 //*************************************************************************************************
976 
977 
978 //*************************************************************************************************
988 template< typename MT >
989 inline void clear( const NumericProxy<MT>& proxy )
990 {
991  proxy.clear();
992 }
993 //*************************************************************************************************
994 
995 
996 //*************************************************************************************************
1006 template< typename MT >
1007 inline bool isDefault( const NumericProxy<MT>& proxy )
1008 {
1009  using blaze::isDefault;
1010 
1011  return isDefault( proxy.get() );
1012 }
1013 //*************************************************************************************************
1014 
1015 } // namespace blaze
1016 
1017 #endif
MT::ElementType RepresentedType
Type of the represented matrix element.
Definition: NumericProxy.h:114
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CONST(T)
Constraint on the data type.In case the given data type is a const-qualified type, a compilation error is created.
Definition: Const.h:116
Constraint on the data type.
size_t row_
Row index of the accessed matrix element.
Definition: NumericProxy.h:190
Compile time type selection.The If class template selects one of the two given types T2 and T3 depend...
Definition: If.h:112
NumericProxy * Pointer
Pointer to the represented element.
Definition: NumericProxy.h:117
Constraint on the data type.
MT & matrix_
Reference to the adapted matrix.
Definition: NumericProxy.h:189
DisableIf< Or< IsComputation< MT >, IsTransExpr< MT > >, typename ColumnExprTrait< MT >::Type >::Type column(Matrix< MT, SO > &matrix, size_t index)
Creating a view on a specific column of the given matrix.
Definition: Column.h:103
bool operator>(const NegativeAccuracy< A > &lhs, const T &rhs)
Greater-than comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:366
bool operator>=(const NegativeAccuracy< A > &, const T &rhs)
Greater-or-equal-than comparison between a NegativeAccuracy object and a floating point value...
Definition: Accuracy.h:442
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VOLATILE(T)
Constraint on the data type.In case the given data type is a volatile-qualified type, a compilation error is created.
Definition: Volatile.h:116
ValueType imag() const
Returns the imaginary part of the represented complex number.
Definition: NumericProxy.h:536
Constraint on the data type.
ConstReference get() const
Returning the value of the accessed matrix element.
Definition: NumericProxy.h:457
void reset() const
Reset the represented element to its default initial value.
Definition: NumericProxy.h:421
Constraint on the data type.
Header file for the clear shim.
Header file for the If class template.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_POINTER_TYPE(T)
Constraint on the data type.In case the given data type T is not a pointer type, a compilation error ...
Definition: Pointer.h:116
Constraint on the data type.
Access proxy for symmetric, square matrices with numeric element types.The NumericProxy provides cont...
Definition: NumericProxy.h:91
BLAZE_ALWAYS_INLINE void clear(const NonNumericProxy< MT > &proxy)
Clearing the represented element.
Definition: NonNumericProxy.h:854
ValueType real() const
Returns the real part of the represented complex number.
Definition: NumericProxy.h:502
Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_UPPER_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a upper triangular matrix type...
Definition: Upper.h:118
Pointer operator->()
Direct access to the represented matrix element.
Definition: NumericProxy.h:385
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2476
const Type & ConstReference
Reference to a constant matrix value.
Definition: CompressedMatrix.h:2480
MT::Reference Reference
Reference to the represented element.
Definition: NumericProxy.h:115
DisableIf< Or< IsComputation< MT >, IsTransExpr< MT > >, typename RowExprTrait< MT >::Type >::Type row(Matrix< MT, SO > &matrix, size_t index)
Creating a view on a specific row of the given matrix.
Definition: Row.h:103
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SYMMETRIC_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a symmetric matrix type, a compilation error is created.
Definition: Symmetric.h:116
Utility type for generic codes.
Constraint on the data type.
Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_NUMERIC_TYPE(T)
Constraint on the data type.In case the given data type T is not a numeric (integral or floating poin...
Definition: Numeric.h:79
size_t column_
Column index of the accessed matrix element.
Definition: NumericProxy.h:191
Header file for the reset shim.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_LOWER_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a lower triangular matrix type...
Definition: Lower.h:118
#define BLAZE_CONSTRAINT_MUST_NOT_BE_REFERENCE_TYPE(T)
Constraint on the data type.In case the given data type T is not a reference type, a compilation error is created.
Definition: Reference.h:116
Header file for the isDefault shim.
If< IsComplex< RepresentedType >, ComplexType< RepresentedType >, BuiltinType< RepresentedType > >::Type::Type ValueType
Value type of the represented complex element.
Definition: NumericProxy.h:123
BLAZE_ALWAYS_INLINE bool isDefault(const NonNumericProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: NonNumericProxy.h:874
Constraint on the data type.
Constraint on the data type.
BLAZE_ALWAYS_INLINE void reset(const NonNumericProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: NonNumericProxy.h:833
NumericProxy & operator=(const NumericProxy &sp)
Copy assignment operator for NumericProxy.
Definition: NumericProxy.h:266
MT::ConstReference ConstReference
Reference-to-const to the represented element.
Definition: NumericProxy.h:116
const NumericProxy * ConstPointer
Pointer-to-const to the represented element.
Definition: NumericProxy.h:118
#define BLAZE_CONSTRAINT_MUST_NOT_BE_EXPRESSION_TYPE(T)
Constraint on the data type.In case the given data type T is an expression (i.e. a type derived from ...
Definition: Expression.h:118
bool operator==(const NegativeAccuracy< A > &lhs, const T &rhs)
Equality comparison between a NegativeAccuracy object and a floating point value. ...
Definition: Accuracy.h:249
bool operator!=(const NegativeAccuracy< A > &lhs, const T &rhs)
Inequality comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:289
Header file for basic type definitions.
Header file for the IsComplex type trait.
MatrixAccessProxy< This > Reference
Reference to a non-constant matrix value.
Definition: CompressedMatrix.h:2479
NumericProxy(MT &matrix, size_t row, size_t column)
Initialization constructor for a NumericProxy.
Definition: NumericProxy.h:229
#define BLAZE_CONSTRAINT_MUST_BE_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a N-dimensional matrix type...
Definition: Matrix.h:79
void clear() const
Clearing the represented element.
Definition: NumericProxy.h:440