CUQIpy 1.1.1.post0.dev36__py3-none-any.whl → 1.4.1.post0.dev124__py3-none-any.whl

cuqi/distribution/_distribution.py

@@ -28,37 +28,6 @@ class Distribution(Density, ABC):
     is_symmetric : bool, default None
         Indicator if distribution is symmetric.
 
-    Attributes
-    ----------
-    dim : int or None
-        Dimension of distribution.
-
-    name : str or None
-        Name of distribution.
-    
-    geometry : Geometry or None
-        Geometry of distribution.
-
-    is_cond : bool
-        Indicator if distribution is conditional.
-
-    Methods
-    -------
-    pdf():
-        Evaluate the probability density function.
-
-    logpdf():
-        Evaluate the log probability density function.
-
-    sample():
-        Generate one or more random samples.
-
-    get_conditioning_variables():
-        Return the conditioning variables of distribution.
-
-    get_mutable_variables():
-        Return the mutable variables (attributes and properties) of distribution.
-
     Notes
     -----
     A distribution can be conditional if one or more mutable variables are unspecified.
@@ -136,7 +105,7 @@ class Distribution(Density, ABC):
                 f"Inconsistent distribution geometry attribute {self._geometry} and inferred "
                 f"dimension from distribution variables {inferred_dim}."
             )
-        
+
         # If Geometry dimension is None, update it with the inferred dimension
         if inferred_dim and self._geometry.par_dim is None: 
             self.geometry = inferred_dim
@@ -148,7 +117,7 @@ class Distribution(Density, ABC):
         # We do not use self.name to potentially infer it from python stack.
         if self._name: 
             self._geometry._variable_name = self._name
-            
+
         return self._geometry
 
     @geometry.setter
@@ -191,7 +160,7 @@ class Distribution(Density, ABC):
                     f"{self.logd.__qualname__}: To evaluate the log density all conditioning variables and main"
                     f" parameter must be specified. Conditioning variables are: {cond_vars}"
                 )
-            
+
             # Check if all conditioning variables are specified
             all_cond_vars_specified = all([key in kwargs for key in cond_vars])
             if not all_cond_vars_specified:
@@ -199,7 +168,7 @@ class Distribution(Density, ABC):
                     f"{self.logd.__qualname__}: To evaluate the log density all conditioning variables must be"
                     f" specified. Conditioning variables are: {cond_vars}"
                 )
-            
+
             # Extract exactly the conditioning variables from kwargs
             cond_kwargs = {key: kwargs[key] for key in cond_vars}
 
@@ -217,7 +186,7 @@ class Distribution(Density, ABC):
         # Not conditional distribution, simply evaluate log density directly
         else:
             return super().logd(*args, **kwargs)
-        
+
     def _logd(self, *args):
         return self.logpdf(*args) # Currently all distributions implement logpdf so we simply call this method.
 
@@ -239,6 +208,7 @@ class Distribution(Density, ABC):
             "enable_FD().")
 
     def sample(self,N=1,*args,**kwargs):
+        """ Sample from the distribution. """
 
         if self.is_cond:
             raise ValueError(f"Cannot sample from conditional distribution. Missing conditioning variables: {self.get_conditioning_variables()}")
@@ -246,7 +216,7 @@ class Distribution(Density, ABC):
         # Get samples from the distribution sample method
         s = self._sample(N,*args,**kwargs)
 
-        #Store samples in cuqi samples object if more than 1 sample
+        # Store samples in cuqi samples object if more than 1 sample
         if N==1:
             if len(s) == 1 and isinstance(s,np.ndarray): #Extract single value from numpy array
                 s = s.ravel()[0]
@@ -263,6 +233,7 @@ class Distribution(Density, ABC):
         pass
 
     def pdf(self,x):
+        """ Evaluate the log probability density function of the distribution. """
         return np.exp(self.logpdf(x))
 
     def _condition(self, *args, **kwargs):
@@ -293,7 +264,7 @@ class Distribution(Density, ABC):
         # Go through every mutable variable and assign value from kwargs if present
         for var_key in mutable_vars:
 
-            #If keyword directly specifies new value of variable we simply reassign
+            # If keyword directly specifies new value of variable we simply reassign
             if var_key in kwargs:
                 setattr(new_dist, var_key, kwargs.get(var_key))
                 processed_kwargs.add(var_key)
@@ -320,9 +291,18 @@ class Distribution(Density, ABC):
 
                 elif len(var_args)>0:                      #Some keywords found
                     # Define new partial function with partially defined args
-                    func = partial(var_val, **var_args)
+                    if (
+                        hasattr(var_val, "_supports_partial_eval")
+                        and var_val._supports_partial_eval
+                    ):
+                        func = var_val(**var_args)
+                    else:
+                        # If the callable does not support partial evaluation,
+                        # we use the partial function to set the variable
+                        func = partial(var_val, **var_args)
+
                     setattr(new_dist, var_key, func)
-                
+
                 # Store processed keywords
                 processed_kwargs.update(var_args.keys())
 
@@ -358,7 +338,7 @@ class Distribution(Density, ABC):
 
     def get_conditioning_variables(self):
         """Return the conditioning variables of this distribution (if any)."""
-        
+
         # Get all mutable variables
         mutable_vars = self.get_mutable_variables()
 
@@ -367,7 +347,7 @@ class Distribution(Density, ABC):
 
         # Add any variables defined through callable functions
         cond_vars += get_indirect_variables(self)
-        
+
         return cond_vars
 
     def get_mutable_variables(self):
@@ -376,10 +356,10 @@ class Distribution(Density, ABC):
         # If mutable variables are already cached, return them
         if hasattr(self, '_mutable_vars'):
             return self._mutable_vars
-        
+
         # Define list of ignored attributes and properties
         ignore_vars = ['name', 'is_symmetric', 'geometry', 'dim']
-        
+
         # Get public attributes
         attributes = get_writeable_attributes(self)
 
@@ -425,7 +405,7 @@ class Distribution(Density, ABC):
                         raise ValueError(f"{self._condition.__qualname__}: {ordered_keys[index]} passed as both argument and keyword argument.\nArguments follow the listed conditioning variable order: {self.get_conditioning_variables()}")
                     kwargs[ordered_keys[index]] = arg
         return kwargs
-    
+
     def _check_geometry_consistency(self):
         """ Checks that the geometry of the distribution is consistent by calling the geometry property. Should be called at the end of __init__ of subclasses. """
         self.geometry
@@ -435,3 +415,9 @@ class Distribution(Density, ABC):
             return "CUQI {}. Conditioning variables {}.".format(self.__class__.__name__,self.get_conditioning_variables())
         else:
             return "CUQI {}.".format(self.__class__.__name__)
+
+    @property
+    def rv(self):
+        """ Return a random variable object representing the distribution. """
+        from cuqi.algebra import RandomVariable
+        return RandomVariable(self)

cuqi/distribution/_gamma.py

@@ -6,14 +6,18 @@ from cuqi.utilities import force_ndarray
 class Gamma(Distribution):
     """
     Represents a multivariate Gamma distribution characterized by shape and rate parameters of independent random variables x_i. Each is distributed according to the PDF function
+
+    .. math::
     
-    f(x_i; shape, rate) = rate^shape * x_i^(shape-1) * exp(-rate * x_i) / Gamma(shape)
+        f(x_i; \\alpha, \\beta) = \\beta^\\alpha x_i^{\\alpha-1} \\exp(-\\beta x_i) / \Gamma(\\alpha)
 
-    where `shape` and `rate` are the parameters of the distribution, and Gamma is the Gamma function.
+    where shape :math:`\\alpha` and rate :math:`\\beta` are the parameters of the distribution, and :math:`\Gamma` is the Gamma function.
 
     In case shape and/or rate are arrays, the pdf looks like
 
-    f(x_i; shape_i, rate_i) = rate_i^shape_i * x_i^(shape_i-1) * exp(-rate_i * x_i) / Gamma(shape_i)
+    .. math::
+    
+        f(x_i; \\alpha_i, \\beta_i) = \\beta_i^{\\alpha_i} x_i^{\\alpha_i-1} \\exp(-\\beta_i x_i) / \Gamma(\\alpha_i)
 
     Parameters
     ----------

cuqi/distribution/_gaussian.py

@@ -730,18 +730,6 @@ class JointGaussianSqrtPrec(Distribution):
     ------------
     means: List of means for each Gaussian distribution.
     sqrtprecs: List of sqrt precision matricies for each Gaussian distribution.
-
-    Attributes
-    ------------
-    sqrtprec: Returns the sqrt precision matrix of the joined gaussian in stacked form.
-    sqrtprecTimesMean: Returns the sqrt precision matrix times the mean of the distribution.
-    
-    Methods
-    -----------
-    sample: generate one or more random samples (NotImplemented)
-    pdf: evaluate probability density function (NotImplemented)
-    logpdf: evaluate log probability density function (NotImplemented)
-    cdf: evaluate cumulative probability function (NotImplemented)
     """    
     def __init__(self,means=None,sqrtprecs=None,is_symmetric=True,**kwargs):
 
@@ -783,6 +771,7 @@ class JointGaussianSqrtPrec(Distribution):
 
     @property
     def sqrtprec(self):
+        """ Returns the sqrt precision matrix of the joined gaussian in stacked form. """
         if spa.issparse(self._sqrtprecs[0]):
             return spa.vstack((self._sqrtprecs))
         else:
@@ -790,6 +779,7 @@ class JointGaussianSqrtPrec(Distribution):
 
     @property
     def sqrtprecTimesMean(self):
+        """ Returns the sqrt precision matrix times the mean of the distribution."""
         result = []
         for i in range(len(self._means)):
             result.append((self._sqrtprecs[i]@self._means[i]).flatten())

cuqi/distribution/_inverse_gamma.py

@@ -8,9 +8,11 @@ class InverseGamma(Distribution):
     """
     Multivariate inverse gamma distribution of independent random variables x_i. Each is distributed according to the PDF function
 
-    f(x) = (x-location)^(-shape-1) * exp(-scale/(x-location)) / (scale^(-shape)*Gamma(shape))
+    .. math::
 
-    where shape, location and scale are the shape, location and scale of x_i, respectively. And Gamma is the Gamma function.
+        f(x) = (x-\\beta)^{(-\\alpha-1)} * \exp(-\\gamma/(x-\\beta)) / (\\gamma^{(-\\alpha)}*\Gamma(\\alpha))
+
+    where shape :math:`\\alpha`, location :math:`\\beta` and scale :math:`\\gamma` are the shape, location and scale of x_i, respectively. And :math:`\Gamma` is the Gamma function.
 
     Parameters
     ------------
@@ -23,14 +25,6 @@ class InverseGamma(Distribution):
     scale: float or array_like
         The scale of the inverse gamma distribution (non-negative)
 
-    
-    Methods
-    -----------
-    sample: generate one or more random samples
-    pdf: evaluate probability density function
-    logpdf: evaluate log probability density function
-    cdf: evaluate cumulative probability function
-    
     Example
     -------
     .. code-block:: python

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.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.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.algebra.RandomVariable) else density for density in densities]
 
         # Ensure all densities have unique names
         names = [density.name for density in densities]
@@ -72,6 +84,8 @@ class JointDistribution:
         cond_vars = self._get_conditioning_variables()
         if len(cond_vars) > 0:
             raise ValueError(f"Every density parameter must have a distribution (prior). Missing prior for {cond_vars}.")
+        # Initialize finite difference gradient approximation settings
+        self.disable_FD()
 
     # --------- Public properties ---------
     @property
@@ -84,6 +98,38 @@ class JointDistribution:
         """ Returns the geometries of the joint distribution. """
         return [dist.geometry for dist in self._distributions]
 
+    @property
+    def FD_enabled(self):
+        """ Returns a dictionary of keys and booleans indicating for each
+        parameter name (key) if finite difference approximation of the logd
+        gradient is enabled. """
+        par_names = self.get_parameter_names()
+        FD_enabled = {
+            par_name: self.FD_epsilon[par_name] is not None for par_name in par_names
+        }
+        return FD_enabled
+
+    @property
+    def FD_epsilon(self):
+        """ Returns a dictionary indicating for each parameter name the
+        spacing for the finite difference approximation of the logd gradient."""
+        return self._FD_epsilon
+
+    @FD_epsilon.setter
+    def FD_epsilon(self, value):
+        """ Set the spacing for the finite difference approximation of the
+        logd gradient as a dictionary. The keys are the parameter names.
+        The value for each key is either None (no FD approximation) or a float
+        representing the FD step size.
+        """
+        par_names = self.get_parameter_names()
+        if value is None:
+            self._FD_epsilon = {par_name: None for par_name in par_names}
+        else:
+            if set(value.keys()) != set(par_names):
+                raise ValueError("Keys of FD_epsilon must match the parameter names of the distribution "+f" {par_names}")
+            self._FD_epsilon = value
+
     # --------- Public methods ---------
     def logd(self, *args, **kwargs):
         """ Evaluate the un-normalized log density function. """
@@ -124,6 +170,33 @@ class JointDistribution:
         # Can reduce to Posterior, Likelihood or Distribution.
         return new_joint._reduce_to_single_density()
 
+    def enable_FD(self, epsilon=None):
+        """ Enable finite difference approximation for logd gradient. Note
+        that if enabled, the FD approximation will be used even if the 
+        _gradient method is implemented. By default, all parameters
+        will have FD enabled with a step size of 1e-8.
+        
+        Parameters
+        ----------
+        epsilon : dict, *optional*
+
+        Dictionary indicating the spacing (step size) to use for finite
+        difference approximation for logd gradient for each variable.
+
+        Keys are variable names.
+        Values are either a float to enable FD with the given value as the FD
+        step size, or None to disable FD for that variable. Default is 1e-8 for
+        all variables.
+        """
+        if epsilon is None:
+            epsilon = {par_name: 1e-8 for par_name in self.get_parameter_names()}
+        self.FD_epsilon = epsilon
+
+    def disable_FD(self):
+        """ Disable finite difference approximation for logd gradient. """
+        par_names = self.get_parameter_names()
+        self.FD_epsilon = {par_name: None for par_name in par_names}
+
     def get_parameter_names(self) -> List[str]:
         """ Returns the parameter names of the joint distribution. """
         return [dist.name for dist in self._distributions]
@@ -190,34 +263,58 @@ class JointDistribution:
         # Count number of distributions and likelihoods
         n_dist = len(self._distributions)
         n_likelihood = len(self._likelihoods)
+        reduced_FD_epsilon = {par_name:self.FD_epsilon[par_name] for par_name in self.get_parameter_names()}
+        self.enable_FD(epsilon=reduced_FD_epsilon)
 
         # Cant reduce if there are multiple distributions or likelihoods
         if n_dist > 1:
             return self
 
+        # If only evaluated densities left return joint to ensure logd method is available
+        if n_dist == 0 and n_likelihood == 0:
+            return self
+
+        # Extract the parameter name of the distribution
+        if n_dist == 1:
+            par_name = self._distributions[0].name
+        elif n_likelihood == 1:
+            par_name = self._likelihoods[0].name
+        else:
+            par_name = None
+
         # If exactly one distribution and multiple likelihoods reduce
         if n_dist == 1 and n_likelihood > 1:
-            return MultipleLikelihoodPosterior(*self._densities)
-        
+            reduced_distribution = MultipleLikelihoodPosterior(*self._densities)
+            reduced_FD_epsilon = {par_name:self.FD_epsilon[par_name]}
+
         # If exactly one distribution and one likelihood its a Posterior
         if n_dist == 1 and n_likelihood == 1:
             # Ensure parameter names match, otherwise return the joint distribution
             if set(self._likelihoods[0].get_parameter_names()) != set(self._distributions[0].get_parameter_names()):
                 return self
-            return self._add_constants_to_density(Posterior(self._likelihoods[0], self._distributions[0]))
+            reduced_distribution = Posterior(self._likelihoods[0], self._distributions[0])
+            reduced_distribution = self._add_constants_to_density(reduced_distribution)
+            reduced_FD_epsilon = self.FD_epsilon[par_name]
 
         # If exactly one distribution and no likelihoods its a Distribution
         if n_dist == 1 and n_likelihood == 0:
-            return self._add_constants_to_density(self._distributions[0])        
-        
+            # Intentionally skip enabling FD here. If the user wants FD, they
+            # can enable it for this particular distribution before forming
+            # the joint distribution.
+            return self._add_constants_to_density(self._distributions[0])
+
         # If no distributions and exactly one likelihood its a Likelihood
         if n_likelihood == 1 and n_dist == 0:
-            return self._likelihoods[0]
+            # This case seems to not happen in practice, but we include it for
+            # completeness.
+            reduced_distribution = self._likelihoods[0]
+            reduced_FD_epsilon = self.FD_epsilon[par_name] 
+
+        if self.FD_enabled[par_name]:
+            reduced_distribution.enable_FD(epsilon=reduced_FD_epsilon)
+
+        return reduced_distribution
 
-        # If only evaluated densities left return joint to ensure logd method is available
-        if n_dist == 0 and n_likelihood == 0:
-            return self
-        
     def _add_constants_to_density(self, density: Density):
         """ Add the constants (evaluated densities) to a single density. Used when reducing to single density. """
 
@@ -262,7 +359,7 @@ class JointDistribution:
                     if len(cond_vars) > 0:
                         msg += f"|{cond_vars}"
                     msg += ")"
-        
+
         msg += "\n"
         msg += "    Densities: \n"
 
@@ -271,7 +368,7 @@ class JointDistribution:
             msg += f"\t{density.name} ~ {density}\n"
 
         # Wrap up
-        msg += ")"
+        msg += " )"
 
         return msg
 

cuqi/distribution/_lognormal.py

@@ -16,13 +16,6 @@ class Lognormal(Distribution):
     cov: np.ndarray
         Covariance matrix of the normal distribution used to define the lognormal distribution 
     
-    Methods
-    -----------
-    sample: generate one or more random samples
-    pdf: evaluate probability density function
-    logpdf: evaluate log probability density function
-    cdf: evaluate cumulative probability function
-    
     Example
     -------
     .. code-block:: python

cuqi/distribution/{_modifiedhalfnormal.py → _modified_half_normal.py}

@@ -7,37 +7,40 @@ from cuqi.utilities import force_ndarray
 class ModifiedHalfNormal(Distribution):
     """
     Represents a modified half-normal (MHN) distribution, a three-parameter family of distributions generalizing the Gamma distribution.
-    The distribution is continuous with pdf 
-    f(x; alpha, beta, gamma) propto x^(alpha-1) * exp(-beta * x^2 + gamma * x)
+    The distribution is continuous with pdf
+
+    .. math::
+    
+        f(x; \\alpha, \\beta, \\gamma) \propto x^{(\\alpha-1)} * \exp(-\\beta * x^2 + \\gamma * x)
 
     The MHN generalizes the half-normal distribution, because
-    f(x; 1, beta, 0) propto exp(-beta * x^2)
+    :math:`f(x; 1, \\beta, 0) \propto \exp(-\\beta * x^2)`
 
     The MHN generalizes the gamma distribution because
-    f(x; alpha, 0, -gamma) propto x^(alpha-1) * exp(- gamma * x)
+    :math:`f(x; \\alpha, 0, -\\gamma) \propto x^{(\\alpha-1)} * \exp(- \\gamma * x)`
 
     Reference:
     [1] Sun, et al. "The Modified-Half-Normal distribution: Properties and an efficient sampling scheme." Communications in Statistics-Theory and Methods
     
     Parameters
     ----------
-    alpha : float
-        The polynomial exponent parameter of the MHN distribution. Must be positive.
+    alpha : float or array_like
+        The polynomial exponent parameter :math:`\\alpha` of the MHN distribution. Must be positive.
 
-    beta : float
-        The quadratic exponential parameter of the MHN distribution. Must be positive.
+    beta : float or array_like
+        The quadratic exponential parameter :math:`\\beta` of the MHN distribution. Must be positive.
 
-    gamma : float
-        The linear exponential parameter of the MHN distribution.
+    gamma : float or array_like
+        The linear exponential parameter :math:`\\gamma` of the MHN distribution.
 
     """
     def __init__(self, alpha=None, beta=None, gamma=None, is_symmetric=False, **kwargs):
         # Init from abstract distribution class
         super().__init__(is_symmetric=is_symmetric, **kwargs) 
 
-        self._alpha = alpha
-        self._beta = beta
-        self._gamma = gamma
+        self.alpha = alpha
+        self.beta = beta
+        self.gamma = gamma
 
     @property
     def alpha(self):
@@ -45,13 +48,13 @@ class ModifiedHalfNormal(Distribution):
         return self._alpha
     
     @alpha.setter
-    def shape(self, value):
-        self._shape = force_ndarray(value, flatten=True)
+    def alpha(self, value):
+        self._alpha = force_ndarray(value, flatten=True)
 
     @property
     def beta(self):
         """ The quadratic exponential parameter of the MHN distribution. Must be positive. """
-        return self._alpha
+        return self._beta
     
     @beta.setter
     def beta(self, value):
@@ -60,7 +63,7 @@ class ModifiedHalfNormal(Distribution):
     @property
     def gamma(self):
         """ The linear exponential parameter of the MHN distribution. """
-        return self._alpha
+        return self._gamma
     
     @gamma.setter
     def gamma(self, value):
@@ -75,11 +78,8 @@ class ModifiedHalfNormal(Distribution):
         return (self.alpha - 1)/val - 2*self.beta*val + self.gamma
 
     def _gradient(self, val, *args, **kwargs):
-        if hasattr(self.alpha, '__iter__'):
-            return np.array([self._gradient_scalar(v) for v in val])
-        else:
-            return np.array([self.dim*[self._gradient_scalar(v)] for v in val])
-    
+        return np.array([self._gradient_scalar(v) for v in val])
+
     def _MHN_sample_gamma_proposal(self, alpha, beta, gamma, rng, delta=None):
         """
             Sample from a modified half-normal distribution using a Gamma distribution proposal.
@@ -177,7 +177,7 @@ class ModifiedHalfNormal(Distribution):
 
     def _sample(self, N, rng=None):
         if hasattr(self.alpha, '__getitem__'):
-            return np.array([self._MHN_sample(self.alpha[i], self.beta[i], self.gamma[i], rng=rng) for i in range(N)])
+            return np.array([[self._MHN_sample(self.alpha[i], self.beta[i], self.gamma[i], rng=rng) for i in range(len(self.alpha))] for _ in range(N)])
         else:
             return np.array([self._MHN_sample(self.alpha, self.beta, self.gamma, rng=rng) for i in range(N)])
 

cuqi/distribution/_normal.py

@@ -1,5 +1,8 @@
 import numpy as np
+import numbers
 from scipy.special import erf
+from cuqi.geometry import _get_identity_geometries
+from cuqi.utilities import force_ndarray
 from cuqi.distribution import Distribution
 
 class Normal(Distribution):
@@ -12,13 +15,6 @@ class Normal(Distribution):
     mean: mean of distribution
     std: standard deviation
     
-    Methods
-    -----------
-    sample: generate one or more random samples
-    pdf: evaluate probability density function
-    logpdf: evaluate log probability density function
-    cdf: evaluate cumulative probability function
-    
     Example
     -----------
     .. code-block:: python
@@ -34,6 +30,24 @@ class Normal(Distribution):
         self.mean = mean
         self.std = std
 
+    @property
+    def mean(self):
+        """ Mean of the distribution """
+        return self._mean
+
+    @mean.setter
+    def mean(self, value):
+        self._mean = force_ndarray(value, flatten=True)
+
+    @property
+    def std(self):
+        """ Std of the distribution """
+        return self._std
+
+    @std.setter
+    def std(self, value):
+        self._std = force_ndarray(value, flatten=True)
+
     def pdf(self, x):
         return np.prod(1/(self.std*np.sqrt(2*np.pi))*np.exp(-0.5*((x-self.mean)/self.std)**2))
 
@@ -43,6 +57,19 @@ class Normal(Distribution):
     def cdf(self, x):
         return np.prod(0.5*(1 + erf((x-self.mean)/(self.std*np.sqrt(2)))))
 
+    def _gradient(self, val, *args, **kwargs):
+        if not type(self.geometry) in _get_identity_geometries():
+            raise NotImplementedError("Gradient not implemented for distribution {} with geometry {}".format(self,self.geometry))
+        if not callable(self.mean):
+            return -(val-self.mean)/(self.std**2)
+        elif hasattr(self.mean, "gradient"): # for likelihood
+            model = self.mean
+            dev = val - model.forward(*args, **kwargs)
+            print(dev)
+            return model.gradient(1.0/(np.array(self.std)) @ dev, *args, **kwargs)
+        else:
+            raise NotImplementedError("Gradient not implemented for distribution {} with location {}".format(self,self.mean))
+
     def _sample(self,N=1, rng=None):
 
         """

cuqi/distribution/_posterior.py

@@ -1,5 +1,6 @@
 from cuqi.geometry import _DefaultGeometry, _get_identity_geometries
 from cuqi.distribution import Distribution
+from cuqi.density import Density
 
 # ========================================================================
 class Posterior(Distribution):
@@ -25,6 +26,14 @@ class Posterior(Distribution):
         self.prior = prior 
         super().__init__(**kwargs)
 
+    def get_density(self, name) -> Density:
+        """ Return a density with the given name. """
+        if name == self.likelihood.name:
+            return self.likelihood
+        if name == self.prior.name:
+            return self.prior
+        raise ValueError(f"No density with name {name}.")
+
     @property
     def data(self):
         return self.likelihood.data