external/boost/boost.random.Wshadow.warnings.patch

   1 --- misc/boost_1_44_0/boost/random/mersenne_twister.hpp
   2 +++ misc/build/boost_1_44_0/boost/random/mersenne_twister.hpp
   3 @@ -195,19 +195,19 @@
   4       * Returns true if the two generators are in the same state,
   5       * and will thus produce identical sequences.
   6       */
   7 -    friend bool operator==(const mersenne_twister_engine& x,
   8 -                           const mersenne_twister_engine& y)
   9 +    friend bool operator==(const mersenne_twister_engine& x_arg,
  10 +                           const mersenne_twister_engine& y_arg)
  11      {
  12 -        if(x.i < y.i) return x.equal_imp(y);
  13 -        else return y.equal_imp(x);
  14 +        if(x_arg.i < y_arg.i) return x_arg.equal_imp(y_arg);
  15 +        else return y_arg.equal_imp(x_arg);
  16      }
  17
  18      /**
  19       * Returns true if the two generators are in different states.
  20       */
  21 -    friend bool operator!=(const mersenne_twister_engine& x,
  22 -                           const mersenne_twister_engine& y)
  23 -    { return !(x == y); }
  24 +    friend bool operator!=(const mersenne_twister_engine& x_arg,
  25 +                           const mersenne_twister_engine& y_arg)
  26 +    { return !(x_arg == y_arg); }
  27
  28  private:
  29      /// \cond show_private
  30 --- foo/foo/foo/boost/random/binomial_distribution.hpp
  31 +++ foo/foo/foo/boost/random/binomial_distribution.hpp
  32 @@ -272,21 +272,21 @@
  33          using std::sqrt;
  34          using std::pow;
  35
  36 -        RealType p = (0.5 < _p)? (1 - _p) : _p;
  37 -        IntType t = _t;
  38 +        RealType p_lcl = (0.5 < _p)? (1 - _p) : _p;
  39 +        IntType t_lcl = _t;
  40
  41 -        m = static_cast<IntType>((t+1)*p);
  42 +        m = static_cast<IntType>((t_lcl+1)*p_lcl);
  43
  44          if(use_inversion()) {
  45 -            q_n = pow((1 - p), static_cast<RealType>(t));
  46 +            q_n = pow((1 - p_lcl), static_cast<RealType>(t_lcl));
  47          } else {
  48 -            btrd.r = p/(1-p);
  49 -            btrd.nr = (t+1)*btrd.r;
  50 -            btrd.npq = t*p*(1-p);
  51 +            btrd.r = p_lcl/(1-p_lcl);
  52 +            btrd.nr = (t_lcl+1)*btrd.r;
  53 +            btrd.npq = t_lcl*p_lcl*(1-p_lcl);
  54              RealType sqrt_npq = sqrt(btrd.npq);
  55              btrd.b = 1.15 + 2.53 * sqrt_npq;
  56 -            btrd.a = -0.0873 + 0.0248*btrd.b + 0.01*p;
  57 -            btrd.c = t*p + 0.5;
  58 +            btrd.a = -0.0873 + 0.0248*btrd.b + 0.01*p_lcl;
  59 +            btrd.c = t_lcl*p_lcl + 0.5;
  60              btrd.alpha = (2.83 + 5.1/btrd.b) * sqrt_npq;
  61              btrd.v_r = 0.92 - 4.2/btrd.b;
  62              btrd.u_rv_r = 0.86*btrd.v_r;
  63 @@ -304,9 +304,9 @@
  64              RealType u;
  65              RealType v = uniform_01<RealType>()(urng);
  66              if(v <= btrd.u_rv_r) {
  67 -                RealType u = v/btrd.v_r - 0.43;
  68 +                RealType u_lcl = v/btrd.v_r - 0.43;
  69                  return static_cast<IntType>(floor(
  70 -                    (2*btrd.a/(0.5 - abs(u)) + btrd.b)*u + btrd.c));
  71 +                    (2*btrd.a/(0.5 - abs(u_lcl)) + btrd.b)*u_lcl + btrd.c));
  72              }
  73
  74              if(v >= btrd.v_r) {
  75 @@ -344,9 +344,9 @@
  76                  v = log(v);
  77                  RealType rho =
  78                      (km/btrd.npq)*(((km/3. + 0.625)*km + 1./6)/btrd.npq + 0.5);
  79 -                RealType t = -km*km/(2*btrd.npq);
  80 -                if(v < t - rho) return k;
  81 -                if(v > t + rho) continue;
  82 +                RealType t_lcl = -km*km/(2*btrd.npq);
  83 +                if(v < t_lcl - rho) return k;
  84 +                if(v > t_lcl + rho) continue;
  85
  86                  IntType nm = _t - m + 1;
  87                  RealType h = (m + 0.5)*log((m + 1)/(btrd.r*nm))
  88 @@ -367,11 +367,11 @@
  89      }
  90
  91      template<class URNG>
  92 -    IntType invert(IntType t, RealType p, URNG& urng) const
  93 +    IntType invert(IntType t_arg, RealType p_arg, URNG& urng) const
  94      {
  95 -        RealType q = 1 - p;
  96 -        RealType s = p / q;
  97 -        RealType a = (t + 1) * s;
  98 +        RealType q = 1 - p_arg;
  99 +        RealType s = p_arg / q;
 100 +        RealType a = (t_arg + 1) * s;
 101          RealType r = q_n;
 102          RealType u = uniform_01<RealType>()(urng);
 103          IntType x = 0;
 104 --- foo/foo/foo/boost/random/geometric_distribution.hpp
 105 +++ foo/foo/foo/boost/random/geometric_distribution.hpp
 106 @@ -104,8 +104,8 @@
 107       *
 108       * Requires: 0 < p < 1
 109       */
 110 -    explicit geometric_distribution(const RealType& p = RealType(0.5))
 111 -      : _p(p)
 112 +    explicit geometric_distribution(const RealType& p_arg = RealType(0.5))
 113 +      : _p(p_arg)
 114      {
 115          BOOST_ASSERT(RealType(0) < _p && _p < RealType(1));
 116          init();
 117 --- foo/foo/foo/boost/random/shuffle_order.hpp
 118 +++ foo/foo/foo/boost/random/shuffle_order.hpp
 119 @@ -200,8 +200,8 @@
 120      }
 121
 122      /** Returns true if the two generators will produce identical sequences. */
 123 -    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(shuffle_order_engine, x, y)
 124 -    { return x._rng == y._rng && x.y == y.y && std::equal(x.v, x.v+k, y.v); }
 125 +    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(shuffle_order_engine, x, y_arg)
 126 +    { return x._rng == y_arg._rng && x.y == y_arg.y && std::equal(x.v, x.v+k, y_arg.v); }
 127      /** Returns true if the two generators will produce different sequences. */
 128      BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(shuffle_order_engine)
 129
 130 --- foo/foo/foo/boost/random/subtract_with_carry.hpp
 131 +++ foo/foo/foo/boost/random/subtract_with_carry.hpp
 132 @@ -268,21 +268,21 @@
 133
 134      friend struct detail::subtract_with_carry_discard;
 135
 136 -    IntType do_update(std::size_t current, std::size_t short_index, IntType carry)
 137 +    IntType do_update(std::size_t current, std::size_t short_index, IntType carry_arg)
 138      {
 139          IntType delta;
 140 -        IntType temp = x[current] + carry;
 141 +        IntType temp = x[current] + carry_arg;
 142          if (x[short_index] >= temp) {
 143              // x(n) >= 0
 144              delta =  x[short_index] - temp;
 145 -            carry = 0;
 146 +            carry_arg = 0;
 147          } else {
 148              // x(n) < 0
 149              delta = modulus - temp + x[short_index];
 150 -            carry = 1;
 151 +            carry_arg = 1;
 152          }
 153          x[current] = delta;
 154 -        return carry;
 155 +        return carry_arg;
 156      }
 157      /// \endcond
 158
 159 @@ -498,17 +498,17 @@
 160
 161      friend struct detail::subtract_with_carry_discard;
 162
 163 -    RealType do_update(std::size_t current, std::size_t short_index, RealType carry)
 164 +    RealType do_update(std::size_t current, std::size_t short_index, RealType carry_arg)
 165      {
 166 -        RealType delta = x[short_index] - x[current] - carry;
 167 +        RealType delta = x[short_index] - x[current] - carry_arg;
 168          if(delta < 0) {
 169              delta += RealType(1);
 170 -            carry = RealType(1)/_modulus;
 171 +            carry_arg = RealType(1)/_modulus;
 172          } else {
 173 -            carry = 0;
 174 +            carry_arg = 0;
 175          }
 176          x[current] = delta;
 177 -        return carry;
 178 +        return carry_arg;
 179      }
 180      /// \endcond
 181      std::size_t k;