22 #ifndef _BLAZE_MATH_DENSE_DYNAMICMATRIX_H_
23 #define _BLAZE_MATH_DENSE_DYNAMICMATRIX_H_
161 template<
typename Type
200 explicit inline DynamicMatrix(
size_t m,
size_t n, Type init );
204 template<
typename Other,
size_t M,
size_t N >
221 inline Type*
data ();
222 inline const Type*
data ()
const;
223 inline Type*
data (
size_t i );
224 inline const Type*
data (
size_t i )
const;
237 template<
typename Other,
size_t M,
size_t N >
247 template<
typename Other >
249 operator*=( Other rhs );
251 template<
typename Other >
253 operator/=( Other rhs );
260 inline size_t rows()
const;
264 inline size_t capacity(
size_t i )
const;
266 inline size_t nonZeros(
size_t i )
const;
268 inline void reset(
size_t i );
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 );
277 template<
typename Other >
inline DynamicMatrix& scale( Other scalar );
286 template<
typename MT >
287 struct VectorizedAssign {
288 enum { value = vectorizable && MT::vectorizable &&
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 canAlias (
const Other* alias )
const;
323 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
326 template<
typename MT >
327 inline typename DisableIf< VectorizedAssign<MT> >::Type
328 assign(
const DenseMatrix<MT,SO>& rhs );
330 template<
typename MT >
331 inline typename EnableIf< VectorizedAssign<MT> >::Type
332 assign(
const DenseMatrix<MT,SO>& rhs );
334 template<
typename MT >
inline void assign(
const DenseMatrix<MT,!SO>& rhs );
335 template<
typename MT >
inline void assign(
const SparseMatrix<MT,SO>& rhs );
336 template<
typename MT >
inline void assign(
const SparseMatrix<MT,!SO>& rhs );
338 template<
typename MT >
339 inline typename DisableIf< VectorizedAddAssign<MT> >::Type
340 addAssign(
const DenseMatrix<MT,SO>& rhs );
342 template<
typename MT >
343 inline typename EnableIf< VectorizedAddAssign<MT> >::Type
344 addAssign(
const DenseMatrix<MT,SO>& rhs );
346 template<
typename MT >
inline void addAssign(
const DenseMatrix<MT,!SO>& rhs );
347 template<
typename MT >
inline void addAssign(
const SparseMatrix<MT,SO>& rhs );
348 template<
typename MT >
inline void addAssign(
const SparseMatrix<MT,!SO>& rhs );
350 template<
typename MT >
351 inline typename DisableIf< VectorizedSubAssign<MT> >::Type
352 subAssign(
const DenseMatrix<MT,SO>& rhs );
354 template<
typename MT >
355 inline typename EnableIf< VectorizedSubAssign<MT> >::Type
356 subAssign(
const DenseMatrix<MT,SO>& rhs );
358 template<
typename MT >
inline void subAssign(
const DenseMatrix<MT,!SO>& rhs );
359 template<
typename MT >
inline void subAssign(
const SparseMatrix<MT,SO>& rhs );
360 template<
typename MT >
inline void subAssign(
const SparseMatrix<MT,!SO>& rhs );
415 template<
typename Type
436 template<
typename Type
441 , nn_ ( adjustColumns( n ) )
442 , capacity_( m_*nn_ )
443 , v_ (
allocate<Type>( capacity_ ) )
446 for(
size_t i=0UL; i<
m_; ++i ) {
447 for(
size_t j=
n_; j<
nn_; ++j )
448 v_[i*nn_+j] = Type();
464 template<
typename Type
469 , nn_ ( adjustColumns( n ) )
470 , capacity_( m_*nn_ )
471 , v_ (
allocate<Type>( capacity_ ) )
473 for(
size_t i=0UL; i<m; ++i ) {
474 for(
size_t j=0UL; j<
n_; ++j )
478 for(
size_t j=n_; j<
nn_; ++j )
479 v_[i*nn_+j] = Type();
494 template<
typename Type
500 , capacity_( m_*nn_ )
501 , v_ (
allocate<Type>( capacity_ ) )
516 template<
typename Type
518 template<
typename MT
523 , nn_ ( adjustColumns( n_ ) )
524 , capacity_( m_*nn_ )
525 , v_ (
allocate<Type>( capacity_ ) )
530 for(
size_t i=0UL; i<
m_; ++i ) {
532 v_[i*nn_+j] = Type();
559 template<
typename Type
561 template<
typename Other
567 , nn_ ( adjustColumns( N ) )
568 , capacity_( m_*nn_ )
569 , v_ (
allocate<Type>( capacity_ ) )
571 for(
size_t i=0UL; i<M; ++i ) {
572 for(
size_t j=0UL; j<N; ++j )
573 v_[i*
nn_+j] = rhs[i][j];
576 for(
size_t j=N; j<
nn_; ++j )
577 v_[i*nn_+j] = Type();
595 template<
typename Type
619 template<
typename Type
638 template<
typename Type
655 template<
typename Type
669 template<
typename Type
684 template<
typename Type
700 template<
typename Type
721 template<
typename Type
743 template<
typename Type
765 template<
typename Type
787 template<
typename Type
793 return v_ + i*nn_ + n_;
809 template<
typename Type
815 return v_ + i*nn_ + n_;
831 template<
typename Type
837 return v_ + i*nn_ + n_;
869 template<
typename Type
871 template<
typename Other
876 resize( M, N,
false );
878 for(
size_t i=0UL; i<M; ++i )
879 for(
size_t j=0UL; j<N; ++j )
880 v_[i*nn_+j] = rhs[i][j];
893 template<
typename Type
897 for(
size_t i=0UL; i<m_; ++i )
898 for(
size_t j=0UL; j<n_; ++j )
915 template<
typename Type
919 if( &rhs ==
this )
return *
this;
921 resize( rhs.
m_, rhs.
n_,
false );
923 for(
size_t i=0UL; i<m_; ++i )
924 for(
size_t j=0UL; j<n_; ++j )
925 v_[i*nn_+j] = rhs(i,j);
941 template<
typename Type
943 template<
typename MT
949 if( (~rhs).canAlias(
this ) ) {
975 template<
typename Type
977 template<
typename MT
983 if( (~rhs).
rows() != m_ || (~rhs).
columns() != n_ )
984 throw std::invalid_argument(
"Matrix sizes do not match" );
986 if( (~rhs).canAlias(
this ) ) {
987 typename MT::ResultType tmp( ~rhs );
1009 template<
typename Type
1011 template<
typename MT
1017 if( (~rhs).
rows() != m_ || (~rhs).
columns() != n_ )
1018 throw std::invalid_argument(
"Matrix sizes do not match" );
1020 if( (~rhs).canAlias(
this ) ) {
1021 typename MT::ResultType tmp( ~rhs );
1043 template<
typename Type
1045 template<
typename MT
1049 if( (~rhs).
rows() != n_ )
1050 throw std::invalid_argument(
"Matrix sizes do not match" );
1067 template<
typename Type
1069 template<
typename Other >
1073 return operator=( (*
this) * rhs );
1085 template<
typename Type
1087 template<
typename Other >
1093 return operator=( (*
this) / rhs );
1111 template<
typename Type
1125 template<
typename Type
1142 template<
typename Type
1156 template<
typename Type
1176 template<
typename Type
1192 template<
typename Type
1196 size_t nonzeros( 0UL );
1198 for(
size_t i=0UL; i<m_; ++i )
1199 for(
size_t j=0UL; j<n_; ++j )
1214 template<
typename Type
1220 const size_t jend( (i+1UL)*nn_ );
1221 size_t nonzeros( 0UL );
1223 for(
size_t j=i*nn_; j<jend; ++j )
1237 template<
typename Type
1243 for(
size_t i=0UL; i<m_; ++i )
1244 for(
size_t j=0UL; j<n_; ++j )
1245 reset( v_[i*nn_+j] );
1261 template<
typename Type
1268 for(
size_t j=0UL; j<n_; ++j )
1269 reset( v_[i*nn_+j] );
1281 template<
typename Type
1324 template<
typename Type
1330 if( m == m_ && n == n_ )
return;
1332 const size_t nn( adjustColumns( n ) );
1337 const size_t min_m(
min( m, m_ ) );
1338 const size_t min_n(
min( n, n_ ) );
1340 for(
size_t i=0UL; i<min_m; ++i )
1341 for(
size_t j=0UL; j<min_n; ++j )
1342 v[i*nn+j] = v_[i*nn_+j];
1345 for(
size_t i=0UL; i<m; ++i )
1346 for(
size_t j=n; j<nn; ++j )
1354 else if( m*nn > capacity_ ) {
1358 for(
size_t i=0UL; i<m; ++i )
1359 for(
size_t j=n; j<nn; ++j )
1389 template<
typename Type
1393 resize( m_+m, n_+n, preserve );
1407 template<
typename Type
1411 if( elements > capacity_ )
1417 std::copy( v_, v_+capacity_, tmp );
1420 for(
size_t i=capacity_; i<elements; ++i )
1427 capacity_ = elements;
1438 template<
typename Type
1457 template<
typename Type
1485 template<
typename Type
1489 if( m_ != n_ )
return false;
1491 for(
size_t i=1UL; i<m_; ++i ) {
1492 for(
size_t j=0UL; j<i; ++j ) {
1508 template<
typename Type
1512 if( m_ != n_ )
return false;
1514 for(
size_t i=1UL; i<m_; ++i ) {
1515 for(
size_t j=0UL; j<i; ++j ) {
1516 if( !
equal( v_[i*nn_+j], v_[j*nn_+i] ) )
1532 template<
typename Type
1534 template<
typename Other >
1537 for(
size_t i=0UL; i<m_; ++i )
1538 for(
size_t j=0UL; j<n_; ++j )
1539 v_[i*nn_+j] *= scalar;
1553 template<
typename Type
1572 template<
typename Type
1577 return minColumns + ( IT::size - ( minColumns % IT::size ) ) % IT::size;
1578 else return minColumns;
1601 template<
typename Type
1603 template<
typename Other >
1606 return static_cast<const void*
>( this ) == static_cast<const void*>( alias );
1621 template<
typename Type
1623 template<
typename Other >
1626 return static_cast<const void*
>( this ) == static_cast<const void*>( alias );
1643 template<
typename Type
1655 return load( &v_[i*nn_+j] );
1671 template<
typename Type
1673 template<
typename MT >
1681 const size_t jend( n_ &
size_t(-2) );
1683 for(
size_t i=0UL; i<m_; ++i ) {
1684 for(
size_t j=0UL; j<jend; j+=2UL ) {
1685 v_[i*nn_+j ] = (~rhs)(i,j );
1686 v_[i*nn_+j+1UL] = (~rhs)(i,j+1UL);
1689 v_[i*nn_+jend] = (~rhs)(i,jend);
1707 template<
typename Type
1709 template<
typename MT >
1718 if( m_*n_ > (
cacheSize / (
sizeof(Type) * 3UL ) ) && !(~rhs).isAliased(
this ) )
1720 for(
size_t i=0UL; i<m_; ++i )
1721 for(
size_t j=0UL; j<n_; j+=IT::size )
1722 stream( &v_[i*nn_+j], (~rhs).
get(i,j) );
1726 BLAZE_INTERNAL_ASSERT( ( n_ - ( n_ % (IT::size*4UL) ) ) == ( n_ &
size_t(-IT::size*4) ),
"Invalid end calculation" );
1727 const size_t jend( n_ &
size_t(-IT::size*4) );
1729 for(
size_t i=0UL; i<m_; ++i ) {
1730 for(
size_t j=0UL; j<jend; j+=IT::size*4UL ) {
1731 store( &v_[i*nn_+j ], (~rhs).
get(i,j ) );
1732 store( &v_[i*nn_+j+IT::size ], (~rhs).
get(i,j+IT::size ) );
1733 store( &v_[i*nn_+j+IT::size*2UL], (~rhs).
get(i,j+IT::size*2UL) );
1734 store( &v_[i*nn_+j+IT::size*3UL], (~rhs).
get(i,j+IT::size*3UL) );
1736 for(
size_t j=jend; j<n_; j+=IT::size ) {
1737 store( &v_[i*nn_+j], (~rhs).
get(i,j) );
1756 template<
typename Type
1758 template<
typename MT >
1764 const size_t block( 16UL );
1766 for(
size_t ii=0UL; ii<m_; ii+=block ) {
1767 const size_t iend( ( m_<(ii+block) )?( m_ ):( ii+block ) );
1768 for(
size_t jj=0UL; jj<n_; jj+=block ) {
1769 const size_t jend( ( n_<(jj+block) )?( n_ ):( jj+block ) );
1770 for(
size_t i=ii; i<iend; ++i ) {
1771 for(
size_t j=jj; j<jend; ++j ) {
1772 v_[i*nn_+j] = (~rhs)(i,j);
1792 template<
typename Type
1794 template<
typename MT >
1800 for(
size_t i=0UL; i<m_; ++i )
1801 for(
typename MT::ConstIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
1802 v_[i*nn_+element->index()] = element->value();
1818 template<
typename Type
1820 template<
typename MT >
1826 for(
size_t j=0UL; j<n_; ++j )
1827 for(
typename MT::ConstIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
1828 v_[element->index()*nn_+j] = element->value();
1844 template<
typename Type
1846 template<
typename MT >
1854 const size_t jend( n_ &
size_t(-2) );
1856 for(
size_t i=0UL; i<m_; ++i ) {
1857 for(
size_t j=0UL; j<jend; j+=2UL ) {
1858 v_[i*nn_+j ] += (~rhs)(i,j );
1859 v_[i*nn_+j+1UL] += (~rhs)(i,j+1UL);
1862 v_[i*nn_+jend] += (~rhs)(i,jend);
1880 template<
typename Type
1882 template<
typename MT >
1891 BLAZE_INTERNAL_ASSERT( ( n_ - ( n_ % (IT::size*4UL) ) ) == ( n_ &
size_t(-IT::size*4) ),
"Invalid end calculation" );
1892 const size_t jend( n_ &
size_t(-IT::size*4) );
1894 for(
size_t i=0UL; i<m_; ++i ) {
1895 for(
size_t j=0UL; j<jend; j+=IT::size*4UL ) {
1896 store( &v_[i*nn_+j ],
load( &v_[i*nn_+j ] ) + (~rhs).
get(i,j ) );
1897 store( &v_[i*nn_+j+IT::size ],
load( &v_[i*nn_+j+IT::size ] ) + (~rhs).
get(i,j+IT::size ) );
1898 store( &v_[i*nn_+j+IT::size*2UL],
load( &v_[i*nn_+j+IT::size*2UL] ) + (~rhs).
get(i,j+IT::size*2UL) );
1899 store( &v_[i*nn_+j+IT::size*3UL],
load( &v_[i*nn_+j+IT::size*3UL] ) + (~rhs).
get(i,j+IT::size*3UL) );
1901 for(
size_t j=jend; j<n_; j+=IT::size ) {
1902 store( &v_[i*nn_+j],
load( &v_[i*nn_+j] ) + (~rhs).
get(i,j) );
1920 template<
typename Type
1922 template<
typename MT >
1928 const size_t block( 16UL );
1930 for(
size_t ii=0UL; ii<m_; ii+=block ) {
1931 const size_t iend( ( m_<(ii+block) )?( m_ ):( ii+block ) );
1932 for(
size_t jj=0UL; jj<n_; jj+=block ) {
1933 const size_t jend( ( n_<(jj+block) )?( n_ ):( jj+block ) );
1934 for(
size_t i=ii; i<iend; ++i ) {
1935 for(
size_t j=jj; j<jend; ++j ) {
1936 v_[i*nn_+j] += (~rhs)(i,j);
1956 template<
typename Type
1958 template<
typename MT >
1964 for(
size_t i=0UL; i<m_; ++i )
1965 for(
typename MT::ConstIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
1966 v_[i*nn_+element->index()] += element->value();
1982 template<
typename Type
1984 template<
typename MT >
1990 for(
size_t j=0UL; j<n_; ++j )
1991 for(
typename MT::ConstIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
1992 v_[element->index()*nn_+j] += element->value();
2008 template<
typename Type
2010 template<
typename MT >
2018 const size_t jend( n_ &
size_t(-2) );
2020 for(
size_t i=0UL; i<m_; ++i ) {
2021 for(
size_t j=0UL; j<jend; j+=2UL ) {
2022 v_[i*nn_+j ] -= (~rhs)(i,j );
2023 v_[i*nn_+j+1UL] -= (~rhs)(i,j+1UL);
2026 v_[i*nn_+jend] -= (~rhs)(i,jend);
2044 template<
typename Type
2046 template<
typename MT >
2055 BLAZE_INTERNAL_ASSERT( ( n_ - ( n_ % (IT::size*4UL) ) ) == ( n_ &
size_t(-IT::size*4) ),
"Invalid end calculation" );
2056 const size_t jend( n_ &
size_t(-IT::size*4) );
2058 for(
size_t i=0UL; i<m_; ++i ) {
2059 for(
size_t j=0UL; j<jend; j+=IT::size*4UL ) {
2060 store( &v_[i*nn_+j ],
load( &v_[i*nn_+j ] ) - (~rhs).
get(i,j ) );
2061 store( &v_[i*nn_+j+IT::size ],
load( &v_[i*nn_+j+IT::size ] ) - (~rhs).
get(i,j+IT::size ) );
2062 store( &v_[i*nn_+j+IT::size*2UL],
load( &v_[i*nn_+j+IT::size*2UL] ) - (~rhs).
get(i,j+IT::size*2UL) );
2063 store( &v_[i*nn_+j+IT::size*3UL],
load( &v_[i*nn_+j+IT::size*3UL] ) - (~rhs).
get(i,j+IT::size*3UL) );
2065 for(
size_t j=jend; j<n_; j+=IT::size ) {
2066 store( &v_[i*nn_+j],
load( &v_[i*nn_+j] ) - (~rhs).
get(i,j) );
2084 template<
typename Type
2086 template<
typename MT >
2092 const size_t block( 16UL );
2094 for(
size_t ii=0UL; ii<m_; ii+=block ) {
2095 const size_t iend( ( m_<(ii+block) )?( m_ ):( ii+block ) );
2096 for(
size_t jj=0UL; jj<n_; jj+=block ) {
2097 const size_t jend( ( n_<(jj+block) )?( n_ ):( jj+block ) );
2098 for(
size_t i=ii; i<iend; ++i ) {
2099 for(
size_t j=jj; j<jend; ++j ) {
2100 v_[i*nn_+j] -= (~rhs)(i,j);
2120 template<
typename Type
2122 template<
typename MT >
2128 for(
size_t i=0UL; i<m_; ++i )
2129 for(
typename MT::ConstIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
2130 v_[i*nn_+element->index()] -= element->value();
2146 template<
typename Type
2148 template<
typename MT >
2154 for(
size_t j=0UL; j<n_; ++j )
2155 for(
typename MT::ConstIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
2156 v_[element->index()*nn_+j] -= element->value();
2181 template<
typename Type >
2219 explicit inline DynamicMatrix(
size_t m,
size_t n, Type init );
2221 template<
typename MT,
bool SO >
inline DynamicMatrix(
const Matrix<MT,SO>& m );
2223 template<
typename Other,
size_t M,
size_t N >
2240 inline Type*
data ();
2241 inline const Type*
data ()
const;
2242 inline Type*
data (
size_t j );
2243 inline const Type*
data (
size_t j )
const;
2256 template<
typename Other,
size_t M,
size_t N >
2257 inline DynamicMatrix& operator=(
const Other (&rhs)[M][N] );
2261 template<
typename MT,
bool SO >
inline DynamicMatrix& operator= (
const Matrix<MT,SO>& rhs );
2262 template<
typename MT,
bool SO >
inline DynamicMatrix& operator+=(
const Matrix<MT,SO>& rhs );
2263 template<
typename MT,
bool SO >
inline DynamicMatrix& operator-=(
const Matrix<MT,SO>& rhs );
2264 template<
typename MT,
bool SO >
inline DynamicMatrix& operator*=(
const Matrix<MT,SO>& rhs );
2266 template<
typename Other >
2267 inline typename EnableIf< IsNumeric<Other>,
DynamicMatrix >::Type&
2268 operator*=( Other rhs );
2270 template<
typename Other >
2271 inline typename EnableIf< IsNumeric<Other>,
DynamicMatrix >::Type&
2272 operator/=( Other rhs );
2279 inline size_t rows()
const;
2280 inline size_t columns()
const;
2281 inline size_t spacing()
const;
2283 inline size_t capacity(
size_t j )
const;
2285 inline size_t nonZeros(
size_t j )
const;
2286 inline void reset();
2287 inline void reset(
size_t j );
2288 inline void clear();
2289 void resize (
size_t m,
size_t n,
bool preserve=
true );
2290 inline void extend (
size_t m,
size_t n,
bool preserve=
true );
2291 inline void reserve(
size_t elements );
2296 template<
typename Other >
inline DynamicMatrix& scale( Other scalar );
2304 template<
typename MT >
2305 struct VectorizedAssign {
2306 enum { value = vectorizable && MT::vectorizable &&
2307 IsSame<Type,typename MT::ElementType>::value };
2313 template<
typename MT >
2314 struct VectorizedAddAssign {
2315 enum { value = vectorizable && MT::vectorizable &&
2316 IsSame<Type,typename MT::ElementType>::value &&
2317 IntrinsicTrait<Type>::addition };
2323 template<
typename MT >
2324 struct VectorizedSubAssign {
2325 enum { value = vectorizable && MT::vectorizable &&
2326 IsSame<Type,typename MT::ElementType>::value &&
2327 IntrinsicTrait<Type>::subtraction };
2335 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
2336 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
2339 template<
typename MT >
2340 inline typename DisableIf< VectorizedAssign<MT> >::Type
2341 assign(
const DenseMatrix<MT,true>& rhs );
2343 template<
typename MT >
2344 inline typename EnableIf< VectorizedAssign<MT> >::Type
2345 assign(
const DenseMatrix<MT,true>& rhs );
2347 template<
typename MT >
inline void assign(
const DenseMatrix<MT,false>& rhs );
2348 template<
typename MT >
inline void assign(
const SparseMatrix<MT,true>& rhs );
2349 template<
typename MT >
inline void assign(
const SparseMatrix<MT,false>& rhs );
2351 template<
typename MT >
2352 inline typename DisableIf< VectorizedAddAssign<MT> >::Type
2353 addAssign(
const DenseMatrix<MT,true>& rhs );
2355 template<
typename MT >
2356 inline typename EnableIf< VectorizedAddAssign<MT> >::Type
2357 addAssign(
const DenseMatrix<MT,true>& rhs );
2359 template<
typename MT >
inline void addAssign(
const DenseMatrix<MT,false>& rhs );
2360 template<
typename MT >
inline void addAssign(
const SparseMatrix<MT,true>& rhs );
2361 template<
typename MT >
inline void addAssign(
const SparseMatrix<MT,false>& rhs );
2363 template<
typename MT >
2364 inline typename DisableIf< VectorizedSubAssign<MT> >::Type
2365 subAssign (
const DenseMatrix<MT,true>& rhs );
2367 template<
typename MT >
2368 inline typename EnableIf< VectorizedSubAssign<MT> >::Type
2369 subAssign (
const DenseMatrix<MT,true>& rhs );
2371 template<
typename MT >
inline void subAssign(
const DenseMatrix<MT,false>& rhs );
2372 template<
typename MT >
inline void subAssign(
const SparseMatrix<MT,true>& rhs );
2373 template<
typename MT >
inline void subAssign(
const SparseMatrix<MT,false>& rhs );
2381 inline size_t adjustRows(
size_t minRows )
const;
2428 template<
typename Type >
2450 template<
typename Type >
2453 , mm_ ( adjustRows( m ) )
2455 , capacity_( mm_*n_ )
2456 , v_ (
allocate<Type>( capacity_ ) )
2458 if( IsBuiltin<Type>::value ) {
2459 for(
size_t j=0UL; j<
n_; ++j )
2460 for(
size_t i=
m_; i<mm_; ++i ) {
2461 v_[i+j*mm_] = Type();
2479 template<
typename Type >
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 )
2491 if( IsBuiltin<Type>::value ) {
2492 for(
size_t i=m_; i<mm_; ++i )
2493 v_[i+j*mm_] = Type();
2510 template<
typename Type >
2515 , capacity_( mm_*n_ )
2516 , v_ (
allocate<Type>( capacity_ ) )
2533 template<
typename Type >
2534 template<
typename MT
2537 : m_ ( (~m).
rows() )
2538 , mm_ ( adjustRows( m_ ) )
2540 , capacity_( mm_*n_ )
2541 , v_ (
allocate<Type>( capacity_ ) )
2545 if( IsBuiltin<Type>::value ) {
2546 for(
size_t j=0UL; j<
n_; ++j )
2547 for(
size_t i=( IsSparseMatrix<MT>::value )?( 0UL ):( m_ ); i<mm_; ++i ) {
2548 v_[i+j*mm_] = Type();
2552 assign( *
this, ~m );
2579 template<
typename Type >
2580 template<
typename Other
2585 , mm_ ( adjustRows( M ) )
2587 , capacity_( mm_*n_ )
2588 , v_ (
allocate<Type>( capacity_ ) )
2590 for(
size_t j=0UL; j<N; ++j ) {
2591 for(
size_t i=0UL; i<M; ++i )
2592 v_[i+j*mm_] = rhs[i][j];
2594 if( IsBuiltin<Type>::value ) {
2595 for(
size_t i=M; i<mm_; ++i )
2596 v_[i+j*mm_] = Type();
2616 template<
typename Type >
2641 template<
typename Type >
2642 inline typename DynamicMatrix<Type,true>::Reference
2661 template<
typename Type >
2662 inline typename DynamicMatrix<Type,true>::ConstReference
2679 template<
typename Type >
2694 template<
typename Type >
2710 template<
typename Type >
2727 template<
typename Type >
2744 template<
typename Type >
2745 inline typename DynamicMatrix<Type,true>::Iterator
2762 template<
typename Type >
2763 inline typename DynamicMatrix<Type,true>::ConstIterator
2780 template<
typename Type >
2781 inline typename DynamicMatrix<Type,true>::ConstIterator
2798 template<
typename Type >
2799 inline typename DynamicMatrix<Type,true>::Iterator
2803 return v_ + j*mm_ + m_;
2816 template<
typename Type >
2817 inline typename DynamicMatrix<Type,true>::ConstIterator
2821 return v_ + j*mm_ + m_;
2834 template<
typename Type >
2835 inline typename DynamicMatrix<Type,true>::ConstIterator
2839 return v_ + j*mm_ + m_;
2873 template<
typename Type >
2874 template<
typename Other
2877 inline DynamicMatrix<Type,true>& DynamicMatrix<Type,true>::operator=(
const Other (&rhs)[M][N] )
2879 resize( M, N,
false );
2881 for(
size_t j=0UL; j<N; ++j )
2882 for(
size_t i=0UL; i<M; ++i )
2883 v_[i+j*mm_] = rhs[i][j];
2898 template<
typename Type >
2899 inline DynamicMatrix<Type,true>& DynamicMatrix<Type,true>::operator=( Type rhs )
2901 for(
size_t j=0UL; j<n_; ++j )
2902 for(
size_t i=0UL; i<m_; ++i )
2921 template<
typename Type >
2922 inline DynamicMatrix<Type,true>& DynamicMatrix<Type,true>::operator=(
const DynamicMatrix& rhs )
2924 if( &rhs ==
this )
return *
this;
2926 resize( rhs.m_, rhs.n_,
false );
2928 for(
size_t j=0UL; j<n_; ++j )
2929 for(
size_t i=0UL; i<m_; ++i )
2930 v_[i+j*mm_] = rhs(i,j);
2948 template<
typename Type >
2949 template<
typename MT
2951 inline DynamicMatrix<Type,true>& DynamicMatrix<Type,true>::operator=(
const Matrix<MT,SO>& rhs )
2955 if( (~rhs).canAlias(
this ) ) {
2956 DynamicMatrix tmp( ~rhs );
2961 if( IsSparseMatrix<MT>::value )
2983 template<
typename Type >
2984 template<
typename MT
2986 inline DynamicMatrix<Type,true>& DynamicMatrix<Type,true>::operator+=(
const Matrix<MT,SO>& rhs )
2990 if( (~rhs).
rows() != m_ || (~rhs).
columns() != n_ )
2991 throw std::invalid_argument(
"Matrix sizes do not match" );
2993 if( (~rhs).canAlias(
this ) ) {
2994 typename MT::ResultType tmp( ~rhs );
3018 template<
typename Type >
3019 template<
typename MT
3021 inline DynamicMatrix<Type,true>& DynamicMatrix<Type,true>::operator-=(
const Matrix<MT,SO>& rhs )
3025 if( (~rhs).
rows() != m_ || (~rhs).
columns() != n_ )
3026 throw std::invalid_argument(
"Matrix sizes do not match" );
3028 if( (~rhs).canAlias(
this ) ) {
3029 typename MT::ResultType tmp( ~rhs );
3053 template<
typename Type >
3054 template<
typename MT
3056 inline DynamicMatrix<Type,true>& DynamicMatrix<Type,true>::operator*=(
const Matrix<MT,SO>& rhs )
3058 if( (~rhs).
rows() != n_ )
3059 throw std::invalid_argument(
"Matrix sizes do not match" );
3061 DynamicMatrix tmp( *
this * (~rhs) );
3078 template<
typename Type >
3079 template<
typename Other >
3080 inline typename EnableIf< IsNumeric<Other>, DynamicMatrix<Type,true> >::Type&
3081 DynamicMatrix<Type,true>::operator*=( Other rhs )
3083 return operator=( (*
this) * rhs );
3097 template<
typename Type >
3098 template<
typename Other >
3099 inline typename EnableIf< IsNumeric<Other>, DynamicMatrix<Type,true> >::Type&
3100 DynamicMatrix<Type,true>::operator/=( Other rhs )
3104 return operator=( (*
this) / rhs );
3124 template<
typename Type >
3139 template<
typename Type >
3157 template<
typename Type >
3172 template<
typename Type >
3188 template<
typename Type >
3205 template<
typename Type >
3208 size_t nonzeros( 0UL );
3210 for(
size_t j=0UL; j<n_; ++j )
3211 for(
size_t i=0UL; i<m_; ++i )
3228 template<
typename Type >
3233 const size_t iend( (j+1UL)*mm_ );
3234 size_t nonzeros( 0UL );
3236 for(
size_t i=j*mm_; i<iend; ++i )
3252 template<
typename Type >
3257 for(
size_t j=0UL; j<n_; ++j )
3258 for(
size_t i=0UL; i<m_; ++i )
3259 reset( v_[i+j*mm_] );
3275 template<
typename Type >
3281 for(
size_t i=0UL; i<m_; ++i )
3282 reset( v_[i+j*mm_] );
3296 template<
typename Type >
3340 template<
typename Type >
3345 if( m == m_ && n == n_ )
return;
3347 const size_t mm( adjustRows( m ) );
3352 const size_t min_m(
min( m, m_ ) );
3353 const size_t min_n(
min( n, n_ ) );
3355 for(
size_t j=0UL; j<min_n; ++j )
3356 for(
size_t i=0UL; i<min_m; ++i )
3357 v[i+j*mm] = v_[i+j*mm_];
3359 if( IsBuiltin<Type>::value ) {
3360 for(
size_t j=0UL; j<n; ++j )
3361 for(
size_t i=m; i<mm; ++i )
3369 else if( mm*n > capacity_ ) {
3372 if( IsBuiltin<Type>::value ) {
3373 for(
size_t j=0UL; j<n; ++j )
3374 for(
size_t i=m; i<mm; ++i )
3406 template<
typename Type >
3409 resize( m_+m, n_+n, preserve );
3425 template<
typename Type >
3428 if( elements > capacity_ )
3434 std::copy( v_, v_+capacity_, tmp );
3436 if( IsBuiltin<Type>::value ) {
3437 for(
size_t i=capacity_; i<elements; ++i )
3444 capacity_ = elements;
3457 template<
typename Type >
3460 DynamicMatrix tmp(
trans(*
this) );
3477 template<
typename Type >
3506 template<
typename Type >
3509 if( m_ != n_ )
return false;
3511 for(
size_t j=1UL; j<n_; ++j ) {
3512 for(
size_t i=0UL; i<j; ++i ) {
3530 template<
typename Type >
3533 if( m_ != n_ )
return false;
3535 for(
size_t j=1UL; j<n_; ++j ) {
3536 for(
size_t i=0UL; i<j; ++i ) {
3537 if( !
equal( v_[i+j*mm_], v_[j+i*mm_] ) )
3555 template<
typename Type >
3556 template<
typename Other >
3557 inline DynamicMatrix<Type,true>& DynamicMatrix<Type,true>::scale( Other scalar )
3559 for(
size_t j=0UL; j<n_; ++j )
3560 for(
size_t i=0UL; i<m_; ++i )
3561 v_[i+j*mm_] *= scalar;
3577 template<
typename Type >
3597 template<
typename Type >
3598 inline size_t DynamicMatrix<Type,true>::adjustRows(
size_t minRows )
const
3600 if( IsBuiltin<Type>::value )
3601 return minRows + ( IT::size - ( minRows % IT::size ) ) % IT::size;
3602 else return minRows;
3627 template<
typename Type >
3628 template<
typename Other >
3631 return static_cast<const void*
>( this ) == static_cast<const void*>( alias );
3648 template<
typename Type >
3649 template<
typename Other >
3652 return static_cast<const void*
>( this ) == static_cast<const void*>( alias );
3671 template<
typename Type >
3672 inline typename DynamicMatrix<Type,true>::IntrinsicType
3682 return load( &v_[i+j*mm_] );
3700 template<
typename Type >
3701 template<
typename MT >
3702 inline typename DisableIf< typename DynamicMatrix<Type,true>::BLAZE_TEMPLATE VectorizedAssign<MT> >::Type
3709 const size_t iend( m_ &
size_t(-2) );
3711 for(
size_t j=0UL; j<n_; ++j ) {
3712 for(
size_t i=0UL; i<iend; i+=2UL ) {
3713 v_[i +j*mm_] = (~rhs)(i ,j);
3714 v_[i+1UL+j*mm_] = (~rhs)(i+1UL,j);
3717 v_[iend+j*mm_] = (~rhs)(iend,j);
3737 template<
typename Type >
3738 template<
typename MT >
3739 inline typename EnableIf< typename DynamicMatrix<Type,true>::BLAZE_TEMPLATE VectorizedAssign<MT> >::Type
3747 if( m_*n_ > (
cacheSize / (
sizeof(Type) * 3UL ) ) && !(~rhs).isAliased(
this ) )
3749 for(
size_t j=0UL; j<n_; ++j )
3750 for(
size_t i=0UL; i<m_; i+=IT::size )
3751 stream( &v_[i+j*mm_], (~rhs).
get(i,j) );
3755 BLAZE_INTERNAL_ASSERT( ( m_ - ( m_ % (IT::size*4UL) ) ) == ( m_ &
size_t(-IT::size*4) ),
"Invalid end calculation" );
3756 const size_t iend( m_ &
size_t(-IT::size*4) );
3758 for(
size_t j=0UL; j<n_; ++j ) {
3759 for(
size_t i=0UL; i<iend; i+=IT::size*4UL ) {
3760 store( &v_[i+j*mm_ ], (~rhs).
get(i ,j) );
3761 store( &v_[i+j*mm_+IT::size ], (~rhs).
get(i+IT::size ,j) );
3762 store( &v_[i+j*mm_+IT::size*2UL], (~rhs).
get(i+IT::size*2UL,j) );
3763 store( &v_[i+j*mm_+IT::size*3UL], (~rhs).
get(i+IT::size*3UL,j) );
3765 for(
size_t i=iend; i<m_; i+=IT::size ) {
3766 store( &v_[i+j*mm_], (~rhs).
get(i,j) );
3787 template<
typename Type >
3788 template<
typename MT >
3794 const size_t block( 16UL );
3796 for(
size_t jj=0UL; jj<n_; jj+=block ) {
3797 const size_t jend( ( n_<(jj+block) )?( n_ ):( jj+block ) );
3798 for(
size_t ii=0UL; ii<m_; ii+=block ) {
3799 const size_t iend( ( m_<(ii+block) )?( m_ ):( ii+block ) );
3800 for(
size_t j=jj; j<jend; ++j ) {
3801 for(
size_t i=ii; i<iend; ++i ) {
3802 v_[i+j*mm_] = (~rhs)(i,j);
3824 template<
typename Type >
3825 template<
typename MT >
3828 for(
size_t j=0UL; j<(~rhs).
columns(); ++j )
3829 for(
typename MT::ConstIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
3830 v_[element->index()+j*mm_] = element->value();
3848 template<
typename Type >
3849 template<
typename MT >
3852 for(
size_t i=0UL; i<(~rhs).
rows(); ++i )
3853 for(
typename MT::ConstIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
3854 v_[i+element->index()*mm_] = element->value();
3872 template<
typename Type >
3873 template<
typename MT >
3874 inline typename DisableIf< typename DynamicMatrix<Type,true>::BLAZE_TEMPLATE VectorizedAddAssign<MT> >::Type
3881 const size_t iend( m_ &
size_t(-2) );
3883 for(
size_t j=0UL; j<n_; ++j ) {
3884 for(
size_t i=0UL; i<iend; i+=2UL ) {
3885 v_[i +j*mm_] += (~rhs)(i ,j);
3886 v_[i+1UL+j*mm_] += (~rhs)(i+1UL,j);
3889 v_[iend+j*mm_] += (~rhs)(iend,j);
3909 template<
typename Type >
3910 template<
typename MT >
3911 inline typename EnableIf< typename DynamicMatrix<Type,true>::BLAZE_TEMPLATE VectorizedAddAssign<MT> >::Type
3919 BLAZE_INTERNAL_ASSERT( ( m_ - ( m_ % (IT::size*4UL) ) ) == ( m_ &
size_t(-IT::size*4) ),
"Invalid end calculation" );
3920 const size_t iend( m_ &
size_t(-IT::size*4) );
3922 for(
size_t j=0UL; j<n_; ++j ) {
3923 for(
size_t i=0UL; i<iend; i+=IT::size*4UL ) {
3924 store( &v_[i+j*mm_ ],
load( &v_[i+j*mm_ ] ) + (~rhs).
get(i ,j) );
3925 store( &v_[i+j*mm_+IT::size ],
load( &v_[i+j*mm_+IT::size ] ) + (~rhs).
get(i+IT::size ,j) );
3926 store( &v_[i+j*mm_+IT::size*2UL],
load( &v_[i+j*mm_+IT::size*2UL] ) + (~rhs).
get(i+IT::size*2UL,j) );
3927 store( &v_[i+j*mm_+IT::size*3UL],
load( &v_[i+j*mm_+IT::size*3UL] ) + (~rhs).
get(i+IT::size*3UL,j) );
3929 for(
size_t i=iend; i<m_; i+=IT::size ) {
3930 store( &v_[i+j*mm_],
load( &v_[i+j*mm_] ) + (~rhs).
get(i,j) );
3950 template<
typename Type >
3951 template<
typename MT >
3957 const size_t block( 16UL );
3959 for(
size_t jj=0UL; jj<n_; jj+=block ) {
3960 const size_t jend( ( n_<(jj+block) )?( n_ ):( jj+block ) );
3961 for(
size_t ii=0UL; ii<m_; ii+=block ) {
3962 const size_t iend( ( m_<(ii+block) )?( m_ ):( ii+block ) );
3963 for(
size_t j=jj; j<jend; ++j ) {
3964 for(
size_t i=ii; i<iend; ++i ) {
3965 v_[i+j*mm_] += (~rhs)(i,j);
3987 template<
typename Type >
3988 template<
typename MT >
3991 for(
size_t j=0UL; j<(~rhs).
columns(); ++j )
3992 for(
typename MT::ConstIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
3993 v_[element->index()+j*mm_] += element->value();
4011 template<
typename Type >
4012 template<
typename MT >
4015 for(
size_t i=0UL; i<(~rhs).
rows(); ++i )
4016 for(
typename MT::ConstIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
4017 v_[i+element->index()*mm_] += element->value();
4035 template<
typename Type >
4036 template<
typename MT >
4037 inline typename DisableIf< typename DynamicMatrix<Type,true>::BLAZE_TEMPLATE VectorizedSubAssign<MT> >::Type
4044 const size_t iend( m_ &
size_t(-2) );
4046 for(
size_t j=0UL; j<n_; ++j ) {
4047 for(
size_t i=0UL; i<iend; i+=2UL ) {
4048 v_[i +j*mm_] -= (~rhs)(i ,j);
4049 v_[i+1+j*mm_] -= (~rhs)(i+1,j);
4052 v_[iend+j*mm_] -= (~rhs)(iend,j);
4073 template<
typename Type >
4074 template<
typename MT >
4075 inline typename EnableIf< typename DynamicMatrix<Type,true>::BLAZE_TEMPLATE VectorizedSubAssign<MT> >::Type
4083 BLAZE_INTERNAL_ASSERT( ( m_ - ( m_ % (IT::size*4UL) ) ) == ( m_ &
size_t(-IT::size*4) ),
"Invalid end calculation" );
4084 const size_t iend( m_ &
size_t(-IT::size*4) );
4086 for(
size_t j=0UL; j<n_; ++j ) {
4087 for(
size_t i=0UL; i<iend; i+=IT::size*4UL ) {
4088 store( &v_[i+j*mm_ ],
load( &v_[i+j*mm_ ] ) - (~rhs).
get(i ,j) );
4089 store( &v_[i+j*mm_+IT::size ],
load( &v_[i+j*mm_+IT::size ] ) - (~rhs).
get(i+IT::size ,j) );
4090 store( &v_[i+j*mm_+IT::size*2UL],
load( &v_[i+j*mm_+IT::size*2UL] ) - (~rhs).
get(i+IT::size*2UL,j) );
4091 store( &v_[i+j*mm_+IT::size*3UL],
load( &v_[i+j*mm_+IT::size*3UL] ) - (~rhs).
get(i+IT::size*3UL,j) );
4093 for(
size_t i=iend; i<m_; i+=IT::size ) {
4094 store( &v_[i+j*mm_],
load( &v_[i+j*mm_] ) - (~rhs).
get(i,j) );
4114 template<
typename Type >
4115 template<
typename MT >
4118 const size_t block( 16UL );
4120 for(
size_t jj=0UL; jj<n_; jj+=block ) {
4121 const size_t jend( ( n_<(jj+block) )?( n_ ):( jj+block ) );
4122 for(
size_t ii=0UL; ii<m_; ii+=block ) {
4123 const size_t iend( ( m_<(ii+block) )?( m_ ):( ii+block ) );
4124 for(
size_t j=jj; j<jend; ++j ) {
4125 for(
size_t i=ii; i<iend; ++i ) {
4126 v_[i+j*mm_] -= (~rhs)(i,j);
4148 template<
typename Type >
4149 template<
typename MT >
4152 for(
size_t j=0UL; j<(~rhs).
columns(); ++j )
4153 for(
typename MT::ConstIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
4154 v_[element->index()+j*mm_] -= element->value();
4172 template<
typename Type >
4173 template<
typename MT >
4176 for(
size_t i=0UL; i<(~rhs).
rows(); ++i )
4177 for(
typename MT::ConstIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
4178 v_[i+element->index()*mm_] -= element->value();
4199 template<
typename Type,
bool SO >
4200 inline bool isnan(
const DynamicMatrix<Type,SO>& m );
4202 template<
typename Type,
bool SO >
4203 inline void reset( DynamicMatrix<Type,SO>& m );
4205 template<
typename Type,
bool SO >
4206 inline void clear( DynamicMatrix<Type,SO>& m );
4208 template<
typename Type,
bool SO >
4209 inline bool isDefault(
const DynamicMatrix<Type,SO>& m );
4211 template<
typename Type,
bool SO >
4212 inline const DynamicMatrix<Type,SO>
inv(
const DynamicMatrix<Type,SO>& m );
4214 template<
typename Type,
bool SO >
4215 inline void swap( DynamicMatrix<Type,SO>& a, DynamicMatrix<Type,SO>& b ) ;
4227 template<
typename Type
4231 for(
size_t i=0UL; i<m.
rows(); ++i ) {
4232 for(
size_t j=0UL; j<m.
columns(); ++j )
4233 if(
isnan( m(i,j) ) )
return true;
4247 template<
typename Type
4263 template<
typename Type
4290 template<
typename Type
4295 for(
size_t i=0UL; i<m.
rows(); ++i )
4296 for(
size_t j=0UL; j<m.
columns(); ++j )
4297 if( !
isDefault( m(i,j) ) )
return false;
4300 for(
size_t j=0UL; j<m.
columns(); ++j )
4301 for(
size_t i=0UL; i<m.
rows(); ++i )
4302 if( !
isDefault( m(i,j) ) )
return false;
4328 template<
typename Type
4349 template<
typename Type
4368 template<
typename T,
bool SO >
4369 struct IsResizable< DynamicMatrix<T,SO> > :
public TrueType
4375 template<
typename T,
bool SO >
4376 struct IsResizable< const DynamicMatrix<T,SO> > :
public TrueType
4382 template<
typename T,
bool SO >
4383 struct IsResizable< volatile DynamicMatrix<T,SO> > :
public TrueType
4389 template<
typename T,
bool SO >
4390 struct IsResizable< const volatile DynamicMatrix<T,SO> > :
public TrueType
4409 template<
typename T1,
bool SO,
typename T2,
size_t M,
size_t N >
4410 struct AddTrait< DynamicMatrix<T1,SO>, StaticMatrix<T2,M,N,SO> >
4412 typedef StaticMatrix< typename AddTrait<T1,T2>::Type, M, N, SO > Type;
4415 template<
typename T1,
bool SO1,
typename T2,
size_t M,
size_t N,
bool SO2 >
4416 struct AddTrait< DynamicMatrix<T1,SO1>, StaticMatrix<T2,M,N,SO2> >
4418 typedef StaticMatrix< typename AddTrait<T1,T2>::Type, M, N,
false > Type;
4421 template<
typename T1,
size_t M,
size_t N,
bool SO,
typename T2 >
4422 struct AddTrait< StaticMatrix<T1,M,N,SO>, DynamicMatrix<T2,SO> >
4424 typedef StaticMatrix< typename AddTrait<T1,T2>::Type, M, N, SO > Type;
4427 template<
typename T1,
size_t M,
size_t N,
bool SO1,
typename T2,
bool SO2 >
4428 struct AddTrait< StaticMatrix<T1,M,N,SO1>, DynamicMatrix<T2,SO2> >
4430 typedef StaticMatrix< typename AddTrait<T1,T2>::Type, M, N,
false > Type;
4433 template<
typename T1,
bool SO,
typename T2 >
4434 struct AddTrait< DynamicMatrix<T1,SO>, DynamicMatrix<T2,SO> >
4436 typedef DynamicMatrix< typename AddTrait<T1,T2>::Type , SO > Type;
4439 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
4440 struct AddTrait< DynamicMatrix<T1,SO1>, DynamicMatrix<T2,SO2> >
4442 typedef DynamicMatrix< typename AddTrait<T1,T2>::Type ,
false > Type;
4458 template<
typename T1,
bool SO,
typename T2,
size_t M,
size_t N >
4459 struct SubTrait< DynamicMatrix<T1,SO>, StaticMatrix<T2,M,N,SO> >
4461 typedef StaticMatrix< typename SubTrait<T1,T2>::Type, M, N, SO > Type;
4464 template<
typename T1,
bool SO1,
typename T2,
size_t M,
size_t N,
bool SO2 >
4465 struct SubTrait< DynamicMatrix<T1,SO1>, StaticMatrix<T2,M,N,SO2> >
4467 typedef StaticMatrix< typename SubTrait<T1,T2>::Type, M, N,
false > Type;
4470 template<
typename T1,
size_t M,
size_t N,
bool SO,
typename T2 >
4471 struct SubTrait< StaticMatrix<T1,M,N,SO>, DynamicMatrix<T2,SO> >
4473 typedef StaticMatrix< typename SubTrait<T1,T2>::Type, M, N, SO > Type;
4476 template<
typename T1,
size_t M,
size_t N,
bool SO1,
typename T2,
bool SO2 >
4477 struct SubTrait< StaticMatrix<T1,M,N,SO1>, DynamicMatrix<T2,SO2> >
4479 typedef StaticMatrix< typename SubTrait<T1,T2>::Type, M, N,
false > Type;
4482 template<
typename T1,
bool SO,
typename T2 >
4483 struct SubTrait< DynamicMatrix<T1,SO>, DynamicMatrix<T2,SO> >
4485 typedef DynamicMatrix< typename SubTrait<T1,T2>::Type , SO > Type;
4488 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
4489 struct SubTrait< DynamicMatrix<T1,SO1>, DynamicMatrix<T2,SO2> >
4491 typedef DynamicMatrix< typename SubTrait<T1,T2>::Type ,
false > Type;
4507 template<
typename T1,
bool SO,
typename T2 >
4508 struct MultTrait< DynamicMatrix<T1,SO>, T2 >
4510 typedef DynamicMatrix< typename MultTrait<T1,T2>::Type, SO > Type;
4514 template<
typename T1,
typename T2,
bool SO >
4515 struct MultTrait< T1, DynamicMatrix<T2,SO> >
4517 typedef DynamicMatrix< typename MultTrait<T1,T2>::Type, SO > Type;
4521 template<
typename T1,
bool SO,
typename T2,
size_t N >
4522 struct MultTrait< DynamicMatrix<T1,SO>, StaticVector<T2,N,false> >
4524 typedef DynamicVector< typename MultTrait<T1,T2>::Type,
false > Type;
4527 template<
typename T1,
size_t N,
typename T2,
bool SO >
4528 struct MultTrait< StaticVector<T1,N,true>, DynamicMatrix<T2,SO> >
4530 typedef DynamicVector< typename MultTrait<T1,T2>::Type,
true > Type;
4533 template<
typename T1,
bool SO,
typename T2 >
4534 struct MultTrait< DynamicMatrix<T1,SO>, DynamicVector<T2,false> >
4536 typedef DynamicVector< typename MultTrait<T1,T2>::Type,
false > Type;
4539 template<
typename T1,
typename T2,
bool SO >
4540 struct MultTrait< DynamicVector<T1,true>, DynamicMatrix<T2,SO> >
4542 typedef DynamicVector< typename MultTrait<T1,T2>::Type,
true > Type;
4545 template<
typename T1,
bool SO,
typename T2 >
4546 struct MultTrait< DynamicMatrix<T1,SO>, CompressedVector<T2,false> >
4548 typedef DynamicVector< typename MultTrait<T1,T2>::Type,
false > Type;
4551 template<
typename T1,
typename T2,
bool SO >
4552 struct MultTrait< CompressedVector<T1,true>, DynamicMatrix<T2,SO> >
4554 typedef DynamicVector< typename MultTrait<T1,T2>::Type,
true > Type;
4557 template<
typename T1,
bool SO1,
typename T2,
size_t M,
size_t N,
bool SO2 >
4558 struct MultTrait< DynamicMatrix<T1,SO1>, StaticMatrix<T2,M,N,SO2> >
4560 typedef DynamicMatrix< typename MultTrait<T1,T2>::Type, SO1 > Type;
4563 template<
typename T1,
size_t M,
size_t N,
bool SO1,
typename T2,
bool SO2 >
4564 struct MultTrait< StaticMatrix<T1,M,N,SO1>, DynamicMatrix<T2,SO2> >
4566 typedef DynamicMatrix< typename MultTrait<T1,T2>::Type, SO1 > Type;
4569 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
4570 struct MultTrait< DynamicMatrix<T1,SO1>, DynamicMatrix<T2,SO2> >
4572 typedef DynamicMatrix< typename MultTrait<T1,T2>::Type, SO1 > Type;
4588 template<
typename T1,
bool SO,
typename T2 >
4589 struct DivTrait< DynamicMatrix<T1,SO>, T2 >
4591 typedef DynamicMatrix< typename DivTrait<T1,T2>::Type , SO > Type;
4608 template<
typename T1,
bool SO,
typename T2 >
4609 struct MathTrait< DynamicMatrix<T1,SO>, DynamicMatrix<T2,SO> >
4611 typedef DynamicMatrix< typename MathTrait<T1,T2>::HighType, SO > HighType;
4612 typedef DynamicMatrix< typename MathTrait<T1,T2>::LowType , SO > LowType;
4628 template<
typename T1,
bool SO >
4629 struct RowTrait< DynamicMatrix<T1,SO> >
4631 typedef DynamicVector<T1,true> Type;
4647 template<
typename T1,
bool SO >
4648 struct ColumnTrait< DynamicMatrix<T1,SO> >
4650 typedef DynamicVector<T1,false> Type;