Vous êtes un professionnel et vous avez besoin d'une formation ? Machine Learning
avec Scikit-Learn Voir le programme détaillé

Module « scipy.special »

Fonction nbdtr - module scipy.special

Signature de la fonction nbdtr

def nbdtr(*args, **kwargs) 

Description

help(scipy.special.nbdtr)

nbdtr(x1, x2, x3, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])

nbdtr(k, n, p, out=None)

Negative binomial cumulative distribution function.

Returns the sum of the terms 0 through `k` of the negative binomial
distribution probability mass function,

.. math::

    F = \sum_{j=0}^k {{n + j - 1}\choose{j}} p^n (1 - p)^j.

In a sequence of Bernoulli trials with individual success probabilities
`p`, this is the probability that `k` or fewer failures precede the nth
success.

Parameters
----------
k : array_like
    The maximum number of allowed failures (nonnegative int).
n : array_like
    The target number of successes (positive int).
p : array_like
    Probability of success in a single event (float).
out : ndarray, optional
    Optional output array for the function results

Returns
-------
F : scalar or ndarray
    The probability of `k` or fewer failures before `n` successes in a
    sequence of events with individual success probability `p`.

See Also
--------
nbdtrc : Negative binomial survival function
nbdtrik : Negative binomial quantile function
scipy.stats.nbinom : Negative binomial distribution

Notes
-----
If floating point values are passed for `k` or `n`, they will be truncated
to integers.

The terms are not summed directly; instead the regularized incomplete beta
function is employed, according to the formula,

.. math::
    \mathrm{nbdtr}(k, n, p) = I_{p}(n, k + 1).

Wrapper for the Cephes [1]_ routine `nbdtr`.

The negative binomial distribution is also available as
`scipy.stats.nbinom`. Using `nbdtr` directly can improve performance
compared to the ``cdf`` method of `scipy.stats.nbinom` (see last example).

References
----------
.. [1] Cephes Mathematical Functions Library,
       http://www.netlib.org/cephes/

Examples
--------
Compute the function for ``k=10`` and ``n=5`` at ``p=0.5``.

>>> import numpy as np
>>> from scipy.special import nbdtr
>>> nbdtr(10, 5, 0.5)
0.940765380859375

Compute the function for ``n=10`` and ``p=0.5`` at several points by
providing a NumPy array or list for `k`.

>>> nbdtr([5, 10, 15], 10, 0.5)
array([0.15087891, 0.58809853, 0.88523853])

Plot the function for four different parameter sets.

>>> import matplotlib.pyplot as plt
>>> k = np.arange(130)
>>> n_parameters = [20, 20, 20, 80]
>>> p_parameters = [0.2, 0.5, 0.8, 0.5]
>>> linestyles = ['solid', 'dashed', 'dotted', 'dashdot']
>>> parameters_list = list(zip(p_parameters, n_parameters,
...                            linestyles))
>>> fig, ax = plt.subplots(figsize=(8, 8))
>>> for parameter_set in parameters_list:
...     p, n, style = parameter_set
...     nbdtr_vals = nbdtr(k, n, p)
...     ax.plot(k, nbdtr_vals, label=rf"$n={n},\, p={p}$",
...             ls=style)
>>> ax.legend()
>>> ax.set_xlabel("$k$")
>>> ax.set_title("Negative binomial cumulative distribution function")
>>> plt.show()

The negative binomial distribution is also available as
`scipy.stats.nbinom`. Using `nbdtr` directly can be much faster than
calling the ``cdf`` method of `scipy.stats.nbinom`, especially for small
arrays or individual values. To get the same results one must use the
following parametrization: ``nbinom(n, p).cdf(k)=nbdtr(k, n, p)``.

>>> from scipy.stats import nbinom
>>> k, n, p = 5, 3, 0.5
>>> nbdtr_res = nbdtr(k, n, p)  # this will often be faster than below
>>> stats_res = nbinom(n, p).cdf(k)
>>> stats_res, nbdtr_res  # test that results are equal
(0.85546875, 0.85546875)

`nbdtr` can evaluate different parameter sets by providing arrays with
shapes compatible for broadcasting for `k`, `n` and `p`. Here we compute
the function for three different `k` at four locations `p`, resulting in
a 3x4 array.

>>> k = np.array([[5], [10], [15]])
>>> p = np.array([0.3, 0.5, 0.7, 0.9])
>>> k.shape, p.shape
((3, 1), (4,))

>>> nbdtr(k, 5, p)
array([[0.15026833, 0.62304687, 0.95265101, 0.9998531 ],
       [0.48450894, 0.94076538, 0.99932777, 0.99999999],
       [0.76249222, 0.99409103, 0.99999445, 1.        ]])

Vous êtes un professionnel et vous avez besoin d'une formation ? Mise en oeuvre d'IHM
avec Qt et PySide6 Voir le programme détaillé