Random.h

Go to the documentation of this file.

/*
 * Copyright 2006-2009 Savarese Software Research Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.savarese.com/software/ApacheLicense-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef __SSRC_WSPR_UTILITY_RANDOM_H
#define __SSRC_WSPR_UTILITY_RANDOM_H

#include <ssrc/wispers-packages.h>

#include <fcntl.h>
#include <unistd.h>

#include <cerrno>
#include <cstring>
#include <stdexcept>

#include <boost/integer_traits.hpp>
#include <boost/nondet_random.hpp>
#include <boost/random/uniform_int.hpp>
#include <boost/random/variate_generator.hpp>

__BEGIN_NS_SSRC_WSPR_UTILITY

class random_device {
  int _fd;

public:
  explicit random_device(const std::string & device_file = "/dev/urandom")
    SSRC_DECL_THROW(std::runtime_error) :
    _fd(::open(device_file.c_str(), O_RDONLY))
  {
    if(_fd < 0)
      throw std::runtime_error(std::strerror(errno));
  }

  ~random_device() {
    ::close(_fd);
  }

  template<typename result_type>
  void read(result_type & result) const SSRC_DECL_THROW(std::runtime_error) {
    if(::read(_fd, &result, sizeof(result_type)) != sizeof(result_type))
      throw std::runtime_error(std::strerror(errno));
  }
};

template<typename int_type>
class random_engine {
  random_device _dev_random;

 public:
  typedef int_type result_type;
  static const bool has_fixed_range = true;
  static const result_type min_value =
    boost::integer_traits<result_type>::const_min;
  static const result_type max_value =
    boost::integer_traits<result_type>::const_max;

  explicit random_engine(const std::string & device_file = "/dev/urandom")
    SSRC_DECL_THROW(std::runtime_error) :
    _dev_random(device_file)
  { }

  result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const {
    return min_value;
  } 

  result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const {
    return max_value;
  }

  double entropy() const {
    return 10;
  }

  result_type operator()() const SSRC_DECL_THROW(std::runtime_error) {
    result_type result;
    _dev_random.read(result);
    return result;
  }
};

template<typename int_type,
         template <typename U> class distribution = boost::uniform_int,
         class engine = random_engine<unsigned int> >
class Random {
public:
  typedef int_type result_type;
  typedef boost::integer_traits<result_type> result_type_traits;
  typedef engine random_engine;
  typedef distribution<result_type> random_distribution;

private:
  random_engine _engine;
  boost::variate_generator<random_engine &, random_distribution> _random;

public:

  explicit Random(result_type min = result_type_traits::const_min,
                  result_type max = result_type_traits::const_max) :
    _engine(), _random(_engine, random_distribution(min, max))
  { }

  result_type operator()() {
    return _random();
  }
};


__END_NS_SSRC_WSPR_UTILITY

#endif