random.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2019, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, 2020.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2023-10-12 19:43+0200\n"
"PO-Revision-Date: 2023-01-27 17:19-0300\n"
"Last-Translator: Adolfo Hristo David Roque Gámez <aroquega@gmail.com>\n"
"Language: es_ES\n"
"Language-Team: \n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.13.0\n"

#: ../Doc/library/random.rst:2
msgid ":mod:`random` --- Generate pseudo-random numbers"
msgstr ":mod:`random` ---Generar números pseudoaleatorios"

#: ../Doc/library/random.rst:7
msgid "**Source code:** :source:`Lib/random.py`"
msgstr "**Código fuente:** :source:`Lib/random.py`"

#: ../Doc/library/random.rst:11
msgid ""
"This module implements pseudo-random number generators for various "
"distributions."
msgstr ""
"Este módulo implementa generadores de números pseudoaleatorios para varias "
"distribuciones."

#: ../Doc/library/random.rst:14
msgid ""
"For integers, there is uniform selection from a range. For sequences, there "
"is uniform selection of a random element, a function to generate a random "
"permutation of a list in-place, and a function for random sampling without "
"replacement."
msgstr ""
"Para los enteros, existe una selección uniforme dentro de un rango. Para las "
"secuencias, existe una selección uniforme de un elemento aleatorio, una "
"función para generar una permutación aleatoria de una lista *in-situ* y una "
"función para el muestreo aleatorio sin reemplazo."

#: ../Doc/library/random.rst:19
msgid ""
"On the real line, there are functions to compute uniform, normal (Gaussian), "
"lognormal, negative exponential, gamma, and beta distributions. For "
"generating distributions of angles, the von Mises distribution is available."
msgstr ""
"Para números reales, existen funciones para calcular distribuciones "
"uniformes, normales (Gaussianas), log-normales, exponenciales negativas, "
"gamma y beta. Para generar distribuciones angulares está disponible la "
"distribución de von Mises."

#: ../Doc/library/random.rst:23
#, fuzzy
msgid ""
"Almost all module functions depend on the basic function :func:`.random`, "
"which generates a random float uniformly in the half-open range ``0.0 <= X < "
"1.0``. Python uses the Mersenne Twister as the core generator.  It produces "
"53-bit precision floats and has a period of 2\\*\\*19937-1.  The underlying "
"implementation in C is both fast and threadsafe.  The Mersenne Twister is "
"one of the most extensively tested random number generators in existence.  "
"However, being completely deterministic, it is not suitable for all "
"purposes, and is completely unsuitable for cryptographic purposes."
msgstr ""
"Casi todas las funciones del módulo dependen de la función básica :func:`."
"random`, la cuál genera uniformemente un número flotante aleatorio en el "
"rango semiabierto [0.0, 1.0). Python utiliza Mersenne Twister como generador "
"principal. Éste produce números de coma flotante de 53 bits de precisión y "
"tiene un periodo de 2\\*\\*19937-1. La implementación subyacente en C es "
"rápida y segura para subprocesos. Mersenne Twister es uno de los generadores "
"de números aleatorios más testados que existen. Sin embargo, al ser "
"completamente determinístico, no es adecuado para todos los propósitos y es "
"completamente inadecuado para fines criptográficos."

#: ../Doc/library/random.rst:32
msgid ""
"The functions supplied by this module are actually bound methods of a hidden "
"instance of the :class:`random.Random` class.  You can instantiate your own "
"instances of :class:`Random` to get generators that don't share state."
msgstr ""
"Las funciones proporcionadas por este módulo en realidad son métodos "
"enlazados a instancias ocultas a la clase :class:`random.Random`. Puedes "
"instanciar tus propias instancias de :class:`Random` para obtener "
"generadores que no compartan estado."

#: ../Doc/library/random.rst:36
msgid ""
"Class :class:`Random` can also be subclassed if you want to use a different "
"basic generator of your own devising: in that case, override the :meth:"
"`~Random.random`, :meth:`~Random.seed`, :meth:`~Random.getstate`, and :meth:"
"`~Random.setstate` methods. Optionally, a new generator can supply a :meth:"
"`~Random.getrandbits` method --- this allows :meth:`randrange` to produce "
"selections over an arbitrarily large range."
msgstr ""
"La clase :class:`Random` puede ser también subclaseada si quieres usar un "
"generador básico diferente para tu propio diseño: en este caso, invalida los "
"métodos :meth:`~Random.random`, :meth:`~Random.seed`, :meth:`~Random."
"getstate` y :meth:`~Random.setstate`. Opcionalmente, se puede substituir un "
"método :meth:`~Random.getrandbits` por un nuevo generador --- esto permite "
"a :meth:`randrange` producir selecciones sobre un rango arbitrariamente "
"amplio."

#: ../Doc/library/random.rst:42
msgid ""
"The :mod:`random` module also provides the :class:`SystemRandom` class which "
"uses the system function :func:`os.urandom` to generate random numbers from "
"sources provided by the operating system."
msgstr ""
"El módulo :mod:`random` también proporciona la clase :class:`SystemRandom`, "
"la cuál usa la función del sistema :func:`os.urandom` para generar números "
"aleatorios a partir de fuentes proporcionadas por el sistema operativo."

#: ../Doc/library/random.rst:48
msgid ""
"The pseudo-random generators of this module should not be used for security "
"purposes.  For security or cryptographic uses, see the :mod:`secrets` module."
msgstr ""
"Los generadores pseudoaleatorios de este módulo no deben ser utilizados con "
"fines de seguridad. Para usos de seguridad o criptográficos, consulta el "
"módulo :mod:`secrets`."

#: ../Doc/library/random.rst:54
msgid ""
"M. Matsumoto and T. Nishimura, \"Mersenne Twister: A 623-dimensionally "
"equidistributed uniform pseudorandom number generator\", ACM Transactions on "
"Modeling and Computer Simulation Vol. 8, No. 1, January pp.3--30 1998."
msgstr ""
"M. Matsumoto y T. Nishimura, \"*Mersenne Twister: A 623-dimensionally "
"equidistributed uniform pseudorandom number generator*\", ACM Transactions "
"on Modeling and Computer Simulation Vol. 8, No. 1, January pp.3--30 1998."

#: ../Doc/library/random.rst:59
msgid ""
"`Complementary-Multiply-with-Carry recipe <https://code.activestate.com/"
"recipes/576707/>`_ for a compatible alternative random number generator with "
"a long period and comparatively simple update operations."
msgstr ""
"`*Complementary-Multiply-with-Carry recipe* <https://code.activestate.com/"
"recipes/576707/>`_ para otro generador de números aleatorios con un período "
"largo compatible y con operaciones de actualización comparativamente simples."

#: ../Doc/library/random.rst:66
msgid "Bookkeeping functions"
msgstr "Funciones de contabilidad"

#: ../Doc/library/random.rst:70
msgid "Initialize the random number generator."
msgstr "Inicializa el generador de números aleatorios."

#: ../Doc/library/random.rst:72
msgid ""
"If *a* is omitted or ``None``, the current system time is used.  If "
"randomness sources are provided by the operating system, they are used "
"instead of the system time (see the :func:`os.urandom` function for details "
"on availability)."
msgstr ""
"Si *a* es omitida o ``None``, se utilizará la hora actual del sistema. Si "
"las fuentes de aleatoriedad vienen del sistema operativo, éstas se usarán en "
"vez de la hora del sistema (ver la función :func:`os.urandom` para detalles "
"sobre su disponibilidad)."

#: ../Doc/library/random.rst:77
msgid "If *a* is an int, it is used directly."
msgstr "Si *a* es un entero, se usará directamente."

#: ../Doc/library/random.rst:79
msgid ""
"With version 2 (the default), a :class:`str`, :class:`bytes`, or :class:"
"`bytearray` object gets converted to an :class:`int` and all of its bits are "
"used."
msgstr ""
"Con la versión 2 (la versión por defecto), un objeto :class:`str`, :class:"
"`bytes`, o :class:`bytearray` se convierte en :class:`int` y se usarán todos "
"sus bits."

#: ../Doc/library/random.rst:82
msgid ""
"With version 1 (provided for reproducing random sequences from older "
"versions of Python), the algorithm for :class:`str` and :class:`bytes` "
"generates a narrower range of seeds."
msgstr ""
"Con la versión 1 (proporcionada para reproducir secuencias aleatorias desde "
"versiones anteriores de Python), el algoritmo para :class:`str` y :class:"
"`bytes` genera un rango de semillas más estrecho."

#: ../Doc/library/random.rst:86
msgid ""
"Moved to the version 2 scheme which uses all of the bits in a string seed."
msgstr ""
"El esquema que usa todos los bits en una semilla de tipo cadena, se ha "
"movido a la versión 2."

#: ../Doc/library/random.rst:89
msgid ""
"The *seed* must be one of the following types: *NoneType*, :class:`int`, :"
"class:`float`, :class:`str`, :class:`bytes`, or :class:`bytearray`."
msgstr ""
"La *semilla* debe ser de uno de los siguientes tipos: *NoneType*, :class:"
"`int`, :class:`float`, :class:`str`, :class:`bytes`, o :class:`bytearray`."

#: ../Doc/library/random.rst:96
msgid ""
"Return an object capturing the current internal state of the generator.  "
"This object can be passed to :func:`setstate` to restore the state."
msgstr ""
"Retorna un objeto capturando el estado interno del generador. Este objeto "
"puede pasarse a :func:`setstate` para restaurar su estado."

#: ../Doc/library/random.rst:102
msgid ""
"*state* should have been obtained from a previous call to :func:`getstate`, "
"and :func:`setstate` restores the internal state of the generator to what it "
"was at the time :func:`getstate` was called."
msgstr ""
"El *state* debería haberse obtenido de una llamada previa a :func:"
"`getstate`, y :func:`setstate` reestablece el estado interno del generador "
"al que tenia cuando se llamó a la función :func:`getstate`."

#: ../Doc/library/random.rst:108
msgid "Functions for bytes"
msgstr "Funciones para los bytes"

#: ../Doc/library/random.rst:112
msgid "Generate *n* random bytes."
msgstr "Genera *n* bytes aleatorios."

#: ../Doc/library/random.rst:114
msgid ""
"This method should not be used for generating security tokens. Use :func:"
"`secrets.token_bytes` instead."
msgstr ""
"Este método no debe utilizarse para generar tokens de seguridad. Utilice :"
"func:`secrets.token_bytes` en su lugar."

#: ../Doc/library/random.rst:121
msgid "Functions for integers"
msgstr "Funciones para enteros"

#: ../Doc/library/random.rst:126
msgid "Return a randomly selected element from ``range(start, stop, step)``."
msgstr ""

#: ../Doc/library/random.rst:128
msgid ""
"This is roughly equivalent to ``choice(range(start, stop, step))`` but "
"supports arbitrarily large ranges and is optimized for common cases."
msgstr ""

#: ../Doc/library/random.rst:131
msgid "The positional argument pattern matches the :func:`range` function."
msgstr ""

#: ../Doc/library/random.rst:133
msgid ""
"Keyword arguments should not be used because they can be interpreted in "
"unexpected ways. For example ``randrange(start=100)`` is interpreted as "
"``randrange(0, 100, 1)``."
msgstr ""

#: ../Doc/library/random.rst:137
msgid ""
":meth:`randrange` is more sophisticated about producing equally distributed "
"values.  Formerly it used a style like ``int(random()*n)`` which could "
"produce slightly uneven distributions."
msgstr ""
":meth:`randrange` es más sofisticado produciendo valores igualmente "
"distribuidos. Anteriormente utilizaba un estilo como ``int(random()*n)`` el "
"cual puede producir distribuciones ligeramente desiguales."

#: ../Doc/library/random.rst:142
#, fuzzy
msgid ""
"Automatic conversion of non-integer types is no longer supported. Calls such "
"as ``randrange(10.0)`` and ``randrange(Fraction(10, 1))`` now raise a :exc:"
"`TypeError`."
msgstr ""
"La conversión automática de tipos que no son enteros a enteros equivalentes "
"está obsoleta. Actualmente ``randrange(10.0)`` se convierte sin pérdidas a "
"``randrange(10)``.  En el futuro, esto lanzará un :exc:`TypeError`."

#: ../Doc/library/random.rst:149
msgid ""
"Return a random integer *N* such that ``a <= N <= b``.  Alias for "
"``randrange(a, b+1)``."
msgstr ""
"Retorna un entero aleatorio *N* tal que ``a <= N <= b``. Alias de "
"``randrange(a, b+1)``."

#: ../Doc/library/random.rst:154
#, fuzzy
msgid ""
"Returns a non-negative Python integer with *k* random bits. This method is "
"supplied with the Mersenne Twister generator and some other generators may "
"also provide it as an optional part of the API. When available, :meth:"
"`getrandbits` enables :meth:`randrange` to handle arbitrarily large ranges."
msgstr ""
"Retorna un entero de Python no negativo con *k* bits aleatorios. Este método "
"se provee con el generador MersenneTwister y algunos otros generadores "
"pueden también proveerlo como una parte opcional de la API. Cuando está "
"disponible, :meth:`getrandbits` permite a :meth:`randrange` manejar rangos "
"arbitrariamente grandes."

#: ../Doc/library/random.rst:160
msgid "This method now accepts zero for *k*."
msgstr "Este método ahora acepta cero para *k*."

#: ../Doc/library/random.rst:165
msgid "Functions for sequences"
msgstr "Funciones para secuencias"

#: ../Doc/library/random.rst:169
msgid ""
"Return a random element from the non-empty sequence *seq*. If *seq* is "
"empty, raises :exc:`IndexError`."
msgstr ""
"Retorna un elemento aleatorio de una secuencia *seq* no vacía. Si *seq* está "
"vacía, lanza :exc:`IndexError`."

#: ../Doc/library/random.rst:174
msgid ""
"Return a *k* sized list of elements chosen from the *population* with "
"replacement. If the *population* is empty, raises :exc:`IndexError`."
msgstr ""
"Retorna una lista de elementos de tamaño *k* elegidos de la *population* con "
"reemplazo. Si la *population* está vacía, lanza :exc:`IndexError`."

#: ../Doc/library/random.rst:177
msgid ""
"If a *weights* sequence is specified, selections are made according to the "
"relative weights.  Alternatively, if a *cum_weights* sequence is given, the "
"selections are made according to the cumulative weights (perhaps computed "
"using :func:`itertools.accumulate`).  For example, the relative weights "
"``[10, 5, 30, 5]`` are equivalent to the cumulative weights ``[10, 15, 45, "
"50]``.  Internally, the relative weights are converted to cumulative weights "
"before making selections, so supplying the cumulative weights saves work."
msgstr ""
"Si se especifica una secuencia *weights*, las selecciones se realizan de "
"acuerdo con las ponderaciones relativas. Alternativamente, si se da una "
"secuencia *cum_weights*, las selecciones se harán según los pesos "
"cumulativos (posiblemente se calculen usando :func:`itertools.accumulate`). "
"Por ejemplo, los pesos relativos ``[10, 5, 30, 5]`` son equivalentes a los "
"pesos cumulativos ``[10, 15, 45, 50]``. Internamente, los pesos relativos se "
"convierten en pesos cumulativos antes de hacer selecciones, por lo cual "
"suplir los pesos cumulativos ahorra trabajo."

#: ../Doc/library/random.rst:186
msgid ""
"If neither *weights* nor *cum_weights* are specified, selections are made "
"with equal probability.  If a weights sequence is supplied, it must be the "
"same length as the *population* sequence.  It is a :exc:`TypeError` to "
"specify both *weights* and *cum_weights*."
msgstr ""
"Si ni *weights* ni *cum_weights* están especificadas, las selecciones se "
"realizan con la misma probabilidad. Si se proporciona una secuencia de "
"ponderaciones, debe tener la misma longitud que la secuencia *population*. "
"Es un :exc:`TypeError` especificar ambas *weights* y *cum_weights*."

#: ../Doc/library/random.rst:191
msgid ""
"The *weights* or *cum_weights* can use any numeric type that interoperates "
"with the :class:`float` values returned by :func:`random` (that includes "
"integers, floats, and fractions but excludes decimals).  Weights are assumed "
"to be non-negative and finite.  A :exc:`ValueError` is raised if all weights "
"are zero."
msgstr ""
"Los *weights* o los *cum_weights* pueden utilizar cualquier tipo numérico "
"que interactúe con los valores :class:`float` retornados por :func:`random` "
"(eso incluye enteros, flotantes y fracciones pero excluye decimales). Se "
"asume que los pesos son no negativos y finitos.  Se lanza un :exc:"
"`ValueError` si todos los pesos son cero."

#: ../Doc/library/random.rst:197
msgid ""
"For a given seed, the :func:`choices` function with equal weighting "
"typically produces a different sequence than repeated calls to :func:"
"`choice`.  The algorithm used by :func:`choices` uses floating point "
"arithmetic for internal consistency and speed.  The algorithm used by :func:"
"`choice` defaults to integer arithmetic with repeated selections to avoid "
"small biases from round-off error."
msgstr ""
"Dada una semilla, la función :func:`choices` normalmente produce una "
"secuencia diferente a las llamadas repetidas a :func:`choice` con la misma "
"ponderación. El algoritmo usado por :func:`choices` emplea aritmética de "
"coma flotante para la consistencia interna y velocidad. El algoritmo usado "
"por :func:`choice` emplea por defecto aritmética de enteros con selecciones "
"repetidas para evitar pequeños sesgos de errores de redondeo."

#: ../Doc/library/random.rst:206
msgid "Raises a :exc:`ValueError` if all weights are zero."
msgstr "Genera un :exc:`ValueError` si todos los pesos son cero."

#: ../Doc/library/random.rst:212
msgid "Shuffle the sequence *x* in place."
msgstr "Mezcla la secuencia *x* in-situ."

#: ../Doc/library/random.rst:214
msgid ""
"To shuffle an immutable sequence and return a new shuffled list, use "
"``sample(x, k=len(x))`` instead."
msgstr ""
"Para mezclar una secuencia inmutable y retornar una nueva lista mezclada, "
"utilice ``muestra(x, k=len(x))`` en su lugar."

#: ../Doc/library/random.rst:217
msgid ""
"Note that even for small ``len(x)``, the total number of permutations of *x* "
"can quickly grow larger than the period of most random number generators. "
"This implies that most permutations of a long sequence can never be "
"generated.  For example, a sequence of length 2080 is the largest that can "
"fit within the period of the Mersenne Twister random number generator."
msgstr ""
"Tenga en cuenta que incluso para pequeños ``len(x)``, el número total de "
"permutaciones de *x* puede crecer rápidamente más que el periodo de muchos "
"generadores de números aleatorios. Esto implica que la mayoría de las "
"permutaciones de una secuencia larga nunca se pueden generar. Por ejemplo, "
"una secuencia de longitud 2080 es la más grande que cabe dentro del período "
"del generador de números aleatorios de Mersenne Twister."

#: ../Doc/library/random.rst:224
msgid "The optional parameter *random*."
msgstr "El parámetro opcional *random*."

#: ../Doc/library/random.rst:229
#, fuzzy
msgid ""
"Return a *k* length list of unique elements chosen from the population "
"sequence.  Used for random sampling without replacement."
msgstr ""
"Retorna una lista de longitud *k* de elementos únicos elegidos de la "
"secuencia de población o conjunto. Se utiliza para el muestreo aleatorio sin "
"reemplazo."

#: ../Doc/library/random.rst:232
msgid ""
"Returns a new list containing elements from the population while leaving the "
"original population unchanged.  The resulting list is in selection order so "
"that all sub-slices will also be valid random samples.  This allows raffle "
"winners (the sample) to be partitioned into grand prize and second place "
"winners (the subslices)."
msgstr ""
"Retorna una nueva lista que contiene elementos de la población sin modificar "
"la población original. La lista resultante está en orden de selección de "
"forma que todos los subsectores también son muestras aleatorias válidas. "
"Esto permite que los ganadores de la rifa (la muestra) se dividan en primer "
"premio y ganadores del segundo lugar (los subsectores)."

#: ../Doc/library/random.rst:238
msgid ""
"Members of the population need not be :term:`hashable` or unique.  If the "
"population contains repeats, then each occurrence is a possible selection in "
"the sample."
msgstr ""
"Los miembros de la población no tienen porqué ser :term:`hashable` o únicos. "
"Si la población incluye repeticiones, entonces cada ocurrencia es una "
"posible selección en la muestra."

#: ../Doc/library/random.rst:241
msgid ""
"Repeated elements can be specified one at a time or with the optional "
"keyword-only *counts* parameter.  For example, ``sample(['red', 'blue'], "
"counts=[4, 2], k=5)`` is equivalent to ``sample(['red', 'red', 'red', 'red', "
"'blue', 'blue'], k=5)``."
msgstr ""
"Los elementos repetidos pueden especificarse de uno en uno o con el "
"parámetro opcional *counts*, que es una palabra clave.  Por ejemplo, "
"``sample(['red', 'blue'], counts=[4, 2], k=5)`` es equivalente a "
"``sample(['red', 'red', 'red', 'red', 'blue', 'blue'], k=5)``."

#: ../Doc/library/random.rst:246
msgid ""
"To choose a sample from a range of integers, use a :func:`range` object as "
"an argument.  This is especially fast and space efficient for sampling from "
"a large population:  ``sample(range(10000000), k=60)``."
msgstr ""
"Para escoger una muestra de un rango de enteros, use un objeto :func:`range` "
"como argumento. Esto es especialmente rápido y eficiente en espacio para el "
"muestreo de poblaciones grandes: ``sample(range(10000000), k=60)``."

#: ../Doc/library/random.rst:250
msgid ""
"If the sample size is larger than the population size, a :exc:`ValueError` "
"is raised."
msgstr ""
"Si el tamaño de la muestra es mayor que el tamaño de la población, se "
"lanzará un :exc:`ValueError`."

#: ../Doc/library/random.rst:253
msgid "Added the *counts* parameter."
msgstr "Se añadió el parámetro *counts*."

#: ../Doc/library/random.rst:258
msgid ""
"The *population* must be a sequence.  Automatic conversion of sets to lists "
"is no longer supported."
msgstr ""
"La población debe ser una secuencia. La conversión automática de sets a "
"listas ya no es compatible."

#: ../Doc/library/random.rst:262
#, fuzzy
msgid "Discrete distributions"
msgstr "Distribuciones para los nombres reales"

#: ../Doc/library/random.rst:264
msgid "The following function generates a discrete distribution."
msgstr ""

#: ../Doc/library/random.rst:268
msgid ""
"`Binomial distribution <https://mathworld.wolfram.com/BinomialDistribution."
"html>`_. Return the number of successes for *n* independent trials with the "
"probability of success in each trial being *p*:"
msgstr ""

#: ../Doc/library/random.rst:273
msgid "Mathematically equivalent to::"
msgstr ""

#: ../Doc/library/random.rst:277
msgid ""
"The number of trials *n* should be a non-negative integer. The probability "
"of success *p* should be between ``0.0 <= p <= 1.0``. The result is an "
"integer in the range ``0 <= X <= n``."
msgstr ""

#: ../Doc/library/random.rst:287
msgid "Real-valued distributions"
msgstr "Distribuciones para los nombres reales"

#: ../Doc/library/random.rst:289
msgid ""
"The following functions generate specific real-valued distributions. "
"Function parameters are named after the corresponding variables in the "
"distribution's equation, as used in common mathematical practice; most of "
"these equations can be found in any statistics text."
msgstr ""
"Las siguientes funciones generan distribuciones específicas para números "
"reales. Los parámetros de la función reciben el nombre de las variables "
"correspondientes en la ecuación de distribución, tal y como se utilizan en "
"la práctica matemática común.; la mayoría de estas ecuaciones se pueden "
"encontrar en cualquier texto estadístico."

#: ../Doc/library/random.rst:297
#, fuzzy
msgid ""
"Return the next random floating point number in the range ``0.0 <= X < 1.0``"
msgstr ""
"Retorna el siguiente número en coma flotante aleatorio dentro del rango "
"[0.0, 1.0)."

#: ../Doc/library/random.rst:302
msgid ""
"Return a random floating point number *N* such that ``a <= N <= b`` for ``a "
"<= b`` and ``b <= N <= a`` for ``b < a``."
msgstr ""
"Retorna un número en coma flotante aleatorio *N* tal que ``a <= N <= b`` "
"para ``a <= b`` y ``b <= N <= a`` para ``b < a``."

#: ../Doc/library/random.rst:305
msgid ""
"The end-point value ``b`` may or may not be included in the range depending "
"on floating-point rounding in the equation ``a + (b-a) * random()``."
msgstr ""
"El valor final ``b`` puede o no estar incluido en el rango, dependiendo del "
"redondeo de coma flotante en la ecuación ``a + (b-a) * random()``."

#: ../Doc/library/random.rst:311
msgid ""
"Return a random floating point number *N* such that ``low <= N <= high`` and "
"with the specified *mode* between those bounds.  The *low* and *high* bounds "
"default to zero and one.  The *mode* argument defaults to the midpoint "
"between the bounds, giving a symmetric distribution."
msgstr ""
"Retorna un número de coma flotante *N* tal que ``low <= N <= high`` y con el "
"*mode* especificado entre esos límites. Los límites *low* (inferior) y "
"*high* (superior) son por defecto cero y uno. El argumento *mode* tiene como "
"valor por defecto el punto medio entre los límites, dando lugar a una "
"distribución simétrica."

#: ../Doc/library/random.rst:319
msgid ""
"Beta distribution.  Conditions on the parameters are ``alpha > 0`` and "
"``beta > 0``. Returned values range between 0 and 1."
msgstr ""
"Distribución beta. Las condiciones de los parámetros son ``alpha > 0`` y "
"``beta > 0``. Retorna valores dentro del rango entre 0 y 1."

#: ../Doc/library/random.rst:325
msgid ""
"Exponential distribution.  *lambd* is 1.0 divided by the desired mean.  It "
"should be nonzero.  (The parameter would be called \"lambda\", but that is a "
"reserved word in Python.)  Returned values range from 0 to positive infinity "
"if *lambd* is positive, and from negative infinity to 0 if *lambd* is "
"negative."
msgstr ""
"Distribución exponencial. *lambd* es 1.0 dividido entre la media deseada. "
"Debe ser distinto a cero (El parámetro debería llamarse ``lambda`` pero esa "
"es una palabra reservada en Python). Retorna valores dentro del rango de 0 a "
"infinito positivo si *lambd* es positivo, y de infinito negativo a 0 si "
"*lambd* es negativo."

#: ../Doc/library/random.rst:331
msgid "Added the default value for ``lambd``."
msgstr ""

#: ../Doc/library/random.rst:337
msgid ""
"Gamma distribution.  (*Not* the gamma function!)  The shape and scale "
"parameters, *alpha* and *beta*, must have positive values. (Calling "
"conventions vary and some sources define 'beta' as the inverse of the scale)."
msgstr ""

#: ../Doc/library/random.rst:342
msgid "The probability distribution function is::"
msgstr "La función de distribución de la probabilidad es::"

#: ../Doc/library/random.rst:351
#, fuzzy
msgid ""
"Normal distribution, also called the Gaussian distribution. *mu* is the "
"mean, and *sigma* is the standard deviation.  This is slightly faster than "
"the :func:`normalvariate` function defined below."
msgstr ""
"Distribución normal, también llamada la distribución Gaussiana. *mu* es la "
"media y *sigma* es la desviación estándar. Es un poco más rápida que la "
"función :func:`normalvariate` definida debajo."

#: ../Doc/library/random.rst:356
msgid ""
"Multithreading note:  When two threads call this function simultaneously, it "
"is possible that they will receive the same return value.  This can be "
"avoided in three ways. 1) Have each thread use a different instance of the "
"random number generator. 2) Put locks around all calls. 3) Use the slower, "
"but thread-safe :func:`normalvariate` function instead."
msgstr ""
"Nota sobre el multithreading: Cuando dos hilos llaman a esta función "
"simultáneamente, es posible que reciban el mismo valor de retorno.  Esto se "
"puede evitar de tres maneras. 1) Hacer que cada hilo utilice una instancia "
"diferente del generador de números aleatorios. 2) Poner bloqueos alrededor "
"de todas las llamadas. 3) Utilizar la función :func:`normalvariate`, más "
"lenta pero segura para los hilos, en su lugar."

#: ../Doc/library/random.rst:363 ../Doc/library/random.rst:379
msgid "*mu* and *sigma* now have default arguments."
msgstr "*mu* y *sigma* ahora tienen argumentos predeterminados."

#: ../Doc/library/random.rst:369
msgid ""
"Log normal distribution.  If you take the natural logarithm of this "
"distribution, you'll get a normal distribution with mean *mu* and standard "
"deviation *sigma*.  *mu* can have any value, and *sigma* must be greater "
"than zero."
msgstr ""
"Logaritmo de la distribución normal. Si se usa un logaritmo natural de esta "
"distribución, se obtendrá una distribución normal con media *mu* y "
"desviación estándar *sigma*. *mu* puede tener cualquier valor, y *sigma* "
"debe ser mayor que cero."

#: ../Doc/library/random.rst:377
msgid ""
"Normal distribution.  *mu* is the mean, and *sigma* is the standard "
"deviation."
msgstr ""
"Distribución normal. *mu* es la media y *sigma* es la desviación estándar."

#: ../Doc/library/random.rst:385
msgid ""
"*mu* is the mean angle, expressed in radians between 0 and 2\\*\\ *pi*, and "
"*kappa* is the concentration parameter, which must be greater than or equal "
"to zero.  If *kappa* is equal to zero, this distribution reduces to a "
"uniform random angle over the range 0 to 2\\*\\ *pi*."
msgstr ""
"*mu* es el ángulo medio, expresado en radiantes entre 0 y 2\\*\\ *pi*, y "
"*kappa* es el parámetro de concentración, que debe ser mayor o igual a cero. "
"Si *kappa* es igual a cero, esta distribución se reduce a un ángulo "
"aleatorio uniforme sobre el rango de 0 a 2\\*\\ *pi*."

#: ../Doc/library/random.rst:393
msgid "Pareto distribution.  *alpha* is the shape parameter."
msgstr "Distribución de Pareto. *alpha* es el parámetro de forma."

#: ../Doc/library/random.rst:398
msgid ""
"Weibull distribution.  *alpha* is the scale parameter and *beta* is the "
"shape parameter."
msgstr ""
"Distribución de Weibull. *alpha* es el parámetro de escala y *beta* es el "
"parámetro de forma."

#: ../Doc/library/random.rst:403
msgid "Alternative Generator"
msgstr "Generador alternativo"

#: ../Doc/library/random.rst:407
msgid ""
"Class that implements the default pseudo-random number generator used by "
"the :mod:`random` module."
msgstr ""
"Esta clase implementa el generador de números pseudoaleatorios "
"predeterminado que usa el módulo :mod:`random` ."

#: ../Doc/library/random.rst:413
#, fuzzy
msgid ""
"Formerly the *seed* could be any hashable object.  Now it is limited to: :"
"class:`NoneType`, :class:`int`, :class:`float`, :class:`str`, :class:"
"`bytes`, or :class:`bytearray`."
msgstr ""
"En el futuro, la *semilla* debe ser de uno de los siguientes tipos: :class:"
"`NoneType`, :class:`int`, :class:`float`, :class:`str`, :class:`bytes`, o :"
"class:`bytearray`."

#: ../Doc/library/random.rst:417
msgid ""
"Class that uses the :func:`os.urandom` function for generating random "
"numbers from sources provided by the operating system. Not available on all "
"systems. Does not rely on software state, and sequences are not "
"reproducible. Accordingly, the :meth:`seed` method has no effect and is "
"ignored. The :meth:`getstate` and :meth:`setstate` methods raise :exc:"
"`NotImplementedError` if called."
msgstr ""
"Clase que utiliza la función :func:`os.urandom` para generar números "
"aleatorios a partir de fuentes proporcionadas por el sistema operativo. No "
"está disponible en todos los sistemas. No se basa en el estado del software "
"y las secuencias no son reproducibles. En consecuencia, el método :meth:"
"`seed` no tiene efecto y es ignorado. Los métodos :meth:`getstate` y :meth:"
"`setstate` lanzan :exc:`NotImplementedError` si se les llama."

#: ../Doc/library/random.rst:426
msgid "Notes on Reproducibility"
msgstr "Notas sobre la Reproducibilidad"

#: ../Doc/library/random.rst:428
#, fuzzy
msgid ""
"Sometimes it is useful to be able to reproduce the sequences given by a "
"pseudo-random number generator.  By reusing a seed value, the same sequence "
"should be reproducible from run to run as long as multiple threads are not "
"running."
msgstr ""
"A veces es útil poder reproducir las secuencias dadas por un generador de "
"números pseudoaleatorios.  Al reutilizar un valor de semilla, la misma "
"secuencia debería ser reproducible de una ejecución a otra siempre que no se "
"estén ejecutando múltiples hilos."

#: ../Doc/library/random.rst:432
msgid ""
"Most of the random module's algorithms and seeding functions are subject to "
"change across Python versions, but two aspects are guaranteed not to change:"
msgstr ""
"Muchos de los algoritmos y de las funciones de generación de semillas del "
"módulo aleatorio pueden cambiar entre versiones de Python, pero se garantiza "
"que dos aspectos no cambien::"

#: ../Doc/library/random.rst:435
msgid ""
"If a new seeding method is added, then a backward compatible seeder will be "
"offered."
msgstr ""
"Si se añade un nuevo método de generación de semilla, se ofrecerá un "
"generador de semilla retrocompatible."

#: ../Doc/library/random.rst:438
msgid ""
"The generator's :meth:`~Random.random` method will continue to produce the "
"same sequence when the compatible seeder is given the same seed."
msgstr ""
"El método generador :meth:`~Random.random` continuará produciendo la misma "
"secuencia cuando se le da la misma semilla al generador de semilla "
"compatible."

#: ../Doc/library/random.rst:444
msgid "Examples"
msgstr "Ejemplos"

#: ../Doc/library/random.rst:446
msgid "Basic examples::"
msgstr "Ejemplos básicos::"

#: ../Doc/library/random.rst:474
msgid "Simulations::"
msgstr "Simulaciones::"

#: ../Doc/library/random.rst:499
msgid ""
"Example of `statistical bootstrapping <https://en.wikipedia.org/wiki/"
"Bootstrapping_(statistics)>`_ using resampling with replacement to estimate "
"a confidence interval for the mean of a sample::"
msgstr ""
"Ejemplo de `statistical bootstrapping <https://en.wikipedia.org/wiki/"
"Bootstrapping_(statistics)>`_ utilizando el remuestreo con reemplazo para "
"estimar un intervalo de confianza para la media de una muestra::"

#: ../Doc/library/random.rst:512
msgid ""
"Example of a `resampling permutation test <https://en.wikipedia.org/wiki/"
"Resampling_(statistics)#Permutation_tests>`_ to determine the statistical "
"significance or `p-value <https://en.wikipedia.org/wiki/P-value>`_ of an "
"observed difference between the effects of a drug versus a placebo::"
msgstr ""
"Ejemplo de un `test de permutación en remuestreo (en) <https://en.wikipedia."
"org/wiki/Resampling_(statistics)#Permutation_tests>`_ para determinar la "
"significación estadística o `p-valor <https://es.wikipedia.org/wiki/"
"Valor_p>`_ de una diferencia observada entre los efectos de un fármaco y un "
"placebo::"

#: ../Doc/library/random.rst:539
msgid ""
"Simulation of arrival times and service deliveries for a multiserver queue::"
msgstr ""
"Simulación de tiempos de llegada y entrega de servicios para una cola de "
"múltiples servidores::"

#: ../Doc/library/random.rst:568
msgid ""
"`Statistics for Hackers <https://www.youtube.com/watch?v=Iq9DzN6mvYA>`_ a "
"video tutorial by `Jake Vanderplas <https://us.pycon.org/2016/speaker/"
"profile/295/>`_ on statistical analysis using just a few fundamental "
"concepts including simulation, sampling, shuffling, and cross-validation."
msgstr ""
"`*Statistics for Hackers* <https://www.youtube.com/watch?v=Iq9DzN6mvYA>`_ un "
"video tutorial de `Jake Vanderplas <https://us.pycon.org/2016/speaker/"
"profile/295/>`_ sobre análisis estadístico usando sólo algunos conceptos "
"fundamentales incluyendo simulación, muestreo, baraja y validación cruzada."

#: ../Doc/library/random.rst:574
#, fuzzy
msgid ""
"`Economics Simulation <https://nbviewer.jupyter.org/url/norvig.com/ipython/"
"Economics.ipynb>`_ a simulation of a marketplace by `Peter Norvig <https://"
"norvig.com/bio.html>`_ that shows effective use of many of the tools and "
"distributions provided by this module (gauss, uniform, sample, betavariate, "
"choice, triangular, and randrange)."
msgstr ""
"`*Economics Simulation* <http://nbviewer.jupyter.org/url/norvig.com/ipython/"
"Economics.ipynb>`_una simulación de un mercado por `Peter Norvig <http://"
"norvig.com/bio.html>`_ que muestra un uso efectivo de las herramientas y "
"distribuciones proporcionadas por este modulo (*gauss*, *uniform*, *sample*, "
"*betavariate*, *choice*, *triangular*, y *randrange*)."

#: ../Doc/library/random.rst:581
#, fuzzy
msgid ""
"`A Concrete Introduction to Probability (using Python) <https://nbviewer."
"jupyter.org/url/norvig.com/ipython/Probability.ipynb>`_ a tutorial by `Peter "
"Norvig <https://norvig.com/bio.html>`_ covering the basics of probability "
"theory, how to write simulations, and how to perform data analysis using "
"Python."
msgstr ""
"`*A Concrete Introduction to Probability (using Python)* <http://nbviewer."
"jupyter.org/url/norvig.com/ipython/Probability.ipynb>`_un tutorial de `Peter "
"Norvig <http://norvig.com/bio.html>`_ cubriendo teoría básica de "
"probabilidad, cómo escribir simulaciones y cómo realizar un análisis de "
"datos usando Python."

#: ../Doc/library/random.rst:589
msgid "Recipes"
msgstr "Recetas"

#: ../Doc/library/random.rst:591
msgid ""
"These recipes show how to efficiently make random selections from the "
"combinatoric iterators in the :mod:`itertools` module:"
msgstr ""
"Estas recetas muestran cómo hacer de manera eficiente selecciones aleatorias "
"de los iteradores combinatorios en el módulo :mod:`itertools`:"

#: ../Doc/library/random.rst:623
msgid ""
"The default :func:`.random` returns multiples of 2⁻⁵³ in the range *0.0 ≤ x "
"< 1.0*.  All such numbers are evenly spaced and are exactly representable as "
"Python floats.  However, many other representable floats in that interval "
"are not possible selections.  For example, ``0.05954861408025609`` isn't an "
"integer multiple of 2⁻⁵³."
msgstr ""
"La función :func:`.random` por defecto devuelve múltiplos de 2⁻⁵³ en el "
"rango *0.0 ≤ x < 1.0*.  Todos estos números están espaciados uniformemente y "
"son representables exactamente como flotantes de Python.  Sin embargo, "
"muchos otros flotadores representables en ese intervalo no son selecciones "
"posibles.  Por ejemplo, ``0.05954861408025609`` no es un múltiplo entero de "
"2⁻⁵³."

#: ../Doc/library/random.rst:629
msgid ""
"The following recipe takes a different approach.  All floats in the interval "
"are possible selections.  The mantissa comes from a uniform distribution of "
"integers in the range *2⁵² ≤ mantissa < 2⁵³*.  The exponent comes from a "
"geometric distribution where exponents smaller than *-53* occur half as "
"often as the next larger exponent."
msgstr ""
"La siguiente receta adopta un enfoque diferente.  Todos los flotantes en el "
"intervalo son selecciones posibles.  La mantisa proviene de una distribución "
"uniforme de enteros en el rango *2⁵² ≤ mantisa < 2⁵³*.  El exponente "
"proviene de una distribución geométrica en la que los exponentes menores de "
"*-53* ocurren con la mitad de frecuencia que el siguiente exponente mayor."

#: ../Doc/library/random.rst:651
msgid ""
"All :ref:`real valued distributions <real-valued-distributions>` in the "
"class will use the new method::"
msgstr ""
"Todas las :ref:`distribuciones de valor real <real-valued-distributions>` de "
"la clase utilizarán el nuevo método::"

#: ../Doc/library/random.rst:660
msgid ""
"The recipe is conceptually equivalent to an algorithm that chooses from all "
"the multiples of 2⁻¹⁰⁷⁴ in the range *0.0 ≤ x < 1.0*.  All such numbers are "
"evenly spaced, but most have to be rounded down to the nearest representable "
"Python float.  (The value 2⁻¹⁰⁷⁴ is the smallest positive unnormalized float "
"and is equal to ``math.ulp(0.0)``.)"
msgstr ""
"La receta es conceptualmente equivalente a un algoritmo que elige entre "
"todos los múltiplos de 2⁻¹⁰⁷⁴ en el rango *0,0 ≤ x < 1,0*.  Todos esos "
"números son uniformes, pero la mayoría tienen que ser redondeados al "
"flotante de Python representable más cercano.  (El valor 2⁻¹⁰⁷⁴ es el menor "
"flotante positivo no normalizado y es igual a ``math.ulp(0.0)``.)"

#: ../Doc/library/random.rst:669
msgid ""
"`Generating Pseudo-random Floating-Point Values <https://allendowney.com/"
"research/rand/downey07randfloat.pdf>`_ a paper by Allen B. Downey describing "
"ways to generate more fine-grained floats than normally generated by :func:`."
"random`."
msgstr ""
"`Generating Pseudo-random Floating-Point Values <https://allendowney.com/"
"research/rand/downey07randfloat.pdf>`_ un artículo de Allen B. Downey en el "
"que se describen formas de generar flotantes más refinados que los generados "
"normalmente por :func:`.random`."

#~ msgid ""
#~ "Return a randomly selected element from ``range(start, stop, step)``.  "
#~ "This is equivalent to ``choice(range(start, stop, step))``, but doesn't "
#~ "actually build a range object."
#~ msgstr ""
#~ "Retorna un elemento de ``range(start, stop, step)`` seleccionado "
#~ "aleatoriamente. Esto es equivalente a ``choice(range(start, stop, "
#~ "step))``, pero en realidad no crea un objeto rango."

#~ msgid ""
#~ "The positional argument pattern matches that of :func:`range`.  Keyword "
#~ "arguments should not be used because the function may use them in "
#~ "unexpected ways."
#~ msgstr ""
#~ "El patrón de argumento posicional coincide con el de :func:`range`. Los "
#~ "argumentos no deben usarse porque la función puede usarlos de forma "
#~ "inesperada."

#~ msgid ""
#~ "The exception raised for non-integral values such as ``randrange(10.5)`` "
#~ "or ``randrange('10')`` will be changed from :exc:`ValueError` to :exc:"
#~ "`TypeError`."
#~ msgstr ""
#~ "La excepción que se lanza de valores no enteros como ``randrange(10.5)`` "
#~ "o ``randrange('10')`` se cambiará de :exc:`ValueError` a :exc:`TypeError`."

#~ msgid ""
#~ "Gamma distribution.  (*Not* the gamma function!)  Conditions on the "
#~ "parameters are ``alpha > 0`` and ``beta > 0``."
#~ msgstr ""
#~ "Distribución gamma. (¡*No* la función gamma!) Las condiciones en los "
#~ "parámetros son ``alpha > 0`` y ``beta > 0``."