Blaze 3.9
DMatNormExpr.h
Go to the documentation of this file.
1//=================================================================================================
33//=================================================================================================
34
35#ifndef _BLAZE_MATH_EXPRESSIONS_DMATNORMEXPR_H_
36#define _BLAZE_MATH_EXPRESSIONS_DMATNORMEXPR_H_
37
38
39//*************************************************************************************************
40// Includes
41//*************************************************************************************************
42
43#include <utility>
44#include <blaze/math/Aliases.h>
65#include <blaze/math/SIMD.h>
73#include <blaze/util/Assert.h>
76#include <blaze/util/mpl/And.h>
77#include <blaze/util/mpl/If.h>
79#include <blaze/util/TypeList.h>
80#include <blaze/util/Types.h>
84
85
86namespace blaze {
87
88//=================================================================================================
89//
90// CLASS DEFINITION
91//
92//=================================================================================================
93
94//*************************************************************************************************
99template< typename MT // Type of the dense matrix
100 , typename Abs // Type of the abs operation
101 , typename Power > // Type of the power operation
102struct DMatNormHelper
103{
104 //**Type definitions****************************************************************************
106 using ET = ElementType_t<MT>;
107
109 using CT = RemoveReference_t< CompositeType_t<MT> >;
110 //**********************************************************************************************
111
112 //**********************************************************************************************
113 static constexpr bool value =
114 ( useOptimizedKernels &&
115 CT::simdEnabled &&
116 If_t< HasSIMDEnabled_v<Abs> && HasSIMDEnabled_v<Power>
117 , And_t< GetSIMDEnabled<Abs,ET>, GetSIMDEnabled<Power,ET> >
118 , And_t< HasLoad<Abs>, HasLoad<Power> > >::value &&
119 HasSIMDAdd_v< ElementType_t<CT>, ElementType_t<CT> > );
120 //**********************************************************************************************
121};
123//*************************************************************************************************
124
125
126
127
128//=================================================================================================
129//
130// GLOBAL FUNCTIONS
131//
132//=================================================================================================
133
134//*************************************************************************************************
149template< typename MT // Type of the dense matrix
150 , typename Abs // Type of the abs opertaion
151 , typename Power // Type of the power operation
152 , typename Root > // Type of the root operation
153inline decltype(auto) norm_backend( const DenseMatrix<MT,false>& dm, Abs abs, Power power, Root root, FalseType )
154{
155 using CT = CompositeType_t<MT>;
156 using ET = ElementType_t<MT>;
157 using PT = RemoveCVRef_t< decltype( power( abs( std::declval<ET>() ) ) ) >;
158 using RT = RemoveCVRef_t< decltype( evaluate( root( std::declval<PT>() ) ) ) >;
159
160 if( (*dm).rows() == 0UL || (*dm).columns() == 0UL ) return RT{};
161
162 CT tmp( *dm );
163
164 const size_t M( tmp.rows() );
165 const size_t N( tmp.columns() );
166
167 PT norm( power( abs( tmp(0UL,0UL) ) ) );
168
169 {
170 size_t j( 1UL );
171
172 for( ; (j+4UL) <= N; j+=4UL ) {
173 norm += power( abs( tmp(0UL,j ) ) ) + power( abs( tmp(0UL,j+1UL) ) ) +
174 power( abs( tmp(0UL,j+2UL) ) ) + power( abs( tmp(0UL,j+3UL) ) );
175 }
176 for( ; (j+2UL) <= N; j+=2UL ) {
177 norm += power( abs( tmp(0UL,j) ) ) + power( abs( tmp(0UL,j+1UL) ) );
178 }
179 for( ; j<N; ++j ) {
180 norm += power( abs( tmp(0UL,j) ) );
181 }
182 }
183
184 for( size_t i=1UL; i<M; ++i )
185 {
186 size_t j( 0UL );
187
188 for( ; (j+4UL) <= N; j+=4UL ) {
189 norm += power( abs( tmp(i,j ) ) ) + power( abs( tmp(i,j+1UL) ) ) +
190 power( abs( tmp(i,j+2UL) ) ) + power( abs( tmp(i,j+3UL) ) );
191 }
192 for( ; (j+2UL) <= N; j+=2UL ) {
193 norm += power( abs( tmp(i,j) ) ) + power( abs( tmp(i,j+1UL) ) );
194 }
195 for( ; j<N; ++j ) {
196 norm += power( abs( tmp(i,j) ) );
197 }
198 }
199
200 return evaluate( root( norm ) );
201}
203//*************************************************************************************************
204
205
206//*************************************************************************************************
221template< typename MT // Type of the dense matrix
222 , typename Abs // Type of the abs operation
223 , typename Power // Type of the power operation
224 , typename Root > // Type of the root operation
225inline decltype(auto) norm_backend( const DenseMatrix<MT,true>& dm, Abs abs, Power power, Root root, FalseType )
226{
227 using CT = CompositeType_t<MT>;
228 using ET = ElementType_t<MT>;
229 using PT = RemoveCVRef_t< decltype( power( abs( std::declval<ET>() ) ) ) >;
230 using RT = RemoveCVRef_t< decltype( evaluate( root( std::declval<PT>() ) ) ) >;
231
232 if( (*dm).rows() == 0UL || (*dm).columns() == 0UL ) return RT{};
233
234 CT tmp( *dm );
235
236 const size_t M( tmp.rows() );
237 const size_t N( tmp.columns() );
238
239 PT norm( power( abs( tmp(0UL,0UL) ) ) );
240
241 {
242 size_t i( 1UL );
243
244 for( ; (i+4UL) <= M; i+=4UL ) {
245 norm += power( abs( tmp(i ,0UL) ) ) + power( abs( tmp(i+1UL,0UL) ) ) +
246 power( abs( tmp(i+2UL,0UL) ) ) + power( abs( tmp(i+3UL,0UL) ) );
247 }
248 for( ; (i+2UL) <= M; i+=2UL ) {
249 norm += power( abs( tmp(i,0UL) ) ) + power( abs( tmp(i+1UL,0UL) ) );
250 }
251 for( ; i<M; ++i ) {
252 norm += power( abs( tmp(i,0UL) ) );
253 }
254 }
255
256 for( size_t j=1UL; j<N; ++j )
257 {
258 size_t i( 0UL );
259
260 for( ; (i+4UL) <= M; i+=4UL ) {
261 norm += power( abs( tmp(i ,j) ) ) + power( abs( tmp(i+1UL,j) ) ) +
262 power( abs( tmp(i+2UL,j) ) ) + power( abs( tmp(i+3UL,j) ) );
263 }
264 for( ; (i+2UL) <= M; i+=2UL ) {
265 norm += power( abs( tmp(i,j) ) ) + power( abs( tmp(i+1UL,j) ) );
266 }
267 for( ; i<M; ++i ) {
268 norm += power( abs( tmp(i,j) ) );
269 }
270 }
271
272 return evaluate( root( norm ) );
273}
275//*************************************************************************************************
276
277
278//*************************************************************************************************
293template< typename MT // Type of the dense matrix
294 , typename Abs // Type of the abs operation
295 , typename Power // Type of the power operation
296 , typename Root > // Type of the root operation
297inline decltype(auto) norm_backend( const DenseMatrix<MT,false>& dm, Abs abs, Power power, Root root, TrueType )
298{
299 using CT = CompositeType_t<MT>;
300 using ET = ElementType_t<MT>;
301 using RT = decltype( evaluate( root( std::declval<ET>() ) ) );
302
303 static constexpr size_t SIMDSIZE = SIMDTrait<ET>::size;
304
305 if( (*dm).rows() == 0UL || (*dm).columns() == 0UL ) return RT{};
306
307 CT tmp( *dm );
308
309 const size_t M( tmp.rows() );
310 const size_t N( tmp.columns() );
311
312 constexpr bool remainder( !IsPadded_v< RemoveReference_t<CT> > );
313
314 ET norm{};
315
316 if( !remainder || N >= SIMDSIZE )
317 {
318 const size_t jpos( remainder ? prevMultiple( N, SIMDSIZE ) : N );
319 BLAZE_INTERNAL_ASSERT( jpos <= N, "Invalid end calculation" );
320
321 SIMDTrait_t<ET> xmm1{};
322 size_t i( 0UL );
323
324 for( ; (i+4UL) <= M; i+=4UL )
325 {
326 xmm1 += power( abs( tmp.load(i,0UL) ) );
327 SIMDTrait_t<ET> xmm2( power( abs( tmp.load(i+1UL,0UL) ) ) );
328 SIMDTrait_t<ET> xmm3( power( abs( tmp.load(i+2UL,0UL) ) ) );
329 SIMDTrait_t<ET> xmm4( power( abs( tmp.load(i+3UL,0UL) ) ) );
330 size_t j( SIMDSIZE );
331
332 for( ; j<jpos; j+=SIMDSIZE ) {
333 xmm1 += power( abs( tmp.load(i ,j) ) );
334 xmm2 += power( abs( tmp.load(i+1UL,j) ) );
335 xmm3 += power( abs( tmp.load(i+2UL,j) ) );
336 xmm4 += power( abs( tmp.load(i+3UL,j) ) );
337 }
338 for( ; remainder && j<N; ++j ) {
339 norm += power( abs( tmp(i ,j) ) );
340 norm += power( abs( tmp(i+1UL,j) ) );
341 norm += power( abs( tmp(i+2UL,j) ) );
342 norm += power( abs( tmp(i+3UL,j) ) );
343 }
344
345 xmm1 += xmm2;
346 xmm3 += xmm4;
347 xmm1 += xmm3;
348 }
349
350 if( i+2UL <= M )
351 {
352 xmm1 += power( abs( tmp.load(i,0UL) ) );
353 SIMDTrait_t<ET> xmm2( power( abs( tmp.load(i+1UL,0UL) ) ) );
354 size_t j( SIMDSIZE );
355
356 for( ; j<jpos; j+=SIMDSIZE ) {
357 xmm1 += power( abs( tmp.load(i ,j) ) );
358 xmm2 += power( abs( tmp.load(i+1UL,j) ) );
359 }
360 for( ; remainder && j<N; ++j ) {
361 norm += power( abs( tmp(i ,j) ) );
362 norm += power( abs( tmp(i+1UL,j) ) );
363 }
364
365 xmm1 += xmm2;
366
367 i += 2UL;
368 }
369
370 if( i < M )
371 {
372 xmm1 += power( abs( tmp.load(i,0UL) ) );
373 size_t j( SIMDSIZE );
374
375 for( ; j<jpos; j+=SIMDSIZE ) {
376 xmm1 += power( abs( tmp.load(i,j) ) );
377 }
378 for( ; remainder && j<N; ++j ) {
379 norm += power( abs( tmp(i,j) ) );
380 }
381 }
382
383 norm += sum( xmm1 );
384 }
385 else
386 {
387 for( size_t i=0UL; i<M; ++i ) {
388 for( size_t j=0UL; j<N; ++j ) {
389 norm += power( abs( tmp(i,j) ) );
390 }
391 }
392 }
393
394 return evaluate( root( norm ) );
395}
397//*************************************************************************************************
398
399
400//*************************************************************************************************
415template< typename MT // Type of the dense matrix
416 , typename Abs // Type of the abs operation
417 , typename Power // Type of the power operation
418 , typename Root > // Type of the root operation
419inline decltype(auto) norm_backend( const DenseMatrix<MT,true>& dm, Abs abs, Power power, Root root, TrueType )
420{
421 using CT = CompositeType_t<MT>;
422 using ET = ElementType_t<MT>;
423 using RT = decltype( evaluate( root( std::declval<ET>() ) ) );
424
425 static constexpr size_t SIMDSIZE = SIMDTrait<ET>::size;
426
427 if( (*dm).rows() == 0UL || (*dm).columns() == 0UL ) return RT{};
428
429 CT tmp( *dm );
430
431 const size_t M( tmp.rows() );
432 const size_t N( tmp.columns() );
433
434 constexpr bool remainder( !IsPadded_v< RemoveReference_t<CT> > );
435
436 ET norm{};
437
438 if( !remainder || N >= SIMDSIZE )
439 {
440 const size_t ipos( remainder ? prevMultiple( M, SIMDSIZE ) :M );
441 BLAZE_INTERNAL_ASSERT( ipos <= M, "Invalid end calculation" );
442
443 SIMDTrait_t<ET> xmm1{};
444 size_t j( 0UL );
445
446 for( ; (j+4UL) <= N; j+=4UL )
447 {
448 xmm1 += power( abs( tmp.load(0UL,j) ) );
449 SIMDTrait_t<ET> xmm2( power( abs( tmp.load(0UL,j+1UL) ) ) );
450 SIMDTrait_t<ET> xmm3( power( abs( tmp.load(0UL,j+2UL) ) ) );
451 SIMDTrait_t<ET> xmm4( power( abs( tmp.load(0UL,j+3UL) ) ) );
452 size_t i( SIMDSIZE );
453
454 for( ; i<ipos; i+=SIMDSIZE ) {
455 xmm1 += power( abs( tmp.load(i,j ) ) );
456 xmm2 += power( abs( tmp.load(i,j+1UL) ) );
457 xmm3 += power( abs( tmp.load(i,j+2UL) ) );
458 xmm4 += power( abs( tmp.load(i,j+3UL) ) );
459 }
460 for( ; remainder && i<M; ++i ) {
461 norm += power( abs( tmp(i,j ) ) );
462 norm += power( abs( tmp(i,j+1UL) ) );
463 norm += power( abs( tmp(i,j+2UL) ) );
464 norm += power( abs( tmp(i,j+3UL) ) );
465 }
466
467 xmm1 += xmm2;
468 xmm3 += xmm4;
469 xmm1 += xmm3;
470 }
471
472 if( j+2UL <= N )
473 {
474 xmm1 += power( abs( tmp.load(0UL,j) ) );
475 SIMDTrait_t<ET> xmm2( power( abs( tmp.load(0UL,j+1UL) ) ) );
476 size_t i( SIMDSIZE );
477
478 for( ; i<ipos; i+=SIMDSIZE ) {
479 xmm1 += power( abs( tmp.load(i,j ) ) );
480 xmm2 += power( abs( tmp.load(i,j+1UL) ) );
481 }
482 for( ; remainder && i<M; ++i ) {
483 norm += power( abs( tmp(i,j ) ) );
484 norm += power( abs( tmp(i,j+1UL) ) );
485 }
486
487 xmm1 += xmm2;
488
489 j += 2UL;
490 }
491
492 if( j < N )
493 {
494 xmm1 += power( abs( tmp.load(0UL,j) ) );
495 size_t i( SIMDSIZE );
496
497 for( ; i<ipos; i+=SIMDSIZE ) {
498 xmm1 += power( abs( tmp.load(i,j) ) );
499 }
500 for( ; remainder && i<M; ++i ) {
501 norm += power( abs( tmp(i,j) ) );
502 }
503 }
504
505 norm += sum( xmm1 );
506 }
507 else
508 {
509 for( size_t j=0UL; j<N; ++j ) {
510 for( size_t i=0UL; i<M; ++i ) {
511 norm += power( abs( tmp(i,j) ) );
512 }
513 }
514 }
515
516 return evaluate( root( norm ) );
517}
519//*************************************************************************************************
520
521
522//*************************************************************************************************
543template< typename MT // Type of the dense matrix
544 , bool SO // Storage order
545 , typename Abs // Type of the abs operation
546 , typename Power // Type of the power operation
547 , typename Root > // Type of the root operation
548decltype(auto) norm_backend( const DenseMatrix<MT,SO>& dm, Abs abs, Power power, Root root )
549{
550 return norm_backend( *dm, abs, power, root, Bool_t< DMatNormHelper<MT,Abs,Power>::value >() );
551}
553//*************************************************************************************************
554
555
556//*************************************************************************************************
571template< typename MT // Type of the dense matrix
572 , bool SO > // Storage order
573decltype(auto) norm( const DenseMatrix<MT,SO>& dm )
574{
576
577 return norm_backend( *dm, SqrAbs(), Noop(), Sqrt() );
578}
579//*************************************************************************************************
580
581
582//*************************************************************************************************
597template< typename MT // Type of the dense matrix
598 , bool SO > // Storage order
599decltype(auto) sqrNorm( const DenseMatrix<MT,SO>& dm )
600{
602
603 return norm_backend( *dm, SqrAbs(), Noop(), Noop() );
604}
605//*************************************************************************************************
606
607
608//*************************************************************************************************
623template< typename MT // Type of the dense matrix
624 , bool SO > // Storage order
625decltype(auto) l1Norm( const DenseMatrix<MT,SO>& dm )
626{
628
629 return norm_backend( *dm, Abs(), Noop(), Noop() );
630}
631//*************************************************************************************************
632
633
634//*************************************************************************************************
649template< typename MT // Type of the dense matrix
650 , bool SO > // Storage order
651decltype(auto) l2Norm( const DenseMatrix<MT,SO>& dm )
652{
654
655 return norm_backend( *dm, SqrAbs(), Noop(), Sqrt() );
656}
657//*************************************************************************************************
658
659
660//*************************************************************************************************
675template< typename MT // Type of the dense matrix
676 , bool SO > // Storage order
677decltype(auto) l3Norm( const DenseMatrix<MT,SO>& dm )
678{
680
681 return norm_backend( *dm, Abs(), Pow3(), Cbrt() );
682}
683//*************************************************************************************************
684
685
686//*************************************************************************************************
701template< typename MT // Type of the dense matrix
702 , bool SO > // Storage order
703decltype(auto) l4Norm( const DenseMatrix<MT,SO>& dm )
704{
706
707 return norm_backend( *dm, SqrAbs(), Pow2(), Qdrt() );
708}
709//*************************************************************************************************
710
711
712//*************************************************************************************************
732template< typename MT // Type of the dense matrix
733 , bool SO // Storage order
734 , typename ST > // Type of the norm parameter
735decltype(auto) lpNorm( const DenseMatrix<MT,SO>& dm, ST p )
736{
738
739 BLAZE_USER_ASSERT( !isZero( p ), "Invalid p for Lp norm detected" );
740
741 using ScalarType = MultTrait_t< UnderlyingBuiltin_t<MT>, decltype( inv( p ) ) >;
742 using UnaryPow = Bind2nd<Pow,ScalarType>;
743 return norm_backend( *dm, Abs(), UnaryPow( Pow(), p ), UnaryPow( Pow(), inv( p ) ) );
744}
745//*************************************************************************************************
746
747
748//*************************************************************************************************
767template< size_t P // Compile time norm parameter
768 , typename MT // Type of the dense matrix
769 , bool SO > // Storage order
770inline decltype(auto) lpNorm( const DenseMatrix<MT,SO>& dm )
771{
772 BLAZE_STATIC_ASSERT_MSG( P > 0UL, "Invalid norm parameter detected" );
773
775 using Norm = typename TypeAt< Norms, min( P-1UL, 4UL ) >::Type;
776
777 return Norm()( *dm );
778}
779//*************************************************************************************************
780
781
782//*************************************************************************************************
797template< typename MT // Type of the dense matrix
798 , bool SO > // Storage order
799decltype(auto) linfNorm( const DenseMatrix<MT,SO>& dm )
800{
802
803 return max( abs( *dm ) );
804}
805//*************************************************************************************************
806
807
808//*************************************************************************************************
823template< typename MT // Type of the dense matrix
824 , bool SO > // Storage order
825decltype(auto) maxNorm( const DenseMatrix<MT,SO>& dm )
826{
828
829 return linfNorm( *dm );
830}
831//*************************************************************************************************
832
833
834//*************************************************************************************************
849template< typename MT // Type of the dense matrix
850 , bool SO > // Storage order
851decltype(auto) minNorm( const DenseMatrix<MT,SO>& dm )
852{
854
855 return min( abs( *dm ) );
856}
857//*************************************************************************************************
858
859} // namespace blaze
860
861#endif
Header file for auxiliary alias declarations.
Header file for run time assertion macros.
Header file for the Bind2nd functor.
Header file for the evaluate shim.
Header file for the function trace functionality.
Header file for the HasLoad type trait.
Header file for the HasMember type traits.
Header file for the HasSIMDAdd type trait.
Header file for the If class template.
Header file for the IntegralConstant class template.
Header file for the invert shim.
Header file for the IsPadded type trait.
Header file for the IsSIMDEnabled type trait.
Header file for the L1Norm functor.
Header file for the L2Norm functor.
Header file for the L3Norm functor.
Header file for the L4Norm functor.
Header file for the LpNorm functor.
Header file for the multiplication trait.
Header file for the Noop functor.
Header file for the prevMultiple shim.
Header file for the RemoveCVRef type trait.
Header file for the RemoveReference type trait.
Header file for all SIMD functionality.
Header file for the SqrAbs functor.
Compile time assertion.
Header file for the type list functionality.
Header file for the UnderlyingBuiltin type trait.
Base class for dense matrices.
Definition: DenseMatrix.h:82
Header file for the DenseMatrix base class.
Header file for the Abs functor.
Header file for the Cbrt functor.
Header file for the Pow2 functor.
Header file for the Pow3 functor.
Header file for the Pow functor.
Header file for the Qdrt functor.
Header file for the Sqrt functor.
decltype(auto) l4Norm(const DenseMatrix< MT, SO > &dm)
Computes the L4 norm for the given dense matrix.
Definition: DMatNormExpr.h:703
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:1339
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:1375
decltype(auto) l2Norm(const DenseMatrix< MT, SO > &dm)
Computes the L2 norm for the given dense matrix.
Definition: DMatNormExpr.h:651
decltype(auto) sqrNorm(const DenseMatrix< MT, SO > &dm)
Computes the squared L2 norm for the given dense matrix.
Definition: DMatNormExpr.h:599
decltype(auto) linfNorm(const DenseMatrix< MT, SO > &dm)
Computes the infinity norm for the given dense matrix.
Definition: DMatNormExpr.h:799
decltype(auto) maxNorm(const DenseMatrix< MT, SO > &dm)
Computes the maximum norm for the given dense matrix.
Definition: DMatNormExpr.h:825
decltype(auto) abs(const DenseMatrix< MT, SO > &dm)
Applies the abs() function to each single element of the dense matrix dm.
Definition: DMatMapExpr.h:1296
decltype(auto) norm(const DenseMatrix< MT, SO > &dm)
Computes the L2 norm for the given dense matrix.
Definition: DMatNormExpr.h:573
decltype(auto) minNorm(const DenseMatrix< MT, SO > &dm)
Computes the minimum norm for the given dense matrix.
Definition: DMatNormExpr.h:851
decltype(auto) lpNorm(const DenseMatrix< MT, SO > &dm)
Computes the Lp norm for the given dense matrix.
Definition: DMatNormExpr.h:770
decltype(auto) inv(const DenseMatrix< MT, SO > &dm)
Calculation of the inverse of the given dense matrix.
Definition: DMatInvExpr.h:405
bool isZero(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a zero matrix.
Definition: DenseMatrix.h:1819
decltype(auto) sum(const DenseMatrix< MT, SO > &dm)
Reduces the given dense matrix by means of addition.
Definition: DMatReduceExpr.h:2156
decltype(auto) l1Norm(const DenseMatrix< MT, SO > &dm)
Computes the L1 norm for the given dense matrix.
Definition: DMatNormExpr.h:625
decltype(auto) l3Norm(const DenseMatrix< MT, SO > &dm)
Computes the L3 norm for the given dense matrix.
Definition: DMatNormExpr.h:677
typename MultTrait< T1, T2 >::Type MultTrait_t
Auxiliary alias declaration for the MultTrait class template.
Definition: MultTrait.h:165
constexpr bool IsPadded_v
Auxiliary variable template for the IsPadded type trait.
Definition: IsPadded.h:134
BLAZE_ALWAYS_INLINE constexpr auto prevMultiple(T1 value, T2 factor) noexcept
Rounds down an integral value to the previous multiple of a given factor.
Definition: PrevMultiple.h:68
MT::ResultType evaluate(const Matrix< MT, SO > &matrix)
Evaluates the given matrix expression.
Definition: Matrix.h:1282
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_USER_ASSERT(expr, msg)
Run time assertion macro for user checks.
Definition: Assert.h:117
#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
#define BLAZE_FUNCTION_TRACE
Function trace macro.
Definition: FunctionTrace.h:94
IntegralConstant< bool, B > Bool_t
Compile time integral constant wrapper for bool.
Definition: IntegralConstant.h:153
Header file for the isZero shim.
Generic wrapper for the abs() function.
Definition: Abs.h:85
Generic wrapper for an operation with fixed 2nd argument.
Definition: Bind2nd.h:66
Generic wrapper for the cbrt() function.
Definition: Cbrt.h:83
Generic wrapper for the null function.
Definition: Noop.h:62
Generic wrapper for the pow2() function.
Definition: Pow2.h:80
Generic wrapper for the pow3() function.
Definition: Pow3.h:80
Generic wrapper for the pow() function.
Definition: Pow.h:65
Generic wrapper for the qdrt() function.
Definition: Qdrt.h:84
Generic wrapper for the squared abs() function.
Definition: SqrAbs.h:86
Generic wrapper for the sqrt() function.
Definition: Sqrt.h:85
Indexing a type list.
Definition: TypeAt.h:75
Implementation of a type list.
Definition: TypeList.h:120
System settings for performance optimizations.
Header file for basic type definitions.
Header file for the And_t alias template.