dpqr 0.0.0.dev0__py3-none-any.whl

dpqr/__init__.py

@@ -0,0 +1,16 @@
+"""
+R style distribution and random variable functions.
+
+This module provides R style distribution functions.
+
+Currently is mainly a wrapper for SciPy distribution functions,
+eventually may convert to Boost C++ functions directly for improved
+vec_recycling performance.
+"""
+
+from .vec_recycle import *
+from .beta import *
+from .gamma import *
+from .invgamma import *
+from .norm import *
+

dpqr/beta.py

@@ -0,0 +1,73 @@
+import numpy as np
+from scipy.stats import beta
+
+from .vec_recycle import vec_recycle_common
+
+###############################################################################
+# Beta
+
+# TODO: ncp version not yet implemented
+# dbeta(x, shape1, shape2, ncp = 0, log = FALSE)
+# pbeta(q, shape1, shape2, ncp = 0, lower.tail = TRUE, log.p = FALSE)
+# qbeta(p, shape1, shape2, ncp = 0, lower.tail = TRUE, log.p = FALSE)
+# rbeta(n, shape1, shape2, ncp = 0)
+
+def dbeta(x, shape1, shape2, log = False):
+    """
+    Density function for the Beta distribution.
+    dbeta(x, shape1, shape2, log = False)
+    """
+
+    x, shape1, shape2 = vec_recycle_common(x, shape1, shape2)
+    if log:
+        return beta.logpdf(x, a=shape1, b=shape2)
+    else:
+        return beta.pdf(x, a=shape1, b=shape2)
+   
+#   pbeta(0,1,1,lower_tail=False,log_p=True)
+def pbeta(q, shape1, shape2, lower_tail = True, log_p = False):
+    """
+    Cumulative Density Function (CDF) for the Beta distribution.
+    pbeta(q, shape1, shape2, lower_tail = True, log_p = False):
+    """
+
+    q, shape1, shape2 = vec_recycle_common(q, shape1, shape2)
+
+    if lower_tail:
+        if log_p:
+            return beta.logcdf(q, a=shape1, b=shape2)
+        else:
+            return beta.cdf(q, a=shape1, b=shape2)
+    else:
+        cdf = np.subtract(1.,beta.cdf(q, a=shape1, b=shape2))
+        if log_p:
+            with np.errstate(divide='ignore', invalid='ignore'):
+                return np.log( cdf )
+        else:
+            return cdf
+
+
+def qbeta(p, shape1, shape2, lower_tail = True, log_p = False):
+    """
+    Inverse Cumulative Density Function (CDF^-1) for the Beta distribution.
+    qbeta(p, shape1, shape2, lower_tail = True, log_p = False)
+    """
+
+    if log_p:
+        p = np.exp(p)
+    if not lower_tail:
+        p = np.subtract(1.,p)
+    p, shape1, shape2 = vec_recycle_common(p, shape1, shape2)
+    q = beta.ppf(p, shape1, shape2)
+    return q
+
+
+def rbeta(n, shape1, shape2):
+    """
+    Random number generator for the Beta distribution.
+    rbeta(n, shape1, shape2)
+    """
+
+    shape1, shape2 = vec_recycle_common(shape1, shape2, n=n)
+    return beta.rvs(shape1, shape2, size=n)
+

dpqr/gamma.py

@@ -0,0 +1,77 @@
+#from operator import ne
+
+import numpy as np
+from scipy.stats import gamma
+
+from .vec_recycle import vec_recycle_common
+
+###############################################################################
+# Gamma
+# TODO: add shape + scale paramaterization
+
+# dgamma(x, shape, rate = 1, scale = 1/rate, log = FALSE)
+# pgamma(q, shape, rate = 1, scale = 1/rate, lower.tail = TRUE, log.p = FALSE)
+# qgamma(p, shape, rate = 1, scale = 1/rate, lower.tail = TRUE, log.p = FALSE)
+# rgamma(n, shape, rate = 1, scale = 1/rate)
+
+def dgamma(x, shape = 1., rate = 1., log = False):
+    """
+    Density function for the Gamma distribution.
+    dgamma(x, shape, rate, log = False)
+    """
+
+    x, shape, scale = vec_recycle_common(x, shape, 1./rate)
+    if log:
+        x = gamma.logpdf(x, a=shape, scale=scale)
+        return np.nan_to_num(x,nan=-np.inf,posinf=np.inf,neginf=-np.inf )
+    else:
+        x = gamma.pdf(x, a=shape, scale=scale)
+        return np.nan_to_num(x,nan=0,posinf=np.inf,neginf=-np.inf )
+  
+
+def pgamma(q, shape=1., rate=1., lower_tail = True, log_p = False):
+    """
+    Cumulative Density Function (CDF) for the Gamma distribution.
+    pgamma(q, shape1, shape2, lower_tail = True, log_p = False):
+    """
+
+    q, shape, scale = vec_recycle_common(q, shape, 1./rate)
+    if lower_tail:
+        if log_p:
+            with np.errstate(divide='ignore', invalid='ignore'):
+                return gamma.logcdf(q, a=shape, scale=scale)
+        else:
+            return gamma.cdf(q, a=shape, scale=scale)
+    else:
+        cdf = np.subtract(1.,gamma.cdf(q, a=shape, scale=scale))
+        if log_p:
+            with np.errstate(divide='ignore', invalid='ignore'):
+                return np.log( cdf )
+        else:
+            return cdf
+
+
+def qgamma(p, shape=1., rate=1., lower_tail = True, log_p = False):
+    """
+    Inverse Cumulative Density Function (CDF^-1) for the Gamma distribution.
+    qgamma(p, shape, rate, lower_tail = True, log_p = False)
+    """
+
+    if log_p:
+        p = np.exp(p)
+    if not lower_tail:
+        p = np.subtract(1.,p)
+    p, shape, scale = vec_recycle_common(p, shape, 1./rate)
+    q = gamma.ppf(p, shape, scale=scale)
+    return q
+
+
+def rgamma(n, shape, rate=1.):
+    """
+    Random number generator for the Gamma distribution.
+    rgamma(n, shape, rate)
+    """
+
+    shape, scale = vec_recycle_common(shape, 1./rate, n=n)
+    return gamma.rvs(shape, scale=scale, size=n)
+

dpqr/invgamma.py

@@ -0,0 +1,80 @@
+import numpy as np
+from scipy.stats import invgamma
+
+from .vec_recycle import vec_recycle_common
+
+###############################################################################
+# Beta
+
+# note, invgamma not part of the base R definitions.
+# using paramaterization from R library MCMCpack, not invgamma
+# dinvgamma(x, shape, scale = 1, log = FALSE)
+# pinvgamma(q, shape, scale = 1, lower.tail = TRUE, log.p = FALSE)
+# qinvgamma(p, shape, scale = 1, lower.tail = TRUE, log.p = FALSE)
+# rinvgamma(n, shape, scale = 1)
+
+# only scale or rate can be defined.
+#scale = 1., rate = 1./scale
+# or just skip rate definition
+#def dinvgamma(x, shape = 1., scale = None, rate = None, log = False):
+def dinvgamma(x, shape = 1., scale = 1., log = False):
+    """
+    Density function for the Inverse Gamma distribution.
+    dinvgamma(x, shape, scale, log = False)
+    """
+
+    x, shape, scale = vec_recycle_common(x, shape, scale)
+    if log:
+        x = invgamma.logpdf(x, a=shape, scale=scale)
+        return np.nan_to_num(x, posinf=np.inf,neginf=-np.inf )
+    else:
+        x = invgamma.pdf(x, a=shape, scale=scale)
+        return np.nan_to_num(x, posinf=np.inf,neginf=-np.inf )
+
+   
+def pinvgamma(q, shape=1., scale=1., lower_tail = True, log_p = False):
+    """
+    Cumulative Density Function (CDF) for the Inv Gamma distribution.
+    pinvgamma(q, shape, scale, lower_tail = True, log_p = False):
+    """
+    
+    q, shape, scale = vec_recycle_common(q, shape, scale)
+    if lower_tail:
+        if log_p:
+            return invgamma.logcdf(q, a=shape, scale=scale)
+        else:
+            return invgamma.cdf(q, a=shape, scale=scale)
+    else:
+        
+        cdf = 1 - invgamma.cdf(q, a=shape, scale=scale)
+        if log_p:
+            with np.errstate(divide='ignore', invalid='ignore'):
+                return np.log( cdf )
+        else:
+            return cdf
+
+
+def qinvgamma(p, shape=1., scale=1., lower_tail = True, log_p = False):
+    """
+    Inverse Cumulative Density Function (CDF^-1) for the Inv Gamma distribution.
+    qinvgamma(p, shape, scale, lower_tail = True, log_p = False)
+    """
+
+    if log_p:
+        p = np.exp(p)
+    if not lower_tail:
+        p = np.subtract(1., p)
+    p, shape, scale = vec_recycle_common(p, shape, scale)
+    q = invgamma.ppf(p, shape, scale=scale)
+    return q
+
+
+def rinvgamma(n, shape, scale):
+    """
+    Random number generator for the Inv Gamma distribution.
+    rinvgamma(n, shape, scale)
+    """
+
+    shape, scale = vec_recycle_common(shape, scale, n=n)
+    return invgamma.rvs(shape, scale=scale, size=n)
+

dpqr/norm.py

@@ -0,0 +1,66 @@
+import numpy as np
+from scipy.stats import norm
+
+from .vec_recycle import vec_recycle_common
+
+###############################################################################
+# Normal
+
+def dnorm(x, mean = 0., sd = 1., log = False):
+    """
+    Density function for the normal distribution.
+    dnorm(x, mean = 0., sd = 1., log = False)
+    """
+
+    x, mean, sd = vec_recycle_common(x, mean, sd)
+    if log:
+        return norm.logpdf(x, loc=mean, scale=sd)
+    else:
+        return norm.pdf(x, loc=mean, scale=sd)
+   
+
+def pnorm(q, mean = 0., sd = 1., lower_tail = True, log_p = False):
+    """
+    Cumulative Density Function (CDF) for the normal distribution.
+    pnorm(q, mean = 0., sd = 1., lower_tail = True, log_p = False)
+    """
+    
+    q, mean, sd = vec_recycle_common(q, mean, sd)
+    if lower_tail:
+        if log_p:
+            return norm.logcdf(q, loc=mean, scale=sd)
+        else:
+            return norm.cdf(q, loc=mean, scale=sd)
+    else:
+        cdf = np.subtract(1., norm.cdf(q, loc=mean, scale=sd) )
+        if log_p:
+            with np.errstate(divide='ignore', invalid='ignore'):
+                return np.log( cdf )
+        else:
+            return cdf
+    
+
+def qnorm(p, mean = 0., sd = 1., lower_tail = True, log_p = False):
+    """
+    Inverse Cumulative Density Function (CDF^-1) for the normal distribution.
+    qnorm(p, mean = 0, sd = 1, lower_tail = True, log_p = False)
+    """
+
+    if log_p:
+        p = np.exp(p)
+    if not lower_tail:
+        p = np.subtract(1., p)
+    p, mean, sd = vec_recycle_common(p, mean, sd)
+    q = norm.ppf(p, loc=mean, scale=sd)
+    return q
+
+
+def rnorm(n=None, mean = 0., sd = 1.):
+    """
+    Random number generator for the normal distribution.
+    rnorm(n=None, mean = 0, sd = 1)
+    """
+
+    mean, sd = vec_recycle_common(mean, sd, n=n)
+    return norm.rvs(loc=mean, scale=sd, size=n)
+

dpqr/vec_recycle.py

@@ -0,0 +1,35 @@
+import numpy as np
+from collections.abc import Sized
+
+###############################################################################
+# common functions
+
+def vec_recycle(x, n):
+    """
+    Recycle vector values to a specified length.
+    """
+
+    # check if resize is needed.
+    if isinstance(x, Sized):
+        if len(x) != n:
+            x = np.resize(x, n)
+    else:
+        if n > 1:
+            x = np.resize(x, n)
+    return x
+
+def vec_recycle_common( *xs, n=None):
+    """
+    Recycle multiple vectors to a common length.
+    """
+
+    # ensure all scalars or vectors.
+    if any( [isinstance(x, Sized) for x in xs] ):
+        xs = np.atleast_1d(*xs)
+        
+    # if n is missing, calculate it.
+    if n is None:
+        n = max([ len(x) if isinstance(x, Sized) else 1 for x in xs] )
+
+    return tuple([vec_recycle(x, n) for x in xs])
+

dpqr-0.0.0.dev0.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: dpqr
+Version: 0.0.0.dev0
+Summary: R style dpqr distribution functions
+Keywords: R,cran,distribution,dpqr,rnorm
+Author: Jacob Colvin
+Author-email: Jacob Colvin <28549119+jbcolvin0@users.noreply.github.com>
+License-Expression: GPL-3.0-or-later
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Python: >=3.10
+Project-URL: Homepage, https://github.com/jbcolvin0/dpqr/
+Project-URL: Repository, https://github.com/jbcolvin0/dpqr.git
+Description-Content-Type: text/markdown
+
+# dpqr
+R style dpqr distribution functions.
+
+# NOTE: this is still experimental / in development.
+version 0.0.0dev0
+

dpqr-0.0.0.dev0.dist-info/RECORD

@@ -0,0 +1,10 @@
+dpqr/__init__.py,sha256=fhevHeukwLP2wyjIu5IRIJRvKmZq3FumbCSNO0WkgPI,388
+dpqr/beta.py,sha256=1P17lP-G9qcoXlYV3pHEVYYnNDVA57rUCiLSo1vJYNM,2147
+dpqr/gamma.py,sha256=ZmIZc_YbZuAYeOpj-EwOFFyFm-uWkVEt6aPKBGPYmag,2406
+dpqr/invgamma.py,sha256=RBttPoZ1YaVIk80nPOoy4oRP-z-HHqg1Rx75-vnR2NY,2552
+dpqr/norm.py,sha256=E2EwbUeznYSdCX70P0zU7IFmskJ5CWsxsg-h0g9zLRE,1854
+dpqr/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dpqr/vec_recycle.py,sha256=RdbWgNIgV_oBO7n6nneLthHC1aNu9qsbScAQyviyxnk,845
+dpqr-0.0.0.dev0.dist-info/WHEEL,sha256=f5fWSvWsg5Knq5GWa6t1nJIug0Tqo69GqAWD_9LbBKw,81
+dpqr-0.0.0.dev0.dist-info/METADATA,sha256=0vRfXgPxKG8uOa6h0VCePFy4STMXASYAPX1mM7mCibY,615
+dpqr-0.0.0.dev0.dist-info/RECORD,,

dpqr-0.0.0.dev0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.16
+Root-Is-Purelib: true
+Tag: py3-none-any