simopt.input_models
===================

.. py:module:: simopt.input_models

.. autoapi-nested-parse::

   Simple input-model wrappers for common distributions.







Module Contents
---------------

.. py:data:: P

.. py:data:: R

.. py:class:: InputModel

   Bases: :py:obj:`Protocol`\ [\ :py:obj:`P`\ , :py:obj:`R`\ ]


   Abstract base for input models used by simulations.


   .. py:attribute:: rng
      :type:  random.Random | None
      :value: None



   .. py:method:: set_rng(rng: random.Random) -> None

      Attach a Python RNG to the input model.

      :param rng: Random number generator to use for sampling.
      :type rng: random.Random



   .. py:method:: unset_rng() -> None

      Detach any RNG currently attached to the input model.



   .. py:method:: random(*args: P, **kwargs: P) -> R
      :abstractmethod:


      Generate a random variate from the input model.

      :returns: A random variate from the input model.
      :rtype: T



.. py:class:: Exp

   Bases: :py:obj:`InputModel`


   Exponential distribution wrapper.


   .. py:method:: random(lambda_: float) -> float

      Sample from Exp(lambda_).

      :param lambda_: Rate parameter (lambda > 0).
      :type lambda_: float

      :returns: An exponential variate.
      :rtype: float



.. py:class:: Gamma

   Bases: :py:obj:`InputModel`


   Gamma distribution wrapper.


   .. py:method:: random(alpha: float, beta: float) -> float

      Sample from Gamma(alpha, beta).

      :param alpha: Shape parameter.
      :type alpha: float
      :param beta: Scale parameter.
      :type beta: float

      :returns: A gamma variate.
      :rtype: float



.. py:class:: WeightedChoice

   Bases: :py:obj:`InputModel`


   Discrete weighted choice wrapper.


   .. py:method:: random(population: collections.abc.Sequence[object], weights: collections.abc.Sequence[float]) -> object

      Sample an element from ``population`` according to ``weights``.

      :param population: Items to choose from.
      :type population: Sequence
      :param weights: Nonnegative weights for each item.
      :type weights: Sequence[float]

      :returns: A randomly selected element from ``population``.
      :rtype: Any



.. py:class:: Poisson

   Bases: :py:obj:`InputModel`


   Poisson distribution wrapper.


   .. py:method:: random(lam: float) -> int

      Sample from Poisson(lam).

      :param lam: Mean rate parameter (lambda >= 0).
      :type lam: float

      :returns: A Poisson variate.
      :rtype: int



.. py:class:: Beta

   Bases: :py:obj:`InputModel`


   Beta distribution wrapper.


   .. py:method:: random(alpha: float, beta: float) -> float

      Sample from Beta(alpha, beta).

      :param alpha: Alpha (>= 0).
      :type alpha: float
      :param beta: Beta (>= 0).
      :type beta: float

      :returns: A beta variate in [0, 1].
      :rtype: float



.. py:class:: Triangular

   Bases: :py:obj:`InputModel`


   Triangular distribution wrapper.


   .. py:method:: random(low: float, high: float, mode: float) -> float

      Sample from Triangular(low, high, mode).

      :param low: Lower bound.
      :type low: float
      :param high: Upper bound.
      :type high: float
      :param mode: Mode of the distribution.
      :type mode: float

      :returns: A triangular variate.
      :rtype: float



.. py:class:: Uniform

   Bases: :py:obj:`InputModel`


   Uniform distribution wrapper.


   .. py:method:: random(low: float, high: float) -> float

      Sample from Uniform(low, high).

      :param low: Lower bound.
      :type low: float
      :param high: Upper bound.
      :type high: float

      :returns: A uniform variate in [low, high].
      :rtype: float



.. py:class:: Normal

   Bases: :py:obj:`InputModel`


   Normal distribution wrapper.


   .. py:method:: random(mu: float = 0.0, sigma: float = 1.0) -> float

      Sample from Normal(mu, sigma).

      :param mu: Mean.
      :type mu: float
      :param sigma: Standard deviation.
      :type sigma: float

      :returns: A normal variate.
      :rtype: float