Column.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_VIEWS_COLUMN_H_
36 #define _BLAZE_MATH_VIEWS_COLUMN_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
73 #include <blaze/util/DisableIf.h>
74 #include <blaze/util/EnableIf.h>
77 #include <blaze/util/mpl/And.h>
78 #include <blaze/util/mpl/Or.h>
79 #include <blaze/util/TrueType.h>
80 #include <blaze/util/Types.h>
81 
82 
83 namespace blaze {
84 
85 //=================================================================================================
86 //
87 // GLOBAL OPERATORS
88 //
89 //=================================================================================================
90 
91 //*************************************************************************************************
123 template< typename MT // Type of the matrix
124  , bool SO > // Storage order
125 inline DisableIf_< Or< IsComputation<MT>, IsTransExpr<MT> >, ColumnExprTrait_<MT> >
126  column( Matrix<MT,SO>& matrix, size_t index )
127 {
129 
130  return ColumnExprTrait_<MT>( ~matrix, index );
131 }
132 //*************************************************************************************************
133 
134 
135 //*************************************************************************************************
167 template< typename MT // Type of the matrix
168  , bool SO > // Storage order
169 inline const DisableIf_< Or< IsComputation<MT>, IsTransExpr<MT> >, ColumnExprTrait_<const MT> >
170  column( const Matrix<MT,SO>& matrix, size_t index )
171 {
173 
174  return ColumnExprTrait_<const MT>( ~matrix, index );
175 }
176 //*************************************************************************************************
177 
178 
179 //*************************************************************************************************
193 template< typename MT // Type of the matrix
194  , bool SO > // Storage order
195 inline DisableIf_< Or< IsComputation<MT>, IsTransExpr<MT> >, ColumnExprTrait_<MT> >
196  column( Matrix<MT,SO>&& matrix, size_t index )
197 {
199 
200  return ColumnExprTrait_<MT>( ~matrix, index );
201 }
202 //*************************************************************************************************
203 
204 
205 
206 
207 //=================================================================================================
208 //
209 // GLOBAL RESTRUCTURING OPERATORS
210 //
211 //=================================================================================================
212 
213 //*************************************************************************************************
225 template< typename MT // Type of the matrix
226  , bool SO > // Storage order
227 inline const EnableIf_< IsMatMatAddExpr<MT>, ColumnExprTrait_<MT> >
228  column( const Matrix<MT,SO>& matrix, size_t index )
229 {
231 
232  return column( (~matrix).leftOperand(), index ) + column( (~matrix).rightOperand(), index );
233 }
235 //*************************************************************************************************
236 
237 
238 //*************************************************************************************************
250 template< typename MT // Type of the matrix
251  , bool SO > // Storage order
252 inline const EnableIf_< IsMatMatSubExpr<MT>, ColumnExprTrait_<MT> >
253  column( const Matrix<MT,SO>& matrix, size_t index )
254 {
256 
257  return column( (~matrix).leftOperand(), index ) - column( (~matrix).rightOperand(), index );
258 }
260 //*************************************************************************************************
261 
262 
263 //*************************************************************************************************
275 template< typename MT // Type of the matrix
276  , bool SO > // Storage order
277 inline const EnableIf_< IsMatMatMultExpr<MT>, ColumnExprTrait_<MT> >
278  column( const Matrix<MT,SO>& matrix, size_t index )
279 {
281 
282  return (~matrix).leftOperand() * column( (~matrix).rightOperand(), index );
283 }
285 //*************************************************************************************************
286 
287 
288 //*************************************************************************************************
300 template< typename MT // Type of the matrix
301  , bool SO > // Storage order
302 inline const EnableIf_< IsVecTVecMultExpr<MT>, ColumnExprTrait_<MT> >
303  column( const Matrix<MT,SO>& matrix, size_t index )
304 {
306 
307  return (~matrix).leftOperand() * (~matrix).rightOperand()[index];
308 }
310 //*************************************************************************************************
311 
312 
313 //*************************************************************************************************
325 template< typename MT // Type of the matrix
326  , bool SO > // Storage order
327 inline const EnableIf_< IsMatScalarMultExpr<MT>, ColumnExprTrait_<MT> >
328  column( const Matrix<MT,SO>& matrix, size_t index )
329 {
331 
332  return column( (~matrix).leftOperand(), index ) * (~matrix).rightOperand();
333 }
335 //*************************************************************************************************
336 
337 
338 //*************************************************************************************************
350 template< typename MT // Type of the matrix
351  , bool SO > // Storage order
352 inline const EnableIf_< IsMatScalarDivExpr<MT>, ColumnExprTrait_<MT> >
353  column( const Matrix<MT,SO>& matrix, size_t index )
354 {
356 
357  return column( (~matrix).leftOperand(), index ) / (~matrix).rightOperand();
358 }
360 //*************************************************************************************************
361 
362 
363 //*************************************************************************************************
375 template< typename MT // Type of the matrix
376  , bool SO > // Storage order
377 inline const EnableIf_< IsMatForEachExpr<MT>, ColumnExprTrait_<MT> >
378  column( const Matrix<MT,SO>& matrix, size_t index )
379 {
381 
382  return forEach( column( (~matrix).operand(), index ), (~matrix).operation() );
383 }
385 //*************************************************************************************************
386 
387 
388 //*************************************************************************************************
400 template< typename MT // Type of the matrix
401  , bool SO > // Storage order
402 inline const EnableIf_< IsMatEvalExpr<MT>, ColumnExprTrait_<MT> >
403  column( const Matrix<MT,SO>& matrix, size_t index )
404 {
406 
407  return eval( column( (~matrix).operand(), index ) );
408 }
410 //*************************************************************************************************
411 
412 
413 //*************************************************************************************************
425 template< typename MT // Type of the matrix
426  , bool SO > // Storage order
427 inline const EnableIf_< IsMatSerialExpr<MT>, ColumnExprTrait_<MT> >
428  column( const Matrix<MT,SO>& matrix, size_t index )
429 {
431 
432  return serial( column( (~matrix).operand(), index ) );
433 }
435 //*************************************************************************************************
436 
437 
438 //*************************************************************************************************
450 template< typename MT // Type of the matrix
451  , bool SO > // Storage order
452 inline const EnableIf_< IsMatTransExpr<MT>, ColumnExprTrait_<MT> >
453  column( const Matrix<MT,SO>& matrix, size_t index )
454 {
456 
457  return trans( row( (~matrix).operand(), index ) );
458 }
460 //*************************************************************************************************
461 
462 
463 
464 
465 
466 
467 
468 
469 
470 
471 //=================================================================================================
472 //
473 // COLUMN OPERATORS
474 //
475 //=================================================================================================
476 
477 //*************************************************************************************************
480 template< typename MT, bool SO, bool DF, bool SF >
481 inline void reset( Column<MT,SO,DF,SF>& column );
482 
483 template< typename MT, bool SO, bool DF, bool SF >
484 inline void clear( Column<MT,SO,DF,SF>& column );
485 
486 template< typename MT, bool SO, bool DF, bool SF >
487 inline bool isDefault( const Column<MT,SO,DF,SF>& column );
488 
489 template< typename MT, bool SO, bool DF, bool SF >
490 inline bool isIntact( const Column<MT,SO,DF,SF>& column ) noexcept;
491 
492 template< typename MT, bool SO, bool DF, bool SF >
493 inline bool isSame( const Column<MT,SO,DF,SF>& a, const Column<MT,SO,DF,SF>& b ) noexcept;
495 //*************************************************************************************************
496 
497 
498 //*************************************************************************************************
505 template< typename MT // Type of the matrix
506  , bool SO // Storage order
507  , bool DF // Density flag
508  , bool SF > // Symmetry flag
510 {
511  column.reset();
512 }
513 //*************************************************************************************************
514 
515 
516 //*************************************************************************************************
525 template< typename MT // Type of the dense matrix
526  , bool SO // Storage order
527  , bool DF // Density flag
528  , bool SF > // Symmetry flag
530 {
531  column.reset();
532 }
533 //*************************************************************************************************
534 
535 
536 //*************************************************************************************************
554 template< typename MT // Type of the matrix
555  , bool SO // Storage order
556  , bool DF // Density flag
557  , bool SF > // Symmetry flag
558 inline bool isDefault( const Column<MT,SO,DF,SF>& column )
559 {
560  for( size_t i=0UL; i<column.size(); ++i )
561  if( !isDefault( column[i] ) ) return false;
562  return true;
563 }
564 //*************************************************************************************************
565 
566 
567 //*************************************************************************************************
586 template< typename MT // Type of the sparse matrix
587  , bool SO // Storage order
588  , bool SF > // Symmetry flag
589 inline bool isDefault( const Column<MT,SO,false,SF>& column )
590 {
591  typedef ConstIterator_< Column<MT,SO,false,SF> > ConstIterator;
592 
593  const ConstIterator end( column.end() );
594  for( ConstIterator element=column.begin(); element!=end; ++element )
595  if( !isDefault( element->value() ) ) return false;
596  return true;
597 }
599 //*************************************************************************************************
600 
601 
602 //*************************************************************************************************
619 template< typename MT // Type of the matrix
620  , bool SO // Storage order
621  , bool DF // Density flag
622  , bool SF > // Symmetry flag
623 inline bool isIntact( const Column<MT,SO,DF,SF>& column ) noexcept
624 {
625  return ( column.col_ <= column.matrix_.columns() &&
626  isIntact( column.matrix_ ) );
627 }
628 //*************************************************************************************************
629 
630 
631 //*************************************************************************************************
643 template< typename MT // Type of the matrix
644  , bool SO // Storage order
645  , bool DF // Density flag
646  , bool SF > // Symmetry flag
647 inline bool isSame( const Column<MT,SO,DF,SF>& a, const Column<MT,SO,DF,SF>& b ) noexcept
648 {
649  return ( isSame( a.matrix_, b.matrix_ ) && ( a.col_ == b.col_ ) );
650 }
651 //*************************************************************************************************
652 
653 
654 //*************************************************************************************************
669 template< typename MT // Type of the matrix
670  , bool SO // Storage order
671  , bool DF // Density flag
672  , bool SF // Symmetry flag
673  , typename VT > // Type of the right-hand side vector
674 inline bool tryAssign( const Column<MT,SO,DF,SF>& lhs, const Vector<VT,false>& rhs, size_t index )
675 {
676  BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
677  BLAZE_INTERNAL_ASSERT( (~rhs).size() <= lhs.size() - index, "Invalid vector size" );
678 
679  return tryAssign( lhs.matrix_, ~rhs, index, lhs.col_ );
680 }
682 //*************************************************************************************************
683 
684 
685 //*************************************************************************************************
700 template< typename MT // Type of the matrix
701  , bool SO // Storage order
702  , bool DF // Density flag
703  , bool SF // Symmetry flag
704  , typename VT > // Type of the right-hand side vector
705 inline bool tryAddAssign( const Column<MT,SO,DF,SF>& lhs, const Vector<VT,false>& rhs, size_t index )
706 {
707  BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
708  BLAZE_INTERNAL_ASSERT( (~rhs).size() <= lhs.size() - index, "Invalid vector size" );
709 
710  return tryAddAssign( lhs.matrix_, ~rhs, index, lhs.col_ );
711 }
713 //*************************************************************************************************
714 
715 
716 //*************************************************************************************************
731 template< typename MT // Type of the matrix
732  , bool SO // Storage order
733  , bool DF // Density flag
734  , bool SF // Symmetry flag
735  , typename VT > // Type of the right-hand side vector
736 inline bool trySubAssign( const Column<MT,SO,DF,SF>& lhs, const Vector<VT,false>& rhs, size_t index )
737 {
738  BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
739  BLAZE_INTERNAL_ASSERT( (~rhs).size() <= lhs.size() - index, "Invalid vector size" );
740 
741  return trySubAssign( lhs.matrix_, ~rhs, index, lhs.col_ );
742 }
744 //*************************************************************************************************
745 
746 
747 //*************************************************************************************************
762 template< typename MT // Type of the matrix
763  , bool SO // Storage order
764  , bool DF // Density flag
765  , bool SF // Symmetry flag
766  , typename VT > // Type of the right-hand side vector
767 inline bool tryMultAssign( const Column<MT,SO,DF,SF>& lhs, const Vector<VT,false>& rhs, size_t index )
768 {
769  BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
770  BLAZE_INTERNAL_ASSERT( (~rhs).size() <= lhs.size() - index, "Invalid vector size" );
771 
772  return tryMultAssign( lhs.matrix_, ~rhs, index, lhs.col_ );
773 }
775 //*************************************************************************************************
776 
777 
778 //*************************************************************************************************
793 template< typename MT // Type of the matrix
794  , bool SO // Storage order
795  , bool DF // Density flag
796  , bool SF // Symmetry flag
797  , typename VT > // Type of the right-hand side vector
798 inline bool tryDivAssign( const Column<MT,SO,DF,SF>& lhs, const Vector<VT,false>& rhs, size_t index )
799 {
800  BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
801  BLAZE_INTERNAL_ASSERT( (~rhs).size() <= lhs.size() - index, "Invalid vector size" );
802 
803  return tryDivAssign( lhs.matrix_, ~rhs, index, lhs.col_ );
804 }
806 //*************************************************************************************************
807 
808 
809 //*************************************************************************************************
824 template< typename MT // Type of the matrix
825  , bool SO // Storage order
826  , bool DF // Density flag
827  , bool SF > // Symmetry flag
828 inline DerestrictTrait_< Column<MT,SO,DF,SF> > derestrict( Column<MT,SO,DF,SF>& column )
829 {
830  typedef DerestrictTrait_< Column<MT,SO,DF,SF> > ReturnType;
831  return ReturnType( derestrict( column.matrix_ ), column.col_ );
832 }
834 //*************************************************************************************************
835 
836 
837 
838 
839 //=================================================================================================
840 //
841 // ISRESTRICTED SPECIALIZATIONS
842 //
843 //=================================================================================================
844 
845 //*************************************************************************************************
847 template< typename MT, bool SO, bool DF, bool SF >
848 struct IsRestricted< Column<MT,SO,DF,SF> > : public BoolConstant< IsRestricted<MT>::value >
849 {};
851 //*************************************************************************************************
852 
853 
854 
855 
856 //=================================================================================================
857 //
858 // DERESTRICTTRAIT SPECIALIZATIONS
859 //
860 //=================================================================================================
861 
862 //*************************************************************************************************
864 template< typename MT, bool SO, bool DF, bool SF >
865 struct DerestrictTrait< Column<MT,SO,DF,SF> >
866 {
867  using Type = Column< RemoveReference_< DerestrictTrait_<MT> > >;
868 };
870 //*************************************************************************************************
871 
872 
873 
874 
875 //=================================================================================================
876 //
877 // HASCONSTDATAACCESS SPECIALIZATIONS
878 //
879 //=================================================================================================
880 
881 //*************************************************************************************************
883 template< typename MT, bool SO, bool SF >
884 struct HasConstDataAccess< Column<MT,SO,true,SF> >
885  : public BoolConstant< HasConstDataAccess<MT>::value >
886 {};
888 //*************************************************************************************************
889 
890 
891 
892 
893 //=================================================================================================
894 //
895 // HASMUTABLEDATAACCESS SPECIALIZATIONS
896 //
897 //=================================================================================================
898 
899 //*************************************************************************************************
901 template< typename MT, bool SO, bool SF >
902 struct HasMutableDataAccess< Column<MT,SO,true,SF> >
903  : public BoolConstant< HasMutableDataAccess<MT>::value >
904 {};
906 //*************************************************************************************************
907 
908 
909 
910 
911 //=================================================================================================
912 //
913 // ISALIGNED SPECIALIZATIONS
914 //
915 //=================================================================================================
916 
917 //*************************************************************************************************
919 template< typename MT, bool SO, bool SF >
920 struct IsAligned< Column<MT,SO,true,SF> >
921  : public BoolConstant< And< IsAligned<MT>, Or< IsColumnMajorMatrix<MT>, IsSymmetric<MT> > >::value >
922 {};
924 //*************************************************************************************************
925 
926 
927 
928 
929 //=================================================================================================
930 //
931 // ISPADDED SPECIALIZATIONS
932 //
933 //=================================================================================================
934 
935 //*************************************************************************************************
937 template< typename MT, bool SO, bool SF >
938 struct IsPadded< Column<MT,SO,true,SF> >
939  : public BoolConstant< And< IsPadded<MT>, Or< IsColumnMajorMatrix<MT>, IsSymmetric<MT> > >::value >
940 {};
942 //*************************************************************************************************
943 
944 
945 
946 
947 //=================================================================================================
948 //
949 // ISOPPOSEDVIEW SPECIALIZATIONS
950 //
951 //=================================================================================================
952 
953 //*************************************************************************************************
955 template< typename MT, bool DF >
956 struct IsOpposedView< Column<MT,false,DF,false> >
957  : public TrueType
958 {};
960 //*************************************************************************************************
961 
962 
963 
964 
965 //=================================================================================================
966 //
967 // ADDTRAIT SPECIALIZATIONS
968 //
969 //=================================================================================================
970 
971 //*************************************************************************************************
973 template< typename MT, bool SO, bool DF, bool SF, typename T >
974 struct AddTrait< Column<MT,SO,DF,SF>, T >
975 {
976  using Type = AddTrait_< ColumnTrait_<MT>, T >;
977 };
978 
979 template< typename T, typename MT, bool SO, bool DF, bool SF >
980 struct AddTrait< T, Column<MT,SO,DF,SF> >
981 {
982  using Type = AddTrait_< T, ColumnTrait_<MT> >;
983 };
985 //*************************************************************************************************
986 
987 
988 
989 
990 //=================================================================================================
991 //
992 // SUBTRAIT SPECIALIZATIONS
993 //
994 //=================================================================================================
995 
996 //*************************************************************************************************
998 template< typename MT, bool SO, bool DF, bool SF, typename T >
999 struct SubTrait< Column<MT,SO,DF,SF>, T >
1000 {
1001  using Type = SubTrait_< ColumnTrait_<MT>, T >;
1002 };
1003 
1004 template< typename T, typename MT, bool SO, bool DF, bool SF >
1005 struct SubTrait< T, Column<MT,SO,DF,SF> >
1006 {
1007  using Type = SubTrait_< T, ColumnTrait_<MT> >;
1008 };
1010 //*************************************************************************************************
1011 
1012 
1013 
1014 
1015 //=================================================================================================
1016 //
1017 // MULTTRAIT SPECIALIZATIONS
1018 //
1019 //=================================================================================================
1020 
1021 //*************************************************************************************************
1023 template< typename MT, bool SO, bool DF, bool SF, typename T >
1024 struct MultTrait< Column<MT,SO,DF,SF>, T >
1025 {
1026  using Type = MultTrait_< ColumnTrait_<MT>, T >;
1027 };
1028 
1029 template< typename T, typename MT, bool SO, bool DF, bool SF >
1030 struct MultTrait< T, Column<MT,SO,DF,SF> >
1031 {
1032  using Type = MultTrait_< T, ColumnTrait_<MT> >;
1033 };
1035 //*************************************************************************************************
1036 
1037 
1038 
1039 
1040 //=================================================================================================
1041 //
1042 // CROSSTRAIT SPECIALIZATIONS
1043 //
1044 //=================================================================================================
1045 
1046 //*************************************************************************************************
1048 template< typename MT, bool SO, bool DF, bool SF, typename T >
1049 struct CrossTrait< Column<MT,SO,DF,SF>, T >
1050 {
1051  using Type = CrossTrait_< ColumnTrait_<MT>, T >;
1052 };
1053 
1054 template< typename T, typename MT, bool SO, bool DF, bool SF >
1055 struct CrossTrait< T, Column<MT,SO,DF,SF> >
1056 {
1057  using Type = CrossTrait_< T, ColumnTrait_<MT> >;
1058 };
1060 //*************************************************************************************************
1061 
1062 
1063 
1064 
1065 //=================================================================================================
1066 //
1067 // DIVTRAIT SPECIALIZATIONS
1068 //
1069 //=================================================================================================
1070 
1071 //*************************************************************************************************
1073 template< typename MT, bool SO, bool DF, bool SF, typename T >
1074 struct DivTrait< Column<MT,SO,DF,SF>, T >
1075 {
1076  using Type = DivTrait_< ColumnTrait_<MT>, T >;
1077 };
1078 
1079 template< typename T, typename MT, bool SO, bool DF, bool SF >
1080 struct DivTrait< T, Column<MT,SO,DF,SF> >
1081 {
1082  using Type = DivTrait_< T, ColumnTrait_<MT> >;
1083 };
1085 //*************************************************************************************************
1086 
1087 
1088 
1089 
1090 //=================================================================================================
1091 //
1092 // SUBVECTORTRAIT SPECIALIZATIONS
1093 //
1094 //=================================================================================================
1095 
1096 //*************************************************************************************************
1098 template< typename MT, bool SO, bool DF, bool SF >
1099 struct SubvectorTrait< Column<MT,SO,DF,SF> >
1100 {
1101  using Type = SubvectorTrait_< ResultType_< Column<MT,SO,DF,SF> > >;
1102 };
1104 //*************************************************************************************************
1105 
1106 } // namespace blaze
1107 
1108 #endif
Header file for the subtraction trait.
BLAZE_ALWAYS_INLINE bool isSame(const Matrix< MT1, SO1 > &a, const Matrix< MT2, SO2 > &b) noexcept
Returns whether the two given matrices represent the same observable state.
Definition: Matrix.h:653
Header file for basic type definitions.
BLAZE_ALWAYS_INLINE size_t size(const Vector< VT, TF > &vector) noexcept
Returns the current size/dimension of the vector.
Definition: Vector.h:258
Header file for the ColumnExprTrait class template.
Header file for the IsColumnMajorMatrix type trait.
Header file for the implementation of the Column base template.
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:533
Header file for the And class template.
Header file for the IsTransExpr type trait class.
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:723
BoolConstant< true > TrueType
Type traits base class.The TrueType class is used as base class for type traits and value traits that...
Definition: TrueType.h:61
Header file for the IsMatMatAddExpr type trait class.
DisableIf_< Or< IsComputation< MT >, IsTransExpr< MT > >, ColumnExprTrait_< MT > > column(Matrix< MT, SO > &matrix, size_t index)
Creating a view on a specific column of the given matrix.
Definition: Column.h:126
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:573
Header file for the IsMatTransExpr type trait class.
Column specialization for dense matrices.
Header file for the DisableIf class template.
Header file for the multiplication trait.
Header file for the IsSymmetric type trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
Header file for the IsVecTVecMultExpr type trait class.
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2647
Header file for the Or class template.
Header file for the IsMatMatMultExpr type trait class.
const DMatForEachExpr< MT, OP, SO > forEach(const DenseMatrix< MT, SO > &dm, OP op)
Evaluates the given custom operation on each single element of the dense matrix dm.
Definition: DMatForEachExpr.h:1046
Header file for the IsMatSerialExpr type trait class.
Header file for the IsMatScalarMultExpr type trait class.
Header file for the subvector trait.
Reference to a specific column of a dense or sparse matrix.The Column template represents a reference...
Definition: BaseTemplate.h:354
Header file for the IsAligned type trait.
typename ColumnExprTrait< MT >::Type ColumnExprTrait_
Auxiliary alias declaration for the ColumnExprTrait type trait.The ColumnExprTrait_ alias declaration...
Definition: ColumnExprTrait.h:133
Header file for the IsOpposedView type trait.
Header file for the IsMatEvalExpr type trait class.
BLAZE_ALWAYS_INLINE MT::Iterator end(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator just past the last element of row/column i.
Definition: Matrix.h:254
Header file for the EnableIf class template.
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:553
Header file for the HasConstDataAccess type trait.
DisableIf_< Or< IsComputation< MT >, IsTransExpr< MT > >, RowExprTrait_< MT > > row(Matrix< MT, SO > &matrix, size_t index)
Creating a view on a specific row of the given matrix.
Definition: Row.h:126
Header file for the Matrix base class.
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2642
Header file for the IsMatScalarDivExpr type trait class.
Header file for the addition trait.
Header file for the cross product trait.
Header file for the division trait.
Header file for the column trait.
Base class for matrices.The Matrix class is a base class for all dense and sparse matrix classes with...
Definition: Forward.h:89
Header file for the HasMutableDataAccess type trait.
const DMatEvalExpr< MT, SO > eval(const DenseMatrix< MT, SO > &dm)
Forces the evaluation of the given dense matrix expression dm.
Definition: DMatEvalExpr.h:705
Header file for the IsMatMatSubExpr type trait class.
IntegralConstant< bool, B > BoolConstant
Generic wrapper for a compile time constant boolean value.The BoolConstant class template represents ...
Definition: IntegralConstant.h:100
const DMatTransExpr< MT,!SO > trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:950
Header file for the IsComputation type trait class.
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:157
Header file for the IntegralConstant class template.
bool isIntact(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the invariants of the given diagonal matrix are intact.
Definition: DiagonalMatrix.h:240
Column specialization for sparse matrices.
Header file for the IsMatForEachExpr type trait class.
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.In case of an invalid run time expression, the program execution is terminated. The BLAZE_INTERNAL_ASSERT macro can be disabled by setting the BLAZE_USER_ASSERTION flag to zero or by defining NDEBUG during the compilation.
Definition: Assert.h:101
Header file for the TrueType type/value trait base class.
Header file for the FunctionTrace class.