35 #ifndef _BLAZE_MATH_DENSE_CUSTOMMATRIX_H_ 36 #define _BLAZE_MATH_DENSE_CUSTOMMATRIX_H_ 408 template<
typename Type
411 ,
bool SO = defaultStorageOrder >
413 :
public DenseMatrix< CustomMatrix<Type,AF,PF,SO>, SO >
446 template<
typename NewType >
455 template<
size_t NewM
481 explicit inline CustomMatrix( Type* ptr,
size_t m,
size_t n );
482 explicit inline CustomMatrix( Type* ptr,
size_t m,
size_t n,
size_t nn );
519 template<
typename Other,
size_t M,
size_t N >
531 template<
typename Other >
534 template<
typename Other >
542 inline size_t rows()
const noexcept;
543 inline size_t columns()
const noexcept;
544 inline size_t spacing()
const noexcept;
545 inline size_t capacity()
const noexcept;
546 inline size_t capacity(
size_t i )
const noexcept;
548 inline size_t nonZeros(
size_t i )
const;
550 inline void reset(
size_t i );
569 inline void reset( Type* ptr,
size_t m,
size_t n );
570 inline void reset( Type* ptr,
size_t m,
size_t n,
size_t nn );
577 template<
typename MT >
579 struct VectorizedAssign {
580 enum :
bool { value = useOptimizedKernels &&
581 simdEnabled && MT::simdEnabled &&
589 template<
typename MT >
591 struct VectorizedAddAssign {
592 enum :
bool { value = useOptimizedKernels &&
593 simdEnabled && MT::simdEnabled &&
603 template<
typename MT >
605 struct VectorizedSubAssign {
606 enum :
bool { value = useOptimizedKernels &&
607 simdEnabled && MT::simdEnabled &&
617 template<
typename MT >
619 struct VectorizedSchurAssign {
620 enum :
bool { value = useOptimizedKernels &&
621 simdEnabled && MT::simdEnabled &&
637 template<
typename Other >
inline bool canAlias (
const Other* alias )
const noexcept;
638 template<
typename Other >
inline bool isAliased(
const Other* alias )
const noexcept;
652 template<
typename MT >
655 template<
typename MT >
662 template<
typename MT >
665 template<
typename MT >
672 template<
typename MT >
675 template<
typename MT >
682 template<
typename MT >
685 template<
typename MT >
736 template<
typename Type
769 template<
typename Type
781 if( ptr ==
nullptr ) {
814 template<
typename Type
824 if( ptr ==
nullptr ) {
837 for(
size_t i=0UL; i<
m_; ++i ) {
838 for(
size_t j=
n_; j<
nn_; ++j )
839 v_[i*nn_+j] = Type();
853 template<
typename Type
871 template<
typename Type
909 template<
typename Type
933 template<
typename Type
958 template<
typename Type
987 template<
typename Type
1000 return (*
this)(i,j);
1017 template<
typename Type
1041 template<
typename Type
1061 template<
typename Type
1082 template<
typename Type
1106 template<
typename Type
1130 template<
typename Type
1154 template<
typename Type
1178 template<
typename Type
1202 template<
typename Type
1226 template<
typename Type
1253 template<
typename Type
1259 for(
size_t i=0UL; i<
m_; ++i )
1260 for(
size_t j=0UL; j<
n_; ++j )
1296 template<
typename Type
1309 for(
const auto& rowList : list ) {
1310 std::fill( std::copy( rowList.begin(), rowList.end(),
v_+i*
nn_ ),
1349 template<
typename Type
1353 template<
typename Other
1358 if(
m_ != M ||
n_ != N ) {
1362 for(
size_t i=0UL; i<M; ++i )
1363 for(
size_t j=0UL; j<N; ++j )
1364 v_[i*
nn_+j] = array[i][j];
1381 template<
typename Type
1404 template<
typename Type
1438 template<
typename Type
1442 template<
typename MT
1485 template<
typename Type
1489 template<
typename MT
1520 template<
typename Type
1524 template<
typename MT
1555 template<
typename Type
1559 template<
typename MT
1590 template<
typename Type
1594 template<
typename MT
1617 template<
typename Type
1621 template<
typename Other >
1638 template<
typename Type
1642 template<
typename Other >
1667 template<
typename Type
1683 template<
typename Type
1704 template<
typename Type
1720 template<
typename Type
1742 template<
typename Type
1760 template<
typename Type
1766 size_t nonzeros( 0UL );
1768 for(
size_t i=0UL; i<
m_; ++i )
1769 for(
size_t j=0UL; j<
n_; ++j )
1789 template<
typename Type
1797 const size_t jend( i*
nn_ +
n_ );
1798 size_t nonzeros( 0UL );
1800 for(
size_t j=i*
nn_; j<jend; ++j )
1814 template<
typename Type
1822 for(
size_t i=0UL; i<
m_; ++i )
1823 for(
size_t j=0UL; j<
n_; ++j )
1840 template<
typename Type
1849 for(
size_t j=0UL; j<
n_; ++j )
1862 template<
typename Type
1882 template<
typename Type
1914 template<
typename Type
1926 for(
size_t i=1UL; i<
m_; ++i )
1927 for(
size_t j=0UL; j<i; ++j )
1943 template<
typename Type
1953 for(
size_t i=0UL; i<
m_; ++i ) {
1954 for(
size_t j=0UL; j<i; ++j ) {
1986 template<
typename Type
1990 template<
typename Other >
1993 for(
size_t i=0UL; i<
m_; ++i )
1994 for(
size_t j=0UL; j<
n_; ++j )
1995 v_[i*
nn_+j] *= scalar;
2033 template<
typename Type
2070 template<
typename Type
2100 template<
typename Type
2104 template<
typename Other >
2107 return static_cast<const void*
>( this ) == static_cast<const void*>( alias );
2122 template<
typename Type
2126 template<
typename Other >
2129 return static_cast<const void*
>( this ) == static_cast<const void*>( alias );
2143 template<
typename Type
2164 template<
typename Type
2170 return (
rows() *
columns() >= SMP_DMATASSIGN_THRESHOLD );
2190 template<
typename Type
2198 return loada( i, j );
2200 return loadu( i, j );
2220 template<
typename Type
2257 template<
typename Type
2293 template<
typename Type
2324 template<
typename Type
2362 template<
typename Type
2399 template<
typename Type
2432 template<
typename Type
2436 template<
typename MT >
2443 const size_t jpos(
n_ &
size_t(-2) );
2446 for(
size_t i=0UL; i<
m_; ++i ) {
2447 for(
size_t j=0UL; j<jpos; j+=2UL ) {
2448 v_[i*
nn_+j ] = (~rhs)(i,j );
2449 v_[i*
nn_+j+1UL] = (~rhs)(i,j+1UL);
2452 v_[i*
nn_+jpos] = (~rhs)(i,jpos);
2470 template<
typename Type
2474 template<
typename MT >
2485 const size_t jpos( ( remainder )?(
n_ &
size_t(-SIMDSIZE) ):(
n_ ) );
2488 if( AF && PF && useStreaming &&
2489 (
m_*
n_ > ( cacheSize / (
sizeof(Type) * 3UL ) ) ) && !(~rhs).
isAliased(
this ) )
2491 for(
size_t i=0UL; i<
m_; ++i )
2497 for( ; j<jpos; j+=SIMDSIZE ) {
2498 left.
stream( right.load() ); left += SIMDSIZE, right += SIMDSIZE;
2500 for( ; remainder && j<
n_; ++j ) {
2501 *left = *right; ++left; ++right;
2507 for(
size_t i=0UL; i<
m_; ++i )
2513 for( ; (j+SIMDSIZE*3UL) < jpos; j+=SIMDSIZE*4UL ) {
2514 left.
store( right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2515 left.
store( right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2516 left.
store( right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2517 left.
store( right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2519 for( ; j<jpos; j+=SIMDSIZE ) {
2520 left.
store( right.load() ); left+=SIMDSIZE, right+=SIMDSIZE;
2522 for( ; remainder && j<
n_; ++j ) {
2523 *left = *right; ++left; ++right;
2542 template<
typename Type
2546 template<
typename MT >
2554 constexpr
size_t block( BLOCK_SIZE );
2556 for(
size_t ii=0UL; ii<
m_; ii+=block ) {
2557 const size_t iend(
min( m_, ii+block ) );
2558 for(
size_t jj=0UL; jj<
n_; jj+=block ) {
2559 const size_t jend(
min( n_, jj+block ) );
2560 for(
size_t i=ii; i<iend; ++i ) {
2561 for(
size_t j=jj; j<jend; ++j ) {
2562 v_[i*
nn_+j] = (~rhs)(i,j);
2582 template<
typename Type
2586 template<
typename MT >
2592 for(
size_t i=0UL; i<
m_; ++i )
2594 v_[i*
nn_+element->index()] = element->value();
2610 template<
typename Type
2614 template<
typename MT >
2622 for(
size_t j=0UL; j<
n_; ++j )
2624 v_[element->index()*
nn_+j] = element->value();
2640 template<
typename Type
2644 template<
typename MT >
2651 for(
size_t i=0UL; i<
m_; ++i )
2655 v_[i*
nn_+i] += (~rhs)(i,i);
2669 for( ; (j+2UL) <= jend; j+=2UL ) {
2670 v_[i*
nn_+j ] += (~rhs)(i,j );
2671 v_[i*
nn_+j+1UL] += (~rhs)(i,j+1UL);
2674 v_[i*
nn_+j] += (~rhs)(i,j);
2693 template<
typename Type
2697 template<
typename MT >
2709 for(
size_t i=0UL; i<
m_; ++i )
2719 const size_t jpos( ( remainder )?( jend &
size_t(-SIMDSIZE) ):( jend ) );
2720 BLAZE_INTERNAL_ASSERT( !remainder || ( jend - ( jend % (SIMDSIZE) ) ) == jpos,
"Invalid end calculation" );
2726 for( ; (j+SIMDSIZE*3UL) < jpos; j+=SIMDSIZE*4UL ) {
2727 left.
store( left.
load() + right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2728 left.
store( left.
load() + right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2729 left.
store( left.
load() + right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2730 left.
store( left.
load() + right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2732 for( ; j<jpos; j+=SIMDSIZE ) {
2733 left.
store( left.
load() + right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2735 for( ; remainder && j<jend; ++j ) {
2736 *left += *right; ++left; ++right;
2754 template<
typename Type
2758 template<
typename MT >
2766 constexpr
size_t block( BLOCK_SIZE );
2768 for(
size_t ii=0UL; ii<
m_; ii+=block ) {
2769 const size_t iend(
min( m_, ii+block ) );
2770 for(
size_t jj=0UL; jj<
n_; jj+=block )
2775 for(
size_t i=ii; i<iend; ++i )
2782 :(
min( n_, jj+block ) ) );
2785 for(
size_t j=jbegin; j<jend; ++j ) {
2786 v_[i*
nn_+j] += (~rhs)(i,j);
2806 template<
typename Type
2810 template<
typename MT >
2816 for(
size_t i=0UL; i<
m_; ++i )
2818 v_[i*
nn_+element->index()] += element->value();
2834 template<
typename Type
2838 template<
typename MT >
2846 for(
size_t j=0UL; j<
n_; ++j )
2848 v_[element->index()*
nn_+j] += element->value();
2864 template<
typename Type
2868 template<
typename MT >
2875 for(
size_t i=0UL; i<
m_; ++i )
2879 v_[i*
nn_+i] -= (~rhs)(i,i);
2893 for( ; (j+2UL) <= jend; j+=2UL ) {
2894 v_[i*
nn_+j ] -= (~rhs)(i,j );
2895 v_[i*
nn_+j+1UL] -= (~rhs)(i,j+1UL);
2898 v_[i*
nn_+j] -= (~rhs)(i,j);
2917 template<
typename Type
2921 template<
typename MT >
2933 for(
size_t i=0UL; i<
m_; ++i )
2943 const size_t jpos( ( remainder )?( jend &
size_t(-SIMDSIZE) ):( jend ) );
2944 BLAZE_INTERNAL_ASSERT( !remainder || ( jend - ( jend % (SIMDSIZE) ) ) == jpos,
"Invalid end calculation" );
2950 for( ; (j+SIMDSIZE*3UL) < jpos; j+=SIMDSIZE*4UL ) {
2951 left.
store( left.
load() - right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2952 left.
store( left.
load() - right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2953 left.
store( left.
load() - right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2954 left.
store( left.
load() - right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2956 for( ; j<jpos; j+=SIMDSIZE ) {
2957 left.
store( left.
load() - right.load() ); left += SIMDSIZE; right += SIMDSIZE;
2959 for( ; remainder && j<jend; ++j ) {
2960 *left -= *right; ++left; ++right;
2978 template<
typename Type
2982 template<
typename MT >
2990 constexpr
size_t block( BLOCK_SIZE );
2992 for(
size_t ii=0UL; ii<
m_; ii+=block ) {
2993 const size_t iend(
min( m_, ii+block ) );
2994 for(
size_t jj=0UL; jj<
n_; jj+=block )
2999 for(
size_t i=ii; i<iend; ++i )
3006 :(
min( n_, jj+block ) ) );
3009 for(
size_t j=jbegin; j<jend; ++j ) {
3010 v_[i*
nn_+j] -= (~rhs)(i,j);
3030 template<
typename Type
3034 template<
typename MT >
3040 for(
size_t i=0UL; i<
m_; ++i )
3042 v_[i*
nn_+element->index()] -= element->value();
3058 template<
typename Type
3062 template<
typename MT >
3070 for(
size_t j=0UL; j<
n_; ++j )
3072 v_[element->index()*
nn_+j] -= element->value();
3088 template<
typename Type
3092 template<
typename MT >
3099 const size_t jpos(
n_ &
size_t(-2) );
3102 for(
size_t i=0UL; i<
m_; ++i ) {
3103 for(
size_t j=0UL; j<jpos; j+=2UL ) {
3104 v_[i*
nn_+j ] *= (~rhs)(i,j );
3105 v_[i*
nn_+j+1UL] *= (~rhs)(i,j+1UL);
3108 v_[i*
nn_+jpos] *= (~rhs)(i,jpos);
3126 template<
typename Type
3130 template<
typename MT >
3141 for(
size_t i=0UL; i<
m_; ++i )
3143 const size_t jpos( ( remainder )?(
n_ &
size_t(-SIMDSIZE) ):(
n_ ) );
3150 for( ; (j+SIMDSIZE*3UL) < jpos; j+=SIMDSIZE*4UL ) {
3151 left.
store( left.
load() * right.load() ); left += SIMDSIZE; right += SIMDSIZE;
3152 left.
store( left.
load() * right.load() ); left += SIMDSIZE; right += SIMDSIZE;
3153 left.
store( left.
load() * right.load() ); left += SIMDSIZE; right += SIMDSIZE;
3154 left.
store( left.
load() * right.load() ); left += SIMDSIZE; right += SIMDSIZE;
3156 for( ; j<jpos; j+=SIMDSIZE ) {
3157 left.
store( left.
load() * right.load() ); left += SIMDSIZE; right += SIMDSIZE;
3159 for( ; remainder && j<
n_; ++j ) {
3160 *left *= *right; ++left; ++right;
3178 template<
typename Type
3182 template<
typename MT >
3190 constexpr
size_t block( BLOCK_SIZE );
3192 for(
size_t ii=0UL; ii<
m_; ii+=block ) {
3193 const size_t iend(
min( m_, ii+block ) );
3194 for(
size_t jj=0UL; jj<
n_; jj+=block ) {
3195 const size_t jend(
min( n_, jj+block ) );
3196 for(
size_t i=ii; i<iend; ++i ) {
3197 for(
size_t j=jj; j<jend; ++j ) {
3198 v_[i*
nn_+j] *= (~rhs)(i,j);
3218 template<
typename Type
3222 template<
typename MT >
3232 for(
size_t i=0UL; i<
m_; ++i )
3234 v_[i*
nn_+element->index()] = tmp(i,element->index()) * element->value();
3250 template<
typename Type
3254 template<
typename MT >
3266 for(
size_t j=0UL; j<
n_; ++j )
3268 v_[element->index()*
nn_+j] = tmp(element->index(),j) * element->value();
3293 template<
typename Type
3297 :
public DenseMatrix< CustomMatrix<Type,AF,PF,true>, true >
3330 template<
typename NewType >
3339 template<
size_t NewM
3365 explicit inline CustomMatrix( Type* ptr,
size_t m,
size_t n );
3366 explicit inline CustomMatrix( Type* ptr,
size_t m,
size_t n,
size_t mm );
3403 template<
typename Other,
size_t M,
size_t N >
3415 template<
typename Other >
3416 inline EnableIf_<IsNumeric<Other>,
CustomMatrix >& operator*=( Other rhs );
3418 template<
typename Other >
3426 inline size_t rows()
const noexcept;
3427 inline size_t columns()
const noexcept;
3428 inline size_t spacing()
const noexcept;
3429 inline size_t capacity()
const noexcept;
3430 inline size_t capacity(
size_t j )
const noexcept;
3432 inline size_t nonZeros(
size_t j )
const;
3433 inline void reset();
3434 inline void reset(
size_t j );
3435 inline void clear();
3446 template<
typename Other >
inline CustomMatrix& scale(
const Other& scalar );
3453 inline void reset( Type* ptr,
size_t m,
size_t n );
3454 inline void reset( Type* ptr,
size_t m,
size_t n,
size_t mm );
3461 template<
typename MT >
3462 struct VectorizedAssign {
3463 enum :
bool { value = useOptimizedKernels &&
3464 simdEnabled && MT::simdEnabled &&
3471 template<
typename MT >
3472 struct VectorizedAddAssign {
3473 enum :
bool { value = useOptimizedKernels &&
3474 simdEnabled && MT::simdEnabled &&
3483 template<
typename MT >
3484 struct VectorizedSubAssign {
3485 enum :
bool { value = useOptimizedKernels &&
3486 simdEnabled && MT::simdEnabled &&
3495 template<
typename MT >
3496 struct VectorizedSchurAssign {
3497 enum :
bool { value = useOptimizedKernels &&
3498 simdEnabled && MT::simdEnabled &&
3513 template<
typename Other >
inline bool canAlias (
const Other* alias )
const noexcept;
3514 template<
typename Other >
inline bool isAliased(
const Other* alias )
const noexcept;
3516 inline bool isAligned ()
const noexcept;
3528 template<
typename MT >
3531 template<
typename MT >
3538 template<
typename MT >
3541 template<
typename MT >
3548 template<
typename MT >
3551 template<
typename MT >
3558 template<
typename MT >
3561 template<
typename MT >
3605 template<
typename Type
3639 template<
typename Type
3650 if( ptr ==
nullptr ) {
3654 if( AF && ( !
checkAlignment( ptr ) || mm_ % SIMDSIZE != 0UL ) ) {
3685 template<
typename Type
3694 if( ptr ==
nullptr ) {
3698 if( AF && ( !
checkAlignment( ptr ) || mm_ % SIMDSIZE != 0UL ) ) {
3707 for(
size_t j=0UL; j<
n_; ++j )
3708 for(
size_t i=
m_; i<mm_; ++i ) {
3709 v_[i+j*mm_] = Type();
3726 template<
typename Type
3745 template<
typename Type
3784 template<
typename Type
3809 template<
typename Type
3835 template<
typename Type
3847 return (*
this)(i,j);
3865 template<
typename Type
3877 return (*
this)(i,j);
3895 template<
typename Type
3919 template<
typename Type
3940 template<
typename Type
3962 template<
typename Type
3982 template<
typename Type
4002 template<
typename Type
4022 template<
typename Type
4042 template<
typename Type
4062 template<
typename Type
4082 template<
typename Type
4110 template<
typename Type
4115 for(
size_t j=0UL; j<
n_; ++j )
4116 for(
size_t i=0UL; i<
m_; ++i )
4154 template<
typename Type
4166 for(
const auto& rowList : list ) {
4168 for(
const auto& element : rowList ) {
4169 v_[i+j*mm_] = element;
4172 for( ; j<
n_; ++j ) {
4173 v_[i+j*mm_] = Type();
4214 template<
typename Type
4217 template<
typename Other
4223 if(
m_ != M ||
n_ != N ) {
4227 for(
size_t j=0UL; j<N; ++j )
4228 for(
size_t i=0UL; i<M; ++i )
4229 v_[i+j*mm_] = array[i][j];
4248 template<
typename Type
4273 template<
typename Type
4308 template<
typename Type
4311 template<
typename MT
4357 template<
typename Type
4360 template<
typename MT
4394 template<
typename Type
4397 template<
typename MT
4431 template<
typename Type
4434 template<
typename MT
4468 template<
typename Type
4471 template<
typename MT
4497 template<
typename Type
4500 template<
typename Other >
4519 template<
typename Type
4522 template<
typename Other >
4549 template<
typename Type
4566 template<
typename Type
4586 template<
typename Type
4603 template<
typename Type
4621 template<
typename Type
4640 template<
typename Type
4645 size_t nonzeros( 0UL );
4647 for(
size_t j=0UL; j<
n_; ++j )
4648 for(
size_t i=0UL; i<
m_; ++i )
4665 template<
typename Type
4672 const size_t iend( j*mm_ +
m_ );
4673 size_t nonzeros( 0UL );
4675 for(
size_t i=j*mm_; i<iend; ++i )
4691 template<
typename Type
4698 for(
size_t j=0UL; j<
n_; ++j )
4699 for(
size_t i=0UL; i<
m_; ++i )
4716 template<
typename Type
4724 for(
size_t i=0UL; i<
m_; ++i )
4739 template<
typename Type
4760 template<
typename Type
4793 template<
typename Type
4804 for(
size_t j=1UL; j<
n_; ++j )
4805 for(
size_t i=0UL; i<j; ++i )
4823 template<
typename Type
4832 for(
size_t j=0UL; j<
n_; ++j ) {
4833 for(
size_t i=0UL; i<j; ++i ) {
4867 template<
typename Type
4870 template<
typename Other >
4873 for(
size_t j=0UL; j<
n_; ++j )
4874 for(
size_t i=0UL; i<
m_; ++i )
4875 v_[i+j*mm_] *= scalar;
4915 template<
typename Type
4953 template<
typename Type
4984 template<
typename Type
4987 template<
typename Other >
4990 return static_cast<const void*
>( this ) == static_cast<const void*>( alias );
5007 template<
typename Type
5010 template<
typename Other >
5013 return static_cast<const void*
>( this ) == static_cast<const void*>( alias );
5029 template<
typename Type
5051 template<
typename Type
5056 return (
rows() *
columns() >= SMP_DMATASSIGN_THRESHOLD );
5077 template<
typename Type
5084 return loada( i, j );
5086 return loadu( i, j );
5107 template<
typename Type
5144 template<
typename Type
5180 template<
typename Type
5211 template<
typename Type
5249 template<
typename Type
5286 template<
typename Type
5320 template<
typename Type
5323 template<
typename MT >
5330 const size_t ipos(
m_ &
size_t(-2) );
5333 for(
size_t j=0UL; j<
n_; ++j ) {
5334 for(
size_t i=0UL; i<ipos; i+=2UL ) {
5335 v_[i +j*mm_] = (~rhs)(i ,j);
5336 v_[i+1UL+j*mm_] = (~rhs)(i+1UL,j);
5339 v_[ipos+j*mm_] = (~rhs)(ipos,j);
5359 template<
typename Type
5362 template<
typename MT >
5373 const size_t ipos( ( remainder )?(
m_ &
size_t(-SIMDSIZE) ):(
m_ ) );
5376 if( AF && PF && useStreaming &&
5377 (
m_*
n_ > ( cacheSize / (
sizeof(Type) * 3UL ) ) ) && !(~rhs).
isAliased(
this ) )
5379 for(
size_t j=0UL; j<
n_; ++j )
5385 for( ; i<ipos; i+=SIMDSIZE ) {
5386 left.
stream( right.load() ); left += SIMDSIZE; right += SIMDSIZE;
5388 for( ; remainder && i<
m_; ++i ) {
5389 *left = *right; ++left; ++right;
5395 for(
size_t j=0UL; j<
n_; ++j )
5401 for( ; (i+SIMDSIZE*3UL) < ipos; i+=SIMDSIZE*4UL ) {
5402 left.
store( right.load() ); left += SIMDSIZE; right += SIMDSIZE;
5403 left.
store( right.load() ); left += SIMDSIZE; right += SIMDSIZE;
5404 left.
store( right.load() ); left += SIMDSIZE; right += SIMDSIZE;
5405 left.
store( right.load() ); left += SIMDSIZE; right += SIMDSIZE;
5407 for( ; i<ipos; i+=SIMDSIZE ) {
5408 left.
store( right.load() ); left += SIMDSIZE; right += SIMDSIZE;
5410 for( ; remainder && i<
m_; ++i ) {
5411 *left = *right; ++left; ++right;
5432 template<
typename Type
5435 template<
typename MT >
5443 constexpr
size_t block( BLOCK_SIZE );
5445 for(
size_t jj=0UL; jj<
n_; jj+=block ) {
5446 const size_t jend(
min( n_, jj+block ) );
5447 for(
size_t ii=0UL; ii<
m_; ii+=block ) {
5448 const size_t iend(
min( m_, ii+block ) );
5449 for(
size_t j=jj; j<jend; ++j ) {
5450 for(
size_t i=ii; i<iend; ++i ) {
5451 v_[i+j*mm_] = (~rhs)(i,j);
5473 template<
typename Type
5476 template<
typename MT >
5482 for(
size_t j=0UL; j<(~rhs).
columns(); ++j )
5484 v_[element->index()+j*mm_] = element->value();
5502 template<
typename Type
5505 template<
typename MT >
5513 for(
size_t i=0UL; i<(~rhs).
rows(); ++i )
5515 v_[i+element->index()*mm_] = element->value();
5533 template<
typename Type
5536 template<
typename MT >
5543 for(
size_t j=0UL; j<
n_; ++j )
5547 v_[j+j*mm_] += (~rhs)(j,j);
5561 for( ; (i+2UL) <= iend; i+=2UL ) {
5562 v_[i +j*mm_] += (~rhs)(i ,j);
5563 v_[i+1UL+j*mm_] += (~rhs)(i+1UL,j);
5566 v_[i+j*mm_] += (~rhs)(i,j);
5587 template<
typename Type
5590 template<
typename MT >
5602 for(
size_t j=0UL; j<
n_; ++j )
5612 const size_t ipos( ( remainder )?( iend &
size_t(-SIMDSIZE) ):( iend ) );
5613 BLAZE_INTERNAL_ASSERT( !remainder || ( iend - ( iend % (SIMDSIZE) ) ) == ipos,
"Invalid end calculation" );
5619 for( ; (i+SIMDSIZE*3UL) < ipos; i+=SIMDSIZE*4UL ) {
5620 left.
store( left.
load() + right.load() ); left += SIMDSIZE; right += SIMDSIZE;
5621 left.
store( left.
load() + right.load() ); left += SIMDSIZE; right += SIMDSIZE;
5622 left.
store( left.
load() + right.load() ); left += SIMDSIZE; right += SIMDSIZE;
5623 left.
store( left.
load() + right.load() ); left += SIMDSIZE; right += SIMDSIZE;
5625 for( ; i<ipos; i+=SIMDSIZE ) {
5626 left.
store( left.
load() + right.load() ); left += SIMDSIZE; right += SIMDSIZE;
5628 for( ; remainder && i<iend; ++i ) {
5629 *left += *right; ++left; ++right;
5649 template<
typename Type
5652 template<
typename MT >
5660 constexpr
size_t block( BLOCK_SIZE );
5662 for(
size_t jj=0UL; jj<
n_; jj+=block ) {
5663 const size_t jend(
min( n_, jj+block ) );
5664 for(
size_t ii=0UL; ii<
m_; ii+=block )
5669 for(
size_t j=jj; j<jend; ++j )
5676 :(
min( m_, ii+block ) ) );
5679 for(
size_t i=ibegin; i<iend; ++i ) {
5680 v_[i+j*mm_] += (~rhs)(i,j);
5702 template<
typename Type
5705 template<
typename MT >
5711 for(
size_t j=0UL; j<(~rhs).
columns(); ++j )
5713 v_[element->index()+j*mm_] += element->value();
5731 template<
typename Type
5734 template<
typename MT >
5742 for(
size_t i=0UL; i<(~rhs).
rows(); ++i )
5744 v_[i+element->index()*mm_] += element->value();
5762 template<
typename Type
5765 template<
typename MT >
5772 for(
size_t j=0UL; j<
n_; ++j )
5776 v_[j+j*mm_] -= (~rhs)(j,j);
5790 for( ; (i+2UL) <= iend; i+=2UL ) {
5791 v_[i +j*mm_] -= (~rhs)(i ,j);
5792 v_[i+1+j*mm_] -= (~rhs)(i+1,j);
5795 v_[i+j*mm_] -= (~rhs)(i,j);
5817 template<
typename Type
5820 template<
typename MT >
5832 for(
size_t j=0UL; j<
n_; ++j )
5842 const size_t ipos( ( remainder )?( iend &
size_t(-SIMDSIZE) ):( iend ) );
5843 BLAZE_INTERNAL_ASSERT( !remainder || ( iend - ( iend % (SIMDSIZE) ) ) == ipos,
"Invalid end calculation" );
5849 for( ; (i+SIMDSIZE*3UL) < ipos; i+=SIMDSIZE*4UL ) {
5850 left.
store( left.
load() - right.load() ); left += SIMDSIZE; right += SIMDSIZE;
5851 left.
store( left.
load() - right.load() ); left += SIMDSIZE; right += SIMDSIZE;
5852 left.
store( left.
load() - right.load() ); left += SIMDSIZE; right += SIMDSIZE;
5853 left.
store( left.
load() - right.load() ); left += SIMDSIZE; right += SIMDSIZE;
5855 for( ; i<ipos; i+=SIMDSIZE ) {
5856 left.
store( left.
load() - right.load() ); left += SIMDSIZE; right += SIMDSIZE;
5858 for( ; remainder && i<iend; ++i ) {
5859 *left -= *right; ++left; ++right;
5879 template<
typename Type
5882 template<
typename MT >
5890 constexpr
size_t block( BLOCK_SIZE );
5892 for(
size_t jj=0UL; jj<
n_; jj+=block ) {
5893 const size_t jend(
min( n_, jj+block ) );
5894 for(
size_t ii=0UL; ii<
m_; ii+=block )
5899 for(
size_t j=jj; j<jend; ++j )
5906 :(
min( m_, ii+block ) ) );
5909 for(
size_t i=ibegin; i<iend; ++i ) {
5910 v_[i+j*mm_] -= (~rhs)(i,j);
5932 template<
typename Type
5935 template<
typename MT >
5941 for(
size_t j=0UL; j<(~rhs).
columns(); ++j )
5943 v_[element->index()+j*mm_] -= element->value();
5961 template<
typename Type
5964 template<
typename MT >
5972 for(
size_t i=0UL; i<(~rhs).
rows(); ++i )
5974 v_[i+element->index()*mm_] -= element->value();
5992 template<
typename Type
5995 template<
typename MT >
6002 const size_t ipos(
m_ &
size_t(-2) );
6005 for(
size_t j=0UL; j<
n_; ++j ) {
6006 for(
size_t i=0UL; i<ipos; i+=2UL ) {
6007 v_[i +j*mm_] *= (~rhs)(i ,j);
6008 v_[i+1UL+j*mm_] *= (~rhs)(i+1UL,j);
6011 v_[ipos+j*mm_] *= (~rhs)(ipos,j);
6032 template<
typename Type
6035 template<
typename MT >
6046 for(
size_t j=0UL; j<
n_; ++j )
6048 const size_t ipos( ( remainder )?(
m_ &
size_t(-SIMDSIZE) ):(
m_ ) );
6055 for( ; (i+SIMDSIZE*3UL) < ipos; i+=SIMDSIZE*4UL ) {
6056 left.
store( left.
load() * right.load() ); left += SIMDSIZE; right += SIMDSIZE;
6057 left.
store( left.
load() * right.load() ); left += SIMDSIZE; right += SIMDSIZE;
6058 left.
store( left.
load() * right.load() ); left += SIMDSIZE; right += SIMDSIZE;
6059 left.
store( left.
load() * right.load() ); left += SIMDSIZE; right += SIMDSIZE;
6061 for( ; i<ipos; i+=SIMDSIZE ) {
6062 left.
store( left.
load() * right.load() ); left += SIMDSIZE; right += SIMDSIZE;
6064 for( ; remainder && i<
m_; ++i ) {
6065 *left *= *right; ++left; ++right;
6085 template<
typename Type
6088 template<
typename MT >
6096 constexpr
size_t block( BLOCK_SIZE );
6098 for(
size_t jj=0UL; jj<
n_; jj+=block ) {
6099 const size_t jend(
min( n_, jj+block ) );
6100 for(
size_t ii=0UL; ii<
m_; ii+=block ) {
6101 const size_t iend(
min( m_, ii+block ) );
6102 for(
size_t j=jj; j<jend; ++j ) {
6103 for(
size_t i=ii; i<iend; ++i ) {
6104 v_[i+j*mm_] *= (~rhs)(i,j);
6126 template<
typename Type
6129 template<
typename MT >
6139 for(
size_t j=0UL; j<(~rhs).
columns(); ++j )
6141 v_[element->index()+j*mm_] = tmp(element->index(),j) * element->value();
6159 template<
typename Type
6162 template<
typename MT >
6174 for(
size_t i=0UL; i<(~rhs).
rows(); ++i )
6176 v_[i+element->index()*mm_] = tmp(i,element->index()) * element->value();
6197 template<
typename Type,
bool AF,
bool PF,
bool SO >
6200 template<
typename Type,
bool AF,
bool PF,
bool SO >
6203 template<
typename Type,
bool AF,
bool PF,
bool SO >
6206 template<
bool RF,
typename Type,
bool AF,
bool PF,
bool SO >
6209 template<
typename Type,
bool AF,
bool PF,
bool SO >
6212 template<
typename Type,
bool AF,
bool PF,
bool SO >
6225 template<
typename Type
6249 template<
typename Type
6267 template<
typename Type
6339 template<
typename Type
6358 template<
typename Type
6379 template<
typename T,
bool AF,
bool PF,
bool SO >
6397 template<
typename T,
bool AF,
bool PF,
bool SO >
6415 template<
typename T,
bool AF,
bool PF,
bool SO >
6416 struct IsCustom< CustomMatrix<T,AF,PF,SO> >
6433 template<
typename T,
bool PF,
bool SO >
6434 struct IsAligned< CustomMatrix<T,aligned,PF,SO> >
6451 template<
typename T,
bool AF,
bool SO >
6452 struct IsPadded< CustomMatrix<T,AF,padded,SO> >
6469 template<
typename T1,
bool AF,
bool PF,
bool SO,
typename T2,
size_t M,
size_t N >
6470 struct AddTrait< CustomMatrix<T1,AF,PF,SO>, StaticMatrix<T2,M,N,SO> >
6475 template<
typename T1,
bool AF,
bool PF,
bool SO1,
typename T2,
size_t M,
size_t N,
bool SO2 >
6476 struct AddTrait< CustomMatrix<T1,AF,PF,SO1>, StaticMatrix<T2,M,N,SO2> >
6481 template<
typename T1,
size_t M,
size_t N,
bool SO,
typename T2,
bool AF,
bool PF >
6482 struct AddTrait< StaticMatrix<T1,M,N,SO>, CustomMatrix<T2,AF,PF,SO> >
6487 template<
typename T1,
size_t M,
size_t N,
bool SO1,
typename T2,
bool AF,
bool PF,
bool SO2 >
6488 struct AddTrait< StaticMatrix<T1,M,N,SO1>, CustomMatrix<T2,AF,PF,SO2> >
6493 template<
typename T1,
bool AF,
bool PF,
bool SO,
typename T2,
size_t M,
size_t N >
6494 struct AddTrait< CustomMatrix<T1,AF,PF,SO>, HybridMatrix<T2,M,N,SO> >
6499 template<
typename T1,
bool AF,
bool PF,
bool SO1,
typename T2,
size_t M,
size_t N,
bool SO2 >
6500 struct AddTrait< CustomMatrix<T1,AF,PF,SO1>, HybridMatrix<T2,M,N,SO2> >
6505 template<
typename T1,
size_t M,
size_t N,
bool SO,
typename T2,
bool AF,
bool PF >
6506 struct AddTrait< HybridMatrix<T1,M,N,SO>, CustomMatrix<T2,AF,PF,SO> >
6511 template<
typename T1,
size_t M,
size_t N,
bool SO1,
typename T2,
bool AF,
bool PF,
bool SO2 >
6512 struct AddTrait< HybridMatrix<T1,M,N,SO1>, CustomMatrix<T2,AF,PF,SO2> >
6517 template<
typename T1,
bool AF,
bool PF,
bool SO,
typename T2 >
6518 struct AddTrait< CustomMatrix<T1,AF,PF,SO>, DynamicMatrix<T2,SO> >
6523 template<
typename T1,
bool AF,
bool PF,
bool SO1,
typename T2,
bool SO2 >
6524 struct AddTrait< CustomMatrix<T1,AF,PF,SO1>, DynamicMatrix<T2,SO2> >
6529 template<
typename T1,
bool SO,
typename T2,
bool AF,
bool PF >
6530 struct AddTrait< DynamicMatrix<T1,SO>, CustomMatrix<T2,AF,PF,SO> >
6535 template<
typename T1,
bool SO1,
typename T2,
bool AF,
bool PF,
bool SO2 >
6536 struct AddTrait< DynamicMatrix<T1,SO1>, CustomMatrix<T2,AF,PF,SO2> >
6541 template<
typename T1,
bool AF1,
bool PF1,
bool SO,
typename T2,
bool AF2,
bool PF2 >
6542 struct AddTrait< CustomMatrix<T1,AF1,PF1,SO>, CustomMatrix<T2,AF2,PF2,SO> >
6547 template<
typename T1,
bool AF1,
bool PF1,
bool SO1,
typename T2,
bool AF2,
bool PF2,
bool SO2 >
6548 struct AddTrait< CustomMatrix<T1,AF1,PF1,SO1>, CustomMatrix<T2,AF2,PF2,SO2> >
6566 template<
typename T1,
bool AF,
bool PF,
bool SO,
typename T2,
size_t M,
size_t N >
6567 struct SubTrait< CustomMatrix<T1,AF,PF,SO>, StaticMatrix<T2,M,N,SO> >
6572 template<
typename T1,
bool AF,
bool PF,
bool SO1,
typename T2,
size_t M,
size_t N,
bool SO2 >
6573 struct SubTrait< CustomMatrix<T1,AF,PF,SO1>, StaticMatrix<T2,M,N,SO2> >
6578 template<
typename T1,
size_t M,
size_t N,
bool SO,
typename T2,
bool AF,
bool PF >
6579 struct SubTrait< StaticMatrix<T1,M,N,SO>, CustomMatrix<T2,AF,PF,SO> >
6584 template<
typename T1,
size_t M,
size_t N,
bool SO1,
typename T2,
bool AF,
bool PF,
bool SO2 >
6585 struct SubTrait< StaticMatrix<T1,M,N,SO1>, CustomMatrix<T2,AF,PF,SO2> >
6590 template<
typename T1,
bool AF,
bool PF,
bool SO,
typename T2,
size_t M,
size_t N >
6591 struct SubTrait< CustomMatrix<T1,AF,PF,SO>, HybridMatrix<T2,M,N,SO> >
6596 template<
typename T1,
bool AF,
bool PF,
bool SO1,
typename T2,
size_t M,
size_t N,
bool SO2 >
6597 struct SubTrait< CustomMatrix<T1,AF,PF,SO1>, HybridMatrix<T2,M,N,SO2> >
6602 template<
typename T1,
size_t M,
size_t N,
bool SO,
typename T2,
bool AF,
bool PF >
6603 struct SubTrait< HybridMatrix<T1,M,N,SO>, CustomMatrix<T2,AF,PF,SO> >
6608 template<
typename T1,
size_t M,
size_t N,
bool SO1,
typename T2,
bool AF,
bool PF,
bool SO2 >
6609 struct SubTrait< HybridMatrix<T1,M,N,SO1>, CustomMatrix<T2,AF,PF,SO2> >
6614 template<
typename T1,
bool AF,
bool PF,
bool SO,
typename T2 >
6615 struct SubTrait< CustomMatrix<T1,AF,PF,SO>, DynamicMatrix<T2,SO> >
6620 template<
typename T1,
bool AF,
bool PF,
bool SO1,
typename T2,
bool SO2 >
6621 struct SubTrait< CustomMatrix<T1,AF,PF,SO1>, DynamicMatrix<T2,SO2> >
6626 template<
typename T1,
bool SO,
typename T2,
bool AF,
bool PF >
6627 struct SubTrait< DynamicMatrix<T1,SO>, CustomMatrix<T2,AF,PF,SO> >
6632 template<
typename T1,
bool SO1,
typename T2,
bool AF,
bool PF,
bool SO2 >
6633 struct SubTrait< DynamicMatrix<T1,SO1>, CustomMatrix<T2,AF,PF,SO2> >
6638 template<
typename T1,
bool AF1,
bool PF1,
bool SO,
typename T2,
bool AF2,
bool PF2 >
6639 struct SubTrait< CustomMatrix<T1,AF1,PF1,SO>, CustomMatrix<T2,AF2,PF2,SO> >
6644 template<
typename T1,
bool AF1,
bool PF1,
bool SO1,
typename T2,
bool AF2,
bool PF2,
bool SO2 >
6645 struct SubTrait< CustomMatrix<T1,AF1,PF1,SO1>, CustomMatrix<T2,AF2,PF2,SO2> >
6663 template<
typename T1,
bool AF,
bool PF,
bool SO,
typename T2,
size_t M,
size_t N >
6664 struct SchurTrait< CustomMatrix<T1,AF,PF,SO>, StaticMatrix<T2,M,N,SO> >
6669 template<
typename T1,
bool AF,
bool PF,
bool SO1,
typename T2,
size_t M,
size_t N,
bool SO2 >
6670 struct SchurTrait< CustomMatrix<T1,AF,PF,SO1>, StaticMatrix<T2,M,N,SO2> >
6675 template<
typename T1,
size_t M,
size_t N,
bool SO,
typename T2,
bool AF,
bool PF >
6676 struct SchurTrait< StaticMatrix<T1,M,N,SO>, CustomMatrix<T2,AF,PF,SO> >
6681 template<
typename T1,
size_t M,
size_t N,
bool SO1,
typename T2,
bool AF,
bool PF,
bool SO2 >
6682 struct SchurTrait< StaticMatrix<T1,M,N,SO1>, CustomMatrix<T2,AF,PF,SO2> >
6687 template<
typename T1,
bool AF,
bool PF,
bool SO,
typename T2,
size_t M,
size_t N >
6688 struct SchurTrait< CustomMatrix<T1,AF,PF,SO>, HybridMatrix<T2,M,N,SO> >
6693 template<
typename T1,
bool AF,
bool PF,
bool SO1,
typename T2,
size_t M,
size_t N,
bool SO2 >
6694 struct SchurTrait< CustomMatrix<T1,AF,PF,SO1>, HybridMatrix<T2,M,N,SO2> >
6699 template<
typename T1,
size_t M,
size_t N,
bool SO,
typename T2,
bool AF,
bool PF >
6700 struct SchurTrait< HybridMatrix<T1,M,N,SO>, CustomMatrix<T2,AF,PF,SO> >
6705 template<
typename T1,
size_t M,
size_t N,
bool SO1,
typename T2,
bool AF,
bool PF,
bool SO2 >
6706 struct SchurTrait< HybridMatrix<T1,M,N,SO1>, CustomMatrix<T2,AF,PF,SO2> >
6711 template<
typename T1,
bool AF,
bool PF,
bool SO,
typename T2 >
6712 struct SchurTrait< CustomMatrix<T1,AF,PF,SO>, DynamicMatrix<T2,SO> >
6717 template<
typename T1,
bool AF,
bool PF,
bool SO1,
typename T2,
bool SO2 >
6718 struct SchurTrait< CustomMatrix<T1,AF,PF,SO1>, DynamicMatrix<T2,SO2> >
6723 template<
typename T1,
bool SO,
typename T2,
bool AF,
bool PF >
6724 struct SchurTrait< DynamicMatrix<T1,SO>, CustomMatrix<T2,AF,PF,SO> >
6729 template<
typename T1,
bool SO1,
typename T2,
bool AF,
bool PF,
bool SO2 >
6730 struct SchurTrait< DynamicMatrix<T1,SO1>, CustomMatrix<T2,AF,PF,SO2> >
6735 template<
typename T1,
bool AF1,
bool PF1,
bool SO,
typename T2,
bool AF2,
bool PF2 >
6736 struct SchurTrait< CustomMatrix<T1,AF1,PF1,SO>, CustomMatrix<T2,AF2,PF2,SO> >
6741 template<
typename T1,
bool AF1,
bool PF1,
bool SO1,
typename T2,
bool AF2,
bool PF2,
bool SO2 >
6742 struct SchurTrait< CustomMatrix<T1,AF1,PF1,SO1>, CustomMatrix<T2,AF2,PF2,SO2> >
6760 template<
typename T1,
bool AF,
bool PF,
bool SO,
typename T2 >
6761 struct MultTrait< CustomMatrix<T1,AF,PF,SO>, T2, EnableIf_<IsNumeric<T2> > >
6766 template<
typename T1,
typename T2,
bool AF,
bool PF,
bool SO >
6767 struct MultTrait< T1, CustomMatrix<T2,AF,PF,SO>, EnableIf_<IsNumeric<T1> > >
6772 template<
typename T1,
bool AF,
bool PF,
bool SO,
typename T2,
size_t N >
6773 struct MultTrait< CustomMatrix<T1,AF,PF,SO>, StaticVector<T2,N,false> >
6778 template<
typename T1,
size_t N,
typename T2,
bool AF,
bool PF,
bool SO >
6779 struct MultTrait< StaticVector<T1,N,true>, CustomMatrix<T2,AF,PF,SO> >
6784 template<
typename T1,
bool AF,
bool PF,
bool SO,
typename T2,
size_t N >
6785 struct MultTrait< CustomMatrix<T1,AF,PF,SO>, HybridVector<T2,N,false> >
6790 template<
typename T1,
size_t N,
typename T2,
bool AF,
bool PF,
bool SO >
6791 struct MultTrait< HybridVector<T1,N,true>, CustomMatrix<T2,AF,PF,SO> >
6796 template<
typename T1,
bool AF,
bool PF,
bool SO,
typename T2 >
6797 struct MultTrait< CustomMatrix<T1,AF,PF,SO>, DynamicVector<T2,false> >
6802 template<
typename T1,
typename T2,
bool AF,
bool PF,
bool SO >
6803 struct MultTrait< DynamicVector<T1,true>, CustomMatrix<T2,AF,PF,SO> >
6808 template<
typename T1,
bool AF1,
bool PF1,
bool SO,
typename T2,
bool AF2,
bool PF2 >
6809 struct MultTrait< CustomMatrix<T1,AF1,PF1,SO>, CustomVector<T2,AF2,PF2,false> >
6814 template<
typename T1,
bool AF1,
bool PF1,
typename T2,
bool AF2,
bool PF2,
bool SO >
6815 struct MultTrait< CustomVector<T1,AF1,PF1,true>, CustomMatrix<T2,AF2,PF2,SO> >
6820 template<
typename T1,
bool AF,
bool PF,
bool SO,
typename T2 >
6821 struct MultTrait< CustomMatrix<T1,AF,PF,SO>, CompressedVector<T2,false> >
6826 template<
typename T1,
typename T2,
bool AF,
bool PF,
bool SO >
6827 struct MultTrait< CompressedVector<T1,true>, CustomMatrix<T2,AF,PF,SO> >
6832 template<
typename T1,
bool AF,
bool PF,
bool SO1,
typename T2,
size_t M,
size_t N,
bool SO2 >
6833 struct MultTrait< CustomMatrix<T1,AF,PF,SO1>, StaticMatrix<T2,M,N,SO2> >
6838 template<
typename T1,
size_t M,
size_t N,
bool SO1,
typename T2,
bool AF,
bool PF,
bool SO2 >
6839 struct MultTrait< StaticMatrix<T1,M,N,SO1>, CustomMatrix<T2,AF,PF,SO2> >
6844 template<
typename T1,
bool AF,
bool PF,
bool SO1,
typename T2,
size_t M,
size_t N,
bool SO2 >
6845 struct MultTrait< CustomMatrix<T1,AF,PF,SO1>, HybridMatrix<T2,M,N,SO2> >
6850 template<
typename T1,
size_t M,
size_t N,
bool SO1,
typename T2,
bool AF,
bool PF,
bool SO2 >
6851 struct MultTrait< HybridMatrix<T1,M,N,SO1>, CustomMatrix<T2,AF,PF,SO2> >
6856 template<
typename T1,
bool AF,
bool PF,
bool SO1,
typename T2,
bool SO2 >
6857 struct MultTrait< CustomMatrix<T1,AF,PF,SO1>, DynamicMatrix<T2,SO2> >
6862 template<
typename T1,
bool SO1,
typename T2,
bool AF,
bool PF,
bool SO2 >
6863 struct MultTrait< DynamicMatrix<T1,SO1>, CustomMatrix<T2,AF,PF,SO2> >
6868 template<
typename T1,
bool AF1,
bool PF1,
bool SO1,
typename T2,
bool AF2,
bool PF2,
bool SO2 >
6869 struct MultTrait< CustomMatrix<T1,AF1,PF1,SO1>, CustomMatrix<T2,AF2,PF2,SO2> >
6887 template<
typename T1,
bool AF,
bool PF,
bool SO,
typename T2 >
6888 struct DivTrait< CustomMatrix<T1,AF,PF,SO>, T2, EnableIf_<IsNumeric<T2> > >
6906 template<
typename T,
bool AF,
bool PF,
bool SO,
typename OP >
6925 template<
typename T1,
bool AF,
bool PF,
bool SO,
typename T2,
size_t M,
size_t N,
typename OP >
6926 struct BinaryMapTrait< CustomMatrix<T1,AF,PF,SO>, StaticMatrix<T2,M,N,SO>, OP >
6931 template<
typename T1,
bool AF,
bool PF,
bool SO1,
typename T2,
size_t M,
size_t N,
bool SO2,
typename OP >
6932 struct BinaryMapTrait< CustomMatrix<T1,AF,PF,SO1>, StaticMatrix<T2,M,N,SO2>, OP >
6937 template<
typename T1,
size_t M,
size_t N,
bool SO,
typename T2,
bool AF,
bool PF,
typename OP >
6938 struct BinaryMapTrait< StaticMatrix<T1,M,N,SO>, CustomMatrix<T2,AF,PF,SO>, OP >
6943 template<
typename T1,
size_t M,
size_t N,
bool SO1,
typename T2,
bool AF,
bool PF,
bool SO2,
typename OP >
6944 struct BinaryMapTrait< StaticMatrix<T1,M,N,SO1>, CustomMatrix<T2,AF,PF,SO2>, OP >
6949 template<
typename T1,
bool AF,
bool PF,
bool SO,
typename T2,
size_t M,
size_t N,
typename OP >
6950 struct BinaryMapTrait< CustomMatrix<T1,AF,PF,SO>, HybridMatrix<T2,M,N,SO>, OP >
6955 template<
typename T1,
bool AF,
bool PF,
bool SO1,
typename T2,
size_t M,
size_t N,
bool SO2,
typename OP >
6956 struct BinaryMapTrait< CustomMatrix<T1,AF,PF,SO1>, HybridMatrix<T2,M,N,SO2>, OP >
6961 template<
typename T1,
size_t M,
size_t N,
bool SO,
typename T2,
bool AF,
bool PF,
typename OP >
6962 struct BinaryMapTrait< HybridMatrix<T1,M,N,SO>, CustomMatrix<T2,AF,PF,SO>, OP >
6967 template<
typename T1,
size_t M,
size_t N,
bool SO1,
typename T2,
bool AF,
bool PF,
bool SO2,
typename OP >
6968 struct BinaryMapTrait< HybridMatrix<T1,M,N,SO1>, CustomMatrix<T2,AF,PF,SO2>, OP >
6973 template<
typename T1,
bool AF,
bool PF,
bool SO,
typename T2,
typename OP >
6974 struct BinaryMapTrait< CustomMatrix<T1,AF,PF,SO>, DynamicMatrix<T2,SO>, OP >
6979 template<
typename T1,
bool AF,
bool PF,
bool SO1,
typename T2,
bool SO2,
typename OP >
6980 struct BinaryMapTrait< CustomMatrix<T1,AF,PF,SO1>, DynamicMatrix<T2,SO2>, OP >
6985 template<
typename T1,
bool SO,
typename T2,
bool AF,
bool PF,
typename OP >
6986 struct BinaryMapTrait< DynamicMatrix<T1,SO>, CustomMatrix<T2,AF,PF,SO>, OP >
6991 template<
typename T1,
bool SO1,
typename T2,
bool AF,
bool PF,
bool SO2,
typename OP >
6992 struct BinaryMapTrait< DynamicMatrix<T1,SO1>, CustomMatrix<T2,AF,PF,SO2>, OP >
6997 template<
typename T1,
bool AF1,
bool PF1,
bool SO,
typename T2,
bool AF2,
bool PF2,
typename OP >
6998 struct BinaryMapTrait< CustomMatrix<T1,AF1,PF1,SO>, CustomMatrix<T2,AF2,PF2,SO>, OP >
7003 template<
typename T1,
bool AF1,
bool PF1,
bool SO1,
typename T2,
bool AF2,
bool PF2,
bool SO2,
typename OP >
7004 struct BinaryMapTrait< CustomMatrix<T1,AF1,PF1,SO1>, CustomMatrix<T2,AF2,PF2,SO2>, OP >
7022 template<
typename T,
bool AF,
bool PF,
bool SO >
7041 template<
typename T,
bool AF,
bool PF,
bool SO >
7042 struct RowTrait< CustomMatrix<T,AF,PF,SO> >
7060 template<
typename T,
bool AF,
bool PF,
bool SO >
size_t spacing() const noexcept
Returns the spacing between the beginning of two rows/columns.
Definition: CustomMatrix.h:1708
Compile time check for vectorizable types.Depending on the available instruction set (SSE...
Definition: IsVectorizable.h:135
Constraint on the data type.
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.This macro encapsulates the default way o...
Definition: Exception.h:235
size_t m_
The current number of rows of the matrix.
Definition: CustomMatrix.h:698
CustomMatrix & ctranspose()
In-place conjugate transpose of the matrix.
Definition: CustomMatrix.h:1947
Header file for auxiliary alias declarations.
Headerfile for the generic min algorithm.
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: CustomMatrix.h:1687
Header file for kernel specific block sizes.
BLAZE_ALWAYS_INLINE void store(size_t i, size_t j, const SIMDType &value) noexcept
Store of a SIMD element of the matrix.
Definition: CustomMatrix.h:2298
Availability of a SIMD subtraction for the given data types.Depending on the available instruction se...
Definition: HasSIMDSub.h:171
Header file for mathematical functions.
Header file for the Schur product trait.
Compile time check for low-level access to constant data.This type trait tests whether the given data...
Definition: HasConstDataAccess.h:75
#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
bool canAlias(const Other *alias) const noexcept
Returns whether the matrix can alias with the given address alias.
Definition: CustomMatrix.h:2105
bool canSMPAssign() const noexcept
Returns whether the matrix can be used in SMP assignments.
Definition: CustomMatrix.h:2168
Header file for the alignment flag values.
Header file for the UNUSED_PARAMETER function template.
EnableIf_< IsDenseMatrix< MT1 > > smpSchurAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP Schur product assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:196
Header file for the subtraction trait.
Header file for basic type definitions.
const SIMDType load() const noexcept
Load of the SIMD element at the current iterator position.
Definition: DenseIterator.h:403
Header file for the row trait.
Base template for the SubmatrixTrait class.
Definition: SubmatrixTrait.h:128
Base template for the ColumnTrait class.
Definition: ColumnTrait.h:127
BLAZE_ALWAYS_INLINE EnableIf_< And< IsIntegral< T1 >, HasSize< T1, 1UL > > > storea(T1 *address, const SIMDi8< T2 > &value) noexcept
Aligned store of a vector of 1-byte integral values.
Definition: Storea.h:79
EnableIf_< IsDenseMatrix< MT1 > > smpSubAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:164
BLAZE_ALWAYS_INLINE SIMDType load(size_t i, size_t j) const noexcept
Load of a SIMD element of the matrix.
Definition: CustomMatrix.h:2195
Header file for the IsSparseMatrix type trait.
Header file for the IsDiagonal type trait.
Type ElementType
Type of the matrix elements.
Definition: CustomMatrix.h:429
Generic wrapper for a compile time constant integral value.The IntegralConstant class template repres...
Definition: IntegralConstant.h:71
const Type & ReturnType
Return type for expression template evaluations.
Definition: CustomMatrix.h:431
BLAZE_ALWAYS_INLINE T1 & operator/=(SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs)
Division assignment operator for the division of two SIMD packs.
Definition: BasicTypes.h:1411
Header file for the IsSame and IsStrictlySame type traits.
Base template for the SchurTrait class.
Definition: SchurTrait.h:124
ConstIterator cbegin(size_t i) const noexcept
Returns an iterator to the first element of row/column i.
Definition: CustomMatrix.h:1159
Availability of a SIMD multiplication for the given data types.Depending on the available instruction...
Definition: HasSIMDMult.h:172
typename SIMDTrait< T >::Type SIMDTrait_
Auxiliary alias declaration for the SIMDTrait class template.The SIMDTrait_ alias declaration provide...
Definition: SIMDTrait.h:316
CustomMatrix & operator=(const Type &set)
Homogenous assignment to all matrix elements.
Definition: CustomMatrix.h:1257
typename DisableIf< Condition, T >::Type DisableIf_
Auxiliary type for the DisableIf class template.The DisableIf_ alias declaration provides a convenien...
Definition: DisableIf.h:224
Header file for the IsIntegral type trait.
const ElementType_< MT > min(const DenseMatrix< MT, SO > &dm)
Returns the smallest element of the dense matrix.
Definition: DenseMatrix.h:1762
Compile time check for lower triangular matrices.This type trait tests whether or not the given templ...
Definition: IsLower.h:88
Availability of a SIMD addition for the given data types.Depending on the available instruction set (...
Definition: HasSIMDAdd.h:171
const Type & ConstReference
Reference to a constant matrix value.
Definition: CustomMatrix.h:435
Reference operator()(size_t i, size_t j) noexcept
2D-access to the matrix elements.
Definition: CustomMatrix.h:914
CustomMatrix & transpose()
In-place transpose of the matrix.
Definition: CustomMatrix.h:1918
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VOLATILE(T)
Constraint on the data type.In case the given data type is a volatile-qualified type, a compilation error is created.
Definition: Volatile.h:79
size_t nn_
The number of elements between two rows.
Definition: CustomMatrix.h:700
typename MultTrait< T1, T2 >::Type MultTrait_
Auxiliary alias declaration for the MultTrait class template.The MultTrait_ alias declaration provide...
Definition: MultTrait.h:250
Type relationship analysis.This class tests if the two data types A and B are equal. For this type comparison, the cv-qualifiers of both data types are ignored. If A and B are the same data type (ignoring the cv-qualifiers), then the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType.
Definition: IsSame.h:140
Compile time check for upper triangular matrices.This type trait tests whether or not the given templ...
Definition: IsUpper.h:88
Efficient implementation of an arbitrary sized vector.The DynamicVector class template is the represe...
Definition: DynamicVector.h:183
System settings for performance optimizations.
Efficient implementation of a dynamic matrix.The DynamicMatrix class template is the representation ...
Definition: DynamicMatrix.h:212
BLAZE_ALWAYS_INLINE T1 & operator*=(SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs)
Multiplication assignment operator for the multiplication of two SIMD packs.
Definition: BasicTypes.h:1393
Compile time check for data types.This type trait tests whether or not the given types can be combine...
Definition: IsSIMDCombinable.h:120
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral< T >, HasSize< T, 1UL > >, If_< IsSigned< T >, SIMDint8, SIMDuint8 > > loadu(const T *address) noexcept
Loads a vector of 1-byte integral values.
Definition: Loadu.h:77
typename T::ResultType ResultType_
Alias declaration for nested ResultType type definitions.The ResultType_ alias declaration provides a...
Definition: Aliases.h:343
const ElementType_< MT > max(const DenseMatrix< MT, SO > &dm)
Returns the largest element of the dense matrix.
Definition: DenseMatrix.h:1809
EnableIf_< IsDenseMatrix< MT1 > > smpAddAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP addition assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:133
void swap(CustomMatrix &m) noexcept
Swapping the contents of two matrices.
Definition: CustomMatrix.h:1886
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:78
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:129
Constraint on the data type.
constexpr bool unpadded
Padding flag for unpadded vectors and matrices.Via this flag it is possible to specify custom vectors...
Definition: PaddingFlag.h:64
Header file for the std::initializer_list aliases.
Header file for the SparseMatrix base class.
Compile time check for low-level access to mutable data.This type trait tests whether the given data ...
Definition: HasMutableDataAccess.h:75
Compile time check for the alignment of data types.This type trait tests whether the given data type ...
Definition: IsAligned.h:87
BLAZE_ALWAYS_INLINE SIMDType loada(size_t i, size_t j) const noexcept
Aligned load of a SIMD element of the matrix.
Definition: CustomMatrix.h:2225
BLAZE_ALWAYS_INLINE void stream(size_t i, size_t j, const SIMDType &value) noexcept
Aligned, non-temporal store of a SIMD element of the matrix.
Definition: CustomMatrix.h:2404
Base template for the RowTrait class.
Definition: RowTrait.h:127
Headerfile for the generic max algorithm.
typename TransExprTrait< T >::Type TransExprTrait_
Auxiliary alias declaration for the TransExprTrait class template.The TransExprTrait_ alias declarati...
Definition: TransExprTrait.h:112
Header file for the DisableIf class template.
Header file for the IsCustom type trait.
Header file for the multiplication trait.
Header file for the IsStrictlyUpper type trait.
Header file for the unary map trait.
void reset()
Reset to the default initial values.
Definition: CustomMatrix.h:1818
SIMDTrait_< ElementType > SIMDType
SIMD type of the matrix elements.
Definition: CustomMatrix.h:430
typename CTransExprTrait< T >::Type CTransExprTrait_
Auxiliary alias declaration for the CTransExprTrait class template.The CTransExprTrait_ alias declara...
Definition: CTransExprTrait.h:112
Header file for the clear shim.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
#define BLAZE_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition: Inline.h:85
Header file for nested template disabiguation.
void swap(CompressedMatrix< Type, SO > &a, CompressedMatrix< Type, SO > &b) noexcept
Swapping the contents of two compressed matrices.
Definition: CompressedMatrix.h:5924
Pointer data() noexcept
Low-level data access to the matrix elements.
Definition: CustomMatrix.h:1022
Header file for all forward declarations of the math module.
size_t capacity() const noexcept
Returns the maximum capacity of the matrix.
Definition: CustomMatrix.h:1724
#define BLAZE_CONSTRAINT_MUST_NOT_BE_POINTER_TYPE(T)
Constraint on the data type.In case the given data type T is not a pointer type, a compilation error ...
Definition: Pointer.h:79
Header file for the IsSMPAssignable type trait.
Compile time check for data types with padding.This type trait tests whether the given data type empl...
Definition: IsPadded.h:76
EnableIf_< IsDenseMatrix< MT1 > > smpAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:102
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exception.This macro encapsulates the default way of Bl...
Definition: Exception.h:331
Header file for the HasSIMDAdd type trait.
Efficient implementation of a fixed-sized matrix.The StaticMatrix class template is the representatio...
Definition: Forward.h:60
Header file for the DenseMatrix base class.
Header file for the DenseIterator class template.
Reference at(size_t i, size_t j)
Checked access to the matrix elements.
Definition: CustomMatrix.h:963
void stream(const SIMDType &value) const noexcept
Aligned, non-temporal store of the SIMD element at the current iterator position. ...
Definition: DenseIterator.h:531
Iterator end(size_t i) noexcept
Returns an iterator just past the last element of row/column i.
Definition: CustomMatrix.h:1183
Header file for all SIMD functionality.
Constraint on the data type.
void store(const SIMDType &value) const noexcept
Store of the SIMD element at the current iterator position.
Definition: DenseIterator.h:468
const Type * ConstPointer
Pointer to a constant matrix value.
Definition: CustomMatrix.h:437
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DIAGONAL_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a diagonal matrix type, a compilation error is created.
Definition: Diagonal.h:79
Header file for the IsLower type trait.
Header file for the IsAligned type trait.
Compile time check for diagonal matrices.This type trait tests whether or not the given template para...
Definition: IsDiagonal.h:90
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral< T >, HasSize< T, 1UL > >, If_< IsSigned< T >, SIMDint8, SIMDuint8 > > loada(const T *address) noexcept
Loads a vector of 1-byte integral values.
Definition: Loada.h:80
Compile time check for custom data types.This type trait tests whether the given data type is a custo...
Definition: IsCustom.h:87
Header file for the default storage order for all vectors of the Blaze library.
size_t n_
The current number of columns of the matrix.
Definition: CustomMatrix.h:699
#define BLAZE_CONSTRAINT_MUST_BE_VECTORIZABLE_TYPE(T)
Constraint on the data type.In case the given data type T is not a vectorizable data type...
Definition: Vectorizable.h:61
Header file for the misalignment function.
Header file for the exception macros of the math module.
Compile time check for strictly upper triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyUpper.h:86
Compile time check for data types.This type trait tests whether or not the given template parameter i...
Definition: IsSMPAssignable.h:119
BLAZE_ALWAYS_INLINE SIMDType loadu(size_t i, size_t j) const noexcept
Unaligned load of a SIMD element of the matrix.
Definition: CustomMatrix.h:2262
Rebind mechanism to obtain a CustomMatrix with different data/element type.
Definition: CustomMatrix.h:447
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:580
Header file for the IsPadded type trait.
Header file for the IsVectorizable type trait.
Header file for the conjugate shim.
Header file for the IsNumeric type trait.
Header file for the HasConstDataAccess type trait.
Resize mechanism to obtain a CustomMatrix with different fixed dimensions.
Definition: CustomMatrix.h:457
BLAZE_ALWAYS_INLINE EnableIf_< And< IsIntegral< T1 >, HasSize< T1, 1UL > > > stream(T1 *address, const SIMDi8< T2 > &value) noexcept
Aligned, non-temporal store of a vector of 1-byte integral values.
Definition: Stream.h:75
Header file for the RemoveConst type trait.
Header file for the IsSIMDCombinable type trait.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SYMMETRIC_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a symmetric matrix type, a compilation error is created.
Definition: Symmetric.h:79
Header file for the HasSIMDMult type trait.
Header file for the binary map trait.
BLAZE_ALWAYS_INLINE T1 & operator+=(SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs)
Addition assignment operator for the addition of two SIMD packs.
Definition: BasicTypes.h:1357
size_t determineColumns(initializer_list< initializer_list< Type > > list) noexcept
Determine the maximum number of columns specified by the given initializer list.
Definition: InitializerList.h:80
Header file for run time assertion macros.
Base template for the AddTrait class.
Definition: AddTrait.h:139
Base template for the MultTrait class.
Definition: MultTrait.h:139
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: CustomMatrix.h:1671
Header file for the addition trait.
Header file for the division trait.
BLAZE_ALWAYS_INLINE void storea(size_t i, size_t j, const SIMDType &value) noexcept
Aligned store of a SIMD element of the matrix.
Definition: CustomMatrix.h:2329
Header file for the InvExprTrait class template.
Header file for the submatrix trait.
void clear()
Clearing the matrix.
Definition: CustomMatrix.h:1866
Type * Pointer
Pointer to a non-constant matrix value.
Definition: CustomMatrix.h:436
SIMD characteristics of data types.The SIMDTrait class template provides the SIMD characteristics of ...
Definition: SIMDTrait.h:296
Header file for the cache size of the target architecture.
Efficient implementation of a dynamically sized matrix with static memory.The HybridMatrix class temp...
Definition: Forward.h:58
#define BLAZE_CONSTRAINT_MUST_NOT_BE_REFERENCE_TYPE(T)
Constraint on the data type.In case the given data type T is not a reference type, a compilation error is created.
Definition: Reference.h:79
Header file for the column trait.
Header file for the isDefault shim.
Header file for the TransExprTrait class template.
Constraint on the data type.
Base class for matrices.The Matrix class is a base class for all dense and sparse matrix classes with...
Definition: Forward.h:101
Constraint on the data type.
Constraint on the data type.
Header file for the HasSIMDSub type trait.
BLAZE_ALWAYS_INLINE void conjugate(T &a) noexcept(IsNumeric< T >::value)
In-place conjugation of the given value/object.
Definition: Conjugate.h:120
decltype(auto) serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:819
Header file for the HasMutableDataAccess type trait.
Type & Reference
Reference to a non-constant matrix value.
Definition: CustomMatrix.h:434
typename EnableIf< Condition, T >::Type EnableIf_
Auxiliary alias declaration for the EnableIf class template.The EnableIf_ alias declaration provides ...
Definition: EnableIf.h:224
Base template for the DivTrait class.
Definition: DivTrait.h:139
Header file for the padding flag values.
Implementation of a generic iterator for dense vectors and matrices.The DenseIterator represents a ge...
Definition: DenseIterator.h:58
BLAZE_ALWAYS_INLINE EnableIf_< And< IsIntegral< T1 >, HasSize< T1, 1UL > > > storeu(T1 *address, const SIMDi8< T2 > &value) noexcept
Unaligned store of a vector of 1-byte integral values.
Definition: Storeu.h:76
BLAZE_ALWAYS_INLINE void cswap(T &a, T &b) noexcept(IsNumeric< T >::value)
Swapping two conjugated values/objects.
Definition: Conjugate.h:195
BLAZE_ALWAYS_INLINE bool checkAlignment(const T *address)
Checks the alignment of the given address.
Definition: AlignmentCheck.h:68
Compile time check for strictly lower triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyLower.h:86
typename T::ConstIterator ConstIterator_
Alias declaration for nested ConstIterator type definitions.The ConstIterator_ alias declaration prov...
Definition: Aliases.h:103
DenseIterator< Type, AF > Iterator
Iterator over non-constant elements.
Definition: CustomMatrix.h:439
CustomMatrix()
The default constructor for CustomMatrix.
Definition: CustomMatrix.h:740
Initializer list type of the Blaze library.
bool isAliased(const Other *alias) const noexcept
Returns whether the matrix is aliased with the given address alias.
Definition: CustomMatrix.h:2127
Efficient implementation of a customizable matrix.The CustomMatrix class template provides the functi...
Definition: CustomMatrix.h:412
Header file for the alignment check function.
typename InvExprTrait< T >::Type InvExprTrait_
Auxiliary alias declaration for the InvExprTrait class template.The InvExprTrait_ alias declaration p...
Definition: InvExprTrait.h:123
BLAZE_ALWAYS_INLINE void storeu(size_t i, size_t j, const SIMDType &value) noexcept
Unaligned store of a SIMD element of the matrix.
Definition: CustomMatrix.h:2367
ConstIterator cend(size_t i) const noexcept
Returns an iterator just past the last element of row/column i.
Definition: CustomMatrix.h:1231
DenseIterator< const Type, AF > ConstIterator
Iterator over constant elements.
Definition: CustomMatrix.h:440
Iterator begin(size_t i) noexcept
Returns an iterator to the first element of row/column i.
Definition: CustomMatrix.h:1111
bool isIntact(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the invariants of the given diagonal matrix are intact.
Definition: DiagonalMatrix.h:252
Compile time check for sparse matrix types.This type trait tests whether or not the given template pa...
Definition: IsSparseMatrix.h:103
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:600
Base template for the SubTrait class.
Definition: SubTrait.h:139
#define BLAZE_THROW_LOGIC_ERROR(MESSAGE)
Macro for the emission of a std::logic_error exception.This macro encapsulates the default way of Bla...
Definition: Exception.h:187
BLAZE_ALWAYS_INLINE T1 & operator-=(SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs)
Subtraction assignment operator for the subtraction of two SIMD packs.
Definition: BasicTypes.h:1375
Header file for the IsUpper type trait.
void UNUSED_PARAMETER(const Args &...)
Suppression of unused parameter warnings.
Definition: Unused.h:81
Header file for the CTransExprTrait class template.
#define BLAZE_STATIC_ASSERT(expr)
Compile time assertion macro.In case of an invalid compile time expression, a compilation error is cr...
Definition: StaticAssert.h:112
size_t nonZeros() const
Returns the total number of non-zero elements in the matrix.
Definition: CustomMatrix.h:1764
Base template for the BinaryMapTrait class.
Definition: BinaryMapTrait.h:119
bool isAligned() const noexcept
Returns whether the matrix is properly aligned in memory.
Definition: CustomMatrix.h:2147
Type * v_
The custom array of elements.
Definition: CustomMatrix.h:701
Base template for the UnaryMapTrait class.
Definition: UnaryMapTrait.h:117
System settings for the inline keywords.
Header file for the thresholds for matrix/vector and matrix/matrix multiplications.
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.In case of an invalid run time expression, the program execution is terminated. The BLAZE_INTERNAL_ASSERT macro can be disabled by setting the BLAZE_USER_ASSERTION flag to zero or by defining NDEBUG during the compilation.
Definition: Assert.h:101
Header file for the TrueType type/value trait base class.