boost/ublas
2
0
Fork 0
mirror of https://github.com/boostorg/ublas.git synced 2026-02-25 16:52:09 +00:00
Code Issues Projects Releases Wiki Activity

Resize infrastructure

Browse Source 
WARNING Function parameter order changed

svn path=/trunk/boost/boost/numeric/ublas/; revision=25293
This commit is contained in:
Michael Stevens
2004-09-21 08:17:17 +00:00
parent c079337e6c
commit e43811ccf6
2 changed files with 86 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
include/boost/numeric/ublas/matrix_sparse.hpp
View File

@@ -264,23 +264,23 @@ namespace boost { namespace numeric { namespace ublas {
BOOST_UBLAS_INLINE
sparse_matrix ():
matrix_expression<self_type> (),
size1_ (0), size2_ (0), non_zeros_ (0), data_ () {}
size1_ (0), size2_ (0), data_ () {}
BOOST_UBLAS_INLINE
sparse_matrix (size_type size1, size_type size2, size_type non_zeros = 0):
matrix_expression<self_type> (),
size1_ (size1), size2_ (size2), non_zeros_ (max_nz (non_zeros)), data_ () {
detail::map_reserve (data (), non_zeros_);
size1_ (size1), size2_ (size2), data_ () {
detail::map_reserve (data (), max_nz (non_zeros));
}
BOOST_UBLAS_INLINE
sparse_matrix (const sparse_matrix &m):
matrix_expression<self_type> (),
size1_ (m.size1_), size2_ (m.size2_), non_zeros_ (m.non_zeros_), data_ (m.data_) {}
size1_ (m.size1_), size2_ (m.size2_), data_ (m.data_) {}
template<class AE>
BOOST_UBLAS_INLINE
sparse_matrix (const matrix_expression<AE> &ae, size_type non_zeros = 0):
matrix_expression<self_type> (),
size1_ (ae ().size1 ()), size2_ (ae ().size2 ()), non_zeros_ (max_nz (non_zeros)), data_ () {
detail::map_reserve (data (), non_zeros_);
size1_ (ae ().size1 ()), size2_ (ae ().size2 ()), data_ () {
detail::map_reserve (data (), max_nz (non_zeros));
matrix_assign (scalar_assign<true_reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
}
@@ -320,21 +320,18 @@ namespace boost { namespace numeric { namespace ublas {
}
public:
BOOST_UBLAS_INLINE
void resize (size_type size1, size_type size2, size_type non_zeros = 0, bool preserve = true) {
void resize (size_type size1, size_type size2, bool preserve = true) {
// FIXME preserve unimplemented
BOOST_UBLAS_CHECK (!preserve, internal_logic ());
size1_ = size1;
size2_ = size2;
non_zeros_ = max_nz (non_zeros);
data ().clear ();
detail::map_reserve (data (), non_zeros_);
}
// Reserving
BOOST_UBLAS_INLINE
void reserve (size_type non_zeros = 0, bool preserve = true) {
non_zeros_ = max_nz (non_zeros);
detail::map_reserve (data (), non_zeros_);
void reserve (size_type non_zeros, bool preserve = true) {
detail::map_reserve (data (), max_nz (non_zeros));
}
// Proxy support
@@ -379,7 +376,6 @@ namespace boost { namespace numeric { namespace ublas {
if (this != &m) {
size1_ = m.size1_;
size2_ = m.size2_;
non_zeros_ = m.non_zeros_;
data () = m.data ();
}
return *this;
@@ -392,8 +388,7 @@ namespace boost { namespace numeric { namespace ublas {
template<class AE>
BOOST_UBLAS_INLINE
sparse_matrix &operator = (const matrix_expression<AE> &ae) {
// return assign (self_type (ae, non_zeros_));
self_type temporary (ae, non_zeros_);
self_type temporary (ae, detail::map_capacity (data ()));
return assign_temporary (temporary);
}
template<class AE>
@@ -405,8 +400,7 @@ namespace boost { namespace numeric { namespace ublas {
template<class AE>
BOOST_UBLAS_INLINE
sparse_matrix& operator += (const matrix_expression<AE> &ae) {
// return assign (self_type (*this + ae, non_zeros_));
self_type temporary (*this + ae, non_zeros_);
self_type temporary (*this + ae, detail::map_capacity (data ()));
return assign_temporary (temporary);
}
template<class AE>
@@ -418,8 +412,7 @@ namespace boost { namespace numeric { namespace ublas {
template<class AE>
BOOST_UBLAS_INLINE
sparse_matrix& operator -= (const matrix_expression<AE> &ae) {
// return assign (self_type (*this - ae, non_zeros_));
self_type temporary (*this - ae, non_zeros_);
self_type temporary (*this - ae, detail::map_capacity (data ()));
return assign_temporary (temporary);
}
template<class AE>
@@ -447,7 +440,6 @@ namespace boost { namespace numeric { namespace ublas {
if (this != &m) {
std::swap (size1_, m.size1_);
std::swap (size2_, m.size2_);
std::swap (non_zeros_, m.non_zeros_);
data ().swap (m.data ());
}
}
@@ -1274,7 +1266,6 @@ namespace boost { namespace numeric { namespace ublas {
private:
size_type size1_;
size_type size2_;
size_type non_zeros_;
array_type data_;
static const value_type zero_;
};
@@ -1375,12 +1366,11 @@ namespace boost { namespace numeric { namespace ublas {
// Resizing
BOOST_UBLAS_INLINE
void resize (size_type size1, size_type size2, size_type non_zeros = 0, bool preserve = true) {
void resize (size_type size1, size_type size2, bool preserve = true) {
// FIXME preserve unimplemented
BOOST_UBLAS_CHECK (!preserve, internal_logic ());
size1_ = size1;
size2_ = size2;
non_zeros_ = non_zeros;
data ().clear ();
data () [functor_type::size1 (size1_, size2_)] = vector_data_value_type ();
}
@@ -2606,12 +2596,12 @@ namespace boost { namespace numeric { namespace ublas {
}
public:
BOOST_UBLAS_INLINE
void resize (size_type size1, size_type size2, size_type non_zeros = 0, bool preserve = true) {
void resize (size_type size1, size_type size2, bool preserve = true) {
// FIXME preserve unimplemented
BOOST_UBLAS_CHECK (!preserve, internal_logic ());
size1_ = size1;
size2_ = size2;
non_zeros_ = max_nz (non_zeros);
non_zeros_ = max_nz (non_zeros_);
filled1_ = 1;
filled2_ = 0;
index1_data ().resize (functor_type::size1 (size1_, size2_) + 1);
@@ -2622,17 +2612,22 @@ namespace boost { namespace numeric { namespace ublas {
// Reserving
BOOST_UBLAS_INLINE
void reserve (size_type non_zeros = 0, bool preserve = true) {
void reserve (size_type non_zeros, bool preserve = true) {
non_zeros_ = max_nz (non_zeros);
if (preserve) {
index2_data ().resize (non_zeros_, size_type ());
value_data ().resize (non_zeros_, value_type ());
filled1_ = (std::min) (non_zeros_ + 1, filled1_);
filled2_ = (std::min) (non_zeros_, filled2_);
}
else {
index2_data ().resize (non_zeros_);
value_data ().resize (non_zeros_);
filled1_ = 1;
filled2_ = 0;
}
}
BOOST_UBLAS_CHECK (index1_data () [filled1_ - 1] == k_based (filled2_), internal_logic ());
}
// Proxy support
#ifdef BOOST_UBLAS_STRICT_MATRIX_SPARSE
@@ -2799,7 +2794,7 @@ namespace boost { namespace numeric { namespace ublas {
void push_back (size_type i, size_type j, const_reference t) {
BOOST_UBLAS_CHECK (index1_data () [filled1_ - 1] == k_based (filled2_), internal_logic ());
if (filled2_ >= non_zeros_)
reserve (2 * non_zeros_);
reserve (2 * non_zeros_, true);
size_type element1 = functor_type::element1 (i, size1_, j, size2_);
size_type element2 = functor_type::element2 (i, size1_, j, size2_);
while (filled1_ < element1 + 2) {
@@ -2822,7 +2817,7 @@ namespace boost { namespace numeric { namespace ublas {
void insert (size_type i, size_type j, const_reference t) {
BOOST_UBLAS_CHECK (index1_data () [filled1_ - 1] == k_based (filled2_), internal_logic ());
if (filled2_ >= non_zeros_)
reserve (2 * non_zeros_);
reserve (2 * non_zeros_, true);
size_type element1 = functor_type::element1 (i, size1_, j, size2_);
size_type element2 = functor_type::element2 (i, size1_, j, size2_);
while (filled1_ < element1 + 2) {
@@ -3925,12 +3920,12 @@ namespace boost { namespace numeric { namespace ublas {
}
public:
BOOST_UBLAS_INLINE
void resize (size_type size1, size_type size2, size_type non_zeros = 0, bool preserve = true) {
void resize (size_type size1, size_type size2, bool preserve = true) {
// FIXME preserve unimplemented
BOOST_UBLAS_CHECK (!preserve, internal_logic ());
size1_ = size1;
size2_ = size2;
non_zeros_ = max_nz (non_zeros);
non_zeros_ = max_nz (non_zeros_);
index1_data ().resize (non_zeros_);
index2_data ().resize (non_zeros_);
value_data ().resize (non_zeros_);
@@ -3939,18 +3934,20 @@ namespace boost { namespace numeric { namespace ublas {
// Reserving
BOOST_UBLAS_INLINE
void reserve (size_type non_zeros = 0, bool preserve = true) {
void reserve (size_type non_zeros, bool preserve = true) {
sort (); // remove duplicate elements
non_zeros_ = max_nz (non_zeros);
if (preserve) {
index1_data ().resize (non_zeros_, size_type ());
index2_data ().resize (non_zeros_, size_type ());
value_data ().resize (non_zeros_, value_type ());
filled_ = (std::min) (non_zeros_, filled_);
}
else {
index1_data ().resize (non_zeros_);
index2_data ().resize (non_zeros_);
value_data ().resize (non_zeros_);
filled_ = 0;
}
}
@@ -4143,7 +4140,7 @@ namespace boost { namespace numeric { namespace ublas {
BOOST_UBLAS_INLINE
void push_back (size_type i, size_type j, const_reference t) {
if (filled_ >= non_zeros_)
reserve (2 * non_zeros_);
reserve (2 * non_zeros_, true);
size_type element1 = functor_type::element1 (i, size1_, j, size2_);
size_type element2 = functor_type::element2 (i, size1_, j, size2_);
if (filled_ == 0 ||
@@ -4160,7 +4157,7 @@ namespace boost { namespace numeric { namespace ublas {
BOOST_UBLAS_INLINE
void insert (size_type i, size_type j, const_reference t) {
if (filled_ >= non_zeros_)
reserve (2 * non_zeros_);
reserve (2 * non_zeros_, true);
size_type element1 = functor_type::element1 (i, size1_, j, size2_);
size_type element2 = functor_type::element2 (i, size1_, j, size2_);
++ filled_;

106
include/boost/numeric/ublas/vector_sparse.hpp
View File

@@ -257,23 +257,23 @@ namespace boost { namespace numeric { namespace ublas {
BOOST_UBLAS_INLINE
sparse_vector ():
vector_expression<self_type> (),
size_ (0), non_zeros_ (0), data_ () {}
size_ (0), data_ () {}
BOOST_UBLAS_INLINE
sparse_vector (size_type size, size_type non_zeros = 0):
vector_expression<self_type> (),
size_ (size), non_zeros_ (non_zeros), data_ () {
detail::map_reserve (data(), non_zeros_);
size_ (size), data_ () {
detail::map_reserve (data(), non_zeros);
}
BOOST_UBLAS_INLINE
sparse_vector (const sparse_vector &v):
vector_expression<self_type> (),
size_ (v.size_), non_zeros_ (v.non_zeros_), data_ (v.data_) {}
size_ (v.size_), data_ (v.data_) {}
template<class AE>
BOOST_UBLAS_INLINE
sparse_vector (const vector_expression<AE> &ae, size_type non_zeros = 0):
vector_expression<self_type> (),
size_ (ae ().size ()), non_zeros_ (non_zeros), data_ () {
detail::map_reserve (data(), non_zeros_);
size_ (ae ().size ()), data_ () {
detail::map_reserve (data(), non_zeros);
vector_assign (scalar_assign<true_reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
}
@@ -297,25 +297,20 @@ namespace boost { namespace numeric { namespace ublas {
// Resizing
BOOST_UBLAS_INLINE
void resize (size_type size, size_type non_zeros = 0, bool preserve = true) {
void resize (size_type size, bool preserve = true) {
size_ = size;
non_zeros_ = (std::max) (non_zeros, size_type (1));
non_zeros_ = (std::min) (non_zeros_, size_);
if (preserve) {
data ().erase (data ().lower_bound(size_), data ().end());
}
else {
data ().clear ();
}
detail::map_reserve (data (), non_zeros_);
}
// Reserving
BOOST_UBLAS_INLINE
void reserve (size_type non_zeros = 0, bool preserve = true) {
non_zeros_ = (std::max) (non_zeros, size_type (1));
non_zeros_ = (std::min) (non_zeros_, size_);
detail::map_reserve (data (), non_zeros_);
detail::map_reserve (data (), non_zeros);
}
// Proxy support
@@ -361,7 +356,6 @@ namespace boost { namespace numeric { namespace ublas {
sparse_vector &operator = (const sparse_vector &v) {
if (this != &v) {
size_ = v.size_;
non_zeros_ = v.non_zeros_;
data () = v.data ();
}
return *this;
@@ -374,8 +368,7 @@ namespace boost { namespace numeric { namespace ublas {
template<class AE>
BOOST_UBLAS_INLINE
sparse_vector &operator = (const vector_expression<AE> &ae) {
// return assign (self_type (ae, non_zeros_));
self_type temporary (ae, non_zeros_);
self_type temporary (ae, detail::map_capacity (data()));
return assign_temporary (temporary);
}
template<class AE>
@@ -387,8 +380,7 @@ namespace boost { namespace numeric { namespace ublas {
template<class AE>
BOOST_UBLAS_INLINE
sparse_vector &operator += (const vector_expression<AE> &ae) {
// return assign (self_type (*this + ae, non_zeros_));
self_type temporary (*this + ae, non_zeros_);
self_type temporary (*this + ae, detail::map_capacity (data()));
return assign_temporary (temporary);
}
template<class AE>
@@ -400,8 +392,7 @@ namespace boost { namespace numeric { namespace ublas {
template<class AE>
BOOST_UBLAS_INLINE
sparse_vector &operator -= (const vector_expression<AE> &ae) {
// return assign (self_type (*this - ae, non_zeros_));
self_type temporary (*this - ae, non_zeros_);
self_type temporary (*this - ae, detail::map_capacity (data()));
return assign_temporary (temporary);
}
template<class AE>
@@ -428,7 +419,6 @@ namespace boost { namespace numeric { namespace ublas {
void swap (sparse_vector &v) {
if (this != &v) {
std::swap (size_, v.size_);
std::swap (non_zeros_, v.non_zeros_);
data ().swap (v.data ());
}
}
@@ -679,7 +669,6 @@ namespace boost { namespace numeric { namespace ublas {
private:
size_type size_;
size_type non_zeros_;
array_type data_;
static const value_type zero_;
};
@@ -738,7 +727,6 @@ namespace boost { namespace numeric { namespace ublas {
vector_expression<self_type> (),
size_ (size), non_zeros_ (non_zeros), filled_ (0),
index_data_ (non_zeros), value_data_ (non_zeros) {
reserve (non_zeros_);
}
BOOST_UBLAS_INLINE
compressed_vector (const compressed_vector &v):
@@ -751,7 +739,6 @@ namespace boost { namespace numeric { namespace ublas {
vector_expression<self_type> (),
size_ (ae ().size ()), non_zeros_ (non_zeros), filled_ (0),
index_data_ (non_zeros), value_data_ (non_zeros) {
reserve (non_zeros_, false);
vector_assign (scalar_assign<true_reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
}
@@ -791,8 +778,20 @@ namespace boost { namespace numeric { namespace ublas {
// Resizing
BOOST_UBLAS_INLINE
void resize (size_type size, size_type non_zeros = 0, bool preserve = true) {
void resize (size_type size, bool preserve = true) {
// FIXME preserve unimplemented
BOOST_UBLAS_CHECK (!preserve, internal_logic ());
size_ = size;
non_zeros_ = (std::max) (non_zeros_, size_type (1));
non_zeros_ = (std::min) (non_zeros_, size_);
index_data (). resize (non_zeros_);
value_data (). resize (non_zeros_);
filled_ = 0;
}
// Reserving
BOOST_UBLAS_INLINE
void reserve (size_type non_zeros, bool preserve = true) {
non_zeros_ = (std::max) (non_zeros, size_type (1));
non_zeros_ = (std::min) (non_zeros_, size_);
if (preserve) {
@@ -807,12 +806,6 @@ namespace boost { namespace numeric { namespace ublas {
}
}
// Reserving
BOOST_UBLAS_INLINE
void reserve (size_type non_zeros = 0, bool preserve = true) {
resize (size_, non_zeros, preserve);
}
// Proxy support
#ifdef BOOST_UBLAS_STRICT_VECTOR_SPARSE
pointer find_element (size_type i) {
@@ -949,7 +942,7 @@ namespace boost { namespace numeric { namespace ublas {
BOOST_UBLAS_INLINE
void push_back (size_type i, const_reference t) {
if (filled_ >= non_zeros_)
reserve (2 * non_zeros_);
reserve (2 * non_zeros_, true);
if (filled_ == 0 || index_data () [filled_ - 1] < k_based (i)) {
++ filled_;
index_data () [filled_ - 1] = k_based (i);
@@ -961,7 +954,7 @@ namespace boost { namespace numeric { namespace ublas {
BOOST_UBLAS_INLINE
void insert (size_type i, const_reference t) {
if (filled_ >= non_zeros_)
reserve (2 * non_zeros_);
reserve (2 * non_zeros_, true);
iterator_type it (detail::lower_bound (index_data ().begin (), index_data ().begin () + filled_, k_based (i), std::less<size_type> ()));
difference_type n = it - index_data ().begin ();
BOOST_UBLAS_CHECK (filled_ == 0 || filled_ == size_type (n) || *it != k_based (i), external_logic ());
@@ -1288,7 +1281,6 @@ namespace boost { namespace numeric { namespace ublas {
vector_expression<self_type> (),
size_ (size), non_zeros_ (non_zeros), filled_ (0),
sorted_ (true), index_data_ (non_zeros), value_data_ (non_zeros) {
reserve (non_zeros_);
}
BOOST_UBLAS_INLINE
coordinate_vector (const coordinate_vector &v):
@@ -1301,7 +1293,6 @@ namespace boost { namespace numeric { namespace ublas {
vector_expression<self_type> (),
size_ (ae ().size ()), non_zeros_ (non_zeros), filled_ (0),
sorted_ (true), index_data_ (non_zeros), value_data_ (non_zeros) {
reserve (non_zeros_, false);
vector_assign (scalar_assign<true_reference, BOOST_UBLAS_TYPENAME AE::value_type> (), *this, ae);
}
@@ -1341,29 +1332,42 @@ namespace boost { namespace numeric { namespace ublas {
// Resizing
BOOST_UBLAS_INLINE
void resize (size_type size, size_type non_zeros = 0, bool preserve = true) {
non_zeros = (std::max) (non_zeros, size_type (1));
sort (); // remove duplicate elements.
non_zeros = (std::min) (non_zeros, size_);
void resize (size_type size, bool preserve = true) {
// FIXME preserve unimplemented
BOOST_UBLAS_CHECK (!preserve, internal_logic ());
if (preserve)
sort (); // remove duplicate elements.
non_zeros_ = (std::max) (non_zeros_, size_type (1));
non_zeros_ = (std::min) (non_zeros_, size);
if (preserve) {
sort ();
index_data (). resize (non_zeros, size_type ());
value_data (). resize (non_zeros, value_type ());
index_data (). resize (non_zeros_, size_type ());
value_data (). resize (non_zeros_, value_type ());
filled_ = (std::min) (non_zeros_, filled_);
}
}
else {
index_data (). resize (non_zeros);
value_data (). resize (non_zeros);
index_data (). resize (non_zeros_);
value_data (). resize (non_zeros_);
filled_ = 0;
}
size_ = size;
non_zeros_ = non_zeros_;
}
// Reserving
BOOST_UBLAS_INLINE
void reserve (size_type non_zeros = 0, bool preserve = true) {
resize (size_, non_zeros, preserve);
void reserve (size_type non_zeros, bool preserve = true) {
if (preserve)
sort (); // remove duplicate elements.
non_zeros_ = (std::max) (non_zeros, size_type (1));
non_zeros_ = (std::min) (non_zeros_, size_);
if (preserve) {
index_data (). resize (non_zeros_, size_type ());
value_data (). resize (non_zeros_, value_type ());
filled_ = (std::min) (non_zeros_, filled_);
}
else {
index_data (). resize (non_zeros_);
value_data (). resize (non_zeros_);
filled_ = 0;
}
}
// Proxy support
@@ -1533,7 +1537,7 @@ namespace boost { namespace numeric { namespace ublas {
BOOST_UBLAS_INLINE
void push_back (size_type i, const_reference t) {
if (filled_ >= non_zeros_)
reserve (2 * non_zeros_);
reserve (2 * non_zeros_, true);
if (filled_ == 0 || index_data () [filled_ - 1] < k_based (i)) {
++ filled_;
index_data () [filled_ - 1] = k_based (i);
@@ -1545,7 +1549,7 @@ namespace boost { namespace numeric { namespace ublas {
BOOST_UBLAS_INLINE
void insert (size_type i, const_reference t) {
if (filled_ >= non_zeros_)
reserve (2 * non_zeros_);
reserve (2 * non_zeros_, true);
++ filled_;
index_data () [filled_ - 1] = k_based (i);
value_data () [filled_ - 1] = t;