Blaze 3.9
SMatMeanExpr.h
Go to the documentation of this file.
1//=================================================================================================
33//=================================================================================================
34
35#ifndef _BLAZE_MATH_EXPRESSIONS_SMATMEANEXPR_H_
36#define _BLAZE_MATH_EXPRESSIONS_SMATMEANEXPR_H_
37
38
39//*************************************************************************************************
40// Includes
41//*************************************************************************************************
42
50#include <blaze/util/Assert.h>
55#include <blaze/util/Types.h>
56
57
58namespace blaze {
59
60//=================================================================================================
61//
62// GLOBAL FUNCTIONS
63//
64//=================================================================================================
65
66//*************************************************************************************************
74template< typename MT // Type of the sparse matrix
75 , bool SO > // Storage order
76inline decltype(auto) mean_backend( const SparseMatrix<MT,SO>& sm, FalseType )
77{
78 using BT = UnderlyingBuiltin_t<MT>;
79
80 BLAZE_INTERNAL_ASSERT( size( *sm ) > 0UL, "Invalid matrix size detected" );
81
82 return sum( *sm ) * inv( BT( size( *sm ) ) );
83}
85//*************************************************************************************************
86
87
88//*************************************************************************************************
96template< typename MT // Type of the sparse matrix
97 , bool SO > // Storage order
98inline decltype(auto) mean_backend( const SparseMatrix<MT,SO>& sm, TrueType )
99{
100 MAYBE_UNUSED( sm );
101
102 BLAZE_INTERNAL_ASSERT( size( *sm ) > 0UL, "Invalid matrix size detected" );
103
104 return ElementType_t<MT>();
105}
107//*************************************************************************************************
108
109
110//*************************************************************************************************
136template< typename MT // Type of the sparse matrix
137 , bool SO > // Storage order
138inline decltype(auto) mean( const SparseMatrix<MT,SO>& sm )
139{
141
142 if( size( *sm ) == 0UL ) {
143 BLAZE_THROW_INVALID_ARGUMENT( "Invalid input matrix" );
144 }
145
146 return mean_backend( *sm, IsZero<MT>() );
147}
148//*************************************************************************************************
149
150
151//*************************************************************************************************
160template< ReductionFlag RF // Reduction flag
161 , typename MT // Type of the sparse matrix
162 , bool SO > // Storage order
163decltype(auto) mean_backend( const SparseMatrix<MT,SO>& sm, FalseType )
164{
165 using BT = UnderlyingBuiltin_t<MT>;
166
167 const size_t n( RF == rowwise ? columns( *sm ) : rows( *sm ) );
168
169 BLAZE_INTERNAL_ASSERT( n > 0UL, "Invalid matrix size detected" );
170
171 return sum<RF>( *sm ) * inv( BT( n ) );
172}
174//*************************************************************************************************
175
176
177//*************************************************************************************************
186template< ReductionFlag RF // Reduction flag
187 , typename MT // Type of the sparse matrix
188 , bool SO > // Storage order
189decltype(auto) mean_backend( const SparseMatrix<MT,SO>& sm, TrueType )
190{
191 const size_t n( RF == rowwise ? rows( *sm ) : columns( *sm ) );
192
193 BLAZE_INTERNAL_ASSERT( n > 0UL, "Invalid matrix size detected" );
194
195 constexpr bool TF( ( RF == rowwise ? columnVector : rowVector ) );
196
197 return uniform<TF>( n, ElementType_t<MT>() );
198}
200//*************************************************************************************************
201
202
203//*************************************************************************************************
239template< ReductionFlag RF // Reduction flag
240 , typename MT // Type of the sparse matrix
241 , bool SO > // Storage order
242decltype(auto) mean( const SparseMatrix<MT,SO>& sm )
243{
245
246 BLAZE_STATIC_ASSERT_MSG( RF < 2UL, "Invalid reduction flag" );
247
248 const size_t n( RF == rowwise ? columns( *sm ) : rows( *sm ) );
249
250 if( n == 0UL ) {
251 BLAZE_THROW_INVALID_ARGUMENT( "Invalid input matrix" );
252 }
253
254 return mean_backend<RF>( *sm, IsZero<MT>() );
255}
256//*************************************************************************************************
257
258} // namespace blaze
259
260#endif
Header file for run time assertion macros.
Header file for the function trace functionality.
Header file for the IntegralConstant class template.
Header file for the invert shim.
Header file for the MAYBE_UNUSED function template.
Header file for the reduction flags.
constexpr ReductionFlag rowwise
Reduction flag for row-wise reduction operations.
Definition: ReductionFlag.h:77
size_t ReductionFlag
Type of the reduction flags.
Definition: ReductionFlag.h:57
Compile time assertion.
Header file for the UnderlyingBuiltin type trait.
Base class for sparse matrices.
Definition: SparseMatrix.h:77
Header file for the implementation of a uniform vector.
Header file for the SparseMatrix base class.
decltype(auto) mean(const DenseMatrix< MT, SO > &dm)
Computes the (arithmetic) mean for the given dense matrix.
Definition: DMatMeanExpr.h:134
decltype(auto) inv(const DenseMatrix< MT, SO > &dm)
Calculation of the inverse of the given dense matrix.
Definition: DMatInvExpr.h:405
decltype(auto) sum(const DenseMatrix< MT, SO > &dm)
Reduces the given dense matrix by means of addition.
Definition: DMatReduceExpr.h:2156
constexpr size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition: Matrix.h:644
constexpr size_t columns(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of columns of the matrix.
Definition: Matrix.h:660
constexpr size_t size(const Matrix< MT, SO > &matrix) noexcept
Returns the total number of elements of the matrix.
Definition: Matrix.h:676
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.
Definition: Assert.h:101
#define BLAZE_STATIC_ASSERT_MSG(expr, msg)
Compile time assertion macro.
Definition: StaticAssert.h:123
BoolConstant< true > TrueType
Type traits base class.
Definition: IntegralConstant.h:132
BoolConstant< false > FalseType
Type/value traits base class.
Definition: IntegralConstant.h:121
constexpr void MAYBE_UNUSED(const Args &...)
Suppression of unused parameter warnings.
Definition: MaybeUnused.h:81
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.
Definition: Exception.h:235
#define BLAZE_FUNCTION_TRACE
Function trace macro.
Definition: FunctionTrace.h:94
Header file for the exception macros of the math module.
Compile time check for zero vectors or matrices.
Definition: IsZero.h:109
Header file for the IsZero type trait.
Header file for basic type definitions.