22 #ifndef _BLAZE_MATH_DENSE_DYNAMICMATRIX_H_
23 #define _BLAZE_MATH_DENSE_DYNAMICMATRIX_H_
159 template<
typename Type
196 enum { canAlias = 0 };
204 explicit inline DynamicMatrix(
size_t m,
size_t n, Type init );
208 template<
typename Other,
size_t M,
size_t N >
226 inline const Type*
data()
const;
239 template<
typename Other,
size_t M,
size_t N >
249 template<
typename Other >
250 inline typename EnableIf< IsNumeric<Other>,
DynamicMatrix >::Type&
253 template<
typename Other >
254 inline typename EnableIf< IsNumeric<Other>,
DynamicMatrix >::Type&
262 inline size_t rows()
const;
267 inline size_t nonZeros(
size_t i )
const;
270 void resize (
size_t m,
size_t n,
bool preserve=
true );
271 inline void extend (
size_t m,
size_t n,
bool preserve=
true );
272 inline void reserve(
size_t elements );
286 template<
typename MT >
287 struct VectorizedAssign {
288 enum { value = vectorizable && MT::vectorizable &&
289 IsSame<Type,typename MT::ElementType>::value };
297 template<
typename MT >
298 struct VectorizedAddAssign {
299 enum { value = vectorizable && MT::vectorizable &&
300 IsSame<Type,typename MT::ElementType>::value &&
301 IntrinsicTrait<Type>::addition };
309 template<
typename MT >
310 struct VectorizedSubAssign {
311 enum { value = vectorizable && MT::vectorizable &&
312 IsSame<Type,typename MT::ElementType>::value &&
313 IntrinsicTrait<Type>::subtraction };
322 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
325 template<
typename MT >
326 inline typename DisableIf< VectorizedAssign<MT> >::Type
327 assign(
const DenseMatrix<MT,SO>& rhs );
329 template<
typename MT >
330 inline typename EnableIf< VectorizedAssign<MT> >::Type
331 assign(
const DenseMatrix<MT,SO>& rhs );
333 template<
typename MT >
inline void assign(
const DenseMatrix<MT,!SO>& rhs );
337 template<
typename MT >
338 inline typename DisableIf< VectorizedAddAssign<MT> >::Type
339 addAssign(
const DenseMatrix<MT,SO>& rhs );
341 template<
typename MT >
342 inline typename EnableIf< VectorizedAddAssign<MT> >::Type
343 addAssign(
const DenseMatrix<MT,SO>& rhs );
345 template<
typename MT >
inline void addAssign(
const DenseMatrix<MT,!SO>& rhs );
349 template<
typename MT >
350 inline typename DisableIf< VectorizedSubAssign<MT> >::Type
351 subAssign(
const DenseMatrix<MT,SO>& rhs );
353 template<
typename MT >
354 inline typename EnableIf< VectorizedSubAssign<MT> >::Type
355 subAssign(
const DenseMatrix<MT,SO>& rhs );
357 template<
typename MT >
inline void subAssign(
const DenseMatrix<MT,!SO>& rhs );
378 Type* BLAZE_RESTRICT
v_;
414 template<
typename Type
435 template<
typename Type
440 , nn_ ( adjustColumns( n ) )
441 , capacity_( m_*nn_ )
442 , v_ (
allocate<Type>( capacity_ ) )
445 for(
size_t i=0UL; i<
m_; ++i ) {
446 for(
size_t j=
n_; j<
nn_; ++j )
447 v_[i*nn_+j] = Type();
463 template<
typename Type
468 , nn_ ( adjustColumns( n ) )
469 , capacity_( m_*nn_ )
470 , v_ (
allocate<Type>( capacity_ ) )
472 for(
size_t i=0UL; i<m; ++i ) {
473 for(
size_t j=0UL; j<
n_; ++j )
477 for(
size_t j=n_; j<
nn_; ++j )
478 v_[i*nn_+j] = Type();
493 template<
typename Type
499 , capacity_( m_*nn_ )
500 , v_ (
allocate<Type>( capacity_ ) )
515 template<
typename Type
517 template<
typename MT
522 , nn_ ( adjustColumns( n_ ) )
523 , capacity_( m_*nn_ )
524 , v_ (
allocate<Type>( capacity_ ) )
529 for(
size_t i=0UL; i<
m_; ++i ) {
531 v_[i*nn_+j] = Type();
558 template<
typename Type
560 template<
typename Other
566 , nn_ ( adjustColumns( N ) )
567 , capacity_( m_*nn_ )
568 , v_ (
allocate<Type>( capacity_ ) )
570 for(
size_t i=0UL; i<M; ++i ) {
571 for(
size_t j=0UL; j<N; ++j )
572 v_[i*
nn_+j] = rhs[i][j];
575 for(
size_t j=N; j<
nn_; ++j )
576 v_[i*nn_+j] = Type();
594 template<
typename Type
618 template<
typename Type
637 template<
typename Type
654 template<
typename Type
668 template<
typename Type
688 template<
typename Type
710 template<
typename Type
732 template<
typename Type
754 template<
typename Type
760 return v_ + i*nn_ + n_;
776 template<
typename Type
782 return v_ + i*nn_ + n_;
798 template<
typename Type
804 return v_ + i*nn_ + n_;
836 template<
typename Type
838 template<
typename Other
843 resize( M, N,
false );
845 for(
size_t i=0UL; i<M; ++i )
846 for(
size_t j=0UL; j<N; ++j )
847 v_[i*nn_+j] = rhs[i][j];
860 template<
typename Type
864 for(
size_t i=0UL; i<m_; ++i )
865 for(
size_t j=0UL; j<n_; ++j )
882 template<
typename Type
886 if( &rhs ==
this )
return *
this;
888 resize( rhs.
m_, rhs.
n_,
false );
890 for(
size_t i=0UL; i<m_; ++i )
891 for(
size_t j=0UL; j<n_; ++j )
892 v_[i*nn_+j] = rhs(i,j);
908 template<
typename Type
910 template<
typename MT
942 template<
typename Type
944 template<
typename MT
950 if( (~rhs).
rows() != m_ || (~rhs).
columns() != n_ )
951 throw std::invalid_argument(
"Matrix sizes do not match" );
954 typename MT::ResultType tmp( ~rhs );
976 template<
typename Type
978 template<
typename MT
984 if( (~rhs).
rows() != m_ || (~rhs).
columns() != n_ )
985 throw std::invalid_argument(
"Matrix sizes do not match" );
988 typename MT::ResultType tmp( ~rhs );
1010 template<
typename Type
1012 template<
typename MT
1016 if( (~rhs).
rows() != n_ )
1017 throw std::invalid_argument(
"Matrix sizes do not match" );
1034 template<
typename Type
1036 template<
typename Other >
1040 return operator=( (*
this) * rhs );
1052 template<
typename Type
1054 template<
typename Other >
1060 return operator=( (*
this) / rhs );
1078 template<
typename Type
1092 template<
typename Type
1109 template<
typename Type
1123 template<
typename Type
1137 template<
typename Type
1141 size_t nonzeros( 0UL );
1143 for(
size_t i=0UL; i<m_; ++i )
1144 for(
size_t j=0UL; j<n_; ++j )
1159 template<
typename Type
1165 const size_t jend( (i+1UL)*nn_ );
1166 size_t nonzeros( 0UL );
1168 for(
size_t j=i*nn_; j<jend; ++j )
1182 template<
typename Type
1187 for(
size_t i=0UL; i<m_; ++i )
1188 for(
size_t j=0UL; j<n_; ++j )
1189 reset( v_[i*nn_+j] );
1201 template<
typename Type
1244 template<
typename Type
1250 if( m == m_ && n == n_ )
return;
1252 const size_t nn( adjustColumns( n ) );
1256 Type* BLAZE_RESTRICT v = allocate<Type>( m*nn );
1257 const size_t min_m(
min( m, m_ ) );
1258 const size_t min_n(
min( n, n_ ) );
1260 for(
size_t i=0UL; i<min_m; ++i )
1261 for(
size_t j=0UL; j<min_n; ++j )
1262 v[i*nn+j] = v_[i*nn_+j];
1265 for(
size_t i=0UL; i<m; ++i )
1266 for(
size_t j=n; j<nn; ++j )
1274 else if( m*nn > capacity_ ) {
1275 Type* BLAZE_RESTRICT v = allocate<Type>( m*nn );
1278 for(
size_t i=0UL; i<m; ++i )
1279 for(
size_t j=n; j<nn; ++j )
1309 template<
typename Type
1313 resize( m_+m, n_+n, preserve );
1327 template<
typename Type
1331 if( elements > capacity_ )
1334 Type* BLAZE_RESTRICT tmp = allocate<Type>( elements );
1337 std::copy( v_, v_+capacity_, tmp );
1340 for(
size_t i=capacity_; i<elements; ++i )
1347 capacity_ = elements;
1358 template<
typename Type
1377 template<
typename Type
1405 template<
typename Type
1409 if( m_ != n_ )
return false;
1411 for(
size_t i=1UL; i<m_; ++i ) {
1412 for(
size_t j=0UL; j<i; ++j ) {
1428 template<
typename Type
1432 if( m_ != n_ )
return false;
1434 for(
size_t i=1UL; i<m_; ++i ) {
1435 for(
size_t j=0UL; j<i; ++j ) {
1436 if( !
equal( v_[i*nn_+j], v_[j*nn_+i] ) )
1452 template<
typename Type
1454 template<
typename Other >
1457 for(
size_t i=0UL; i<m_; ++i )
1458 for(
size_t j=0UL; j<n_; ++j )
1459 v_[i*nn_+j] *= scalar;
1473 template<
typename Type
1492 template<
typename Type
1497 return minColumns + ( IT::size - ( minColumns % IT::size ) ) % IT::size;
1498 else return minColumns;
1517 template<
typename Type
1519 template<
typename Other >
1522 return static_cast<const void*
>( this ) == static_cast<const void*>( alias );
1539 template<
typename Type
1551 return load( &v_[i*nn_+j] );
1567 template<
typename Type
1569 template<
typename MT >
1577 const size_t jend( n_ &
size_t(-2) );
1579 for(
size_t i=0UL; i<m_; ++i ) {
1580 for(
size_t j=0UL; j<jend; j+=2UL ) {
1581 v_[i*nn_+j ] = (~rhs)(i,j );
1582 v_[i*nn_+j+1UL] = (~rhs)(i,j+1UL);
1585 v_[i*nn_+jend] = (~rhs)(i,jend);
1603 template<
typename Type
1605 template<
typename MT >
1614 if( m_*n_ > (
cacheSize / (
sizeof(Type) * 3UL ) ) && !(~rhs).isAliased(
this ) )
1616 for(
size_t i=0UL; i<m_; ++i )
1617 for(
size_t j=0UL; j<n_; j+=IT::size )
1618 stream( &v_[i*nn_+j], (~rhs).
get(i,j) );
1622 BLAZE_INTERNAL_ASSERT( ( n_ - ( n_ % (IT::size*4UL) ) ) == ( n_ &
size_t(-IT::size*4) ),
"Invalid end calculation" );
1623 const size_t jend( n_ &
size_t(-IT::size*4) );
1625 for(
size_t i=0UL; i<m_; ++i ) {
1626 for(
size_t j=0UL; j<jend; j+=IT::size*4UL ) {
1627 store( &v_[i*nn_+j ], (~rhs).
get(i,j ) );
1628 store( &v_[i*nn_+j+IT::size ], (~rhs).
get(i,j+IT::size ) );
1629 store( &v_[i*nn_+j+IT::size*2UL], (~rhs).
get(i,j+IT::size*2UL) );
1630 store( &v_[i*nn_+j+IT::size*3UL], (~rhs).
get(i,j+IT::size*3UL) );
1632 for(
size_t j=jend; j<n_; j+=IT::size ) {
1633 store( &v_[i*nn_+j], (~rhs).
get(i,j) );
1652 template<
typename Type
1654 template<
typename MT >
1660 const size_t block( 16UL );
1662 for(
size_t ii=0UL; ii<m_; ii+=block ) {
1663 const size_t iend( ( m_<(ii+block) )?( m_ ):( ii+block ) );
1664 for(
size_t jj=0UL; jj<n_; jj+=block ) {
1665 const size_t jend( ( n_<(jj+block) )?( n_ ):( jj+block ) );
1666 for(
size_t i=ii; i<iend; ++i ) {
1667 for(
size_t j=jj; j<jend; ++j ) {
1668 v_[i*nn_+j] = (~rhs)(i,j);
1688 template<
typename Type
1690 template<
typename MT >
1696 for(
size_t i=0UL; i<m_; ++i )
1697 for(
typename MT::ConstIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
1698 v_[i*nn_+element->index()] = element->value();
1714 template<
typename Type
1716 template<
typename MT >
1722 for(
size_t j=0UL; j<n_; ++j )
1723 for(
typename MT::ConstIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
1724 v_[element->index()*nn_+j] = element->value();
1740 template<
typename Type
1742 template<
typename MT >
1750 const size_t jend( n_ &
size_t(-2) );
1752 for(
size_t i=0UL; i<m_; ++i ) {
1753 for(
size_t j=0UL; j<jend; j+=2UL ) {
1754 v_[i*nn_+j ] += (~rhs)(i,j );
1755 v_[i*nn_+j+1UL] += (~rhs)(i,j+1UL);
1758 v_[i*nn_+jend] += (~rhs)(i,jend);
1776 template<
typename Type
1778 template<
typename MT >
1787 BLAZE_INTERNAL_ASSERT( ( n_ - ( n_ % (IT::size*4UL) ) ) == ( n_ &
size_t(-IT::size*4) ),
"Invalid end calculation" );
1788 const size_t jend( n_ &
size_t(-IT::size*4) );
1790 for(
size_t i=0UL; i<m_; ++i ) {
1791 for(
size_t j=0UL; j<jend; j+=IT::size*4UL ) {
1792 store( &v_[i*nn_+j ],
load( &v_[i*nn_+j ] ) + (~rhs).
get(i,j ) );
1793 store( &v_[i*nn_+j+IT::size ],
load( &v_[i*nn_+j+IT::size ] ) + (~rhs).
get(i,j+IT::size ) );
1794 store( &v_[i*nn_+j+IT::size*2UL],
load( &v_[i*nn_+j+IT::size*2UL] ) + (~rhs).
get(i,j+IT::size*2UL) );
1795 store( &v_[i*nn_+j+IT::size*3UL],
load( &v_[i*nn_+j+IT::size*3UL] ) + (~rhs).
get(i,j+IT::size*3UL) );
1797 for(
size_t j=jend; j<n_; j+=IT::size ) {
1798 store( &v_[i*nn_+j],
load( &v_[i*nn_+j] ) + (~rhs).
get(i,j) );
1816 template<
typename Type
1818 template<
typename MT >
1824 const size_t block( 16UL );
1826 for(
size_t ii=0UL; ii<m_; ii+=block ) {
1827 const size_t iend( ( m_<(ii+block) )?( m_ ):( ii+block ) );
1828 for(
size_t jj=0UL; jj<n_; jj+=block ) {
1829 const size_t jend( ( n_<(jj+block) )?( n_ ):( jj+block ) );
1830 for(
size_t i=ii; i<iend; ++i ) {
1831 for(
size_t j=jj; j<jend; ++j ) {
1832 v_[i*nn_+j] += (~rhs)(i,j);
1852 template<
typename Type
1854 template<
typename MT >
1860 for(
size_t i=0UL; i<m_; ++i )
1861 for(
typename MT::ConstIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
1862 v_[i*nn_+element->index()] += element->value();
1878 template<
typename Type
1880 template<
typename MT >
1886 for(
size_t j=0UL; j<n_; ++j )
1887 for(
typename MT::ConstIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
1888 v_[element->index()*nn_+j] += element->value();
1904 template<
typename Type
1906 template<
typename MT >
1914 const size_t jend( n_ &
size_t(-2) );
1916 for(
size_t i=0UL; i<m_; ++i ) {
1917 for(
size_t j=0UL; j<jend; j+=2UL ) {
1918 v_[i*nn_+j ] -= (~rhs)(i,j );
1919 v_[i*nn_+j+1UL] -= (~rhs)(i,j+1UL);
1922 v_[i*nn_+jend] -= (~rhs)(i,jend);
1940 template<
typename Type
1942 template<
typename MT >
1951 BLAZE_INTERNAL_ASSERT( ( n_ - ( n_ % (IT::size*4UL) ) ) == ( n_ &
size_t(-IT::size*4) ),
"Invalid end calculation" );
1952 const size_t jend( n_ &
size_t(-IT::size*4) );
1954 for(
size_t i=0UL; i<m_; ++i ) {
1955 for(
size_t j=0UL; j<jend; j+=IT::size*4UL ) {
1956 store( &v_[i*nn_+j ],
load( &v_[i*nn_+j ] ) - (~rhs).
get(i,j ) );
1957 store( &v_[i*nn_+j+IT::size ],
load( &v_[i*nn_+j+IT::size ] ) - (~rhs).
get(i,j+IT::size ) );
1958 store( &v_[i*nn_+j+IT::size*2UL],
load( &v_[i*nn_+j+IT::size*2UL] ) - (~rhs).
get(i,j+IT::size*2UL) );
1959 store( &v_[i*nn_+j+IT::size*3UL],
load( &v_[i*nn_+j+IT::size*3UL] ) - (~rhs).
get(i,j+IT::size*3UL) );
1961 for(
size_t j=jend; j<n_; j+=IT::size ) {
1962 store( &v_[i*nn_+j],
load( &v_[i*nn_+j] ) - (~rhs).
get(i,j) );
1980 template<
typename Type
1982 template<
typename MT >
1988 const size_t block( 16UL );
1990 for(
size_t ii=0UL; ii<m_; ii+=block ) {
1991 const size_t iend( ( m_<(ii+block) )?( m_ ):( ii+block ) );
1992 for(
size_t jj=0UL; jj<n_; jj+=block ) {
1993 const size_t jend( ( n_<(jj+block) )?( n_ ):( jj+block ) );
1994 for(
size_t i=ii; i<iend; ++i ) {
1995 for(
size_t j=jj; j<jend; ++j ) {
1996 v_[i*nn_+j] -= (~rhs)(i,j);
2016 template<
typename Type
2018 template<
typename MT >
2024 for(
size_t i=0UL; i<m_; ++i )
2025 for(
typename MT::ConstIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
2026 v_[i*nn_+element->index()] -= element->value();
2042 template<
typename Type
2044 template<
typename MT >
2050 for(
size_t j=0UL; j<n_; ++j )
2051 for(
typename MT::ConstIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
2052 v_[element->index()*nn_+j] -= element->value();
2077 template<
typename Type >
2113 enum { canAlias = 0 };
2121 explicit inline DynamicMatrix(
size_t m,
size_t n, Type init );
2125 template<
typename Other,
size_t M,
size_t N >
2142 inline Type*
data();
2143 inline const Type*
data()
const;
2156 template<
typename Other,
size_t M,
size_t N >
2166 template<
typename Other >
2167 inline typename EnableIf< IsNumeric<Other>,
DynamicMatrix >::Type&
2170 template<
typename Other >
2171 inline typename EnableIf< IsNumeric<Other>,
DynamicMatrix >::Type&
2179 inline size_t rows()
const;
2180 inline size_t columns()
const;
2181 inline size_t spacing()
const;
2184 inline size_t nonZeros(
size_t j )
const;
2185 inline void reset();
2186 inline void clear();
2187 void resize (
size_t m,
size_t n,
bool preserve=
true );
2188 inline void extend (
size_t m,
size_t n,
bool preserve=
true );
2189 inline void reserve(
size_t elements );
2202 template<
typename MT >
2203 struct VectorizedAssign {
2204 enum { value = vectorizable && MT::vectorizable &&
2205 IsSame<Type,typename MT::ElementType>::value };
2211 template<
typename MT >
2212 struct VectorizedAddAssign {
2213 enum { value = vectorizable && MT::vectorizable &&
2214 IsSame<Type,typename MT::ElementType>::value &&
2215 IntrinsicTrait<Type>::addition };
2221 template<
typename MT >
2222 struct VectorizedSubAssign {
2223 enum { value = vectorizable && MT::vectorizable &&
2224 IsSame<Type,typename MT::ElementType>::value &&
2225 IntrinsicTrait<Type>::subtraction };
2233 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
2236 template<
typename MT >
2237 inline typename DisableIf< VectorizedAssign<MT> >::Type
2238 assign(
const DenseMatrix<MT,true>& rhs );
2240 template<
typename MT >
2241 inline typename EnableIf< VectorizedAssign<MT> >::Type
2242 assign(
const DenseMatrix<MT,true>& rhs );
2244 template<
typename MT >
inline void assign(
const DenseMatrix<MT,false>& rhs );
2248 template<
typename MT >
2249 inline typename DisableIf< VectorizedAddAssign<MT> >::Type
2250 addAssign(
const DenseMatrix<MT,true>& rhs );
2252 template<
typename MT >
2253 inline typename EnableIf< VectorizedAddAssign<MT> >::Type
2254 addAssign(
const DenseMatrix<MT,true>& rhs );
2256 template<
typename MT >
inline void addAssign(
const DenseMatrix<MT,false>& rhs );
2260 template<
typename MT >
2261 inline typename DisableIf< VectorizedSubAssign<MT> >::Type
2262 subAssign (
const DenseMatrix<MT,true>& rhs );
2264 template<
typename MT >
2265 inline typename EnableIf< VectorizedSubAssign<MT> >::Type
2266 subAssign (
const DenseMatrix<MT,true>& rhs );
2268 template<
typename MT >
inline void subAssign(
const DenseMatrix<MT,false>& rhs );
2278 inline size_t adjustRows(
size_t minRows )
const;
2289 Type* BLAZE_RESTRICT
v_;
2325 template<
typename Type >
2347 template<
typename Type >
2350 , mm_ ( adjustRows( m ) )
2352 , capacity_( mm_*n_ )
2353 , v_ (
allocate<Type>( capacity_ ) )
2355 if( IsBuiltin<Type>::value ) {
2356 for(
size_t j=0UL; j<
n_; ++j )
2357 for(
size_t i=m_; i<mm_; ++i ) {
2358 v_[i+j*mm_] = Type();
2376 template<
typename Type >
2379 , mm_ ( adjustRows( m ) )
2381 , capacity_( mm_*n_ )
2382 , v_ (
allocate<Type>( capacity_ ) )
2384 for(
size_t j=0UL; j<
n_; ++j ) {
2385 for(
size_t i=0UL; i<
m_; ++i )
2388 if( IsBuiltin<Type>::value ) {
2389 for(
size_t i=m_; i<mm_; ++i )
2390 v_[i+j*mm_] = Type();
2407 template<
typename Type >
2412 , capacity_( mm_*n_ )
2413 , v_ (
allocate<Type>( capacity_ ) )
2430 template<
typename Type >
2431 template<
typename MT
2434 : m_ ( (~m).
rows() )
2435 , mm_ ( adjustRows( m_ ) )
2437 , capacity_( mm_*n_ )
2438 , v_ (
allocate<Type>( capacity_ ) )
2442 if( IsBuiltin<Type>::value ) {
2443 for(
size_t j=0UL; j<
n_; ++j )
2444 for(
size_t i=( IsSparseMatrix<MT>::value )?( 0UL ):( m_ ); i<mm_; ++i ) {
2445 v_[i+j*mm_] = Type();
2476 template<
typename Type >
2477 template<
typename Other
2482 , mm_ ( adjustRows( M ) )
2484 , capacity_( mm_*n_ )
2485 , v_ (
allocate<Type>( capacity_ ) )
2487 for(
size_t j=0UL; j<N; ++j ) {
2488 for(
size_t i=0UL; i<M; ++i )
2489 v_[i+j*mm_] = rhs[i][j];
2491 if( IsBuiltin<Type>::value ) {
2492 for(
size_t i=M; i<mm_; ++i )
2493 v_[i+j*mm_] = Type();
2513 template<
typename Type >
2538 template<
typename Type >
2539 inline typename DynamicMatrix<Type,true>::Reference
2558 template<
typename Type >
2559 inline typename DynamicMatrix<Type,true>::ConstReference
2576 template<
typename Type >
2591 template<
typename Type >
2607 template<
typename Type >
2608 inline typename DynamicMatrix<Type,true>::Iterator
2625 template<
typename Type >
2626 inline typename DynamicMatrix<Type,true>::ConstIterator
2643 template<
typename Type >
2644 inline typename DynamicMatrix<Type,true>::ConstIterator
2661 template<
typename Type >
2662 inline typename DynamicMatrix<Type,true>::Iterator
2666 return v_ + j*mm_ + m_;
2679 template<
typename Type >
2680 inline typename DynamicMatrix<Type,true>::ConstIterator
2684 return v_ + j*mm_ + m_;
2697 template<
typename Type >
2698 inline typename DynamicMatrix<Type,true>::ConstIterator
2702 return v_ + j*mm_ + m_;
2736 template<
typename Type >
2737 template<
typename Other
2742 resize( M, N,
false );
2744 for(
size_t j=0UL; j<N; ++j )
2745 for(
size_t i=0UL; i<M; ++i )
2746 v_[i+j*mm_] = rhs[i][j];
2761 template<
typename Type >
2764 for(
size_t j=0UL; j<n_; ++j )
2765 for(
size_t i=0UL; i<m_; ++i )
2784 template<
typename Type >
2787 if( &rhs ==
this )
return *
this;
2789 resize( rhs.m_, rhs.n_,
false );
2791 for(
size_t j=0UL; j<n_; ++j )
2792 for(
size_t i=0UL; i<m_; ++i )
2793 v_[i+j*mm_] = rhs(i,j);
2811 template<
typename Type >
2812 template<
typename MT
2818 if( CanAlias<MT>::value && (~rhs).isAliased(
this ) ) {
2819 DynamicMatrix tmp( ~rhs );
2824 if( IsSparseMatrix<MT>::value )
2846 template<
typename Type >
2847 template<
typename MT
2853 if( (~rhs).
rows() != m_ || (~rhs).
columns() != n_ )
2854 throw std::invalid_argument(
"Matrix sizes do not match" );
2856 if( CanAlias<MT>::value && (~rhs).isAliased(
this ) ) {
2857 typename MT::ResultType tmp( ~rhs );
2881 template<
typename Type >
2882 template<
typename MT
2888 if( (~rhs).
rows() != m_ || (~rhs).
columns() != n_ )
2889 throw std::invalid_argument(
"Matrix sizes do not match" );
2891 if( CanAlias<MT>::value && (~rhs).isAliased(
this ) ) {
2892 typename MT::ResultType tmp( ~rhs );
2916 template<
typename Type >
2917 template<
typename MT
2921 if( (~rhs).
rows() != n_ )
2922 throw std::invalid_argument(
"Matrix sizes do not match" );
2924 DynamicMatrix tmp( *
this * (~rhs) );
2941 template<
typename Type >
2942 template<
typename Other >
2943 inline typename EnableIf< IsNumeric<Other>, DynamicMatrix<Type,true> >::Type&
2946 return operator=( (*
this) * rhs );
2960 template<
typename Type >
2961 template<
typename Other >
2962 inline typename EnableIf< IsNumeric<Other>, DynamicMatrix<Type,true> >::Type&
2967 return operator=( (*
this) / rhs );
2987 template<
typename Type >
3002 template<
typename Type >
3020 template<
typename Type >
3035 template<
typename Type >
3050 template<
typename Type >
3053 size_t nonzeros( 0UL );
3055 for(
size_t j=0UL; j<n_; ++j )
3056 for(
size_t i=0UL; i<m_; ++i )
3073 template<
typename Type >
3078 const size_t iend( (j+1UL)*mm_ );
3079 size_t nonzeros( 0UL );
3081 for(
size_t i=j*mm_; i<iend; ++i )
3097 template<
typename Type >
3101 for(
size_t j=0UL; j<n_; ++j )
3102 for(
size_t i=0UL; i<m_; ++i )
3103 reset( v_[i+j*mm_] );
3117 template<
typename Type >
3161 template<
typename Type >
3166 if( m == m_ && n == n_ )
return;
3168 const size_t mm( adjustRows( m ) );
3172 Type* BLAZE_RESTRICT v = allocate<Type>( mm*n );
3173 const size_t min_m(
min( m, m_ ) );
3174 const size_t min_n(
min( n, n_ ) );
3176 for(
size_t j=0UL; j<min_n; ++j )
3177 for(
size_t i=0UL; i<min_m; ++i )
3178 v[i+j*mm] = v_[i+j*mm_];
3180 if( IsBuiltin<Type>::value ) {
3181 for(
size_t j=0UL; j<n; ++j )
3182 for(
size_t i=m; i<mm; ++i )
3190 else if( mm*n > capacity_ ) {
3191 Type* BLAZE_RESTRICT v = allocate<Type>( mm*n );
3193 if( IsBuiltin<Type>::value ) {
3194 for(
size_t j=0UL; j<n; ++j )
3195 for(
size_t i=m; i<mm; ++i )
3227 template<
typename Type >
3230 resize( m_+m, n_+n, preserve );
3246 template<
typename Type >
3249 if( elements > capacity_ )
3252 Type* BLAZE_RESTRICT tmp = allocate<Type>( elements );
3255 std::copy( v_, v_+capacity_, tmp );
3257 if( IsBuiltin<Type>::value ) {
3258 for(
size_t i=capacity_; i<elements; ++i )
3265 capacity_ = elements;
3278 template<
typename Type >
3281 DynamicMatrix tmp(
trans(*
this) );
3298 template<
typename Type >
3327 template<
typename Type >
3330 if( m_ != n_ )
return false;
3332 for(
size_t j=1UL; j<n_; ++j ) {
3333 for(
size_t i=0UL; i<j; ++i ) {
3351 template<
typename Type >
3354 if( m_ != n_ )
return false;
3356 for(
size_t j=1UL; j<n_; ++j ) {
3357 for(
size_t i=0UL; i<j; ++i ) {
3358 if( !
equal( v_[i+j*mm_], v_[j+i*mm_] ) )
3376 template<
typename Type >
3377 template<
typename Other >
3380 for(
size_t j=0UL; j<n_; ++j )
3381 for(
size_t i=0UL; i<m_; ++i )
3382 v_[i+j*mm_] *= scalar;
3398 template<
typename Type >
3418 template<
typename Type >
3419 inline size_t DynamicMatrix<Type,true>::adjustRows(
size_t minRows )
const
3421 if( IsBuiltin<Type>::value )
3422 return minRows + ( IT::size - ( minRows % IT::size ) ) % IT::size;
3423 else return minRows;
3444 template<
typename Type >
3445 template<
typename Other >
3448 return static_cast<const void*
>( this ) == static_cast<const void*>( alias );
3467 template<
typename Type >
3468 inline typename DynamicMatrix<Type,true>::IntrinsicType
3478 return load( &v_[i+j*mm_] );
3496 template<
typename Type >
3497 template<
typename MT >
3498 inline typename DisableIf< typename DynamicMatrix<Type,true>::BLAZE_TEMPLATE VectorizedAssign<MT> >::Type
3505 const size_t iend( m_ &
size_t(-2) );
3507 for(
size_t j=0UL; j<n_; ++j ) {
3508 for(
size_t i=0UL; i<iend; i+=2UL ) {
3509 v_[i +j*mm_] = (~rhs)(i ,j);
3510 v_[i+1UL+j*mm_] = (~rhs)(i+1UL,j);
3513 v_[iend+j*mm_] = (~rhs)(iend,j);
3533 template<
typename Type >
3534 template<
typename MT >
3535 inline typename EnableIf< typename DynamicMatrix<Type,true>::BLAZE_TEMPLATE VectorizedAssign<MT> >::Type
3543 if( m_*n_ > (
cacheSize / (
sizeof(Type) * 3UL ) ) && !(~rhs).isAliased(
this ) )
3545 for(
size_t j=0UL; j<n_; ++j )
3546 for(
size_t i=0UL; i<m_; i+=IT::size )
3547 stream( &v_[i+j*mm_], (~rhs).
get(i,j) );
3551 BLAZE_INTERNAL_ASSERT( ( m_ - ( m_ % (IT::size*4UL) ) ) == ( m_ &
size_t(-IT::size*4) ),
"Invalid end calculation" );
3552 const size_t iend( m_ &
size_t(-IT::size*4) );
3554 for(
size_t j=0UL; j<n_; ++j ) {
3555 for(
size_t i=0UL; i<iend; i+=IT::size*4UL ) {
3556 store( &v_[i+j*mm_ ], (~rhs).
get(i ,j) );
3557 store( &v_[i+j*mm_+IT::size ], (~rhs).
get(i+IT::size ,j) );
3558 store( &v_[i+j*mm_+IT::size*2UL], (~rhs).
get(i+IT::size*2UL,j) );
3559 store( &v_[i+j*mm_+IT::size*3UL], (~rhs).
get(i+IT::size*3UL,j) );
3561 for(
size_t i=iend; i<m_; i+=IT::size ) {
3562 store( &v_[i+j*mm_], (~rhs).
get(i,j) );
3583 template<
typename Type >
3584 template<
typename MT >
3590 const size_t block( 16UL );
3592 for(
size_t jj=0UL; jj<n_; jj+=block ) {
3593 const size_t jend( ( n_<(jj+block) )?( n_ ):( jj+block ) );
3594 for(
size_t ii=0UL; ii<m_; ii+=block ) {
3595 const size_t iend( ( m_<(ii+block) )?( m_ ):( ii+block ) );
3596 for(
size_t j=jj; j<jend; ++j ) {
3597 for(
size_t i=ii; i<iend; ++i ) {
3598 v_[i+j*mm_] = (~rhs)(i,j);
3620 template<
typename Type >
3621 template<
typename MT >
3624 for(
size_t j=0UL; j<(~rhs).
columns(); ++j )
3625 for(
typename MT::ConstIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
3626 v_[element->index()+j*mm_] = element->value();
3644 template<
typename Type >
3645 template<
typename MT >
3648 for(
size_t i=0UL; i<(~rhs).
rows(); ++i )
3649 for(
typename MT::ConstIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
3650 v_[i+element->index()*mm_] = element->value();
3668 template<
typename Type >
3669 template<
typename MT >
3670 inline typename DisableIf< typename DynamicMatrix<Type,true>::BLAZE_TEMPLATE VectorizedAddAssign<MT> >::Type
3677 const size_t iend( m_ &
size_t(-2) );
3679 for(
size_t j=0UL; j<n_; ++j ) {
3680 for(
size_t i=0UL; i<iend; i+=2UL ) {
3681 v_[i +j*mm_] += (~rhs)(i ,j);
3682 v_[i+1UL+j*mm_] += (~rhs)(i+1UL,j);
3685 v_[iend+j*mm_] += (~rhs)(iend,j);
3705 template<
typename Type >
3706 template<
typename MT >
3707 inline typename EnableIf< typename DynamicMatrix<Type,true>::BLAZE_TEMPLATE VectorizedAddAssign<MT> >::Type
3715 BLAZE_INTERNAL_ASSERT( ( m_ - ( m_ % (IT::size*4UL) ) ) == ( m_ &
size_t(-IT::size*4) ),
"Invalid end calculation" );
3716 const size_t iend( m_ &
size_t(-IT::size*4) );
3718 for(
size_t j=0UL; j<n_; ++j ) {
3719 for(
size_t i=0UL; i<iend; i+=IT::size*4UL ) {
3720 store( &v_[i+j*mm_ ],
load( &v_[i+j*mm_ ] ) + (~rhs).
get(i ,j) );
3721 store( &v_[i+j*mm_+IT::size ],
load( &v_[i+j*mm_+IT::size ] ) + (~rhs).
get(i+IT::size ,j) );
3722 store( &v_[i+j*mm_+IT::size*2UL],
load( &v_[i+j*mm_+IT::size*2UL] ) + (~rhs).
get(i+IT::size*2UL,j) );
3723 store( &v_[i+j*mm_+IT::size*3UL],
load( &v_[i+j*mm_+IT::size*3UL] ) + (~rhs).
get(i+IT::size*3UL,j) );
3725 for(
size_t i=iend; i<m_; i+=IT::size ) {
3726 store( &v_[i+j*mm_],
load( &v_[i+j*mm_] ) + (~rhs).
get(i,j) );
3746 template<
typename Type >
3747 template<
typename MT >
3753 const size_t block( 16UL );
3755 for(
size_t jj=0UL; jj<n_; jj+=block ) {
3756 const size_t jend( ( n_<(jj+block) )?( n_ ):( jj+block ) );
3757 for(
size_t ii=0UL; ii<m_; ii+=block ) {
3758 const size_t iend( ( m_<(ii+block) )?( m_ ):( ii+block ) );
3759 for(
size_t j=jj; j<jend; ++j ) {
3760 for(
size_t i=ii; i<iend; ++i ) {
3761 v_[i+j*mm_] += (~rhs)(i,j);
3783 template<
typename Type >
3784 template<
typename MT >
3787 for(
size_t j=0UL; j<(~rhs).
columns(); ++j )
3788 for(
typename MT::ConstIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
3789 v_[element->index()+j*mm_] += element->value();
3807 template<
typename Type >
3808 template<
typename MT >
3811 for(
size_t i=0UL; i<(~rhs).
rows(); ++i )
3812 for(
typename MT::ConstIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
3813 v_[i+element->index()*mm_] += element->value();
3831 template<
typename Type >
3832 template<
typename MT >
3833 inline typename DisableIf< typename DynamicMatrix<Type,true>::BLAZE_TEMPLATE VectorizedSubAssign<MT> >::Type
3840 const size_t iend( m_ &
size_t(-2) );
3842 for(
size_t j=0UL; j<n_; ++j ) {
3843 for(
size_t i=0UL; i<iend; i+=2UL ) {
3844 v_[i +j*mm_] -= (~rhs)(i ,j);
3845 v_[i+1+j*mm_] -= (~rhs)(i+1,j);
3848 v_[iend+j*mm_] -= (~rhs)(iend,j);
3869 template<
typename Type >
3870 template<
typename MT >
3871 inline typename EnableIf< typename DynamicMatrix<Type,true>::BLAZE_TEMPLATE VectorizedSubAssign<MT> >::Type
3879 BLAZE_INTERNAL_ASSERT( ( m_ - ( m_ % (IT::size*4UL) ) ) == ( m_ &
size_t(-IT::size*4) ),
"Invalid end calculation" );
3880 const size_t iend( m_ &
size_t(-IT::size*4) );
3882 for(
size_t j=0UL; j<n_; ++j ) {
3883 for(
size_t i=0UL; i<iend; i+=IT::size*4UL ) {
3884 store( &v_[i+j*mm_ ],
load( &v_[i+j*mm_ ] ) - (~rhs).
get(i ,j) );
3885 store( &v_[i+j*mm_+IT::size ],
load( &v_[i+j*mm_+IT::size ] ) - (~rhs).
get(i+IT::size ,j) );
3886 store( &v_[i+j*mm_+IT::size*2UL],
load( &v_[i+j*mm_+IT::size*2UL] ) - (~rhs).
get(i+IT::size*2UL,j) );
3887 store( &v_[i+j*mm_+IT::size*3UL],
load( &v_[i+j*mm_+IT::size*3UL] ) - (~rhs).
get(i+IT::size*3UL,j) );
3889 for(
size_t i=iend; i<m_; i+=IT::size ) {
3890 store( &v_[i+j*mm_],
load( &v_[i+j*mm_] ) - (~rhs).
get(i,j) );
3910 template<
typename Type >
3911 template<
typename MT >
3914 const size_t block( 16UL );
3916 for(
size_t jj=0UL; jj<n_; jj+=block ) {
3917 const size_t jend( ( n_<(jj+block) )?( n_ ):( jj+block ) );
3918 for(
size_t ii=0UL; ii<m_; ii+=block ) {
3919 const size_t iend( ( m_<(ii+block) )?( m_ ):( ii+block ) );
3920 for(
size_t j=jj; j<jend; ++j ) {
3921 for(
size_t i=ii; i<iend; ++i ) {
3922 v_[i+j*mm_] -= (~rhs)(i,j);
3944 template<
typename Type >
3945 template<
typename MT >
3948 for(
size_t j=0UL; j<(~rhs).
columns(); ++j )
3949 for(
typename MT::ConstIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
3950 v_[element->index()+j*mm_] -= element->value();
3968 template<
typename Type >
3969 template<
typename MT >
3972 for(
size_t i=0UL; i<(~rhs).
rows(); ++i )
3973 for(
typename MT::ConstIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
3974 v_[i+element->index()*mm_] -= element->value();
3995 template<
typename Type,
bool SO >
3996 inline bool isnan(
const DynamicMatrix<Type,SO>& m );
3998 template<
typename Type,
bool SO >
3999 inline void reset( DynamicMatrix<Type,SO>& m );
4001 template<
typename Type,
bool SO >
4002 inline void clear( DynamicMatrix<Type,SO>& m );
4004 template<
typename Type,
bool SO >
4005 inline bool isDefault(
const DynamicMatrix<Type,SO>& m );
4007 template<
typename Type,
bool SO >
4008 inline const DynamicMatrix<Type,SO>
inv(
const DynamicMatrix<Type,SO>& m );
4010 template<
typename Type,
bool SO >
4011 inline void swap( DynamicMatrix<Type,SO>& a, DynamicMatrix<Type,SO>& b ) ;
4023 template<
typename Type
4027 for(
size_t i=0UL; i<m.
rows(); ++i ) {
4028 for(
size_t j=0UL; j<m.
columns(); ++j )
4029 if(
isnan( m(i,j) ) )
return true;
4043 template<
typename Type
4059 template<
typename Type
4086 template<
typename Type
4091 for(
size_t i=0UL; i<m.
rows(); ++i )
4092 for(
size_t j=0UL; j<m.
columns(); ++j )
4093 if( !
isDefault( m(i,j) ) )
return false;
4096 for(
size_t j=0UL; j<m.
columns(); ++j )
4097 for(
size_t i=0UL; i<m.
rows(); ++i )
4098 if( !
isDefault( m(i,j) ) )
return false;
4124 template<
typename Type
4144 template<
typename Type
4163 template<
typename T,
bool SO >
4164 struct IsResizable< DynamicMatrix<T,SO> > :
public TrueType
4170 template<
typename T,
bool SO >
4171 struct IsResizable< const DynamicMatrix<T,SO> > :
public TrueType
4177 template<
typename T,
bool SO >
4178 struct IsResizable< volatile DynamicMatrix<T,SO> > :
public TrueType
4184 template<
typename T,
bool SO >
4185 struct IsResizable< const volatile DynamicMatrix<T,SO> > :
public TrueType
4204 template<
typename T1,
bool SO,
typename T2,
size_t M,
size_t N >
4205 struct AddTrait< DynamicMatrix<T1,SO>, StaticMatrix<T2,M,N,SO> >
4207 typedef StaticMatrix< typename AddTrait<T1,T2>::Type, M, N, SO > Type;
4210 template<
typename T1,
bool SO1,
typename T2,
size_t M,
size_t N,
bool SO2 >
4211 struct AddTrait< DynamicMatrix<T1,SO1>, StaticMatrix<T2,M,N,SO2> >
4213 typedef StaticMatrix< typename AddTrait<T1,T2>::Type, M, N,
false > Type;
4216 template<
typename T1,
size_t M,
size_t N,
bool SO,
typename T2 >
4217 struct AddTrait< StaticMatrix<T1,M,N,SO>, DynamicMatrix<T2,SO> >
4219 typedef StaticMatrix< typename AddTrait<T1,T2>::Type, M, N, SO > Type;
4222 template<
typename T1,
size_t M,
size_t N,
bool SO1,
typename T2,
bool SO2 >
4223 struct AddTrait< StaticMatrix<T1,M,N,SO1>, DynamicMatrix<T2,SO2> >
4225 typedef StaticMatrix< typename AddTrait<T1,T2>::Type, M, N,
false > Type;
4228 template<
typename T1,
bool SO,
typename T2 >
4229 struct AddTrait< DynamicMatrix<T1,SO>, DynamicMatrix<T2,SO> >
4231 typedef DynamicMatrix< typename AddTrait<T1,T2>::Type , SO > Type;
4234 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
4235 struct AddTrait< DynamicMatrix<T1,SO1>, DynamicMatrix<T2,SO2> >
4237 typedef DynamicMatrix< typename AddTrait<T1,T2>::Type ,
false > Type;
4253 template<
typename T1,
bool SO,
typename T2,
size_t M,
size_t N >
4254 struct SubTrait< DynamicMatrix<T1,SO>, StaticMatrix<T2,M,N,SO> >
4256 typedef StaticMatrix< typename SubTrait<T1,T2>::Type, M, N, SO > Type;
4259 template<
typename T1,
bool SO1,
typename T2,
size_t M,
size_t N,
bool SO2 >
4260 struct SubTrait< DynamicMatrix<T1,SO1>, StaticMatrix<T2,M,N,SO2> >
4262 typedef StaticMatrix< typename SubTrait<T1,T2>::Type, M, N,
false > Type;
4265 template<
typename T1,
size_t M,
size_t N,
bool SO,
typename T2 >
4266 struct SubTrait< StaticMatrix<T1,M,N,SO>, DynamicMatrix<T2,SO> >
4268 typedef StaticMatrix< typename SubTrait<T1,T2>::Type, M, N, SO > Type;
4271 template<
typename T1,
size_t M,
size_t N,
bool SO1,
typename T2,
bool SO2 >
4272 struct SubTrait< StaticMatrix<T1,M,N,SO1>, DynamicMatrix<T2,SO2> >
4274 typedef StaticMatrix< typename SubTrait<T1,T2>::Type, M, N,
false > Type;
4277 template<
typename T1,
bool SO,
typename T2 >
4278 struct SubTrait< DynamicMatrix<T1,SO>, DynamicMatrix<T2,SO> >
4280 typedef DynamicMatrix< typename SubTrait<T1,T2>::Type , SO > Type;
4283 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
4284 struct SubTrait< DynamicMatrix<T1,SO1>, DynamicMatrix<T2,SO2> >
4286 typedef DynamicMatrix< typename SubTrait<T1,T2>::Type ,
false > Type;
4302 template<
typename T1,
bool SO,
typename T2 >
4303 struct MultTrait< DynamicMatrix<T1,SO>, T2 >
4305 typedef DynamicMatrix< typename MultTrait<T1,T2>::Type, SO > Type;
4309 template<
typename T1,
typename T2,
bool SO >
4310 struct MultTrait< T1, DynamicMatrix<T2,SO> >
4312 typedef DynamicMatrix< typename MultTrait<T1,T2>::Type, SO > Type;
4316 template<
typename T1,
bool SO,
typename T2,
size_t N >
4317 struct MultTrait< DynamicMatrix<T1,SO>, StaticVector<T2,N,false> >
4319 typedef DynamicVector< typename MultTrait<T1,T2>::Type,
false > Type;
4322 template<
typename T1,
size_t N,
typename T2,
bool SO >
4323 struct MultTrait< StaticVector<T1,N,true>, DynamicMatrix<T2,SO> >
4325 typedef DynamicVector< typename MultTrait<T1,T2>::Type,
true > Type;
4328 template<
typename T1,
bool SO,
typename T2 >
4329 struct MultTrait< DynamicMatrix<T1,SO>, DynamicVector<T2,false> >
4331 typedef DynamicVector< typename MultTrait<T1,T2>::Type,
false > Type;
4334 template<
typename T1,
typename T2,
bool SO >
4335 struct MultTrait< DynamicVector<T1,true>, DynamicMatrix<T2,SO> >
4337 typedef DynamicVector< typename MultTrait<T1,T2>::Type,
true > Type;
4340 template<
typename T1,
bool SO,
typename T2 >
4341 struct MultTrait< DynamicMatrix<T1,SO>, CompressedVector<T2,false> >
4343 typedef DynamicVector< typename MultTrait<T1,T2>::Type,
false > Type;
4346 template<
typename T1,
typename T2,
bool SO >
4347 struct MultTrait< CompressedVector<T1,true>, DynamicMatrix<T2,SO> >
4349 typedef DynamicVector< typename MultTrait<T1,T2>::Type,
true > Type;
4352 template<
typename T1,
bool SO1,
typename T2,
size_t M,
size_t N,
bool SO2 >
4353 struct MultTrait< DynamicMatrix<T1,SO1>, StaticMatrix<T2,M,N,SO2> >
4355 typedef DynamicMatrix< typename MultTrait<T1,T2>::Type, SO1 > Type;
4358 template<
typename T1,
size_t M,
size_t N,
bool SO1,
typename T2,
bool SO2 >
4359 struct MultTrait< StaticMatrix<T1,M,N,SO1>, DynamicMatrix<T2,SO2> >
4361 typedef DynamicMatrix< typename MultTrait<T1,T2>::Type, SO1 > Type;
4364 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
4365 struct MultTrait< DynamicMatrix<T1,SO1>, DynamicMatrix<T2,SO2> >
4367 typedef DynamicMatrix< typename MultTrait<T1,T2>::Type, SO1 > Type;
4383 template<
typename T1,
bool SO,
typename T2 >
4384 struct DivTrait< DynamicMatrix<T1,SO>, T2 >
4386 typedef DynamicMatrix< typename DivTrait<T1,T2>::Type , SO > Type;
4403 template<
typename T1,
bool SO,
typename T2 >
4404 struct MathTrait< DynamicMatrix<T1,SO>, DynamicMatrix<T2,SO> >
4406 typedef DynamicMatrix< typename MathTrait<T1,T2>::HighType, SO > HighType;
4407 typedef DynamicMatrix< typename MathTrait<T1,T2>::LowType , SO > LowType;