uniform_random.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2014-2015, Hewlett-Packard Development Company, LP.
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details. You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 * HP designates this particular file as subject to the "Classpath" exception
 * as provided by HP in the LICENSE.txt file that accompanied this code.
 */
#ifndef FOEDUS_ASSORTED_UNIFORM_RANDOM_HPP_
#define FOEDUS_ASSORTED_UNIFORM_RANDOM_HPP_

#include <stdint.h>

#include "foedus/assert_nd.hpp"
#include "foedus/memory/fwd.hpp"

namespace foedus {
namespace assorted {
class UniformRandom {
 public:
  UniformRandom() : seed_(0) {}
  explicit UniformRandom(uint64_t seed) : seed_(seed) {}

  uint32_t uniform_within(uint32_t from, uint32_t to) {
    ASSERT_ND(from <= to);
    if (from == to) {
      return from;
    }
    return from + (next_uint32() % (to - from + 1));
  }
  uint32_t uniform_within_except(uint32_t from, uint32_t to, uint32_t except) {
    while (true) {
      uint32_t val = uniform_within(from, to);
      if (val != except) {
        return val;
      }
    }
  }

  uint32_t non_uniform_within(uint32_t A, uint32_t from, uint32_t to) {
    uint32_t C = get_c(A);
    return  (((uniform_within(0, A) | uniform_within(from, to)) + C) % (to - from + 1)) + from;
  }

  uint64_t get_current_seed() const {
    return seed_;
  }
  void set_current_seed(uint64_t seed) {
    seed_ = seed;
  }

  void fill_memory(foedus::memory::AlignedMemory *memory);

  uint64_t next_uint64() {
    return (static_cast<uint64_t>(next_uint32()) << 32) | next_uint32();
  }
  uint32_t next_uint32() {
    seed_ = seed_ * 0xD04C3175 + 0x53DA9022;
    return (seed_ >> 32) ^ (seed_ & 0xFFFFFFFF);
  }

 private:
  uint64_t seed_;

  uint32_t get_c(uint32_t A) const {
    // yes, I'm lazy. but this satisfies the spec.
    const uint64_t kCSeed = 0x734b00c6d7d3bbdaULL;
    return kCSeed % (A + 1);
  }
};

}  // namespace assorted
}  // namespace foedus

#endif  // FOEDUS_ASSORTED_UNIFORM_RANDOM_HPP_