RNG.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <random>
 
#include "NumCpp/Core/Enums.hpp"
#include "NumCpp/Random/bernoulli.hpp"
#include "NumCpp/Random/beta.hpp"
#include "NumCpp/Random/binomial.hpp"
#include "NumCpp/Random/cauchy.hpp"
#include "NumCpp/Random/chiSquare.hpp"
#include "NumCpp/Random/choice.hpp"
#include "NumCpp/Random/discrete.hpp"
#include "NumCpp/Random/exponential.hpp"
#include "NumCpp/Random/extremeValue.hpp"
#include "NumCpp/Random/f.hpp"
#include "NumCpp/Random/gamma.hpp"
#include "NumCpp/Random/geometric.hpp"
#include "NumCpp/Random/laplace.hpp"
#include "NumCpp/Random/lognormal.hpp"
#include "NumCpp/Random/negativeBinomial.hpp"
#include "NumCpp/Random/nonCentralChiSquared.hpp"
#include "NumCpp/Random/normal.hpp"
#include "NumCpp/Random/permutation.hpp"
#include "NumCpp/Random/poisson.hpp"
#include "NumCpp/Random/rand.hpp"
#include "NumCpp/Random/randFloat.hpp"
#include "NumCpp/Random/randInt.hpp"
#include "NumCpp/Random/randN.hpp"
#include "NumCpp/Random/shuffle.hpp"
#include "NumCpp/Random/standardNormal.hpp"
#include "NumCpp/Random/studentT.hpp"
#include "NumCpp/Random/triangle.hpp"
#include "NumCpp/Random/uniform.hpp"
#include "NumCpp/Random/uniformOnSphere.hpp"
#include "NumCpp/Random/weibull.hpp"
 
namespace nc::random
{
    //============================================================================
    // Class Description:
    template<typename GeneratorType = std::mt19937_64>
    class RNG
    {
    public:
        //============================================================================
        // Method Description:
        RNG() = default;
 
        //============================================================================
        // Method Description:
        explicit RNG(int seed) :
            generator_(seed){};
 
        //============================================================================
        // Method Description:
        bool bernoulli(double inP = 0.5)
        {
            return detail::bernoulli(generator_, inP);
        }
 
        //============================================================================
        // Method Description:
        NdArray<bool> bernoulli(const Shape& inShape, double inP = 0.5)
        {
            return detail::bernoulli(generator_, inShape, inP);
        }
 
#ifndef NUMCPP_NO_USE_BOOST
        //============================================================================
        // Method Description:
        template<typename dtype>
        dtype beta(dtype inAlpha, dtype inBeta)
        {
            return detail::beta(generator_, inAlpha, inBeta);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        NdArray<dtype> beta(const Shape& inShape, dtype inAlpha, dtype inBeta)
        {
            return detail::beta(generator_, inShape, inAlpha, inBeta);
        }
#endif
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        dtype binomial(dtype inN, double inP = 0.5)
        {
            return detail::binomial(generator_, inN, inP);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        NdArray<dtype> binomial(const Shape& inShape, dtype inN, double inP = 0.5)
        {
            return detail::binomial(generator_, inShape, inN, inP);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        dtype cauchy(dtype inMean = 0, dtype inSigma = 1)
        {
            return detail::cauchy(generator_, inMean, inSigma);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        NdArray<dtype> cauchy(const Shape& inShape, dtype inMean = 0, dtype inSigma = 1)
        {
            return detail::cauchy(generator_, inShape, inMean, inSigma);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        dtype chiSquare(dtype inDof)
        {
            return detail::chiSquare(generator_, inDof);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        NdArray<dtype> chiSquare(const Shape& inShape, dtype inDof)
        {
            return detail::chiSquare(generator_, inShape, inDof);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        dtype choice(const NdArray<dtype>& inArray)
        {
            return detail::choice(generator_, inArray);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        NdArray<dtype> choice(const NdArray<dtype>& inArray, uint32 inNum, Replace replace = Replace::YES)
        {
            return detail::choice(generator_, inArray, inNum, replace);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        dtype discrete(const NdArray<double>& inWeights)
        {
            return detail::discrete<dtype>(generator_, inWeights);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        NdArray<dtype> discrete(const Shape& inShape, const NdArray<double>& inWeights)
        {
            return detail::discrete<dtype>(generator_, inShape, inWeights);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        dtype exponential(dtype inScaleValue = 1)
        {
            return detail::exponential(generator_, inScaleValue);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        NdArray<dtype> exponential(const Shape& inShape, dtype inScaleValue = 1)
        {
            return detail::exponential(generator_, inShape, inScaleValue);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        dtype extremeValue(dtype inA = 1, dtype inB = 1)
        {
            return detail::extremeValue(generator_, inA, inB);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        NdArray<dtype> extremeValue(const Shape& inShape, dtype inA = 1, dtype inB = 1)
        {
            return detail::extremeValue(generator_, inShape, inA, inB);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        dtype f(dtype inDofN, dtype inDofD)
        {
            return detail::f(generator_, inDofN, inDofD);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        NdArray<dtype> f(const Shape& inShape, dtype inDofN, dtype inDofD)
        {
            return detail::f(generator_, inShape, inDofN, inDofD);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        dtype gamma(dtype inGammaShape, dtype inScaleValue = 1)
        {
            return detail::gamma(generator_, inGammaShape, inScaleValue);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        NdArray<dtype> gamma(const Shape& inShape, dtype inGammaShape, dtype inScaleValue = 1)
        {
            return detail::gamma(generator_, inShape, inGammaShape, inScaleValue);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        dtype geometric(double inP = 0.5)
        {
            return detail::geometric<dtype>(generator_, inP);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        NdArray<dtype> geometric(const Shape& inShape, double inP = 0.5)
        {
            return detail::geometric<dtype>(generator_, inShape, inP);
        }
 
#ifndef NUMCPP_NO_USE_BOOST
        //============================================================================
        // Method Description:
        template<typename dtype>
        dtype laplace(dtype inLoc = 0, dtype inScale = 1)
        {
            return detail::laplace(generator_, inLoc, inScale);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        NdArray<dtype> laplace(const Shape& inShape, dtype inLoc = 0, dtype inScale = 1)
        {
            return detail::laplace(generator_, inShape, inLoc, inScale);
        }
#endif
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        dtype lognormal(dtype inMean = 0, dtype inSigma = 1)
        {
            return detail::lognormal(generator_, inMean, inSigma);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        NdArray<dtype> lognormal(const Shape& inShape, dtype inMean = 0, dtype inSigma = 1)
        {
            return detail::lognormal(generator_, inShape, inMean, inSigma);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        dtype negativeBinomial(dtype inN, double inP = 0.5)
        {
            return detail::negativeBinomial(generator_, inN, inP);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        NdArray<dtype> negativeBinomial(const Shape& inShape, dtype inN, double inP = 0.5)
        {
            return detail::negativeBinomial(generator_, inShape, inN, inP);
        }
 
#ifndef NUMCPP_NO_USE_BOOST
        //============================================================================
        // Method Description:
        template<typename dtype>
        dtype nonCentralChiSquared(dtype inK = 1, dtype inLambda = 1)
        {
            return detail::nonCentralChiSquared(generator_, inK, inLambda);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        NdArray<dtype> nonCentralChiSquared(const Shape& inShape, dtype inK = 1, dtype inLambda = 1)
        {
            return detail::nonCentralChiSquared(generator_, inShape, inK, inLambda);
        }
#endif
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        dtype normal(dtype inMean = 0, dtype inSigma = 1)
        {
            return detail::normal(generator_, inMean, inSigma);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        NdArray<dtype> normal(const Shape& inShape, dtype inMean = 0, dtype inSigma = 1)
        {
            return detail::normal(generator_, inShape, inMean, inSigma);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        NdArray<dtype> permutation(dtype inValue)
        {
            return detail::permutation(generator_, inValue);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        NdArray<dtype> permutation(const NdArray<dtype>& inArray)
        {
            return detail::permutation(generator_, inArray);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        dtype poisson(double inMean = 1)
        {
            return detail::poisson<dtype>(generator_, inMean);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        NdArray<dtype> poisson(const Shape& inShape, double inMean = 1)
        {
            return detail::poisson<dtype>(generator_, inShape, inMean);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        dtype rand()
        {
            return detail::rand<dtype>(generator_);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        NdArray<dtype> rand(const Shape& inShape)
        {
            return detail::rand<dtype>(generator_, inShape);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        dtype randFloat(dtype inLow, dtype inHigh = 0.)
        {
            return detail::randFloat(generator_, inLow, inHigh);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        NdArray<dtype> randFloat(const Shape& inShape, dtype inLow, dtype inHigh = 0.)
        {
            return detail::randFloat(generator_, inShape, inLow, inHigh);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        dtype randInt(dtype inLow, dtype inHigh = 0)
        {
            return detail::randInt(generator_, inLow, inHigh);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        NdArray<dtype> randInt(const Shape& inShape, dtype inLow, dtype inHigh = 0)
        {
            return detail::randInt(generator_, inShape, inLow, inHigh);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        dtype randN()
        {
            return detail::randN<dtype>(generator_);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        NdArray<dtype> randN(const Shape& inShape)
        {
            return detail::randN<dtype>(generator_, inShape);
        }
 
        //============================================================================
        // Method Description:
        void seed(int value) noexcept
        {
            generator_.seed(value);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        void shuffle(NdArray<dtype>& inArray)
        {
            return detail::shuffle(generator_, inArray);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        dtype standardNormal()
        {
            return detail::standardNormal<dtype>(generator_);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        NdArray<dtype> standardNormal(const Shape& inShape)
        {
            return detail::standardNormal<dtype>(generator_, inShape);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        dtype studentT(dtype inDof)
        {
            return detail::studentT(generator_, inDof);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        NdArray<dtype> studentT(const Shape& inShape, dtype inDof)
        {
            return detail::studentT(generator_, inShape, inDof);
        }
 
#ifndef NUMCPP_NO_USE_BOOST
        //============================================================================
        // Method Description:
        template<typename dtype>
        dtype triangle(dtype inA = 0, dtype inB = 0.5, dtype inC = 1)
        {
            return detail::triangle(generator_, inA, inB, inC);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        NdArray<dtype> triangle(const Shape& inShape, dtype inA = 0, dtype inB = 0.5, dtype inC = 1)
        {
            return detail::triangle(generator_, inShape, inA, inB, inC);
        }
#endif
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        dtype uniform(dtype inLow, dtype inHigh)
        {
            return detail::uniform(generator_, inLow, inHigh);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        NdArray<dtype> uniform(const Shape& inShape, dtype inLow, dtype inHigh)
        {
            return detail::uniform(generator_, inShape, inLow, inHigh);
        }
 
#ifndef NUMCPP_NO_USE_BOOST
        //============================================================================
        // Method Description:
        template<typename dtype>
        NdArray<dtype> uniformOnSphere(uint32 inNumPoints, uint32 inDims = 2)
        {
            return detail::uniformOnSphere<dtype>(generator_, inNumPoints, inDims);
        }
#endif
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        dtype weibull(dtype inA = 1, dtype inB = 1)
        {
            return detail::weibull(generator_, inA, inB);
        }
 
        //============================================================================
        // Method Description:
        template<typename dtype>
        NdArray<dtype> weibull(const Shape& inShape, dtype inA = 1, dtype inB = 1)
        {
            return detail::weibull(generator_, inShape, inA, inB);
        }
 
    private:
        GeneratorType generator_{};
    };
} // namespace nc::random