22 #ifndef _BLAZE_MATH_SPARSE_COMPRESSEDMATRIX_H_
23 #define _BLAZE_MATH_SPARSE_COMPRESSEDMATRIX_H_
180 template<
typename Type
195 using ElementBase::operator=;
205 struct FindIndex :
public std::binary_function<Element,size_t,bool>
207 inline bool operator()(
const Element& element,
size_t index )
const {
208 return element.index() < index;
210 inline bool operator()(
size_t index,
const Element& element )
const {
211 return index < element.index();
213 inline bool operator()(
const Element& element1,
const Element& element2 )
const {
214 return element1.index() < element2.index();
240 enum { canAlias = 0 };
249 explicit CompressedMatrix(
size_t m,
size_t n,
const std::vector<size_t>& nonzeros );
287 template<
typename Other >
291 template<
typename Other >
300 inline size_t rows()
const;
303 inline size_t capacity(
size_t i )
const;
305 inline size_t nonZeros(
size_t i )
const;
311 void resize (
size_t m,
size_t n,
bool preserve=
true );
312 inline void reserve(
size_t nonzeros );
313 void reserve(
size_t i,
size_t nonzeros );
326 inline void append (
size_t i,
size_t j,
const Type& value );
334 template<
typename Other >
inline bool isAliased (
const Other* alias )
const;
388 template<
typename Type,
bool SO >
403 template<
typename Type
425 template<
typename Type
432 , end_ ( begin_+(m+1UL) )
434 for(
size_t i=0UL; i<2UL*
m_+2UL; ++i )
449 template<
typename Type
456 , end_ ( begin_+(m+1UL) )
458 begin_[0UL] =
new Element[nonzeros];
459 for(
size_t i=1UL; i<(2UL*
m_+1UL); ++i )
475 template<
typename Type
481 , begin_( new
Iterator[2UL*m_+2UL] )
482 , end_ ( begin_+(m_+1UL) )
484 BLAZE_USER_ASSERT( nonzeros.size() == m,
"Size of capacity vector and number of rows don't match" );
486 size_t newCapacity( 0UL );
487 for( std::vector<size_t>::const_iterator it=nonzeros.begin(); it!=nonzeros.end(); ++it )
490 begin_[0UL] =
end_[0UL] =
new Element[newCapacity];
491 for(
size_t i=0UL; i<
m_; ++i ) {
503 template<
typename Type
509 , begin_ ( new
Iterator[2UL*m_+2UL] )
510 , end_ ( begin_+(m_+1UL) )
512 const size_t nonzeros( sm.
nonZeros() );
514 begin_[0UL] =
new Element[nonzeros];
515 for(
size_t i=0UL; i<
m_; ++i )
516 begin_[i+1UL] =
end_[i] = std::copy( sm.
begin(i), sm.
end(i), begin_[i] );
517 end_[
m_] = begin_[0UL]+nonzeros;
527 template<
typename Type
529 template<
typename MT
532 : m_ ( (~dm).
rows() )
535 , begin_ ( new
Iterator[2UL*m_+2UL] )
536 , end_ ( begin_+(m_+1UL) )
540 for(
size_t i=0UL; i<2UL*
m_+2UL; ++i )
553 template<
typename Type
555 template<
typename MT
558 : m_ ( (~sm).
rows() )
561 , begin_ ( new
Iterator[2UL*m_+2UL] )
562 , end_ ( begin_+(m_+1UL) )
566 const size_t nonzeros( (~sm).
nonZeros() );
568 begin_[0UL] =
new Element[nonzeros];
569 for(
size_t i=0UL; i<
m_; ++i )
589 template<
typename Type
593 delete [] begin_[0UL];
614 template<
typename Type
634 template<
typename Type
642 const ConstIterator pos( std::lower_bound( begin_[i], end_[i], j, FindIndex() ) );
644 if( pos == end_[i] || pos->index_ != j )
663 template<
typename Type
685 template<
typename Type
707 template<
typename Type
729 template<
typename Type
751 template<
typename Type
773 template<
typename Type
801 template<
typename Type
806 if( &rhs ==
this )
return *
this;
808 const size_t nonzeros( rhs.
nonZeros() );
810 if( rhs.
m_ > capacity_ || nonzeros > capacity() )
815 newBegin[0UL] =
new Element[nonzeros];
816 for(
size_t i=0UL; i<rhs.
m_; ++i ) {
817 newBegin[i+1UL] = newEnd[i] = std::copy( rhs.
begin_[i], rhs.
end_[i], newBegin[i] );
819 newEnd[rhs.
m_] = newBegin[0UL]+nonzeros;
823 delete [] newBegin[0UL];
828 for(
size_t i=0UL; i<rhs.
m_; ++i ) {
829 begin_[i+1UL] = end_[i] = std::copy( rhs.
begin_[i], rhs.
end_[i], begin_[i] );
850 template<
typename Type
852 template<
typename MT
882 template<
typename Type
884 template<
typename MT
892 (~rhs).
rows() > capacity_ ||
893 (~rhs).nonZeros() > capacity() ) {
918 template<
typename Type
920 template<
typename MT
927 if( (~rhs).
rows() != m_ || (~rhs).
columns() != n_ )
928 throw std::invalid_argument(
"Matrix sizes do not match" );
946 template<
typename Type
948 template<
typename MT
954 if( (~rhs).
rows() != m_ || (~rhs).
columns() != n_ )
955 throw std::invalid_argument(
"Matrix sizes do not match" );
973 template<
typename Type
975 template<
typename MT
980 if( (~rhs).
rows() != n_ )
981 throw std::invalid_argument(
"Matrix sizes do not match" );
998 template<
typename Type
1000 template<
typename Other >
1004 for(
size_t i=0UL; i<m_; ++i ) {
1006 for(
Iterator elem=begin(i); elem<endElem; ++elem )
1007 elem->value_ *= rhs;
1022 template<
typename Type
1024 template<
typename Other >
1036 const Tmp tmp( Tmp(1)/static_cast<Tmp>( rhs ) );
1037 for(
size_t i=0UL; i<m_; ++i ) {
1039 for(
Iterator elem=begin(i); elem<endElem; ++elem )
1040 elem->value_ *= tmp;
1044 for(
size_t i=0UL; i<m_; ++i ) {
1046 for(
Iterator elem=begin(i); elem<endElem; ++elem )
1047 elem->value_ /= rhs;
1069 template<
typename Type
1083 template<
typename Type
1097 template<
typename Type
1101 return end_[m_] - begin_[0UL];
1117 template<
typename Type
1122 return begin_[i+1UL] - begin_[i];
1132 template<
typename Type
1136 size_t nonzeros( 0UL );
1138 for(
size_t i=0UL; i<m_; ++i )
1139 nonzeros += nonZeros( i );
1157 template<
typename Type
1162 return end_[i] - begin_[i];
1172 template<
typename Type
1176 for(
size_t i=0UL; i<m_; ++i )
1177 end_[i] = begin_[i];
1189 template<
typename Type
1193 end_[0UL] = end_[m_];
1213 template<
typename Type
1221 const Iterator pos( std::lower_bound( begin_[i], end_[i], j, FindIndex() ) );
1223 if( pos != end_[i] && pos->index_ == j )
1224 throw std::invalid_argument(
"Bad access index" );
1226 if( begin_[i+1UL] - end_[i] != 0 ) {
1227 std::copy_backward( pos, end_[i], end_[i]+1 );
1228 pos->value_ = value;
1234 else if( end_[m_] - begin_[m_] != 0 ) {
1235 std::copy_backward( pos, end_[m_-1UL], end_[m_-1UL]+1 );
1237 pos->value_ = value;
1240 for(
size_t k=i+1UL; k<m_+1UL; ++k ) {
1248 size_t newCapacity( extendCapacity() );
1251 Iterator* newEnd = newBegin+capacity_+1UL;
1253 newBegin[0UL] =
new Element[newCapacity];
1255 for(
size_t k=0UL; k<i; ++k ) {
1256 const size_t nonzeros( end_[k] - begin_[k] );
1257 const size_t total( begin_[k+1UL] - begin_[k] );
1258 newEnd [k] = newBegin[k] + nonzeros;
1259 newBegin[k+1UL] = newBegin[k] + total;
1261 newEnd [i] = newBegin[i] + ( end_[i] - begin_[i] ) + 1;
1262 newBegin[i+1UL] = newBegin[i] + ( begin_[i+1] - begin_[i] ) + 1;
1263 for(
size_t k=i+1UL; k<m_; ++k ) {
1264 const size_t nonzeros( end_[k] - begin_[k] );
1265 const size_t total( begin_[k+1UL] - begin_[k] );
1266 newEnd [k] = newBegin[k] + nonzeros;
1267 newBegin[k+1UL] = newBegin[k] + total;
1270 newEnd[m_] = newEnd[capacity_] = newBegin[0UL]+newCapacity;
1272 Iterator tmp = std::copy( begin_[0UL], pos, newBegin[0UL] );
1273 tmp->value_ = value;
1275 std::copy( pos, end_[m_-1UL], tmp+1UL );
1279 delete [] newBegin[0UL];
1302 template<
typename Type
1307 return const_cast<Iterator>(
const_cast<const This&
>( *this ).
find( i, j ) );
1326 template<
typename Type
1331 const Iterator pos( std::lower_bound( begin_[i], end_[i], j, FindIndex() ) );
1332 if( pos != end_[i] && pos->index_ == j )
1334 else return end_[i];
1352 template<
typename Type
1356 if( m == m_ && n == n_ )
return;
1363 newBegin[0UL] = begin_[0UL];
1366 for(
size_t i=0UL; i<m_; ++i ) {
1367 newEnd [i] = end_ [i];
1368 newBegin[i+1UL] = begin_[i+1UL];
1370 for(
size_t i=m_; i<m; ++i ) {
1371 newBegin[i+1UL] = newEnd[i] = begin_[m_];
1375 for(
size_t i=0UL; i<m; ++i ) {
1376 newBegin[i+1UL] = newEnd[i] = begin_[0UL];
1380 newEnd[m] = end_[m_];
1393 for(
size_t i=0UL; i<m_; ++i )
1394 end_[i] = begin_[i];
1397 for(
size_t i=m_; i<m; ++i )
1398 begin_[i+1UL] = end_[i] = begin_[m_];
1403 for(
size_t i=0UL; i<m; ++i )
1404 end_[i] = std::lower_bound( begin_[i], end_[i], n, FindIndex() );
1407 for(
size_t i=0UL; i<m; ++i )
1408 end_[i] = begin_[i];
1430 template<
typename Type
1434 if( nonzeros > capacity() )
1435 reserveElements( nonzeros );
1454 template<
typename Type
1460 const size_t current( capacity(i) );
1462 if( current >= nonzeros )
return;
1464 const ptrdiff_t additional( nonzeros - current );
1466 if( end_[m_] - begin_[m_] < additional )
1468 const size_t newCapacity( begin_[m_] - begin_[0UL] + additional );
1472 Iterator* newEnd ( newBegin+m_+1UL );
1474 newBegin[0UL] =
new Element[newCapacity];
1475 newEnd [m_ ] = newBegin[0UL]+newCapacity;
1477 for(
size_t k=0UL; k<i; ++k ) {
1478 newEnd [k ] = std::copy( begin_[k], end_[k], newBegin[k] );
1479 newBegin[k+1UL] = newBegin[k] + capacity(k);
1481 newEnd [i ] = std::copy( begin_[i], end_[i], newBegin[i] );
1482 newBegin[i+1UL] = newBegin[i] + nonzeros;
1483 for(
size_t k=i+1UL; k<m_; ++k ) {
1484 newEnd [k ] = std::copy( begin_[k], end_[k], newBegin[k] );
1485 newBegin[k+1UL] = newBegin[k] + capacity(k);
1491 delete [] newBegin[0UL];
1497 begin_[m_] += additional;
1498 for(
size_t j=m_-1UL; j>i; --j ) {
1499 begin_[j] = std::copy_backward( begin_[j], end_[j], end_[j]+additional );
1500 end_ [j] += additional;
1512 template<
typename Type
1540 template<
typename Type
1544 for(
size_t i=0UL; i<
rows(); ++i ) {
1545 for(
ConstIterator element=begin_[i]; element!=end_[i]; ++element )
1546 if( element->index_ != i && !
isDefault( element->value_ ) )
1560 template<
typename Type
1564 if( m_ != n_ )
return false;
1566 for(
size_t i=0UL; i<
rows(); ++i ) {
1567 for(
ConstIterator element=begin_[i]; element!=end_[i]; ++element )
1569 const size_t index( element->index_ );
1574 const Iterator pos( std::lower_bound( begin_[index], end_[index], i, FindIndex() ) );
1575 if( pos == end_[index] || pos->index_ != i || !
equal( pos->value_, element->value_ ) )
1591 template<
typename Type
1593 template<
typename Other >
1596 for(
size_t i=0UL; i<m_; ++i )
1597 for(
Iterator element=begin_[i]; element!=end_[i]; ++element )
1598 element->value_ *= scalar;
1611 template<
typename Type
1613 template<
typename Other >
1618 for(
size_t i=0UL; i<size; ++i ) {
1619 Iterator pos = std::lower_bound( begin_[i], end_[i], i, FindIndex() );
1620 if( pos != end_[i] && pos->index_ == i )
1621 pos->value_ *= scalar;
1636 template<
typename Type
1657 template<
typename Type
1661 size_t nonzeros( 2UL*capacity()+1UL );
1678 template<
typename Type
1683 Iterator* newEnd = newBegin+m_+1UL;
1685 newBegin[0UL] =
new Element[nonzeros];
1687 for(
size_t k=0UL; k<m_; ++k ) {
1689 newEnd [k] = std::copy( begin_[k], end_[k], newBegin[k] );
1690 newBegin[k+1UL] = newBegin[k] + ( begin_[k+1UL] - begin_[k] );
1693 newEnd[m_] = newBegin[0UL]+nonzeros;
1696 delete [] newBegin[0UL];
1748 template<
typename Type
1755 BLAZE_USER_ASSERT( begin_[i] == end_[i] || j > ( end_[i]-1UL )->index_,
"Index is not strictly increasing" );
1757 end_[i]->value_ = value;
1758 end_[i]->index_ = j;
1777 template<
typename Type
1783 begin_[i+1UL] = end_[i];
1785 end_[i+1UL] = end_[i];
1804 template<
typename Type
1806 template<
typename Other >
1809 return static_cast<const void*
>( this ) == static_cast<const void*>( alias );
1825 template<
typename Type
1827 template<
typename MT
1831 size_t nonzeros( 0UL );
1833 for(
size_t i=1UL; i<=m_; ++i )
1834 begin_[i] = end_[i] = end_[m_];
1836 for(
size_t i=0UL; i<m_; ++i )
1838 begin_[i] = end_[i] = begin_[0UL]+nonzeros;
1840 for(
size_t j=0UL; j<n_; ++j )
1842 if( nonzeros == capacity() ) {
1843 reserveElements( extendCapacity() );
1844 for(
size_t k=i+1UL; k<=m_; ++k )
1845 begin_[k] = end_[k] = end_[m_];
1848 end_[i]->value_ = (~rhs)(i,j);
1851 end_[i]->index_ = j;
1858 begin_[m_] = begin_[0UL]+nonzeros;
1874 template<
typename Type
1876 template<
typename MT >
1879 for(
size_t i=0UL; i<(~rhs).
rows(); ++i ) {
1880 begin_[i+1UL] = end_[i] = std::copy( (~rhs).begin(i), (~rhs).end(i), begin_[i] );
1897 template<
typename Type
1899 template<
typename MT >
1902 typedef typename MT::ConstIterator RhsIterator;
1905 std::vector<size_t> rowLengths( m_, 0UL );
1906 for(
size_t j=0UL; j<n_; ++j ) {
1907 for( RhsIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
1908 ++rowLengths[element->index()];
1912 for(
size_t i=0UL; i<m_; ++i ) {
1913 begin_[i+1UL] = end_[i+1UL] = begin_[i] + rowLengths[i];
1917 for(
size_t j=0UL; j<n_; ++j ) {
1918 for( RhsIterator element=(~rhs).begin(j); element!=(~rhs).end(j); ++element )
1919 append( element->index(), j, element->value() );
1936 template<
typename Type
1938 template<
typename MT
1962 template<
typename Type
1964 template<
typename MT
1988 template<
typename Type
1990 template<
typename MT
2014 template<
typename Type
2016 template<
typename MT
2049 template<
typename Type >
2063 using ElementBase::operator=;
2073 struct FindIndex :
public std::binary_function<Element,size_t,bool>
2075 inline bool operator()(
const Element& element,
size_t index )
const {
2076 return element.index() < index;
2078 inline bool operator()(
size_t index,
const Element& element )
const {
2079 return index < element.index();
2081 inline bool operator()(
const Element& element1,
const Element& element2 )
const {
2082 return element1.index() < element2.index();
2090 typedef CompressedMatrix<Type,true>
This;
2097 typedef MatrixAccessProxy<This>
Reference;
2108 enum { canAlias = 0 };
2117 explicit CompressedMatrix(
size_t m,
size_t n,
const std::vector<size_t>& nonzeros );
2119 template<
typename MT,
bool SO >
inline CompressedMatrix(
const DenseMatrix<MT,SO>& dm );
2155 template<
typename Other >
2159 template<
typename Other >
2168 inline size_t rows()
const;
2169 inline size_t columns()
const;
2171 inline size_t capacity(
size_t j )
const;
2173 inline size_t nonZeros(
size_t j )
const;
2174 inline void reset();
2175 inline void clear();
2179 void resize (
size_t m,
size_t n,
bool preserve=
true );
2180 inline void reserve(
size_t nonzeros );
2181 void reserve(
size_t j,
size_t nonzeros );
2194 inline void append (
size_t i,
size_t j,
const Type& value );
2202 template<
typename Other >
inline bool isAliased (
const Other* alias )
const;
2203 template<
typename MT,
bool SO >
inline void assign (
const DenseMatrix<MT,SO>& rhs );
2206 template<
typename MT,
bool SO >
inline void addAssign(
const DenseMatrix<MT,SO>& rhs );
2208 template<
typename MT,
bool SO >
inline void subAssign(
const DenseMatrix<MT,SO>& rhs );
2231 static const Type
zero_;
2257 template<
typename Type >
2258 const Type CompressedMatrix<Type,true>::zero_ = Type();
2273 template<
typename Type >
2278 , begin_( new Iterator[2UL] )
2279 , end_ ( begin_+1UL )
2296 template<
typename Type >
2301 , begin_( new Iterator[2UL*n+2UL] )
2302 , end_ ( begin_+(n+1UL) )
2304 for(
size_t j=0UL; j<2UL*
n_+2UL; ++j )
2321 template<
typename Type >
2326 , begin_( new Iterator[2UL*n+2UL] )
2327 , end_ ( begin_+(n+1UL) )
2329 begin_[0UL] =
new Element[nonzeros];
2330 for(
size_t j=1UL; j<(2UL*
n_+1UL); ++j )
2348 template<
typename Type >
2353 , begin_( new Iterator[2UL*n_+2UL] )
2354 , end_ ( begin_+(n_+1UL) )
2356 BLAZE_USER_ASSERT( nonzeros.size() == n,
"Size of capacity vector and number of columns don't match" );
2358 size_t newCapacity( 0UL );
2359 for( std::vector<size_t>::const_iterator it=nonzeros.begin(); it!=nonzeros.end(); ++it )
2362 begin_[0UL] =
end_[0UL] =
new Element[newCapacity];
2363 for(
size_t j=0UL; j<
n_; ++j ) {
2377 template<
typename Type >
2381 , capacity_( sm.n_ )
2382 , begin_ ( new Iterator[2UL*n_+2UL] )
2383 , end_ ( begin_+(n_+1UL) )
2385 const size_t nonzeros( sm.nonZeros() );
2387 begin_[0UL] =
new Element[nonzeros];
2388 for(
size_t j=0UL; j<
n_; ++j )
2389 begin_[j+1UL] =
end_[j] = std::copy( sm.begin(j), sm.end(j), begin_[j] );
2390 end_[
n_] = begin_[0UL]+nonzeros;
2402 template<
typename Type >
2403 template<
typename MT
2406 : m_ ( (~dm).
rows() )
2409 , begin_ ( new Iterator[2UL*n_+2UL] )
2410 , end_ ( begin_+(n_+1UL) )
2414 for(
size_t j=0UL; j<2UL*n_+2UL; ++j )
2429 template<
typename Type >
2430 template<
typename MT
2433 : m_ ( (~sm).
rows() )
2436 , begin_ ( new Iterator[2UL*n_+2UL] )
2437 , end_ ( begin_+(n_+1UL) )
2441 const size_t nonzeros( (~sm).
nonZeros() );
2443 begin_[0UL] =
new Element[nonzeros];
2444 for(
size_t j=0UL; j<
n_; ++j )
2445 begin_[j+1UL] =
end_[j] = begin_[0UL];
2446 end_[
n_] = begin_[0UL]+nonzeros;
2466 template<
typename Type >
2469 delete [] begin_[0UL];
2492 template<
typename Type >
2493 inline typename CompressedMatrix<Type,true>::Reference
2499 return Reference( *
this, i, j );
2513 template<
typename Type >
2514 inline typename CompressedMatrix<Type,true>::ConstReference
2520 const ConstIterator pos( std::lower_bound( begin_[j], end_[j], i, FindIndex() ) );
2522 if( pos == end_[j] || pos->index_ != i )
2538 template<
typename Type >
2539 inline typename CompressedMatrix<Type,true>::Iterator
2556 template<
typename Type >
2557 inline typename CompressedMatrix<Type,true>::ConstIterator
2574 template<
typename Type >
2575 inline typename CompressedMatrix<Type,true>::ConstIterator
2592 template<
typename Type >
2593 inline typename CompressedMatrix<Type,true>::Iterator
2610 template<
typename Type >
2611 inline typename CompressedMatrix<Type,true>::ConstIterator
2628 template<
typename Type >
2629 inline typename CompressedMatrix<Type,true>::ConstIterator
2657 template<
typename Type >
2658 inline CompressedMatrix<Type,true>&
2661 if( &rhs ==
this )
return *
this;
2663 const size_t nonzeros( rhs.nonZeros() );
2665 if( rhs.n_ > capacity_ || nonzeros > capacity() )
2667 Iterator* newBegin(
new Iterator[2UL*rhs.n_+2UL] );
2668 Iterator* newEnd ( newBegin+(rhs.n_+1UL) );
2670 newBegin[0UL] =
new Element[nonzeros];
2671 for(
size_t j=0UL; j<rhs.n_; ++j ) {
2672 newBegin[j+1UL] = newEnd[j] = std::copy( rhs.begin_[j], rhs.end_[j], newBegin[j] );
2674 newEnd[rhs.n_] = newBegin[0UL]+nonzeros;
2678 delete [] newBegin[0UL];
2683 for(
size_t j=0UL; j<rhs.n_; ++j ) {
2684 begin_[j+1UL] = end_[j] = std::copy( rhs.begin_[j], rhs.end_[j], begin_[j] );
2707 template<
typename Type >
2708 template<
typename MT
2710 inline CompressedMatrix<Type,true>&
2715 if( CanAlias<MT>::value && (~rhs).isAliased(
this ) ) {
2716 CompressedMatrix tmp( rhs );
2740 template<
typename Type >
2741 template<
typename MT
2743 inline CompressedMatrix<Type,true>&
2748 if( ( CanAlias<MT>::value && (~rhs).isAliased(
this ) ) ||
2749 (~rhs).
columns() > capacity_ ||
2750 (~rhs).nonZeros() > capacity() ) {
2751 CompressedMatrix tmp( rhs );
2777 template<
typename Type >
2778 template<
typename MT
2784 if( (~rhs).
rows() != m_ || (~rhs).
columns() != n_ )
2785 throw std::invalid_argument(
"Matrix sizes do not match" );
2805 template<
typename Type >
2806 template<
typename MT
2812 if( (~rhs).
rows() != m_ || (~rhs).
columns() != n_ )
2813 throw std::invalid_argument(
"Matrix sizes do not match" );
2833 template<
typename Type >
2834 template<
typename MT
2836 inline CompressedMatrix<Type,true>&
2839 if( (~rhs).
rows() != n_ )
2840 throw std::invalid_argument(
"Matrix sizes do not match" );
2842 CompressedMatrix tmp( *
this * (~rhs) );
2859 template<
typename Type >
2860 template<
typename Other >
2861 inline typename EnableIf< IsNumeric<Other>, CompressedMatrix<Type,true> >::Type&
2864 for(
size_t j=0UL; j<n_; ++j ) {
2865 const Iterator endElem( end(j) );
2866 for( Iterator elem=begin(j); elem<endElem; ++elem )
2867 elem->value_ *= rhs;
2884 template<
typename Type >
2885 template<
typename Other >
2886 inline typename EnableIf< IsNumeric<Other>, CompressedMatrix<Type,true> >::Type&
2891 typedef typename DivTrait<Type,Other>::Type DT;
2892 typedef typename If< IsNumeric<DT>, DT, Other >::Type Tmp;
2896 if( IsNumeric<DT>::value && IsFloatingPoint<DT>::value ) {
2897 const Tmp tmp( Tmp(1)/static_cast<Tmp>( rhs ) );
2898 for(
size_t j=0UL; j<n_; ++j ) {
2899 const Iterator endElem( end(j) );
2900 for( Iterator elem=begin(j); elem<endElem; ++elem )
2901 elem->value_ *= tmp;
2905 for(
size_t j=0UL; j<n_; ++j ) {
2906 const Iterator endElem( end(j) );
2907 for( Iterator elem=begin(j); elem<endElem; ++elem )
2908 elem->value_ /= rhs;
2932 template<
typename Type >
2947 template<
typename Type >
2962 template<
typename Type >
2965 return end_[n_] - begin_[0UL];
2978 template<
typename Type >
2982 return begin_[j+1UL] - begin_[j];
2994 template<
typename Type >
2997 size_t nonzeros( 0UL );
2999 for(
size_t j=0UL; j<n_; ++j )
3000 nonzeros += nonZeros( j );
3015 template<
typename Type >
3019 return end_[j] - begin_[j];
3031 template<
typename Type >
3034 for(
size_t j=0UL; j<n_; ++j )
3035 end_[j] = begin_[j];
3049 template<
typename Type >
3052 end_[0UL] = end_[n_];
3074 template<
typename Type >
3075 inline typename CompressedMatrix<Type,true>::Iterator
3081 const Iterator pos( std::lower_bound( begin_[j], end_[j], i, FindIndex() ) );
3083 if( pos != end_[j] && pos->index_ == i )
3084 throw std::invalid_argument(
"Bad access index" );
3086 if( begin_[j+1UL] - end_[j] != 0 ) {
3087 std::copy_backward( pos, end_[j], end_[j]+1 );
3088 pos->value_ = value;
3094 else if( end_[n_] - begin_[n_] != 0 ) {
3095 std::copy_backward( pos, end_[n_-1UL], end_[n_-1]+1 );
3097 pos->value_ = value;
3100 for(
size_t k=j+1UL; k<n_+1UL; ++k ) {
3108 size_t newCapacity( extendCapacity() );
3110 Iterator* newBegin =
new Iterator[2UL*capacity_+2UL];
3111 Iterator* newEnd = newBegin+capacity_+1UL;
3113 newBegin[0UL] =
new Element[newCapacity];
3115 for(
size_t k=0UL; k<j; ++k ) {
3116 const size_t nonzeros( end_[k] - begin_[k] );
3117 const size_t total( begin_[k+1UL] - begin_[k] );
3118 newEnd [k] = newBegin[k] + nonzeros;
3119 newBegin[k+1UL] = newBegin[k] + total;
3121 newEnd [j] = newBegin[j] + ( end_[j] - begin_[j] ) + 1;
3122 newBegin[j+1UL] = newBegin[j] + ( begin_[j+1UL] - begin_[j] ) + 1;
3123 for(
size_t k=j+1UL; k<n_; ++k ) {
3124 const size_t nonzeros( end_[k] - begin_[k] );
3125 const size_t total( begin_[k+1UL] - begin_[k] );
3126 newEnd [k] = newBegin[k] + nonzeros;
3127 newBegin[k+1UL] = newBegin[k] + total;
3130 newEnd[n_] = newEnd[capacity_] = newBegin[0UL]+newCapacity;
3132 Iterator tmp = std::copy( begin_[0UL], pos, newBegin[0UL] );
3133 tmp->value_ = value;
3135 std::copy( pos, end_[n_-1UL], tmp+1UL );
3139 delete [] newBegin[0UL];
3164 template<
typename Type >
3165 inline typename CompressedMatrix<Type,true>::Iterator
3168 return const_cast<Iterator
>(
const_cast<const This&
>( *this ).find( i, j ) );
3189 template<
typename Type >
3190 inline typename CompressedMatrix<Type,true>::ConstIterator
3193 const Iterator pos( std::lower_bound( begin_[j], end_[j], i, FindIndex() ) );
3194 if( pos != end_[j] && pos->index_ == i )
3196 else return end_[j];
3216 template<
typename Type >
3219 if( m == m_ && n == n_ )
return;
3223 Iterator* newBegin(
new Iterator[2UL*n+2UL] );
3224 Iterator* newEnd ( newBegin+n+1 );
3226 newBegin[0UL] = begin_[0UL];
3229 for(
size_t j=0UL; j<n_; ++j ) {
3230 newEnd [j] = end_ [j];
3231 newBegin[j+1UL] = begin_[j+1UL];
3233 for(
size_t j=n_; j<n; ++j ) {
3234 newBegin[j+1UL] = newEnd[j] = begin_[n_];
3238 for(
size_t j=0UL; j<n; ++j ) {
3239 newBegin[j+1UL] = newEnd[j] = begin_[0UL];
3243 newEnd[n] = end_[n_];
3256 for(
size_t j=0UL; j<n_; ++j )
3257 end_[j] = begin_[j];
3260 for(
size_t j=n_; j<n; ++j )
3261 begin_[j+1UL] = end_[j] = begin_[n_];
3266 for(
size_t j=0UL; j<n; ++j )
3267 end_[j] = std::lower_bound( begin_[j], end_[j], m, FindIndex() );
3270 for(
size_t j=0UL; j<n; ++j )
3271 end_[j] = begin_[j];
3295 template<
typename Type >
3298 if( nonzeros > capacity() )
3299 reserveElements( nonzeros );
3317 template<
typename Type >
3322 const size_t current( capacity(j) );
3324 if( current >= nonzeros )
return;
3326 const ptrdiff_t additional( nonzeros - current );
3328 if( end_[n_] - begin_[n_] < additional )
3330 const size_t newCapacity( begin_[n_] - begin_[0UL] + additional );
3333 Iterator* newBegin(
new Iterator[2UL*n_+2UL] );
3334 Iterator* newEnd ( newBegin+n_+1UL );
3336 newBegin[0UL] =
new Element[newCapacity];
3337 newEnd [n_ ] = newBegin[0UL]+newCapacity;
3339 for(
size_t k=0UL; k<j; ++k ) {
3340 newEnd [k ] = std::copy( begin_[k], end_[k], newBegin[k] );
3341 newBegin[k+1UL] = newBegin[k] + capacity(k);
3343 newEnd [j ] = std::copy( begin_[j], end_[j], newBegin[j] );
3344 newBegin[j+1UL] = newBegin[j] + nonzeros;
3345 for(
size_t k=j+1UL; k<n_; ++k ) {
3346 newEnd [k ] = std::copy( begin_[k], end_[k], newBegin[k] );
3347 newBegin[k+1UL] = newBegin[k] + capacity(k);
3353 delete [] newBegin[0UL];
3359 begin_[n_] += additional;
3360 for(
size_t k=n_-1UL; k>j; --k ) {
3361 begin_[k] = std::copy_backward( begin_[k], end_[k], end_[k]+additional );
3362 end_ [k] += additional;
3376 template<
typename Type >
3379 CompressedMatrix tmp(
trans( *
this ) );
3405 template<
typename Type >
3408 for(
size_t j=0UL; j<
columns(); ++j ) {
3409 for( ConstIterator element=begin_[j]; element!=end_[j]; ++element )
3410 if( element->index_ != j && !
isDefault( element->value_ ) )
3426 template<
typename Type >
3429 if( m_ != n_ )
return false;
3431 for(
size_t j=0UL; j<
rows(); ++j ) {
3432 for( ConstIterator element=begin_[j]; element!=end_[j]; ++element )
3434 const size_t index( element->index_ );
3439 const Iterator pos( std::lower_bound( begin_[index], end_[index], j, FindIndex() ) );
3440 if( pos == end_[index] || pos->index_ != j || !
equal( pos->value_, element->value_ ) )
3458 template<
typename Type >
3459 template<
typename Other >
3462 for(
size_t j=0UL; j<n_; ++j )
3463 for( Iterator element=begin_[j]; element!=end_[j]; ++element )
3464 element->value_ *= scalar;
3479 template<
typename Type >
3480 template<
typename Other >
3485 for(
size_t j=0UL; j<size; ++j ) {
3486 Iterator pos = std::lower_bound( begin_[j], end_[j], j, FindIndex() );
3487 if( pos != end_[j] && pos->index_ == j )
3488 pos->value_ *= scalar;
3505 template<
typename Type >
3527 template<
typename Type >
3530 size_t nonzeros( 2UL*capacity()+1UL );
3549 template<
typename Type >
3552 Iterator* newBegin =
new Iterator[2UL*n_+2UL];
3553 Iterator* newEnd = newBegin+n_+1UL;
3555 newBegin[0UL] =
new Element[nonzeros];
3557 for(
size_t k=0UL; k<n_; ++k ) {
3559 newEnd [k] = std::copy( begin_[k], end_[k], newBegin[k] );
3560 newBegin[k+1UL] = newBegin[k] + ( begin_[k+1UL] - begin_[k] );
3563 newEnd[n_] = newBegin[0UL]+nonzeros;
3566 delete [] newBegin[0UL];
3620 template<
typename Type >
3626 BLAZE_USER_ASSERT( begin_[j] == end_[j] || i > ( end_[j]-1UL )->index_,
"Index is not strictly increasing" );
3628 end_[j]->value_ = value;
3629 end_[j]->index_ = i;
3650 template<
typename Type >
3655 begin_[j+1UL] = end_[j];
3657 end_[j+1UL] = end_[j];
3678 template<
typename Type >
3679 template<
typename Other >
3682 return static_cast<const void*
>( this ) == static_cast<const void*>( alias );
3700 template<
typename Type >
3701 template<
typename MT
3705 size_t nonzeros( 0UL );
3707 for(
size_t j=1UL; j<=n_; ++j )
3708 begin_[j] = end_[j] = end_[n_];
3710 for(
size_t j=0UL; j<n_; ++j )
3712 begin_[j] = end_[j] = begin_[0UL]+nonzeros;
3714 for(
size_t i=0UL; i<m_; ++i )
3716 if( nonzeros == capacity() ) {
3717 reserveElements( extendCapacity() );
3718 for(
size_t k=j+1UL; k<=n_; ++k )
3719 begin_[k] = end_[k] = end_[n_];
3722 end_[j]->value_ = (~rhs)(i,j);
3725 end_[j]->index_ = i;
3732 begin_[n_] = begin_[0UL]+nonzeros;
3750 template<
typename Type >
3751 template<
typename MT >
3754 for(
size_t j=0UL; j<(~rhs).
columns(); ++j ) {
3755 begin_[j+1UL] = end_[j] = std::copy( (~rhs).begin(j), (~rhs).end(j), begin_[j] );
3774 template<
typename Type >
3775 template<
typename MT >
3778 typedef typename MT::ConstIterator RhsIterator;
3781 std::vector<size_t> columnLengths( n_, 0UL );
3782 for(
size_t i=0UL; i<m_; ++i ) {
3783 for( RhsIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
3784 ++columnLengths[element->index()];
3788 for(
size_t j=0UL; j<n_; ++j ) {
3789 begin_[j+1UL] = end_[j+1UL] = begin_[j] + columnLengths[j];
3793 for(
size_t i=0UL; i<m_; ++i ) {
3794 for( RhsIterator element=(~rhs).begin(i); element!=(~rhs).end(i); ++element )
3795 append( i, element->index(), element->value() );
3814 template<
typename Type >
3815 template<
typename MT
3822 CompressedMatrix tmp( *
this + (~rhs) );
3841 template<
typename Type >
3842 template<
typename MT
3849 CompressedMatrix tmp( *
this + (~rhs) );
3868 template<
typename Type >
3869 template<
typename MT
3876 CompressedMatrix tmp( *
this - (~rhs) );
3895 template<
typename Type >
3896 template<
typename MT
3903 CompressedMatrix tmp( *
this - (~rhs) );
3925 template<
typename Type,
bool SO >
3926 inline bool isnan(
const CompressedMatrix<Type,SO>& m );
3928 template<
typename Type,
bool SO >
3929 inline void reset( CompressedMatrix<Type,SO>& m );
3931 template<
typename Type,
bool SO >
3932 inline void clear( CompressedMatrix<Type,SO>& m );
3934 template<
typename Type,
bool SO >
3935 inline bool isDefault(
const CompressedMatrix<Type,SO>& m );
3937 template<
typename Type,
bool SO >
3938 inline const CompressedMatrix<Type,SO>
inv(
const CompressedMatrix<Type,SO>& m );
3940 template<
typename Type,
bool SO >
3941 inline void swap( CompressedMatrix<Type,SO>& a, CompressedMatrix<Type,SO>& b ) ;
3953 template<
typename Type
3959 for(
size_t i=0UL; i<m.
rows(); ++i ) {
3960 for( ConstIterator element=m.
begin(i); element!=m.
end(i); ++element )
3961 if(
isnan( *element ) )
return true;
3975 template<
typename Type
3991 template<
typename Type
4018 template<
typename Type
4025 for(
size_t i=0UL; i<m.
rows(); ++i ) {
4026 for( ConstIterator element=m.
begin(i); element!=m.
end(i); ++element )
4027 if( !
isDefault( element->value() ) )
return false;
4031 for(
size_t j=0UL; j<m.
columns(); ++j ) {
4032 for( ConstIterator element=m.
begin(j); element!=m.
end(j); ++element )
4033 if( !
isDefault( element->value() ) )
return false;
4051 template<
typename Type
4069 template<
typename Type
4088 template<
typename T,
bool SO >
4089 struct IsResizable< CompressedMatrix<T,SO> > :
public TrueType
4095 template<
typename T,
bool SO >
4096 struct IsResizable< const CompressedMatrix<T,SO> > :
public TrueType
4102 template<
typename T,
bool SO >
4103 struct IsResizable< volatile CompressedMatrix<T,SO> > :
public TrueType
4109 template<
typename T,
bool SO >
4110 struct IsResizable< const volatile CompressedMatrix<T,SO> > :
public TrueType
4129 template<
typename T1,
bool SO,
typename T2,
size_t M,
size_t N >
4130 struct AddTrait< CompressedMatrix<T1,SO>, StaticMatrix<T2,M,N,SO> >
4132 typedef StaticMatrix< typename AddTrait<T1,T2>::Type, M, N, SO > Type;
4135 template<
typename T1,
bool SO1,
typename T2,
size_t M,
size_t N,
bool SO2 >
4136 struct AddTrait< CompressedMatrix<T1,SO1>, StaticMatrix<T2,M,N,SO2> >
4138 typedef StaticMatrix< typename AddTrait<T1,T2>::Type, M, N,
false > Type;
4141 template<
typename T1,
size_t M,
size_t N,
bool SO,
typename T2 >
4142 struct AddTrait< StaticMatrix<T1,M,N,SO>, CompressedMatrix<T2,SO> >
4144 typedef StaticMatrix< typename AddTrait<T1,T2>::Type, M, N, SO > Type;
4147 template<
typename T1,
size_t M,
size_t N,
bool SO1,
typename T2,
bool SO2 >
4148 struct AddTrait< StaticMatrix<T1,M,N,SO1>, CompressedMatrix<T2,SO2> >
4150 typedef StaticMatrix< typename AddTrait<T1,T2>::Type, M, N,
false > Type;
4153 template<
typename T1,
bool SO,
typename T2 >
4154 struct AddTrait< CompressedMatrix<T1,SO>, DynamicMatrix<T2,SO> >
4156 typedef DynamicMatrix< typename AddTrait<T1,T2>::Type , SO > Type;
4159 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
4160 struct AddTrait< CompressedMatrix<T1,SO1>, DynamicMatrix<T2,SO2> >
4162 typedef DynamicMatrix< typename AddTrait<T1,T2>::Type ,
false > Type;
4165 template<
typename T1,
bool SO,
typename T2 >
4166 struct AddTrait< DynamicMatrix<T1,SO>, CompressedMatrix<T2,SO> >
4168 typedef DynamicMatrix< typename AddTrait<T1,T2>::Type , SO > Type;
4171 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
4172 struct AddTrait< DynamicMatrix<T1,SO1>, CompressedMatrix<T2,SO2> >
4174 typedef DynamicMatrix< typename AddTrait<T1,T2>::Type ,
false > Type;
4177 template<
typename T1,
bool SO,
typename T2 >
4178 struct AddTrait< CompressedMatrix<T1,SO>, CompressedMatrix<T2,SO> >
4180 typedef CompressedMatrix< typename AddTrait<T1,T2>::Type , SO > Type;
4183 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
4184 struct AddTrait< CompressedMatrix<T1,SO1>, CompressedMatrix<T2,SO2> >
4186 typedef CompressedMatrix< typename AddTrait<T1,T2>::Type ,
false > Type;
4202 template<
typename T1,
bool SO,
typename T2,
size_t M,
size_t N >
4203 struct SubTrait< CompressedMatrix<T1,SO>, StaticMatrix<T2,M,N,SO> >
4205 typedef StaticMatrix< typename SubTrait<T1,T2>::Type, M, N, SO > Type;
4208 template<
typename T1,
bool SO1,
typename T2,
size_t M,
size_t N,
bool SO2 >
4209 struct SubTrait< CompressedMatrix<T1,SO1>, StaticMatrix<T2,M,N,SO2> >
4211 typedef StaticMatrix< typename SubTrait<T1,T2>::Type, M, N,
false > Type;
4214 template<
typename T1,
size_t M,
size_t N,
bool SO,
typename T2 >
4215 struct SubTrait< StaticMatrix<T1,M,N,SO>, CompressedMatrix<T2,SO> >
4217 typedef StaticMatrix< typename SubTrait<T1,T2>::Type, M, N, SO > Type;
4220 template<
typename T1,
size_t M,
size_t N,
bool SO1,
typename T2,
bool SO2 >
4221 struct SubTrait< StaticMatrix<T1,M,N,SO1>, CompressedMatrix<T2,SO2> >
4223 typedef StaticMatrix< typename SubTrait<T1,T2>::Type, M, N,
false > Type;
4226 template<
typename T1,
bool SO,
typename T2 >
4227 struct SubTrait< CompressedMatrix<T1,SO>, DynamicMatrix<T2,SO> >
4229 typedef DynamicMatrix< typename SubTrait<T1,T2>::Type , SO > Type;
4232 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
4233 struct SubTrait< CompressedMatrix<T1,SO1>, DynamicMatrix<T2,SO2> >
4235 typedef DynamicMatrix< typename SubTrait<T1,T2>::Type ,
false > Type;
4238 template<
typename T1,
bool SO,
typename T2 >
4239 struct SubTrait< DynamicMatrix<T1,SO>, CompressedMatrix<T2,SO> >
4241 typedef DynamicMatrix< typename SubTrait<T1,T2>::Type , SO > Type;
4244 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
4245 struct SubTrait< DynamicMatrix<T1,SO1>, CompressedMatrix<T2,SO2> >
4247 typedef DynamicMatrix< typename SubTrait<T1,T2>::Type ,
false > Type;
4250 template<
typename T1,
bool SO,
typename T2 >
4251 struct SubTrait< CompressedMatrix<T1,SO>, CompressedMatrix<T2,SO> >
4253 typedef CompressedMatrix< typename SubTrait<T1,T2>::Type , SO > Type;
4256 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
4257 struct SubTrait< CompressedMatrix<T1,SO1>, CompressedMatrix<T2,SO2> >
4259 typedef CompressedMatrix< typename SubTrait<T1,T2>::Type ,
false > Type;
4275 template<
typename T1,
bool SO,
typename T2 >
4276 struct MultTrait< CompressedMatrix<T1,SO>, T2 >
4278 typedef CompressedMatrix< typename MultTrait<T1,T2>::Type, SO > Type;
4282 template<
typename T1,
typename T2,
bool SO >
4283 struct MultTrait< T1, CompressedMatrix<T2,SO> >
4285 typedef CompressedMatrix< typename MultTrait<T1,T2>::Type, SO > Type;
4289 template<
typename T1,
bool SO,
typename T2,
size_t N >
4290 struct MultTrait< CompressedMatrix<T1,SO>, StaticVector<T2,N,false> >
4292 typedef DynamicVector< typename MultTrait<T1,T2>::Type,
false > Type;
4295 template<
typename T1,
size_t N,
typename T2,
bool SO >
4296 struct MultTrait< StaticVector<T1,N,true>, CompressedMatrix<T2,SO> >
4298 typedef DynamicVector< typename MultTrait<T1,T2>::Type,
true > Type;
4301 template<
typename T1,
bool SO,
typename T2 >
4302 struct MultTrait< CompressedMatrix<T1,SO>, DynamicVector<T2,false> >
4304 typedef DynamicVector< typename MultTrait<T1,T2>::Type,
false > Type;
4307 template<
typename T1,
typename T2,
bool SO >
4308 struct MultTrait< DynamicVector<T1,true>, CompressedMatrix<T2,SO> >
4310 typedef DynamicVector< typename MultTrait<T1,T2>::Type,
true > Type;
4313 template<
typename T1,
bool SO,
typename T2 >
4314 struct MultTrait< CompressedMatrix<T1,SO>, CompressedVector<T2,false> >
4316 typedef CompressedVector< typename MultTrait<T1,T2>::Type,
false > Type;
4319 template<
typename T1,
typename T2,
bool SO >
4320 struct MultTrait< CompressedVector<T1,true>, CompressedMatrix<T2,SO> >
4322 typedef CompressedVector< typename MultTrait<T1,T2>::Type,
true > Type;
4325 template<
typename T1,
bool SO1,
typename T2,
size_t M,
size_t N,
bool SO2 >
4326 struct MultTrait< CompressedMatrix<T1,SO1>, StaticMatrix<T2,M,N,SO2> >
4328 typedef DynamicMatrix< typename MultTrait<T1,T2>::Type, SO1 > Type;
4331 template<
typename T1,
size_t M,
size_t N,
bool SO1,
typename T2,
bool SO2 >
4332 struct MultTrait< StaticMatrix<T1,M,N,SO1>, CompressedMatrix<T2,SO2> >
4334 typedef DynamicMatrix< typename MultTrait<T1,T2>::Type, SO1 > Type;
4337 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
4338 struct MultTrait< CompressedMatrix<T1,SO1>, DynamicMatrix<T2,SO2> >
4340 typedef DynamicMatrix< typename MultTrait<T1,T2>::Type, SO1 > Type;
4343 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
4344 struct MultTrait< DynamicMatrix<T1,SO1>, CompressedMatrix<T2,SO2> >
4346 typedef DynamicMatrix< typename MultTrait<T1,T2>::Type, SO1 > Type;
4349 template<
typename T1,
bool SO1,
typename T2,
bool SO2 >
4350 struct MultTrait< CompressedMatrix<T1,SO1>, CompressedMatrix<T2,SO2> >
4352 typedef CompressedMatrix< typename MultTrait<T1,T2>::Type, SO1 > Type;
4368 template<
typename T1,
bool SO,
typename T2 >
4369 struct DivTrait< CompressedMatrix<T1,SO>, T2 >
4371 typedef CompressedMatrix< typename DivTrait<T1,T2>::Type, SO > Type;
4388 template<
typename T1,
bool SO,
typename T2 >
4389 struct MathTrait< CompressedMatrix<T1,SO>, CompressedMatrix<T2,SO> >
4391 typedef CompressedMatrix< typename MathTrait<T1,T2>::HighType, SO > HighType;
4392 typedef CompressedMatrix< typename MathTrait<T1,T2>::LowType , SO > LowType;