22 #ifndef _BLAZE_MATH_DENSE_STATICMATRIX_H_
23 #define _BLAZE_MATH_DENSE_STATICMATRIX_H_
162 template<
typename Type
176 enum { NN = N + ( IT::size - ( N % IT::size ) ) % IT::size };
207 enum { canAlias = 0 };
217 template<
typename Other,
bool SO2 >
inline StaticMatrix(
const StaticMatrix<Other,M,N,SO2>& m );
221 inline StaticMatrix(
const Type& v1,
const Type& v2,
const Type& v3 );
222 inline StaticMatrix(
const Type& v1,
const Type& v2,
const Type& v3,
const Type& v4 );
223 inline StaticMatrix(
const Type& v1,
const Type& v2,
const Type& v3,
const Type& v4,
const Type& v5 );
224 inline StaticMatrix(
const Type& v1,
const Type& v2,
const Type& v3,
const Type& v4,
const Type& v5,
226 inline StaticMatrix(
const Type& v1,
const Type& v2,
const Type& v3,
const Type& v4,
const Type& v5,
227 const Type& v6,
const Type& v7 );
228 inline StaticMatrix(
const Type& v1,
const Type& v2,
const Type& v3,
const Type& v4,
const Type& v5,
229 const Type& v6,
const Type& v7,
const Type& v8 );
230 inline StaticMatrix(
const Type& v1,
const Type& v2,
const Type& v3,
const Type& v4,
const Type& v5,
231 const Type& v6,
const Type& v7,
const Type& v8,
const Type& v9 );
232 inline StaticMatrix(
const Type& v1,
const Type& v2,
const Type& v3,
const Type& v4,
const Type& v5,
233 const Type& v6,
const Type& v7,
const Type& v8,
const Type& v9,
const Type& v10 );
247 inline const Type*
data()
const;
262 template<
typename Other,
bool SO2 >
inline StaticMatrix&
operator= (
const StaticMatrix<Other,M,N,SO2>& rhs );
268 template<
typename Other >
269 inline typename EnableIf< IsNumeric<Other>,
StaticMatrix >::Type&
272 template<
typename Other >
273 inline typename EnableIf< IsNumeric<Other>,
StaticMatrix >::Type&
281 inline size_t rows()
const;
285 inline size_t nonZeros(
size_t i )
const;
299 template<
typename MT >
300 struct VectorizedAssign {
301 enum { value = vectorizable && MT::vectorizable &&
302 IsSame<Type,typename MT::ElementType>::value &&
303 IsRowMajorMatrix<MT>::value };
311 template<
typename MT >
312 struct VectorizedAddAssign {
313 enum { value = vectorizable && MT::vectorizable &&
314 IsSame<Type,typename MT::ElementType>::value &&
315 IntrinsicTrait<Type>::addition &&
316 IsRowMajorMatrix<MT>::value };
324 template<
typename MT >
325 struct VectorizedSubAssign {
326 enum { value = vectorizable && MT::vectorizable &&
327 IsSame<Type,typename MT::ElementType>::value &&
328 IntrinsicTrait<Type>::subtraction &&
329 IsRowMajorMatrix<MT>::value };
338 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
341 template<
typename MT,
bool SO2 >
342 inline typename DisableIf< VectorizedAssign<MT> >::Type
343 assign(
const DenseMatrix<MT,SO2>& rhs );
345 template<
typename MT,
bool SO2 >
346 inline typename EnableIf< VectorizedAssign<MT> >::Type
347 assign(
const DenseMatrix<MT,SO2>& rhs );
352 template<
typename MT,
bool SO2 >
353 inline typename DisableIf< VectorizedAddAssign<MT> >::Type
354 addAssign(
const DenseMatrix<MT,SO2>& rhs );
356 template<
typename MT,
bool SO2 >
357 inline typename EnableIf< VectorizedAddAssign<MT> >::Type
358 addAssign(
const DenseMatrix<MT,SO2>& rhs );
363 template<
typename MT,
bool SO2 >
364 inline typename DisableIf< VectorizedSubAssign<MT> >::Type
365 subAssign(
const DenseMatrix<MT,SO2>& rhs );
367 template<
typename MT,
bool SO2 >
368 inline typename EnableIf< VectorizedSubAssign<MT> >::Type
369 subAssign(
const DenseMatrix<MT,SO2>& rhs );
419 template<
typename Type
425 BLAZE_INTERNAL_ASSERT( !( reinterpret_cast<size_t>( v_ ) % IT::alignment ),
"Invalid alignment detected" );
428 for(
size_t i=0UL; i<M*NN; ++i )
440 template<
typename Type
446 BLAZE_INTERNAL_ASSERT( !( reinterpret_cast<size_t>( v_ ) % IT::alignment ),
"Invalid alignment detected" );
448 for(
size_t i=0UL; i<M; ++i ) {
449 for(
size_t j=0UL; j<N; ++j )
453 for(
size_t j=N; j<NN; ++j )
468 template<
typename Type
474 BLAZE_INTERNAL_ASSERT( !( reinterpret_cast<size_t>( v_ ) % IT::alignment ),
"Invalid alignment detected" );
476 for(
size_t i=0UL; i<M*NN; ++i )
487 template<
typename Type
491 template<
typename Other
495 BLAZE_INTERNAL_ASSERT( !( reinterpret_cast<size_t>( v_ ) % IT::alignment ),
"Invalid alignment detected" );
497 for(
size_t i=0UL; i<M; ++i ) {
498 for(
size_t j=0UL; j<N; ++j )
502 for(
size_t j=N; j<NN; ++j )
520 template<
typename Type
524 template<
typename MT
530 BLAZE_INTERNAL_ASSERT( !( reinterpret_cast<size_t>( v_ ) % IT::alignment ),
"Invalid alignment detected" );
533 throw std::invalid_argument(
"Invalid setup of static matrix" );
536 for(
size_t i=0UL; i<M; ++i ) {
564 template<
typename Type
571 BLAZE_INTERNAL_ASSERT( !( reinterpret_cast<size_t>( v_ ) % IT::alignment ),
"Invalid alignment detected" );
586 for(
size_t i=0UL; i<M; ++i ) {
587 for(
size_t j=N; j<NN; ++j )
613 template<
typename Type
620 BLAZE_INTERNAL_ASSERT( !( reinterpret_cast<size_t>( v_ ) % IT::alignment ),
"Invalid alignment detected" );
637 for(
size_t i=0UL; i<M; ++i ) {
638 for(
size_t j=N; j<NN; ++j )
667 template<
typename Type
672 const Type& v3,
const Type& v4 )
675 BLAZE_INTERNAL_ASSERT( !( reinterpret_cast<size_t>( v_ ) % IT::alignment ),
"Invalid alignment detected" );
686 else if( M == 2UL ) {
702 for(
size_t i=0UL; i<M; ++i ) {
703 for(
size_t j=N; j<NN; ++j )
731 template<
typename Type
736 const Type& v4,
const Type& v5 )
739 BLAZE_INTERNAL_ASSERT( !( reinterpret_cast<size_t>( v_ ) % IT::alignment ),
"Invalid alignment detected" );
760 for(
size_t i=0UL; i<M; ++i ) {
761 for(
size_t j=N; j<NN; ++j )
793 template<
typename Type
798 const Type& v4,
const Type& v5,
const Type& v6 )
801 BLAZE_INTERNAL_ASSERT( !( reinterpret_cast<size_t>( v_ ) % IT::alignment ),
"Invalid alignment detected" );
814 else if( M == 2UL ) {
824 else if( M == 3UL ) {
844 for(
size_t i=0UL; i<M; ++i ) {
845 for(
size_t j=N; j<NN; ++j )
875 template<
typename Type
880 const Type& v4,
const Type& v5,
const Type& v6,
884 BLAZE_INTERNAL_ASSERT( !( reinterpret_cast<size_t>( v_ ) % IT::alignment ),
"Invalid alignment detected" );
909 for(
size_t i=0UL; i<M; ++i ) {
910 for(
size_t j=N; j<NN; ++j )
943 template<
typename Type
948 const Type& v4,
const Type& v5,
const Type& v6,
949 const Type& v7,
const Type& v8 )
952 BLAZE_INTERNAL_ASSERT( !( reinterpret_cast<size_t>( v_ ) % IT::alignment ),
"Invalid alignment detected" );
967 else if( M == 2UL ) {
979 else if( M == 4UL ) {
1003 for(
size_t i=0UL; i<M; ++i ) {
1004 for(
size_t j=N; j<NN; ++j )
1005 v_[i*NN+j] = Type();
1039 template<
typename Type
1044 const Type& v4,
const Type& v5,
const Type& v6,
1045 const Type& v7,
const Type& v8,
const Type& v9 )
1048 BLAZE_INTERNAL_ASSERT( !( reinterpret_cast<size_t>( v_ ) % IT::alignment ),
"Invalid alignment detected" );
1064 else if( M == 3UL ) {
1072 v_[2UL*NN+1UL] = v8;
1073 v_[2UL*NN+2UL] = v9;
1090 for(
size_t i=0UL; i<M; ++i ) {
1091 for(
size_t j=N; j<NN; ++j )
1092 v_[i*NN+j] = Type();
1127 template<
typename Type
1132 const Type& v4,
const Type& v5,
const Type& v6,
1133 const Type& v7,
const Type& v8,
const Type& v9,
1137 BLAZE_INTERNAL_ASSERT( !( reinterpret_cast<size_t>( v_ ) % IT::alignment ),
"Invalid alignment detected" );
1154 else if( M == 2UL ) {
1168 else if( M == 5UL ) {
1174 v_[2UL*NN+1UL] = v6;
1176 v_[3UL*NN+1UL] = v8;
1178 v_[4UL*NN+1UL] = v10;
1196 for(
size_t i=0UL; i<M; ++i ) {
1197 for(
size_t j=N; j<NN; ++j )
1198 v_[i*NN+j] = Type();
1220 template<
typename Type
1241 template<
typename Type
1260 template<
typename Type
1276 template<
typename Type
1298 template<
typename Type
1322 template<
typename Type
1346 template<
typename Type
1370 template<
typename Type
1378 return v_ + i*NN + N;
1394 template<
typename Type
1402 return v_ + i*NN + N;
1418 template<
typename Type
1426 return v_ + i*NN + N;
1445 template<
typename Type
1451 for(
size_t i=0UL; i<M; ++i )
1452 for(
size_t j=0UL; j<N; ++j )
1468 template<
typename Type
1474 for(
size_t i=0UL; i<M; ++i )
1475 for(
size_t j=0UL; j<N; ++j )
1476 v_[i*NN+j] = rhs(i,j);
1489 template<
typename Type
1493 template<
typename Other
1498 for(
size_t i=0UL; i<M; ++i )
1499 for(
size_t j=0UL; j<N; ++j )
1500 v_[i*NN+j] = rhs(i,j);
1518 template<
typename Type
1522 template<
typename MT
1529 throw std::invalid_argument(
"Invalid assignment to static matrix" );
1556 template<
typename Type
1560 template<
typename MT
1567 throw std::invalid_argument(
"Matrix sizes do not match" );
1592 template<
typename Type
1596 template<
typename MT
1603 throw std::invalid_argument(
"Matrix sizes do not match" );
1628 template<
typename Type
1632 template<
typename MT
1636 if( M != N || (~rhs).
rows() != M || (~rhs).
columns() != M )
1637 throw std::invalid_argument(
"Matrix sizes do not match" );
1640 return this->operator=( tmp );
1652 template<
typename Type
1656 template<
typename Other >
1660 return operator=( (*
this) * rhs );
1674 template<
typename Type
1678 template<
typename Other >
1684 return operator=( (*
this) / rhs );
1702 template<
typename Type
1718 template<
typename Type
1737 template<
typename Type
1753 template<
typename Type
1759 size_t nonzeros( 0UL );
1761 for(
size_t i=0UL; i<M; ++i )
1762 for(
size_t j=0UL; j<N; ++j )
1777 template<
typename Type
1785 const size_t jend( (i+1UL)*NN );
1786 size_t nonzeros( 0UL );
1788 for(
size_t j=i*NN; j<jend; ++j )
1802 template<
typename Type
1810 for(
size_t i=0UL; i<M; ++i )
1811 for(
size_t j=0UL; j<N; ++j )
1812 reset( v_[i*NN+j] );
1822 template<
typename Type
1830 for(
size_t i=1UL; i<M; ++i )
1831 for(
size_t j=0UL; j<i; ++j )
1832 swap( v_[i*NN+j], v_[j*NN+i] );
1856 template<
typename Type
1862 if( M != N )
return false;
1864 for(
size_t i=1UL; i<M; ++i ) {
1865 for(
size_t j=0UL; j<i; ++j ) {
1881 template<
typename Type
1887 if( M != N )
return false;
1889 for(
size_t i=1UL; i<M; ++i ) {
1890 for(
size_t j=0UL; j<i; ++j ) {
1891 if( !
equal( v_[i*NN+j], v_[j*NN+i] ) )
1907 template<
typename Type
1911 template<
typename Other >
1914 for(
size_t i=0UL; i<M; ++i )
1915 for(
size_t j=0UL; j<N; ++j )
1916 v_[i*NN+j] *= scalar;
1930 template<
typename Type
1938 for(
size_t i=0UL; i<M; ++i ) {
1939 for(
size_t j=0UL; j<N; ++j ) {
1940 swap( v_[i*NN+j], m(i,j) );
1961 template<
typename Type
1965 template<
typename Other >
1968 return static_cast<const void*
>( this ) == static_cast<const void*>( alias );
1985 template<
typename Type
1999 return load( &v_[i*NN+j] );
2015 template<
typename Type
2019 template<
typename MT
2026 for(
size_t i=0UL; i<M; ++i ) {
2027 for(
size_t j=0UL; j<N; ++j ) {
2028 v_[i*NN+j] = (~rhs)(i,j);
2046 template<
typename Type
2050 template<
typename MT
2059 for(
size_t i=0UL; i<M; ++i ) {
2060 for(
size_t j=0UL; j<N; j+=IT::size ) {
2061 store( &v_[i*NN+j], (~rhs).
get(i,j) );
2079 template<
typename Type
2083 template<
typename MT >
2090 for(
size_t i=0UL; i<M; ++i )
2091 for( ConstIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
2092 v_[i*NN+element->index()] = element->value();
2108 template<
typename Type
2112 template<
typename MT >
2119 for(
size_t j=0UL; j<N; ++j )
2120 for( ConstIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
2121 v_[element->index()*NN+j] = element->value();
2137 template<
typename Type
2141 template<
typename MT
2148 for(
size_t i=0UL; i<M; ++i ) {
2149 for(
size_t j=0UL; j<N; ++j ) {
2150 v_[i*NN+j] += (~rhs)(i,j);
2168 template<
typename Type
2172 template<
typename MT
2181 for(
size_t i=0UL; i<M; ++i ) {
2182 for(
size_t j=0UL; j<N; j+=IT::size ) {
2183 store( &v_[i*NN+j],
load( &v_[i*NN+j] ) + (~rhs).
get(i,j) );
2201 template<
typename Type
2205 template<
typename MT >
2212 for(
size_t i=0UL; i<M; ++i )
2213 for( ConstIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
2214 v_[i*NN+element->index()] += element->value();
2230 template<
typename Type
2234 template<
typename MT >
2241 for(
size_t j=0UL; j<N; ++j )
2242 for( ConstIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
2243 v_[element->index()*NN+j] += element->value();
2259 template<
typename Type
2263 template<
typename MT
2270 for(
size_t i=0UL; i<M; ++i ) {
2271 for(
size_t j=0UL; j<N; ++j ) {
2272 v_[i*NN+j] -= (~rhs)(i,j);
2290 template<
typename Type
2294 template<
typename MT
2303 for(
size_t i=0UL; i<M; ++i ) {
2304 for(
size_t j=0UL; j<N; j+=IT::size ) {
2305 store( &v_[i*NN+j],
load( &v_[i*NN+j] ) - (~rhs).
get(i,j) );
2323 template<
typename Type
2327 template<
typename MT >
2334 for(
size_t i=0UL; i<M; ++i )
2335 for( ConstIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
2336 v_[i*NN+element->index()] -= element->value();
2352 template<
typename Type
2356 template<
typename MT >
2363 for(
size_t j=0UL; j<N; ++j )
2364 for( ConstIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
2365 v_[element->index()*NN+j] -= element->value();
2390 template<
typename Type
2403 enum { MM = M + ( IT::size - ( M % IT::size ) ) % IT::size };
2408 typedef StaticMatrix<Type,M,N,true>
This;
2428 enum { vectorizable = IsVectorizable<Type>::value };
2434 enum { canAlias = 0 };
2444 template<
typename Other,
bool SO >
inline StaticMatrix(
const StaticMatrix<Other,M,N,SO>& m );
2448 inline StaticMatrix(
const Type& v1,
const Type& v2,
const Type& v3 );
2449 inline StaticMatrix(
const Type& v1,
const Type& v2,
const Type& v3,
const Type& v4 );
2450 inline StaticMatrix(
const Type& v1,
const Type& v2,
const Type& v3,
const Type& v4,
const Type& v5 );
2451 inline StaticMatrix(
const Type& v1,
const Type& v2,
const Type& v3,
const Type& v4,
const Type& v5,
2453 inline StaticMatrix(
const Type& v1,
const Type& v2,
const Type& v3,
const Type& v4,
const Type& v5,
2454 const Type& v6,
const Type& v7 );
2455 inline StaticMatrix(
const Type& v1,
const Type& v2,
const Type& v3,
const Type& v4,
const Type& v5,
2456 const Type& v6,
const Type& v7,
const Type& v8 );
2457 inline StaticMatrix(
const Type& v1,
const Type& v2,
const Type& v3,
const Type& v4,
const Type& v5,
2458 const Type& v6,
const Type& v7,
const Type& v8,
const Type& v9 );
2459 inline StaticMatrix(
const Type& v1,
const Type& v2,
const Type& v3,
const Type& v4,
const Type& v5,
2460 const Type& v6,
const Type& v7,
const Type& v8,
const Type& v9,
const Type& v10 );
2473 inline Type*
data();
2474 inline const Type*
data()
const;
2489 template<
typename Other,
bool SO >
inline StaticMatrix&
operator= (
const StaticMatrix<Other,M,N,SO>& rhs );
2495 template<
typename Other >
2496 inline typename EnableIf< IsNumeric<Other>,
StaticMatrix >::Type&
2499 template<
typename Other >
2500 inline typename EnableIf< IsNumeric<Other>,
StaticMatrix >::Type&
2508 inline size_t rows()
const;
2509 inline size_t columns()
const;
2510 inline size_t spacing()
const;
2512 inline size_t nonZeros(
size_t j )
const;
2513 inline void reset();
2525 template<
typename MT >
2526 struct VectorizedAssign {
2527 enum { value = vectorizable && MT::vectorizable &&
2528 IsSame<Type,typename MT::ElementType>::value &&
2529 IsColumnMajorMatrix<MT>::value };
2535 template<
typename MT >
2536 struct VectorizedAddAssign {
2537 enum { value = vectorizable && MT::vectorizable &&
2538 IsSame<Type,typename MT::ElementType>::value &&
2539 IntrinsicTrait<Type>::addition &&
2540 IsColumnMajorMatrix<MT>::value };
2546 template<
typename MT >
2547 struct VectorizedSubAssign {
2548 enum { value = vectorizable && MT::vectorizable &&
2549 IsSame<Type,typename MT::ElementType>::value &&
2550 IntrinsicTrait<Type>::subtraction &&
2551 IsColumnMajorMatrix<MT>::value };
2559 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
2562 template<
typename MT,
bool SO >
2563 inline typename DisableIf< VectorizedAssign<MT> >::Type
2564 assign(
const DenseMatrix<MT,SO>& rhs );
2566 template<
typename MT,
bool SO >
2567 inline typename EnableIf< VectorizedAssign<MT> >::Type
2568 assign(
const DenseMatrix<MT,SO>& rhs );
2573 template<
typename MT,
bool SO >
2574 inline typename DisableIf< VectorizedAddAssign<MT> >::Type
2575 addAssign(
const DenseMatrix<MT,SO>& rhs );
2577 template<
typename MT,
bool SO >
2578 inline typename EnableIf< VectorizedAddAssign<MT> >::Type
2579 addAssign(
const DenseMatrix<MT,SO>& rhs );
2584 template<
typename MT,
bool SO >
2585 inline typename DisableIf< VectorizedSubAssign<MT> >::Type
2586 subAssign(
const DenseMatrix<MT,SO>& rhs );
2588 template<
typename MT,
bool SO >
2589 inline typename EnableIf< VectorizedSubAssign<MT> >::Type
2590 subAssign(
const DenseMatrix<MT,SO>& rhs );
2633 template<
typename Type
2638 BLAZE_INTERNAL_ASSERT( !( reinterpret_cast<size_t>( v_ ) % IT::alignment ),
"Invalid alignment detected" );
2640 if( IsBuiltin<Type>::value ) {
2641 for(
size_t i=0UL; i<MM*N; ++i )
2655 template<
typename Type
2660 BLAZE_INTERNAL_ASSERT( !( reinterpret_cast<size_t>( v_ ) % IT::alignment ),
"Invalid alignment detected" );
2662 for(
size_t j=0UL; j<N; ++j ) {
2663 for(
size_t i=0UL; i<M; ++i )
2666 if( IsBuiltin<Type>::value ) {
2667 for(
size_t i=M; i<MM; ++i )
2668 v_[i+j*MM] = Type();
2684 template<
typename Type
2689 BLAZE_INTERNAL_ASSERT( !( reinterpret_cast<size_t>( v_ ) % IT::alignment ),
"Invalid alignment detected" );
2691 for(
size_t i=0UL; i<MM*N; ++i )
2704 template<
typename Type
2707 template<
typename Other
2711 BLAZE_INTERNAL_ASSERT( !( reinterpret_cast<size_t>( v_ ) % IT::alignment ),
"Invalid alignment detected" );
2713 for(
size_t j=0UL; j<N; ++j ) {
2714 for(
size_t i=0UL; i<M; ++i )
2715 v_[i+j*MM] = m(i,j);
2717 if( IsBuiltin<Type>::value ) {
2718 for(
size_t i=M; i<MM; ++i )
2719 v_[i+j*MM] = Type();
2738 template<
typename Type
2741 template<
typename MT
2747 BLAZE_INTERNAL_ASSERT( !( reinterpret_cast<size_t>( v_ ) % IT::alignment ),
"Invalid alignment detected" );
2750 throw std::invalid_argument(
"Invalid setup of static matrix" );
2752 if( IsBuiltin<Type>::value ) {
2753 for(
size_t j=0UL; j<N; ++j )
2754 for(
size_t i=( IsSparseMatrix<MT>::value )?( 0UL ):( M ); i<MM; ++i ) {
2755 v_[i+j*MM] = Type();
2783 template<
typename Type
2789 BLAZE_INTERNAL_ASSERT( !( reinterpret_cast<size_t>( v_ ) % IT::alignment ),
"Invalid alignment detected" );
2803 if( IsBuiltin<Type>::value ) {
2804 for(
size_t j=0UL; j<N; ++j )
2805 for(
size_t i=M; i<MM; ++i ) {
2806 v_[i+j*MM] = Type();
2833 template<
typename Type
2839 BLAZE_INTERNAL_ASSERT( !( reinterpret_cast<size_t>( v_ ) % IT::alignment ),
"Invalid alignment detected" );
2855 if( IsBuiltin<Type>::value ) {
2856 for(
size_t j=0UL; j<N; ++j )
2857 for(
size_t i=M; i<MM; ++i ) {
2858 v_[i+j*MM] = Type();
2888 template<
typename Type
2895 BLAZE_INTERNAL_ASSERT( !( reinterpret_cast<size_t>( v_ ) % IT::alignment ),
"Invalid alignment detected" );
2906 else if( N == 2UL ) {
2921 if( IsBuiltin<Type>::value ) {
2922 for(
size_t j=0UL; j<N; ++j )
2923 for(
size_t i=M; i<MM; ++i ) {
2924 v_[i+j*MM] = Type();
2953 template<
typename Type
2957 const Type& v4,
const Type& v5 )
2960 BLAZE_INTERNAL_ASSERT( !( reinterpret_cast<size_t>( v_ ) % IT::alignment ),
"Invalid alignment detected" );
2980 if( IsBuiltin<Type>::value ) {
2981 for(
size_t j=0UL; j<N; ++j )
2982 for(
size_t i=M; i<MM; ++i ) {
2983 v_[i+j*MM] = Type();
3016 template<
typename Type
3020 const Type& v4,
const Type& v5,
const Type& v6 )
3023 BLAZE_INTERNAL_ASSERT( !( reinterpret_cast<size_t>( v_ ) % IT::alignment ),
"Invalid alignment detected" );
3036 else if( N == 2UL ) {
3046 else if( N == 3UL ) {
3052 v_[2UL*MM+1UL] = v6;
3065 if( IsBuiltin<Type>::value ) {
3066 for(
size_t j=0UL; j<N; ++j )
3067 for(
size_t i=M; i<MM; ++i ) {
3068 v_[i+j*MM] = Type();
3099 template<
typename Type
3103 const Type& v4,
const Type& v5,
const Type& v6,
3107 BLAZE_INTERNAL_ASSERT( !( reinterpret_cast<size_t>( v_ ) % IT::alignment ),
"Invalid alignment detected" );
3131 if( IsBuiltin<Type>::value ) {
3132 for(
size_t j=0UL; j<N; ++j )
3133 for(
size_t i=M; i<MM; ++i ) {
3134 v_[i+j*MM] = Type();
3169 template<
typename Type
3173 const Type& v4,
const Type& v5,
const Type& v6,
3174 const Type& v7,
const Type& v8 )
3177 BLAZE_INTERNAL_ASSERT( !( reinterpret_cast<size_t>( v_ ) % IT::alignment ),
"Invalid alignment detected" );
3192 else if( N == 2UL ) {
3204 else if( N == 4UL ) {
3210 v_[2UL*MM+1UL] = v6;
3212 v_[3UL*MM+1UL] = v8;
3227 if( IsBuiltin<Type>::value ) {
3228 for(
size_t j=0UL; j<N; ++j )
3229 for(
size_t i=M; i<MM; ++i ) {
3230 v_[i+j*MM] = Type();
3266 template<
typename Type
3270 const Type& v4,
const Type& v5,
const Type& v6,
3271 const Type& v7,
const Type& v8,
const Type& v9 )
3274 BLAZE_INTERNAL_ASSERT( !( reinterpret_cast<size_t>( v_ ) % IT::alignment ),
"Invalid alignment detected" );
3290 else if( N == 3UL ) {
3298 v_[2UL*MM+1UL] = v8;
3299 v_[2UL*MM+2UL] = v9;
3315 if( IsBuiltin<Type>::value ) {
3316 for(
size_t j=0UL; j<N; ++j )
3317 for(
size_t i=M; i<MM; ++i ) {
3318 v_[i+j*MM] = Type();
3355 template<
typename Type
3359 const Type& v4,
const Type& v5,
const Type& v6,
3360 const Type& v7,
const Type& v8,
const Type& v9,
3364 BLAZE_INTERNAL_ASSERT( !( reinterpret_cast<size_t>( v_ ) % IT::alignment ),
"Invalid alignment detected" );
3381 else if( N == 2UL ) {
3395 else if( N == 5UL ) {
3401 v_[2UL*MM+1UL] = v6;
3403 v_[3UL*MM+1UL] = v8;
3405 v_[4UL*MM+1UL] = v10;
3422 if( IsBuiltin<Type>::value ) {
3423 for(
size_t j=0UL; j<N; ++j )
3424 for(
size_t i=M; i<MM; ++i ) {
3425 v_[i+j*MM] = Type();
3449 template<
typename Type
3452 inline typename StaticMatrix<Type,M,N,true>::Reference
3471 template<
typename Type
3474 inline typename StaticMatrix<Type,M,N,true>::ConstReference
3491 template<
typename Type
3508 template<
typename Type
3526 template<
typename Type
3529 inline typename StaticMatrix<Type,M,N,true>::Iterator
3546 template<
typename Type
3549 inline typename StaticMatrix<Type,M,N,true>::ConstIterator
3566 template<
typename Type
3569 inline typename StaticMatrix<Type,M,N,true>::ConstIterator
3586 template<
typename Type
3589 inline typename StaticMatrix<Type,M,N,true>::Iterator
3593 return v_ + j*MM + M;
3606 template<
typename Type
3609 inline typename StaticMatrix<Type,M,N,true>::ConstIterator
3613 return v_ + j*MM + M;
3626 template<
typename Type
3629 inline typename StaticMatrix<Type,M,N,true>::ConstIterator
3633 return v_ + j*MM + M;
3654 template<
typename Type
3657 inline StaticMatrix<Type,M,N,true>&
3660 for(
size_t j=0UL; j<N; ++j )
3661 for(
size_t i=0UL; i<M; ++i )
3679 template<
typename Type
3682 inline StaticMatrix<Type,M,N,true>&
3685 for(
size_t j=0UL; j<N; ++j )
3686 for(
size_t i=0UL; i<M; ++i )
3687 v_[i+j*MM] = rhs(i,j);
3702 template<
typename Type
3705 template<
typename Other
3707 inline StaticMatrix<Type,M,N,true>&
3710 for(
size_t j=0UL; j<N; ++j )
3711 for(
size_t i=0UL; i<M; ++i )
3712 v_[i+j*MM] = rhs(i,j);
3732 template<
typename Type
3735 template<
typename MT
3742 throw std::invalid_argument(
"Invalid assignment to static matrix" );
3744 if( CanAlias<MT>::value && (~rhs).isAliased(
this ) ) {
3745 StaticMatrix tmp( ~rhs );
3749 if( IsSparseMatrix<MT>::value )
3771 template<
typename Type
3774 template<
typename MT
3781 throw std::invalid_argument(
"Matrix sizes do not match" );
3783 if( CanAlias<MT>::value && (~rhs).isAliased(
this ) ) {
3784 StaticMatrix tmp( ~rhs );
3808 template<
typename Type
3811 template<
typename MT
3818 throw std::invalid_argument(
"Matrix sizes do not match" );
3820 if( CanAlias<MT>::value && (~rhs).isAliased(
this ) ) {
3821 StaticMatrix tmp( ~rhs );
3845 template<
typename Type
3848 template<
typename MT
3852 if( M != N || (~rhs).
rows() != M || (~rhs).
columns() != M )
3853 throw std::invalid_argument(
"Matrix sizes do not match" );
3855 StaticMatrix tmp( *
this * (~rhs) );
3856 return this->operator=( tmp );
3870 template<
typename Type
3873 template<
typename Other >
3874 inline typename EnableIf< IsNumeric<Other>, StaticMatrix<Type,M,N,true> >::Type&
3877 return operator=( (*
this) * rhs );
3893 template<
typename Type
3896 template<
typename Other >
3897 inline typename EnableIf< IsNumeric<Other>, StaticMatrix<Type,M,N,true> >::Type&
3902 return operator=( (*
this) / rhs );
3922 template<
typename Type
3939 template<
typename Type
3959 template<
typename Type
3976 template<
typename Type
3981 size_t nonzeros( 0UL );
3983 for(
size_t j=0UL; j<N; ++j )
3984 for(
size_t i=0UL; i<M; ++i )
4001 template<
typename Type
4008 const size_t iend( (j+1UL)*MM );
4009 size_t nonzeros( 0UL );
4011 for(
size_t i=j*MM; i<iend; ++i )
4027 template<
typename Type
4034 for(
size_t j=0UL; j<N; ++j )
4035 for(
size_t i=0UL; i<M; ++i )
4036 reset( v_[i+j*MM] );
4048 template<
typename Type
4055 for(
size_t j=1UL; j<N; ++j )
4056 for(
size_t i=0UL; i<j; ++i )
4057 swap( v_[i+j*MM], v_[j+i*MM] );
4083 template<
typename Type
4088 if( M != N )
return false;
4090 for(
size_t j=1UL; j<N; ++j ) {
4091 for(
size_t i=0UL; i<j; ++i ) {
4109 template<
typename Type
4114 if( M != N )
return false;
4116 for(
size_t j=1; j<N; ++j ) {
4117 for(
size_t i=0; i<j; ++i ) {
4118 if( !
equal( v_[i+j*MM], v_[j+i*MM] ) )
4136 template<
typename Type
4139 template<
typename Other >
4140 inline StaticMatrix<Type,M,N,true>&
4143 for(
size_t j=0UL; j<N; ++j )
4144 for(
size_t i=0UL; i<M; ++i )
4145 v_[i+j*MM] *= scalar;
4161 template<
typename Type
4168 for(
size_t j=0UL; j<N; ++j ) {
4169 for(
size_t i=0UL; i<M; ++i ) {
4170 swap( v_[i+j*MM], m(i,j) );
4193 template<
typename Type
4196 template<
typename Other >
4199 return static_cast<const void*
>( this ) == static_cast<const void*>( alias );
4218 template<
typename Type
4221 inline typename StaticMatrix<Type,M,N,true>::IntrinsicType
4231 return load( &v_[i+j*MM] );
4249 template<
typename Type
4252 template<
typename MT
4254 inline typename DisableIf< typename StaticMatrix<Type,M,N,true>::BLAZE_TEMPLATE VectorizedAssign<MT> >::Type
4259 for(
size_t j=0UL; j<N; ++j ) {
4260 for(
size_t i=0UL; i<M; ++i ) {
4261 v_[i+j*MM] = (~rhs)(i,j);
4281 template<
typename Type
4284 template<
typename MT
4286 inline typename EnableIf< typename StaticMatrix<Type,M,N,true>::BLAZE_TEMPLATE VectorizedAssign<MT> >::Type
4293 for(
size_t j=0UL; j<N; ++j ) {
4294 for(
size_t i=0UL; i<M; i+=IT::size ) {
4295 store( &v_[i+j*MM], (~rhs).
get(i,j) );
4315 template<
typename Type
4318 template<
typename MT >
4323 typedef typename MT::ConstIterator ConstIterator;
4325 for(
size_t j=0UL; j<N; ++j )
4326 for( ConstIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
4327 v_[element->index()+j*MM] = element->value();
4345 template<
typename Type
4348 template<
typename MT >
4353 typedef typename MT::ConstIterator ConstIterator;
4355 for(
size_t i=0UL; i<M; ++i )
4356 for( ConstIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
4357 v_[i+element->index()*MM] = element->value();
4375 template<
typename Type
4378 template<
typename MT
4380 inline typename DisableIf< typename StaticMatrix<Type,M,N,true>::BLAZE_TEMPLATE VectorizedAddAssign<MT> >::Type
4385 for(
size_t j=0UL; j<N; ++j ) {
4386 for(
size_t i=0UL; i<M; ++i ) {
4387 v_[i+j*MM] += (~rhs)(i,j);
4407 template<
typename Type
4410 template<
typename MT
4412 inline typename EnableIf< typename StaticMatrix<Type,M,N,true>::BLAZE_TEMPLATE VectorizedAddAssign<MT> >::Type
4419 for(
size_t j=0UL; j<N; ++j ) {
4420 for(
size_t i=0UL; i<M; i+=IT::size ) {
4421 store( &v_[i+j*MM],
load( &v_[i+j*MM] ) + (~rhs).
get(i,j) );
4441 template<
typename Type
4444 template<
typename MT >
4449 typedef typename MT::ConstIterator ConstIterator;
4451 for(
size_t j=0UL; j<N; ++j )
4452 for( ConstIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
4453 v_[element->index()+j*MM] += element->value();
4471 template<
typename Type
4474 template<
typename MT >
4479 typedef typename MT::ConstIterator ConstIterator;
4481 for(
size_t i=0UL; i<M; ++i )
4482 for( ConstIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
4483 v_[i+element->index()*MM] += element->value();
4501 template<
typename Type
4504 template<
typename MT
4506 inline typename DisableIf< typename StaticMatrix<Type,M,N,true>::BLAZE_TEMPLATE VectorizedSubAssign<MT> >::Type
4511 for(
size_t j=0UL; j<N; ++j ) {
4512 for(
size_t i=0UL; i<M; ++i ) {
4513 v_[i+j*MM] -= (~rhs)(i,j);
4533 template<
typename Type
4536 template<
typename MT
4538 inline typename EnableIf< typename StaticMatrix<Type,M,N,true>::BLAZE_TEMPLATE VectorizedSubAssign<MT> >::Type
4545 for(
size_t j=0UL; j<N; ++j ) {
4546 for(
size_t i=0UL; i<M; i+=IT::size ) {
4547 store( &v_[i+j*MM],
load( &v_[i+j*MM] ) - (~rhs).
get(i,j) );
4567 template<
typename Type
4570 template<
typename MT >
4575 typedef typename MT::ConstIterator ConstIterator;
4577 for(
size_t j=0UL; j<N; ++j )
4578 for( ConstIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
4579 v_[element->index()+j*MM] -= element->value();
4597 template<
typename Type
4600 template<
typename MT >
4605 typedef typename MT::ConstIterator ConstIterator;
4607 for(
size_t i=0UL; i<M; ++i )
4608 for( ConstIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
4609 v_[i+element->index()*MM] -= element->value();
4635 template<
typename Type
4638 class StaticMatrix<Type,M,0UL,SO>;
4651 template<
typename Type
4654 class StaticMatrix<Type,0UL,N,SO>;
4667 template<
typename Type
4669 class StaticMatrix<Type,0UL,0UL,SO>;
4689 template<
typename Type,
size_t M,
size_t N,
bool SO >
4690 inline bool isnan(
const StaticMatrix<Type,M,N,SO>& m );
4692 template<
typename Type,
size_t M,
size_t N,
bool SO >
4693 inline void reset( StaticMatrix<Type,M,N,SO>& m );
4695 template<
typename Type,
size_t M,
size_t N,
bool SO >
4696 inline void clear( StaticMatrix<Type,M,N,SO>& m );
4698 template<
typename Type,
size_t M,
size_t N,
bool SO >
4699 inline bool isDefault(
const StaticMatrix<Type,M,N,SO>& m );
4701 template<
typename Type,
size_t M,
size_t N,
bool SO >
4702 inline void swap( StaticMatrix<Type,M,N,SO>& a, StaticMatrix<Type,M,N,SO>& b ) ;
4714 template<
typename Type
4720 for(
size_t i=0UL; i<M*N; ++i ) {
4737 template<
typename Type
4757 template<
typename Type
4775 template<
typename Type
4781 for(
size_t i=0UL; i<M*N; ++i ) {
4800 template<
typename Type
4821 template<
typename T1,
size_t M,
size_t N,
bool SO,
typename T2 >
4822 struct AddTrait< StaticMatrix<T1,M,N,SO>, StaticMatrix<T2,M,N,SO> >
4824 typedef StaticMatrix< typename AddTrait<T1,T2>::Type, M, N, SO > Type;
4827 template<
typename T1,
size_t M,
size_t N,
bool SO1,
typename T2,
bool SO2 >
4828 struct AddTrait< StaticMatrix<T1,M,N,SO1>, StaticMatrix<T2,M,N,SO2> >
4830 typedef StaticMatrix< typename AddTrait<T1,T2>::Type, M, N,
false > Type;
4846 template<
typename T1,
size_t M,
size_t N,
bool SO,
typename T2 >
4847 struct SubTrait< StaticMatrix<T1,M,N,SO>, StaticMatrix<T2,M,N,SO> >
4849 typedef StaticMatrix< typename SubTrait<T1,T2>::Type, M, N, SO > Type;
4852 template<
typename T1,
size_t M,
size_t N,
bool SO1,
typename T2,
bool SO2 >
4853 struct SubTrait< StaticMatrix<T1,M,N,SO1>, StaticMatrix<T2,M,N,SO2> >
4855 typedef StaticMatrix< typename SubTrait<T1,T2>::Type, M, N,
false > Type;
4871 template<
typename T1,
size_t M,
size_t N,
bool SO,
typename T2 >
4872 struct MultTrait< StaticMatrix<T1,M,N,SO>, T2 >
4874 typedef StaticMatrix< typename MultTrait<T1,T2>::Type, M, N, SO > Type;
4878 template<
typename T1,
typename T2,
size_t M,
size_t N,
bool SO >
4879 struct MultTrait< T1, StaticMatrix<T2,M,N,SO> >
4881 typedef StaticMatrix< typename MultTrait<T1,T2>::Type, M, N, SO > Type;
4885 template<
typename T1,
size_t M,
size_t N,
bool SO,
typename T2 >
4886 struct MultTrait< StaticMatrix<T1,M,N,SO>, StaticVector<T2,N,false> >
4888 typedef StaticVector< typename MultTrait<T1,T2>::Type, M,
false > Type;
4891 template<
typename T1,
size_t M,
typename T2,
size_t N,
bool SO >
4892 struct MultTrait< StaticVector<T1,M,true>, StaticMatrix<T2,M,N,SO> >
4894 typedef StaticVector< typename MultTrait<T1,T2>::Type, N,
true > Type;
4897 template<
typename T1,
size_t M,
size_t N,
bool SO,
typename T2 >
4898 struct MultTrait< StaticMatrix<T1,M,N,SO>, DynamicVector<T2,false> >
4900 typedef StaticVector< typename MultTrait<T1,T2>::Type, M,
false > Type;
4903 template<
typename T1,
typename T2,
size_t M,
size_t N,
bool SO >
4904 struct MultTrait< DynamicVector<T1,true>, StaticMatrix<T2,M,N,SO> >
4906 typedef StaticVector< typename MultTrait<T1,T2>::Type, N,
true > Type;
4909 template<
typename T1,
size_t M,
size_t N,
bool SO,
typename T2 >
4910 struct MultTrait< StaticMatrix<T1,M,N,SO>, CompressedVector<T2,false> >
4912 typedef StaticVector< typename MultTrait<T1,T2>::Type, M,
false > Type;
4915 template<
typename T1,
typename T2,
size_t M,
size_t N,
bool SO >
4916 struct MultTrait< CompressedVector<T1,true>, StaticMatrix<T2,M,N,SO> >
4918 typedef StaticVector< typename MultTrait<T1,T2>::Type, N,
true > Type;
4921 template<
typename T1,
size_t M,
size_t K,
bool SO1,
typename T2,
size_t N,
bool SO2 >
4922 struct MultTrait< StaticMatrix<T1,M,K,SO1>, StaticMatrix<T2,K,N,SO2> >
4924 typedef StaticMatrix< typename MultTrait<T1,T2>::Type, M, N, SO1 > Type;
4940 template<
typename T1,
size_t M,
size_t N,
bool SO,
typename T2 >
4941 struct DivTrait< StaticMatrix<T1,M,N,SO>, T2 >
4943 typedef StaticMatrix< typename DivTrait<T1,T2>::Type, M, N, SO > Type;
4960 template<
typename T1,
size_t M,
size_t N,
bool SO,
typename T2 >
4961 struct MathTrait< StaticMatrix<T1,M,N,SO>, StaticMatrix<T2,M,N,SO> >
4963 typedef StaticMatrix< typename MathTrait<T1,T2>::HighType, M, N, SO > HighType;
4964 typedef StaticMatrix< typename MathTrait<T1,T2>::LowType , M, N, SO > LowType;