bivpoispy 0.1.0__tar.gz

bivpoispy-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ilyan Alexey Cortés Miranda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

bivpoispy-0.1.0/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: bivpoispy
+Version: 0.1.0
+Summary: Tols for bivariate Poisson distribution: density, sampling, MLE, and goodness-of-fit
+Author-email: Ilyan Alexey Cortés Miranda <alexey.cortes13@gmail.com>
+License-Expression: MIT
+Keywords: bivpois,bivariate poisson
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20
+Requires-Dist: scipy>=1.7
+Requires-Dist: matplotlib>=3.5
+Requires-Dist: numdifftools>=0.9
+Dynamic: license-file

bivpoispy-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools >= 61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "bivpoispy"
+version = "0.1.0"
+description = "Tols for bivariate Poisson distribution: density, sampling, MLE, and goodness-of-fit"
+readme = "README.md"
+authors = [
+    {name = "Ilyan Alexey Cortés Miranda", email = "alexey.cortes13@gmail.com"}
+]
+keywords = ["bivpois", "bivariate poisson"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering :: Mathematics",
+    "Programming Language :: Python :: 3",
+]
+license = "MIT"
+
+requires-python = ">= 3.9"
+dependencies = [
+    "numpy >= 1.20",
+    "scipy >= 1.7",
+    "matplotlib >= 3.5",
+    "numdifftools >= 0.9",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]

bivpoispy-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

bivpoispy-0.1.0/src/bivpoispy/__init__.py

@@ -0,0 +1 @@
+from .bivpoispy import logp, random, contour, mle, gof, lambda3_profile, BivpoisMle

bivpoispy-0.1.0/src/bivpoispy/bivpoispy.py

@@ -0,0 +1,460 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib import gridspec, cm
+from mpl_toolkits.axes_grid1 import make_axes_locatable
+from scipy.special import gammaln, logsumexp
+from scipy.stats import chi2, norm 
+from scipy.optimize import minimize 
+import numdifftools as nd
+from numpy.typing import ArrayLike, NDArray
+from dataclasses import dataclass
+
+__all__ = ['logp', 'random', 'contour', 'mle', 'gof', 'lambda3_profile', 'BivpoisMle']
+
+def _log_choose(n: np.ndarray, k: np.ndarray) -> np.ndarray:
+    """This function computes the log of the binomial coefficients of a polynomial of degree n
+    also known as n choose k.
+
+    Parameters
+    ----------
+    n : numpy array 
+        Total number of elements.
+    k : numpy array
+        Number of elements to choose.
+
+    Returns
+    -------
+    numpy array 
+        An array containing the values of the log n choose k of each values of n and k.
+        Returns -inf when k > n or k < 0, and 0 when n = 0 or k = 0.
+
+    """
+    modif_n = np.where((n < k) | (n ==0), k, n)  
+    modif_k = np.where(k == 0, 1, k)           
+    
+    result = gammaln(modif_n+1) - gammaln(modif_n-modif_k+1) - gammaln(modif_k+1)
+    result[(n < k)| (k < 0)] = -np.inf 
+    result[(n == 0) | (k == 0)] = 0 
+    return result
+
+def _make_llf(mx, my, n, sly1, sly2, z, f2a, indexes):
+    """Build the negative log-likelihood function for lam3."""
+    def llf(lam3):
+        """Negative log-likelihood as a function of lam3, with lam1 and lam2
+        derived from the sample means as lam1 = mx - lam3, lam2 = my - lam3."""
+
+        lam1 = mx - lam3
+        lam2 = my - lam3
+        if lam1 <= 0 or lam2 <= 0 or lam3 < 0:
+            return np.inf
+        
+        lam = lam3 / (lam1 * lam2)
+        llf_value = -n * (lam1 + lam2 + lam3) - sly1 - sly2 + n * mx * np.log(lam1) + n * my * np.log(lam2) 
+
+        if lam3 != 0:
+            log_lam_term = np.where(indexes == 0, 0, np.log(lam) * indexes)
+            sum_terms = f2a + log_lam_term
+            sum_terms = np.where(z[None, :] < indexes, -np.inf, sum_terms)
+            last_term = logsumexp(sum_terms, axis = 0)
+            llf_value += last_term.sum()
+
+        return -llf_value
+    return llf
+
+def logp(value: ArrayLike, lam1: float, lam2: float, lam3: float, logged: bool =True) -> np.ndarray:
+    r"""This function computes the log (or not) probability density function of the Poisson Bivariate distribution.
+    
+    
+    It's defined like:
+
+    \(\log(p(x, y) ) = -(\lambda_1+\lambda_2+\lambda_3) + x \log({\lambda_1}) - \log(x!) +  y \log(\lambda_2) -
+    \log(y!) + \log \left( \sum_{i = 0}^{min(x,y)}{\binom xi \binom yi i! \left(\frac{\lambda_3}{\lambda_1\lambda_2}\right)^i} \right)\)
+
+    Parameters
+    ----------
+    value : array like 
+        the observed count values.
+    lam1 : float
+        the value of the parameter $\lambda_1$.
+    lam2 : float
+        the value of the parameter $\lambda_2$.
+    lam3 : float
+        the value of the parameter $\lambda_3$.
+    logged : boolean, optional 
+        If True (default), returns the log-density.
+        If False, returns the density on the original scale.
+        
+    Returns
+    -------
+    numpy array
+        the value logged or not of the probability of the observed values given the parameters $(\lambda_1, \lambda_2, \lambda_3)$
+
+    """
+    value = np.asarray(value)
+
+    if lam1 <= 0 or lam2 <= 0:
+        raise ValueError(f"lam1 and lam2 must be > 0, got lam1={lam1}, lam2={lam2}")
+    if lam3 < 0:
+        raise ValueError(f"lam3 must be >= 0, got lam3={lam3}")
+
+    x = value[..., 0]   
+    y = value[..., 1]
+    batch_shape = x.shape  
+    lam = lam3 / (lam1 * lam2)
+
+    first_team = (- (lam1 + lam2 + lam3)
+                  + x * np.log(lam1) - gammaln(x + 1)
+                  + y * np.log(lam2) - gammaln(y + 1))
+    logp_flat = first_team.ravel()
+
+    if lam3 != 0:
+        x_flat = x.ravel()   
+        y_flat = y.ravel()
+        lam_flat = np.broadcast_to(lam, batch_shape).ravel()
+        z = np.minimum(x_flat, y_flat)
+        m = int(np.max(z))
+        indexes = np.arange(m + 1)[:, None]  
+
+        sum_terms = (
+            _log_choose(x_flat[None, :], indexes)
+            + _log_choose(y_flat[None, :], indexes)
+            + gammaln(indexes + 1)
+            + np.log(lam_flat[None, :]) * indexes
+        )
+
+        sum_terms[z[None, :] < indexes] = -np.inf
+        logp_flat += logsumexp(sum_terms, axis=0)  
+    result = logp_flat.reshape(batch_shape)  
+
+    return result if logged else np.exp(result)
+
+def random(lam1: float, lam2: float, lam3: float, size: int) -> np.ndarray:
+    """This function computes random draws of the bivariate Poisson distribution with parameters lam1, lam2, lam3.
+
+    Parameters
+    ----------
+    lam1 : float
+        the value of the parameter lambda1.
+    lam2 : float
+        the value of the parameter lambda_2.
+    lam3 : float
+        the value of the parameter lambda_3.
+    size : int 
+        the sample size.
+
+    Returns
+    -------
+    numpy array
+        A two dimensional vector containing size samples of the bivariate Poisson distribution parameters lambda_1, lambda_2, lambda_3.
+
+    """
+    x1 = np.random.poisson(lam1, size=size)
+    x2 = np.random.poisson(lam2, size=size)
+    x3 = np.random.poisson(lam3, size=size)
+
+    return np.array([x1+x3, x2+x3]).T
+
+def contour(value: ArrayLike, lam1: float, lam2: float, lam3:float, points: bool=True):
+    """This function plot the contour of the bivariate Poisson with coefficients lam1, lam2, lam3)
+
+    Parameters
+    ----------
+    value : array like
+        The count observed values
+    lam1 : float
+        The value of the parameter lambda_1.
+    lam2 : float
+        The value of the parameter lambda_2.
+    lam3 : float
+        The value of the parameter lambda_3.
+    points : boolean
+        If True (default), plot the observed points in value.
+        If False, don't plot the points saved in value.
+        
+
+    """
+    if lam1 <= 0 or lam2 <= 0:
+        raise ValueError(f"lam1 and lam2 must be > 0, got lam1={lam1}, lam2={lam2}")
+    if lam3 < 0:
+        raise ValueError(f"lam3 must be >= 0, got lam3={lam3}")
+
+    x = value[..., 0]  
+    y = value[..., 1]
+    z1, z2 = np.mgrid[
+        (np.max(np.min(x)-3, 0)):(np.max(x) + 3), 
+        (np.max(np.min(y) -3, 0)):(np.max(y) + 3)
+    ]
+    z = logp(np.dstack((z1, z2)), lam1, lam2, lam3, logged = False)
+    
+    fig = plt.figure(figsize=(7, 7))
+    gs = gridspec.GridSpec(
+        2, 2, width_ratios=[2, 1], height_ratios=[2, 1])
+    gs.update(wspace=0.25, hspace=0.25)
+    fig.suptitle('Marginal distributions', y=0.93)
+
+    ## bivariate
+    ax1 = fig.add_subplot(gs[0])
+    con = ax1.contourf(z1, z2, z, levels = 10, cmap = cm.YlGnBu)
+    if points:
+        ax1.scatter(x, y, color='red', s=1)
+    ax1.set_xlabel('$x$', fontsize=13)
+
+    ## plot y
+    marginal_y = z.sum(axis=0) 
+    ax2 = fig.add_subplot(gs[1], sharey=ax1)
+    ax2.plot(marginal_y, z2[0, :], 'o-', markersize = 4, label=f'$p(y)$')  
+    plt.setp(ax2.get_yticklabels(), visible=False)
+    ax2.legend(loc=0)
+    ax2.set_ylabel('$y$', fontsize=13)
+    ax2.set_xlabel('density', fontsize=13)
+
+     ## plot x
+    marginal_x = z.sum(axis=1)  
+    ax3 = fig.add_subplot(gs[2], sharex = ax1)
+    ax3.plot(z1[:, 0], marginal_x, 'o-', markersize = 4, label=f'$p(x)$')  
+    plt.setp(ax3.get_xticklabels(), visible=False)
+    ax3.legend(loc=0)
+    ax3.set_ylabel('density', fontsize=13)
+    ax3.yaxis.set_label_position('right')
+
+    # density 
+    ax4 = fig.add_subplot(gs[3])
+    ax4.set_visible(False)
+    divider = make_axes_locatable(ax4)
+    cax = divider.append_axes('left', size='20%', pad=0.05)
+    cbar = fig.colorbar(con, cax=cax)
+    cbar.ax.set_ylabel('density: $p(x, xy)$', fontsize=12)
+    return fig
+
+@dataclass
+class BivpoisMle:
+    """ Object to save the MLE output
+
+    Attributes
+    ----------
+    lam1 : float
+        The value of the parameter lambda1.
+    lam2 : float
+        The value of the parameter lambda2.
+    lam3 : float
+        The value of the parameter lambda3.
+    rho : float
+        Pearson correlation coefficient between the two variables.
+    ci_obs : ArrayLike of shape (2,)
+        Observed confidence interval for λ₃, as [lower, upper].
+    ci_asymp : ArrayLike of shape (2,)
+        Asymptotic confidence interval for λ₃, as [lower, upper].
+    loglik : ArrayLike of shape (2,)
+        Log-likelihood values, as [restricted, unrestricted].
+    pvalue : ArrayLike of shape (3,)
+        P-values for the hypothesis tests.
+
+    """
+    lam1: float
+    lam2: float
+    lam3: float
+    rho: float
+    ci_obs: ArrayLike
+    ci_asymp: ArrayLike
+    loglik: ArrayLike
+    pvalue: ArrayLike
+
+    def __str__(self) -> str:
+        return (
+            f"lambda: [{self.lam1}, {self.lam2}, {self.lam3}]\n"
+            f"rho: {self.rho}\n"
+            f"observed ci: [{self.ci_obs[0]}, {self.ci_obs[1]}]\n"
+            f"asymptotic ci: [{self.ci_asymp[0]}, {self.ci_asymp[1]}]\n"
+            f"loglik: [{self.loglik[0]}, {self.loglik[1]}]\n"
+            f"pvalues: [{self.pvalue[0]}, {self.pvalue[1]}, {self.pvalue[2]}]"
+        )
+
+def mle(value: ArrayLike) -> BivpoisMle:
+    """Function to compute the estimation of maximum likelihood given a set of values.
+
+    Parameters
+    ----------
+    value : ArrayLike of shape (n, 2)
+        Observed count pairs (x, y). Each row is one observation.
+
+    Returns
+    -------
+    BivpoisMle
+        MLE estimates of lam1, lam2, lam3 along with the correlation coefficient,
+        confidence intervals, log-likelihood values, and p-values.
+
+    """
+    value = np.asarray(value)
+    if value.ndim != 2 or value.shape[1] != 2:
+        raise ValueError(f"value must have shape (n, 2), got {value.shape}")
+    if np.any(value < 0):
+        raise ValueError("All count values must be >= 0")
+
+    x = value[..., 0]  
+    y = value[..., 1]
+
+    n = x.shape[0]
+    mx, my = np.mean(value, axis = 0)
+    sly1 = gammaln(x + 1).sum()
+    sly2 = gammaln(y + 1).sum()
+    z = np.minimum(x, y)
+    m = int(np.max(z))
+    indexes = np.arange(m + 1)[:, None] 
+    f2a = _log_choose(x[None, :], indexes) + _log_choose(y[None, :], indexes) + gammaln(indexes + 1)
+
+    llf = _make_llf(mx, my, n, sly1, sly2, z, f2a, indexes)
+    res = minimize(fun=llf, 
+                   x0=np.cov(x, y)[0][1],
+                   bounds=[(0, np.min([mx,my]))],
+                   method='L-BFGS-B'
+                   )
+    lam3 = res.x[0]
+    
+    if lam3 == 0: 
+        hess = nd.Hessian(llf, step=1e-4, method='forward')
+
+    else: 
+        hess = nd.Hessian(llf, step=1e-4, method='central')
+
+    v1 = 1 / hess(lam3)[0,0][0]
+    lam1 = mx - lam3
+    lam2 = my - lam3
+    llf0 = - llf(0)
+    llf1 = - res.fun
+    rho = lam3 / np.sqrt(mx * my)
+
+    r_vals = np.arange(1, np.max([x, y]) + 21)
+    s_vals = np.arange(1, np.max([x, y]) + 21)
+    R, S = np.meshgrid(r_vals, s_vals, indexing='ij') 
+    grid = np.stack((R, S), axis=-1) 
+    num = logp(grid -1, lam1, lam2, lam3, logged=False) ** 2
+    den = logp(grid, lam1, lam2, lam3, logged=False)
+    tau = (num / den).sum()
+
+    delta2 = - (lam1 + lam2) + (mx * my - lam3 **2) * (tau -1)
+    asymp_var = (lam1 * lam2 + lam3 * (lam1 + lam2) * (lam3* (tau - 1) -1)) / ( n * delta2)
+
+    t1 = lam3 / np.sqrt(v1)
+    t2 = lam3 / np.sqrt(asymp_var)
+
+    Z95 = 1.959964
+    ci_obs   = [lam3 - Z95 * np.sqrt(v1),      lam3 + Z95 * np.sqrt(v1)]
+    ci_asymp = [lam3 - Z95 * np.sqrt(asymp_var), lam3 + Z95 * np.sqrt(asymp_var)]
+    loglik   = [llf0, llf1]
+    pvalue   = [chi2.sf(2 * (llf1 - llf0), df=1), norm.cdf(-t1), norm.cdf(-t2)]
+
+    return BivpoisMle(lam1, lam2, lam3, rho, ci_obs, ci_asymp, loglik, pvalue)
+
+def gof(value: ArrayLike, R: int = 1000) -> float:
+    """This function computes goodnes of fit test for the bivariate Poisson distribution given a set
+    of values
+
+    Parameters
+    ----------
+    value : array like 
+        Observed count pairs (x, y). Each row is one observation.
+    R : int 
+        Number of Monte Carlo replicates. Default is 1000.
+
+    Returns
+    -------
+    float 
+        The pvalue of the index of dispersion test using Monte Carlo.
+
+    """
+    value = np.asarray(value)
+    if value.ndim != 2 or value.shape[1] != 2:
+        raise ValueError(f"value must have shape (n, 2), got {value.shape}")
+
+    x = value[..., 0]  
+    y = value[..., 1]
+
+    n = x.shape[0]
+    mx, my = np.mean(value, axis = 0)
+    vx = ((x * x).sum() - n * (mx * mx)) / (n-1)
+    vy = ((y * y).sum() - n * (my * my)) / (n-1)
+    cov_xy = np.mean((x - mx) * (y - my)) * n / (n - 1)
+    r_obs = cov_xy / np.sqrt(vx * vy)
+    Ib = (n / (1 - (r_obs * r_obs))) * ((vx / mx) - 2 * (r_obs * r_obs) * np.sqrt((vx / mx) * (vy / my)) + (vy / my))
+
+    lam3 = mle(value).lam3
+    lam1 = mx - lam3
+    lam2 = my - lam3
+
+    # bootstrap
+    z3 = np.random.poisson(lam= lam3, size = (n, R))
+    z1 = np.random.poisson(lam= lam1, size = (n, R)) + z3
+    z2 = np.random.poisson(lam= lam2, size = (n, R)) + z3 
+
+    m1, m2 = z1.sum(axis = 0)/n, z2.sum(axis = 0)/n 
+    s1 = ((z1 * z1).sum(axis = 0) - n * m1 * m1) / (n-1)
+    s2 = ((z2 * z2).sum(axis = 0) - n * m2 * m2) / (n-1)
+
+    dev1 = z1 - m1
+    dev2 = z2 - m2
+    cov_12 = np.sum(dev1 * dev2, axis = 0) / (n - 1)
+    r_b = cov_12 / np.sqrt(s1 * s2)
+    tb = (n/ (1 - r_b*r_b) ) * ((s1 / m1) - 2 * r_b*r_b * np.sqrt((s1/m1) * (s2/m2)) + s2/m2)
+
+    return ((tb > Ib).sum() + 1) / (R + 1)
+
+def lambda3_profile(value: ArrayLike) -> np.ndarray:
+    """This function plot the likelihood profile of lambda3 of the bivariate Poisson distribution with a
+    95% confidence interval of the parameter, given a set of values.
+
+    Parameters
+    ----------
+    value : array like
+        Observed count pairs (x, y). Each row is one observation.
+
+    Returns
+    -------
+    numpy array 
+        The confident interval
+    """
+
+    x = value[..., 0]  
+    y = value[..., 1]
+
+    n = x.shape[0]
+    mx, my = np.mean(value, axis = 0)
+    sly1 = gammaln(x + 1).sum()
+    sly2 = gammaln(y + 1).sum()
+
+    z = np.minimum(x, y)
+    m = int(np.max(z))
+    indexes = np.arange(m + 1)[:, None] 
+    f2a = _log_choose(x[None, :], indexes) + _log_choose(y[None, :], indexes) + gammaln(indexes + 1)
+
+    llf = _make_llf(mx, my, n, sly1, sly2, z, f2a, indexes)
+    res = minimize(fun = llf, 
+                   x0 = np.cov(x, y)[0][1],
+                   bounds = [(0, np.min([mx,my]) - 0.05)],
+                   method = 'L-BFGS-B'
+                   )
+    
+    llf1 = -res.fun
+    lam3 = res.x[0]
+    rang = np.linspace(0, min(mx, my) - 0.1, num = 400, endpoint= False)
+
+    fig, ax = plt.subplots(figsize = (6,6))
+    fig.suptitle(r'$\lambda_3$ profile likelihood')
+
+    values_lff = np.array([-llf(a) for a in rang])
+    CHI2_95_HALF = 1.920729  
+    cl = llf1 - CHI2_95_HALF
+    a1 = (rang[ values_lff >= cl ]).min()
+    a2 = (rang[ values_lff >= cl ]).max()
+
+    ax.plot(rang, values_lff, color = 'black', label = 'Loglikelihood function')
+    ax.axhline(llf1, color = 'blue')
+    ax.axvline(lam3, color = 'blue')
+    ax.axvspan(a1, a2, alpha=0.1, color='blue', label = 'Confidence interval')
+    ax.plot(lam3, llf1, 'o', color = 'blue', label = 'Maximum')
+    ax.set_xlabel(r'Values of $\lambda_3$')
+    ax.set_ylabel('Log-likelihood')
+
+    fig.legend(loc='center left', bbox_to_anchor=(0.9, 0.5))
+
+    return np.array([a1, a2])
+

bivpoispy-0.1.0/src/bivpoispy.egg-info/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: bivpoispy
+Version: 0.1.0
+Summary: Tols for bivariate Poisson distribution: density, sampling, MLE, and goodness-of-fit
+Author-email: Ilyan Alexey Cortés Miranda <alexey.cortes13@gmail.com>
+License-Expression: MIT
+Keywords: bivpois,bivariate poisson
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20
+Requires-Dist: scipy>=1.7
+Requires-Dist: matplotlib>=3.5
+Requires-Dist: numdifftools>=0.9
+Dynamic: license-file

bivpoispy-0.1.0/src/bivpoispy.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+src/bivpoispy/__init__.py
+src/bivpoispy/bivpoispy.py
+src/bivpoispy.egg-info/PKG-INFO
+src/bivpoispy.egg-info/SOURCES.txt
+src/bivpoispy.egg-info/dependency_links.txt
+src/bivpoispy.egg-info/requires.txt
+src/bivpoispy.egg-info/top_level.txt

bivpoispy-0.1.0/src/bivpoispy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

bivpoispy-0.1.0/src/bivpoispy.egg-info/requires.txt

@@ -0,0 +1,4 @@
+numpy>=1.20
+scipy>=1.7
+matplotlib>=3.5
+numdifftools>=0.9

bivpoispy-0.1.0/src/bivpoispy.egg-info/top_level.txt

@@ -0,0 +1 @@
+bivpoispy