comparison DEPENDENCIES/generic/include/boost/random/lagged_fibonacci.hpp @ 101:c530137014c0

Update Boost headers (1.58.0)

  * accompanying file LICENSE_1_0.txt or copy at
  * http://www.boost.org/LICENSE_1_0.txt)
  *
  * See http://www.boost.org for most recent version including documentation.
  *
- * $Id: lagged_fibonacci.hpp 72951 2011-07-07 04:57:37Z steven_watanabe $
+ * $Id$
  *
  * Revision history
+ *  2013-10-14  fixed some warnings with Wshadow (mgaunard)
  *  2001-02-18  moved to individual header files
  */
 
 #ifndef BOOST_RANDOM_LAGGED_FIBONACCI_HPP
 #define BOOST_RANDOM_LAGGED_FIBONACCI_HPP

 #include <boost/random/detail/generator_seed_seq.hpp>
 
 namespace boost {
 namespace random {
 
-/** 
+/**
  * Instantiations of class template \lagged_fibonacci_engine model a
  * \pseudo_random_number_generator. It uses a lagged Fibonacci
  * algorithm with two lags @c p and @c q:
  * x(i) = x(i-p) + x(i-q) (mod 2<sup>w</sup>) with p > q.
  */

      */
     template<class It> lagged_fibonacci_engine(It& first, It last)
     { seed(first, last); }
 
     // compiler-generated copy ctor and assignment operator are fine
-    
+
     /** Calls @c seed(default_seed). */
     void seed() { seed(default_seed); }
 
     /**
      * Sets the state of the generator to values produced by

     {
         if(i >= long_lag)
             fill();
         return x[i++];
     }
-  
+
     /** Fills a range with random values */
     template<class Iter>
     void generate(Iter first, Iter last)
     { detail::generate_from_int(*this, first, last); }
 

     {
         for(boost::uintmax_t j = 0; j < z; ++j) {
             (*this)();
         }
     }
-  
+
     /**
      * Writes the textual representation of the generator to a @c std::ostream.
      */
     BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, lagged_fibonacci_engine, f)
     {
         os << f.i;
-        for(unsigned int i = 0; i < f.long_lag; ++i)
-            os << ' ' << f.x[i];
+        for(unsigned int j = 0; j < f.long_lag; ++j)
+            os << ' ' << f.x[j];
         return os;
     }
-    
+
     /**
      * Reads the textual representation of the generator from a @c std::istream.
      */
     BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, lagged_fibonacci_engine, f)
     {
         is >> f.i >> std::ws;
-        for(unsigned int i = 0; i < f.long_lag; ++i)
-            is >> f.x[i] >> std::ws;
+        for(unsigned int j = 0; j < f.long_lag; ++j)
+            is >> f.x[j] >> std::ws;
         return is;
     }
-    
+
     /**
      * Returns true if the two generators will produce identical
      * sequences of outputs.
      */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(lagged_fibonacci_engine, x, y)
-    { return x.i == y.i && std::equal(x.x, x.x+long_lag, y.x); }
-    
+    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(lagged_fibonacci_engine, x_, y_)
+    { return x_.i == y_.i && std::equal(x_.x, x_.x+long_lag, y_.x); }
+
     /**
      * Returns true if the two generators will produce different
      * sequences of outputs.
      */
     BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(lagged_fibonacci_engine)

     BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(lagged_fibonacci_01_engine, SeedSeq, seq)
     {
         detail::seed_array_real<w>(seq, x);
         i = long_lag;
     }
-    
+
     /**
      * Seeds this @c lagged_fibonacci_01_engine using values from the
      * iterator range [first, last).  If there are not enough elements
      * in the range, throws @c std::invalid_argument.
      */

     void seed(It& first, It last)
     {
         detail::fill_array_real<w>(first, last, x);
         i = long_lag;
     }
-    
+
     /** Returns the smallest value that the generator can produce. */
     static result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () { return result_type(0); }
     /** Returns the upper bound of the generators outputs. */
     static result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () { return result_type(1); }
 

     {
         if(i >= long_lag)
             fill();
         return x[i++];
     }
-  
+
     /** Fills a range with random values */
     template<class Iter>
     void generate(Iter first, Iter last)
     { return detail::generate_from_real(*this, first, last); }
 

     {
         for(boost::uintmax_t j = 0; j < z; ++j) {
             (*this)();
         }
     }
-    
+
     /**
      * Writes the textual representation of the generator to a @c std::ostream.
      */
     BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, lagged_fibonacci_01_engine, f)
     {
         // allow for Koenig lookup
         using std::pow;
         os << f.i;
-        std::ios_base::fmtflags oldflags = os.flags(os.dec | os.fixed | os.left); 
-        for(unsigned int i = 0; i < f.long_lag; ++i)
-            os << ' ' << f.x[i] * f.modulus();
+        std::ios_base::fmtflags oldflags = os.flags(os.dec | os.fixed | os.left);
+        for(unsigned int j = 0; j < f.long_lag; ++j)
+            os << ' ' << f.x[j] * f.modulus();
         os.flags(oldflags);
         return os;
     }
-    
+
     /**
      * Reads the textual representation of the generator from a @c std::istream.
      */
     BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, lagged_fibonacci_01_engine, f)
     {
         is >> f.i;
-        for(unsigned int i = 0; i < f.long_lag; ++i) {
+        for(unsigned int j = 0; j < f.long_lag; ++j) {
             typename lagged_fibonacci_01_engine::result_type value;
             is >> std::ws >> value;
-            f.x[i] = value / f.modulus();
+            f.x[j] = value / f.modulus();
         }
         return is;
     }
-    
+
     /**
      * Returns true if the two generators will produce identical
      * sequences of outputs.
      */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(lagged_fibonacci_01_engine, x, y)
-    { return x.i == y.i && std::equal(x.x, x.x+long_lag, y.x); }
-    
+    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(lagged_fibonacci_01_engine, x_, y_)
+    { return x_.i == y_.i && std::equal(x_.x, x_.x+long_lag, y_.x); }
+
     /**
      * Returns true if the two generators will produce different
      * sequences of outputs.
      */
     BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(lagged_fibonacci_01_engine)