number.h

Go to the documentation of this file.

#pragma once
 
#include <concepts>
#include <optional>
#include <random>
#include <stdexcept>
#include <type_traits>
 
#include "faker-cxx/export.h"
#include "faker-cxx/generator.h"
#include "faker-cxx/types/hex.h"
 
namespace faker::number
{
template <std::integral I>
    requires(sizeof(I) <= sizeof(long long))
I integer(I min, I max)
{
    // std::uniform_int_distribution only accepts certain types, so we use signed or unsigned long long and don't allow
    // larger types
    using LongLongType = std::conditional_t<std::is_unsigned_v<I>, unsigned long long, long long>;
 
    if (min > max)
    {
        throw std::invalid_argument("Minimum value must be smaller than maximum value.");
    }
 
    std::mt19937_64& pseudoRandomGenerator = getGenerator();
 
    std::uniform_int_distribution<LongLongType> distribution(min, max);
 
    return static_cast<I>(distribution(pseudoRandomGenerator));
}

template <std::integral I>
    requires(sizeof(I) <= sizeof(long long))
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.");
    }
 
    std::mt19937_64& pseudoRandomGenerator = getGenerator();
    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::mt19937_64& pseudoRandomGenerator = getGenerator();
 
    std::normal_distribution<F> distribution(mean, standardDeviation);
    return distribution(pseudoRandomGenerator);
}

 
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);

FAKER_CXX_EXPORT std::string roman(std::optional<int> min = std::nullopt, std::optional<int> max = std::nullopt);
 
}