SVecNormExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_SVECNORMEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_SVECNORMEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <utility>
44 #include <blaze/math/Aliases.h>
65 #include <blaze/util/Assert.h>
68 #include <blaze/util/TypeList.h>
70 
71 
72 namespace blaze {
73 
74 //=================================================================================================
75 //
76 // GLOBAL FUNCTIONS
77 //
78 //=================================================================================================
79 
80 //*************************************************************************************************
101 template< typename VT // Type of the sparse vector
102  , bool TF // Transpose flag
103  , typename Abs // Type of the abs operation
104  , typename Power // Type of the power operation
105  , typename Root > // Type of the root operation
106 decltype(auto) norm_backend( const SparseVector<VT,TF>& sv, Abs abs, Power power, Root root )
107 {
108  using CT = CompositeType_<VT>;
109  using ET = ElementType_<VT>;
110  using RT = decltype( evaluate( root( std::declval<ET>() ) ) );
111  using Iterator = ConstIterator_< RemoveReference_<CT> >;
112 
113  if( (~sv).size() == 0UL ) return RT();
114 
115  CT tmp( ~sv );
116 
117  const Iterator end( tmp.end() );
118  Iterator element( tmp.begin() );
119 
120  if( element == end ) return RT();
121 
122  ET norm( power( abs( element->value() ) ) );
123  ++element;
124 
125  for( ; element!=end; ++element ) {
126  norm += power( abs( element->value() ) );
127  }
128 
129  return evaluate( root( norm ) );
130 }
132 //*************************************************************************************************
133 
134 
135 //*************************************************************************************************
150 template< typename VT // Type of the sparse vector
151  , bool TF > // Transpose flag
152 decltype(auto) norm( const SparseVector<VT,TF>& sv )
153 {
155 
156  return norm_backend( ~sv, Noop(), Pow2(), Sqrt() );
157 }
158 //*************************************************************************************************
159 
160 
161 //*************************************************************************************************
176 template< typename VT // Type of the sparse vector
177  , bool TF > // Transpose flag
178 decltype(auto) sqrNorm( const SparseVector<VT,TF>& sv )
179 {
181 
182  return norm_backend( ~sv, Noop(), Pow2(), Noop() );
183 }
184 //*************************************************************************************************
185 
186 
187 //*************************************************************************************************
202 template< typename VT // Type of the sparse vector
203  , bool TF > // Transpose flag
204 decltype(auto) l1Norm( const SparseVector<VT,TF>& sv )
205 {
207 
208  return norm_backend( ~sv, Abs(), Noop(), Noop() );
209 }
210 //*************************************************************************************************
211 
212 
213 //*************************************************************************************************
228 template< typename VT // Type of the sparse vector
229  , bool TF > // Transpose flag
230 decltype(auto) l2Norm( const SparseVector<VT,TF>& sv )
231 {
233 
234  return norm_backend( ~sv, Noop(), Pow2(), Sqrt() );
235 }
236 //*************************************************************************************************
237 
238 
239 //*************************************************************************************************
254 template< typename VT // Type of the sparse vector
255  , bool TF > // Transpose flag
256 decltype(auto) l3Norm( const SparseVector<VT,TF>& sv )
257 {
259 
260  return norm_backend( ~sv, Abs(), Pow3(), Cbrt() );
261 }
262 //*************************************************************************************************
263 
264 
265 //*************************************************************************************************
280 template< typename VT // Type of the sparse vector
281  , bool TF > // Transpose flag
282 decltype(auto) l4Norm( const SparseVector<VT,TF>& sv )
283 {
285 
286  return norm_backend( ~sv, Noop(), Pow4(), Qdrt() );
287 }
288 //*************************************************************************************************
289 
290 
291 //*************************************************************************************************
311 template< typename VT // Type of the sparse vector
312  , bool TF // Transpose flag
313  , typename ST > // Type of the norm parameter
314 decltype(auto) lpNorm( const SparseVector<VT,TF>& sv, ST p )
315 {
317 
318  BLAZE_USER_ASSERT( !isZero( p ), "Invalid p for Lp norm detected" );
319 
320  using ScalarType = MultTrait_< UnderlyingBuiltin_<VT>, decltype( inv( p ) ) >;
321  return norm_backend( ~sv, Abs(), UnaryPow<ScalarType>( p ), UnaryPow<ScalarType>( inv( p ) ) );
322 }
323 //*************************************************************************************************
324 
325 
326 //*************************************************************************************************
345 template< size_t P // Compile time norm parameter
346  , typename VT // Type of the sparse vector
347  , bool TF > // Transpose flag
348 inline decltype(auto) lpNorm( const SparseVector<VT,TF>& sv )
349 {
350  BLAZE_STATIC_ASSERT_MSG( P > 0UL, "Invalid norm parameter detected" );
351 
353  using Norm = typename TypeAt< Norms, min( P-1UL, 4UL ) >::Type;
354 
355  return Norm()( ~sv );
356 }
357 //*************************************************************************************************
358 
359 
360 //*************************************************************************************************
375 template< typename VT // Type of the sparse vector
376  , bool TF > // Transpose flag
377 decltype(auto) maxNorm( const SparseVector<VT,TF>& sv )
378 {
380 
381  return max( abs( ~sv ) );
382 }
383 //*************************************************************************************************
384 
385 } // namespace blaze
386 
387 #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 the SparseVector base class.
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
BLAZE_ALWAYS_INLINE size_t size(const Vector< VT, TF > &vector) noexcept
Returns the current size/dimension of the vector.
Definition: Vector.h:265
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
Element * Iterator
Iterator over non-constant elements.
Definition: CompressedMatrix.h:3084
#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.
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
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.
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 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
Generic wrapper for the pow3() function.
Definition: Pow3.h:61
Header file for the L3Norm functor.
Base class for sparse vectors.The SparseVector class is a base class for all arbitrarily sized (N-dim...
Definition: Forward.h:130
Header file for the L1Norm functor.
Header file for the Qdrt functor.
Header file for the Pow3 functor.
Header file for the function trace functionality.