Random.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        CloudViewer: www.cloudViewer.org                  -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.cloudViewer.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#pragma once
 
#include <Logging.h>
 
#include <algorithm>
#include <mutex>
#include <random>
#include <vector>
 
namespace cloudViewer {
namespace utility {
namespace random {
 
void Seed(const int seed);
 
std::mt19937* GetEngine();
 
std::mutex* GetMutex();
 
uint32_t RandUint32();
 
template <typename T>
class UniformIntGenerator {
public:
    UniformIntGenerator(const T low, const T high) : distribution_(low, high) {
        if (low < 0) {
            utility::LogError("low must be > 0, but got {}.", low);
        }
        if (low > high) {
            utility::LogError(
                    "low must be <= high, but got low={} and high={}.", low,
                    high);
        }
    }
 
    T operator()() {
        std::lock_guard<std::mutex> lock(*GetMutex());
        return distribution_(*GetEngine());
    }
 
protected:
    std::uniform_int_distribution<T> distribution_;
};
 
template <typename T>
class UniformRealGenerator {
public:
    UniformRealGenerator(const T low = 0.0, const T high = 1.0)
        : distribution_(low, high) {
        if (low >= high) {
            utility::LogError("low must be < high, but got low={} and high={}.",
                              low, high);
        }
    }
 
    T operator()() {
        std::lock_guard<std::mutex> lock(*GetMutex());
        return distribution_(*GetEngine());
    }
 
protected:
    std::uniform_real_distribution<T> distribution_;
};
 
template <typename T>
class NormalGenerator {
public:
    NormalGenerator(const T mean = 0.0, const T stddev = 1.0)
        : distribution_(mean, stddev) {
        if (stddev <= 0) {
            utility::LogError("stddev must be > 0, but got {}.", stddev);
        }
    }
 
    T operator()() {
        std::lock_guard<std::mutex> lock(*GetMutex());
        return distribution_(*GetEngine());
    }
 
protected:
    std::normal_distribution<T> distribution_;
};
 
template <typename T>
class DiscreteGenerator {
public:
    template <typename InputIt>
    DiscreteGenerator(InputIt first, InputIt last)
        : distribution_(first, last) {
        if (first > last) {
            utility::LogError("first must be <= last.");
        }
    }
 
    T operator()() {
        std::lock_guard<std::mutex> lock(*GetMutex());
        return distribution_(*GetEngine());
    }
 
protected:
    std::discrete_distribution<T> distribution_;
};
 
}  // namespace random
}  // namespace utility
}  // namespace cloudViewer