Class splitmix64

boost::random::splitmix64

Synopsis

// In header: <boost/random/splitmix64.hpp>


class splitmix64 {
public:
  // types
  typedef  ;
  typedef  ;  

  // private member functions
   (, ) ;

  // public member functions
   ( = ) ;
  template<typename Sseq, 
           typename std::enable_if<!std::is_convertible< Sseq, std::uint64_t >::value, bool >::type> 
     ();
  template<typename Sseq, 
           typename std::enable_if<!std::is_convertible< Sseq, splitmix64 >::value, bool >::type> 
    ();
  template<typename T, 
           typename std::enable_if< std::is_convertible< T, std::uint64_t >::value, bool >::type> 
     ( = ) ;
  ( = ) ;
  () = ;
   () = ;
   () ;
   () ;
   () ;
  template<typename FIter>  (, ) ;

  // friend functions
   (, ) ;
   (, ) ;
  template<typename CharT, typename Traits> 
     
    (, );
  template<typename CharT, typename Traits> 
     
    (, );

  // public static functions
   () ;
   () ;

  // public data members
  static  has_fixed_range;
};

Description

This is a fixed-increment version of Java 8's SplittableRandom generator See http://dx.doi.org/10.1145/2714064.2660195 and http://docs.oracle.com/javase/8/docs/api/java/util/SplittableRandom.html It is a very fast generator passing BigCrush, and it can be useful if for some reason you absolutely want 64 bits of state; otherwise, we rather suggest to use a xoroshiro128+ (for moderately parallel computations) or xorshift1024* (for massively parallel computations) generator.

`splitmix64` private member functions

```
 ( word1,  word2) ;
```

`splitmix64` public member functions

```
 ( value = ) ;
```
Seeds the generator with the default seed.

template<typename Sseq, 
         typename std::enable_if<!std::is_convertible< Sseq, std::uint64_t >::value, bool >::type> 
   ( seq);

Seeds the generator with 32-bit values produced by seq.generate().

template<typename Sseq, 
         typename std::enable_if<!std::is_convertible< Sseq, splitmix64 >::value, bool >::type> 
  ( seq);

Seeds the generator with 64-bit values produced by seq.generate().

template<typename T, 
         typename std::enable_if< std::is_convertible< T, std::uint64_t >::value, bool >::type> 
   ( value = ) ;

Seeds the generator with a user provided seed.

```
( state = ) ;
```
Seeds the generator with a user provided seed.
```
( other) = ;
```
```
 ( other) = ;
```
```
 () ;
```
Returns the next value of the generator.
```
 () ;
```
Returns the next value of the generator.
```
 ( z) ;
```
Advances the state of the generator by z.

template<typename FIter>  ( first,  last) ;

Fills a range with random values

`splitmix64` friend functions

```
 ( lhs,  rhs) ;
```
Returns true if the two generators will produce identical sequences of values.
```
 ( lhs,  rhs) ;
```
Returns true if the two generators will produce different sequences of values.

template<typename CharT, typename Traits> 
   
  ( ost,  e);

Writes a splitmix64 to a std::ostream.

template<typename CharT, typename Traits> 
   
  ( ist,  e);

Writes a splitmix64 to a std::istream.

`splitmix64` public static functions

```
 () ;
```
Returns the largest value that the splitmix64 can produce.
```
 () ;
```
Returns the smallest value that the splitmix64 can produce.