SMatNormExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_SMATNORMEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_SMATNORMEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <utility>
44 #include <blaze/math/Aliases.h>
68 #include <blaze/util/Assert.h>
71 #include <blaze/util/TypeList.h>
72 #include <blaze/util/Types.h>
73 
74 
75 namespace blaze {
76 
77 //=================================================================================================
78 //
79 // GLOBAL FUNCTIONS
80 //
81 //=================================================================================================
82 
83 //*************************************************************************************************
98 template< typename MT // Type of the sparse matrix
99  , bool SO // Storage order
100  , typename Abs // Type of the abs operation
101  , typename Power // Type of the power operation
102  , typename Root > // Type of the root operation
103 inline decltype(auto) norm_backend( const SparseMatrix<MT,SO>& sm, Abs abs, Power power, Root root )
104 {
105  using CT = CompositeType_t<MT>;
106  using ET = ElementType_t<MT>;
107  using RT = decltype( evaluate( root( std::declval<ET>() ) ) );
108 
109  if( (~sm).rows() == 0UL || (~sm).columns() == 0UL ) return RT();
110 
111  CT tmp( ~sm );
112 
113  const size_t N( IsRowMajorMatrix_v<MT> ? tmp.rows(): tmp.columns() );
114 
115  ET norm{};
116 
117  for( size_t i=0UL; i<N; ++i )
118  {
119  const auto end( tmp.end(i) );
120  for( auto element=tmp.begin(i); element!=end; ++element ) {
121  if( IsResizable_v<ET> && isDefault( norm ) )
122  norm = power( abs( element->value() ) );
123  else
124  norm += power( abs( element->value() ) );
125  }
126  }
127 
128  return evaluate( root( norm ) );
129 }
131 //*************************************************************************************************
132 
133 
134 //*************************************************************************************************
149 template< typename MT // Type of the sparse matrix
150  , bool SO > // Storage order
151 decltype(auto) norm( const SparseMatrix<MT,SO>& sm )
152 {
154 
155  return norm_backend( ~sm, SqrAbs(), Noop(), Sqrt() );
156 }
157 //*************************************************************************************************
158 
159 
160 //*************************************************************************************************
175 template< typename MT // Type of the sparse matrix
176  , bool SO > // Storage order
177 decltype(auto) sqrNorm( const SparseMatrix<MT,SO>& sm )
178 {
180 
181  return norm_backend( ~sm, SqrAbs(), Noop(), Noop() );
182 }
183 //*************************************************************************************************
184 
185 
186 //*************************************************************************************************
201 template< typename MT // Type of the sparse matrix
202  , bool SO > // Storage order
203 decltype(auto) l1Norm( const SparseMatrix<MT,SO>& sm )
204 {
206 
207  return norm_backend( ~sm, Abs(), Noop(), Noop() );
208 }
209 //*************************************************************************************************
210 
211 
212 //*************************************************************************************************
227 template< typename MT // Type of the sparse matrix
228  , bool SO > // Storage order
229 decltype(auto) l2Norm( const SparseMatrix<MT,SO>& sm )
230 {
232 
233  return norm_backend( ~sm, SqrAbs(), Noop(), Sqrt() );
234 }
235 //*************************************************************************************************
236 
237 
238 //*************************************************************************************************
253 template< typename MT // Type of the sparse matrix
254  , bool SO > // Storage order
255 decltype(auto) l3Norm( const SparseMatrix<MT,SO>& sm )
256 {
258 
259  return norm_backend( ~sm, Abs(), Pow3(), Cbrt() );
260 }
261 //*************************************************************************************************
262 
263 
264 //*************************************************************************************************
279 template< typename MT // Type of the sparse matrix
280  , bool SO > // Storage order
281 decltype(auto) l4Norm( const SparseMatrix<MT,SO>& sm )
282 {
284 
285  return norm_backend( ~sm, SqrAbs(), Pow2(), Qdrt() );
286 }
287 //*************************************************************************************************
288 
289 
290 //*************************************************************************************************
310 template< typename MT // Type of the sparse matrix
311  , bool SO // Storage order
312  , typename ST > // Type of the norm parameter
313 decltype(auto) lpNorm( const SparseMatrix<MT,SO>& sm, ST p )
314 {
316 
317  BLAZE_USER_ASSERT( !isZero( p ), "Invalid p for Lp norm detected" );
318 
319  using ScalarType = MultTrait_t< UnderlyingBuiltin_t<MT>, decltype( inv( p ) ) >;
320  return norm_backend( ~sm, Abs(), UnaryPow<ScalarType>( p ), UnaryPow<ScalarType>( inv( p ) ) );
321 }
322 //*************************************************************************************************
323 
324 
325 //*************************************************************************************************
344 template< size_t P // Compile time norm parameter
345  , typename MT // Type of the sparse matrix
346  , bool SO > // Storage order
347 inline decltype(auto) lpNorm( const SparseMatrix<MT,SO>& sm )
348 {
349  BLAZE_STATIC_ASSERT_MSG( P > 0UL, "Invalid norm parameter detected" );
350 
352  using Norm = typename TypeAt< Norms, min( P-1UL, 4UL ) >::Type;
353 
354  return Norm()( ~sm );
355 }
356 //*************************************************************************************************
357 
358 
359 //*************************************************************************************************
374 template< typename MT // Type of the sparse matrix
375  , bool SO > // Storage order
376 decltype(auto) maxNorm( const SparseMatrix<MT,SO>& sm )
377 {
379 
380  return max( abs( ~sm ) );
381 }
382 //*************************************************************************************************
383 
384 } // namespace blaze
385 
386 #endif
decltype(auto) sqrNorm(const DenseMatrix< MT, SO > &dm)
Computes the squared L2 norm for the given dense matrix.
Definition: DMatNormExpr.h:496
Header file for the Sqrt functor.
Header file for auxiliary alias declarations.
#define BLAZE_USER_ASSERT(expr, msg)
Run time assertion macro for user checks.In case of an invalid run time expression, the program execution is terminated. The BLAZE_USER_ASSERT macro can be disabled by setting the BLAZE_USER_ASSERT flag to zero or by defining NDEBUG during the compilation.
Definition: Assert.h:117
Generic wrapper for the cbrt() function.
Definition: Cbrt.h:80
Generic wrapper for the squared abs() function.
Definition: SqrAbs.h:84
Header file for basic type definitions.
decltype(auto) l3Norm(const DenseMatrix< MT, SO > &dm)
Computes the L3 norm for the given dense matrix.
Definition: DMatNormExpr.h:574
Header file for the Pow2 functor.
decltype(auto) l2Norm(const DenseMatrix< MT, SO > &dm)
Computes the L2 norm for the given dense matrix.
Definition: DMatNormExpr.h:548
decltype(auto) l4Norm(const DenseMatrix< MT, SO > &dm)
Computes the L4 norm for the given dense matrix.
Definition: DMatNormExpr.h:600
Header file for the isZero shim.
Generic wrapper for the pow() function with fixed exponent.
Definition: Forward.h:129
decltype(auto) lpNorm(const DenseMatrix< MT, SO > &dm, ST p)
Computes the Lp norm for the given dense matrix.
Definition: DMatNormExpr.h:632
Header file for the invert shim.
Generic wrapper for the qdrt() function.
Definition: Qdrt.h:81
#define BLAZE_STATIC_ASSERT_MSG(expr, msg)
Compile time assertion macro.In case of an invalid compile time expression, a compilation error is cr...
Definition: StaticAssert.h:123
const MT::ResultType evaluate(const Matrix< MT, SO > &matrix)
Evaluates the given matrix expression.
Definition: Matrix.h:912
constexpr size_t columns(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of columns of the matrix.
Definition: Matrix.h:514
Header file for the Cbrt functor.
Header file for the LpNorm functor.
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:137
Header file for the SparseMatrix base class.
bool isZero(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is 0.
Definition: DiagonalProxy.h:673
Generic wrapper for the abs() function.
Definition: Abs.h:82
Generic wrapper for the sqrt() function.
Definition: Sqrt.h:82
Header file for the multiplication trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:58
Header file for the L4Norm functor.
Compile time assertion.
Header file for the SqrAbs functor.
Header file for the UnderlyingBuiltin type trait.
decltype(auto) l1Norm(const DenseMatrix< MT, SO > &dm)
Computes the L1 norm for the given dense matrix.
Definition: DMatNormExpr.h:522
decltype(auto) min(const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs)
Computes the componentwise minimum of the dense matrices lhs and rhs.
Definition: DMatDMatMapExpr.h:1147
decltype(auto) inv(const DenseMatrix< MT, SO > &dm)
Calculation of the inverse of the given dense matrix.
Definition: DMatInvExpr.h:423
Header file for the L2Norm functor.
Implementation of a type list.The TypeList class template represents a list of data types of arbitrar...
Definition: TypeList.h:119
Generic wrapper for the null function.
Definition: Noop.h:59
decltype(auto) max(const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs)
Computes the componentwise maximum of the dense matrices lhs and rhs.
Definition: DMatDMatMapExpr.h:1179
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:438
Header file for the Abs functor.
decltype(auto) abs(const DenseMatrix< MT, SO > &dm)
Applies the abs() function to each single element of the dense matrix dm.
Definition: DMatMapExpr.h:1152
decltype(auto) maxNorm(const DenseMatrix< MT, SO > &dm)
Computes the maximum norm for the given dense matrix.
Definition: DMatNormExpr.h:695
typename MultTrait< T1, T2 >::Type MultTrait_t
Auxiliary alias declaration for the MultTrait class template.The MultTrait_t alias declaration provid...
Definition: MultTrait.h:240
Header file for the evaluate shim.
Generic wrapper for the pow2() function.
Definition: Pow2.h:77
Header file for run time assertion macros.
Indexing a type list.The TypeAt class can be used to access a type list at a specified position to qu...
Definition: TypeAt.h:76
Header file for the Unique class template.
Header file for the UnaryPow functor.
#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 isDefault shim.
Header file for the Noop functor.
constexpr size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition: Matrix.h:498
decltype(auto) norm(const DenseMatrix< MT, SO > &dm)
Computes the L2 norm for the given dense matrix.
Definition: DMatNormExpr.h:470
Generic wrapper for the pow3() function.
Definition: Pow3.h:77
Header file for the L3Norm functor.
Header file for the IsRowMajorMatrix type trait.
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:631
Header file for the L1Norm functor.
Header file for the Qdrt functor.
Header file for the IsResizable type trait.
Header file for the Pow3 functor.
Header file for the function trace functionality.