diff -rupN /hub/3rdparty/R2010b/151720/glnxa64/boost/include/boost/numeric/ublas/detail/matrix_assign.hpp ublas/detail/matrix_assign.hpp --- /hub/3rdparty/R2010b/151720/glnxa64/boost/include/boost/numeric/ublas/detail/matrix_assign.hpp 2009-12-01 14:03:26.000000000 -0500 +++ ublas/detail/matrix_assign.hpp 2009-12-04 16:32:56.307232000 -0500 @@ -74,21 +74,21 @@ namespace detail { if (it2 != it2_end && it2e != it2e_end) { size_type it2_index = it2.index2 (), it2e_index = it2e.index2 (); while (true) { - difference_type compare = it2_index - it2e_index; - if (compare == 0) { + difference_type compare2 = it2_index - it2e_index; + if (compare2 == 0) { ++ it2, ++ it2e; if (it2 != it2_end && it2e != it2e_end) { it2_index = it2.index2 (); it2e_index = it2e.index2 (); } else break; - } else if (compare < 0) { - increment (it2, it2_end, - compare); + } else if (compare2 < 0) { + increment (it2, it2_end, - compare2); if (it2 != it2_end) it2_index = it2.index2 (); else break; - } else if (compare > 0) { + } else if (compare2 > 0) { if (conformant_restrict_type::other (it2e.index1 (), it2e.index2 ())) if (*it2e != value_type/*zero*/()) index.push_back (std::pair (it2e.index1 (), it2e.index2 ())); @@ -177,21 +177,21 @@ namespace detail { if (it1 != it1_end && it1e != it1e_end) { size_type it1_index = it1.index1 (), it1e_index = it1e.index1 (); while (true) { - difference_type compare = it1_index - it1e_index; - if (compare == 0) { + difference_type compare2 = it1_index - it1e_index; + if (compare2 == 0) { ++ it1, ++ it1e; if (it1 != it1_end && it1e != it1e_end) { it1_index = it1.index1 (); it1e_index = it1e.index1 (); } else break; - } else if (compare < 0) { - increment (it1, it1_end, - compare); + } else if (compare2 < 0) { + increment (it1, it1_end, - compare2); if (it1 != it1_end) it1_index = it1.index1 (); else break; - } else if (compare > 0) { + } else if (compare2 > 0) { if (conformant_restrict_type::other (it1e.index1 (), it1e.index2 ())) if (*it1e != value_type/*zero*/()) index.push_back (std::pair (it1e.index1 (), it1e.index2 ())); @@ -993,8 +993,8 @@ namespace detail { if (it2 != it2_end && it2e != it2e_end) { size_type it2_index = it2.index2 (), it2e_index = it2e.index2 (); while (true) { - difference_type compare = it2_index - it2e_index; - if (compare == 0) { + difference_type compare2 = it2_index - it2e_index; + if (compare2 == 0) { functor_type::apply (*it2, *it2e); ++ it2, ++ it2e; if (it2 != it2_end && it2e != it2e_end) { @@ -1002,18 +1002,18 @@ namespace detail { it2e_index = it2e.index2 (); } else break; - } else if (compare < 0) { + } else if (compare2 < 0) { if (!functor_type::computed) { functor_type::apply (*it2, value_type/*zero*/()); ++ it2; } else - increment (it2, it2_end, - compare); + increment (it2, it2_end, - compare2); if (it2 != it2_end) it2_index = it2.index2 (); else break; - } else if (compare > 0) { - increment (it2e, it2e_end, compare); + } else if (compare2 > 0) { + increment (it2e, it2e_end, compare2); if (it2e != it2e_end) it2e_index = it2e.index2 (); else @@ -1113,8 +1113,8 @@ namespace detail { if (it1 != it1_end && it1e != it1e_end) { size_type it1_index = it1.index1 (), it1e_index = it1e.index1 (); while (true) { - difference_type compare = it1_index - it1e_index; - if (compare == 0) { + difference_type compare2 = it1_index - it1e_index; + if (compare2 == 0) { functor_type::apply (*it1, *it1e); ++ it1, ++ it1e; if (it1 != it1_end && it1e != it1e_end) { @@ -1122,18 +1122,18 @@ namespace detail { it1e_index = it1e.index1 (); } else break; - } else if (compare < 0) { + } else if (compare2 < 0) { if (!functor_type::computed) { functor_type::apply (*it1, value_type/*zero*/()); // zeroing ++ it1; } else - increment (it1, it1_end, - compare); + increment (it1, it1_end, - compare2); if (it1 != it1_end) it1_index = it1.index1 (); else break; - } else if (compare > 0) { - increment (it1e, it1e_end, compare); + } else if (compare2 > 0) { + increment (it1e, it1e_end, compare2); if (it1e != it1e_end) it1e_index = it1e.index1 (); else @@ -1381,8 +1381,8 @@ namespace detail { if (it2 != it2_end && it2e != it2e_end) { size_type it2_index = it2.index2 (), it2e_index = it2e.index2 (); while (true) { - difference_type compare = it2_index - it2e_index; - if (compare == 0) { + difference_type compare2 = it2_index - it2e_index; + if (compare2 == 0) { functor_type::apply (*it2, *it2e); ++ it2, ++ it2e; if (it2 != it2_end && it2e != it2e_end) { @@ -1390,14 +1390,14 @@ namespace detail { it2e_index = it2e.index2 (); } else break; - } else if (compare < 0) { - increment (it2, it2_end, - compare); + } else if (compare2 < 0) { + increment (it2, it2_end, - compare2); if (it2 != it2_end) it2_index = it2.index2 (); else break; - } else if (compare > 0) { - increment (it2e, it2e_end, compare); + } else if (compare2 > 0) { + increment (it2e, it2e_end, compare2); if (it2e != it2e_end) it2e_index = it2e.index2 (); else @@ -1506,8 +1506,8 @@ namespace detail { if (it1 != it1_end && it1e != it1e_end) { size_type it1_index = it1.index1 (), it1e_index = it1e.index1 (); while (true) { - difference_type compare = it1_index - it1e_index; - if (compare == 0) { + difference_type compare2 = it1_index - it1e_index; + if (compare2 == 0) { functor_type::apply (*it1, *it1e); ++ it1, ++ it1e; if (it1 != it1_end && it1e != it1e_end) { @@ -1515,14 +1515,14 @@ namespace detail { it1e_index = it1e.index1 (); } else break; - } else if (compare < 0) { - increment (it1, it1_end, - compare); + } else if (compare2 < 0) { + increment (it1, it1_end, - compare2); if (it1 != it1_end) it1_index = it1.index1 (); else break; - } else if (compare > 0) { - increment (it1e, it1e_end, compare); + } else if (compare2 > 0) { + increment (it1e, it1e_end, compare2); if (it1e != it1e_end) it1e_index = it1e.index1 (); else diff -rupN /hub/3rdparty/R2010b/151720/glnxa64/boost/include/boost/numeric/ublas/matrix.hpp ublas/matrix.hpp --- /hub/3rdparty/R2010b/151720/glnxa64/boost/include/boost/numeric/ublas/matrix.hpp 2009-12-01 14:12:09.000000000 -0500 +++ ublas/matrix.hpp 2009-12-04 16:35:16.024571000 -0500 @@ -92,18 +92,18 @@ namespace boost { namespace numeric { na matrix_container (), size1_ (0), size2_ (0), data_ () {} BOOST_UBLAS_INLINE - matrix (size_type size1, size_type size2): + matrix (size_type size1_arg, size_type size2_arg): matrix_container (), - size1_ (size1), size2_ (size2), data_ (layout_type::storage_size (size1, size2)) { + size1_ (size1_arg), size2_ (size2_arg), data_ (layout_type::storage_size (size1_arg, size2_arg)) { } - matrix (size_type size1, size_type size2, const value_type &init): + matrix (size_type size1_arg, size_type size2_arg, const value_type &init): matrix_container (), - size1_ (size1), size2_ (size2), data_ (layout_type::storage_size (size1, size2), init) { + size1_ (size1_arg), size2_ (size2_arg), data_ (layout_type::storage_size (size1_arg, size2_arg), init) { } BOOST_UBLAS_INLINE - matrix (size_type size1, size_type size2, const array_type &data): + matrix (size_type size1_arg, size_type size2_arg, const array_type &data_arg): matrix_container (), - size1_ (size1), size2_ (size2), data_ (data) {} + size1_ (size1_arg), size2_ (size2_arg), data_ (data_arg) {} BOOST_UBLAS_INLINE matrix (const matrix &m): matrix_container (), @@ -138,15 +138,15 @@ namespace boost { namespace numeric { na // Resizing BOOST_UBLAS_INLINE - void resize (size_type size1, size_type size2, bool preserve = true) { + void resize (size_type size1_arg, size_type size2_arg, bool preserve = true) { if (preserve) { - self_type temporary (size1, size2); + self_type temporary (size1_arg, size2_arg); detail::matrix_resize_preserve (*this, temporary); } else { - data ().resize (layout_type::storage_size (size1, size2)); - size1_ = size1; - size2_ = size2; + data ().resize (layout_type::storage_size (size1_arg, size2_arg)); + size1_ = size1_arg; + size2_ = size2_arg; } } @@ -1065,10 +1065,10 @@ namespace boost { namespace numeric { na matrix_container (), size1_ (0), size2_ (0), data_ (1) {} BOOST_UBLAS_INLINE - vector_of_vector (size_type size1, size_type size2): + vector_of_vector (size_type size1_arg, size_type size2_arg): matrix_container (), - size1_ (size1), size2_ (size2), data_ (1) { - resize (size1, size2, true); + size1_ (size1_arg), size2_ (size2_arg), data_ (1) { + resize (size1_arg, size2_arg, true); } BOOST_UBLAS_INLINE vector_of_vector (const vector_of_vector &m): @@ -1106,18 +1106,18 @@ namespace boost { namespace numeric { na // Resizing BOOST_UBLAS_INLINE - void resize (size_type size1, size_type size2, bool preserve = true) { - size1_ = size1; - size2_ = size2; + void resize (size_type size1_arg, size_type size2_arg, bool preserve = true) { + size1_ = size1_arg; + size2_ = size2_arg; if (preserve) - data ().resize (layout_type::size_M (size1, size2) + 1, typename array_type::value_type ()); + data ().resize (layout_type::size_M (size1_arg, size2_arg) + 1, typename array_type::value_type ()); else - data ().resize (layout_type::size_M (size1, size2) + 1); - for (size_type k = 0; k < layout_type::size_M (size1, size2); ++ k) { + data ().resize (layout_type::size_M (size1_arg, size2_arg) + 1); + for (size_type k = 0; k < layout_type::size_M (size1_arg, size2_arg); ++ k) { if (preserve) - data () [k].resize (layout_type::size_m (size1, size2), value_type ()); + data () [k].resize (layout_type::size_m (size1_arg, size2_arg), value_type ()); else - data () [k].resize (layout_type::size_m (size1, size2)); + data () [k].resize (layout_type::size_m (size1_arg, size2_arg)); } } @@ -2043,9 +2043,9 @@ namespace boost { namespace numeric { na matrix_container (), size1_ (size), size2_ (size) {} BOOST_UBLAS_INLINE - zero_matrix (size_type size1, size_type size2): + zero_matrix (size_type size1_arg, size_type size2_arg): matrix_container (), - size1_ (size1), size2_ (size2) {} + size1_ (size1_arg), size2_ (size2_arg) {} BOOST_UBLAS_INLINE zero_matrix (const zero_matrix &m): matrix_container (), @@ -2068,9 +2068,9 @@ namespace boost { namespace numeric { na size2_ = size; } BOOST_UBLAS_INLINE - void resize (size_type size1, size_type size2, bool /*preserve*/ = true) { - size1_ = size1; - size2_ = size2; + void resize (size_type size1_arg, size_type size2_arg, bool /*preserve*/ = true) { + size1_ = size1_arg; + size2_ = size2_arg; } // Element access @@ -2423,9 +2423,9 @@ namespace boost { namespace numeric { na matrix_container (), size1_ (size), size2_ (size), size_common_ ((std::min) (size1_, size2_)) {} BOOST_UBLAS_INLINE - identity_matrix (size_type size1, size_type size2): + identity_matrix (size_type size1_arg, size_type size2_arg): matrix_container (), - size1_ (size1), size2_ (size2), size_common_ ((std::min) (size1_, size2_)) {} + size1_ (size1_arg), size2_ (size2_arg), size_common_ ((std::min) (size1_, size2_)) {} BOOST_UBLAS_INLINE identity_matrix (const identity_matrix &m): matrix_container (), @@ -2448,9 +2448,9 @@ namespace boost { namespace numeric { na size2_ = size; } BOOST_UBLAS_INLINE - void resize (size_type size1, size_type size2, bool /*preserve*/ = true) { - size1_ = size1; - size2_ = size2; + void resize (size_type size1_arg, size_type size2_arg, bool /*preserve*/ = true) { + size1_ = size1_arg; + size2_ = size2_arg; } // Element access @@ -2824,9 +2824,9 @@ namespace boost { namespace numeric { na matrix_container (), size1_ (0), size2_ (0), value_ () {} BOOST_UBLAS_INLINE - scalar_matrix (size_type size1, size_type size2, const value_type &value = value_type(1)): + scalar_matrix (size_type size1_arg, size_type size2_arg, const value_type &value = value_type(1)): matrix_container (), - size1_ (size1), size2_ (size2), value_ (value) {} + size1_ (size1_arg), size2_ (size2_arg), value_ (value) {} BOOST_UBLAS_INLINE scalar_matrix (const scalar_matrix &m): matrix_container (), @@ -2844,9 +2844,9 @@ namespace boost { namespace numeric { na // Resizing BOOST_UBLAS_INLINE - void resize (size_type size1, size_type size2, bool /*preserve*/ = true) { - size1_ = size1; - size2_ = size2; + void resize (size_type size1_arg, size_type size2_arg, bool /*preserve*/ = true) { + size1_ = size1_arg; + size2_ = size2_arg; } // Element access @@ -3284,8 +3284,8 @@ namespace boost { namespace numeric { na size1_ (N), size2_ (M) /* , data_ () */ { } BOOST_UBLAS_INLINE - c_matrix (size_type size1, size_type size2): - size1_ (size1), size2_ (size2) /* , data_ () */ { + c_matrix (size_type size1_arg, size_type size2_arg): + size1_ (size1_arg), size2_ (size2_arg) /* , data_ () */ { if (size1_ > N || size2_ > M) bad_size ().raise (); } @@ -3325,14 +3325,14 @@ namespace boost { namespace numeric { na // Resizing BOOST_UBLAS_INLINE - void resize (size_type size1, size_type size2, bool preserve = true) { - if (size1 > N || size2 > M) + void resize (size_type size1_arg, size_type size2_arg, bool preserve = true) { + if (size1_arg > N || size2_arg > M) bad_size ().raise (); if (preserve) { - self_type temporary (size1, size2); + self_type temporary (size1_arg, size2_arg); // Common elements to preserve - const size_type size1_min = (std::min) (size1, size1_); - const size_type size2_min = (std::min) (size2, size2_); + const size_type size1_min = (std::min) (size1_arg, size1_); + const size_type size2_min = (std::min) (size2_arg, size2_); for (size_type i = 0; i != size1_min; ++i) { // indexing copy over major for (size_type j = 0; j != size2_min; ++j) { temporary.data_[i][j] = data_[i][j]; @@ -3341,8 +3341,8 @@ namespace boost { namespace numeric { na assign_temporary (temporary); } else { - size1_ = size1; - size2_ = size2; + size1_ = size1_arg; + size2_ = size2_arg; } } diff -rupN /hub/3rdparty/R2010b/151720/glnxa64/boost/include/boost/numeric/ublas/matrix_expression.hpp ublas/matrix_expression.hpp --- /hub/3rdparty/R2010b/151720/glnxa64/boost/include/boost/numeric/ublas/matrix_expression.hpp 2009-12-01 14:12:09.000000000 -0500 +++ ublas/matrix_expression.hpp 2009-12-04 16:35:24.904491000 -0500 @@ -1918,39 +1918,39 @@ namespace boost { namespace numeric { na // Sparse specializations BOOST_UBLAS_INLINE void increment (sparse_bidirectional_iterator_tag) { - size_type index1 = (*this) ().size1 (); + size_type index1_val = (*this) ().size1 (); if (it1_ != it1_end_) { if (it1_.index1 () <= i_) ++ it1_; if (it1_ != it1_end_) - index1 = it1_.index1 (); + index1_val = it1_.index1 (); } - size_type index2 = (*this) ().size1 (); + size_type index2_val = (*this) ().size1 (); if (it2_ != it2_end_) if (it2_.index1 () <= i_) ++ it2_; if (it2_ != it2_end_) { - index2 = it2_.index1 (); + index2_val = it2_.index1 (); } - i_ = (std::min) (index1, index2); + i_ = (std::min) (index1_val, index2_val); } BOOST_UBLAS_INLINE void decrement (sparse_bidirectional_iterator_tag) { - size_type index1 = (*this) ().size1 (); + size_type index1_val = (*this) ().size1 (); if (it1_ != it1_end_) { if (i_ <= it1_.index1 ()) -- it1_; if (it1_ != it1_end_) - index1 = it1_.index1 (); + index1_val = it1_.index1 (); } - size_type index2 = (*this) ().size1 (); + size_type index2_val = (*this) ().size1 (); if (it2_ != it2_end_) { if (i_ <= it2_.index1 ()) -- it2_; if (it2_ != it2_end_) - index2 = it2_.index1 (); + index2_val = it2_.index1 (); } - i_ = (std::max) (index1, index2); + i_ = (std::max) (index1_val, index2_val); } BOOST_UBLAS_INLINE void increment (sparse_bidirectional_iterator_tag, difference_type n) { @@ -2233,39 +2233,39 @@ namespace boost { namespace numeric { na // Sparse specializations BOOST_UBLAS_INLINE void increment (sparse_bidirectional_iterator_tag) { - size_type index1 = (*this) ().size2 (); + size_type index1_val = (*this) ().size2 (); if (it1_ != it1_end_) { if (it1_.index2 () <= j_) ++ it1_; if (it1_ != it1_end_) - index1 = it1_.index2 (); + index1_val = it1_.index2 (); } - size_type index2 = (*this) ().size2 (); + size_type index2_val = (*this) ().size2 (); if (it2_ != it2_end_) { if (it2_.index2 () <= j_) ++ it2_; if (it2_ != it2_end_) - index2 = it2_.index2 (); + index2_val = it2_.index2 (); } - j_ = (std::min) (index1, index2); + j_ = (std::min) (index1_val, index2_val); } BOOST_UBLAS_INLINE void decrement (sparse_bidirectional_iterator_tag) { - size_type index1 = (*this) ().size2 (); + size_type index1_val = (*this) ().size2 (); if (it1_ != it1_end_) { if (j_ <= it1_.index2 ()) -- it1_; if (it1_ != it1_end_) - index1 = it1_.index2 (); + index1_val = it1_.index2 (); } - size_type index2 = (*this) ().size2 (); + size_type index2_val = (*this) ().size2 (); if (it2_ != it2_end_) { if (j_ <= it2_.index2 ()) -- it2_; if (it2_ != it2_end_) - index2 = it2_.index2 (); + index2_val = it2_.index2 (); } - j_ = (std::max) (index1, index2); + j_ = (std::max) (index1_val, index2_val); } BOOST_UBLAS_INLINE void increment (sparse_bidirectional_iterator_tag, difference_type n) { diff -rupN /hub/3rdparty/R2010b/151720/glnxa64/boost/include/boost/numeric/ublas/matrix_sparse.hpp ublas/matrix_sparse.hpp --- /hub/3rdparty/R2010b/151720/glnxa64/boost/include/boost/numeric/ublas/matrix_sparse.hpp 2009-12-01 14:12:09.000000000 -0500 +++ ublas/matrix_sparse.hpp 2009-12-04 16:35:35.271315000 -0500 @@ -284,9 +284,9 @@ namespace boost { namespace numeric { na matrix_container (), size1_ (0), size2_ (0), data_ () {} BOOST_UBLAS_INLINE - mapped_matrix (size_type size1, size_type size2, size_type non_zeros = 0): + mapped_matrix (size_type size1_arg, size_type size2_arg, size_type non_zeros = 0): matrix_container (), - size1_ (size1), size2_ (size2), data_ () { + size1_ (size1_arg), size2_ (size2_arg), data_ () { detail::map_reserve (data (), restrict_capacity (non_zeros)); } BOOST_UBLAS_INLINE @@ -342,11 +342,11 @@ namespace boost { namespace numeric { na } public: BOOST_UBLAS_INLINE - void resize (size_type size1, size_type size2, bool preserve = true) { + void resize (size_type size1_arg, size_type size2_arg, bool preserve = true) { // FIXME preserve unimplemented BOOST_UBLAS_CHECK (!preserve, internal_logic ()); - size1_ = size1; - size2_ = size2; + size1_ = size1_arg; + size2_ = size2_arg; data ().clear (); } @@ -1357,9 +1357,9 @@ namespace boost { namespace numeric { na data_ [layout_type::size_M (size1_, size2_)] = vector_data_value_type (); } BOOST_UBLAS_INLINE - mapped_vector_of_mapped_vector (size_type size1, size_type size2, size_type non_zeros = 0): + mapped_vector_of_mapped_vector (size_type size1_arg, size_type size2_arg, size_type non_zeros = 0): matrix_container (), - size1_ (size1), size2_ (size2), data_ () { + size1_ (size1_arg), size2_ (size2_arg), data_ () { data_ [layout_type::size_M (size1_, size2_)] = vector_data_value_type (); } BOOST_UBLAS_INLINE @@ -1411,11 +1411,11 @@ namespace boost { namespace numeric { na // Resizing BOOST_UBLAS_INLINE - void resize (size_type size1, size_type size2, bool preserve = true) { + void resize (size_type size1_arg, size_type size2_arg, bool preserve = true) { // FIXME preserve unimplemented BOOST_UBLAS_CHECK (!preserve, internal_logic ()); - size1_ = size1; - size2_ = size2; + size1_ = size1_arg; + size2_ = size2_arg; data ().clear (); data () [layout_type::size_M (size1_, size2_)] = vector_data_value_type (); } @@ -2650,9 +2650,9 @@ namespace boost { namespace numeric { na storage_invariants (); } BOOST_UBLAS_INLINE - compressed_matrix (size_type size1, size_type size2, size_type non_zeros = 0): + compressed_matrix (size_type size1_arg, size_type size2_arg, size_type non_zeros = 0): matrix_container (), - size1_ (size1), size2_ (size2), capacity_ (restrict_capacity (non_zeros)), + size1_ (size1_arg), size2_ (size2_arg), capacity_ (restrict_capacity (non_zeros)), filled1_ (1), filled2_ (0), index1_data_ (layout_type::size_M (size1_, size2_) + 1), index2_data_ (capacity_), value_data_ (capacity_) { index1_data_ [filled1_ - 1] = k_based (filled2_); @@ -2748,9 +2748,9 @@ namespace boost { namespace numeric { na return value_data_; } BOOST_UBLAS_INLINE - void set_filled (const array_size_type& filled1, const array_size_type& filled2) { - filled1_ = filled1; - filled2_ = filled2; + void set_filled (const array_size_type& filled1_arg, const array_size_type& filled2_arg) { + filled1_ = filled1_arg; + filled2_ = filled2_arg; storage_invariants (); } BOOST_UBLAS_INLINE @@ -2786,11 +2786,11 @@ namespace boost { namespace numeric { na } public: BOOST_UBLAS_INLINE - void resize (size_type size1, size_type size2, bool preserve = true) { + void resize (size_type size1_arg, size_type size2_arg, bool preserve = true) { // FIXME preserve unimplemented BOOST_UBLAS_CHECK (!preserve, internal_logic ()); - size1_ = size1; - size2_ = size2; + size1_ = size1_arg; + size2_ = size2_arg; capacity_ = restrict_capacity (capacity_); filled1_ = 1; filled2_ = 0; @@ -4029,9 +4029,9 @@ namespace boost { namespace numeric { na storage_invariants (); } BOOST_UBLAS_INLINE - coordinate_matrix (size_type size1, size_type size2, array_size_type non_zeros = 0): + coordinate_matrix (size_type size1_arg, size_type size2_arg, array_size_type non_zeros = 0): matrix_container (), - size1_ (size1), size2_ (size2), capacity_ (restrict_capacity (non_zeros)), + size1_ (size1_arg), size2_ (size2_arg), capacity_ (restrict_capacity (non_zeros)), filled_ (0), sorted_filled_ (filled_), sorted_ (true), index1_data_ (capacity_), index2_data_ (capacity_), value_data_ (capacity_) { storage_invariants (); @@ -4095,13 +4095,13 @@ namespace boost { namespace numeric { na return value_data_; } BOOST_UBLAS_INLINE - void set_filled (const array_size_type &filled) { + void set_filled (const array_size_type &filled_arg) { // Make sure that storage_invariants() succeeds - if (sorted_ && filled < filled_) - sorted_filled_ = filled; + if (sorted_ && filled_arg < filled_) + sorted_filled_ = filled_arg; else - sorted_ = (sorted_filled_ == filled); - filled_ = filled; + sorted_ = (sorted_filled_ == filled_arg); + filled_ = filled_arg; storage_invariants (); } BOOST_UBLAS_INLINE @@ -4128,11 +4128,11 @@ namespace boost { namespace numeric { na } public: BOOST_UBLAS_INLINE - void resize (size_type size1, size_type size2, bool preserve = true) { + void resize (size_type size1_arg, size_type size2_arg, bool preserve = true) { // FIXME preserve unimplemented BOOST_UBLAS_CHECK (!preserve, internal_logic ()); - size1_ = size1; - size2_ = size2; + size1_ = size1_arg; + size2_ = size2_arg; capacity_ = restrict_capacity (capacity_); index1_data_.resize (capacity_); index2_data_.resize (capacity_); @@ -4387,21 +4387,21 @@ namespace boost { namespace numeric { na std::inplace_merge (ita.begin (), iunsorted, ita.end ()); // sum duplicates with += and remove - array_size_type filled = 0; + array_size_type filled_val = 0; for (array_size_type i = 1; i < filled_; ++ i) { - if (index1_data_ [filled] != index1_data_ [i] || - index2_data_ [filled] != index2_data_ [i]) { - ++ filled; - if (filled != i) { - index1_data_ [filled] = index1_data_ [i]; - index2_data_ [filled] = index2_data_ [i]; - value_data_ [filled] = value_data_ [i]; + if (index1_data_ [filled_val] != index1_data_ [i] || + index2_data_ [filled_val] != index2_data_ [i]) { + ++ filled_val; + if (filled_val != i) { + index1_data_ [filled_val] = index1_data_ [i]; + index2_data_ [filled_val] = index2_data_ [i]; + value_data_ [filled_val] = value_data_ [i]; } } else { - value_data_ [filled] += value_data_ [i]; + value_data_ [filled_val] += value_data_ [i]; } } - filled_ = filled + 1; + filled_ = filled_val + 1; sorted_filled_ = filled_; sorted_ = true; storage_invariants (); diff -rupN /hub/3rdparty/R2010b/151720/glnxa64/boost/include/boost/numeric/ublas/storage.hpp ublas/storage.hpp --- /hub/3rdparty/R2010b/151720/glnxa64/boost/include/boost/numeric/ublas/storage.hpp 2009-12-01 14:12:09.000000000 -0500 +++ ublas/storage.hpp 2009-12-24 07:45:47.599833000 -0500 @@ -62,8 +62,8 @@ namespace boost { namespace numeric { na data_ = 0; } explicit BOOST_UBLAS_INLINE - unbounded_array (size_type size, const ALLOC &a = ALLOC()): - alloc_(a), size_ (size) { + unbounded_array (size_type size_arg, const ALLOC &a = ALLOC()): + alloc_(a), size_ (size_arg) { if (size_) { data_ = alloc_.allocate (size_); if (! detail::has_trivial_constructor::value) { @@ -76,8 +76,8 @@ namespace boost { namespace numeric { na } // No value initialised, but still be default constructed BOOST_UBLAS_INLINE - unbounded_array (size_type size, const value_type &init, const ALLOC &a = ALLOC()): - alloc_ (a), size_ (size) { + unbounded_array (size_type size_arg, const value_type &init, const ALLOC &a = ALLOC()): + alloc_ (a), size_ (size_arg) { if (size_) { data_ = alloc_.allocate (size_); std::uninitialized_fill (begin(), end(), init); @@ -113,33 +113,33 @@ namespace boost { namespace numeric { na // Resizing private: BOOST_UBLAS_INLINE - void resize_internal (const size_type size, const value_type init, const bool preserve) { - if (size != size_) { + void resize_internal (const size_type size_arg, const value_type init, const bool preserve) { + if (size_arg != size_) { pointer p_data = data_; - if (size) { - data_ = alloc_.allocate (size); + if (size_arg) { + data_ = alloc_.allocate (size_arg); if (preserve) { pointer si = p_data; pointer di = data_; - if (size < size_) { - for (; di != data_ + size; ++di) { + if (size_arg < size_) { + for (; di != data_ + size_arg; ++di) { alloc_.construct (di, *si); ++si; } } else { - for (pointer si = p_data; si != p_data + size_; ++si) { - alloc_.construct (di, *si); + for (pointer si2 = p_data; si2 != p_data + size_; ++si2) { + alloc_.construct (di, *si2); ++di; } - for (; di != data_ + size; ++di) { + for (; di != data_ + size_arg; ++di) { alloc_.construct (di, init); } } } else { if (! detail::has_trivial_constructor::value) { - for (pointer di = data_; di != data_ + size; ++di) + for (pointer di = data_; di != data_ + size_arg; ++di) alloc_.construct (di, value_type()); } } @@ -153,19 +153,19 @@ namespace boost { namespace numeric { na alloc_.deallocate (p_data, size_); } - if (!size) + if (!size_arg) data_ = 0; - size_ = size; + size_ = size_arg; } } public: BOOST_UBLAS_INLINE - void resize (size_type size) { - resize_internal (size, value_type (), false); + void resize (size_type size_arg) { + resize_internal (size_arg, value_type (), false); } BOOST_UBLAS_INLINE - void resize (size_type size, value_type init) { - resize_internal (size, init, true); + void resize (size_type size_arg, value_type init) { + resize_internal (size_arg, init, true); } // Random Access Container @@ -318,14 +318,14 @@ namespace boost { namespace numeric { na size_ (0) /*, data_ ()*/ { // size 0 - use bounded_vector to default construct with size N } explicit BOOST_UBLAS_INLINE - bounded_array (size_type size): - size_ (size) /*, data_ ()*/ { + bounded_array (size_type size_arg): + size_ (size_arg) /*, data_ ()*/ { BOOST_UBLAS_CHECK (size_ <= N, bad_size ()); // data_ (an array) elements are already default constructed } BOOST_UBLAS_INLINE - bounded_array (size_type size, const value_type &init): - size_ (size) /*, data_ ()*/ { + bounded_array (size_type size_arg, const value_type &init): + size_ (size_arg) /*, data_ ()*/ { BOOST_UBLAS_CHECK (size_ <= N, bad_size ()); // ISSUE elements should be value constructed here, but we must fill instead as already default constructed std::fill (begin(), end(), init) ; @@ -339,16 +339,16 @@ namespace boost { namespace numeric { na // Resizing BOOST_UBLAS_INLINE - void resize (size_type size) { - BOOST_UBLAS_CHECK (size <= N, bad_size ()); - size_ = size; + void resize (size_type size_arg) { + BOOST_UBLAS_CHECK (size_arg <= N, bad_size ()); + size_ = size_arg; } BOOST_UBLAS_INLINE - void resize (size_type size, value_type init) { - BOOST_UBLAS_CHECK (size <= N, bad_size ()); - if (size > size_) - std::fill (data_ + size_, data_ + size, init); - size_ = size; + void resize (size_type size_arg, value_type init) { + BOOST_UBLAS_CHECK (size_arg <= N, bad_size ()); + if (size_arg > size_) + std::fill (data_ + size_, data_ + size_arg, init); + size_ = size_arg; } // Random Access Container @@ -489,17 +489,17 @@ namespace boost { namespace numeric { na size_ (0), own_ (true), data_ (new value_type [0]) { } explicit BOOST_UBLAS_INLINE - array_adaptor (size_type size): - size_ (size), own_ (true), data_ (new value_type [size]) { + array_adaptor (size_type size_arg): + size_ (size_arg), own_ (true), data_ (new value_type [size_arg]) { } BOOST_UBLAS_INLINE - array_adaptor (size_type size, const value_type &init): - size_ (size), own_ (true), data_ (new value_type [size]) { + array_adaptor (size_type size_arg, const value_type &init): + size_ (size_arg), own_ (true), data_ (new value_type [size_arg]) { std::fill (data_, data_ + size_, init); } BOOST_UBLAS_INLINE - array_adaptor (size_type size, pointer data): - size_ (size), own_ (false), data_ (data) {} + array_adaptor (size_type size_arg, pointer data): + size_ (size_arg), own_ (false), data_ (data) {} BOOST_UBLAS_INLINE array_adaptor (const array_adaptor &a): storage_array (), @@ -516,26 +516,26 @@ namespace boost { namespace numeric { na // Resizing private: BOOST_UBLAS_INLINE - void resize_internal (size_type size, value_type init, bool preserve = true) { - if (size != size_) { - pointer data = new value_type [size]; + void resize_internal (size_type size_arg, value_type init, bool preserve = true) { + if (size_arg != size_) { + pointer data = new value_type [size_arg]; if (preserve) { - std::copy (data_, data_ + (std::min) (size, size_), data); - std::fill (data + (std::min) (size, size_), data + size, init); + std::copy (data_, data_ + (std::min) (size_arg, size_), data); + std::fill (data + (std::min) (size_arg, size_), data + size_arg, init); } if (own_) delete [] data_; - size_ = size; + size_ = size_arg; own_ = true; data_ = data; } } BOOST_UBLAS_INLINE - void resize_internal (size_type size, pointer data, value_type init, bool preserve = true) { + void resize_internal (size_type size_arg, pointer data, value_type init, bool preserve = true) { if (data != data_) { if (preserve) { - std::copy (data_, data_ + (std::min) (size, size_), data); - std::fill (data + (std::min) (size, size_), data + size, init); + std::copy (data_, data_ + (std::min) (size_arg, size_), data); + std::fill (data + (std::min) (size_arg, size_), data + size_arg, init); } if (own_) delete [] data_; @@ -543,26 +543,26 @@ namespace boost { namespace numeric { na data_ = data; } else { - std::fill (data + (std::min) (size, size_), data + size, init); + std::fill (data + (std::min) (size_arg, size_), data + size_arg, init); } - size_ = size; + size_ = size_arg; } public: BOOST_UBLAS_INLINE - void resize (size_type size) { - resize_internal (size, value_type (), false); + void resize (size_type size_arg) { + resize_internal (size_arg, value_type (), false); } BOOST_UBLAS_INLINE - void resize (size_type size, value_type init) { - resize_internal (size, init, true); + void resize (size_type size_arg, value_type init) { + resize_internal (size_arg, init, true); } BOOST_UBLAS_INLINE - void resize (size_type size, pointer data) { - resize_internal (size, data, value_type (), false); + void resize (size_type size_arg, pointer data) { + resize_internal (size_arg, data, value_type (), false); } BOOST_UBLAS_INLINE - void resize (size_type size, pointer data, value_type init) { - resize_internal (size, data, init, true); + void resize (size_type size_arg, pointer data, value_type init) { + resize_internal (size_arg, data, init, true); } BOOST_UBLAS_INLINE @@ -882,8 +882,8 @@ namespace boost { namespace numeric { na basic_range (): start_ (0), size_ (0) {} BOOST_UBLAS_INLINE - basic_range (size_type start, size_type stop): - start_ (start), size_ (stop - start) { + basic_range (size_type start_arg, size_type stop): + start_ (start_arg), size_ (stop - start_arg) { BOOST_UBLAS_CHECK (start_ <= stop, bad_index ()); } @@ -1055,10 +1055,10 @@ namespace boost { namespace numeric { na } BOOST_UBLAS_INLINE - basic_range preprocess (size_type size) const { + basic_range preprocess (size_type size_arg) const { if (this != &all_) return *this; - return basic_range (0, size); + return basic_range (0, size_arg); } static BOOST_UBLAS_INLINE @@ -1094,8 +1094,8 @@ namespace boost { namespace numeric { na basic_slice (): start_ (0), stride_ (0), size_ (0) {} BOOST_UBLAS_INLINE - basic_slice (size_type start, difference_type stride, size_type size): - start_ (start), stride_ (stride), size_ (size) {} + basic_slice (size_type start_arg, difference_type stride_arg, size_type size_arg): + start_ (start_arg), stride_ (stride_arg), size_ (size_arg) {} BOOST_UBLAS_INLINE size_type start () const { @@ -1274,10 +1274,10 @@ namespace boost { namespace numeric { na } BOOST_UBLAS_INLINE - basic_slice preprocess (size_type size) const { + basic_slice preprocess (size_type size_arg) const { if (this != &all_) return *this; - return basic_slice (0, 1, size); + return basic_slice (0, 1, size_arg); } static BOOST_UBLAS_INLINE @@ -1316,11 +1316,11 @@ namespace boost { namespace numeric { na indirect_array (): size_ (), data_ () {} explicit BOOST_UBLAS_INLINE - indirect_array (size_type size): - size_ (size), data_ (size) {} + indirect_array (size_type size_arg): + size_ (size_arg), data_ (size_arg) {} BOOST_UBLAS_INLINE - indirect_array (size_type size, const array_type &data): - size_ (size), data_ (data) {} + indirect_array (size_type size_arg, const array_type &data_arg): + size_ (size_arg), data_ (data_arg) {} BOOST_UBLAS_INLINE indirect_array (pointer start, pointer stop): size_ (stop - start), data_ (stop - start) { @@ -1376,27 +1376,27 @@ namespace boost { namespace numeric { na BOOST_UBLAS_INLINE indirect_array compose (const basic_range &r) const { BOOST_UBLAS_CHECK (r.start () + r.size () <= size_, bad_size ()); - array_type data (r.size ()); + array_type data_val (r.size ()); for (size_type i = 0; i < r.size (); ++ i) - data [i] = data_ [r.start () + i]; - return indirect_array (r.size (), data); + data_val [i] = data_ [r.start () + i]; + return indirect_array (r.size (), data_val); } BOOST_UBLAS_INLINE indirect_array compose (const basic_slice &s) const { BOOST_UBLAS_CHECK (s.start () + s.stride () * (s.size () - (s.size () > 0)) <= size (), bad_size ()); - array_type data (s.size ()); + array_type data_val (s.size ()); for (size_type i = 0; i < s.size (); ++ i) - data [i] = data_ [s.start () + s.stride () * i]; - return indirect_array (s.size (), data); + data_val [i] = data_ [s.start () + s.stride () * i]; + return indirect_array (s.size (), data_val); } BOOST_UBLAS_INLINE indirect_array compose (const indirect_array &ia) const { - array_type data (ia.size_); + array_type data_val (ia.size_); for (size_type i = 0; i < ia.size_; ++ i) { BOOST_UBLAS_CHECK (ia.data_ [i] <= size_, bad_size ()); - data [i] = data_ [ia.data_ [i]]; + data_val [i] = data_ [ia.data_ [i]]; } - return indirect_array (ia.size_, data); + return indirect_array (ia.size_, data_val); } // Comparison @@ -1534,11 +1534,11 @@ namespace boost { namespace numeric { na } BOOST_UBLAS_INLINE - indirect_array preprocess (size_type size) const { + indirect_array preprocess (size_type size_arg) const { if (this != &all_) return *this; - indirect_array ia (size); - for (size_type i = 0; i < size; ++ i) + indirect_array ia (size_arg); + for (size_type i = 0; i < size_arg; ++ i) ia (i) = i; return ia; } @@ -1666,8 +1666,8 @@ namespace boost { namespace numeric { na typedef const value_type const_reference; BOOST_UBLAS_INLINE - index_pair_array(size_type size, V1& data1, V2& data2) : - size_(size),data1_(data1),data2_(data2) {} + index_pair_array(size_type size_arg, V1& data1, V2& data2) : + size_(size_arg),data1_(data1),data2_(data2) {} BOOST_UBLAS_INLINE size_type size() const { @@ -1841,8 +1841,8 @@ namespace boost { namespace numeric { na typedef const value_type const_reference; BOOST_UBLAS_INLINE - index_triple_array(size_type size, V1& data1, V2& data2, V3& data3) : - size_(size),data1_(data1),data2_(data2),data3_(data3) {} + index_triple_array(size_type size_arg, V1& data1, V2& data2, V3& data3) : + size_(size_arg),data1_(data1),data2_(data2),data3_(data3) {} BOOST_UBLAS_INLINE size_type size() const { diff -rupN /hub/3rdparty/R2010b/151720/glnxa64/boost/include/boost/numeric/ublas/storage_sparse.hpp ublas/storage_sparse.hpp --- /hub/3rdparty/R2010b/151720/glnxa64/boost/include/boost/numeric/ublas/storage_sparse.hpp 2009-12-01 14:12:09.000000000 -0500 +++ ublas/storage_sparse.hpp 2009-12-04 16:35:54.135086000 -0500 @@ -263,38 +263,38 @@ namespace boost { namespace numeric { na private: // Resizing - implicitly exposses uninitialized (but default constructed) mapped_type BOOST_UBLAS_INLINE - void resize (size_type size) { + void resize (size_type size_arg) { BOOST_UBLAS_CHECK (size_ <= capacity_, internal_logic ()); - if (size > capacity_) { - const size_type capacity = size << 1; - BOOST_UBLAS_CHECK (capacity, internal_logic ()); - pointer data = alloc_.allocate (capacity); - std::uninitialized_copy (data_, data_ + (std::min) (size, size_), data); - std::uninitialized_fill (data + (std::min) (size, size_), data + capacity, value_type ()); + if (size_arg > capacity_) { + const size_type capacity2 = size_arg << 1; + BOOST_UBLAS_CHECK (capacity2, internal_logic ()); + pointer data = alloc_.allocate (capacity2); + std::uninitialized_copy (data_, data_ + (std::min) (size_arg, size_), data); + std::uninitialized_fill (data + (std::min) (size_arg, size_), data + capacity2, value_type ()); if (capacity_) { std::for_each (data_, data_ + capacity_, static_destroy); alloc_.deallocate (data_, capacity_); } - capacity_ = capacity; + capacity_ = capacity2; data_ = data; } - size_ = size; + size_ = size_arg; BOOST_UBLAS_CHECK (size_ <= capacity_, internal_logic ()); } public: // Reserving BOOST_UBLAS_INLINE - void reserve (size_type capacity) { + void reserve (size_type capacity_arg) { BOOST_UBLAS_CHECK (size_ <= capacity_, internal_logic ()); // Reduce capacity_ if size_ allows - BOOST_UBLAS_CHECK (capacity >= size_, bad_size ()); + BOOST_UBLAS_CHECK (capacity_arg >= size_, bad_size ()); pointer data; - if (capacity) { - data = alloc_.allocate (capacity); + if (capacity_arg) { + data = alloc_.allocate (capacity_arg); std::uninitialized_copy (data_, data_ + size_, data); - std::uninitialized_fill (data + size_, data + capacity, value_type ()); + std::uninitialized_fill (data + size_, data + capacity_arg, value_type ()); } else data = 0; @@ -303,7 +303,7 @@ namespace boost { namespace numeric { na std::for_each (data_, data_ + capacity_, static_destroy); alloc_.deallocate (data_, capacity_); } - capacity_ = capacity; + capacity_ = capacity_arg; data_ = data; BOOST_UBLAS_CHECK (size_ <= capacity_, internal_logic ()); } diff -rupN /hub/3rdparty/R2010b/151720/glnxa64/boost/include/boost/numeric/ublas/vector.hpp ublas/vector.hpp --- /hub/3rdparty/R2010b/151720/glnxa64/boost/include/boost/numeric/ublas/vector.hpp 2009-12-01 14:12:09.000000000 -0500 +++ ublas/vector.hpp 2009-12-04 16:36:11.548016000 -0500 @@ -52,18 +52,18 @@ namespace boost { namespace numeric { na vector_container (), data_ () {} explicit BOOST_UBLAS_INLINE - vector (size_type size): + vector (size_type size_arg): vector_container (), - data_ (size) { + data_ (size_arg) { } BOOST_UBLAS_INLINE - vector (size_type size, const array_type &data): + vector (size_type size_arg, const array_type &data_arg): vector_container (), - data_ (data) {} + data_ (data_arg) {} BOOST_UBLAS_INLINE - vector (size_type size, const value_type &init): + vector (size_type size_arg, const value_type &init): vector_container (), - data_ (size, init) {} + data_ (size_arg, init) {} BOOST_UBLAS_INLINE vector (const vector &v): vector_container (), @@ -104,11 +104,11 @@ namespace boost { namespace numeric { na // Resizing BOOST_UBLAS_INLINE - void resize (size_type size, bool preserve = true) { + void resize (size_type size_arg, bool preserve = true) { if (preserve) - data ().resize (size, typename A::value_type ()); + data ().resize (size_arg, typename A::value_type ()); else - data ().resize (size); + data ().resize (size_arg); } // Element support @@ -602,9 +602,9 @@ namespace boost { namespace numeric { na vector_container (), size_ (0) {} explicit BOOST_UBLAS_INLINE - zero_vector (size_type size): + zero_vector (size_type size_arg): vector_container (), - size_ (size) {} + size_ (size_arg) {} BOOST_UBLAS_INLINE zero_vector (const zero_vector &v): vector_container (), @@ -618,8 +618,8 @@ namespace boost { namespace numeric { na // Resizing BOOST_UBLAS_INLINE - void resize (size_type size, bool /*preserve*/ = true) { - size_ = size; + void resize (size_type size_arg, bool /*preserve*/ = true) { + size_ = size_arg; } // Element support @@ -802,9 +802,9 @@ namespace boost { namespace numeric { na vector_container (), size_ (0), index_ (0) {} BOOST_UBLAS_INLINE - explicit unit_vector (size_type size, size_type index = 0): + explicit unit_vector (size_type size_arg, size_type index_arg = 0): vector_container (), - size_ (size), index_ (index) {} + size_ (size_arg), index_ (index_arg) {} BOOST_UBLAS_INLINE unit_vector (const unit_vector &v): vector_container (), @@ -822,8 +822,8 @@ namespace boost { namespace numeric { na // Resizing BOOST_UBLAS_INLINE - void resize (size_type size, bool /*preserve*/ = true) { - size_ = size; + void resize (size_type size_arg, bool /*preserve*/ = true) { + size_ = size_arg; } // Element support @@ -1027,9 +1027,9 @@ namespace boost { namespace numeric { na vector_container (), size_ (0), value_ () {} BOOST_UBLAS_INLINE - explicit scalar_vector (size_type size, const value_type &value = value_type(1)): + explicit scalar_vector (size_type size_arg, const value_type &value = value_type(1)): vector_container (), - size_ (size), value_ (value) {} + size_ (size_arg), value_ (value) {} BOOST_UBLAS_INLINE scalar_vector (const scalar_vector &v): vector_container (), @@ -1043,8 +1043,8 @@ namespace boost { namespace numeric { na // Resizing BOOST_UBLAS_INLINE - void resize (size_type size, bool /*preserve*/ = true) { - size_ = size; + void resize (size_type size_arg, bool /*preserve*/ = true) { + size_ = size_arg; } // Element support @@ -1266,8 +1266,8 @@ namespace boost { namespace numeric { na c_vector (): size_ (N) /* , data_ () */ {} explicit BOOST_UBLAS_INLINE - c_vector (size_type size): - size_ (size) /* , data_ () */ { + c_vector (size_type size_arg): + size_ (size_arg) /* , data_ () */ { if (size_ > N) bad_size ().raise (); } @@ -1303,10 +1303,10 @@ namespace boost { namespace numeric { na // Resizing BOOST_UBLAS_INLINE - void resize (size_type size, bool preserve = true) { - if (size > N) + void resize (size_type size_arg, bool preserve = true) { + if (size_arg > N) bad_size ().raise (); - size_ = size; + size_ = size_arg; } // Element support diff -rupN /hub/3rdparty/R2010b/151720/glnxa64/boost/include/boost/numeric/ublas/vector_sparse.hpp ublas/vector_sparse.hpp --- /hub/3rdparty/R2010b/151720/glnxa64/boost/include/boost/numeric/ublas/vector_sparse.hpp 2009-12-01 14:12:09.000000000 -0500 +++ ublas/vector_sparse.hpp 2009-12-04 16:36:19.870979000 -0500 @@ -294,9 +294,9 @@ namespace boost { namespace numeric { na vector_container (), size_ (0), data_ () {} BOOST_UBLAS_INLINE - mapped_vector (size_type size, size_type non_zeros = 0): + mapped_vector (size_type size_arg, size_type non_zeros = 0): vector_container (), - size_ (size), data_ () { + size_ (size_arg), data_ () { detail::map_reserve (data(), restrict_capacity (non_zeros)); } BOOST_UBLAS_INLINE @@ -345,8 +345,8 @@ namespace boost { namespace numeric { na } public: BOOST_UBLAS_INLINE - void resize (size_type size, bool preserve = true) { - size_ = size; + void resize (size_type size_arg, bool preserve = true) { + size_ = size_arg; if (preserve) { data ().erase (data ().lower_bound(size_), data ().end()); } @@ -796,9 +796,9 @@ namespace boost { namespace numeric { na storage_invariants (); } explicit BOOST_UBLAS_INLINE - compressed_vector (size_type size, size_type non_zeros = 0): + compressed_vector (size_type size_arg, size_type non_zeros = 0): vector_container (), - size_ (size), capacity_ (restrict_capacity (non_zeros)), filled_ (0), + size_ (size_arg), capacity_ (restrict_capacity (non_zeros)), filled_ (0), index_data_ (capacity_), value_data_ (capacity_) { storage_invariants (); } @@ -851,8 +851,8 @@ namespace boost { namespace numeric { na return value_data_; } BOOST_UBLAS_INLINE - void set_filled (const typename index_array_type::size_type & filled) { - filled_ = filled; + void set_filled (const typename index_array_type::size_type & filled_arg) { + filled_ = filled_arg; storage_invariants (); } BOOST_UBLAS_INLINE @@ -874,14 +874,14 @@ namespace boost { namespace numeric { na } public: BOOST_UBLAS_INLINE - void resize (size_type size, bool preserve = true) { - size_ = size; + void resize (size_type size_arg, bool preserve = true) { + size_ = size_arg; capacity_ = restrict_capacity (capacity_); if (preserve) { index_data_. resize (capacity_, size_type ()); value_data_. resize (capacity_, value_type ()); filled_ = (std::min) (capacity_, filled_); - while ((filled_ > 0) && (zero_based(index_data_[filled_ - 1]) >= size)) { + while ((filled_ > 0) && (zero_based(index_data_[filled_ - 1]) >= size_arg)) { --filled_; } } @@ -1417,9 +1417,9 @@ namespace boost { namespace numeric { na storage_invariants (); } explicit BOOST_UBLAS_INLINE - coordinate_vector (size_type size, size_type non_zeros = 0): + coordinate_vector (size_type size_arg, size_type non_zeros = 0): vector_container (), - size_ (size), capacity_ (restrict_capacity (non_zeros)), + size_ (size_arg), capacity_ (restrict_capacity (non_zeros)), filled_ (0), sorted_filled_ (filled_), sorted_ (true), index_data_ (capacity_), value_data_ (capacity_) { storage_invariants (); @@ -1475,9 +1475,9 @@ namespace boost { namespace numeric { na return value_data_; } BOOST_UBLAS_INLINE - void set_filled (const typename index_array_type::size_type &sorted, const typename index_array_type::size_type &filled) { + void set_filled (const typename index_array_type::size_type &sorted, const typename index_array_type::size_type &filled_arg) { sorted_filled_ = sorted; - filled_ = filled; + filled_ = filled_arg; storage_invariants (); return filled_; } @@ -1501,16 +1501,16 @@ namespace boost { namespace numeric { na } public: BOOST_UBLAS_INLINE - void resize (size_type size, bool preserve = true) { + void resize (size_type size_arg, bool preserve = true) { if (preserve) sort (); // remove duplicate elements. - size_ = size; + size_ = size_arg; capacity_ = restrict_capacity (capacity_); if (preserve) { index_data_. resize (capacity_, size_type ()); value_data_. resize (capacity_, value_type ()); filled_ = (std::min) (capacity_, filled_); - while ((filled_ > 0) && (zero_based(index_data_[filled_ - 1]) >= size)) { + while ((filled_ > 0) && (zero_based(index_data_[filled_ - 1]) >= size_arg)) { --filled_; } } @@ -1758,19 +1758,19 @@ namespace boost { namespace numeric { na std::inplace_merge (ipa.begin (), iunsorted, ipa.end ()); // sum duplicates with += and remove - size_type filled = 0; + size_type filled_val = 0; for (size_type i = 1; i < filled_; ++ i) { - if (index_data_ [filled] != index_data_ [i]) { - ++ filled; - if (filled != i) { - index_data_ [filled] = index_data_ [i]; - value_data_ [filled] = value_data_ [i]; + if (index_data_ [filled_val] != index_data_ [i]) { + ++ filled_val; + if (filled_val != i) { + index_data_ [filled_val] = index_data_ [i]; + value_data_ [filled_val] = value_data_ [i]; } } else { - value_data_ [filled] += value_data_ [i]; + value_data_ [filled_val] += value_data_ [i]; } } - filled_ = filled + 1; + filled_ = filled_val + 1; sorted_filled_ = filled_; sorted_ = true; storage_invariants ();