CUQIpy 1.2.0.post0.dev352__py3-none-any.whl → 1.2.0.post0.dev380__py3-none-any.whl

{CUQIpy-1.2.0.post0.dev352.dist-info → CUQIpy-1.2.0.post0.dev380.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CUQIpy
-Version: 1.2.0.post0.dev352
+Version: 1.2.0.post0.dev380
 Summary: Computational Uncertainty Quantification for Inverse problems in Python
 Maintainer-email: "Nicolai A. B. Riis" <nabr@dtu.dk>, "Jakob S. Jørgensen" <jakj@dtu.dk>, "Amal M. Alghamdi" <amaal@dtu.dk>, Chao Zhang <chaz@dtu.dk>
 License:                                  Apache License

{CUQIpy-1.2.0.post0.dev352.dist-info → CUQIpy-1.2.0.post0.dev380.dist-info}/RECORD

@@ -1,6 +1,6 @@
 cuqi/__init__.py,sha256=LsGilhl-hBLEn6Glt8S_l0OJzAA1sKit_rui8h-D-p0,488
 cuqi/_messages.py,sha256=fzEBrZT2kbmfecBBPm7spVu7yHdxGARQB4QzXhJbCJ0,415
-cuqi/_version.py,sha256=C3E_fdIvWSE-v7utMG2sMEohKeQFQh02EkThKcjI6Ic,510
+cuqi/_version.py,sha256=4Rygq2rO32tD5TYtalGmZY_AqICH80eNKpSu2m7Zj5A,510
 cuqi/config.py,sha256=wcYvz19wkeKW2EKCGIKJiTpWt5kdaxyt4imyRkvtTRA,526
 cuqi/diagnostics.py,sha256=5OrbJeqpynqRXOe5MtOKKhe7EAVdOEpHIqHnlMW9G_c,3029
 cuqi/array/__init__.py,sha256=-EeiaiWGNsE3twRS4dD814BIlfxEsNkTCZUc5gjOXb0,30
@@ -24,7 +24,7 @@ cuqi/distribution/_gamma.py,sha256=VcvBJS51N-MxuX42r9L2j2QYRlzhdgAtQ6Wa5IFO_YE,3
 cuqi/distribution/_gaussian.py,sha256=3L1L_3W6i6YuPQ8vnFmju5QsvkLlg4VsgCnj11lYBUE,32977
 cuqi/distribution/_gmrf.py,sha256=OwId8qQWEtmC2fxVhL4iBHZnc8ZCrZzfV6yGXDE3k30,9522
 cuqi/distribution/_inverse_gamma.py,sha256=oPJuiYp3O1m547pmmIz9OWesky9YpwLTHT7-9MmcYss,3159
-cuqi/distribution/_joint_distribution.py,sha256=7TxDaZ7y362LfxEpD4I5Z0icdtsBmOBJGnpIkz_bYXA,15900
+cuqi/distribution/_joint_distribution.py,sha256=vadRTOpQh1skAgnf-f2-2e6IMvoH2d8beriDvjh236g,16709
 cuqi/distribution/_laplace.py,sha256=5exLvlzJm2AgfvZ3KUSkjfwlGwwbsktBxP8z0iLMik8,1401
 cuqi/distribution/_lmrf.py,sha256=rdGoQ-fPe1oW6Z29P-l3woq0NX3_RxUQ2rzm1VzemNM,3290
 cuqi/distribution/_lognormal.py,sha256=8_hOFQ3iu88ujX8vxmfVEZ0fdmlhTY98PlG5PasPjEg,2612
@@ -35,8 +35,10 @@ cuqi/distribution/_smoothed_laplace.py,sha256=p-1Y23mYA9omwiHGkEuv3T2mwcPAAoNlCr
 cuqi/distribution/_truncated_normal.py,sha256=sZkLYgnkGOyS_3ZxY7iw6L62t-Jh6shzsweRsRepN2k,4240
 cuqi/distribution/_uniform.py,sha256=KA8yQ6ZS3nQGS4PYJ4hpDg6Eq8EQKQvPsIpYfR8fj2w,1967
 cuqi/experimental/__init__.py,sha256=iStrmEy4ZMnGpEyd6QNlC6RK83lrS9iRkxQS0u-s8cU,105
-cuqi/experimental/algebra/__init__.py,sha256=3d4Bfx1upcHhEubNn6-Sa3WFpuksPQJif4OptcNDe_s,31
-cuqi/experimental/algebra/_ast.py,sha256=SAlqqQkW_559fyiM66S3dWgfACR7jdSZkomJm1mKix0,8698
+cuqi/experimental/algebra/__init__.py,sha256=btRAWG58ZfdtK0afXKOg60AX7d76KMBjlZa4AWBCCgU,81
+cuqi/experimental/algebra/_ast.py,sha256=iJ_umDzTct4O9tZM-ep2NNkrdxR4_PTIEOrxZiwvlc0,9257
+cuqi/experimental/algebra/_orderedset.py,sha256=8SxktP1333ByTldtqzU9xLQ5SAFU0V9B-i6U1prVBYk,2019
+cuqi/experimental/algebra/_randomvariable.py,sha256=lwOTy9KApqXwJ57VBYUBMrCwpbA7cR91OlT0ZUtiIaE,15841
 cuqi/experimental/mcmc/__init__.py,sha256=zSqLZmxOqQ-F94C9-gPv7g89TX1XxlrlNm071Eb167I,4487
 cuqi/experimental/mcmc/_conjugate.py,sha256=VNPQkGity0mposcqxrx4UIeXm35EvJvZED4p2stffvA,9924
 cuqi/experimental/mcmc/_conjugate_approx.py,sha256=uEnY2ea9su5ivcNagyRAwpQP2gBY98sXU7N0y5hTADo,3653
@@ -61,13 +63,13 @@ cuqi/implicitprior/_restorator.py,sha256=Z350XUJEt7N59Qw-SIUaBljQNDJk4Zb0i_KRFrt
 cuqi/likelihood/__init__.py,sha256=QXif382iwZ5bT3ZUqmMs_n70JVbbjxbqMrlQYbMn4Zo,1776
 cuqi/likelihood/_likelihood.py,sha256=z3AXAbIrv_DjOYh4jy3iDHemuIFUUJu6wdvJ5e2dgW0,6913
 cuqi/model/__init__.py,sha256=jgY2-jyxEMC79vkyH9BpfowW7_DbMRjqedOtO5fykXQ,62
-cuqi/model/_model.py,sha256=Hddc2qlKH0tVCB7gTY_U8TPO8IcjkAe63-TwCAVXUWI,31423
+cuqi/model/_model.py,sha256=LqeMwOSb1oIGpT7g1cmItP_2Q4dmgg8eNPNo0joPUyg,32905
 cuqi/operator/__init__.py,sha256=0pc9p-KPyl7KtPV0noB0ddI0CP2iYEHw5rbw49D8Njk,136
 cuqi/operator/_operator.py,sha256=yNwPTh7jR07AiKMbMQQ5_54EgirlKFsbq9JN1EODaQI,8856
 cuqi/pde/__init__.py,sha256=NyS_ZYruCvy-Yg24qKlwm3ZIX058kLNQX9bqs-xg4ZM,99
 cuqi/pde/_pde.py,sha256=WRkOYyIdT_T3aZepRh0aS9C5nBbUZUcHaA80iSRvgoo,12572
 cuqi/problem/__init__.py,sha256=JxJty4JqHTOqSG6NeTGiXRQ7OLxiRK9jvVq3lXLeIRw,38
-cuqi/problem/_problem.py,sha256=d5jS5ETyinv8Ez_B6I5-QOIl4Vqvf-e_6qy5RN2gnUE,38160
+cuqi/problem/_problem.py,sha256=XyJ_MZbVFUiiywUM-mrra3tUD_QMRK_kXLj4xVqRgAc,38169
 cuqi/sampler/__init__.py,sha256=D-dYa0gFgIwQukP8_VKhPGmlGKXbvVo7YqaET4SdAeQ,382
 cuqi/sampler/_conjugate.py,sha256=ztmUR3V3qZk9zelKx48ULnmMs_zKTDUfohc256VOIe8,2753
 cuqi/sampler/_conjugate_approx.py,sha256=xX-X71EgxGnZooOY6CIBhuJTs3dhcKfoLnoFxX3CO2g,1938
@@ -82,15 +84,15 @@ cuqi/sampler/_rto.py,sha256=KIs0cDEoYK5I35RwO9fr5eKWeINLsmTLSVBnLdZmzzM,11921
 cuqi/sampler/_sampler.py,sha256=TkZ_WAS-5Q43oICa-Elc2gftsRTBd7PEDUMDZ9tTGmU,5712
 cuqi/samples/__init__.py,sha256=vCs6lVk-pi8RBqa6cIN5wyn6u-K9oEf1Na4k1ZMrYv8,44
 cuqi/samples/_samples.py,sha256=hUc8OnCF9CTCuDTrGHwwzv3wp8mG_6vsJAFvuQ-x0uA,35832
-cuqi/solver/__init__.py,sha256=3eoTTgBHe3M6ygrbgUVG3GlqaZVe5lGajNV9rolXZJ8,179
-cuqi/solver/_solver.py,sha256=GquU_rj-9yfPQnBVE_gXo4wdF84xw_pLks3bJarzR58,29491
+cuqi/solver/__init__.py,sha256=KuNlGxjPphG9tV-46YrmbcSQNhi0HMyhDd_v6V5sRaQ,209
+cuqi/solver/_solver.py,sha256=2mil7Gq7InHlQaOfnuTRDB5nw6dqJk9gR8DLFxpw_6g,29481
 cuqi/testproblem/__init__.py,sha256=DWTOcyuNHMbhEuuWlY5CkYkNDSAqhvsKmJXBLivyblU,202
 cuqi/testproblem/_testproblem.py,sha256=x769LwwRdJdzIiZkcQUGb_5-vynNTNALXWKato7sS0Q,52540
 cuqi/utilities/__init__.py,sha256=H7xpJe2UinjZftKvE2JuXtTi4DqtkR6uIezStAXwfGg,428
-cuqi/utilities/_get_python_variable_name.py,sha256=QwlBVj2koJRA8s8pWd554p7-ElcI7HUwY32HknaR92E,1827
+cuqi/utilities/_get_python_variable_name.py,sha256=wxpCaj9f3ZtBNqlGmmuGiITgBaTsY-r94lUIlK6UAU4,2043
 cuqi/utilities/_utilities.py,sha256=Jc4knn80vLoA7kgw9FzXwKVFGaNBOXiA9kgvltZU3Ao,11777
-CUQIpy-1.2.0.post0.dev352.dist-info/LICENSE,sha256=kJWRPrtRoQoZGXyyvu50Uc91X6_0XRaVfT0YZssicys,10799
-CUQIpy-1.2.0.post0.dev352.dist-info/METADATA,sha256=O3no2L4vDQEK-vO2bF_jWmHLydUYcXR6FN8deJHucmk,18529
-CUQIpy-1.2.0.post0.dev352.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-CUQIpy-1.2.0.post0.dev352.dist-info/top_level.txt,sha256=AgmgMc6TKfPPqbjV0kvAoCBN334i_Lwwojc7HE3ZwD0,5
-CUQIpy-1.2.0.post0.dev352.dist-info/RECORD,,
+CUQIpy-1.2.0.post0.dev380.dist-info/LICENSE,sha256=kJWRPrtRoQoZGXyyvu50Uc91X6_0XRaVfT0YZssicys,10799
+CUQIpy-1.2.0.post0.dev380.dist-info/METADATA,sha256=pio8eeEPi2sbNpoalD1ZWlftxpKJMt3vin-Y0LRsJLo,18529
+CUQIpy-1.2.0.post0.dev380.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+CUQIpy-1.2.0.post0.dev380.dist-info/top_level.txt,sha256=AgmgMc6TKfPPqbjV0kvAoCBN334i_Lwwojc7HE3ZwD0,5
+CUQIpy-1.2.0.post0.dev380.dist-info/RECORD,,

cuqi/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-11-28T12:43:32+0100",
+ "date": "2024-12-20T09:13:49+0100",
  "dirty": false,
  "error": null,
- "full-revisionid": "6f800787a63fef7d6ba2c0b88b96dbc209afdbad",
- "version": "1.2.0.post0.dev352"
+ "full-revisionid": "7405af566d2a50ba59fc861865d41c08f8dcf160",
+ "version": "1.2.0.post0.dev380"
 }
 '''  # END VERSION_JSON
 

cuqi/distribution/_joint_distribution.py

@@ -5,6 +5,7 @@ from cuqi.density import Density, EvaluatedDensity
 from cuqi.distribution import Distribution, Posterior
 from cuqi.likelihood import Likelihood
 from cuqi.geometry import Geometry, _DefaultGeometry1D
+import cuqi
 import numpy as np # for splitting array. Can avoid.
 
 class JointDistribution:
@@ -13,9 +14,11 @@ class JointDistribution:
 
     Parameters
     ----------
-    densities : Density
+    densities : RandomVariable or Density
         The densities to include in the joint distribution.
-        Each density is passed as comma-separated arguments.
+        Each density is passed as comma-separated arguments,
+        and can be either a :class:'Density' such as :class:'Distribution'
+        or :class:`RandomVariable`.
 
     Notes
     -----
@@ -59,7 +62,16 @@ class JointDistribution:
         posterior = joint(y=y_obs)
         
     """
-    def __init__(self, *densities: Density):
+    def __init__(self, *densities: [Density, cuqi.experimental.algebra.RandomVariable]):
+        """ Create a joint distribution from the given densities. """
+
+        # Check if all RandomVariables are simple (not-transformed)
+        for density in densities:
+            if isinstance(density, cuqi.experimental.algebra.RandomVariable) and density.is_transformed:
+                raise ValueError(f"To be used in {self.__class__.__name__}, all RandomVariables must be untransformed.")
+
+        # Convert potential random variables to their underlying distribution
+        densities = [density.distribution if isinstance(density, cuqi.experimental.algebra.RandomVariable) else density for density in densities]
 
         # Ensure all densities have unique names
         names = [density.name for density in densities]

cuqi/experimental/algebra/__init__.py

@@ -1 +1,2 @@
-from ._ast import VariableNode
+from ._ast import VariableNode, Node
+from ._randomvariable import RandomVariable

cuqi/experimental/algebra/_ast.py

@@ -56,6 +56,20 @@ class Node(ABC):
         """String representation of the node. Used for printing the AST."""
         pass
 
+    def get_variables(self, variables=None):
+        """Returns a set with the names of all variables in the sub-tree originated at this node."""
+        if variables is None:
+            variables = set()
+        if isinstance(self, VariableNode):
+            variables.add(self.name)
+        if hasattr(self, "child"):
+            self.child.get_variables(variables)
+        if hasattr(self, "left"):
+            self.left.get_variables(variables)
+        if hasattr(self, "right"):
+            self.right.get_variables(variables)
+        return variables
+
     def __add__(self, other):
         return AddNode(self, convert_to_node(other))
 

cuqi/experimental/algebra/_orderedset.py

@@ -0,0 +1,59 @@
+class _OrderedSet:
+    """A set (i.e. unique elements) that keeps its elements in the order they were added.
+
+    This is a minimal implementation of an ordered set, using a dictionary for storage.
+    """
+    
+    def __init__(self, iterable=None):
+        """Initialize the OrderedSet. 
+
+        If an iterable is provided, add all its elements to the set.
+        """
+        self.dict = dict.fromkeys(iterable if iterable else [])
+
+    def add(self, item):
+        """Add an item to the set. 
+
+        If the item is already in the set, it does nothing.
+        Otherwise, the item is stored as a key in the dictionary, with None as its value.
+        """
+        self.dict[item] = None
+
+    def __contains__(self, item):
+        """Check if an item is in the set. 
+
+        This is equivalent to checking if the item is a key in the dictionary.
+        """
+        return item in self.dict
+
+    def __iter__(self):
+        """Return an iterator over the set. 
+
+        This iterates over the keys in the dictionary.
+        """
+        return iter(self.dict)
+
+    def __len__(self):
+        """Return the number of items in the set."""
+        return len(self.dict)
+
+    def extend(self, other):
+        """Extend the set with the items in another set.
+
+        Raises a TypeError if the other object is not an _OrderedSet.
+        """
+        if not isinstance(other, _OrderedSet):
+            raise TypeError("unsupported operand type(s) for extend: '_OrderedSet' and '{}'".format(type(other).__name__))
+        for item in other:
+            self.add(item)
+
+    def __or__(self, other):
+        """Return a new set that is the union of this set and another set.
+
+        Raises a TypeError if the other object is not an _OrderedSet.
+        """
+        if not isinstance(other, _OrderedSet):
+            raise TypeError("unsupported operand type(s) for |: '_OrderedSet' and '{}'".format(type(other).__name__))
+        new_set = _OrderedSet(self.dict.keys())
+        new_set.extend(other)
+        return new_set

cuqi/experimental/algebra/_randomvariable.py

@@ -0,0 +1,360 @@
+from __future__ import annotations
+from typing import List, Any, Union
+from ._ast import VariableNode, Node
+from ._orderedset import _OrderedSet
+import operator
+import cuqi
+from cuqi.distribution import Distribution
+from copy import copy
+
+
+class RandomVariable:
+    """ Random variable defined by a distribution with the option to apply algebraic operations on it.
+
+    Random variables allow for the definition of Bayesian Problems in a natural way. In the context
+    of code, the random variable can be viewed as a lazily evaluated variable/array. It records
+    operations applied to it and acts as a function that, when called, evaluates the operations
+    and returns the result.
+
+    In CUQIpy, random variables can be in two forms: (1) a 'primal' random variable that is directly
+    defined by a distribution, e.g. x ~ N(0, 1), or (2) a 'transformed' random variable that is defined by
+    applying algebraic operations on one or more random variables, e.g. y = x + 1.
+
+    This distinction is purely for the purpose of the implementation in CUQIpy, as mathematically both
+    x ~ N(0, 1) and y = x + 1 ~ N(1, 1) are random variables. The distinction is useful for the
+    code implementation. In the future some operations like the above may allow primal random variables
+    that are transformed if the distribution can be analytically described.
+
+    Parameters
+    ----------
+    distributions : Distribution or list of Distributions
+        The distribution from which the random variable originates. If multiple distributions are
+        provided, the random variable is defined by the passed abstract syntax `tree` representing the
+        algebraic operations applied to one or more random variables.
+
+    tree : Node, optional
+        The tree, represented by the syntax tree nodes, that contain the algebraic operations applied to the random variable.
+        Specifically, the root of the tree should be provided.
+
+    name : str, optional
+        Name of the random variable. If not provided, the name is extracted from either the distribution provided
+        or from the variable name in the code. The name provided must match the parameter name of the distribution.
+
+    Example
+    -------
+
+    Basic usage:
+
+    .. code-block:: python
+
+        from cuqi.distribution import Gaussian
+
+        x = RandomVariable(Gaussian(0, 1))
+
+    Defining Bayesian problem using random variables:
+
+    .. code-block:: python
+
+        from cuqi.testproblem import Deconvolution1D
+        from cuqi.distribution import Gaussian, Gamma, GMRF
+        from cuqi.experimental.algebra import RandomVariable
+        from cuqi.problem import BayesianProblem
+
+        import numpy as np
+        A, y_obs, info = Deconvolution1D().get_components()
+
+        # Bayesian problem
+        d = RandomVariable(Gamma(1, 1e-4))
+        s = RandomVariable(Gamma(1, 1e-4))
+        x = RandomVariable(GMRF(np.zeros(A.domain_dim), d))
+        y = RandomVariable(Gaussian(A @ x, 1/s))
+
+        BP = BayesianProblem(y, x, s, d)
+        BP.set_data(y=y_obs)
+        BP.UQ()
+
+    Defining random variable from multiple distributions:
+
+    .. code-block:: python
+
+        from cuqi.distribution import Gaussian, Gamma
+        from cuqi.experimental.algebra import RandomVariable, VariableNode
+
+        # Define the variables
+        x = VariableNode('x')
+        y = VariableNode('y')
+
+        # Define the distributions (names must match variables)
+        dist_x = Gaussian(0, 1, name='x')
+        dist_y = Gamma(1, 1e-4, name='y')
+
+        # Define the tree (this is the algebra that defines the random variable along with the distributions)
+        tree = x + y
+
+        # Define random variable from 2 distributions with relation x+y
+        rv = RandomVariable([dist_x, dist_y], tree)
+
+    """
+
+
+    def __init__(self, distributions: Union['Distribution', List['Distribution']], tree: 'Node' = None, name: str = None):
+        """ Create random variable from distribution """
+
+        if isinstance(distributions, Distribution):
+            distributions = [distributions]
+        
+        if not  isinstance(distributions, list) and not isinstance(distributions, _OrderedSet):
+            raise ValueError("Expected a distribution or a list of distributions")
+
+        # Convert single distribution(s) to internal datastructure _OrderedSet.
+        # We use ordered set to ensure that the order of the distributions is preserved.
+        # which in turn ensures that the parameter names are always in the same order.
+        if not isinstance(distributions, _OrderedSet):
+            distributions = _OrderedSet(distributions)
+
+        # If tree is provided, check it is consistent with the given distributions
+        if tree:
+            tree_var_names = tree.get_variables()
+            dist_par_names = {dist._name for dist in distributions}
+
+            if len(tree_var_names) != len(distributions):
+                raise ValueError(
+                    f"There are {len(tree_var_names)} variables in the tree, but {len(distributions)} distributions are provided. "
+                    "This may be due to passing multiple distributions with the same parameter name. "
+                    f"The tree variables are {tree_var_names} and the distribution parameter names are {dist_par_names}."
+                )
+            
+            if not all(var_name in dist_par_names for var_name in tree_var_names):
+                raise ValueError(
+                    f"Variable names in the tree {tree_var_names} do not match the parameter names in the distributions {dist_par_names}. "
+                    "Ensure the name is inferred from the variable or explicitly provide it using name='var_name' in the distribution."
+                )
+
+        # Match random variable name with distribution parameter name (for single distribution)
+        if len(distributions) == 1 and tree is None:
+            dist = next(iter(distributions))
+            dist_par_name = dist._name
+            if dist_par_name is not None:
+                if name is not None and dist_par_name != name:
+                    raise ValueError(f"Parameter name '{dist_par_name}' of the distribution does not match the input name '{name}' for the random variable.")
+                name = dist_par_name
+    
+        self._distributions = distributions
+        """ The distribution from which the random variable originates. """
+        
+        self._tree = tree
+        """ The tree representation of the random variable. """
+
+        self._original_variable = None
+        """ Stores the original variable if this is a conditioned copy"""
+
+        self._name = name
+        """ Name of the random variable. """
+
+
+    def __call__(self, *args, **kwargs) -> Any:
+        """ Evaluate random variable at a given parameter value. For example, for random variable `X`, `X(1)` gives `1` and `(X+1)(1)` gives `2` """
+
+        if args and kwargs:
+            raise ValueError("Cannot pass both positional and keyword arguments to RandomVariable")
+        
+        if args:
+            kwargs = self._parse_args_add_to_kwargs(args, kwargs)
+
+        # Check if kwargs match parameter names using a all compare
+        if not all([name in kwargs for name in self.parameter_names]) or not all([name in self.parameter_names for name in kwargs]):
+            raise ValueError(f"Expected arguments {self.parameter_names}, got arguments {kwargs}")
+
+        return self.tree(**kwargs)
+    
+    @property
+    def tree(self):
+        if self._tree is None:
+            if len(self._distributions) > 1:
+                raise ValueError("Tree for multiple distributions can not be created automatically and need to be passed as an argument to the {} initializer.".format(type(self).__name__))
+            self._tree = VariableNode(self.name)
+        return self._tree
+
+    @property
+    def name(self):
+        """ Name of the random variable. If not provided, the name is extracted from the variable name in the code. """
+        if self._is_copy: # Extract the original variable name if this is a copy
+            return self._original_variable.name
+        if self._name is None: # If None extract the name from the stack
+            self._name = cuqi.utilities._get_python_variable_name(self)
+        if self._name is not None:
+            self._inject_name_into_distribution(self._name)
+        return self._name
+    
+    @name.setter
+    def name(self, name):
+        if self._is_copy:
+            raise ValueError("This random variable is derived from the conditional random variable named "+self._original_variable.name+". The name of the derived random variable cannot be set, but follows the name of the original random variable.")
+        self._name = name
+        
+    @property
+    def distribution(self) -> cuqi.distribution.Distribution:
+        """ Distribution from which the random variable originates. """
+        if len(self._distributions) > 1:
+            raise ValueError("Cannot get distribution from random variable defined by multiple distributions")
+        self._inject_name_into_distribution()
+        return next(iter(self._distributions))
+    
+    @property
+    def distributions(self) -> set:
+        """ Distributions from which the random variable originates. """
+        self._inject_name_into_distribution()
+        return self._distributions
+        
+    @property
+    def parameter_names(self) -> str:
+        """ Name of the parameter that the random variable can be evaluated at. """
+        self._inject_name_into_distribution()
+        return [distribution.name for distribution in self.distributions] # Consider renaming .name to .par_name for distributions
+
+    @property
+    def dim(self):
+        if self.is_transformed:
+            raise NotImplementedError("Dimension not implemented for transformed random variables")
+        return self.distribution.dim
+
+    @property
+    def geometry(self):
+        if self.is_transformed:
+            raise NotImplementedError("Geometry not implemented for transformed random variables")
+        return self.distribution.geometry
+
+    @geometry.setter
+    def geometry(self, geometry):
+        if self.is_transformed:
+            raise NotImplementedError("Geometry not implemented for transformed random variables")
+        self.distribution.geometry = geometry
+
+    @property
+    def expression(self):
+        """ Expression (formula) of the random variable. """
+        return str(self.tree)
+
+    @property
+    def is_transformed(self):
+        """ Returns True if the random variable is transformed. """
+        return not isinstance(self.tree, VariableNode)
+    
+    @property
+    def _non_default_args(self) -> List[str]:
+        """List of non-default arguments to distribution. This is used to return the correct
+        arguments when evaluating the random variable.
+        """
+        return self.parameter_names
+
+    def _inject_name_into_distribution(self, name=None):
+        if len(self._distributions) == 1:
+            dist = next(iter(self._distributions))
+            if dist._name is None:
+                if name is None:
+                    name = self.name
+                dist._name = name
+    
+    def _parse_args_add_to_kwargs(self, args, kwargs) -> dict:
+        """ Parse args and add to kwargs if any. Arguments follow self.parameter_names order. """
+        if len(args) != len(self.parameter_names):
+            raise ValueError(f"Expected {len(self.parameter_names)} arguments, got {len(args)}. Parameters are: {self.parameter_names}")
+        
+        # Add args to kwargs
+        for arg, name in zip(args, self.parameter_names):
+            kwargs[name] = arg
+            
+        return kwargs
+
+    def __repr__(self):
+        # Create strings for parameter name ~ distribution pairs
+        parameter_strings = [f"{name} ~ {distribution}" for name, distribution in zip(self.parameter_names, self.distributions)]
+        # Join strings with newlines
+        parameter_strings = "\n".join(parameter_strings)
+        # Add initial newline and indentations
+        parameter_strings = "\n".join(["\t"+line for line in parameter_strings.split("\n")])
+        # Print parameter strings with newlines
+        if self.is_transformed:
+            title = f"Transformed Random Variable"
+        else:
+            title = f""
+        if self.is_transformed:
+            body = (
+                f"\n"
+                f"Expression: {self.tree}\n"
+                f"Components: \n{parameter_strings}"
+                )
+        else:
+            body = parameter_strings.replace("\t","")
+        return title+body
+   
+    @property
+    def _is_copy(self):
+        """ Returns True if this is a copy of another random variable, e.g. by conditioning. """
+        return hasattr(self, '_original_variable') and self._original_variable is not None
+
+    def _make_copy(self):
+        """ Returns a shallow copy of the density keeping a pointer to the original. """
+        new_variable = copy(self)
+        new_variable._distributions = copy(self.distributions)
+        new_variable._tree = copy(self._tree)
+        new_variable._original_variable = self
+        return new_variable
+    
+    def _apply_operation(self, operation, other=None) -> 'RandomVariable':
+        """
+        Apply a specified operation to this RandomVariable.
+        """
+        if isinstance(other, cuqi.distribution.Distribution):
+            raise ValueError("Cannot apply operation to distribution. Use .rv to create random variable first.")
+        if other is None: # unary operation case
+            return RandomVariable(self.distributions, operation(self.tree))
+        elif isinstance(other, RandomVariable): # binary operation case with another random variable that has distributions
+            return RandomVariable(self.distributions | other.distributions, operation(self.tree, other.tree))
+        return RandomVariable(self.distributions, operation(self.tree, other)) # binary operation case with any other object (constant)
+
+    def __add__(self, other) -> 'RandomVariable':
+        return self._apply_operation(operator.add, other)
+
+    def __radd__(self, other) -> 'RandomVariable':
+        return self.__add__(other)
+
+    def __sub__(self, other) -> 'RandomVariable':
+        return self._apply_operation(operator.sub, other)
+
+    def __rsub__(self, other) -> 'RandomVariable':
+        return self._apply_operation(lambda x, y: operator.sub(y, x), other)
+
+    def __mul__(self, other) -> 'RandomVariable':
+        return self._apply_operation(operator.mul, other)
+
+    def __rmul__(self, other) -> 'RandomVariable':
+        return self.__mul__(other)
+
+    def __truediv__(self, other) -> 'RandomVariable':
+        return self._apply_operation(operator.truediv, other)
+
+    def __rtruediv__(self, other) -> 'RandomVariable':
+        return self._apply_operation(lambda x, y: operator.truediv(y, x), other)
+
+    def __matmul__(self, other) -> 'RandomVariable':
+        if isinstance(other, cuqi.model.Model) and not isinstance(other, cuqi.model.LinearModel):
+            raise TypeError("Cannot apply matmul to non-linear models")
+        return self._apply_operation(operator.matmul, other)
+
+    def __rmatmul__(self, other) -> 'RandomVariable':
+        if isinstance(other, cuqi.model.Model) and not isinstance(other, cuqi.model.LinearModel):
+            raise TypeError("Cannot apply matmul to non-linear models")
+        return self._apply_operation(lambda x, y: operator.matmul(y, x), other)
+
+    def __neg__(self) -> 'RandomVariable':
+        return self._apply_operation(operator.neg)
+
+    def __abs__(self) -> 'RandomVariable':
+        return self._apply_operation(abs)
+
+    def __pow__(self, other) -> 'RandomVariable':
+        return self._apply_operation(operator.pow, other)
+
+    def __getitem__(self, other) -> 'RandomVariable':
+        return self._apply_operation(operator.getitem, other)

cuqi/model/_model.py

@@ -351,6 +351,17 @@ class Model(object):
             new_model._non_default_args = [x.name] # Defaults to x if distribution had no name
             return new_model
 
+        # If input is a random variable, we handle it separately
+        if isinstance(x, cuqi.experimental.algebra.RandomVariable):
+            return self._handle_random_variable(x)
+        
+        # If input is a Node from internal abstract syntax tree, we let the Node handle the operation
+        # We use NotImplemented to indicate that the operation is not supported from the Model class
+        # in case of operations such as "@" that can be interpreted as both __matmul__ and __rmatmul__
+        # the operation may be delegated to the Node class.
+        if isinstance(x, cuqi.experimental.algebra.Node):
+            return NotImplemented
+
         # Else we apply the forward operator
         return self._apply_func(self._forward_func,
                                 self.range_geometry,
@@ -463,6 +474,20 @@ class Model(object):
             not type(self.domain_geometry) in _get_identity_geometries():
             raise NotImplementedError("Gradient not implemented for model {} with domain geometry {}".format(self,self.domain_geometry))
 
+    def _handle_random_variable(self, x):
+        """ Private function that handles the case of the input being a random variable. """
+        # If random variable is not a leaf-type node (e.g. internal node) we return NotImplemented
+        if not isinstance(x.tree, cuqi.experimental.algebra.VariableNode):
+            return NotImplemented        
+        
+        # In leaf-type node case we simply change the parameter name of model to match the random variable name
+        dist = x.distribution
+        if dist.dim != self.domain_dim:
+            raise ValueError("Attempting to match parameter name of Model with given random variable, but random variable dimension does not match model domain dimension.")
+        
+        new_model = copy(self)
+        new_model._non_default_args = [dist.name]
+        return new_model
 
     def __len__(self):
         return self.range_dim

cuqi/problem/_problem.py

@@ -771,11 +771,11 @@ class BayesianProblem(object):
         if self._check_posterior(self, CMRF, must_have_gradient=True): # Use L-BFGS-B for CMRF prior as it has better performance for this multi-modal posterior
             if disp: print(f"Using scipy.optimize.L_BFGS_B on negative log of {density.__class__.__name__}")
             if disp: print("x0: ones vector")
-            solver = cuqi.solver.L_BFGS_B(func, x0, gradfunc=gradfunc)
+            solver = cuqi.solver.ScipyLBFGSB(func, x0, gradfunc=gradfunc)
         else:
             if disp: print(f"Using scipy.optimize.minimize on negative log of {density.__class__.__name__}")
             if disp: print("x0: ones vector")
-            solver = cuqi.solver.minimize(func, x0, gradfunc=gradfunc)
+            solver = cuqi.solver.ScipyMinimizer(func, x0, gradfunc=gradfunc)
 
         x_MAP, solver_info = solver.solve()
 

cuqi/solver/__init__.py

@@ -1,8 +1,8 @@
 from ._solver import (
-    L_BFGS_B,
-    minimize,
-    maximize,
-    LS,
+    ScipyLBFGSB,
+    ScipyMinimizer,
+    ScipyMaximizer,
+    ScipyLeastSquares,
     CGLS,
     LM,
     PDHG,

cuqi/solver/_solver.py

@@ -15,7 +15,7 @@ except ImportError:
     has_cholmod = False
 
 
-class L_BFGS_B(object):
+class ScipyLBFGSB(object):
     """Wrapper for :meth:`scipy.optimize.fmin_l_bfgs_b`.
 
     Minimize a function func using the L-BFGS-B algorithm.
@@ -30,14 +30,10 @@ class L_BFGS_B(object):
         Initial guess.
     gradfunc : callable f(x,*args), optional
         The gradient of func. 
-        If None, then the solver approximates the gradient.
+        If None, the solver approximates the gradient with a finite difference scheme.
     kwargs : keyword arguments passed to scipy's L-BFGS-B algorithm. See documentation for scipy.optimize.minimize
-
-    Methods
-    ----------
-    :meth:`solve`: Runs the solver and returns the solution and info about the optimization.
     """
-    def __init__(self,func,x0, gradfunc = None, **kwargs):
+    def __init__(self, func, x0, gradfunc = None, **kwargs):
         self.func= func
         self.x0 = x0
         self.gradfunc = gradfunc
@@ -83,7 +79,7 @@ class L_BFGS_B(object):
                 "nfev": solution[2]['funcalls']}
         return solution[0], info
 
-class minimize(object):
+class ScipyMinimizer(object):
     """Wrapper for :meth:`scipy.optimize.minimize`.
 
     Minimize a function func using scipy's optimize.minimize module.
@@ -115,12 +111,8 @@ class minimize(object):
         ‘trust-krylov’ 
         If not given, chosen to be one of BFGS, L-BFGS-B, SLSQP, depending if the problem has constraints or bounds.
     kwargs : keyword arguments passed to scipy's minimizer. See documentation for scipy.optimize.minimize
-
-    Methods
-    ----------
-    :meth:`solve`: Runs the solver and returns the solution and info about the optimization.
     """
-    def __init__(self,func,x0, gradfunc = None, method = None, **kwargs):
+    def __init__(self, func, x0, gradfunc = '2-point', method = None, **kwargs):
         self.func= func
         self.x0 = x0
         self.method = method
@@ -147,18 +139,20 @@ class minimize(object):
         info = {"success": solution['success'],
                 "message": solution['message'],
                 "func": solution['fun'],
-                "grad": solution['jac'],
                 "nit": solution['nit'], 
                 "nfev": solution['nfev']}
+        # if gradfunc is callable, record the gradient in the info dict
+        if 'jac' in solution.keys():
+            info['grad'] = solution['jac']
         if isinstance(self.x0,CUQIarray):
             sol = CUQIarray(solution['x'],geometry=self.x0.geometry)
         else:
             sol = solution['x']
         return sol, info
 
-class maximize(minimize):
-    """Simply calls ::class:: cuqi.solver.minimize with -func."""
-    def __init__(self,func,x0, gradfunc = None, method = None, **kwargs):
+class ScipyMaximizer(ScipyMinimizer):
+    """Simply calls ::class:: cuqi.solver.ScipyMinimizer with -func."""
+    def __init__(self, func, x0, gradfunc = None, method = None, **kwargs):
         def nfunc(*args,**kwargs):
             return -func(*args,**kwargs)
         if gradfunc is not None:
@@ -170,7 +164,7 @@ class maximize(minimize):
 
 
 
-class LS(object):
+class ScipyLeastSquares(object):
     """Wrapper for :meth:`scipy.optimize.least_squares`.
 
     Solve nonlinear least-squares problems with bounds:
@@ -189,7 +183,7 @@ class LS(object):
         Initial guess.
     Jac : callable f(x,*args), optional
         The Jacobian of func. 
-        If None, then the solver approximates the Jacobian.
+        If not specified, the solver approximates the Jacobian with a finite difference scheme.
     loss: callable rho(x,*args)
         Determines the loss function
         'linear' : rho(z) = z. Gives a standard least-squares problem.
@@ -203,7 +197,7 @@ class LS(object):
         'dogbox', dogleg algorithm with rectangular trust regions, for small problems with bounds.
         'lm', Levenberg-Marquardt algorithm as implemented in MINPACK. Doesn't handle bounds and sparse Jacobians.
     """
-    def __init__(self, func, x0, jacfun=None, method='trf', loss='linear', tol=1e-6, maxit=1e4):
+    def __init__(self, func, x0, jacfun='2-point', method='trf', loss='linear', tol=1e-6, maxit=1e4):
         self.func = func
         self.x0 = x0
         self.jacfun = jacfun

cuqi/utilities/_get_python_variable_name.py

@@ -9,7 +9,7 @@ import cuqi
 def _get_python_variable_name(var):
     """ Retrieve the Python variable name of an object. Takes the first variable name appearing on the stack that is not in the ignore list. """
 
-    ignored_var_names = ["self", "cls", "obj", "var", "_"]
+    ignored_var_names = ["self", "cls", "obj", "var", "_", "result", "args", "kwargs", "par_name", "name", "distribution", "dist"]
 
     # First get the stack size and loop (in reverse) through the stack
     # It can be a bit slow to loop through stack size so we limit the levels
@@ -29,7 +29,7 @@ def _get_python_variable_name(var):
             if len(var_names) > 0:
                 return var_names[0]
 
-    warnings.warn("Could not automatically find variable name for object: {}. Use keyword `name` when defining distribution to specify a name. If code runs slowly and variable name is not needed set config.MAX_STACK_SEARCH_DEPTH to 0.".format(var))
+    warnings.warn("Could not automatically find variable name for object. Did you assign (=) the object to a python variable? Alternatively, use keyword `name` when defining distribution to specify a name. If code runs slowly and variable name is not needed set config.MAX_STACK_SEARCH_DEPTH to 0. These names are reserved {} and should not be used as object name.".format(ignored_var_names))
 
     return None