22 #ifndef _BLAZE_MATH_DENSE_DYNAMICMATRIX_H_
23 #define _BLAZE_MATH_DENSE_DYNAMICMATRIX_H_
160 template<
typename Type
199 explicit inline DynamicMatrix(
size_t m,
size_t n, Type init );
203 template<
typename Other,
size_t M,
size_t N >
220 inline Type*
data ();
221 inline const Type*
data ()
const;
222 inline Type*
data (
size_t i );
223 inline const Type*
data (
size_t i )
const;
236 template<
typename Other,
size_t M,
size_t N >
246 template<
typename Other >
248 operator*=( Other rhs );
250 template<
typename Other >
252 operator/=( Other rhs );
259 inline size_t rows()
const;
263 inline size_t capacity(
size_t i )
const;
265 inline size_t nonZeros(
size_t i )
const;
267 inline void reset(
size_t i );
269 void resize (
size_t m,
size_t n,
bool preserve=
true );
270 inline void extend (
size_t m,
size_t n,
bool preserve=
true );
271 inline void reserve(
size_t elements );
275 template<
typename Other >
inline DynamicMatrix& scale( Other scalar );
284 template<
typename MT >
285 struct VectorizedAssign {
286 enum { value = vectorizable && MT::vectorizable &&
295 template<
typename MT >
296 struct VectorizedAddAssign {
297 enum { value = vectorizable && MT::vectorizable &&
298 IsSame<Type,typename MT::ElementType>::value &&
299 IntrinsicTrait<Type>::addition };
307 template<
typename MT >
308 struct VectorizedSubAssign {
309 enum { value = vectorizable && MT::vectorizable &&
310 IsSame<Type,typename MT::ElementType>::value &&
311 IntrinsicTrait<Type>::subtraction };
320 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
321 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
324 template<
typename MT >
325 inline typename DisableIf< VectorizedAssign<MT> >::Type
326 assign(
const DenseMatrix<MT,SO>& rhs );
328 template<
typename MT >
329 inline typename EnableIf< VectorizedAssign<MT> >::Type
330 assign(
const DenseMatrix<MT,SO>& rhs );
332 template<
typename MT >
inline void assign(
const DenseMatrix<MT,!SO>& rhs );
333 template<
typename MT >
inline void assign(
const SparseMatrix<MT,SO>& rhs );
334 template<
typename MT >
inline void assign(
const SparseMatrix<MT,!SO>& rhs );
336 template<
typename MT >
337 inline typename DisableIf< VectorizedAddAssign<MT> >::Type
338 addAssign(
const DenseMatrix<MT,SO>& rhs );
340 template<
typename MT >
341 inline typename EnableIf< VectorizedAddAssign<MT> >::Type
342 addAssign(
const DenseMatrix<MT,SO>& rhs );
344 template<
typename MT >
inline void addAssign(
const DenseMatrix<MT,!SO>& rhs );
345 template<
typename MT >
inline void addAssign(
const SparseMatrix<MT,SO>& rhs );
346 template<
typename MT >
inline void addAssign(
const SparseMatrix<MT,!SO>& rhs );
348 template<
typename MT >
349 inline typename DisableIf< VectorizedSubAssign<MT> >::Type
350 subAssign(
const DenseMatrix<MT,SO>& rhs );
352 template<
typename MT >
353 inline typename EnableIf< VectorizedSubAssign<MT> >::Type
354 subAssign(
const DenseMatrix<MT,SO>& rhs );
356 template<
typename MT >
inline void subAssign(
const DenseMatrix<MT,!SO>& rhs );
357 template<
typename MT >
inline void subAssign(
const SparseMatrix<MT,SO>& rhs );
358 template<
typename MT >
inline void subAssign(
const SparseMatrix<MT,!SO>& rhs );
413 template<
typename Type
434 template<
typename Type
439 , nn_ ( adjustColumns( n ) )
440 , capacity_( m_*nn_ )
441 , v_ (
allocate<Type>( capacity_ ) )
444 for(
size_t i=0UL; i<
m_; ++i ) {
445 for(
size_t j=
n_; j<
nn_; ++j )
446 v_[i*nn_+j] = Type();
462 template<
typename Type
467 , nn_ ( adjustColumns( n ) )
468 , capacity_( m_*nn_ )
469 , v_ (
allocate<Type>( capacity_ ) )
471 for(
size_t i=0UL; i<m; ++i ) {
472 for(
size_t j=0UL; j<
n_; ++j )
476 for(
size_t j=n_; j<
nn_; ++j )
477 v_[i*nn_+j] = Type();
492 template<
typename Type
498 , capacity_( m_*nn_ )
499 , v_ (
allocate<Type>( capacity_ ) )
514 template<
typename Type
516 template<
typename MT
521 , nn_ ( adjustColumns( n_ ) )
522 , capacity_( m_*nn_ )
523 , v_ (
allocate<Type>( capacity_ ) )
528 for(
size_t i=0UL; i<
m_; ++i ) {
530 v_[i*nn_+j] = Type();
557 template<
typename Type
559 template<
typename Other
565 , nn_ ( adjustColumns( N ) )
566 , capacity_( m_*nn_ )
567 , v_ (
allocate<Type>( capacity_ ) )
569 for(
size_t i=0UL; i<M; ++i ) {
570 for(
size_t j=0UL; j<N; ++j )
571 v_[i*
nn_+j] = rhs[i][j];
574 for(
size_t j=N; j<
nn_; ++j )
575 v_[i*nn_+j] = Type();
593 template<
typename Type
617 template<
typename Type
636 template<
typename Type
653 template<
typename Type
667 template<
typename Type
682 template<
typename Type
698 template<
typename Type
719 template<
typename Type
741 template<
typename Type
763 template<
typename Type
785 template<
typename Type
791 return v_ + i*nn_ + n_;
807 template<
typename Type
813 return v_ + i*nn_ + n_;
829 template<
typename Type
835 return v_ + i*nn_ + n_;
867 template<
typename Type
869 template<
typename Other
874 resize( M, N,
false );
876 for(
size_t i=0UL; i<M; ++i )
877 for(
size_t j=0UL; j<N; ++j )
878 v_[i*nn_+j] = rhs[i][j];
891 template<
typename Type
895 for(
size_t i=0UL; i<m_; ++i )
896 for(
size_t j=0UL; j<n_; ++j )
913 template<
typename Type
917 if( &rhs ==
this )
return *
this;
919 resize( rhs.
m_, rhs.
n_,
false );
921 for(
size_t i=0UL; i<m_; ++i )
922 for(
size_t j=0UL; j<n_; ++j )
923 v_[i*nn_+j] = rhs(i,j);
939 template<
typename Type
941 template<
typename MT
947 if( (~rhs).canAlias(
this ) ) {
973 template<
typename Type
975 template<
typename MT
981 if( (~rhs).
rows() != m_ || (~rhs).
columns() != n_ )
982 throw std::invalid_argument(
"Matrix sizes do not match" );
984 if( (~rhs).canAlias(
this ) ) {
985 typename MT::ResultType tmp( ~rhs );
1007 template<
typename Type
1009 template<
typename MT
1015 if( (~rhs).
rows() != m_ || (~rhs).
columns() != n_ )
1016 throw std::invalid_argument(
"Matrix sizes do not match" );
1018 if( (~rhs).canAlias(
this ) ) {
1019 typename MT::ResultType tmp( ~rhs );
1041 template<
typename Type
1043 template<
typename MT
1047 if( (~rhs).
rows() != n_ )
1048 throw std::invalid_argument(
"Matrix sizes do not match" );
1065 template<
typename Type
1067 template<
typename Other >
1071 return operator=( (*
this) * rhs );
1083 template<
typename Type
1085 template<
typename Other >
1091 return operator=( (*
this) / rhs );
1109 template<
typename Type
1123 template<
typename Type
1140 template<
typename Type
1154 template<
typename Type
1174 template<
typename Type
1190 template<
typename Type
1194 size_t nonzeros( 0UL );
1196 for(
size_t i=0UL; i<m_; ++i )
1197 for(
size_t j=0UL; j<n_; ++j )
1212 template<
typename Type
1218 const size_t jend( (i+1UL)*nn_ );
1219 size_t nonzeros( 0UL );
1221 for(
size_t j=i*nn_; j<jend; ++j )
1235 template<
typename Type
1241 for(
size_t i=0UL; i<m_; ++i )
1242 for(
size_t j=0UL; j<n_; ++j )
1243 reset( v_[i*nn_+j] );
1259 template<
typename Type
1266 for(
size_t j=0UL; j<n_; ++j )
1267 reset( v_[i*nn_+j] );
1279 template<
typename Type
1323 template<
typename Type
1329 if( m == m_ && n == n_ )
return;
1331 const size_t nn( adjustColumns( n ) );
1336 const size_t min_m(
min( m, m_ ) );
1337 const size_t min_n(
min( n, n_ ) );
1339 for(
size_t i=0UL; i<min_m; ++i )
1340 for(
size_t j=0UL; j<min_n; ++j )
1341 v[i*nn+j] = v_[i*nn_+j];
1344 for(
size_t i=0UL; i<m; ++i )
1345 for(
size_t j=n; j<nn; ++j )
1353 else if( m*nn > capacity_ ) {
1357 for(
size_t i=0UL; i<m; ++i )
1358 for(
size_t j=n; j<nn; ++j )
1388 template<
typename Type
1392 resize( m_+m, n_+n, preserve );
1406 template<
typename Type
1410 if( elements > capacity_ )
1416 std::copy( v_, v_+capacity_, tmp );
1419 for(
size_t i=capacity_; i<elements; ++i )
1426 capacity_ = elements;
1437 template<
typename Type
1465 template<
typename Type
1469 if( m_ != n_ )
return false;
1471 for(
size_t i=1UL; i<m_; ++i ) {
1472 for(
size_t j=0UL; j<i; ++j ) {
1488 template<
typename Type
1492 if( m_ != n_ )
return false;
1494 for(
size_t i=1UL; i<m_; ++i ) {
1495 for(
size_t j=0UL; j<i; ++j ) {
1496 if( !
equal( v_[i*nn_+j], v_[j*nn_+i] ) )
1512 template<
typename Type
1514 template<
typename Other >
1517 for(
size_t i=0UL; i<m_; ++i )
1518 for(
size_t j=0UL; j<n_; ++j )
1519 v_[i*nn_+j] *= scalar;
1533 template<
typename Type
1552 template<
typename Type
1557 return minColumns + ( IT::size - ( minColumns % IT::size ) ) % IT::size;
1558 else return minColumns;
1581 template<
typename Type
1583 template<
typename Other >
1586 return static_cast<const void*
>( this ) == static_cast<const void*>( alias );
1601 template<
typename Type
1603 template<
typename Other >
1606 return static_cast<const void*
>( this ) == static_cast<const void*>( alias );
1623 template<
typename Type
1635 return load( &v_[i*nn_+j] );
1651 template<
typename Type
1653 template<
typename MT >
1661 const size_t jend( n_ &
size_t(-2) );
1663 for(
size_t i=0UL; i<m_; ++i ) {
1664 for(
size_t j=0UL; j<jend; j+=2UL ) {
1665 v_[i*nn_+j ] = (~rhs)(i,j );
1666 v_[i*nn_+j+1UL] = (~rhs)(i,j+1UL);
1669 v_[i*nn_+jend] = (~rhs)(i,jend);
1687 template<
typename Type
1689 template<
typename MT >
1698 if( m_*n_ > (
cacheSize / (
sizeof(Type) * 3UL ) ) && !(~rhs).isAliased(
this ) )
1700 for(
size_t i=0UL; i<m_; ++i )
1701 for(
size_t j=0UL; j<n_; j+=IT::size )
1702 stream( &v_[i*nn_+j], (~rhs).
get(i,j) );
1706 BLAZE_INTERNAL_ASSERT( ( n_ - ( n_ % (IT::size*4UL) ) ) == ( n_ &
size_t(-IT::size*4) ),
"Invalid end calculation" );
1707 const size_t jend( n_ &
size_t(-IT::size*4) );
1709 for(
size_t i=0UL; i<m_; ++i ) {
1710 for(
size_t j=0UL; j<jend; j+=IT::size*4UL ) {
1711 store( &v_[i*nn_+j ], (~rhs).
get(i,j ) );
1712 store( &v_[i*nn_+j+IT::size ], (~rhs).
get(i,j+IT::size ) );
1713 store( &v_[i*nn_+j+IT::size*2UL], (~rhs).
get(i,j+IT::size*2UL) );
1714 store( &v_[i*nn_+j+IT::size*3UL], (~rhs).
get(i,j+IT::size*3UL) );
1716 for(
size_t j=jend; j<n_; j+=IT::size ) {
1717 store( &v_[i*nn_+j], (~rhs).
get(i,j) );
1736 template<
typename Type
1738 template<
typename MT >
1744 const size_t block( 16UL );
1746 for(
size_t ii=0UL; ii<m_; ii+=block ) {
1747 const size_t iend( ( m_<(ii+block) )?( m_ ):( ii+block ) );
1748 for(
size_t jj=0UL; jj<n_; jj+=block ) {
1749 const size_t jend( ( n_<(jj+block) )?( n_ ):( jj+block ) );
1750 for(
size_t i=ii; i<iend; ++i ) {
1751 for(
size_t j=jj; j<jend; ++j ) {
1752 v_[i*nn_+j] = (~rhs)(i,j);
1772 template<
typename Type
1774 template<
typename MT >
1780 for(
size_t i=0UL; i<m_; ++i )
1781 for(
typename MT::ConstIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
1782 v_[i*nn_+element->index()] = element->value();
1798 template<
typename Type
1800 template<
typename MT >
1806 for(
size_t j=0UL; j<n_; ++j )
1807 for(
typename MT::ConstIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
1808 v_[element->index()*nn_+j] = element->value();
1824 template<
typename Type
1826 template<
typename MT >
1834 const size_t jend( n_ &
size_t(-2) );
1836 for(
size_t i=0UL; i<m_; ++i ) {
1837 for(
size_t j=0UL; j<jend; j+=2UL ) {
1838 v_[i*nn_+j ] += (~rhs)(i,j );
1839 v_[i*nn_+j+1UL] += (~rhs)(i,j+1UL);
1842 v_[i*nn_+jend] += (~rhs)(i,jend);
1860 template<
typename Type
1862 template<
typename MT >
1871 BLAZE_INTERNAL_ASSERT( ( n_ - ( n_ % (IT::size*4UL) ) ) == ( n_ &
size_t(-IT::size*4) ),
"Invalid end calculation" );
1872 const size_t jend( n_ &
size_t(-IT::size*4) );
1874 for(
size_t i=0UL; i<m_; ++i ) {
1875 for(
size_t j=0UL; j<jend; j+=IT::size*4UL ) {
1876 store( &v_[i*nn_+j ],
load( &v_[i*nn_+j ] ) + (~rhs).
get(i,j ) );
1877 store( &v_[i*nn_+j+IT::size ],
load( &v_[i*nn_+j+IT::size ] ) + (~rhs).
get(i,j+IT::size ) );
1878 store( &v_[i*nn_+j+IT::size*2UL],
load( &v_[i*nn_+j+IT::size*2UL] ) + (~rhs).
get(i,j+IT::size*2UL) );
1879 store( &v_[i*nn_+j+IT::size*3UL],
load( &v_[i*nn_+j+IT::size*3UL] ) + (~rhs).
get(i,j+IT::size*3UL) );
1881 for(
size_t j=jend; j<n_; j+=IT::size ) {
1882 store( &v_[i*nn_+j],
load( &v_[i*nn_+j] ) + (~rhs).
get(i,j) );
1900 template<
typename Type
1902 template<
typename MT >
1908 const size_t block( 16UL );
1910 for(
size_t ii=0UL; ii<m_; ii+=block ) {
1911 const size_t iend( ( m_<(ii+block) )?( m_ ):( ii+block ) );
1912 for(
size_t jj=0UL; jj<n_; jj+=block ) {
1913 const size_t jend( ( n_<(jj+block) )?( n_ ):( jj+block ) );
1914 for(
size_t i=ii; i<iend; ++i ) {
1915 for(
size_t j=jj; j<jend; ++j ) {
1916 v_[i*nn_+j] += (~rhs)(i,j);
1936 template<
typename Type
1938 template<
typename MT >
1944 for(
size_t i=0UL; i<m_; ++i )
1945 for(
typename MT::ConstIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
1946 v_[i*nn_+element->index()] += element->value();
1962 template<
typename Type
1964 template<
typename MT >
1970 for(
size_t j=0UL; j<n_; ++j )
1971 for(
typename MT::ConstIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
1972 v_[element->index()*nn_+j] += element->value();
1988 template<
typename Type
1990 template<
typename MT >
1998 const size_t jend( n_ &
size_t(-2) );
2000 for(
size_t i=0UL; i<m_; ++i ) {
2001 for(
size_t j=0UL; j<jend; j+=2UL ) {
2002 v_[i*nn_+j ] -= (~rhs)(i,j );
2003 v_[i*nn_+j+1UL] -= (~rhs)(i,j+1UL);
2006 v_[i*nn_+jend] -= (~rhs)(i,jend);
2024 template<
typename Type
2026 template<
typename MT >
2035 BLAZE_INTERNAL_ASSERT( ( n_ - ( n_ % (IT::size*4UL) ) ) == ( n_ &
size_t(-IT::size*4) ),
"Invalid end calculation" );
2036 const size_t jend( n_ &
size_t(-IT::size*4) );
2038 for(
size_t i=0UL; i<m_; ++i ) {
2039 for(
size_t j=0UL; j<jend; j+=IT::size*4UL ) {
2040 store( &v_[i*nn_+j ],
load( &v_[i*nn_+j ] ) - (~rhs).
get(i,j ) );
2041 store( &v_[i*nn_+j+IT::size ],
load( &v_[i*nn_+j+IT::size ] ) - (~rhs).
get(i,j+IT::size ) );
2042 store( &v_[i*nn_+j+IT::size*2UL],
load( &v_[i*nn_+j+IT::size*2UL] ) - (~rhs).
get(i,j+IT::size*2UL) );
2043 store( &v_[i*nn_+j+IT::size*3UL],
load( &v_[i*nn_+j+IT::size*3UL] ) - (~rhs).
get(i,j+IT::size*3UL) );
2045 for(
size_t j=jend; j<n_; j+=IT::size ) {
2046 store( &v_[i*nn_+j],
load( &v_[i*nn_+j] ) - (~rhs).
get(i,j) );
2064 template<
typename Type
2066 template<
typename MT >
2072 const size_t block( 16UL );
2074 for(
size_t ii=0UL; ii<m_; ii+=block ) {
2075 const size_t iend( ( m_<(ii+block) )?( m_ ):( ii+block ) );
2076 for(
size_t jj=0UL; jj<n_; jj+=block ) {
2077 const size_t jend( ( n_<(jj+block) )?( n_ ):( jj+block ) );
2078 for(
size_t i=ii; i<iend; ++i ) {
2079 for(
size_t j=jj; j<jend; ++j ) {
2080 v_[i*nn_+j] -= (~rhs)(i,j);
2100 template<
typename Type
2102 template<
typename MT >
2108 for(
size_t i=0UL; i<m_; ++i )
2109 for(
typename MT::ConstIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
2110 v_[i*nn_+element->index()] -= element->value();
2126 template<
typename Type
2128 template<
typename MT >
2134 for(
size_t j=0UL; j<n_; ++j )
2135 for(
typename MT::ConstIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
2136 v_[element->index()*nn_+j] -= element->value();
2161 template<
typename Type >
2199 explicit inline DynamicMatrix(
size_t m,
size_t n, Type init );
2201 template<
typename MT,
bool SO >
inline DynamicMatrix(
const Matrix<MT,SO>& m );
2203 template<
typename Other,
size_t M,
size_t N >
2220 inline Type*
data ();
2221 inline const Type*
data ()
const;
2222 inline Type*
data (
size_t j );
2223 inline const Type*
data (
size_t j )
const;
2236 template<
typename Other,
size_t M,
size_t N >
2237 inline DynamicMatrix& operator=(
const Other (&rhs)[M][N] );
2241 template<
typename MT,
bool SO >
inline DynamicMatrix& operator= (
const Matrix<MT,SO>& rhs );
2242 template<
typename MT,
bool SO >
inline DynamicMatrix& operator+=(
const Matrix<MT,SO>& rhs );
2243 template<
typename MT,
bool SO >
inline DynamicMatrix& operator-=(
const Matrix<MT,SO>& rhs );
2244 template<
typename MT,
bool SO >
inline DynamicMatrix& operator*=(
const Matrix<MT,SO>& rhs );
2246 template<
typename Other >
2247 inline typename EnableIf< IsNumeric<Other>,
DynamicMatrix >::Type&
2248 operator*=( Other rhs );
2250 template<
typename Other >
2251 inline typename EnableIf< IsNumeric<Other>,
DynamicMatrix >::Type&
2252 operator/=( Other rhs );
2259 inline size_t rows()
const;
2260 inline size_t columns()
const;
2261 inline size_t spacing()
const;
2263 inline size_t capacity(
size_t j )
const;
2265 inline size_t nonZeros(
size_t j )
const;
2266 inline void reset();
2267 inline void reset(
size_t j );
2268 inline void clear();
2269 void resize (
size_t m,
size_t n,
bool preserve=
true );
2270 inline void extend (
size_t m,
size_t n,
bool preserve=
true );
2271 inline void reserve(
size_t elements );
2275 template<
typename Other >
inline DynamicMatrix& scale( Other scalar );
2283 template<
typename MT >
2284 struct VectorizedAssign {
2285 enum { value = vectorizable && MT::vectorizable &&
2286 IsSame<Type,typename MT::ElementType>::value };
2292 template<
typename MT >
2293 struct VectorizedAddAssign {
2294 enum { value = vectorizable && MT::vectorizable &&
2295 IsSame<Type,typename MT::ElementType>::value &&
2296 IntrinsicTrait<Type>::addition };
2302 template<
typename MT >
2303 struct VectorizedSubAssign {
2304 enum { value = vectorizable && MT::vectorizable &&
2305 IsSame<Type,typename MT::ElementType>::value &&
2306 IntrinsicTrait<Type>::subtraction };
2314 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
2315 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
2318 template<
typename MT >
2319 inline typename DisableIf< VectorizedAssign<MT> >::Type
2320 assign(
const DenseMatrix<MT,true>& rhs );
2322 template<
typename MT >
2323 inline typename EnableIf< VectorizedAssign<MT> >::Type
2324 assign(
const DenseMatrix<MT,true>& rhs );
2326 template<
typename MT >
inline void assign(
const DenseMatrix<MT,false>& rhs );
2327 template<
typename MT >
inline void assign(
const SparseMatrix<MT,true>& rhs );
2328 template<
typename MT >
inline void assign(
const SparseMatrix<MT,false>& rhs );
2330 template<
typename MT >
2331 inline typename DisableIf< VectorizedAddAssign<MT> >::Type
2332 addAssign(
const DenseMatrix<MT,true>& rhs );
2334 template<
typename MT >
2335 inline typename EnableIf< VectorizedAddAssign<MT> >::Type
2336 addAssign(
const DenseMatrix<MT,true>& rhs );
2338 template<
typename MT >
inline void addAssign(
const DenseMatrix<MT,false>& rhs );
2339 template<
typename MT >
inline void addAssign(
const SparseMatrix<MT,true>& rhs );
2340 template<
typename MT >
inline void addAssign(
const SparseMatrix<MT,false>& rhs );
2342 template<
typename MT >
2343 inline typename DisableIf< VectorizedSubAssign<MT> >::Type
2344 subAssign (
const DenseMatrix<MT,true>& rhs );
2346 template<
typename MT >
2347 inline typename EnableIf< VectorizedSubAssign<MT> >::Type
2348 subAssign (
const DenseMatrix<MT,true>& rhs );
2350 template<
typename MT >
inline void subAssign(
const DenseMatrix<MT,false>& rhs );
2351 template<
typename MT >
inline void subAssign(
const SparseMatrix<MT,true>& rhs );
2352 template<
typename MT >
inline void subAssign(
const SparseMatrix<MT,false>& rhs );
2360 inline size_t adjustRows(
size_t minRows )
const;
2407 template<
typename Type >
2429 template<
typename Type >
2432 , mm_ ( adjustRows( m ) )
2434 , capacity_( mm_*n_ )
2435 , v_ (
allocate<Type>( capacity_ ) )
2437 if( IsNumeric<Type>::value ) {
2438 for(
size_t j=0UL; j<
n_; ++j )
2439 for(
size_t i=
m_; i<mm_; ++i ) {
2440 v_[i+j*mm_] = Type();
2458 template<
typename Type >
2461 , mm_ ( adjustRows( m ) )
2463 , capacity_( mm_*n_ )
2464 , v_ (
allocate<Type>( capacity_ ) )
2466 for(
size_t j=0UL; j<
n_; ++j ) {
2467 for(
size_t i=0UL; i<
m_; ++i )
2470 if( IsNumeric<Type>::value ) {
2471 for(
size_t i=m_; i<mm_; ++i )
2472 v_[i+j*mm_] = Type();
2489 template<
typename Type >
2494 , capacity_( mm_*n_ )
2495 , v_ (
allocate<Type>( capacity_ ) )
2512 template<
typename Type >
2513 template<
typename MT
2516 : m_ ( (~m).
rows() )
2517 , mm_ ( adjustRows( m_ ) )
2519 , capacity_( mm_*n_ )
2520 , v_ (
allocate<Type>( capacity_ ) )
2524 if( IsNumeric<Type>::value ) {
2525 for(
size_t j=0UL; j<
n_; ++j )
2526 for(
size_t i=( IsSparseMatrix<MT>::value )?( 0UL ):( m_ ); i<mm_; ++i ) {
2527 v_[i+j*mm_] = Type();
2531 assign( *
this, ~m );
2558 template<
typename Type >
2559 template<
typename Other
2564 , mm_ ( adjustRows( M ) )
2566 , capacity_( mm_*n_ )
2567 , v_ (
allocate<Type>( capacity_ ) )
2569 for(
size_t j=0UL; j<N; ++j ) {
2570 for(
size_t i=0UL; i<M; ++i )
2571 v_[i+j*mm_] = rhs[i][j];
2573 if( IsNumeric<Type>::value ) {
2574 for(
size_t i=M; i<mm_; ++i )
2575 v_[i+j*mm_] = Type();
2595 template<
typename Type >
2620 template<
typename Type >
2621 inline typename DynamicMatrix<Type,true>::Reference
2640 template<
typename Type >
2641 inline typename DynamicMatrix<Type,true>::ConstReference
2658 template<
typename Type >
2673 template<
typename Type >
2689 template<
typename Type >
2706 template<
typename Type >
2723 template<
typename Type >
2724 inline typename DynamicMatrix<Type,true>::Iterator
2741 template<
typename Type >
2742 inline typename DynamicMatrix<Type,true>::ConstIterator
2759 template<
typename Type >
2760 inline typename DynamicMatrix<Type,true>::ConstIterator
2777 template<
typename Type >
2778 inline typename DynamicMatrix<Type,true>::Iterator
2782 return v_ + j*mm_ + m_;
2795 template<
typename Type >
2796 inline typename DynamicMatrix<Type,true>::ConstIterator
2800 return v_ + j*mm_ + m_;
2813 template<
typename Type >
2814 inline typename DynamicMatrix<Type,true>::ConstIterator
2818 return v_ + j*mm_ + m_;
2852 template<
typename Type >
2853 template<
typename Other
2856 inline DynamicMatrix<Type,true>& DynamicMatrix<Type,true>::operator=(
const Other (&rhs)[M][N] )
2858 resize( M, N,
false );
2860 for(
size_t j=0UL; j<N; ++j )
2861 for(
size_t i=0UL; i<M; ++i )
2862 v_[i+j*mm_] = rhs[i][j];
2877 template<
typename Type >
2878 inline DynamicMatrix<Type,true>& DynamicMatrix<Type,true>::operator=( Type rhs )
2880 for(
size_t j=0UL; j<n_; ++j )
2881 for(
size_t i=0UL; i<m_; ++i )
2900 template<
typename Type >
2901 inline DynamicMatrix<Type,true>& DynamicMatrix<Type,true>::operator=(
const DynamicMatrix& rhs )
2903 if( &rhs ==
this )
return *
this;
2905 resize( rhs.m_, rhs.n_,
false );
2907 for(
size_t j=0UL; j<n_; ++j )
2908 for(
size_t i=0UL; i<m_; ++i )
2909 v_[i+j*mm_] = rhs(i,j);
2927 template<
typename Type >
2928 template<
typename MT
2930 inline DynamicMatrix<Type,true>& DynamicMatrix<Type,true>::operator=(
const Matrix<MT,SO>& rhs )
2934 if( (~rhs).canAlias(
this ) ) {
2935 DynamicMatrix tmp( ~rhs );
2940 if( IsSparseMatrix<MT>::value )
2962 template<
typename Type >
2963 template<
typename MT
2965 inline DynamicMatrix<Type,true>& DynamicMatrix<Type,true>::operator+=(
const Matrix<MT,SO>& rhs )
2969 if( (~rhs).
rows() != m_ || (~rhs).
columns() != n_ )
2970 throw std::invalid_argument(
"Matrix sizes do not match" );
2972 if( (~rhs).canAlias(
this ) ) {
2973 typename MT::ResultType tmp( ~rhs );
2997 template<
typename Type >
2998 template<
typename MT
3000 inline DynamicMatrix<Type,true>& DynamicMatrix<Type,true>::operator-=(
const Matrix<MT,SO>& rhs )
3004 if( (~rhs).
rows() != m_ || (~rhs).
columns() != n_ )
3005 throw std::invalid_argument(
"Matrix sizes do not match" );
3007 if( (~rhs).canAlias(
this ) ) {
3008 typename MT::ResultType tmp( ~rhs );
3032 template<
typename Type >
3033 template<
typename MT
3035 inline DynamicMatrix<Type,true>& DynamicMatrix<Type,true>::operator*=(
const Matrix<MT,SO>& rhs )
3037 if( (~rhs).
rows() != n_ )
3038 throw std::invalid_argument(
"Matrix sizes do not match" );
3040 DynamicMatrix tmp( *
this * (~rhs) );
3057 template<
typename Type >
3058 template<
typename Other >
3059 inline typename EnableIf< IsNumeric<Other>, DynamicMatrix<Type,true> >::Type&
3060 DynamicMatrix<Type,true>::operator*=( Other rhs )
3062 return operator=( (*
this) * rhs );
3076 template<
typename Type >
3077 template<
typename Other >
3078 inline typename EnableIf< IsNumeric<Other>, DynamicMatrix<Type,true> >::Type&
3079 DynamicMatrix<Type,true>::operator/=( Other rhs )
3083 return operator=( (*
this) / rhs );
3103 template<
typename Type >
3118 template<
typename Type >
3136 template<
typename Type >
3151 template<
typename Type >
3167 template<
typename Type >
3184 template<
typename Type >
3187 size_t nonzeros( 0UL );
3189 for(
size_t j=0UL; j<n_; ++j )
3190 for(
size_t i=0UL; i<m_; ++i )
3207 template<
typename Type >
3212 const size_t iend( (j+1UL)*mm_ );
3213 size_t nonzeros( 0UL );
3215 for(
size_t i=j*mm_; i<iend; ++i )
3231 template<
typename Type >
3236 for(
size_t j=0UL; j<n_; ++j )
3237 for(
size_t i=0UL; i<m_; ++i )
3238 reset( v_[i+j*mm_] );
3254 template<
typename Type >
3260 for(
size_t i=0UL; i<m_; ++i )
3261 reset( v_[i+j*mm_] );
3275 template<
typename Type >
3320 template<
typename Type >
3325 if( m == m_ && n == n_ )
return;
3327 const size_t mm( adjustRows( m ) );
3332 const size_t min_m(
min( m, m_ ) );
3333 const size_t min_n(
min( n, n_ ) );
3335 for(
size_t j=0UL; j<min_n; ++j )
3336 for(
size_t i=0UL; i<min_m; ++i )
3337 v[i+j*mm] = v_[i+j*mm_];
3339 if( IsNumeric<Type>::value ) {
3340 for(
size_t j=0UL; j<n; ++j )
3341 for(
size_t i=m; i<mm; ++i )
3349 else if( mm*n > capacity_ ) {
3352 if( IsNumeric<Type>::value ) {
3353 for(
size_t j=0UL; j<n; ++j )
3354 for(
size_t i=m; i<mm; ++i )
3386 template<
typename Type >
3389 resize( m_+m, n_+n, preserve );
3405 template<
typename Type >
3408 if( elements > capacity_ )
3414 std::copy( v_, v_+capacity_, tmp );
3416 if( IsNumeric<Type>::value ) {
3417 for(
size_t i=capacity_; i<elements; ++i )
3424 capacity_ = elements;
3437 template<
typename Type >
3440 DynamicMatrix tmp(
trans(*
this) );
3466 template<
typename Type >
3469 if( m_ != n_ )
return false;
3471 for(
size_t j=1UL; j<n_; ++j ) {
3472 for(
size_t i=0UL; i<j; ++i ) {
3490 template<
typename Type >
3493 if( m_ != n_ )
return false;
3495 for(
size_t j=1UL; j<n_; ++j ) {
3496 for(
size_t i=0UL; i<j; ++i ) {
3497 if( !
equal( v_[i+j*mm_], v_[j+i*mm_] ) )
3515 template<
typename Type >
3516 template<
typename Other >
3517 inline DynamicMatrix<Type,true>& DynamicMatrix<Type,true>::scale( Other scalar )
3519 for(
size_t j=0UL; j<n_; ++j )
3520 for(
size_t i=0UL; i<m_; ++i )
3521 v_[i+j*mm_] *= scalar;
3537 template<
typename Type >
3557 template<
typename Type >
3558 inline size_t DynamicMatrix<Type,true>::adjustRows(
size_t minRows )
const
3560 if( IsNumeric<Type>::value )
3561 return minRows + ( IT::size - ( minRows % IT::size ) ) % IT::size;
3562 else return minRows;
3587 template<
typename Type >
3588 template<
typename Other >
3591 return static_cast<const void*
>( this ) == static_cast<const void*>( alias );
3608 template<
typename Type >
3609 template<
typename Other >
3612 return static_cast<const void*
>( this ) == static_cast<const void*>( alias );
3631 template<
typename Type >
3632 inline typename DynamicMatrix<Type,true>::IntrinsicType
3642 return load( &v_[i+j*mm_] );
3660 template<
typename Type >
3661 template<
typename MT >
3662 inline typename DisableIf< typename DynamicMatrix<Type,true>::BLAZE_TEMPLATE VectorizedAssign<MT> >::Type
3669 const size_t iend( m_ &
size_t(-2) );
3671 for(
size_t j=0UL; j<n_; ++j ) {
3672 for(
size_t i=0UL; i<iend; i+=2UL ) {
3673 v_[i +j*mm_] = (~rhs)(i ,j);
3674 v_[i+1UL+j*mm_] = (~rhs)(i+1UL,j);
3677 v_[iend+j*mm_] = (~rhs)(iend,j);
3697 template<
typename Type >
3698 template<
typename MT >
3699 inline typename EnableIf< typename DynamicMatrix<Type,true>::BLAZE_TEMPLATE VectorizedAssign<MT> >::Type
3707 if( m_*n_ > (
cacheSize / (
sizeof(Type) * 3UL ) ) && !(~rhs).isAliased(
this ) )
3709 for(
size_t j=0UL; j<n_; ++j )
3710 for(
size_t i=0UL; i<m_; i+=IT::size )
3711 stream( &v_[i+j*mm_], (~rhs).
get(i,j) );
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_ ], (~rhs).
get(i ,j) );
3721 store( &v_[i+j*mm_+IT::size ], (~rhs).
get(i+IT::size ,j) );
3722 store( &v_[i+j*mm_+IT::size*2UL], (~rhs).
get(i+IT::size*2UL,j) );
3723 store( &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_], (~rhs).
get(i,j) );
3747 template<
typename Type >
3748 template<
typename MT >
3754 const size_t block( 16UL );
3756 for(
size_t jj=0UL; jj<n_; jj+=block ) {
3757 const size_t jend( ( n_<(jj+block) )?( n_ ):( jj+block ) );
3758 for(
size_t ii=0UL; ii<m_; ii+=block ) {
3759 const size_t iend( ( m_<(ii+block) )?( m_ ):( ii+block ) );
3760 for(
size_t j=jj; j<jend; ++j ) {
3761 for(
size_t i=ii; i<iend; ++i ) {
3762 v_[i+j*mm_] = (~rhs)(i,j);
3784 template<
typename Type >
3785 template<
typename MT >
3788 for(
size_t j=0UL; j<(~rhs).
columns(); ++j )
3789 for(
typename MT::ConstIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
3790 v_[element->index()+j*mm_] = element->value();
3808 template<
typename Type >
3809 template<
typename MT >
3812 for(
size_t i=0UL; i<(~rhs).
rows(); ++i )
3813 for(
typename MT::ConstIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
3814 v_[i+element->index()*mm_] = element->value();
3832 template<
typename Type >
3833 template<
typename MT >
3834 inline typename DisableIf< typename DynamicMatrix<Type,true>::BLAZE_TEMPLATE VectorizedAddAssign<MT> >::Type
3841 const size_t iend( m_ &
size_t(-2) );
3843 for(
size_t j=0UL; j<n_; ++j ) {
3844 for(
size_t i=0UL; i<iend; i+=2UL ) {
3845 v_[i +j*mm_] += (~rhs)(i ,j);
3846 v_[i+1UL+j*mm_] += (~rhs)(i+1UL,j);
3849 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 VectorizedAddAssign<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 >
3917 const size_t block( 16UL );
3919 for(
size_t jj=0UL; jj<n_; jj+=block ) {
3920 const size_t jend( ( n_<(jj+block) )?( n_ ):( jj+block ) );
3921 for(
size_t ii=0UL; ii<m_; ii+=block ) {
3922 const size_t iend( ( m_<(ii+block) )?( m_ ):( ii+block ) );
3923 for(
size_t j=jj; j<jend; ++j ) {
3924 for(
size_t i=ii; i<iend; ++i ) {
3925 v_[i+j*mm_] += (~rhs)(i,j);
3947 template<
typename Type >
3948 template<
typename MT >
3951 for(
size_t j=0UL; j<(~rhs).
columns(); ++j )
3952 for(
typename MT::ConstIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
3953 v_[element->index()+j*mm_] += element->value();
3971 template<
typename Type >
3972 template<
typename MT >
3975 for(
size_t i=0UL; i<(~rhs).
rows(); ++i )
3976 for(
typename MT::ConstIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
3977 v_[i+element->index()*mm_] += element->value();
3995 template<
typename Type >
3996 template<
typename MT >
3997 inline typename DisableIf< typename DynamicMatrix<Type,true>::BLAZE_TEMPLATE VectorizedSubAssign<MT> >::Type
4004 const size_t iend( m_ &
size_t(-2) );
4006 for(
size_t j=0UL; j<n_; ++j ) {
4007 for(
size_t i=0UL; i<iend; i+=2UL ) {
4008 v_[i +j*mm_] -= (~rhs)(i ,j);
4009 v_[i+1+j*mm_] -= (~rhs)(i+1,j);
4012 v_[iend+j*mm_] -= (~rhs)(iend,j);
4033 template<
typename Type >
4034 template<
typename MT >
4035 inline typename EnableIf< typename DynamicMatrix<Type,true>::BLAZE_TEMPLATE VectorizedSubAssign<MT> >::Type
4043 BLAZE_INTERNAL_ASSERT( ( m_ - ( m_ % (IT::size*4UL) ) ) == ( m_ &
size_t(-IT::size*4) ),
"Invalid end calculation" );
4044 const size_t iend( m_ &
size_t(-IT::size*4) );
4046 for(
size_t j=0UL; j<n_; ++j ) {
4047 for(
size_t i=0UL; i<iend; i+=IT::size*4UL ) {
4048 store( &v_[i+j*mm_ ],
load( &v_[i+j*mm_ ] ) - (~rhs).
get(i ,j) );
4049 store( &v_[i+j*mm_+IT::size ],
load( &v_[i+j*mm_+IT::size ] ) - (~rhs).
get(i+IT::size ,j) );
4050 store( &v_[i+j*mm_+IT::size*2UL],
load( &v_[i+j*mm_+IT::size*2UL] ) - (~rhs).
get(i+IT::size*2UL,j) );
4051 store( &v_[i+j*mm_+IT::size*3UL],
load( &v_[i+j*mm_+IT::size*3UL] ) - (~rhs).
get(i+IT::size*3UL,j) );
4053 for(
size_t i=iend; i<m_; i+=IT::size ) {
4054 store( &v_[i+j*mm_],
load( &v_[i+j*mm_] ) - (~rhs).
get(i,j) );
4074 template<
typename Type >
4075 template<
typename MT >
4078 const size_t block( 16UL );
4080 for(
size_t jj=0UL; jj<n_; jj+=block ) {
4081 const size_t jend( ( n_<(jj+block) )?( n_ ):( jj+block ) );
4082 for(
size_t ii=0UL; ii<m_; ii+=block ) {
4083 const size_t iend( ( m_<(ii+block) )?( m_ ):( ii+block ) );
4084 for(
size_t j=jj; j<jend; ++j ) {
4085 for(
size_t i=ii; i<iend; ++i ) {
4086 v_[i+j*mm_] -= (~rhs)(i,j);
4108 template<
typename Type >
4109 template<
typename MT >
4112 for(
size_t j=0UL; j<(~rhs).
columns(); ++j )
4113 for(
typename MT::ConstIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
4114 v_[element->index()+j*mm_] -= element->value();
4132 template<
typename Type >
4133 template<
typename MT >
4136 for(
size_t i=0UL; i<(~rhs).
rows(); ++i )
4137 for(
typename MT::ConstIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
4138 v_[i+element->index()*mm_] -= element->value();
4159 template<
typename Type,
bool SO >
4160 inline bool isnan(
const DynamicMatrix<Type,SO>& m );
4162 template<
typename Type,
bool SO >
4163 inline void reset( DynamicMatrix<Type,SO>& m );
4165 template<
typename Type,
bool SO >
4166 inline void clear( DynamicMatrix<Type,SO>& m );
4168 template<
typename Type,
bool SO >
4169 inline bool isDefault(
const DynamicMatrix<Type,SO>& m );
4171 template<
typename Type,
bool SO >
4172 inline void swap( DynamicMatrix<Type,SO>& a, DynamicMatrix<Type,SO>& b ) ;
4184 template<
typename Type
4188 for(
size_t i=0UL; i<m.
rows(); ++i ) {
4189 for(
size_t j=0UL; j<m.
columns(); ++j )
4190 if(
isnan( m(i,j) ) )
return true;
4204 template<
typename Type
4220 template<
typename Type
4247 template<
typename Type
4252 for(
size_t i=0UL; i<m.
rows(); ++i )
4253 for(
size_t j=0UL; j<m.
columns(); ++j )
4254 if( !
isDefault( m(i,j) ) )
return false;
4257 for(
size_t j=0UL; j<m.
columns(); ++j )
4258 for(
size_t i=0UL; i<m.
rows(); ++i )
4259 if( !
isDefault( m(i,j) ) )
return false;
4276 template<
typename Type
4295 template<
typename T,
bool SO >
4296 struct IsResizable< DynamicMatrix<T,SO> > :
public TrueType
4302 template<
typename T,
bool SO >
4303 struct IsResizable< const DynamicMatrix<T,SO> > :
public TrueType
4309 template<
typename T,
bool SO >
4310 struct IsResizable< volatile DynamicMatrix<T,SO> > :
public TrueType
4316 template<
typename T,
bool SO >
4317 struct IsResizable< const volatile DynamicMatrix<T,SO> > :
public TrueType
4336 template<
typename T1,
bool SO,
typename T2,
size_t M,
size_t N >
4337 struct AddTrait< DynamicMatrix<T1,SO>, StaticMatrix<T2,M,N,SO> >
4339 typedef StaticMatrix< typename AddTrait<T1,T2>::Type, M, N, SO > Type;
4342 template<
typename T1,
bool SO1,
typename T2,
size_t M,
size_t N,
bool SO2 >
4343 struct AddTrait< DynamicMatrix<T1,SO1>, StaticMatrix<T2,M,N,SO2> >
4345 typedef StaticMatrix< typename AddTrait<T1,T2>::Type, M, N,
false > Type;
4348 template<
typename T1,
size_t M,
size_t N,
bool SO,
typename T2 >
4349 struct AddTrait< StaticMatrix<T1,M,N,SO>, DynamicMatrix<T2,SO> >
4351 typedef StaticMatrix< typename AddTrait<T1,T2>::Type, M, N, SO > Type;
4354 template<
typename T1,
size_t M,
size_t N,
bool SO1,
typename T2,
bool SO2 >
4355 struct AddTrait< StaticMatrix<T1,M,N,SO1>, DynamicMatrix<T2,SO2> >
4357 typedef StaticMatrix< typename AddTrait<T1,T2>::Type, M, N,
false > Type;
4360 template<
typename T1,
bool SO,
typename T2 >
4361 struct AddTrait< DynamicMatrix<T1,SO>, DynamicMatrix<T2,SO> >
4363 typedef DynamicMatrix< typename AddTrait<T1,T2>::Type , SO > Type;
4366 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
4367 struct AddTrait< DynamicMatrix<T1,SO1>, DynamicMatrix<T2,SO2> >
4369 typedef DynamicMatrix< typename AddTrait<T1,T2>::Type ,
false > Type;
4385 template<
typename T1,
bool SO,
typename T2,
size_t M,
size_t N >
4386 struct SubTrait< DynamicMatrix<T1,SO>, StaticMatrix<T2,M,N,SO> >
4388 typedef StaticMatrix< typename SubTrait<T1,T2>::Type, M, N, SO > Type;
4391 template<
typename T1,
bool SO1,
typename T2,
size_t M,
size_t N,
bool SO2 >
4392 struct SubTrait< DynamicMatrix<T1,SO1>, StaticMatrix<T2,M,N,SO2> >
4394 typedef StaticMatrix< typename SubTrait<T1,T2>::Type, M, N,
false > Type;
4397 template<
typename T1,
size_t M,
size_t N,
bool SO,
typename T2 >
4398 struct SubTrait< StaticMatrix<T1,M,N,SO>, DynamicMatrix<T2,SO> >
4400 typedef StaticMatrix< typename SubTrait<T1,T2>::Type, M, N, SO > Type;
4403 template<
typename T1,
size_t M,
size_t N,
bool SO1,
typename T2,
bool SO2 >
4404 struct SubTrait< StaticMatrix<T1,M,N,SO1>, DynamicMatrix<T2,SO2> >
4406 typedef StaticMatrix< typename SubTrait<T1,T2>::Type, M, N,
false > Type;
4409 template<
typename T1,
bool SO,
typename T2 >
4410 struct SubTrait< DynamicMatrix<T1,SO>, DynamicMatrix<T2,SO> >
4412 typedef DynamicMatrix< typename SubTrait<T1,T2>::Type , SO > Type;
4415 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
4416 struct SubTrait< DynamicMatrix<T1,SO1>, DynamicMatrix<T2,SO2> >
4418 typedef DynamicMatrix< typename SubTrait<T1,T2>::Type ,
false > Type;
4434 template<
typename T1,
bool SO,
typename T2 >
4435 struct MultTrait< DynamicMatrix<T1,SO>, T2 >
4437 typedef DynamicMatrix< typename MultTrait<T1,T2>::Type, SO > Type;
4441 template<
typename T1,
typename T2,
bool SO >
4442 struct MultTrait< T1, DynamicMatrix<T2,SO> >
4444 typedef DynamicMatrix< typename MultTrait<T1,T2>::Type, SO > Type;
4448 template<
typename T1,
bool SO,
typename T2,
size_t N >
4449 struct MultTrait< DynamicMatrix<T1,SO>, StaticVector<T2,N,false> >
4451 typedef DynamicVector< typename MultTrait<T1,T2>::Type,
false > Type;
4454 template<
typename T1,
size_t N,
typename T2,
bool SO >
4455 struct MultTrait< StaticVector<T1,N,true>, DynamicMatrix<T2,SO> >
4457 typedef DynamicVector< typename MultTrait<T1,T2>::Type,
true > Type;
4460 template<
typename T1,
bool SO,
typename T2 >
4461 struct MultTrait< DynamicMatrix<T1,SO>, DynamicVector<T2,false> >
4463 typedef DynamicVector< typename MultTrait<T1,T2>::Type,
false > Type;
4466 template<
typename T1,
typename T2,
bool SO >
4467 struct MultTrait< DynamicVector<T1,true>, DynamicMatrix<T2,SO> >
4469 typedef DynamicVector< typename MultTrait<T1,T2>::Type,
true > Type;
4472 template<
typename T1,
bool SO,
typename T2 >
4473 struct MultTrait< DynamicMatrix<T1,SO>, CompressedVector<T2,false> >
4475 typedef DynamicVector< typename MultTrait<T1,T2>::Type,
false > Type;
4478 template<
typename T1,
typename T2,
bool SO >
4479 struct MultTrait< CompressedVector<T1,true>, DynamicMatrix<T2,SO> >
4481 typedef DynamicVector< typename MultTrait<T1,T2>::Type,
true > Type;
4484 template<
typename T1,
bool SO1,
typename T2,
size_t M,
size_t N,
bool SO2 >
4485 struct MultTrait< DynamicMatrix<T1,SO1>, StaticMatrix<T2,M,N,SO2> >
4487 typedef DynamicMatrix< typename MultTrait<T1,T2>::Type, SO1 > Type;
4490 template<
typename T1,
size_t M,
size_t N,
bool SO1,
typename T2,
bool SO2 >
4491 struct MultTrait< StaticMatrix<T1,M,N,SO1>, DynamicMatrix<T2,SO2> >
4493 typedef DynamicMatrix< typename MultTrait<T1,T2>::Type, SO1 > Type;
4496 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
4497 struct MultTrait< DynamicMatrix<T1,SO1>, DynamicMatrix<T2,SO2> >
4499 typedef DynamicMatrix< typename MultTrait<T1,T2>::Type, SO1 > Type;
4515 template<
typename T1,
bool SO,
typename T2 >
4516 struct DivTrait< DynamicMatrix<T1,SO>, T2 >
4518 typedef DynamicMatrix< typename DivTrait<T1,T2>::Type , SO > Type;
4535 template<
typename T1,
bool SO,
typename T2 >
4536 struct MathTrait< DynamicMatrix<T1,SO>, DynamicMatrix<T2,SO> >
4538 typedef DynamicMatrix< typename MathTrait<T1,T2>::HighType, SO > HighType;
4539 typedef DynamicMatrix< typename MathTrait<T1,T2>::LowType , SO > LowType;
4555 template<
typename T1,
bool SO >
4556 struct RowTrait< DynamicMatrix<T1,SO> >
4558 typedef DynamicVector<T1,true> Type;
4574 template<
typename T1,
bool SO >
4575 struct ColumnTrait< DynamicMatrix<T1,SO> >
4577 typedef DynamicVector<T1,false> Type;