Class template uniform_on_sphere

boost::random::uniform_on_sphere

Synopsis

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

template<typename RealType = double, typename Cont = std::vector<RealType> > 
class uniform_on_sphere {
public:
  // types
  typedef RealType input_type; 
  typedef Cont     result_type;

  // member classes/structs/unions

  class param_type {
  public:
    // types
    typedef uniform_on_sphere distribution_type;

    // construct/copy/destruct
    explicit param_type(int = 2);

    // public member functions
    int dim() const;

    // friend functions
    template<typename CharT, typename Traits> 
      friend std::basic_ostream< CharT, Traits > & 
      operator<<(std::basic_ostream< CharT, Traits > &, const param_type &);
    template<typename CharT, typename Traits> 
      friend std::basic_istream< CharT, Traits > & 
      operator>>(std::basic_istream< CharT, Traits > &, const param_type &);
    friend bool operator==(const param_type &, const param_type &);
    friend bool operator!=(const param_type &, const param_type &);
  };

  // construct/copy/destruct
  explicit uniform_on_sphere(int = 2);
  explicit uniform_on_sphere(const param_type &);

  // public member functions
  int dim() const;
  param_type param() const;
  void param(const param_type &);
  result_type min() const;
  result_type max() const;
  void reset();
  template<typename Engine> const result_type & operator()(Engine &);
  template<typename Engine> 
    result_type operator()(Engine &, const param_type &) const;

  // friend functions
  template<typename CharT, typename Traits> 
    friend std::basic_ostream< CharT, Traits > & 
    operator<<(std::basic_ostream< CharT, Traits > &, 
               const uniform_on_sphere &);
  template<typename CharT, typename Traits> 
    friend std::basic_istream< CharT, Traits > & 
    operator>>(std::basic_istream< CharT, Traits > &, 
               const uniform_on_sphere &);
  friend bool operator==(const uniform_on_sphere &, const uniform_on_sphere &);
  friend bool operator!=(const uniform_on_sphere &, const uniform_on_sphere &);
};

Description

Instantiations of class template uniform_on_sphere model a random distribution . Such a distribution produces random numbers uniformly distributed on the unit sphere of arbitrary dimension dim. The Cont template parameter must be a STL-like container type with begin and end operations returning non-const ForwardIterators of type Cont::iterator.

`uniform_on_sphere` public construct/copy/destruct

```
explicit uniform_on_sphere(int dim = 2);
```
Constructs a uniform_on_sphere distribution. dim is the dimension of the sphere.

Requires: dim >= 0
```
explicit uniform_on_sphere(const param_type & param);
```
Constructs a uniform_on_sphere distribution from its parameters.

`uniform_on_sphere` public member functions

```
int dim() const;
```
Returns the dimension of the sphere.
```
param_type param() const;
```
Returns the parameters of the distribution.
```
void param(const param_type & param);
```
Sets the parameters of the distribution.
```
result_type min() const;
```
Returns the smallest value that the distribution can produce. Note that this is required to approximate the standard library's requirements. The behavior is defined according to lexicographical comparison so that for a container type of std::vector, dist.min() <= x <= dist.max() where x is any value produced by the distribution.
```
result_type max() const;
```
Returns the largest value that the distribution can produce. Note that this is required to approximate the standard library's requirements. The behavior is defined according to lexicographical comparison so that for a container type of std::vector, dist.min() <= x <= dist.max() where x is any value produced by the distribution.
```
void reset();
```
Effects: Subsequent uses of the distribution do not depend on values produced by any engine prior to invoking reset.
```
template<typename Engine> const result_type & operator()(Engine & eng);
```
Returns a point uniformly distributed over the surface of a sphere of dimension dim().

template<typename Engine> 
  result_type operator()(Engine & eng, const param_type & param) const;

Returns a point uniformly distributed over the surface of a sphere of dimension param.dim().

`uniform_on_sphere` friend functions

template<typename CharT, typename Traits> 
  friend std::basic_ostream< CharT, Traits > & 
  operator<<(std::basic_ostream< CharT, Traits > & os, 
             const uniform_on_sphere & sd);

Writes the distribution to a std::ostream.

template<typename CharT, typename Traits> 
  friend std::basic_istream< CharT, Traits > & 
  operator>>(std::basic_istream< CharT, Traits > & is, 
             const uniform_on_sphere & sd);

Reads the distribution from a std::istream.

friend bool operator==(const uniform_on_sphere & lhs, 
                       const uniform_on_sphere & rhs);

Returns true if the two distributions will produce identical sequences of values, given equal generators.

friend bool operator!=(const uniform_on_sphere & lhs, 
                       const uniform_on_sphere & rhs);

Returns true if the two distributions may produce different sequences of values, given equal generators.

Boost C++ Libraries