CUQIpy 1.0.0.post0.dev360__tar.gz → 1.0.0.post0.dev384__tar.gz

{cuqipy-1.0.0.post0.dev360 → cuqipy-1.0.0.post0.dev384}/CUQIpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CUQIpy
-Version: 1.0.0.post0.dev360
+Version: 1.0.0.post0.dev384
 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.0.0.post0.dev360 → cuqipy-1.0.0.post0.dev384}/CUQIpy.egg-info/SOURCES.txt

@@ -41,6 +41,7 @@ cuqi/distribution/_lognormal.py
 cuqi/distribution/_modifiedhalfnormal.py
 cuqi/distribution/_normal.py
 cuqi/distribution/_posterior.py
+cuqi/distribution/_smoothed_laplace.py
 cuqi/distribution/_uniform.py
 cuqi/experimental/__init__.py
 cuqi/experimental/mcmc/__init__.py
@@ -62,6 +63,7 @@ cuqi/geometry/_geometry.py
 cuqi/implicitprior/__init__.py
 cuqi/implicitprior/_regularizedGMRF.py
 cuqi/implicitprior/_regularizedGaussian.py
+cuqi/implicitprior/_regularizedUnboundedUniform.py
 cuqi/likelihood/__init__.py
 cuqi/likelihood/_likelihood.py
 cuqi/model/__init__.py

{cuqipy-1.0.0.post0.dev360 → cuqipy-1.0.0.post0.dev384}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CUQIpy
-Version: 1.0.0.post0.dev360
+Version: 1.0.0.post0.dev384
 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.0.0.post0.dev360 → cuqipy-1.0.0.post0.dev384}/cuqi/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-07-01T14:33:09+0200",
+ "date": "2024-07-05T09:29:07+0200",
  "dirty": false,
  "error": null,
- "full-revisionid": "4da44104c9163182cd1eeb31fb4678a2893111fe",
- "version": "1.0.0.post0.dev360"
+ "full-revisionid": "3e3d762fab019f39257708bb9cdf5abc3681f196",
+ "version": "1.0.0.post0.dev384"
 }
 '''  # END VERSION_JSON
 

{cuqipy-1.0.0.post0.dev360 → cuqipy-1.0.0.post0.dev384}/cuqi/distribution/__init__.py

@@ -9,6 +9,7 @@ from ._gmrf import GMRF
 from ._inverse_gamma import InverseGamma
 from ._lmrf import LMRF
 from ._laplace import Laplace
+from ._smoothed_laplace import SmoothedLaplace
 from ._lognormal import Lognormal
 from ._normal import Normal
 from ._posterior import Posterior

cuqipy-1.0.0.post0.dev384/cuqi/distribution/_smoothed_laplace.py

@@ -0,0 +1,95 @@
+import numpy as np
+from cuqi.utilities import force_ndarray
+from cuqi.distribution import Distribution
+
+class SmoothedLaplace(Distribution):
+    """ Smoothed Laplace distribution. 
+
+    Defines a smoothed Laplace distribution given a location, a scale and a smoothing parameter
+    beta. The smoothed Laplace distribution is defined as
+
+    .. math::
+
+        p(x) = \\frac{1}{2b} \exp\left(-\\frac{\sqrt{(x-\mu)^2 + \beta}}{b}\\right),
+
+    where :math:`\mu` is the location (mean), :math:`b` is the scale (decay) parameter and
+    :math:`\beta` is the smoothing parameter.
+
+    The rate parameter is defined as :math:`\lambda = \\frac{1}{b}`.
+
+    The variables of this Laplace distribution are independent identically distributed (i.i.d.).
+
+    Parameters
+    ----------
+    location : scalar, list, tuple, or ndarray
+        The location parameter of the distribution.
+
+    scale : scalar, list, tuple, or ndarray
+        The scale parameter of the distribution.
+    
+    beta : scalar
+        The smoothing parameter of the distribution.
+
+    """
+
+    def __init__(self, location=None, scale=None, beta=1e-3, **kwargs):
+        super().__init__(**kwargs)
+
+        self.location = location
+        self.scale = scale
+        self.beta = beta
+
+    @property
+    def location(self):
+        """ Location parameter """
+        return self._location
+    
+    @location.setter
+    def location(self, value):
+        self._location = force_ndarray(value, flatten=True)
+
+    @property
+    def scale(self):
+        """ Scale parameter """
+        return self._scale
+    
+    @scale.setter
+    def scale(self, value):
+        self._scale = force_ndarray(value, flatten=True)
+
+    @property
+    def beta(self):
+        """ Beta parameter """
+        return self._beta
+    
+    @beta.setter
+    def beta(self, value):
+        self._beta = value
+
+    def logpdf(self, x):
+        """
+        Computes the logarithm of the probability density function at the given values of x.
+        """
+        # x accepts scalar, list, tuple, or ndarray
+        if isinstance(x, (float, int)):
+            x = np.array([x])
+        elif isinstance(x, (list, tuple)):
+            x = np.array(x)
+        return np.sum(np.log(0.5 / self.scale)) - np.sum(np.sqrt((x - self.location) ** 2 + self.beta) / self.scale)
+
+    def gradient(self, x):
+        """
+        Computes the gradient of logpdf at the given values of x.
+        """
+        # x accepts scalar, list, tuple, or ndarray
+        if isinstance(x, (float, int)):
+            x = np.array([x])
+        elif isinstance(x, (list, tuple)):
+            x = np.array(x)
+        return -np.array((x - self.location) / self.scale / np.sqrt((x - self.location) ** 2 + self.beta))
+
+    def _sample(self, N=1, rng=None):
+        """
+        Generates random samples from the distribution.
+        """
+        raise NotImplementedError(f"sample is not implemented for {self.__class__.__name__}.")

cuqipy-1.0.0.post0.dev384/cuqi/implicitprior/__init__.py

@@ -0,0 +1,3 @@
+from ._regularizedGaussian import RegularizedGaussian, ConstrainedGaussian, NonnegativeGaussian
+from ._regularizedGMRF import RegularizedGMRF, ConstrainedGMRF, NonnegativeGMRF
+from ._regularizedUnboundedUniform import RegularizedUnboundedUniform

cuqipy-1.0.0.post0.dev384/cuqi/implicitprior/_regularizedGMRF.py

@@ -0,0 +1,152 @@
+from cuqi.implicitprior import RegularizedGaussian
+from cuqi.distribution import Distribution, GMRF
+
+class RegularizedGMRF(RegularizedGaussian):
+    """ Implicit Regularized GMRF (Gaussian Markov Random Field). 
+
+    Defines a so-called implicit prior based on a GMRF distribution with implicit regularization.
+    The regularization can be defined in the form of a proximal operator or a projector.
+    Alternatively, preset constraints and regularization can be used.
+
+    Only one of proximal, projector, constraint or regularization can be provided. Otherwise, an error is raised.
+
+    Can be used as a prior in a posterior which can be sampled with the RegularizedLinearRTO sampler.
+
+
+    For more details on implicit regularized Gaussian see the following paper:
+
+    [1] Everink, Jasper M., Yiqiu Dong, and Martin S. Andersen. "Sparse Bayesian inference with regularized
+    Gaussian distributions." Inverse Problems 39.11 (2023): 115004.
+
+    Parameters
+    ----------
+    mean
+        See :class:`~cuqi.distribution.GMRF` for details.
+        
+    prec
+        See :class:`~cuqi.distribution.GMRF` for details.
+
+    bc_type
+        See :class:`~cuqi.distribution.GMRF` for details.
+
+    order
+        See :class:`~cuqi.distribution.GMRF` for details.
+
+    proximal : callable f(x, scale) or None
+        Euclidean proximal operator f of the regularization function g, that is, a solver for the optimization problem
+        min_z 0.5||x-z||_2^2+scale*g(x).
+
+    projector : callable f(x) or None
+        Euclidean projection onto the constraint C, that is, a solver for the optimization problem
+        min_(z in C) 0.5||x-z||_2^2.
+
+    constraint : string or None
+        Preset constraints. Can be set to "nonnegativity" and "box". Required for use in Gibbs.
+        For "box", the following additional parameters can be passed:
+            lower_bound : array_like or None
+                Lower bound of box, defaults to zero
+            upper_bound : array_like
+                Upper bound of box, defaults to one
+
+    regularization : string or None
+        Preset regularization. Can be set to "l1". Required for use in Gibbs in future update.
+        For "l1", the following additional parameters can be passed:
+            strength : scalar
+                Regularization parameter, i.e., strength*||x||_1 , defaults to one
+
+    """
+    def __init__(self, mean=None, prec=None, bc_type='zero', order=1, proximal = None, projector = None, constraint = None, regularization = None, **kwargs):
+            
+            args = {"lower_bound" : kwargs.pop("lower_bound", None),
+                    "upper_bound" : kwargs.pop("upper_bound", None),
+                    "strength" : kwargs.pop("strength", None)}
+            
+            # Underlying explicit GMRF
+            self._gaussian = GMRF(mean, prec, bc_type=bc_type, order=order, **kwargs)
+            
+            # Init from abstract distribution class
+            super(Distribution, self).__init__(**kwargs)
+
+            self._parse_regularization_input_arguments(proximal, projector, constraint, regularization, args)
+
+
+
+class ConstrainedGMRF(RegularizedGMRF):
+    """ Implicit Constrained GMRF (Gaussian Markov Random Field). 
+
+    Defines a so-called implicit prior based on a GMRF distribution with implicit constraints.
+    The constraint can be defined as a preset or in the form of a projector. 
+
+    Precisely one of projector or constraint needs to be provided. Otherwise, an error is raised.
+
+    Can be used as a prior in a posterior which can be sampled with the RegularizedLinearRTO sampler.
+
+    Alias for :class:`~cuqi.implicitprior.RegularizedGMRF` with only constraints available.
+
+    For more details on implicit regularized Gaussian see the following paper:
+
+    [1] Everink, Jasper M., Yiqiu Dong, and Martin S. Andersen. "Sparse Bayesian inference with regularized
+    Gaussian distributions." Inverse Problems 39.11 (2023): 115004.
+
+    Parameters
+    ----------
+    mean
+        See :class:`~cuqi.distribution.GMRF` for details.
+        
+    prec
+        See :class:`~cuqi.distribution.GMRF` for details.
+
+    bc_type
+        See :class:`~cuqi.distribution.GMRF` for details.
+
+    order
+        See :class:`~cuqi.distribution.GMRF` for details.
+
+    projector : callable f(x) or None
+        Euclidean projection onto the constraint C, that is, a solver for the optimization problem
+        min_(z in C) 0.5||x-z||_2^2.
+
+    constraint : string or None
+        Preset constraints. Can be set to "nonnegativity" and "box". Required for use in Gibbs.
+        For "box", the following additional parameters can be passed:
+            lower_bound : array_like or None
+                Lower bound of box, defaults to zero
+            upper_bound : array_like
+                Upper bound of box, defaults to one
+
+    """
+    def __init__(self, mean=None, prec=None, bc_type='zero', order=1, projector=None, constraint=None, **kwargs):
+        super().__init__(mean=mean, prec=prec, bc_type=bc_type, order=order, projector=projector, constraint=constraint, **kwargs)
+
+        
+class NonnegativeGMRF(RegularizedGMRF):
+    """ Implicit Nonnegative GMRF (Gaussian Markov Random Field). 
+
+    Defines a so-called implicit prior based on a GMRF distribution with implicit nonnegativity constraints.
+
+    Can be used as a prior in a posterior which can be sampled with the RegularizedLinearRTO sampler.
+
+    Alias for :class:`~cuqi.implicitprior.RegularizedGMRF` with only nonnegativity constraints.
+
+    For more details on implicit regularized Gaussian see the following paper:
+
+    [1] Everink, Jasper M., Yiqiu Dong, and Martin S. Andersen. "Sparse Bayesian inference with regularized
+    Gaussian distributions." Inverse Problems 39.11 (2023): 115004.
+
+    Parameters
+    ----------
+    mean
+        See :class:`~cuqi.distribution.GMRF` for details.
+        
+    prec
+        See :class:`~cuqi.distribution.GMRF` for details.
+
+    bc_type
+        See :class:`~cuqi.distribution.GMRF` for details.
+
+    order
+        See :class:`~cuqi.distribution.GMRF` for details.
+
+    """
+    def __init__(self, mean=None, prec=None, bc_type='zero', order=1, **kwargs):
+        super().__init__(mean=mean, prec=prec, bc_type=bc_type, order=order, constraint="nonnegativity", **kwargs)

{cuqipy-1.0.0.post0.dev360 → cuqipy-1.0.0.post0.dev384}/cuqi/implicitprior/_regularizedGaussian.py

@@ -234,3 +234,90 @@ class RegularizedGaussian(Distribution):
             new_density = new_density.to_likelihood(value)
 
         return new_density
+
+
+class ConstrainedGaussian(RegularizedGaussian):
+    """ Implicit Constrained Gaussian.
+
+    Defines a so-called implicit prior based on a Gaussian distribution with implicit constraints.
+    The constraint can be defined as a preset or in the form of a projector. 
+
+    Precisely one of projector or constraint needs to be provided. Otherwise, an error is raised.
+
+    Can be used as a prior in a posterior which can be sampled with the RegularizedLinearRTO sampler.
+
+    Alias for :class:`~cuqi.implicitprior.RegularizedGaussian` with only constraints available.
+
+    For more details on implicit regularized Gaussian see the following paper:
+
+    [1] Everink, Jasper M., Yiqiu Dong, and Martin S. Andersen. "Sparse Bayesian inference with regularized
+    Gaussian distributions." Inverse Problems 39.11 (2023): 115004.
+
+    Parameters
+    ----------
+    mean
+        See :class:`~cuqi.distribution.Gaussian` for details.
+
+    cov
+        See :class:`~cuqi.distribution.Gaussian` for details.
+
+    prec
+        See :class:`~cuqi.distribution.Gaussian` for details.
+
+    sqrtcov
+        See :class:`~cuqi.distribution.Gaussian` for details.
+
+    sqrtprec
+        See :class:`~cuqi.distribution.Gaussian` for details.
+
+    projector : callable f(x) or None
+        Euclidean projection onto the constraint C, that is, a solver for the optimization problem
+        min_(z in C) 0.5||x-z||_2^2.
+
+    constraint : string or None
+        Preset constraints. Can be set to "nonnegativity" and "box". Required for use in Gibbs.
+        For "box", the following additional parameters can be passed:
+            lower_bound : array_like or None
+                Lower bound of box, defaults to zero
+            upper_bound : array_like
+                Upper bound of box, defaults to one
+
+    """
+    def __init__(self, mean=None, cov=None, prec=None, sqrtcov=None,sqrtprec=None, projector=None, constraint=None, **kwargs):
+        super().__init__(mean=mean, cov=cov, prec=prec, sqrtcov=sqrtcov, sqrtprec=sqrtprec, projector=projector, constraint=constraint, **kwargs)
+
+        
+class NonnegativeGaussian(RegularizedGaussian):
+    """ Implicit Nonnegative Gaussian.
+
+    Defines a so-called implicit prior based on a Gaussian distribution with implicit nonnegativity constraints.
+
+    Can be used as a prior in a posterior which can be sampled with the RegularizedLinearRTO sampler.
+
+    Alias for :class:`~cuqi.implicitprior.RegularizedGaussian` with only nonnegativity constraints.
+
+    For more details on implicit regularized Gaussian see the following paper:
+
+    [1] Everink, Jasper M., Yiqiu Dong, and Martin S. Andersen. "Sparse Bayesian inference with regularized
+    Gaussian distributions." Inverse Problems 39.11 (2023): 115004.
+
+    Parameters
+    ----------
+    mean
+        See :class:`~cuqi.distribution.Gaussian` for details.
+
+    cov
+        See :class:`~cuqi.distribution.Gaussian` for details.
+
+    prec
+        See :class:`~cuqi.distribution.Gaussian` for details.
+
+    sqrtcov
+        See :class:`~cuqi.distribution.Gaussian` for details.
+
+    sqrtprec
+        See :class:`~cuqi.distribution.Gaussian` for details.
+
+    """
+    def __init__(self, mean=None, cov=None, prec=None, sqrtcov=None,sqrtprec=None, **kwargs):
+        super().__init__(mean=mean, cov=cov, prec=prec, sqrtcov=sqrtcov, sqrtprec=sqrtprec, constraint="nonnegativity", **kwargs)

cuqipy-1.0.0.post0.dev384/cuqi/implicitprior/_regularizedUnboundedUniform.py

@@ -0,0 +1,66 @@
+from cuqi.implicitprior import RegularizedGaussian
+from cuqi.distribution import Distribution, Gaussian
+
+import numpy as np
+
+
+class RegularizedUnboundedUniform(RegularizedGaussian):
+        """ Implicit Regularized Unbounded Uniform. 
+
+        Defines a so-called implicit prior with implicit regularization on a Gaussian distribution with zero precision.
+        The regularization can be defined in the form of a proximal operator or a projector.
+        Alternatively, preset constraints and regularization can be used.
+
+        For regularization of the form f(x), provide a single proximal operator.
+
+        Can be used as a prior in a posterior which can be sampled with the RegularizedLinearRTO sampler.
+
+        Alias for :class:`~cuqi.implicitprior.RegularizedGaussian` with zero mean and zero sqrtprec.
+
+        For more details on implicit regularized Gaussian see the following paper:
+
+        [1] Everink, Jasper M., Yiqiu Dong, and Martin S. Andersen. "Sparse Bayesian inference with regularized
+        Gaussian distributions." Inverse Problems 39.11 (2023): 115004.
+
+        Parameters
+        ----------
+        geometry : :class:`~cuqi.geometry.Geometry` or integer
+                The geometry of the underlying variable. Defines the dimension of the distribution. 
+
+        proximal : callable f(x, scale) or None
+                Euclidean proximal operator f of the regularization function g, that is, a solver for the optimization problem
+                min_z 0.5||x-z||_2^2+scale*g(x).
+
+        projector : callable f(x) or None
+                Euclidean projection onto the constraint C, that is, a solver for the optimization problem
+                min_(z in C) 0.5||x-z||_2^2.
+
+        constraint : string or None
+                Preset constraints. Can be set to "nonnegativity" and "box". Required for use in Gibbs.
+                For "box", the following additional parameters can be passed:
+                lower_bound : array_like or None
+                        Lower bound of box, defaults to zero
+                upper_bound : array_like
+                        Upper bound of box, defaults to one
+
+        regularization : string or None
+                Preset regularization. Can be set to "l1". Required for use in Gibbs in future update.
+                For "l1", the following additional parameters can be passed:
+                strength : scalar
+                        Regularization parameter, i.e., strength*||x||_1 , defaults to one
+
+        """
+        def __init__(self, geometry, proximal = None, projector = None, constraint = None, regularization = None, **kwargs):
+                
+                args = {"lower_bound" : kwargs.pop("lower_bound", None),
+                        "upper_bound" : kwargs.pop("upper_bound", None),
+                        "strength" : kwargs.pop("strength", None)}
+
+                # Underlying explicit Gaussian
+                # This line throws a warning due trying to applying get_sqrtprec_from_sqrtprec to an all zero matrix  
+                self._gaussian = Gaussian(mean = np.zeros(geometry.par_dim), sqrtprec = np.zeros((geometry.par_dim,geometry.par_dim)), geometry = geometry, **kwargs) 
+
+                # Init from abstract distribution class
+                super(Distribution, self).__init__(**kwargs)
+
+                self._parse_regularization_input_arguments(proximal, projector, constraint, regularization, args)

{cuqipy-1.0.0.post0.dev360 → cuqipy-1.0.0.post0.dev384}/tests/test_distribution.py

@@ -779,4 +779,30 @@ def test_MHN_regression(alpha, beta, gamma, expected_logpdf, expected_gradient):
     logpdf = dist.logpdf(np.array([1.0, 2.0, 3.0, 4.0, 5.0]))
     gradient = dist._gradient(np.array([1.0, 2.0, 3.0, 4.0, 5.0]))
     assert np.allclose( logpdf, np.array(expected_logpdf))
-    assert np.allclose( gradient, np.array(expected_gradient))
+    assert np.allclose( gradient, np.array(expected_gradient))
+
+def test_Smoothed_Laplace():
+    """ Test Smoothed Laplace distribution logpdf and gradient """
+
+    location = np.array([1, 2])
+    scale = np.array([1, 2])
+    scalar_laplace_0 = cuqi.distribution.Laplace(location[0], scale[0])
+
+    scalar_smoothed_laplace_0 = cuqi.distribution.SmoothedLaplace(location[0], scale[0], 1e-8)
+    scalar_smoothed_laplace_1 = cuqi.distribution.SmoothedLaplace(location[1], scale[1], 1e-8)
+    vector_smoothed_laplace = cuqi.distribution.SmoothedLaplace(location, scale, 1e-8)
+
+    x = np.array([3, 4])
+
+    # logpdf (scalar Laplace vs scalar Smoothed Laplace)
+    assert np.allclose(scalar_laplace_0.logpdf([x[0]]), scalar_smoothed_laplace_0.logpdf(x[0]))
+
+    # logpdf (scalar Smoothed Laplace * scalar Smoothed Laplace vs vector Smoothed Laplace)
+    assert np.allclose(scalar_smoothed_laplace_0.logpdf(x[0])+scalar_smoothed_laplace_1.logpdf(x[1]),
+                       vector_smoothed_laplace.logpdf(x))
+    
+    # gradient (scalar Smoothed Laplace vs analytical)
+    assert np.allclose(scalar_smoothed_laplace_0.gradient(x[0]), -1/scale[0])
+
+    # gradient (vector Smoothed Laplace vs analytical)
+    assert np.allclose(vector_smoothed_laplace.gradient(x), -1/scale)

cuqipy-1.0.0.post0.dev384/tests/test_implicit_priors.py

@@ -0,0 +1,70 @@
+import cuqi
+import numpy as np
+import pytest
+
+def test_RegularizedGaussian_default_init():
+    """ Test that the implicit regularized Gaussian requires at least 1 regularization argument """
+
+    with pytest.raises(ValueError, match="Precisely one of "):
+        x = cuqi.implicitprior.RegularizedGaussian(np.zeros(5), 1)
+
+def test_RegularizedGaussian_guarding_statements():
+    """ Test that we catch incorrect initialization of RegularizedGaussian """
+
+    # More than 1 argument
+    with pytest.raises(ValueError, match="Precisely one of "):
+        cuqi.implicitprior.RegularizedGaussian(np.zeros(5), 1, proximal=lambda s,z: s, constraint="nonnegativity")
+
+    # Proximal
+    with pytest.raises(ValueError, match="Proximal needs to be callable"):
+        cuqi.implicitprior.RegularizedGaussian(np.zeros(5), 1, proximal=1)
+
+    with pytest.raises(ValueError, match="Proximal should take 2 arguments"):
+        cuqi.implicitprior.RegularizedGaussian(np.zeros(5), 1, proximal=lambda s: s)
+
+    # Projector
+    with pytest.raises(ValueError, match="Projector needs to be callable"):
+        cuqi.implicitprior.RegularizedGaussian(np.zeros(5), 1, projector=1)
+
+    with pytest.raises(ValueError, match="Projector should take 1 argument"):
+        cuqi.implicitprior.RegularizedGaussian(np.zeros(5), 1, projector=lambda s,z: s)
+
+def test_ConstrainedGaussian_alias():
+    """ Test that the implicit constrained Gaussian is a correct allias for an implicit regularized Gaussian """
+
+    x = cuqi.implicitprior.ConstrainedGaussian(np.zeros(5), 1, constraint="nonnegativity")
+
+    assert isinstance(x, cuqi.implicitprior.RegularizedGaussian)
+    assert x.preset == "nonnegativity"
+
+def test_NonnegativeGaussian_alias():
+    """ Test that the implicit nonnegative Gaussian is a correct allias for an implicit regularized Gaussian """
+
+    x = cuqi.implicitprior.NonnegativeGaussian(np.zeros(5), 1)
+
+    assert isinstance(x, cuqi.implicitprior.RegularizedGaussian)
+    assert x.preset == "nonnegativity"
+
+def test_ConstrainedGMRF_alias():
+    """ Test that the implicit constrained GMRF is a correct allias for an implicit regularized GMRF """
+
+    x = cuqi.implicitprior.ConstrainedGMRF(np.zeros(5), 1, constraint="nonnegativity")
+
+    assert isinstance(x, cuqi.implicitprior.RegularizedGMRF)
+    assert x.preset == "nonnegativity"
+
+def test_NonnegativeGMRF_alias():
+    """ Test that the implicit nonnegative GMRF is a correct allias for an implicit regularized GMRF """
+
+    x = cuqi.implicitprior.NonnegativeGMRF(np.zeros(5), 1)
+
+    assert isinstance(x, cuqi.implicitprior.RegularizedGMRF)
+    assert x.preset == "nonnegativity"
+
+def test_RegularizedUnboundedUniform_is_RegularizedGaussian():
+    """ Test that the implicit regularized unbounded uniform create a Regularized Gaussian with zero sqrtprec """
+    # NOTE: Test is based on the current assumption that the regularized uniform is modeled as a Gaussian with zero precision. This might change in the future.
+
+    x = cuqi.implicitprior.RegularizedUnboundedUniform(cuqi.geometry.Continuous1D(5), regularization="l1", strength = 5.0)
+    
+    assert np.allclose(x.gaussian.sqrtprec, 0.0)

cuqipy-1.0.0.post0.dev360/cuqi/implicitprior/__init__.py

@@ -1,2 +0,0 @@
-from ._regularizedGaussian import RegularizedGaussian
-from ._regularizedGMRF import RegularizedGMRF

cuqipy-1.0.0.post0.dev360/cuqi/implicitprior/_regularizedGMRF.py

@@ -1,70 +0,0 @@
-from cuqi.implicitprior import RegularizedGaussian
-from cuqi.distribution import Distribution, GMRF
-
-class RegularizedGMRF(RegularizedGaussian):
-    """ Implicit Regularized GMRF (Gaussian Markov Random Field). 
-
-    Defines a so-called implicit prior based on a GMRF distribution with implicit regularization.
-    The regularization can be defined in the form of a proximal operator or a projector.
-    Alternatively, preset constraints and regularization can be used.
-
-    Only one of proximal, projector, constraint or regularization can be provided. Otherwise, an error is raised.
-
-    Can be used as a prior in a posterior which can be sampled with the RegularizedLinearRTO sampler.
-
-
-    For more details on implicit regularized Gaussian see the following paper:
-
-    [1] Everink, Jasper M., Yiqiu Dong, and Martin S. Andersen. "Sparse Bayesian inference with regularized
-    Gaussian distributions." Inverse Problems 39.11 (2023): 115004.
-
-    Parameters
-    ----------
-    mean
-        See :class:`~cuqi.distribution.GMRF` for details.
-        
-    prec
-        See :class:`~cuqi.distribution.GMRF` for details.
-
-    bc_type
-        See :class:`~cuqi.distribution.GMRF` for details.
-
-    order
-        See :class:`~cuqi.distribution.GMRF` for details.
-
-    proximal : callable f(x, scale) or None
-        Euclidean proximal operator f of the regularization function g, that is, a solver for the optimization problem
-        min_z 0.5||x-z||_2^2+scale*g(x).
-
-    projector : callable f(x) or None
-        Euclidean projection onto the constraint C, that is, a solver for the optimization problem
-        min_(z in C) 0.5||x-z||_2^2.
-
-    constraint : string or None
-        Preset constraints. Can be set to "nonnegativity" and "box". Required for use in Gibbs.
-        For "box", the following additional parameters can be passed:
-            lower_bound : array_like or None
-                Lower bound of box, defaults to zero
-            upper_bound : array_like
-                Upper bound of box, defaults to one
-
-    regularization : string or None
-        Preset regularization. Can be set to "l1". Required for use in Gibbs in future update.
-        For "l1", the following additional parameters can be passed:
-            strength : scalar
-                Regularization parameter, i.e., strength*||x||_1 , defaults to one
-
-    """
-    def __init__(self, mean=None, prec=None, bc_type='zero', order=1, proximal = None, projector = None, constraint = None, regularization = None, **kwargs):
-            
-            args = {"lower_bound" : kwargs.pop("lower_bound", None),
-                    "upper_bound" : kwargs.pop("upper_bound", None),
-                    "strength" : kwargs.pop("strength", None)}
-            
-            # Underlying explicit GMRF
-            self._gaussian = GMRF(mean, prec, bc_type=bc_type, order=order, **kwargs)
-            
-            # Init from abstract distribution class
-            super(Distribution, self).__init__(**kwargs)
-
-            self._parse_regularization_input_arguments(proximal, projector, constraint, regularization, args)

cuqipy-1.0.0.post0.dev360/tests/test_implicit_priors.py

@@ -1,30 +0,0 @@
-import cuqi
-import numpy as np
-import pytest
-
-def test_RegularizedGaussian_default_init():
-    """ Test that the implicit regularized Gaussian requires at least 1 regularization argument """
-
-    with pytest.raises(ValueError, match="Precisely one of "):
-        x = cuqi.implicitprior.RegularizedGaussian(np.zeros(5), 1)
-
-def test_RegularizedGaussian_guarding_statements():
-    """ Test that we catch incorrect initialization of RegularizedGaussian """
-
-    # More than 1 argument
-    with pytest.raises(ValueError, match="Precisely one of "):
-        cuqi.implicitprior.RegularizedGaussian(np.zeros(5), 1, proximal=lambda s,z: s, constraint="nonnegativity")
-
-    # Proximal
-    with pytest.raises(ValueError, match="Proximal needs to be callable"):
-        cuqi.implicitprior.RegularizedGaussian(np.zeros(5), 1, proximal=1)
-
-    with pytest.raises(ValueError, match="Proximal should take 2 arguments"):
-        cuqi.implicitprior.RegularizedGaussian(np.zeros(5), 1, proximal=lambda s: s)
-
-    # Projector
-    with pytest.raises(ValueError, match="Projector needs to be callable"):
-        cuqi.implicitprior.RegularizedGaussian(np.zeros(5), 1, projector=1)
-
-    with pytest.raises(ValueError, match="Projector should take 1 argument"):
-        cuqi.implicitprior.RegularizedGaussian(np.zeros(5), 1, projector=lambda s,z: s)