Row.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_VIEWS_ROW_H_
36 #define _BLAZE_MATH_VIEWS_ROW_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 FUNCTION
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> >, RowExprTrait_<MT> >
126  row( Matrix<MT,SO>& matrix, size_t index )
127 {
129 
130  return RowExprTrait_<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> >, RowExprTrait_<const MT> >
170  row( const Matrix<MT,SO>& matrix, size_t index )
171 {
173 
174  return RowExprTrait_<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> >, RowExprTrait_<MT> >
196  row( Matrix<MT,SO>&& matrix, size_t index )
197 {
199 
200  return RowExprTrait_<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>, RowExprTrait_<MT> >
228  row( const Matrix<MT,SO>& matrix, size_t index )
229 {
231 
232  return row( (~matrix).leftOperand(), index ) + row( (~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>, RowExprTrait_<MT> >
253  row( const Matrix<MT,SO>& matrix, size_t index )
254 {
256 
257  return row( (~matrix).leftOperand(), index ) - row( (~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>, RowExprTrait_<MT> >
278  row( const Matrix<MT,SO>& matrix, size_t index )
279 {
281 
282  return row( (~matrix).leftOperand(), index ) * (~matrix).rightOperand();
283 }
285 //*************************************************************************************************
286 
287 
288 //*************************************************************************************************
299 template< typename MT // Type of the matrix
300  , bool SO > // Storage order
301 inline const EnableIf_< IsVecTVecMultExpr<MT>, RowExprTrait_<MT> >
302  row( const Matrix<MT,SO>& matrix, size_t index )
303 {
305 
306  return (~matrix).leftOperand()[index] * (~matrix).rightOperand();
307 }
309 //*************************************************************************************************
310 
311 
312 //*************************************************************************************************
324 template< typename MT // Type of the matrix
325  , bool SO > // Storage order
326 inline const EnableIf_< IsMatScalarMultExpr<MT>, RowExprTrait_<MT> >
327  row( const Matrix<MT,SO>& matrix, size_t index )
328 {
330 
331  return row( (~matrix).leftOperand(), index ) * (~matrix).rightOperand();
332 }
334 //*************************************************************************************************
335 
336 
337 //*************************************************************************************************
349 template< typename MT // Type of the matrix
350  , bool SO > // Storage order
351 inline const EnableIf_< IsMatScalarDivExpr<MT>, RowExprTrait_<MT> >
352  row( const Matrix<MT,SO>& matrix, size_t index )
353 {
355 
356  return row( (~matrix).leftOperand(), index ) / (~matrix).rightOperand();
357 }
359 //*************************************************************************************************
360 
361 
362 //*************************************************************************************************
374 template< typename MT // Type of the matrix
375  , bool SO > // Storage order
376 inline const EnableIf_< IsMatForEachExpr<MT>, RowExprTrait_<MT> >
377  row( const Matrix<MT,SO>& matrix, size_t index )
378 {
380 
381  return forEach( row( (~matrix).operand(), index ), (~matrix).operation() );
382 }
384 //*************************************************************************************************
385 
386 
387 //*************************************************************************************************
399 template< typename MT // Type of the matrix
400  , bool SO > // Storage order
401 inline const EnableIf_< IsMatEvalExpr<MT>, RowExprTrait_<MT> >
402  row( const Matrix<MT,SO>& matrix, size_t index )
403 {
405 
406  return eval( row( (~matrix).operand(), index ) );
407 }
409 //*************************************************************************************************
410 
411 
412 //*************************************************************************************************
424 template< typename MT // Type of the matrix
425  , bool SO > // Storage order
426 inline const EnableIf_< IsMatSerialExpr<MT>, RowExprTrait_<MT> >
427  row( const Matrix<MT,SO>& matrix, size_t index )
428 {
430 
431  return serial( row( (~matrix).operand(), index ) );
432 }
434 //*************************************************************************************************
435 
436 
437 //*************************************************************************************************
449 template< typename MT // Type of the matrix
450  , bool SO > // Storage order
451 inline const EnableIf_< IsMatTransExpr<MT>, RowExprTrait_<MT> >
452  row( const Matrix<MT,SO>& matrix, size_t index )
453 {
455 
456  return trans( column( (~matrix).operand(), index ) );
457 }
459 //*************************************************************************************************
460 
461 
462 
463 
464 
465 
466 
467 
468 //=================================================================================================
469 //
470 // ROW OPERATORS
471 //
472 //=================================================================================================
473 
474 //*************************************************************************************************
477 template< typename MT, bool SO, bool DF, bool SF >
478 inline void reset( Row<MT,SO,DF,SF>& row );
479 
480 template< typename MT, bool SO, bool DF, bool SF >
481 inline void clear( Row<MT,SO,DF,SF>& row );
482 
483 template< typename MT, bool SO, bool DF, bool SF >
484 inline bool isDefault( const Row<MT,SO,DF,SF>& row );
485 
486 template< typename MT, bool SO, bool DF, bool SF >
487 inline bool isIntact( const Row<MT,SO,DF,SF>& row ) noexcept;
488 
489 template< typename MT, bool SO, bool DF, bool SF >
490 inline bool isSame( const Row<MT,SO,DF,SF>& a, const Row<MT,SO,DF,SF>& b ) noexcept;
492 //*************************************************************************************************
493 
494 
495 //*************************************************************************************************
502 template< typename MT // Type of the matrix
503  , bool SO // Storage order
504  , bool DF // Density flag
505  , bool SF > // Symmetry flag
506 inline void reset( Row<MT,SO,DF,SF>& row )
507 {
508  row.reset();
509 }
510 //*************************************************************************************************
511 
512 
513 //*************************************************************************************************
522 template< typename MT // Type of the matrix
523  , bool SO // Storage order
524  , bool DF // Density flag
525  , bool SF > // Symmetry flag
526 inline void clear( Row<MT,SO,DF,SF>& row )
527 {
528  row.reset();
529 }
530 //*************************************************************************************************
531 
532 
533 //*************************************************************************************************
551 template< typename MT // Type of the matrix
552  , bool SO // Storage order
553  , bool DF // Density flag
554  , bool SF > // Symmetry flag
555 inline bool isDefault( const Row<MT,SO,DF,SF>& row )
556 {
557  for( size_t i=0UL; i<row.size(); ++i )
558  if( !isDefault( row[i] ) ) return false;
559  return true;
560 }
561 //*************************************************************************************************
562 
563 
564 //*************************************************************************************************
583 template< typename MT // Type of the sparse matrix
584  , bool SO // Storage order
585  , bool SF > // Symmetry flag
586 inline bool isDefault( const Row<MT,SO,false,SF>& row )
587 {
588  typedef ConstIterator_< Row<MT,SO,false,SF> > ConstIterator;
589 
590  const ConstIterator end( row.end() );
591  for( ConstIterator element=row.begin(); element!=end; ++element )
592  if( !isDefault( element->value() ) ) return false;
593  return true;
594 }
596 //*************************************************************************************************
597 
598 
599 //*************************************************************************************************
616 template< typename MT // Type of the matrix
617  , bool SO // Storage order
618  , bool DF // Density flag
619  , bool SF > // Symmetry flag
620 inline bool isIntact( const Row<MT,SO,DF,SF>& row ) noexcept
621 {
622  return ( row.row_ <= row.matrix_.rows() &&
623  isIntact( row.matrix_ ) );
624 }
625 //*************************************************************************************************
626 
627 
628 //*************************************************************************************************
640 template< typename MT // Type of the matrix
641  , bool SO // Storage order
642  , bool DF // Density flag
643  , bool SF > // Symmetry flag
644 inline bool isSame( const Row<MT,SO,DF,SF>& a, const Row<MT,SO,DF,SF>& b ) noexcept
645 {
646  return ( isSame( a.matrix_, b.matrix_ ) && ( a.row_ == b.row_ ) );
647 }
648 //*************************************************************************************************
649 
650 
651 //*************************************************************************************************
666 template< typename MT // Type of the matrix
667  , bool SO // Storage order
668  , bool DF // Density flag
669  , bool SF // Symmetry flag
670  , typename VT > // Type of the right-hand side vector
671 inline bool tryAssign( const Row<MT,SO,DF,SF>& lhs, const Vector<VT,true>& rhs, size_t index )
672 {
673  BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
674  BLAZE_INTERNAL_ASSERT( (~rhs).size() <= lhs.size() - index, "Invalid vector size" );
675 
676  return tryAssign( lhs.matrix_, ~rhs, lhs.row_, index );
677 }
679 //*************************************************************************************************
680 
681 
682 //*************************************************************************************************
697 template< typename MT // Type of the matrix
698  , bool SO // Storage order
699  , bool DF // Density flag
700  , bool SF // Symmetry flag
701  , typename VT > // Type of the right-hand side vector
702 inline bool tryAddAssign( const Row<MT,SO,DF,SF>& lhs, const Vector<VT,true>& rhs, size_t index )
703 {
704  BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
705  BLAZE_INTERNAL_ASSERT( (~rhs).size() <= lhs.size() - index, "Invalid vector size" );
706 
707  return tryAddAssign( lhs.matrix_, ~rhs, lhs.row_, index );
708 }
710 //*************************************************************************************************
711 
712 
713 //*************************************************************************************************
728 template< typename MT // Type of the matrix
729  , bool SO // Storage order
730  , bool DF // Density flag
731  , bool SF // Symmetry flag
732  , typename VT > // Type of the right-hand side vector
733 inline bool trySubAssign( const Row<MT,SO,DF,SF>& lhs, const Vector<VT,true>& rhs, size_t index )
734 {
735  BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
736  BLAZE_INTERNAL_ASSERT( (~rhs).size() <= lhs.size() - index, "Invalid vector size" );
737 
738  return trySubAssign( lhs.matrix_, ~rhs, lhs.row_, index );
739 }
741 //*************************************************************************************************
742 
743 
744 //*************************************************************************************************
759 template< typename MT // Type of the matrix
760  , bool SO // Storage order
761  , bool DF // Density flag
762  , bool SF // Symmetry flag
763  , typename VT > // Type of the right-hand side vector
764 inline bool tryMultAssign( const Row<MT,SO,DF,SF>& lhs, const Vector<VT,true>& rhs, size_t index )
765 {
766  BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
767  BLAZE_INTERNAL_ASSERT( (~rhs).size() <= lhs.size() - index, "Invalid vector size" );
768 
769  return tryMultAssign( lhs.matrix_, ~rhs, lhs.row_, index );
770 }
772 //*************************************************************************************************
773 
774 
775 //*************************************************************************************************
790 template< typename MT // Type of the matrix
791  , bool SO // Storage order
792  , bool DF // Density flag
793  , bool SF // Symmetry flag
794  , typename VT > // Type of the right-hand side vector
795 inline bool tryDivAssign( const Row<MT,SO,DF,SF>& lhs, const Vector<VT,true>& rhs, size_t index )
796 {
797  BLAZE_INTERNAL_ASSERT( index <= lhs.size(), "Invalid vector access index" );
798  BLAZE_INTERNAL_ASSERT( (~rhs).size() <= lhs.size() - index, "Invalid vector size" );
799 
800  return tryDivAssign( lhs.matrix_, ~rhs, lhs.row_, index );
801 }
803 //*************************************************************************************************
804 
805 
806 //*************************************************************************************************
821 template< typename MT // Type of the matrix
822  , bool SO // Storage order
823  , bool DF // Density flag
824  , bool SF > // Symmetry flag
825 inline DerestrictTrait_< Row<MT,SO,DF,SF> > derestrict( Row<MT,SO,DF,SF>& row )
826 {
827  typedef DerestrictTrait_< Row<MT,SO,DF,SF> > ReturnType;
828  return ReturnType( derestrict( row.matrix_ ), row.row_ );
829 }
831 //*************************************************************************************************
832 
833 
834 
835 
836 //=================================================================================================
837 //
838 // ISRESTRICTED SPECIALIZATIONS
839 //
840 //=================================================================================================
841 
842 //*************************************************************************************************
844 template< typename MT, bool SO, bool DF, bool SF >
845 struct IsRestricted< Row<MT,SO,DF,SF> >
846  : public BoolConstant< IsRestricted<MT>::value >
847 {};
849 //*************************************************************************************************
850 
851 
852 
853 
854 //=================================================================================================
855 //
856 // DERESTRICTTRAIT SPECIALIZATIONS
857 //
858 //=================================================================================================
859 
860 //*************************************************************************************************
862 template< typename MT, bool SO, bool DF, bool SF >
863 struct DerestrictTrait< Row<MT,SO,DF,SF> >
864 {
865  using Type = Row< RemoveReference_< DerestrictTrait_<MT> > >;
866 };
868 //*************************************************************************************************
869 
870 
871 
872 
873 //=================================================================================================
874 //
875 // HASCONSTDATAACCESS SPECIALIZATIONS
876 //
877 //=================================================================================================
878 
879 //*************************************************************************************************
881 template< typename MT, bool SO, bool SF >
882 struct HasConstDataAccess< Row<MT,SO,true,SF> >
883  : public BoolConstant< HasConstDataAccess<MT>::value >
884 {};
886 //*************************************************************************************************
887 
888 
889 
890 
891 //=================================================================================================
892 //
893 // HASMUTABLEDATAACCESS SPECIALIZATIONS
894 //
895 //=================================================================================================
896 
897 //*************************************************************************************************
899 template< typename MT, bool SO, bool SF >
900 struct HasMutableDataAccess< Row<MT,SO,true,SF> >
901  : public BoolConstant< HasMutableDataAccess<MT>::value >
902 {};
904 //*************************************************************************************************
905 
906 
907 
908 
909 //=================================================================================================
910 //
911 // ISALIGNED SPECIALIZATIONS
912 //
913 //=================================================================================================
914 
915 //*************************************************************************************************
917 template< typename MT, bool SO, bool SF >
918 struct IsAligned< Row<MT,SO,true,SF> >
919  : public BoolConstant< And< IsAligned<MT>, Or< IsRowMajorMatrix<MT>, IsSymmetric<MT> > >::value >
920 {};
922 //*************************************************************************************************
923 
924 
925 
926 
927 //=================================================================================================
928 //
929 // ISPADDED SPECIALIZATIONS
930 //
931 //=================================================================================================
932 
933 //*************************************************************************************************
935 template< typename MT, bool SO, bool SF >
936 struct IsPadded< Row<MT,SO,true,SF> >
937  : public BoolConstant< And< IsPadded<MT>, Or< IsRowMajorMatrix<MT>, IsSymmetric<MT> > >::value >
938 {};
940 //*************************************************************************************************
941 
942 
943 
944 
945 //=================================================================================================
946 //
947 // ISOPPOSEDVIEW SPECIALIZATIONS
948 //
949 //=================================================================================================
950 
951 //*************************************************************************************************
953 template< typename MT, bool DF >
954 struct IsOpposedView< Row<MT,false,DF,false> >
955  : public TrueType
956 {};
958 //*************************************************************************************************
959 
960 
961 
962 
963 //=================================================================================================
964 //
965 // ADDTRAIT SPECIALIZATIONS
966 //
967 //=================================================================================================
968 
969 //*************************************************************************************************
971 template< typename MT, bool SO, bool DF, bool SF, typename T >
972 struct AddTrait< Row<MT,SO,DF,SF>, T >
973 {
974  using Type = AddTrait_< RowTrait_<MT>, T >;
975 };
976 
977 template< typename T, typename MT, bool SO, bool DF, bool SF >
978 struct AddTrait< T, Row<MT,SO,DF,SF> >
979 {
980  using Type = AddTrait_< T, RowTrait_<MT> >;
981 };
983 //*************************************************************************************************
984 
985 
986 
987 
988 //=================================================================================================
989 //
990 // SUBTRAIT SPECIALIZATIONS
991 //
992 //=================================================================================================
993 
994 //*************************************************************************************************
996 template< typename MT, bool SO, bool DF, bool SF, typename T >
997 struct SubTrait< Row<MT,SO,DF,SF>, T >
998 {
999  using Type = SubTrait_< RowTrait_<MT>, T >;
1000 };
1001 
1002 template< typename T, typename MT, bool SO, bool DF, bool SF >
1003 struct SubTrait< T, Row<MT,SO,DF,SF> >
1004 {
1005  using Type = SubTrait_< T, RowTrait_<MT> >;
1006 };
1008 //*************************************************************************************************
1009 
1010 
1011 
1012 
1013 //=================================================================================================
1014 //
1015 // MULTTRAIT SPECIALIZATIONS
1016 //
1017 //=================================================================================================
1018 
1019 //*************************************************************************************************
1021 template< typename MT, bool SO, bool DF, bool SF, typename T >
1022 struct MultTrait< Row<MT,SO,DF,SF>, T >
1023 {
1024  using Type = MultTrait_< RowTrait_<MT>, T >;
1025 };
1026 
1027 template< typename T, typename MT, bool SO, bool DF, bool SF >
1028 struct MultTrait< T, Row<MT,SO,DF,SF> >
1029 {
1030  using Type = MultTrait_< T, RowTrait_<MT> >;
1031 };
1033 //*************************************************************************************************
1034 
1035 
1036 
1037 
1038 //=================================================================================================
1039 //
1040 // CROSSTRAIT SPECIALIZATIONS
1041 //
1042 //=================================================================================================
1043 
1044 //*************************************************************************************************
1046 template< typename MT, bool SO, bool DF, bool SF, typename T >
1047 struct CrossTrait< Row<MT,SO,DF,SF>, T >
1048 {
1049  using Type = CrossTrait_< RowTrait_<MT>, T >;
1050 };
1051 
1052 template< typename T, typename MT, bool SO, bool DF, bool SF >
1053 struct CrossTrait< T, Row<MT,SO,DF,SF> >
1054 {
1055  using Type = CrossTrait_< T, RowTrait_<MT> >;
1056 };
1058 //*************************************************************************************************
1059 
1060 
1061 
1062 
1063 //=================================================================================================
1064 //
1065 // DIVTRAIT SPECIALIZATIONS
1066 //
1067 //=================================================================================================
1068 
1069 //*************************************************************************************************
1071 template< typename MT, bool SO, bool DF, bool SF, typename T >
1072 struct DivTrait< Row<MT,SO,DF,SF>, T >
1073 {
1074  using Type = DivTrait_< RowTrait_<MT>, T >;
1075 };
1076 
1077 template< typename T, typename MT, bool SO, bool DF, bool SF >
1078 struct DivTrait< T, Row<MT,SO,DF,SF> >
1079 {
1080  using Type = DivTrait_< T, RowTrait_<MT> >;
1081 };
1083 //*************************************************************************************************
1084 
1085 
1086 
1087 
1088 //=================================================================================================
1089 //
1090 // SUBVECTORTRAIT SPECIALIZATIONS
1091 //
1092 //=================================================================================================
1093 
1094 //*************************************************************************************************
1096 template< typename MT, bool SO, bool DF, bool SF >
1097 struct SubvectorTrait< Row<MT,SO,DF,SF> >
1098 {
1099  using Type = SubvectorTrait_< ResultType_< Row<MT,SO,DF,SF> > >;
1100 };
1102 //*************************************************************************************************
1103 
1104 } // namespace blaze
1105 
1106 #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.
Header file for the row trait.
BLAZE_ALWAYS_INLINE size_t size(const Vector< VT, TF > &vector) noexcept
Returns the current size/dimension of the vector.
Definition: Vector.h:258
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:533
Row specialization for dense matrices.
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
Row specialization for sparse matrices.
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.
Header file for the DisableIf class template.
typename RowExprTrait< MT >::Type RowExprTrait_
Auxiliary alias declaration for the RowExprTrait type trait.The RowExprTrait_ alias declaration provi...
Definition: RowExprTrait.h:134
Header file for the implementation of the Row base 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.
Header file for the IsAligned type trait.
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 RowExprTrait class template.
Header file for the EnableIf class template.
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:553
Reference to a specific row of a dense or sparse matrix.The Row template represents a reference to a ...
Definition: Forward.h:48
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.
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
Header file for the IsRowMajorMatrix type trait.
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
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.