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 
76 #include <blaze/util/mpl/And.h>
77 #include <blaze/util/mpl/Or.h>
78 #include <blaze/util/TrueType.h>
79 #include <blaze/util/Types.h>
80 
81 
82 namespace blaze {
83 
84 //=================================================================================================
85 //
86 // GLOBAL FUNCTIONS
87 //
88 //=================================================================================================
89 
90 //*************************************************************************************************
122 template< typename MT // Type of the matrix
123  , bool SO > // Storage order
124 inline Column<MT> column( Matrix<MT,SO>& matrix, size_t index )
125 {
127 
128  return Column<MT>( ~matrix, index );
129 }
130 //*************************************************************************************************
131 
132 
133 //*************************************************************************************************
165 template< typename MT // Type of the matrix
166  , bool SO > // Storage order
167 inline const Column<const MT> column( const Matrix<MT,SO>& matrix, size_t index )
168 {
170 
171  return Column<const MT>( ~matrix, index );
172 }
173 //*************************************************************************************************
174 
175 
176 //*************************************************************************************************
190 template< typename MT // Type of the matrix
191  , bool SO > // Storage order
192 inline Column<MT> column( Matrix<MT,SO>&& matrix, size_t index )
193 {
195 
196  return Column<MT>( ~matrix, index );
197 }
198 //*************************************************************************************************
199 
200 
201 
202 
203 //=================================================================================================
204 //
205 // GLOBAL RESTRUCTURING FUNCTIONS
206 //
207 //=================================================================================================
208 
209 //*************************************************************************************************
221 template< typename MT > // Matrix base type of the expression
222 inline decltype(auto) column( const MatMatAddExpr<MT>& matrix, size_t index )
223 {
225 
226  return column( (~matrix).leftOperand(), index ) + column( (~matrix).rightOperand(), index );
227 }
229 //*************************************************************************************************
230 
231 
232 //*************************************************************************************************
244 template< typename MT > // Matrix base type of the expression
245 inline decltype(auto) column( const MatMatSubExpr<MT>& matrix, size_t index )
246 {
248 
249  return column( (~matrix).leftOperand(), index ) - column( (~matrix).rightOperand(), index );
250 }
252 //*************************************************************************************************
253 
254 
255 //*************************************************************************************************
267 template< typename MT > // Matrix base type of the expression
268 inline decltype(auto) column( const SchurExpr<MT>& matrix, size_t index )
269 {
271 
272  return column( (~matrix).leftOperand(), index ) * column( (~matrix).rightOperand(), index );
273 }
275 //*************************************************************************************************
276 
277 
278 //*************************************************************************************************
290 template< typename MT > // Matrix base type of the expression
291 inline decltype(auto) column( const MatMatMultExpr<MT>& matrix, size_t index )
292 {
294 
295  return (~matrix).leftOperand() * column( (~matrix).rightOperand(), index );
296 }
298 //*************************************************************************************************
299 
300 
301 //*************************************************************************************************
313 template< typename MT > // Matrix base type of the expression
314 inline decltype(auto) column( const VecTVecMultExpr<MT>& matrix, size_t index )
315 {
317 
318  return (~matrix).leftOperand() * (~matrix).rightOperand()[index];
319 }
321 //*************************************************************************************************
322 
323 
324 //*************************************************************************************************
336 template< typename MT > // Matrix base type of the expression
337 inline decltype(auto) column( const MatScalarMultExpr<MT>& matrix, size_t index )
338 {
340 
341  return column( (~matrix).leftOperand(), index ) * (~matrix).rightOperand();
342 }
344 //*************************************************************************************************
345 
346 
347 //*************************************************************************************************
359 template< typename MT > // Matrix base type of the expression
360 inline decltype(auto) column( const MatScalarDivExpr<MT>& matrix, size_t index )
361 {
363 
364  return column( (~matrix).leftOperand(), index ) / (~matrix).rightOperand();
365 }
367 //*************************************************************************************************
368 
369 
370 //*************************************************************************************************
382 template< typename MT > // Matrix base type of the expression
383 inline decltype(auto) column( const MatMapExpr<MT>& matrix, size_t index )
384 {
386 
387  return map( column( (~matrix).operand(), index ), (~matrix).operation() );
388 }
390 //*************************************************************************************************
391 
392 
393 //*************************************************************************************************
405 template< typename MT > // Matrix base type of the expression
406 inline decltype(auto) column( const MatMatMapExpr<MT>& matrix, size_t index )
407 {
409 
410  return map( column( (~matrix).leftOperand() , index ),
411  column( (~matrix).rightOperand(), index ),
412  (~matrix).operation() );
413 }
415 //*************************************************************************************************
416 
417 
418 //*************************************************************************************************
430 template< typename MT > // Matrix base type of the expression
431 inline decltype(auto) column( const MatEvalExpr<MT>& matrix, size_t index )
432 {
434 
435  return eval( column( (~matrix).operand(), index ) );
436 }
438 //*************************************************************************************************
439 
440 
441 //*************************************************************************************************
453 template< typename MT > // Matrix base type of the expression
454 inline decltype(auto) column( const MatSerialExpr<MT>& matrix, size_t index )
455 {
457 
458  return serial( column( (~matrix).operand(), index ) );
459 }
461 //*************************************************************************************************
462 
463 
464 //*************************************************************************************************
476 template< typename MT > // Matrix base type of the expression
477 inline decltype(auto) column( const DeclExpr<MT>& matrix, size_t index )
478 {
480 
481  return column( (~matrix).operand(), index );
482 }
484 //*************************************************************************************************
485 
486 
487 //*************************************************************************************************
499 template< typename MT > // Matrix base type of the expression
500 inline decltype(auto) column( const MatTransExpr<MT>& matrix, size_t index )
501 {
503 
504  return trans( row( (~matrix).operand(), index ) );
505 }
507 //*************************************************************************************************
508 
509 
510 
511 
512 //=================================================================================================
513 //
514 // COLUMN OPERATORS
515 //
516 //=================================================================================================
517 
518 //*************************************************************************************************
521 template< typename MT, bool SO, bool DF, bool SF >
522 inline void reset( Column<MT,SO,DF,SF>& column );
523 
524 template< typename MT, bool SO, bool DF, bool SF >
525 inline void reset( Column<MT,SO,DF,SF>&& column );
526 
527 template< typename MT, bool SO, bool DF, bool SF >
528 inline void clear( Column<MT,SO,DF,SF>& column );
529 
530 template< typename MT, bool SO, bool DF, bool SF >
531 inline void clear( Column<MT,SO,DF,SF>&& column );
532 
533 template< bool RF, typename MT, bool SO, bool DF, bool SF >
534 inline bool isDefault( const Column<MT,SO,DF,SF>& column );
535 
536 template< typename MT, bool SO, bool DF, bool SF >
537 inline bool isIntact( const Column<MT,SO,DF,SF>& column ) noexcept;
538 
539 template< typename MT, bool SO, bool DF, bool SF >
540 inline bool isSame( const Column<MT,SO,DF,SF>& a, const Column<MT,SO,DF,SF>& b ) noexcept;
542 //*************************************************************************************************
543 
544 
545 //*************************************************************************************************
552 template< typename MT // Type of the matrix
553  , bool SO // Storage order
554  , bool DF // Density flag
555  , bool SF > // Symmetry flag
556 inline void reset( Column<MT,SO,DF,SF>& column )
557 {
558  column.reset();
559 }
560 //*************************************************************************************************
561 
562 
563 //*************************************************************************************************
570 template< typename MT // Type of the matrix
571  , bool SO // Storage order
572  , bool DF // Density flag
573  , bool SF > // Symmetry flag
574 inline void reset( Column<MT,SO,DF,SF>&& column )
575 {
576  column.reset();
577 }
578 //*************************************************************************************************
579 
580 
581 //*************************************************************************************************
590 template< typename MT // Type of the dense matrix
591  , bool SO // Storage order
592  , bool DF // Density flag
593  , bool SF > // Symmetry flag
594 inline void clear( Column<MT,SO,DF,SF>& column )
595 {
596  column.reset();
597 }
598 //*************************************************************************************************
599 
600 
601 //*************************************************************************************************
610 template< typename MT // Type of the dense matrix
611  , bool SO // Storage order
612  , bool DF // Density flag
613  , bool SF > // Symmetry flag
614 inline void clear( Column<MT,SO,DF,SF>&& column )
615 {
616  column.reset();
617 }
618 //*************************************************************************************************
619 
620 
621 //*************************************************************************************************
646 template< bool RF // Relaxation flag
647  , typename MT // Type of the matrix
648  , bool SO // Storage order
649  , bool DF // Density flag
650  , bool SF > // Symmetry flag
651 inline bool isDefault( const Column<MT,SO,DF,SF>& column )
652 {
653  using blaze::isDefault;
654 
655  for( size_t i=0UL; i<column.size(); ++i )
656  if( !isDefault<RF>( column[i] ) ) return false;
657  return true;
658 }
659 //*************************************************************************************************
660 
661 
662 //*************************************************************************************************
681 template< bool RF // Relaxation flag
682  , typename MT // Type of the sparse matrix
683  , bool SO // Storage order
684  , bool SF > // Symmetry flag
685 inline bool isDefault( const Column<MT,SO,false,SF>& column )
686 {
687  using blaze::isDefault;
688 
690 
691  const ConstIterator end( column.end() );
692  for( ConstIterator element=column.begin(); element!=end; ++element )
693  if( !isDefault<RF>( element->value() ) ) return false;
694  return true;
695 }
697 //*************************************************************************************************
698 
699 
700 //*************************************************************************************************
717 template< typename MT // Type of the matrix
718  , bool SO // Storage order
719  , bool DF // Density flag
720  , bool SF > // Symmetry flag
721 inline bool isIntact( const Column<MT,SO,DF,SF>& column ) noexcept
722 {
723  return ( column.column() < column.operand().columns() &&
724  isIntact( column.operand() ) );
725 }
726 //*************************************************************************************************
727 
728 
729 //*************************************************************************************************
741 template< typename MT // Type of the matrix
742  , bool SO // Storage order
743  , bool DF // Density flag
744  , bool SF > // Symmetry flag
745 inline bool isSame( const Column<MT,SO,DF,SF>& a, const Column<MT,SO,DF,SF>& b ) noexcept
746 {
747  return ( isSame( a.operand(), b.operand() ) && ( a.column() == b.column() ) );
748 }
749 //*************************************************************************************************
750 
751 
752 //*************************************************************************************************
767 template< typename MT // Type of the matrix
768  , bool SO // Storage order
769  , bool DF // Density flag
770  , bool SF // Symmetry flag
771  , typename VT > // Type of the right-hand side vector
772 inline bool tryAssign( const Column<MT,SO,DF,SF>& lhs, const Vector<VT,false>& rhs, size_t index )
773 {
774  BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
775  BLAZE_INTERNAL_ASSERT( (~rhs).size() <= lhs.size() - index, "Invalid vector size" );
776 
777  return tryAssign( lhs.operand(), ~rhs, index, lhs.column );
778 }
780 //*************************************************************************************************
781 
782 
783 //*************************************************************************************************
798 template< typename MT // Type of the matrix
799  , bool SO // Storage order
800  , bool DF // Density flag
801  , bool SF // Symmetry flag
802  , typename VT > // Type of the right-hand side vector
803 inline bool tryAddAssign( const Column<MT,SO,DF,SF>& lhs, const Vector<VT,false>& rhs, size_t index )
804 {
805  BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
806  BLAZE_INTERNAL_ASSERT( (~rhs).size() <= lhs.size() - index, "Invalid vector size" );
807 
808  return tryAddAssign( lhs.operand(), ~rhs, index, lhs.column() );
809 }
811 //*************************************************************************************************
812 
813 
814 //*************************************************************************************************
829 template< typename MT // Type of the matrix
830  , bool SO // Storage order
831  , bool DF // Density flag
832  , bool SF // Symmetry flag
833  , typename VT > // Type of the right-hand side vector
834 inline bool trySubAssign( const Column<MT,SO,DF,SF>& lhs, const Vector<VT,false>& rhs, size_t index )
835 {
836  BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
837  BLAZE_INTERNAL_ASSERT( (~rhs).size() <= lhs.size() - index, "Invalid vector size" );
838 
839  return trySubAssign( lhs.operand(), ~rhs, index, lhs.column() );
840 }
842 //*************************************************************************************************
843 
844 
845 //*************************************************************************************************
860 template< typename MT // Type of the matrix
861  , bool SO // Storage order
862  , bool DF // Density flag
863  , bool SF // Symmetry flag
864  , typename VT > // Type of the right-hand side vector
865 inline bool tryMultAssign( const Column<MT,SO,DF,SF>& lhs, const Vector<VT,false>& rhs, size_t index )
866 {
867  BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
868  BLAZE_INTERNAL_ASSERT( (~rhs).size() <= lhs.size() - index, "Invalid vector size" );
869 
870  return tryMultAssign( lhs.operand(), ~rhs, index, lhs.column() );
871 }
873 //*************************************************************************************************
874 
875 
876 //*************************************************************************************************
891 template< typename MT // Type of the matrix
892  , bool SO // Storage order
893  , bool DF // Density flag
894  , bool SF // Symmetry flag
895  , typename VT > // Type of the right-hand side vector
896 inline bool tryDivAssign( const Column<MT,SO,DF,SF>& lhs, const Vector<VT,false>& rhs, size_t index )
897 {
898  BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
899  BLAZE_INTERNAL_ASSERT( (~rhs).size() <= lhs.size() - index, "Invalid vector size" );
900 
901  return tryDivAssign( lhs.operand(), ~rhs, index, lhs.column() );
902 }
904 //*************************************************************************************************
905 
906 
907 //*************************************************************************************************
922 template< typename MT // Type of the matrix
923  , bool SO // Storage order
924  , bool DF // Density flag
925  , bool SF > // Symmetry flag
926 inline decltype(auto) derestrict( Column<MT,SO,DF,SF>& c )
927 {
928  return column( derestrict( c.operand() ), c.column() );
929 }
931 //*************************************************************************************************
932 
933 
934 //*************************************************************************************************
949 template< typename MT // Type of the matrix
950  , bool SO // Storage order
951  , bool DF // Density flag
952  , bool SF > // Symmetry flag
953 inline decltype(auto) derestrict( Column<MT,SO,DF,SF>&& c )
954 {
955  return column( derestrict( c.operand() ), c.column() );
956 }
958 //*************************************************************************************************
959 
960 
961 
962 
963 //=================================================================================================
964 //
965 // ISRESTRICTED SPECIALIZATIONS
966 //
967 //=================================================================================================
968 
969 //*************************************************************************************************
971 template< typename MT, bool SO, bool DF, bool SF >
972 struct IsRestricted< Column<MT,SO,DF,SF> >
973  : public BoolConstant< IsRestricted<MT>::value >
974 {};
976 //*************************************************************************************************
977 
978 
979 
980 
981 //=================================================================================================
982 //
983 // HASCONSTDATAACCESS SPECIALIZATIONS
984 //
985 //=================================================================================================
986 
987 //*************************************************************************************************
989 template< typename MT, bool SO, bool SF >
990 struct HasConstDataAccess< Column<MT,SO,true,SF> >
991  : public BoolConstant< HasConstDataAccess<MT>::value >
992 {};
994 //*************************************************************************************************
995 
996 
997 
998 
999 //=================================================================================================
1000 //
1001 // HASMUTABLEDATAACCESS SPECIALIZATIONS
1002 //
1003 //=================================================================================================
1004 
1005 //*************************************************************************************************
1007 template< typename MT, bool SO, bool SF >
1008 struct HasMutableDataAccess< Column<MT,SO,true,SF> >
1009  : public BoolConstant< HasMutableDataAccess<MT>::value >
1010 {};
1012 //*************************************************************************************************
1013 
1014 
1015 
1016 
1017 //=================================================================================================
1018 //
1019 // ISALIGNED SPECIALIZATIONS
1020 //
1021 //=================================================================================================
1022 
1023 //*************************************************************************************************
1025 template< typename MT, bool SO, bool SF >
1026 struct IsAligned< Column<MT,SO,true,SF> >
1027  : public BoolConstant< And< IsAligned<MT>, Or< IsColumnMajorMatrix<MT>, IsSymmetric<MT> > >::value >
1028 {};
1030 //*************************************************************************************************
1031 
1032 
1033 
1034 
1035 //=================================================================================================
1036 //
1037 // ISPADDED SPECIALIZATIONS
1038 //
1039 //=================================================================================================
1040 
1041 //*************************************************************************************************
1043 template< typename MT, bool SO, bool SF >
1044 struct IsPadded< Column<MT,SO,true,SF> >
1045  : public BoolConstant< And< IsPadded<MT>, Or< IsColumnMajorMatrix<MT>, IsSymmetric<MT> > >::value >
1046 {};
1048 //*************************************************************************************************
1049 
1050 
1051 
1052 
1053 //=================================================================================================
1054 //
1055 // ISOPPOSEDVIEW SPECIALIZATIONS
1056 //
1057 //=================================================================================================
1058 
1059 //*************************************************************************************************
1061 template< typename MT, bool DF >
1062 struct IsOpposedView< Column<MT,false,DF,false> >
1063  : public TrueType
1064 {};
1066 //*************************************************************************************************
1067 
1068 
1069 
1070 
1071 //=================================================================================================
1072 //
1073 // ADDTRAIT SPECIALIZATIONS
1074 //
1075 //=================================================================================================
1076 
1077 //*************************************************************************************************
1079 template< typename MT, bool SO, bool DF, bool SF, typename T >
1080 struct AddTrait< Column<MT,SO,DF,SF>, T >
1081 {
1082  using Type = AddTrait_< ColumnTrait_<MT>, T >;
1083 };
1084 
1085 template< typename T, typename MT, bool SO, bool DF, bool SF >
1086 struct AddTrait< T, Column<MT,SO,DF,SF> >
1087 {
1088  using Type = AddTrait_< T, ColumnTrait_<MT> >;
1089 };
1091 //*************************************************************************************************
1092 
1093 
1094 
1095 
1096 //=================================================================================================
1097 //
1098 // SUBTRAIT SPECIALIZATIONS
1099 //
1100 //=================================================================================================
1101 
1102 //*************************************************************************************************
1104 template< typename MT, bool SO, bool DF, bool SF, typename T >
1105 struct SubTrait< Column<MT,SO,DF,SF>, T >
1106 {
1107  using Type = SubTrait_< ColumnTrait_<MT>, T >;
1108 };
1109 
1110 template< typename T, typename MT, bool SO, bool DF, bool SF >
1111 struct SubTrait< T, Column<MT,SO,DF,SF> >
1112 {
1113  using Type = SubTrait_< T, ColumnTrait_<MT> >;
1114 };
1116 //*************************************************************************************************
1117 
1118 
1119 
1120 
1121 //=================================================================================================
1122 //
1123 // MULTTRAIT SPECIALIZATIONS
1124 //
1125 //=================================================================================================
1126 
1127 //*************************************************************************************************
1129 template< typename MT, bool SO, bool DF, bool SF, typename T >
1130 struct MultTrait< Column<MT,SO,DF,SF>, T >
1131 {
1132  using Type = MultTrait_< ColumnTrait_<MT>, T >;
1133 };
1134 
1135 template< typename T, typename MT, bool SO, bool DF, bool SF >
1136 struct MultTrait< T, Column<MT,SO,DF,SF> >
1137 {
1138  using Type = MultTrait_< T, ColumnTrait_<MT> >;
1139 };
1141 //*************************************************************************************************
1142 
1143 
1144 
1145 
1146 //=================================================================================================
1147 //
1148 // DIVTRAIT SPECIALIZATIONS
1149 //
1150 //=================================================================================================
1151 
1152 //*************************************************************************************************
1154 template< typename MT, bool SO, bool DF, bool SF, typename T >
1155 struct DivTrait< Column<MT,SO,DF,SF>, T >
1156 {
1157  using Type = DivTrait_< ColumnTrait_<MT>, T >;
1158 };
1159 
1160 template< typename T, typename MT, bool SO, bool DF, bool SF >
1161 struct DivTrait< T, Column<MT,SO,DF,SF> >
1162 {
1163  using Type = DivTrait_< T, ColumnTrait_<MT> >;
1164 };
1166 //*************************************************************************************************
1167 
1168 
1169 
1170 
1171 //=================================================================================================
1172 //
1173 // CROSSTRAIT SPECIALIZATIONS
1174 //
1175 //=================================================================================================
1176 
1177 //*************************************************************************************************
1179 template< typename MT, bool SO, bool DF, bool SF, typename T >
1180 struct CrossTrait< Column<MT,SO,DF,SF>, T >
1181 {
1182  using Type = CrossTrait_< ColumnTrait_<MT>, T >;
1183 };
1184 
1185 template< typename T, typename MT, bool SO, bool DF, bool SF >
1186 struct CrossTrait< T, Column<MT,SO,DF,SF> >
1187 {
1188  using Type = CrossTrait_< T, ColumnTrait_<MT> >;
1189 };
1191 //*************************************************************************************************
1192 
1193 
1194 
1195 
1196 //=================================================================================================
1197 //
1198 // SUBVECTORTRAIT SPECIALIZATIONS
1199 //
1200 //=================================================================================================
1201 
1202 //*************************************************************************************************
1204 template< typename MT, bool SO, bool DF, bool SF >
1205 struct SubvectorTrait< Column<MT,SO,DF,SF> >
1206 {
1208 };
1210 //*************************************************************************************************
1211 
1212 } // namespace blaze
1213 
1214 #endif
Base class for all binary matrix map expression templates.The MatMatMapExpr class serves as a tag for...
Definition: MatMatMapExpr.h:66
Compile time check for low-level access to constant data.This type trait tests whether the given data...
Definition: HasConstDataAccess.h:75
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:786
Header file for basic type definitions.
Base class for all matrix serial evaluation expression templates.The MatSerialExpr class serves as a ...
Definition: MatSerialExpr.h:67
Base class for all matrix/scalar division expression templates.The MatScalarDivExpr class serves as a...
Definition: MatScalarDivExpr.h:66
BLAZE_ALWAYS_INLINE size_t size(const Vector< VT, TF > &vector) noexcept
Returns the current size/dimension of the vector.
Definition: Vector.h:265
Generic wrapper for a compile time constant integral value.The IntegralConstant class template repres...
Definition: IntegralConstant.h:71
Header file for the MatTransExpr base class.
Compile time check for resizable data types.This type trait tests whether the given data type is an o...
Definition: IsOpposedView.h:81
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:560
Base class for all matrix/scalar multiplication expression templates.The MatScalarMultExpr class serv...
Definition: MatScalarMultExpr.h:67
Header file for the And class template.
Header file for the MatEvalExpr base class.
typename MultTrait< T1, T2 >::Type MultTrait_
Auxiliary alias declaration for the MultTrait class template.The MultTrait_ alias declaration provide...
Definition: MultTrait.h:250
Column< MT > column(Matrix< MT, SO > &matrix, size_t index)
Creating a view on a specific column of the given matrix.
Definition: Column.h:124
Header file for the MatMatMultExpr base class.
Base template for the CrossTrait class.
Definition: CrossTrait.h:116
Compile time check for data types with restricted data access.This type trait tests whether the given...
Definition: IsRestricted.h:82
Base template for the SubvectorTrait class.
Definition: SubvectorTrait.h:120
Compile time check for low-level access to mutable data.This type trait tests whether the given data ...
Definition: HasMutableDataAccess.h:75
Row< MT > row(Matrix< MT, SO > &matrix, size_t index)
Creating a view on a specific row of the given matrix.
Definition: Row.h:124
Compile time check for the alignment of data types.This type trait tests whether the given data type ...
Definition: IsAligned.h:87
Column specialization for dense matrices.
Header file for the MatMapExpr base class.
Header file for the multiplication trait.
Header file for the IsSymmetric type trait.
Base class for all matrix/matrix subtraction expression templates.The MatMatSubExpr class serves as a...
Definition: MatMatSubExpr.h:67
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
Compile time check for data types with padding.This type trait tests whether the given data type empl...
Definition: IsPadded.h:76
Header file for the Or class template.
typename SubvectorTrait< VT >::Type SubvectorTrait_
Auxiliary alias declaration for the SubvectorTrait type trait.The SubvectorTrait_ alias declaration p...
Definition: SubvectorTrait.h:155
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:3087
Header file for the subvector trait.
Base class for all matrix/matrix addition expression templates.The MatMatAddExpr class serves as a ta...
Definition: MatMatAddExpr.h:66
Header file for the MatMatSubExpr base class.
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.
Base class for all unary matrix map expression templates.The MatMapExpr class serves as a tag for all...
Definition: MatMapExpr.h:66
Header file for the IsOpposedView type trait.
decltype(auto) eval(const DenseMatrix< MT, SO > &dm)
Forces the evaluation of the given dense matrix expression dm.
Definition: DMatEvalExpr.h:797
typename CrossTrait< T1, T2 >::Type CrossTrait_
Auxiliary alias declaration for the CrossTrait class template.The CrossTrait_ alias declaration provi...
Definition: CrossTrait.h:159
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:264
Header file for the MatSerialExpr base class.
Header file for the VecTVecMultExpr base class.
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:580
typename DivTrait< T1, T2 >::Type DivTrait_
Auxiliary alias declaration for the DivTrait class template.The DivTrait_ alias declaration provides ...
Definition: DivTrait.h:250
Header file for the HasConstDataAccess type trait.
Header file for the DeclExpr base class.
Base class for all matrix/matrix multiplication expression templates.The MatMatMultExpr class serves ...
Definition: MatMatMultExpr.h:67
Header file for the Matrix base class.
Header file for the MatScalarMultExpr base class.
Base class for all Schur product expression templates.The SchurExpr class serves as a tag for all exp...
Definition: SchurExpr.h:66
Base template for the AddTrait class.
Definition: AddTrait.h:139
Base template for the MultTrait class.
Definition: MultTrait.h:139
Header file for the addition trait.
Header file for the cross product trait.
Header file for the division trait.
Header file for the SchurExpr base class.
Base class for all matrix evaluation expression templates.The MatEvalExpr class serves as a tag for a...
Definition: MatEvalExpr.h:66
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:94
Header file for the column trait.
Header file for the isDefault shim.
Base class for matrices.The Matrix class is a base class for all dense and sparse matrix classes with...
Definition: Forward.h:101
decltype(auto) serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:819
Base class for all matrix transposition expression templates.The MatTransExpr class serves as a tag f...
Definition: MatTransExpr.h:66
Header file for the HasMutableDataAccess type trait.
Header file for the MatMatAddExpr base class.
Base class for all outer product expression templates.The VecTVecMultExpr class serves as a tag for a...
Definition: VecTVecMultExpr.h:67
Base template for the DivTrait class.
Definition: DivTrait.h:139
typename T::ConstIterator ConstIterator_
Alias declaration for nested ConstIterator type definitions.The ConstIterator_ alias declaration prov...
Definition: Aliases.h:103
decltype(auto) trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:790
Base class for N-dimensional vectors.The Vector class is a base class for all arbitrarily sized (N-di...
Definition: Forward.h:177
Header file for the MatMatMapExpr base class.
typename SubTrait< T1, T2 >::Type SubTrait_
Auxiliary alias declaration for the SubTrait class template.The SubTrait_ alias declaration provides ...
Definition: SubTrait.h:250
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:252
Column specialization for sparse matrices.
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:600
Base template for the SubTrait class.
Definition: SubTrait.h:139
Header file for the MatScalarDivExpr base class.
typename AddTrait< T1, T2 >::Type AddTrait_
Auxiliary alias declaration for the AddTrait class template.The AddTrait_ alias declaration provides ...
Definition: AddTrait.h:250
#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 function trace functionality.
decltype(auto) map(const DenseMatrix< MT1, SO > &lhs, const DenseMatrix< MT2, SO > &rhs, OP op)
Evaluates the given binary operation on each single element of the dense matrices lhs and rhs...
Definition: DMatDMatMapExpr.h:1133