Refactor RandomVariable

.github/workflows/pylint_check.py

@@ -4,8 +4,11 @@
 PYPROJECTTOML_FILE = Path("pyproject.toml")
 GLOBAL_DISABLES = {
     "invalid-name",
+    "fixme",
+    "bad-continuation",
     "no-else-raise",
     "no-else-return",
+    "no-member",
 }
 
 

benchmarks/ivpsolve.py

@@ -3,12 +3,12 @@
 """
 import numpy as np
 from probnum.diffeq import lotkavolterra, probsolve_ivp
-from probnum.prob import RandomVariable, Dirac
+from probnum.random_variables import Dirac
 
 
 def load_lotkavolterra():
     """Load LV system as a basic IVP."""
-    initrv = RandomVariable(distribution=Dirac(np.array([20, 20])))
+    initrv = Dirac(np.array([20, 20]))
     return lotkavolterra(
         timespan=[0, 0.55], initrv=initrv, params=(0.5, 0.05, 0.5, 0.05)
     )

benchmarks/random_variables.py

@@ -0,0 +1,104 @@
+"""
+Benchmarks for random variables.
+"""
+
+import numpy as np
+
+from probnum import random_variables as rvs
+import probnum.linalg.linops as linops
+
+# Module level variables
+rv_names = [
+    "univar_normal",
+    "multivar_normal",
+    "matrixvar_normal",
+    "symmatrixvar_normal",
+    "operatorvar_normal",
+]
+
+
+def get_randvar(rv_name):
+    """
+    Return a random variable for a given distribution name
+    """
+    # Distribution Means and Covariances
+    spd_mat = np.array(
+        [
+            [2.3, -2.3, 3.5, 4.2, 1.8],
+            [-2.3, 3.0, -3.5, -4.8, -1.9],
+            [3.5, -3.5, 6.9, 5.8, 0.8],
+            [4.2, -4.8, 5.8, 10.1, 6.3],
+            [1.8, -1.9, 0.8, 6.3, 12.1],
+        ]
+    )
+    mean_0d = np.random.rand()
+    mean_1d = np.random.rand(5)
+    mean_2d_mat = spd_mat
+    mean_2d_linop = linops.MatrixMult(spd_mat)
+    cov_0d = np.random.rand() + 10 ** -12
+    cov_1d = spd_mat
+    cov_2d_kron = linops.Kronecker(A=spd_mat, B=spd_mat)
+    cov_2d_symkron = linops.SymmetricKronecker(A=spd_mat)
+
+    if rv_name == "univar_normal":
+        randvar = rvs.Normal(mean=mean_0d, cov=cov_0d)
+    elif rv_name == "multivar_normal":
+        randvar = rvs.Normal(mean=mean_1d, cov=cov_1d)
+    elif rv_name == "matrixvar_normal":
+        randvar = rvs.Normal(mean=mean_2d_mat, cov=cov_2d_kron)
+    elif rv_name == "symmatrixvar_normal":
+        randvar = rvs.Normal(mean=mean_2d_mat, cov=cov_2d_symkron)
+    elif rv_name == "operatorvar_normal":
+        randvar = rvs.Normal(mean=mean_2d_linop, cov=cov_2d_symkron)
+
+    return randvar
+
+
+class Functions:
+    """
+    Benchmark various functions of distributions.
+    """
+
+    param_names = ["randvar", "property"]
+    params = [rv_names, ["pdf", "logpdf", "cdf", "logcdf"]]
+
+    def setup(self, randvar, property):
+        self.randvar = get_randvar(rv_name=randvar)
+        self.eval_point = np.random.uniform(size=self.randvar.shape)
+        self.quantile = np.random.uniform(size=self.randvar.shape)
+
+    def time_distr_functions(self, randvar, property):
+        """Times evaluation of the pdf, logpdf, cdf and logcdf."""
+        try:
+            if property == "pdf":
+                self.randvar.pdf(x=self.eval_point)
+            elif property == "logpdf":
+                self.randvar.logpdf(x=self.eval_point)
+            elif property == "cdf":
+                self.randvar.cdf(x=self.quantile)
+            elif property == "logcdf":
+                self.randvar.logcdf(x=self.quantile)
+        except NotImplementedError:
+            pass
+
+
+class Sampling:
+    """
+    Benchmark sampling routines for various distributions.
+    """
+
+    param_names = ["randvar"]
+    params = [rv_names]
+
+    def setup(self, randvar):
+        np.random.seed(42)
+        self.n_samples = 1000
+        self.randvar = get_randvar(rv_name=randvar)
+
+    def time_sample(self, randvar):
+        """Times sampling from this distribution."""
+        self.randvar.sample(self.n_samples)
+
+    def peakmem_sample(self, randvar):
+        """Peak memory of sampling process."""
+        self.randvar.sample(self.n_samples)

docs/source/index.rst

@@ -48,7 +48,7 @@ To learn how to use ProbNum check out the `quickstart guide <introduction/quicks
    :maxdepth: 1
    :caption: API Documentation
 
-   public_api/prob
+   public_api/probnum
    public_api/linalg
    public_api/quad
    public_api/diffeq

docs/source/public_api/probnum.rst

@@ -0,0 +1,7 @@
+probnum
+=======
+
+probnum.random_variables
+************************
+.. automodapi:: probnum.random_variables
+	:no-heading:

pyproject.toml

@@ -27,10 +27,15 @@ exclude = '''
 # Exceptions suggested from Black: bad-continuation, bad-whitespace
 disable = """
 invalid-name,
+fixme,
+
+bad-continuation,
 
 no-else-return,
 no-else-raise,
 
+no-member,
+
 abstract-class-instantiated,
 too-many-locals,
 too-few-public-methods,
@@ -50,9 +55,6 @@ too-many-lines,
 redefined-builtin,
 abstract-method,
 too-many-branches,
-fixme,
-broad-except,
-raise-missing-from,
 line-too-long,
 missing-class-docstring,
 unnecessary-pass,

setup.cfg

@@ -8,7 +8,7 @@ version = 0.0.1
 description = Probabilistic Numerics in Python.
 url = https://github.com/probabilistic-numerics/probnum
 author = ProbNum Authors
-author-email = 
+author-email =
 license = MIT
 long-description = file: README.md
 long-description-content-type = text/markdown
@@ -35,6 +35,7 @@ install_requires =
     scipy>=1.4
     GPy
     matplotlib
+    cached_property; python_version<"3.8"
 # The usage of test_requires is discouraged, see `Dependency Management` docs
 # tests_require = pytest; pytest-cov
 # Require a specific Python version, e.g. Python 2.7 or >= 3.4

src/probnum/__init__.py

@@ -27,10 +27,12 @@
 from . import diffeq
 from . import filtsmooth
 from . import linalg
-from . import prob
 from . import quad
+from . import random_variables
 from . import utils
 
+from .random_variables import asrandvar, RandomVariable
+
 # -*- coding: utf-8 -*-
 from pkg_resources import get_distribution, DistributionNotFound
 

src/probnum/prob/_randomvariablelist.py → src/probnum/_randomvariablelist.py

@@ -16,16 +16,16 @@ def __init__(self, rv_list):
         super().__init__(rv_list)
 
     def mean(self):
-        return np.stack([rv.mean() for rv in self])
+        return np.stack([rv.mean for rv in self])
 
     def cov(self):
-        return np.stack([rv.cov() for rv in self])
+        return np.stack([rv.cov for rv in self])
 
     def var(self):
-        return np.stack([rv.distribution.var() for rv in self])
+        return np.stack([rv.var for rv in self])
 
     def std(self):
-        return np.stack([rv.distribution.std() for rv in self])
+        return np.stack([rv.std for rv in self])
 
     def __getitem__(self, idx):
         """Make sure to wrap the result into a _RandomVariableList if necessary"""

src/probnum/diffeq/ode/ivp.py

@@ -61,7 +61,7 @@ def hess(t, y):
         return log_hess(t, y, params)
 
     def sol(t):
-        return log_sol(t, params, initrv.mean())
+        return log_sol(t, params, initrv.mean)
 
     return IVP(timespan, initrv, rhs, jac, hess, sol)
 
@@ -263,8 +263,8 @@ class IVP(ODE):
     --------
     >>> from probnum.diffeq import IVP
     >>> rhsfun = lambda t, y, **kwargs: 2.0*y
-    >>> from probnum.prob import Dirac, Normal, RandomVariable
-    >>> initrv = RandomVariable(distribution=Dirac(0.1))
+    >>> from probnum import random_variables as rvs
+    >>> initrv = rvs.Dirac(0.1)
     >>> timespan = (0, 10)
     >>> ivp = IVP(timespan, initrv, rhsfun)
     >>> print(ivp.rhs(0., 2.))
@@ -274,7 +274,7 @@ class IVP(ODE):
     >>> print(ivp.t0)
     0
 
-    >>> initrv = RandomVariable(distribution=Normal(0.1, 1.0))
+    >>> initrv = rvs.Normal(0.1, 1.0)
     >>> ivp = IVP(timespan, initrv, rhsfun)
     >>> jac = lambda t, y, **kwargs: 2.0
     >>> ivp = IVP(timespan, initrv, rhs=rhsfun, jac=jac)
@@ -310,7 +310,7 @@ def ndim(self):
 
         Depends on the mean of the initial random variable.
         """
-        if np.isscalar(self.initrv.mean()):
+        if np.isscalar(self.initrv.mean):
             return 1
         else:
-            return len(self.initrv.mean())
+            return len(self.initrv.mean)