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>
74 
75 
76 namespace blaze {
77 
78 //=================================================================================================
79 //
80 // GLOBAL FUNCTIONS
81 //
82 //=================================================================================================
83 
84 //*************************************************************************************************
99 template< typename MT // Type of the sparse matrix
100  , bool SO // Storage order
101  , typename Abs // Type of the abs operation
102  , typename Power // Type of the power operation
103  , typename Root > // Type of the root operation
104 inline decltype(auto) norm_backend( const SparseMatrix<MT,SO>& sm, Abs abs, Power power, Root root )
105 {
106  using CT = CompositeType_<MT>;
107  using ET = ElementType_<MT>;
108  using RT = decltype( evaluate( root( std::declval<ET>() ) ) );
109 
110  using ConstIterator = ConstIterator_< RemoveReference_<CT> >;
111 
112  if( (~sm).rows() == 0UL || (~sm).columns() == 0UL ) return RT();
113 
114  CT tmp( ~sm );
115 
116  const size_t N( IsRowMajorMatrix<MT>::value ? tmp.rows(): tmp.columns() );
117 
118  ET norm{};
119 
120  for( size_t i=0UL; i<N; ++i )
121  {
122  const ConstIterator end( tmp.end(i) );
123  for( ConstIterator element=tmp.begin(i); element!=end; ++element ) {
124  if( IsResizable<ET>::value && isDefault( norm ) )
125  norm = power( abs( element->value() ) );
126  else
127  norm += power( abs( element->value() ) );
128  }
129  }
130 
131  return evaluate( root( norm ) );
132 }
134 //*************************************************************************************************
135 
136 
137 //*************************************************************************************************
152 template< typename MT // Type of the sparse matrix
153  , bool SO > // Storage order
154 decltype(auto) norm( const SparseMatrix<MT,SO>& sm )
155 {
157 
158  return norm_backend( ~sm, Noop(), Pow2(), Sqrt() );
159 }
160 //*************************************************************************************************
161 
162 
163 //*************************************************************************************************
178 template< typename MT // Type of the sparse matrix
179  , bool SO > // Storage order
180 decltype(auto) sqrNorm( const SparseMatrix<MT,SO>& sm )
181 {
183 
184  return norm_backend( ~sm, Noop(), Pow2(), Noop() );
185 }
186 //*************************************************************************************************
187 
188 
189 //*************************************************************************************************
204 template< typename MT // Type of the sparse matrix
205  , bool SO > // Storage order
206 decltype(auto) l1Norm( const SparseMatrix<MT,SO>& sm )
207 {
209 
210  return norm_backend( ~sm, Abs(), Noop(), Noop() );
211 }
212 //*************************************************************************************************
213 
214 
215 //*************************************************************************************************
230 template< typename MT // Type of the sparse matrix
231  , bool SO > // Storage order
232 decltype(auto) l2Norm( const SparseMatrix<MT,SO>& sm )
233 {
235 
236  return norm_backend( ~sm, Noop(), Pow2(), Sqrt() );
237 }
238 //*************************************************************************************************
239 
240 
241 //*************************************************************************************************
256 template< typename MT // Type of the sparse matrix
257  , bool SO > // Storage order
258 decltype(auto) l3Norm( const SparseMatrix<MT,SO>& sm )
259 {
261 
262  return norm_backend( ~sm, Abs(), Pow3(), Cbrt() );
263 }
264 //*************************************************************************************************
265 
266 
267 //*************************************************************************************************
282 template< typename MT // Type of the sparse matrix
283  , bool SO > // Storage order
284 decltype(auto) l4Norm( const SparseMatrix<MT,SO>& sm )
285 {
287 
288  return norm_backend( ~sm, Noop(), Pow4(), Qdrt() );
289 }
290 //*************************************************************************************************
291 
292 
293 //*************************************************************************************************
313 template< typename MT // Type of the sparse matrix
314  , bool SO // Storage order
315  , typename ST > // Type of the norm parameter
316 decltype(auto) lpNorm( const SparseMatrix<MT,SO>& sm, ST p )
317 {
319 
320  BLAZE_USER_ASSERT( !isZero( p ), "Invalid p for Lp norm detected" );
321 
322  using ScalarType = MultTrait_< UnderlyingBuiltin_<MT>, decltype( inv( p ) ) >;
323  return norm_backend( ~sm, Abs(), UnaryPow<ScalarType>( p ), UnaryPow<ScalarType>( inv( p ) ) );
324 }
325 //*************************************************************************************************
326 
327 
328 //*************************************************************************************************
347 template< size_t P // Compile time norm parameter
348  , typename MT // Type of the sparse matrix
349  , bool SO > // Storage order
350 inline decltype(auto) lpNorm( const SparseMatrix<MT,SO>& sm )
351 {
352  BLAZE_STATIC_ASSERT_MSG( P > 0UL, "Invalid norm parameter detected" );
353 
355  using Norm = typename TypeAt< Norms, min( P-1UL, 4UL ) >::Type;
356 
357  return Norm()( ~sm );
358 }
359 //*************************************************************************************************
360 
361 
362 //*************************************************************************************************
377 template< typename MT // Type of the sparse matrix
378  , bool SO > // Storage order
379 decltype(auto) maxNorm( const SparseMatrix<MT,SO>& sm )
380 {
382 
383  return max( abs( ~sm ) );
384 }
385 //*************************************************************************************************
386 
387 } // namespace blaze
388 
389 #endif
decltype(auto) sqrNorm(const DenseMatrix< MT, SO > &dm)
Computes the squared L2 norm for the given dense matrix.
Definition: DMatNormExpr.h:504
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:62
Header file for the Pow4 functor.
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:582
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:556
decltype(auto) l4Norm(const DenseMatrix< MT, SO > &dm)
Computes the L4 norm for the given dense matrix.
Definition: DMatNormExpr.h:608
const ElementType_< MT > min(const DenseMatrix< MT, SO > &dm)
Returns the smallest element of the dense matrix.
Definition: DenseMatrix.h:1903
Generic wrapper for the pow() function with fixed exponent.
Definition: Forward.h:119
decltype(auto) lpNorm(const DenseMatrix< MT, SO > &dm, ST p)
Computes the Lp norm for the given dense matrix.
Definition: DMatNormExpr.h:640
Header file for the invert shim.
typename MultTrait< T1, T2 >::Type MultTrait_
Auxiliary alias declaration for the MultTrait class template.The MultTrait_ alias declaration provide...
Definition: MultTrait.h:291
Generic wrapper for the qdrt() function.
Definition: Qdrt.h:61
#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:888
const ElementType_< MT > max(const DenseMatrix< MT, SO > &dm)
Returns the largest element of the dense matrix.
Definition: DenseMatrix.h:1950
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:129
Header file for the SparseMatrix base class.
bool isZero(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is 0.
Definition: DiagonalProxy.h:670
Generic wrapper for the sqrt() function.
Definition: Sqrt.h:62
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 UnderlyingBuiltin type trait.
decltype(auto) l1Norm(const DenseMatrix< MT, SO > &dm)
Computes the L1 norm for the given dense matrix.
Definition: DMatNormExpr.h:530
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:3085
Header file for the isZero shim.
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.
BLAZE_ALWAYS_INLINE size_t columns(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of columns of the matrix.
Definition: Matrix.h:506
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
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:430
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:1176
decltype(auto) maxNorm(const DenseMatrix< MT, SO > &dm)
Computes the maximum norm for the given dense matrix.
Definition: DMatNormExpr.h:703
Generic wrapper for the pow4() function.
Definition: Pow4.h:61
Header file for the evaluate shim.
Generic wrapper for the pow2() function.
Definition: Pow2.h:61
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.
Header file for the RemoveReference type trait.
decltype(auto) norm(const DenseMatrix< MT, SO > &dm)
Computes the L2 norm for the given dense matrix.
Definition: DMatNormExpr.h:478
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition: Matrix.h:490
Generic wrapper for the pow3() function.
Definition: Pow3.h:61
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:628
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.