UniformRandom.hpp

/******************************************************************************
* Copyright (c) ATTX LLC 2024. All Rights Reserved.
*
* This software and associated documentation (the "Software") are the 
* proprietary and confidential information of ATTX, LLC. The Software is 
* furnished under a license agreement between ATTX and the user organization 
* and may be used or copied only in accordance with the terms of the agreement.
* Refer to 'license/attx_license.adoc' for standard license terms.
*
* EXPORT CONTROL NOTICE: THIS SOFTWARE MAY INCLUDE CONTENT CONTROLLED UNDER THE
* INTERNATIONAL TRAFFIC IN ARMS REGULATIONS (ITAR) OR THE EXPORT ADMINISTRATION 
* REGULATIONS (EAR99). No part of the Software may be used, reproduced, or 
* transmitted in any form or by any means, for any purpose, without the express 
* written permission of ATTX, LLC.
******************************************************************************/
/*
Uniform Random Distribution Header File
 
Author: Alex Reynolds
*/
#ifndef UNIFORM_RANDOM_HPP
#define UNIFORM_RANDOM_HPP
 
#include <random>
 
#include "data_management/GraphTreeObject.h"
#include "data_management/DataIO.hpp"
 
namespace modelspace {
 
    /**
     * @brief   Class to generate random numbers according to uniform distribution
     * 
     * This function generates a random uniform distribution draw according to
     * the mt19937 engine and a std::uniform_distribution. It produces random
     * numbers according to the min, max, and seed set in the constructor. Min 
     * and max may be modified via standard setters mean and std.
     * 
     * If numbers are entered backwards, will flip them
    */
    template<typename T>
    class UniformRandom : clockwerk::GraphTreeObject {
    public:
        /// @brief Constructor for the normal random distribution
        /// @param set_min The minimum value in the distribution
        /// @param set_max The maximum value in the distribution
        /// @param seed Seed for the RNG -- Defaults to zero
        UniformRandom(T set_min, T set_max, unsigned int seed = 0);
        ~UniformRandom() {}
 
        T operator () ();
 
        /// @brief The mean of the random output. Can be get/set
        clockwerk::DataIO<T> min = clockwerk::DataIO<T>(this, "min");
 
        /// @brief The standard deviation of the random output. Can be get/set
        clockwerk::DataIO<T> max = clockwerk::DataIO<T>(this, "max");
    protected:
        std::mt19937 _engine;
        std::uniform_real_distribution<double> _distribution;
    };
 
    template <typename T>
    UniformRandom<T>::UniformRandom(T set_min, T set_max, unsigned int seed)
        : _engine{seed}, _distribution(0, 1.0) {
        // Handle the case where someone put numbers in backwards. Someone will.
        if(set_min > set_max) {
            min(set_max);
            max(set_min);
        } else {
            min(set_min);
            max(set_max);
        }
    }
 
    template <typename T>
    T UniformRandom<T>::operator () () {
        // Calculate our distribution as 
        // val = min + (max - min)*rng
 
        return min() + _distribution(_engine)*(max() - min());
    }
 
}
 
#endif