--- foo/foo/foo/boost/math/special_functions/detail/bessel_jy_series.hpp +++ foo/foo/foo/boost/math/special_functions/detail/bessel_jy_series.hpp @@ -194,9 +194,9 @@ } else { - int s; - prefix = boost::math::lgamma(-v, &s, pol) + p; - prefix = exp(prefix) * s / constants::pi(); + int s_lcl; + prefix = boost::math::lgamma(-v, &s_lcl, pol) + p; + prefix = exp(prefix) * s_lcl / constants::pi(); } bessel_y_small_z_series_term_b s2(v, x); max_iter = policies::get_max_series_iterations(); --- foo/foo/foo/boost/math/special_functions/ellint_rj.hpp +++ foo/foo/foo/boost/math/special_functions/ellint_rj.hpp @@ -91,11 +91,11 @@ BOOST_ASSERT(pmy >= 0); - T p = pmy + y; - value = boost::math::ellint_rj(x, y, z, p, pol); + T p_lcl = pmy + y; + value = boost::math::ellint_rj(x, y, z, p_lcl, pol); value *= pmy; value -= 3 * boost::math::ellint_rf(x, y, z, pol); - value += 3 * sqrt((x * y * z) / (x * z + p * q)) * boost::math::ellint_rc(x * z + p * q, p * q, pol); + value += 3 * sqrt((x * y * z) / (x * z + p_lcl * q)) * boost::math::ellint_rc(x * z + p_lcl * q, p_lcl * q, pol); value /= (y + q); return value; } --- foo/foo/foo/boost/random/binomial_distribution.hpp +++ foo/foo/foo/boost/random/binomial_distribution.hpp @@ -272,21 +272,21 @@ using std::sqrt; using std::pow; - RealType p = (0.5 < _p)? (1 - _p) : _p; - IntType t = _t; + RealType p_lcl = (0.5 < _p)? (1 - _p) : _p; + IntType t_lcl = _t; - m = static_cast((t+1)*p); + m = static_cast((t_lcl+1)*p_lcl); if(use_inversion()) { - q_n = pow((1 - p), static_cast(t)); + q_n = pow((1 - p_lcl), static_cast(t_lcl)); } else { - btrd.r = p/(1-p); - btrd.nr = (t+1)*btrd.r; - btrd.npq = t*p*(1-p); + btrd.r = p_lcl/(1-p_lcl); + btrd.nr = (t_lcl+1)*btrd.r; + btrd.npq = t_lcl*p_lcl*(1-p_lcl); RealType sqrt_npq = sqrt(btrd.npq); btrd.b = 1.15 + 2.53 * sqrt_npq; - btrd.a = -0.0873 + 0.0248*btrd.b + 0.01*p; - btrd.c = t*p + 0.5; + btrd.a = -0.0873 + 0.0248*btrd.b + 0.01*p_lcl; + btrd.c = t_lcl*p_lcl + 0.5; btrd.alpha = (2.83 + 5.1/btrd.b) * sqrt_npq; btrd.v_r = 0.92 - 4.2/btrd.b; btrd.u_rv_r = 0.86*btrd.v_r; @@ -304,9 +304,9 @@ RealType u; RealType v = uniform_01()(urng); if(v <= btrd.u_rv_r) { - RealType u = v/btrd.v_r - 0.43; + RealType u_lcl = v/btrd.v_r - 0.43; return static_cast(floor( - (2*btrd.a/(0.5 - abs(u)) + btrd.b)*u + btrd.c)); + (2*btrd.a/(0.5 - abs(u_lcl)) + btrd.b)*u_lcl + btrd.c)); } if(v >= btrd.v_r) { @@ -344,9 +344,9 @@ v = log(v); RealType rho = (km/btrd.npq)*(((km/3. + 0.625)*km + 1./6)/btrd.npq + 0.5); - RealType t = -km*km/(2*btrd.npq); - if(v < t - rho) return k; - if(v > t + rho) continue; + RealType t_lcl = -km*km/(2*btrd.npq); + if(v < t_lcl - rho) return k; + if(v > t_lcl + rho) continue; IntType nm = _t - m + 1; RealType h = (m + 0.5)*log((m + 1)/(btrd.r*nm)) @@ -367,11 +367,11 @@ } template - IntType invert(IntType t, RealType p, URNG& urng) const + IntType invert(IntType t_arg, RealType p_arg, URNG& urng) const { - RealType q = 1 - p; - RealType s = p / q; - RealType a = (t + 1) * s; + RealType q = 1 - p_arg; + RealType s = p_arg / q; + RealType a = (t_arg + 1) * s; RealType r = q_n; RealType u = uniform_01()(urng); IntType x = 0; --- foo/foo/foo/boost/random/geometric_distribution.hpp +++ foo/foo/foo/boost/random/geometric_distribution.hpp @@ -104,8 +104,8 @@ * * Requires: 0 < p < 1 */ - explicit geometric_distribution(const RealType& p = RealType(0.5)) - : _p(p) + explicit geometric_distribution(const RealType& p_arg = RealType(0.5)) + : _p(p_arg) { BOOST_ASSERT(RealType(0) < _p && _p < RealType(1)); init(); --- foo/foo/foo/boost/random/shuffle_order.hpp +++ foo/foo/foo/boost/random/shuffle_order.hpp @@ -200,8 +200,8 @@ } /** Returns true if the two generators will produce identical sequences. */ - BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(shuffle_order_engine, x, y) - { return x._rng == y._rng && x.y == y.y && std::equal(x.v, x.v+k, y.v); } + BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(shuffle_order_engine, x, y_arg) + { return x._rng == y_arg._rng && x.y == y_arg.y && std::equal(x.v, x.v+k, y_arg.v); } /** Returns true if the two generators will produce different sequences. */ BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(shuffle_order_engine) --- foo/foo/foo/boost/random/subtract_with_carry.hpp +++ foo/foo/foo/boost/random/subtract_with_carry.hpp @@ -268,21 +268,21 @@ friend struct detail::subtract_with_carry_discard; - IntType do_update(std::size_t current, std::size_t short_index, IntType carry) + IntType do_update(std::size_t current, std::size_t short_index, IntType carry_arg) { IntType delta; - IntType temp = x[current] + carry; + IntType temp = x[current] + carry_arg; if (x[short_index] >= temp) { // x(n) >= 0 delta = x[short_index] - temp; - carry = 0; + carry_arg = 0; } else { // x(n) < 0 delta = modulus - temp + x[short_index]; - carry = 1; + carry_arg = 1; } x[current] = delta; - return carry; + return carry_arg; } /// \endcond @@ -498,17 +498,17 @@ friend struct detail::subtract_with_carry_discard; - RealType do_update(std::size_t current, std::size_t short_index, RealType carry) + RealType do_update(std::size_t current, std::size_t short_index, RealType carry_arg) { - RealType delta = x[short_index] - x[current] - carry; + RealType delta = x[short_index] - x[current] - carry_arg; if(delta < 0) { delta += RealType(1); - carry = RealType(1)/_modulus; + carry_arg = RealType(1)/_modulus; } else { - carry = 0; + carry_arg = 0; } x[current] = delta; - return carry; + return carry_arg; } /// \endcond std::size_t k; --- foo/foo/foo/boost/smart_ptr/detail/allocate_array_helper.hpp +++ foo/foo/foo/boost/smart_ptr/detail/allocate_array_helper.hpp @@ -33,10 +33,10 @@ struct rebind { typedef allocate_array_helper other; }; - allocate_array_helper(const A& allocator, std::size_t size, T** data) - : allocator(allocator), - size(sizeof(T) * size), - data(data) { + allocate_array_helper(const A& allocator_arg, std::size_t size_arg, T** data_arg) + : allocator(allocator_arg), + size(sizeof(T) * size_arg), + data(data_arg) { } template allocate_array_helper(const allocate_array_helper& other) @@ -107,9 +107,9 @@ struct rebind { typedef allocate_array_helper other; }; - allocate_array_helper(const A& allocator, T** data) - : allocator(allocator), - data(data) { + allocate_array_helper(const A& allocator_arg, T** data_arg) + : allocator(allocator_arg), + data(data_arg) { } template allocate_array_helper(const allocate_array_helper& other) --- foo/foo/foo/boost/smart_ptr/detail/array_deleter.hpp +++ foo/foo/foo/boost/smart_ptr/detail/array_deleter.hpp @@ -20,8 +20,8 @@ template class array_deleter { public: - array_deleter(std::size_t size) - : size(size), + array_deleter(std::size_t size_arg) + : size(size_arg), object(0) { } ~array_deleter() { --- foo/foo/foo/boost/smart_ptr/detail/make_array_helper.hpp +++ foo/foo/foo/boost/smart_ptr/detail/make_array_helper.hpp @@ -31,9 +31,9 @@ struct rebind { typedef make_array_helper other; }; - make_array_helper(std::size_t size, T** data) - : size(sizeof(T) * size), - data(data) { + make_array_helper(std::size_t size_arg, T** data_arg) + : size(sizeof(T) * size_arg), + data(data_arg) { } template make_array_helper(const make_array_helper& other) @@ -99,8 +99,8 @@ struct rebind { typedef make_array_helper other; }; - make_array_helper(T** data) - : data(data) { + make_array_helper(T** data_arg) + : data(data_arg) { } template make_array_helper(const make_array_helper& other) --- foo/foo/foo/boost/unordered/detail/equivalent.hpp +++ foo/foo/foo/boost/unordered/detail/equivalent.hpp @@ -536,9 +536,9 @@ node_pointer first_node = static_cast(prev->next_); link_pointer end = first_node->group_prev_->next_; - std::size_t count = this->delete_nodes(prev, end); + std::size_t count_lcl = this->delete_nodes(prev, end); this->fix_bucket(bucket_index, prev); - return count; + return count_lcl; } iterator erase(c_iterator r) @@ -557,21 +557,21 @@ return iterator(r2.node_); } - link_pointer erase_nodes(node_pointer begin, node_pointer end) + link_pointer erase_nodes(node_pointer begin_arg, node_pointer end) { - std::size_t bucket_index = this->hash_to_bucket(begin->hash_); + std::size_t bucket_index = this->hash_to_bucket(begin_arg->hash_); - // Split the groups containing 'begin' and 'end'. - // And get the pointer to the node before begin while + // Split the groups containing 'begin_arg' and 'end.' + // And get the pointer to the node before begin_arg while // we're at it. - link_pointer prev = split_groups(begin, end); + link_pointer prev = split_groups(begin_arg, end); - // If we don't have a 'prev' it means that begin is at the + // If we don't have a 'prev' it means that begin_arg is at the // beginning of a block, so search through the blocks in the // same bucket. if (!prev) { prev = this->get_previous_start(bucket_index); - while (prev->next_ != begin) + while (prev->next_ != begin_arg) prev = static_cast(prev->next_)->group_prev_; } @@ -586,27 +586,27 @@ return prev; } - static link_pointer split_groups(node_pointer begin, node_pointer end) + static link_pointer split_groups(node_pointer begin_arg, node_pointer end) { - node_pointer prev = begin->group_prev_; - if (prev->next_ != begin) prev = node_pointer(); + node_pointer prev = begin_arg->group_prev_; + if (prev->next_ != begin_arg) prev = node_pointer(); if (end) { node_pointer first = end; - while (first != begin && first->group_prev_->next_ == first) { + while (first != begin_arg && first->group_prev_->next_ == first) { first = first->group_prev_; } boost::swap(first->group_prev_, end->group_prev_); - if (first == begin) return prev; + if (first == begin_arg) return prev; } if (prev) { node_pointer first = prev; while (first->group_prev_->next_ == first) { first = first->group_prev_; } - boost::swap(first->group_prev_, begin->group_prev_); + boost::swap(first->group_prev_, begin_arg->group_prev_); } return prev; --- foo/foo/foo/boost/unordered/detail/table.hpp +++ foo/foo/foo/boost/unordered/detail/table.hpp @@ -256,9 +256,9 @@ return prev ? iterator(prev->next_) : iterator(); } - std::size_t hash_to_bucket(std::size_t hash) const + std::size_t hash_to_bucket(std::size_t hash_arg) const { - return policy::to_bucket(bucket_count_, hash); + return policy::to_bucket(bucket_count_, hash_arg); } float load_factor() const @@ -655,8 +655,8 @@ // assign_nodes takes ownership of the container's elements, // assigning to them if possible, and deleting any that are // left over. - assign_nodes assign(*this); - table_impl::fill_buckets(x.begin(), *this, assign); + assign_nodes
assign_lcl(*this); + table_impl::fill_buckets(x.begin(), *this, assign_lcl); } void assign(table const& x, true_type) @@ -732,9 +732,9 @@ // move_assign_nodes takes ownership of the container's // elements, assigning to them if possible, and deleting // any that are left over. - move_assign_nodes
assign(*this); + move_assign_nodes
assign_lcl(*this); node_holder nodes(x); - table_impl::fill_buckets(nodes.begin(), *this, assign); + table_impl::fill_buckets(nodes.begin(), *this, assign_lcl); } } --- foo/foo/foo/boost/unordered/detail/unique.hpp +++ foo/foo/foo/boost/unordered/detail/unique.hpp @@ -531,9 +531,9 @@ link_pointer end = static_cast(prev->next_)->next_; - std::size_t count = this->delete_nodes(prev, end); + std::size_t count_lcl = this->delete_nodes(prev, end); this->fix_bucket(bucket_index, prev); - return count; + return count_lcl; } iterator erase(c_iterator r) @@ -552,13 +552,13 @@ return iterator(r2.node_); } - void erase_nodes(node_pointer begin, node_pointer end) + void erase_nodes(node_pointer begin_arg, node_pointer end) { - std::size_t bucket_index = this->hash_to_bucket(begin->hash_); + std::size_t bucket_index = this->hash_to_bucket(begin_arg->hash_); - // Find the node before begin. + // Find the node before begin_arg. link_pointer prev = this->get_previous_start(bucket_index); - while(prev->next_ != begin) prev = prev->next_; + while(prev->next_ != begin_arg) prev = prev->next_; // Delete the nodes. do {