Espacios de nombres
Variantes
Acciones

std::seed_seq::generate

De cppreference.com
< cpp‎ | numeric‎ | random‎ | seed seq

 
 
Numéricos biblioteca
Funciones matemáticas comunes
Floating-point medio ambiente
Los números complejos
Matrices numéricas
Pseudo-aleatoria de generación de números
En tiempo de compilación aritmética racional (C++11)
Genéricos operaciones numéricas
Original:
Generic numeric operations
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
iota(C++11)
accumulate
inner_product
adjacent_difference
partial_sum
 
Pseudo-aleatoria de generación de números
Motores y adaptadores de motor
Original:
Engines and engine adaptors
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
linear_congruential_engine(C++11)
mersenne_twister_engine(C++11)
subtract_with_carry_engine(C++11)
discard_block_engine(C++11)
independent_bits_engine(C++11)
shuffle_order_engine(C++11)
Generadores
Original:
Generators
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
random_device(C++11)
Distribuciones
Original:
Distributions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Distribuciones uniformes
Original:
Uniform distributions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
uniform_int_distribution(C++11)
uniform_real_distribution(C++11)
generate_canonical(C++11)
Bernoulli distribuciones
Original:
Bernoulli distributions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
bernoulli_distribution(C++11)
binomial_distribution(C++11)
negative_binomial_distribution(C++11)
geometric_distribution(C++11)
Poisson distribuciones
Original:
Poisson distributions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
poisson_distribution(C++11)
exponential_distribution(C++11)
gamma_distribution(C++11)
weibull_distribution(C++11)
extreme_value_distribution(C++11)
Distribuciones normales
Original:
Normal distributions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
normal_distribution(C++11)
lognormal_distribution(C++11)
chi_squared_distribution(C++11)
cauchy_distribution(C++11)
fisher_f_distribution(C++11)
student_t_distribution(C++11)
Distribuciones de muestreo
Original:
Sampling distributions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
discrete_distribution(C++11)
piecewise_constant_distribution(C++11)
piecewise_linear_distribution(C++11)
Secuencias de semillas
Original:
Seed Sequences
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
seed_seq(C++11)
C biblioteca
Original:
C library
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
rand
srand
RAND_MAX
 
std::seed_seq
Las funciones miembro
Original:
Member functions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
seed_seq::seed_seq
seed_seq::generate
seed_seq::size
seed_seq::param
 
template< class RandomIt >
void generate( RandomIt begin, RandomIt end );
(desde C++11)
Llena el [begin, end) rango con valores enteros sin signo i, 0 ≤ i < 232
, sobre la base de los datos originalmente proporcionados en el constructor de esta seed_seq. Los valores producidos se distribuyen sobre toda la gama de 32-bit, incluso si los valores iniciales fueron fuertemente sesgada .
Original:
Fills the range [begin, end) with unsigned integer values i, 0 ≤ i < 232
, based on the data originally provided in the constructor of this seed_seq. The produced values are distributed over the entire 32-bit range even if the initial values were strongly biased.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
El siguiente algoritmo se utiliza (adaptado de la secuencia de inicialización del generador Mersenne Twister por Makoto Matsumoto and Takuji Nishimura, la incorporación de las mejoras realizadas por Mutsuo Saito in 2007)
Original:
The following algorithm is used (adapted from the initialization sequence of the Mersenne Twister generator by Makoto Matsumoto and Takuji Nishimura, incorporating the improvements made by Mutsuo Saito in 2007)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
  • Si begin == end, no haga nada. De lo contrario,
    Original:
    If begin == end, do nothing. Otherwise,
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
  • En primer lugar, configure cada elemento del rango de salida a la 0x8b8b8b8b valor
    Original:
    First, set each element of the output range to the value 0x8b8b8b8b
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
  • Transformar los elementos de la gama de salida de acuerdo con el siguiente algoritmo:
    Original:
    Transform the elements of the output range according to the following algorithm:
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

For k = 0,..., m-1

donde m=max(s+1, n)
Original:
where m=max(s+1, n)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

and n=begin-end
and s=v.size()

y v es el contenedor privada que tiene los valores inicialmente previstos por el constructor de este objeto seed_seq,
Original:
and v is the private container holding the values originally provided by the constructor of this seed_seq object,
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
  1. begin[k+p] += r1
  2. begin[k+q] += r2
  3. begin[k] = r2,
donde p=(n-t)/2
Original:
where p=(n-t)/2
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

and q=p+t
and t=(n >= 623) ? 11 : (n >= 68) ? 7 : (n >= 39) ? 5 : (n >= 7) ? 3 : (n - 1) / 2
and r1=1664525 * T(begin[k]^begin[k+p]^begin[k−1])
and T(x) = x ^ (x << 27)
and r2=r1+s if k==0, r2=r1 + k%n + v[k-1] if 0<k<=s, r2=r1 + k%n if k>s.

For k = m,..., m+n-1,

  1. begin[k+p] ^= r3
  2. begin[k+q] ^= r4
  3. begin[k]=r4
donde r3 = 1566083941 * T(begin[k]+begin[k+p]+begin[k-1])
Original:
where r3 = 1566083941 * T(begin[k]+begin[k+p]+begin[k-1])
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

and r4=r3 - k%n

donde todos los cálculos se realizan modulo 232
y donde la indexación del rango de salida (begin[x]) se toma modulo n .
Original:
where all calculations are performed modulo 232
and where the indexing of the output range (begin[x]) is taken modulo n.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[editar] Parámetros

begin, end -
mutables iteradores de acceso aleatorio cuyo std::iterator_traits<>::value_type es un tipo entero sin signo adecuado para el almacenamiento de valores de 32 bits
Original:
mutable random-access iterators whose std::iterator_traits<>::value_type is an unsigned integer type suitable for storing 32-bit values
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Type requirements
-
RandomIt must meet the requirements of RandomAccessIterator.

[editar] Valor de retorno

ninguno, los resultados son escritos en el rango [begin, end) .
Original:
none, the results are written to the [begin, end) range.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[editar] Ejemplo

#include <random>
#include <iostream>
 
int main()
{
    std::seed_seq seq({1,2,3,4,5});
    std::vector<std::uint32_t> seeds(10);
    seq.generate(seeds.begin(), seeds.end());
// Step 1: fill with 0x8b8b8b8b
// seeds = {2341178251, 2341178251, 2341178251, 2341178251, 2341178251,
//          2341178251, 2341178251, 2341178251, 2341178251, 2341178251 }
//
// Step 2: 
// n = 10, s = 5, t = 3, p = 3, q = 6, m = 10
//
// First iteration, k = 0; r1 = 1371501266, r2 = 1371501271
//
// seeds = {1371501271, 2341178251, 2341178251, 3712679517, 2341178251,
//          2341178251, 3712679522, 2341178251, 2341178251, 2341178251 }
//
// Iterations from k = 1 to k = 5 (r2 = r1 + k%n + v[k-1])
//
// r1 = 2786190137, 3204727651, 4173325571, 1979226628, 401983366
// r2 = 2786190139, 3204727655, 4173325577, 1979226636, 401983376
//
// seeds = {3350727907, 3188173515, 3204727655, 4173325577, 1979226636,
//           401983376, 3591037797, 2811627722, 1652921976, 2219536532 } 
//
// Iterations from k = 6 to k = 9 (r2 = r1 + k%n)
//
// r1 = 2718637909, 1378394210, 2297813071, 1608643617
// r2 = 2718637915, 1378394217, 2297813079, 1608643626
//
// seeds = { 434154821, 1191019290, 3237041891, 1256752498, 4277039715,
//          2010627002, 2718637915, 1378394217, 2297813079, 1608643626 } 
//
// Step 3
// iterations from k = 10 to k = 19, using ^= to modify the output
//
// r1 = 1615303485, 3210438310, 893477041, 2884072672, 1918321961,
// r2 = 1615303485, 3210438309, 893477039, 2884072669, 1918321957
//
// seeds = { 303093272, 3210438309,  893477039, 2884072669, 1918321957,
//          1117182731, 1772877958, 2669970405, 3182737656, 4094066935 }
//
// r1 =  423054846, 46783064, 3904109085, 1534123446, 1495905687
// r2 =  423054841, 46783058, 3904109078, 1534123438, 1495905678
//
// seeds = { 4204997637, 4246533866, 1856049002, 1129615051, 690460811,
//           1075771511,   46783058, 3904109078, 1534123438, 1495905678 }
 
    for(std::uint32_t n : seeds)
        std::cout << n << '\n';
}

Output:

4204997637
4246533866
1856049002
1129615051
690460811
1075771511
46783058
3904109078
1534123438
1495905678