number.h

Go to the documentation of this file.

#pragma once
 
#include <concepts>
#include <optional>
#include <random>
#include <stdexcept>
 
#include "faker-cxx/export.h"
#include "faker-cxx/types/hex.h"
 
namespace faker::number
{
 
template <std::integral I>
I integer(I min, I max)
{
    if (min > max)
    {
        throw std::invalid_argument("Minimum value must be smaller than maximum value.");
    }
 
    static std::mt19937 pseudoRandomGenerator{std::random_device{}()};
 
    std::uniform_int_distribution<I> distribution(min, max);
 
    return distribution(pseudoRandomGenerator);
}
 
template <std::integral I>
I integer(I max)
{
    return integer<I>(static_cast<I>(0), max);
}
 
template <std::floating_point F>
F decimal(F min, F max)
{
    if (min > max)
    {
        throw std::invalid_argument("Minimum value must be smaller than maximum value.");
    }
 
    static std::mt19937 pseudoRandomGenerator{std::random_device{}()};
    std::uniform_real_distribution<F> distribution(min, max);
 
    return distribution(pseudoRandomGenerator);
}
 
template <std::floating_point F>
F decimal(F max)
{
    return decimal<F>(static_cast<F>(0.), max);
}
 
template <std::floating_point F>
F normalDistribution(F mean, F standardDeviation)
{
    if (standardDeviation < 0 || standardDeviation == INFINITY || mean == INFINITY)
    {
        throw std::invalid_argument("Standard Deviation cannot be negative");
    }
    else if (standardDeviation == 0)
    {
        return mean;
    }
 
    std::random_device randDev;
    std::mt19937 PSRNG(randDev());
 
    std::normal_distribution<F> dist(mean, standardDeviation);
    return dist(PSRNG);
}
 
template <std::floating_point F>
F normalDistribution(F mean, F standardDeviation, F min, F max)
{
    if (min > max)
    {
        throw std::invalid_argument("min cannot be larger than max");
    }
 
    F sample = normalDistribution(mean, standardDeviation);
 
    if (sample > max)
    {
        sample = max;
    }
    else if (sample < min)
    {
        sample = min;
    }
 
    return sample;
}
 
FAKER_CXX_EXPORT std::string hexadecimal(unsigned length = 1, HexCasing casing = HexCasing::Lower,
                                         HexPrefix prefix = HexPrefix::ZeroX);
 
FAKER_CXX_EXPORT std::string hexadecimal(std::optional<int> min = std::nullopt, std::optional<int> max = std::nullopt);
 
FAKER_CXX_EXPORT std::string octal(unsigned length = 1);
 
FAKER_CXX_EXPORT std::string binary(int length = 1);
 
FAKER_CXX_EXPORT std::string binary(int min, int max);
}