C++ Library Extensions 2022.12.09
To help learn modern C++ programming
Classes | Namespaces | Macros | Typedefs | Functions | Variables
cpg_chrono_random.hpp File Reference
#include <chrono>
#include <ratio>
#include <random>
#include <iostream>
#include <sstream>
#include <vector>
#include <numeric>
#include <algorithm>
#include <execution>
#include "cpg_types.hpp"
#include "cpg_conversion.hpp"
Include dependency graph for cpg_chrono_random.hpp:

Go to the source code of this file.

Classes

class  cpg::chrono_random::stop_watch
 
class  cpg::chrono_random::fair_dice< Type >
 
class  cpg::chrono_random::random_t< Type, DistributionType, EngineType >
 
class  cpg::chrono_random::random_words< CharType, Size >
 

Namespaces

namespace  cpg
 Includes subnamespace conversion.
 
namespace  cpg::chrono_random
 Implements random number generator and stop watch.
 

Macros

#define NOMINMAX
 

Typedefs

using cpg::chrono_random::nano_t = std::nano
 
using cpg::chrono_random::micro_t = std::micro
 
using cpg::chrono_random::milli_t = std::milli
 
using cpg::chrono_random::second_t = std::ratio< 1 >
 
using cpg::chrono_random::minute_t = std::ratio< 60 >
 
using cpg::chrono_random::hour_t = std::ratio< 3600 >
 
template<typename TimeUnit >
using cpg::chrono_random::duration_t = std::chrono::duration< double, TimeUnit >
 
using cpg::chrono_random::nanoseconds_t = duration_t< nano_t >
 
using cpg::chrono_random::microseconds_t = duration_t< micro_t >
 
using cpg::chrono_random::milliseconds_t = duration_t< milli_t >
 
using cpg::chrono_random::seconds_t = duration_t< second_t >
 
using cpg::chrono_random::minutes_t = duration_t< minute_t >
 
using cpg::chrono_random::hours_t = duration_t< hour_t >
 
using cpg::chrono_random::high_resolution_clock_t = std::chrono::high_resolution_clock
 
using cpg::chrono_random::time_point_t = std::chrono::time_point< high_resolution_clock_t >
 
using cpg::chrono_random::random_engine_t = std::default_random_engine
 
template<std::integral IntegralType>
using cpg::chrono_random::random_uniform_integral_distribution = std::uniform_int_distribution< IntegralType >
 
template<std::floating_point RealType>
using cpg::chrono_random::random_uniform_real_distribution = std::uniform_real_distribution< RealType >
 
template<std::integral IntegralType>
using cpg::chrono_random::random_uniform_integer_t = random_t< IntegralType, random_uniform_integral_distribution< IntegralType >, random_engine_t >
 
template<std::floating_point RealType>
using cpg::chrono_random::random_uniform_real_t = random_t< RealType, random_uniform_real_distribution< RealType >, random_engine_t >
 

Functions

unsigned int cpg::chrono_random::seed ()
 
unsigned int cpg::chrono_random::get_current_tick ()
 
template<typename TimeUnit >
double cpg::chrono_random::time_difference_in_unit (const time_point_t &start_time, const time_point_t &end_time)
 
template<typename ValueType , typename RangeType1 , typename RangeType2 >
auto cpg::chrono_random::random_generator (RangeType1 range_start, RangeType2 range_end)
 
template<typename Type , std::size_t N, typename RandomGeneratorType >
void cpg::chrono_random::random_fill (Type(&container)[N], RandomGeneratorType const &random_generator)
 
template<typename Type , std::size_t M, std::size_t N, typename RandomGeneratorType >
void cpg::chrono_random::random_fill (Type(&container)[M][N], RandomGeneratorType const &random_generator)
 
template<typename Type , std::size_t L, std::size_t M, std::size_t N, typename RandomGeneratorType >
void cpg::chrono_random::random_fill (Type(&container)[L][M][N], RandomGeneratorType const &random_generator)
 
template<template< typename, typename... > class ContainerType, typename Type , typename... Types, typename RType , template< typename, typename... > class RandomGeneratorType, typename... RTypes>
void cpg::chrono_random::random_fill (ContainerType< Type, Types... > &container, const RandomGeneratorType< RType, RTypes... > &random_generator)
 
template<template< typename, typename... > class ContainerType, typename Type , typename... Types, typename RandomGeneratorType >
void cpg::chrono_random::random_fill (ContainerType< Type, Types... > &container, RandomGeneratorType &&random_generator)
 
template<template< typename, typename... > class ContainerType, typename Type , typename... Types, typename RangeType >
void cpg::chrono_random::random_fill (ContainerType< Type, Types... > &container, RangeType range_start, RangeType range_end)
 
template<template< typename, std::size_t > class ContainerType, typename Type , std::size_t N, typename RType , template< typename, typename... > class RandomGeneratorType, typename... RTypes>
void cpg::chrono_random::random_fill (ContainerType< Type, N > &container, const RandomGeneratorType< RType, RTypes... > &random_generator)
 
template<template< typename, std::size_t > class ContainerType, typename Type , std::size_t N, typename RandomGeneratorType >
void cpg::chrono_random::random_fill (ContainerType< Type, N > &container, RandomGeneratorType &&random_generator)
 
template<template< typename, std::size_t > class ContainerType, typename Type , std::size_t N, typename RangeType >
void cpg::chrono_random::random_fill (ContainerType< Type, N > &container, RangeType range_start, RangeType range_end)
 
template<typename Type , std::size_t N, template< typename, typename... > class RandomGeneratorType, typename RType , typename... RTypes>
void cpg::chrono_random::random_parallel_fill (Type(&container)[N], const RandomGeneratorType< RType, RTypes... > &random_generator)
 
template<typename Type , std::size_t M, std::size_t N, template< typename, typename... > class RandomGeneratorType, typename RType , typename... RTypes>
void cpg::chrono_random::random_parallel_fill (Type(&container)[M][N], const RandomGeneratorType< RType, RTypes... > &random_generator)
 
template<typename Type , std::size_t L, std::size_t M, std::size_t N, template< typename, typename... > class RandomGeneratorType, typename RType , typename... RTypes>
void cpg::chrono_random::random_parallel_fill (Type(&container)[L][M][N], const RandomGeneratorType< RType, RTypes... > &random_generator)
 
template<template< typename, typename... > class ContainerType, typename Type , typename... Types, typename RType , template< typename, typename... > class RandomGeneratorType, typename... RTypes>
void cpg::chrono_random::random_parallel_fill (ContainerType< Type, Types... > &container, const RandomGeneratorType< RType, RTypes... > &random_generator)
 
template<template< typename, typename... > class ContainerType, typename Type , typename... Types, typename RandomGeneratorType >
void cpg::chrono_random::random_parallel_fill (ContainerType< Type, Types... > &container, RandomGeneratorType &&random_generator)
 
template<template< typename, typename... > class ContainerType, typename Type , typename... Types, typename RangeType >
void cpg::chrono_random::random_parallel_fill (ContainerType< Type, Types... > &container, RangeType range_start, RangeType range_end)
 
template<template< typename, std::size_t > class ContainerType, typename Type , std::size_t N, typename RType , template< typename, typename... > class RandomGeneratorType, typename... RTypes>
void cpg::chrono_random::random_parallel_fill (ContainerType< Type, N > &container, const RandomGeneratorType< RType, RTypes... > &random_generator)
 
template<template< typename, std::size_t > class ContainerType, typename Type , std::size_t N, typename RandomGeneratorType >
void cpg::chrono_random::random_parallel_fill (ContainerType< Type, N > &container, RandomGeneratorType &&random_generator)
 
template<template< typename, std::size_t > class ContainerType, typename Type , std::size_t N, typename RangeType >
void cpg::chrono_random::random_parallel_fill (ContainerType< Type, N > &container, RangeType range_start, RangeType range_end)
 
template<template< typename, typename... > class ContainerType, typename Type , typename... Types, typename SizeType , template< typename, typename... > class RandomGeneratorType, typename... RTypes>
void cpg::chrono_random::random_fill (ContainerType< Type, Types... > &container, const RandomGeneratorType< Type, RTypes... > &random_generator, SizeType size)
 Fills the /a container with random numbers. If the /a container is /a set or /a unordered_set, the range of the random_generator should be sufficiently big, otherwise it can fall into infinity loop.
More...
 
template<typename Type , size_t ArraySize>
 cpg::chrono_random::random_words (int, int, int, const Type(&)[ArraySize]) -> random_words< Type, ArraySize >
 

Variables

auto & cpg::chrono_random::now = high_resolution_clock_t::now
 

Macro Definition Documentation

◆ NOMINMAX

#define NOMINMAX

Definition at line 16 of file cpg_chrono_random.hpp.