| --- 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<T>(); |
| + int s_lcl; |
| + prefix = boost::math::lgamma(-v, &s_lcl, pol) + p; |
| + prefix = exp(prefix) * s_lcl / constants::pi<T>(); |
| } |
| bessel_y_small_z_series_term_b<T, Policy> s2(v, x); |
| max_iter = policies::get_max_series_iterations<Policy>(); |
| --- 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<IntType>((t+1)*p); |
| + m = static_cast<IntType>((t_lcl+1)*p_lcl); |
| |
| if(use_inversion()) { |
| - q_n = pow((1 - p), static_cast<RealType>(t)); |
| + q_n = pow((1 - p_lcl), static_cast<RealType>(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<RealType>()(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<IntType>(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<class URNG> |
| - 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<RealType>()(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/unordered/detail/equivalent.hpp |
| +++ foo/foo/foo/boost/unordered/detail/equivalent.hpp |
| @@ -536,9 +536,9 @@ |
| node_pointer first_node = static_cast<node_pointer>(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<node_pointer>(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<table> assign(*this); |
| - table_impl::fill_buckets(x.begin(), *this, assign); |
| + assign_nodes<table> 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<table> assign(*this); |
| + move_assign_nodes<table> assign_lcl(*this); |
| node_holder<node_allocator> 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<node_pointer>(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 { |