Partager via


operator<< <random>

Écrit les informations d'état au flux.

template<class Elem, class Traits, class UIntType,
    UIntType A, UIntType C, UIntType M>
    std::basic_ostream<Elem, Traits>& operator<<(
        std::basic_ostream<Elem, Traits>& ostr,
        const linear_congruential<UIntType, A, C, M>& right);
template<class Elem, class Traits, class UIntType,
    int W, int N, int M, int R,
    UIntType A, int U, int S,
    UIntType B, int T, UIntType C, int L>
    std::basic_ostream<Elem, Traits>& operator<<(
        std::basic_ostream<Elem, Traits>& ostr,
        const mersenne_twister<UIntType, W, N, M, R,
            A, U, S, B, T, C, L>& right);
template<class Elem, class Traits, class IntType,
    IntType M, int S, int R>
    std::basic_ostream<Elem, Traits>& operator<<(
        std::basic_ostream<Elem, Traits>& ostr,
        const subtract_with_carry<IntType, M, S, R>& right);
template<class Elem, class Traits, class RealType,
    int W, int S, int R>
    std::basic_ostream<Elem, Traits>& operator<<(
        std::basic_ostream<Elem, Traits>& ostr,
        const subtract_with_carry_01<RealType, W, S, R>& right);
template<class Elem, class Traits, class Engine,
    int P, int R>
    std::basic_ostream<Elem, Traits>& operator<<(
        std::basic_ostream<Elem, Traits>& ostr,
        const discard_block<Engine, F, R>& right);
template<class Elem, class Traits, class Engine1, int S1,
    class Engine2, int S2>
    std::basic_ostream<Elem, Traits>& operator<<(
        std::basic_ostream<Elem, Traits>& ostr,
        const xor_combine<Engine1, S1, Engine2, S2>& right);
template<class Elem, class Traits>
    std::basic_ostream<Elem, Traits>& operator<<(
        std::basic_ostream<Elem, Traits>& ostr,
        const bernoulli_distribution& right);
template<class Elem, class Traits, class IntType
    class RealType>
    std::basic_ostream<Elem, Traits>& operator<<(
        std::basic_ostream<Elem, Traits>& ostr,
        const binomial_distribution<IntType, RealType>& right);
template<class Elem, class Traits, class RealType>
    std::basic_ostream<Elem, Traits>& operator<<(
        std::basic_ostream<Elem, Traits>& ostr,
        const exponential_distribution<RealType>& right);
template<class Elem, class Traits, class RealType>
    std::basic_ostream<Elem, Traits>& operator<<(
        std::basic_ostream<Elem, Traits>& ostr,
        const gamma_distribution<RealType>& right);
template<class Elem, class Traits, class IntType
    class RealType>
    std::basic_ostream<Elem, Traits>& operator<<(
        std::basic_ostream<Elem, Traits>& ostr,
        const geometric_distribution<IntType, RealType>& right);
template<class Elem, class Traits, class RealType>
    std::basic_ostream<Elem, Traits>& operator<<(
        std::basic_ostream<Elem, Traits>& ostr,
        const normal_distribution<RealType>& right);
template<class Elem, class Traits, class IntType
    class RealType>
    std::basic_ostream<Elem, Traits>& operator<<(
        std::basic_ostream<Elem, Traits>& ostr,
        const poisson_distribution<IntType, RealType>& right);
template<class Elem, class Traits, class IntType>
    std::basic_ostream<Elem, Traits>& operator<<(
        std::basic_ostream<Elem, Traits>& ostr,
        const uniform_int<IntType>& right);
template<class Elem, class Traits, class RealType>
    std::basic_ostream<Elem, Traits>& operator<<(
        std::basic_ostream<Elem, Traits>& ostr,
        const uniform_real<RealType>& right);
template<class Elem, class Traits, class Engine,
    size_t W, class UIntType>
    std::basic_ostream<Elem, Traits>& operator<<(
        std::basic_ostream<Elem, Traits>& ostr,
        const independent_bits_engine<Engine, W, U>& right);
template<class Elem, class Traits, class Engine,
    size_t K>
    std::basic_ostream<Elem, Traits>& operator<<(
        std::basic_ostream<Elem, Traits>& ostr,
        const shuffle_order_engine<Engine, K>& right);
template<class Elem, class Traits, class RealType>
    std::basic_ostream<Elem, Traits>& operator<<(
        std::basic_ostream<Elem, Traits>& ostr,
        const cauchy_distribution<RealType>& right);
template<class Elem, class Traits, class RealType>
    std::basic_ostream<Elem, Traits>& operator<<(
        std::basic_ostream<Elem, Traits>& ostr,
        const chi_squared_distribution<RealType>& right);
template<class Elem, class Traits, class IntType>
    std::basic_ostream<Elem, Traits>& operator<<(
        std::basic_ostream<Elem, Traits>& ostr,
        const discrete_distribution<IntType>& right);
template<class Elem, class Traits, class RealType>
    std::basic_ostream<Elem, Traits>& operator<<(
        std::basic_ostream<Elem, Traits>& ostr,
        const extreme_value_distribution<RealType>& right);
template<class Elem, class Traits, class RealType>
    std::basic_ostream<Elem, Traits>& operator<<(
        std::basic_ostream<Elem, Traits>& ostr,
        const fisher_f_distribution<RealType>& right);
template<class Elem, class Traits, class RealType>
    std::basic_ostream<Elem, Traits>& operator<<(
        std::basic_ostream<Elem, Traits>& ostr,
        const lognormal_distribution<RealType>& right);
template<class Elem, class Traits, class IntType>
    std::basic_ostream<Elem, Traits>& operator<<(
        std::basic_ostream<Elem, Traits>& ostr,
        const negative_binomial_distribution<IntType>& right);
template<class Elem, class Traits, class RealType>
    std::basic_ostream<Elem, Traits>& operator<<(
        std::basic_ostream<Elem, Traits>& ostr,
        const piecewise_constant_distribution<RealType>& right);
template<class Elem, class Traits, class RealType>
    std::basic_ostream<Elem, Traits>& operator<<(
        std::basic_ostream<Elem, Traits>& ostr,
        const student_t_distribution<RealType>& right);
template<class Elem, class Traits, class IntType>
    std::basic_ostream<Elem, Traits>& operator<<(
        std::basic_ostream<Elem, Traits>& ostr,
        const uniform_int_distribution<IntType>& right);
template<class Elem, class Traits, class RealType>
    std::basic_ostream<Elem, Traits>& operator<<(
        std::basic_ostream<Elem, Traits>& ostr,
        const uniform_real_distribution<RealType>& right);
template<class Elem, class Traits, class RealType>
    std::basic_ostream<Elem, Traits>& operator<<(
        std::basic_ostream<Elem, Traits>& ostr,
        const weibull_distribution<RealType>& right);

Paramètres

Paramètre

Description

ostr

Le flux de données pour recevoir les informations d'état.

right

Le moteur ou l'objet de distribution contenant les informations d'état.

Notes

Insertions de cette fonction de modèle dans des informations suffisantes pour ostr de flux sur right pour restaurer les paramètres enregistrés avec un extrait suivant.Le flux de données doit insérer des valeurs entières en décimales.

Configuration requise

en-tête : <random>

l'espace de noms : DST

Voir aussi

Référence

<random>