CUQIpy 1.2.0.post0.dev446__py3-none-any.whl → 1.2.0.post0.dev501__py3-none-any.whl

{CUQIpy-1.2.0.post0.dev446.dist-info → CUQIpy-1.2.0.post0.dev501.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: CUQIpy
-Version: 1.2.0.post0.dev446
+Version: 1.2.0.post0.dev501
 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.dev446.dist-info → CUQIpy-1.2.0.post0.dev501.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=ukIYDW0D_LdEgCoVq2KQxRE9HDsW1NNxfWZNFz2Syds,510
+cuqi/_version.py,sha256=-wStiLQQiCB-PTnm1EIuY2Bqw9TKX4zIsPlS3OkQHg8,510
 cuqi/config.py,sha256=wcYvz19wkeKW2EKCGIKJiTpWt5kdaxyt4imyRkvtTRA,526
 cuqi/diagnostics.py,sha256=5OrbJeqpynqRXOe5MtOKKhe7EAVdOEpHIqHnlMW9G_c,3029
 cuqi/array/__init__.py,sha256=-EeiaiWGNsE3twRS4dD814BIlfxEsNkTCZUc5gjOXb0,30
@@ -28,22 +28,22 @@ cuqi/distribution/_joint_distribution.py,sha256=vadRTOpQh1skAgnf-f2-2e6IMvoH2d8b
 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
-cuqi/distribution/_modifiedhalfnormal.py,sha256=eCg9YhH-zyX25V5WqdBwQykwG_90lm5Qc2901z7jFUE,7390
+cuqi/distribution/_modifiedhalfnormal.py,sha256=ErULXUFRjbMyCYywaOzfuxtoy-XQmC0McMROo2mTQtc,7313
 cuqi/distribution/_normal.py,sha256=vhIiAseW09IKh1uy0KUq7RP1IuY7hH5aNM1W_R8Gd_Q,2912
 cuqi/distribution/_posterior.py,sha256=zAfL0GECxekZ2lBt1W6_LN0U_xskMwK4VNce5xAF7ig,5018
 cuqi/distribution/_smoothed_laplace.py,sha256=p-1Y23mYA9omwiHGkEuv3T2mwcPAAoNlCr7T8osNkjE,2925
 cuqi/distribution/_truncated_normal.py,sha256=sZkLYgnkGOyS_3ZxY7iw6L62t-Jh6shzsweRsRepN2k,4240
 cuqi/distribution/_uniform.py,sha256=KA8yQ6ZS3nQGS4PYJ4hpDg6Eq8EQKQvPsIpYfR8fj2w,1967
-cuqi/experimental/__init__.py,sha256=6PFlmAkWuxWhzVrZz2g10tBBDuH5542G02nIRQfQCNg,128
+cuqi/experimental/__init__.py,sha256=bIQ9OroeitHbwgNe3wI_JvzkILK0N25Tt7wpquPoU3w,129
 cuqi/experimental/algebra/__init__.py,sha256=btRAWG58ZfdtK0afXKOg60AX7d76KMBjlZa4AWBCCgU,81
 cuqi/experimental/algebra/_ast.py,sha256=PdPz19cJMjvnMx4KEzhn4gvxIZX_UViE33Mbttj_5Xw,9873
 cuqi/experimental/algebra/_orderedset.py,sha256=fKysh4pmI4xF7Y5Z6O86ABzg20o4uBs-v8jmLBMrdpo,2849
-cuqi/experimental/algebra/_randomvariable.py,sha256=1VwJjsF5PPmkchGa7mbNCcAgnt19olkvMeHCRAvEVtk,18911
+cuqi/experimental/algebra/_randomvariable.py,sha256=isbFtIWsWXF-yF5Vb56nLy4MCkQM6akjd-dQau4wfbE,19725
 cuqi/experimental/geometry/__init__.py,sha256=kgoKegfz3Jhr7fpORB_l55z9zLZRtloTLyXFDh1oF2o,47
 cuqi/experimental/geometry/_productgeometry.py,sha256=G-hIYnfLiRS5IWD2EPXORNBKNP2zSaCCHAeBlDC_R3I,7177
 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
+cuqi/experimental/mcmc/_conjugate.py,sha256=MT_On2figPyYPVwrL19ocRFzfcJIvG2SDr3yRSmCSno,18971
+cuqi/experimental/mcmc/_conjugate_approx.py,sha256=jmxe2FEbO9fwpc8opyjJ2px0oed3dGyj0qDwyHo4aOk,3545
 cuqi/experimental/mcmc/_cwmh.py,sha256=50v3uZaWhlVnfrEB5-lB_7pn8QoUVBe-xWxKGKbmNHg,7234
 cuqi/experimental/mcmc/_direct.py,sha256=9pQS_2Qk2-ybt6m8WTfPoKetcxQ00WaTRN85-Z0FrBY,777
 cuqi/experimental/mcmc/_gibbs.py,sha256=evgxf2tLFLlKB3hN0qz9a9NcZQSES8wdacnn3uNWocQ,12005
@@ -58,9 +58,9 @@ cuqi/experimental/mcmc/_utilities.py,sha256=kUzHbhIS3HYZRbneNBK41IogUYX5dS_bJxqE
 cuqi/geometry/__init__.py,sha256=Tz1WGzZBY-QGH3c0GiyKm9XHN8MGGcnU6TUHLZkzB3o,842
 cuqi/geometry/_geometry.py,sha256=tsWMca6E-KEXwr_LhjwP7Lsdi5TWCyu0T956Cj5LEXQ,47091
 cuqi/implicitprior/__init__.py,sha256=6z3lvw-tWDyjZSpB3pYzvijSMK9Zlf1IYqOVTtMD2h4,309
-cuqi/implicitprior/_regularizedGMRF.py,sha256=rr3R2C1aheuu_KD35MureZKfOwY8O1pkVDHvuaFnFFU,6300
-cuqi/implicitprior/_regularizedGaussian.py,sha256=btpjKUG1byLSu7S3J8N1MZZBuskCEIdmatMASwQEHtE,15656
-cuqi/implicitprior/_regularizedUnboundedUniform.py,sha256=H2fTOSqYTlDiLxQ7Ya6wnpCUIkpO4qKrkTOsOPnBBeU,3483
+cuqi/implicitprior/_regularizedGMRF.py,sha256=Ck1JGo8jTb-Z8zDQl4-shMEB2_T0Az9fBpbxDjwatRU,6308
+cuqi/implicitprior/_regularizedGaussian.py,sha256=QlaloekbKojhdXVdmSEFwq__T15XoKBt3uL75mdi0KU,14935
+cuqi/implicitprior/_regularizedUnboundedUniform.py,sha256=Ez7TuyR3Y9Km4qeqGnUJl5tQ8-G3assAQm_id4yBNlI,3491
 cuqi/implicitprior/_restorator.py,sha256=Z350XUJEt7N59Qw-SIUaBljQNDJk4Zb0i_KRFrt2DCg,10087
 cuqi/likelihood/__init__.py,sha256=QXif382iwZ5bT3ZUqmMs_n70JVbbjxbqMrlQYbMn4Zo,1776
 cuqi/likelihood/_likelihood.py,sha256=PuW8ufRefLt6w40JQWqNnEh3YCLxu4pz0h0PcpT8inc,7075
@@ -71,7 +71,7 @@ cuqi/operator/_operator.py,sha256=yNwPTh7jR07AiKMbMQQ5_54EgirlKFsbq9JN1EODaQI,88
 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=XyJ_MZbVFUiiywUM-mrra3tUD_QMRK_kXLj4xVqRgAc,38169
+cuqi/problem/_problem.py,sha256=31ByO279-6hM8PhWjwD5k7i9aBAkk9S1tcgMzxv1PiQ,38256
 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
@@ -87,14 +87,14 @@ 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=KYgAi_8VoAwljTB3S2I87YnJkRtedskLee7hQp_-zp8,220
-cuqi/solver/_solver.py,sha256=hGOFEJ74s0qHvXwt8h0JBdnqE5LGa_yZzNB9cd8zPAs,30661
+cuqi/solver/_solver.py,sha256=_Q47Atv8Ze6eMJzA22s0OzdW4lcDigRhbotnCzmrQWE,30662
 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/__init__.py,sha256=RB84VstmFcZgPOz58LKSzOvCVebbeKDcKl9MGk-EwoA,515
 cuqi/utilities/_get_python_variable_name.py,sha256=wxpCaj9f3ZtBNqlGmmuGiITgBaTsY-r94lUIlK6UAU4,2043
-cuqi/utilities/_utilities.py,sha256=Jc4knn80vLoA7kgw9FzXwKVFGaNBOXiA9kgvltZU3Ao,11777
-CUQIpy-1.2.0.post0.dev446.dist-info/LICENSE,sha256=kJWRPrtRoQoZGXyyvu50Uc91X6_0XRaVfT0YZssicys,10799
-CUQIpy-1.2.0.post0.dev446.dist-info/METADATA,sha256=z-UvrfRd531Ja_erEONzN_pqzmd6u3_zh14VnObY3y0,18529
-CUQIpy-1.2.0.post0.dev446.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-CUQIpy-1.2.0.post0.dev446.dist-info/top_level.txt,sha256=AgmgMc6TKfPPqbjV0kvAoCBN334i_Lwwojc7HE3ZwD0,5
-CUQIpy-1.2.0.post0.dev446.dist-info/RECORD,,
+cuqi/utilities/_utilities.py,sha256=gc9YAj7wFKzyZTE1H5iI_1Tt4AtjT1g5l1-zxBdH-Co,15281
+CUQIpy-1.2.0.post0.dev501.dist-info/LICENSE,sha256=kJWRPrtRoQoZGXyyvu50Uc91X6_0XRaVfT0YZssicys,10799
+CUQIpy-1.2.0.post0.dev501.dist-info/METADATA,sha256=qAa9TTLdoTmo7L8fOcRrE_9sj6Sfk2z2DpfCY8eitD0,18529
+CUQIpy-1.2.0.post0.dev501.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+CUQIpy-1.2.0.post0.dev501.dist-info/top_level.txt,sha256=AgmgMc6TKfPPqbjV0kvAoCBN334i_Lwwojc7HE3ZwD0,5
+CUQIpy-1.2.0.post0.dev501.dist-info/RECORD,,

cuqi/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-01-20T14:37:50+0100",
+ "date": "2025-01-30T19:07:50+0100",
  "dirty": false,
  "error": null,
- "full-revisionid": "04ade2ac5f81fefc462cb802ec723be5f10e0f0a",
- "version": "1.2.0.post0.dev446"
+ "full-revisionid": "ead079a625cad175f6a0159d46c90d7cdf80bc0f",
+ "version": "1.2.0.post0.dev501"
 }
 '''  # END VERSION_JSON
 

cuqi/distribution/_modifiedhalfnormal.py

@@ -24,13 +24,13 @@ class ModifiedHalfNormal(Distribution):
     
     Parameters
     ----------
-    alpha : float
+    alpha : float or array_like
         The polynomial exponent parameter :math:`\\alpha` of the MHN distribution. Must be positive.
 
-    beta : float
+    beta : float or array_like
         The quadratic exponential parameter :math:`\\beta` of the MHN distribution. Must be positive.
 
-    gamma : float
+    gamma : float or array_like
         The linear exponential parameter :math:`\\gamma` of the MHN distribution.
 
     """
@@ -38,9 +38,9 @@ class ModifiedHalfNormal(Distribution):
         # 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):
@@ -48,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):
@@ -63,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):
@@ -78,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.
@@ -180,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/experimental/__init__.py

@@ -1,4 +1,4 @@
-""" Experimental module for testing new features and ideas. """
+""" Experimental module for testing new features and ideas.  """
 from . import mcmc
 from . import algebra
 from . import geometry

cuqi/experimental/algebra/_randomvariable.py

@@ -6,6 +6,8 @@ import operator
 import cuqi
 from cuqi.distribution import Distribution
 from copy import copy, deepcopy
+import numpy as np
+
 
 class RandomVariable:
     """ Random variable defined by a distribution with the option to apply algebraic operations on it.
@@ -165,6 +167,30 @@ class RandomVariable:
             raise ValueError(f"Expected arguments {self.parameter_names}, got arguments {kwargs}")
 
         return self.tree(**kwargs)
+
+    def sample(self, N=1):
+        """ Sample from the random variable. 
+
+        Parameters
+        ----------
+        N : int, optional
+            Number of samples to draw. Default is 1.
+        """
+
+        if self.is_cond:
+            raise NotImplementedError(
+                "Unable to directly sample from a random variable that has distributions with "
+                "conditioning variables. This is not implemented."
+            )
+
+        if N == 1: return self(**{dist.name: dist.sample() for dist in self.distributions})
+            
+        samples = np.array([
+            self(**{dist.name: dist.sample() for dist in self.distributions})
+            for _ in range(N)
+        ]).reshape(-1, N)  # Ensure correct shape (dim, N)
+
+        return cuqi.samples.Samples(samples)
     
     @property
     def tree(self):

cuqi/experimental/mcmc/_conjugate.py

@@ -2,9 +2,10 @@ import numpy as np
 from abc import ABC, abstractmethod
 import math
 from cuqi.experimental.mcmc import Sampler
-from cuqi.distribution import Posterior, Gaussian, Gamma, GMRF
-from cuqi.implicitprior import RegularizedGaussian, RegularizedGMRF
-from cuqi.utilities import get_non_default_args
+from cuqi.distribution import Posterior, Gaussian, Gamma, GMRF, ModifiedHalfNormal
+from cuqi.implicitprior import RegularizedGaussian, RegularizedGMRF, RegularizedUnboundedUniform
+from cuqi.utilities import get_non_default_args, count_nonzero, count_constant_components_1D, count_constant_components_2D
+from cuqi.geometry import Continuous1D, Continuous2D, Image2D
 
 class Conjugate(Sampler):
     """ Conjugate sampler
@@ -14,10 +15,12 @@ class Conjugate(Sampler):
     Currently supported conjugate pairs are:
     - (Gaussian, Gamma) where Gamma is defined on the precision parameter of the Gaussian
     - (GMRF, Gamma) where Gamma is defined on the precision parameter of the GMRF
-    - (RegularizedGaussian, Gamma) with nonnegativity constraints only and Gamma is defined on the precision parameter of the RegularizedGaussian
-    - (RegularizedGMRF, Gamma) with nonnegativity constraints only and Gamma is defined on the precision parameter of the RegularizedGMRF
+    - (RegularizedGaussian, Gamma) with preset constraints only and Gamma is defined on the precision parameter of the RegularizedGaussian
+    - (RegularizedGMRF, Gamma) with preset constraints only and Gamma is defined on the precision parameter of the RegularizedGMRF
+    - (RegularizedGaussian, ModifiedHalfNormal) with preset constraints and regularization only
+    - (RegularizedGMRF, ModifiedHalfNormal) with preset constraints and regularization only
 
-    Currently the Gamma distribution must be univariate.
+    Currently the Gamma and ModifiedHalfNormal distribution must be univariate.
 
     A conjugate pair defines implicitly a so-called conjugate distribution which can be sampled from directly.
 
@@ -25,9 +28,10 @@ class Conjugate(Sampler):
 
     For more information on conjugacy and conjugate distributions see https://en.wikipedia.org/wiki/Conjugate_prior.
 
-    For implicit regularized Gaussians see:
+    For implicit regularized Gaussians and the corresponding conjugacy relations, see:
     
-    [1] Everink, Jasper M., Yiqiu Dong, and Martin S. Andersen. "Bayesian inference with projected densities." SIAM/ASA Journal on Uncertainty Quantification 11.3 (2023): 1025-1043.
+    Section 3.3 from [1] Everink, Jasper M., Yiqiu Dong, and Martin S. Andersen. "Bayesian inference with projected densities." SIAM/ASA Journal on Uncertainty Quantification 11.3 (2023): 1025-1043.
+    Section 4 from [2] Everink, Jasper M., Yiqiu Dong, and Martin S. Andersen. "Sparse Bayesian inference with regularized Gaussian distributions." Inverse Problems 39.11 (2023): 115004.
 
     """
 
@@ -63,11 +67,19 @@ class Conjugate(Sampler):
         self._ensure_target_is_posterior()
         if isinstance(self.target.likelihood.distribution, (Gaussian, GMRF)) and isinstance(self.target.prior, Gamma):
             self._conjugatepair = _GaussianGammaPair(self.target)
+        elif isinstance(self.target.likelihood.distribution, RegularizedUnboundedUniform) and isinstance(self.target.prior, Gamma):
+            # Check RegularizedUnboundedUniform before RegularizedGaussian and RegularizedGMRF due to the first inheriting from the second.
+            self._conjugatepair = _RegularizedUnboundedUniformGammaPair(self.target)
         elif isinstance(self.target.likelihood.distribution, (RegularizedGaussian, RegularizedGMRF)) and isinstance(self.target.prior, Gamma):
             self._conjugatepair = _RegularizedGaussianGammaPair(self.target)
+        elif isinstance(self.target.likelihood.distribution, (RegularizedGaussian, RegularizedGMRF)) and isinstance(self.target.prior, ModifiedHalfNormal):
+            self._conjugatepair = _RegularizedGaussianModifiedHalfNormalPair(self.target)
         else:
             raise ValueError(f"Conjugacy is not defined for likelihood {type(self.target.likelihood.distribution)} and prior {type(self.target.prior)}, in CUQIpy")
 
+    def conjugate_distribution(self):
+        return self._conjugatepair.conjugate_distribution()
+
     def __repr__(self):
         msg = super().__repr__()
         if hasattr(self, "_conjugatepair"):
@@ -86,35 +98,36 @@ class _ConjugatePair(ABC):
         pass
 
     @abstractmethod
+    def conjugate_distribution(self):
+        """ Returns the posterior distribution in the form of a CUQIpy distribution """
+        pass
+
     def sample(self):
         """ Sample from the conjugate distribution. """
-        pass
+        return self.conjugate_distribution().sample()
 
 
 class _GaussianGammaPair(_ConjugatePair):
     """ Implementation for the Gaussian-Gamma conjugate pair."""
 
     def validate_target(self):
-        if not isinstance(self.target.likelihood.distribution, (Gaussian, GMRF)):
-            raise ValueError("Conjugate sampler only works with a Gaussian likelihood function")
-
-        if not isinstance(self.target.prior, Gamma):
-            raise ValueError("Conjugate sampler only works with Gamma prior")
-
         if self.target.prior.dim != 1:
-            raise ValueError("Conjugate sampler only works with univariate Gamma prior")
-
-        key, value = _get_conjugate_parameter(self.target)
-        if key == "cov":
-            if not _check_conjugate_parameter_is_scalar_reciprocal(value):
-                raise ValueError("Gaussian-Gamma conjugate pair defined via covariance requires `cov` for the `Gaussian` to be: lambda x : 1.0/x for the conjugate parameter")
-        elif key == "prec":
-            if not _check_conjugate_parameter_is_scalar_identity(value):
-                raise ValueError("Gaussian-Gamma conjugate pair defined via precision requires `prec` for the `Gaussian` to be: lambda x : x for the conjugate parameter")
-        else:
-            raise ValueError("Conjugate sampler for Gaussian likelihood functions only works when conjugate parameter is defined via covariance or precision")
-
-    def sample(self):
+            raise ValueError("Gaussian-Gamma conjugacy only works with univariate Gamma prior")
+
+        key_value_pairs = _get_conjugate_parameter(self.target)
+        if len(key_value_pairs) != 1:
+            raise ValueError(f"Multiple references to conjugate parameter {self.target.prior.name} found in likelihood. Only one occurance is supported.")
+        for key, value in key_value_pairs:
+            if key == "cov":
+                if not _check_conjugate_parameter_is_scalar_linear_reciprocal(value):
+                    raise ValueError("Gaussian-Gamma conjugate pair defined via covariance requires cov: lambda x : s/x for the conjugate parameter")
+            elif key == "prec":
+                if not _check_conjugate_parameter_is_scalar_linear(value):
+                    raise ValueError("Gaussian-Gamma conjugate pair defined via precision requires prec: lambda x : s*x for the conjugate parameter")
+            else:
+                raise ValueError(f"RegularizedGaussian-ModifiedHalfNormal conjugacy does not support the conjugate parameter {self.target.prior.name} in the {key} attribute. Only cov and prec")
+
+    def conjugate_distribution(self):
         # Extract variables
         b = self.target.likelihood.data                                 # mu
         m = len(b)                                                      # n
@@ -124,38 +137,33 @@ class _GaussianGammaPair(_ConjugatePair):
         beta = self.target.prior.rate                                   # beta
 
         # Create Gamma distribution and sample
-        dist = Gamma(shape=m/2 + alpha, rate=.5 * np.linalg.norm(L @ (Ax - b))**2 + beta)
-
-        return dist.sample()
+        return Gamma(shape=m/2 + alpha, rate=.5 * np.linalg.norm(L @ (Ax - b))**2 + beta)
 
 
 class _RegularizedGaussianGammaPair(_ConjugatePair):
-    """Implementation for the Regularized Gaussian-Gamma conjugate pair."""
+    """Implementation for the Regularized Gaussian-Gamma conjugate pair using the conjugacy rules from [1], Section 3.3."""
 
     def validate_target(self):
-        if not isinstance(self.target.likelihood.distribution, (RegularizedGaussian, RegularizedGMRF)):
-            raise ValueError("Conjugate sampler only works with a Regularized Gaussian likelihood function")
-
-        if not isinstance(self.target.prior, Gamma):
-            raise ValueError("Conjugate sampler only works with Gamma prior")
-
         if self.target.prior.dim != 1:
-            raise ValueError("Conjugate sampler only works with univariate Gamma prior")
+            raise ValueError("RegularizedGaussian-Gamma conjugacy only works with univariate ModifiedHalfNormal prior")
 
         if self.target.likelihood.distribution.preset not in ["nonnegativity"]:
-            raise ValueError("Conjugate sampler only works with implicit regularized Gaussian likelihood with nonnegativity constraints")
-
-        key, value = _get_conjugate_parameter(self.target)
-        if key == "cov":
-            if not _check_conjugate_parameter_is_scalar_reciprocal(value):
-                raise ValueError("Regularized Gaussian-Gamma conjugate pair defined via covariance requires cov: lambda x : 1.0/x for the conjugate parameter")
-        elif key == "prec":
-            if not _check_conjugate_parameter_is_scalar_identity(value):
-                raise ValueError("Regularized Gaussian-Gamma conjugate pair defined via precision requires prec: lambda x : x for the conjugate parameter")
-        else:
-            raise ValueError("Conjugate sampler for a Regularized Gaussian likelihood functions only works when conjugate parameter is defined via covariance or precision")
-
-    def sample(self):
+            raise ValueError("RegularizedGaussian-Gamma conjugacy only works with implicit regularized Gaussian likelihood with nonnegativity constraints")
+
+        key_value_pairs = _get_conjugate_parameter(self.target)
+        if len(key_value_pairs) != 1:
+            raise ValueError(f"Multiple references to conjugate parameter {self.target.prior.name} found in likelihood. Only one occurance is supported.")
+        for key, value in key_value_pairs:
+            if key == "cov":
+                if not _check_conjugate_parameter_is_scalar_linear_reciprocal(value):
+                    raise ValueError("Regularized Gaussian-Gamma conjugacy defined via covariance requires cov: lambda x : s/x for the conjugate parameter")
+            elif key == "prec":
+                if not _check_conjugate_parameter_is_scalar_linear(value):
+                    raise ValueError("Regularized Gaussian-Gamma conjugacy defined via precision requires prec: lambda x : s*x for the conjugate parameter")
+            else:
+                raise ValueError(f"RegularizedGaussian-ModifiedHalfNormal conjugacy does not support the conjugate parameter {self.target.prior.name} in the {key} attribute. Only cov and prec")
+
+    def conjugate_distribution(self):
         # Extract variables
         b = self.target.likelihood.data                                 # mu
         m = np.count_nonzero(b)                                         # n
@@ -165,9 +173,107 @@ class _RegularizedGaussianGammaPair(_ConjugatePair):
         beta = self.target.prior.rate                                   # beta
 
         # Create Gamma distribution and sample
-        dist = Gamma(shape=m/2 + alpha, rate=.5 * np.linalg.norm(L @ (Ax - b))**2 + beta)
+        return Gamma(shape=m/2 + alpha, rate=.5 * np.linalg.norm(L @ (Ax - b))**2 + beta)
+    
+    
+class _RegularizedUnboundedUniformGammaPair(_ConjugatePair):
+    """Implementation for the RegularizedUnboundedUniform-ModifiedHalfNormal conjugate pair using the conjugacy rules from [2], Section 4."""
 
-        return dist.sample()
+    def validate_target(self):
+        if self.target.prior.dim != 1:
+            raise ValueError("RegularizedUnboundedUniform-Gamma conjugacy only works with univariate Gamma prior")
+        
+        if self.target.likelihood.distribution.preset not in ["l1", "tv"]:
+            raise ValueError("RegularizedUnboundedUniform-Gamma conjugacy only works with implicit regularized Gaussian likelihood with l1 or tv regularization")
+        
+        key_value_pairs = _get_conjugate_parameter(self.target)
+        if len(key_value_pairs) != 1:
+            raise ValueError(f"Multiple references to conjugate parameter {self.target.prior.name} found in likelihood. Only one occurance is supported.")
+        for key, value in key_value_pairs:
+            if key == "strength":
+                if not _check_conjugate_parameter_is_scalar_linear(value):
+                    raise ValueError("RegularizedUnboundedUniform-Gamma conjugacy defined via strength requires strength: lambda x : s*x for the conjugate parameter")
+            else:
+                raise ValueError(f"RegularizedUnboundedUniform-Gamma conjugacy does not support the conjugate parameter {self.target.prior.name} in the {key} attribute. Only strength is supported")
+
+    def conjugate_distribution(self):
+        # Extract prior variables
+        alpha = self.target.prior.shape
+        beta = self.target.prior.rate
+
+        # Compute likelihood quantities
+        x = self.target.likelihood.data
+        if self.target.likelihood.distribution.preset == "l1":
+            m = count_nonzero(x)
+        elif self.target.likelihood.distribution.preset == "tv" and isinstance(self.target.likelihood.distribution.geometry, Continuous1D):
+            m = count_constant_components_1D(x)
+        elif self.target.likelihood.distribution.preset == "tv" and isinstance(self.target.likelihood.distribution.geometry, (Continuous2D, Image2D)):
+            m = count_constant_components_2D(self.target.likelihood.distribution.geometry.par2fun(x))
+
+        reg_op = self.target.likelihood.distribution._regularization_oper
+        reg_strength = self.target.likelihood.distribution(np.array([1])).strength
+        fx = reg_strength*np.linalg.norm(reg_op@x, ord = 1)
+
+        # Create Gamma distribution
+        return Gamma(shape=m/2 + alpha, rate=fx + beta)
+    
+class _RegularizedGaussianModifiedHalfNormalPair(_ConjugatePair):
+    """Implementation for the Regularized Gaussian-ModifiedHalfNormal conjugate pair using the conjugacy rules from [2], Section 4."""
+
+    def validate_target(self):
+        if self.target.prior.dim != 1:
+            raise ValueError("RegularizedGaussian-ModifiedHalfNormal conjugacy only works with univariate ModifiedHalfNormal prior")
+        
+        if self.target.likelihood.distribution.preset not in ["l1", "tv"]:
+            raise ValueError("RegularizedGaussian-ModifiedHalfNormal conjugacy only works with implicit regularized Gaussian likelihood with l1 or tv regularization")
+
+        key_value_pairs = _get_conjugate_parameter(self.target)
+        if len(key_value_pairs) != 2:
+            raise ValueError(f"Incorrect number of references to conjugate parameter {self.target.prior.name} found in likelihood. Found {len(key_value_pairs)} times, but needs to occur in prec or cov, and in strength")
+        for key, value in key_value_pairs:
+            if key == "strength":
+                if not _check_conjugate_parameter_is_scalar_linear(value):
+                    raise ValueError("RegularizedGaussian-ModifiedHalfNormal conjugacy defined via strength requires strength: lambda x : s*x for the conjugate parameter")
+            elif key == "prec":
+                if not _check_conjugate_parameter_is_scalar_quadratic(value):
+                    raise ValueError("RegularizedGaussian-ModifiedHalfNormal conjugacy defined via precision requires prec: lambda x : s*x for the conjugate parameter")
+            elif key == "cov":
+                if not _check_conjugate_parameter_is_scalar_quadratic_reciprocal(value):
+                    raise ValueError("RegularizedGaussian-ModifiedHalfNormal conjugacy  defined via covariance requires cov: lambda x : s/x for the conjugate parameter")
+            else:
+                raise ValueError(f"RegularizedGaussian-ModifiedHalfNormal conjugacy does not support the conjugate parameter {self.target.prior.name} in the {key} attribute. Only cov, prec and strength are supported")
+
+
+    def conjugate_distribution(self):
+        # Extract prior variables
+        alpha = self.target.prior.alpha
+        beta = self.target.prior.beta
+        gamma = self.target.prior.gamma
+
+        # Compute likelihood variables
+        x = self.target.likelihood.data
+        mu = self.target.likelihood.distribution.mean
+        L = self.target.likelihood.distribution(np.array([1])).sqrtprec
+
+        if self.target.likelihood.distribution.preset == "l1":
+            m = count_nonzero(x)
+        elif self.target.likelihood.distribution.preset == "tv" and isinstance(self.target.likelihood.distribution.geometry, Continuous1D):
+            m = count_constant_components_1D(x)
+        elif self.target.likelihood.distribution.preset == "tv" and isinstance(self.target.likelihood.distribution.geometry, (Continuous2D, Image2D)):
+            m = count_constant_components_2D(self.target.likelihood.distribution.geometry.par2fun(x))
+
+        reg_op = self.target.likelihood.distribution._regularization_oper
+        reg_strength = self.target.likelihood.distribution(np.array([1])).strength
+        fx = reg_strength*np.linalg.norm(reg_op@x, ord = 1)
+
+        # Compute parameters of conjugate distribution
+        conj_alpha = m + alpha
+        conj_beta = 0.5*np.linalg.norm(L @ (mu - x))**2 + beta
+        conj_gamma = -fx + gamma
+
+        # Create conjugate distribution
+        return ModifiedHalfNormal(conj_alpha, conj_beta, conj_gamma)
+    
 
 def _get_conjugate_parameter(target):
     """Extract the conjugate parameter name (e.g. d), and returns the mutable variable that is defined by the conjugate parameter, e.g. cov and its value e.g. lambda d:1/d"""
@@ -180,12 +286,9 @@ def _get_conjugate_parameter(target):
         attr = getattr(target.likelihood.distribution, var_key)
         if callable(attr) and par_name in get_non_default_args(attr):
             found_parameter_pairs.append((var_key, attr))
-    if len(found_parameter_pairs) == 1:
-        return found_parameter_pairs[0]
-    elif len(found_parameter_pairs) > 1:
-        raise ValueError(f"Multiple references of parameter {par_name} found in likelihood function for conjugate sampler with target {target}. This is not supported.")
-    else:
+    if len(found_parameter_pairs) == 0:
         raise ValueError(f"Unable to find conjugate parameter {par_name} in likelihood function for conjugate sampler with target {target}")
+    return found_parameter_pairs
 
 def _check_conjugate_parameter_is_scalar_identity(f):
     """Tests whether a function (scalar to scalar) is the identity (lambda x: x)."""
@@ -195,3 +298,38 @@ def _check_conjugate_parameter_is_scalar_identity(f):
 def _check_conjugate_parameter_is_scalar_reciprocal(f):
     """Tests whether a function (scalar to scalar) is the reciprocal (lambda x : 1.0/x)."""
     return all(math.isclose(f(x), 1.0 / x) for x in [1.0, 10.0, 100.0])
+
+def _check_conjugate_parameter_is_scalar_linear(f):
+    """
+        Tests whether a function (scalar to scalar) is linear (lambda x: s*x for some s).
+        The tests checks whether the function is zero and some finite differences are constant.
+    """
+    test_values = [1.0, 10.0, 100.0]
+    h = 1e-2
+    finite_diffs = [(f(x + h*x)-f(x))/(h*x) for x in test_values]
+    return np.isclose(f(0.0), 0.0) and all(np.allclose(c, finite_diffs[0]) for c in finite_diffs[1:])
+
+def _check_conjugate_parameter_is_scalar_linear_reciprocal(f):
+    """
+        Tests whether a function (scalar to scalar) is a constant times the inverse of the input (lambda x: s/x for some s).
+        The tests checks whether the the reciprocal of the function has constant finite differences.
+    """
+    g = lambda x : 1.0/f(x)
+    test_values = [1.0, 10.0, 100.0]
+    h = 1e-2
+    finite_diffs = [(g(x + h*x)-g(x))/(h*x) for x in test_values]
+    return all(np.allclose(c, finite_diffs[0]) for c in finite_diffs[1:])
+
+def _check_conjugate_parameter_is_scalar_quadratic(f):
+    """
+        Tests whether a function (scalar to scalar) is linear (lambda x: s*x**2 for some s).
+        The tests checks whether the function divided by the parameter is linear
+    """
+    return _check_conjugate_parameter_is_scalar_linear(lambda x: f(x)/x if x != 0.0 else f(0.0))
+
+def _check_conjugate_parameter_is_scalar_quadratic_reciprocal(f):
+    """
+        Tests whether a function (scalar to scalar) is linear (lambda x: s*x**-2 for some s).
+        The tests checks whether the function divided by the parameter is the reciprical of a linear function.
+    """
+    return _check_conjugate_parameter_is_scalar_linear_reciprocal(lambda x: f(x)/x)

cuqi/experimental/mcmc/_conjugate_approx.py

@@ -33,26 +33,23 @@ class _LMRFGammaPair(_ConjugatePair):
     """ Implementation of the conjugate pair (LMRF, Gamma) """
 
     def validate_target(self):
-        if not isinstance(self.target.likelihood.distribution, LMRF):
-            raise ValueError("Approximate conjugate sampler only works with LMRF likelihood function")
-        
-        if not isinstance(self.target.prior, Gamma):
-            raise ValueError("Approximate conjugate sampler with LMRF likelihood only works with Gamma prior")
-        
         if not self.target.prior.dim == 1:
             raise ValueError("Approximate conjugate sampler only works with univariate Gamma prior")
         
         if np.sum(self.target.likelihood.distribution.location) != 0:
             raise ValueError("Approximate conjugate sampler only works with zero mean LMRF likelihood")
         
-        key, value = _get_conjugate_parameter(self.target)
-        if key == "scale":
-            if not _check_conjugate_parameter_is_scalar_reciprocal(value):
-                raise ValueError("Approximate conjugate sampler only works with Gamma prior on the inverse of the scale parameter of the LMRF likelihood")
-        else:
-            raise ValueError(f"No approximate conjugacy defined for likelihood {type(self.target.likelihood.distribution)} and prior {type(self.target.prior)}, in CUQIpy")
+        key_value_pairs = _get_conjugate_parameter(self.target)
+        if len(key_value_pairs) != 1:
+            raise ValueError(f"Multiple references to conjugate parameter {self.target.prior.name} found in likelihood. Only one occurance is supported.")
+        for key, value in key_value_pairs:
+            if key == "scale":
+                if not _check_conjugate_parameter_is_scalar_reciprocal(value):
+                    raise ValueError("Approximate conjugate sampler only works with Gamma prior on the inverse of the scale parameter of the LMRF likelihood")
+            else:
+                raise ValueError(f"No approximate conjugacy defined for likelihood {type(self.target.likelihood.distribution)} and prior {type(self.target.prior)}, in CUQIpy")
         
-    def sample(self):
+    def conjugate_distribution(self):
         # Extract variables
         # Here we approximate the LMRF with a Gaussian
 
@@ -76,6 +73,4 @@ class _LMRFGammaPair(_ConjugatePair):
         beta = self.target.prior.rate                   #beta
 
         # Create Gamma distribution and sample
-        dist = Gamma(shape=d+alpha, rate=np.linalg.norm(Lx)**2+beta)
-
-        return dist.sample()
+        return Gamma(shape=d+alpha, rate=np.linalg.norm(Lx)**2+beta)

cuqi/implicitprior/_regularizedGMRF.py

@@ -50,9 +50,9 @@ class RegularizedGMRF(RegularizedGaussian):
 
     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:
+        For "l1" or "tv", the following additional parameters can be passed:
             strength : scalar
-                Regularization parameter, i.e., strength*||x||_1 , defaults to one
+                Regularization parameter, i.e., strength*||Lx||_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):

cuqi/implicitprior/_regularizedGaussian.py

@@ -5,6 +5,7 @@ from cuqi.geometry import Continuous1D, Continuous2D, Image2D
 from cuqi.operator import FirstOrderFiniteDifference
 
 import numpy as np
+from copy import copy
 
 
 class RegularizedGaussian(Distribution):
@@ -269,29 +270,12 @@ class RegularizedGaussian(Distribution):
             mutable_vars += ["strength"]
         return mutable_vars
     
-    # Overwrite the condition method such that the underlying Gaussian is conditioned in general, except when conditioning on self.name
-    # which means we convert Distribution to Likelihood or EvaluatedDensity.
-    def _condition(self, *args, **kwargs):
-        if self.preset in self.regularization_options():
-            return super()._condition(*args, **kwargs)
-        
-        # Handle positional arguments (similar code as in Distribution._condition)
-        cond_vars = self.get_conditioning_variables()
-        kwargs = self._parse_args_add_to_kwargs(cond_vars, *args, **kwargs)
-
-        # When conditioning, we always do it on a copy to avoid unintentional side effects
-        new_density = self._make_copy()
-
-        # Check if self.name is in the provided keyword arguments.
-        # If so, pop it and store its value.
-        value = kwargs.pop(self.name, None)
-
-        new_density._gaussian = self.gaussian._condition(**kwargs)
-
-        # If self.name was provided, we convert to a likelihood or evaluated density
-        if value is not None:
-            new_density = new_density.to_likelihood(value)
-
+    def _make_copy(self):
+        """ Returns a shallow copy of the density keeping a pointer to the original. """
+        # Using deepcopy would also copy the underlying geometry, which causes a crash because geometries won't match anymore.
+        new_density = copy(self)
+        new_density._gaussian = copy(new_density._gaussian)
+        new_density._original_density = self
         return new_density
 
 

cuqi/implicitprior/_regularizedUnboundedUniform.py

@@ -45,9 +45,9 @@ class RegularizedUnboundedUniform(RegularizedGaussian):
 
         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:
+                For "l1" or "tv", the following additional parameters can be passed:
                 strength : scalar
-                        Regularization parameter, i.e., strength*||x||_1 , defaults to one
+                        Regularization parameter, i.e., strength*||Lx||_1, defaults to one
 
         """
         def __init__(self, geometry, proximal = None, projector = None, constraint = None, regularization = None, **kwargs):

cuqi/problem/_problem.py

@@ -5,7 +5,7 @@ from typing import Tuple
 
 import cuqi
 from cuqi import config
-from cuqi.distribution import Distribution, Gaussian, InverseGamma, LMRF, GMRF, Lognormal, Posterior, Beta, JointDistribution, Gamma, CMRF
+from cuqi.distribution import Distribution, Gaussian, InverseGamma, LMRF, GMRF, Lognormal, Posterior, Beta, JointDistribution, Gamma, ModifiedHalfNormal, CMRF
 from cuqi.implicitprior import RegularizedGaussian, RegularizedGMRF
 from cuqi.density import Density
 from cuqi.model import LinearModel, Model
@@ -923,8 +923,8 @@ class BayesianProblem(object):
             if not isinstance(cond_target, Posterior):
                 raise NotImplementedError(f"Unable to determine sampling strategy for {par_name} with target {cond_target}")
 
-            # Gamma prior, Gaussian likelihood -> Conjugate
-            if self._check_posterior(cond_target, Gamma, (Gaussian, GMRF, RegularizedGaussian, RegularizedGMRF)):
+            # Gamma or ModifiedHalfNormal prior, Gaussian or RegularizedGaussian likelihood -> Conjugate
+            if self._check_posterior(cond_target, (Gamma, ModifiedHalfNormal), (Gaussian, GMRF, RegularizedGaussian, RegularizedGMRF)):
                 if experimental:
                     sampling_strategy[par_name] = cuqi.experimental.mcmc.Conjugate()
                 else:

cuqi/solver/_solver.py

@@ -884,4 +884,4 @@ def ProximalL1(x, gamma):
     x : array_like.
     gamma : scale parameter.
     """
-    return np.multiply(np.sign(x), np.maximum(np.abs(x)-gamma, 0))
+    return np.multiply(np.sign(x), np.maximum(np.abs(x)-gamma, 0))

cuqi/utilities/__init__.py

@@ -12,7 +12,10 @@ from ._utilities import (
     approx_derivative,
     check_if_conditional_from_attr,
     plot_1D_density,
-    plot_2D_density
+    plot_2D_density,
+    count_nonzero,
+    count_constant_components_1D,
+    count_constant_components_2D
 )
 
 from ._get_python_variable_name import _get_python_variable_name

cuqi/utilities/_utilities.py

@@ -344,4 +344,102 @@ def plot_2D_density(density: Density,
     extent = (v1_min-hp_x, v1_max+hp_x, v2_min-hp_y, v2_max+hp_y)
 
     im = plt.imshow(evaluated_density, origin='lower', extent=extent, **kwargs)
-    return im
+    return im
+
+
+
+def count_nonzero(x, threshold = 1e-6):
+        """ Returns the number of values in an array whose absolute value is larger than a specified threshold
+
+        Parameters
+        ----------
+        x : `np.ndarray` 
+            Array to count nonzero elements of.
+
+        threshold : float
+            Theshold for considering a value as nonzero.
+        """
+        return np.sum([np.abs(v) >= threshold for v in x])
+    
+def count_constant_components_1D(x, threshold = 1e-2, lower = -np.inf, upper = np.inf):
+        """ Returns the number of piecewise constant components in a one-dimensional array
+
+        Parameters
+        ----------
+        x : `np.ndarray` 
+            1D Array to count components of.
+
+        threshold : float
+            Strict theshold on when the difference of neighbouring values is considered zero.
+
+        lower : float
+            Piecewise constant components below this value are not counted.
+
+        upper : float
+            Piecewise constant components above this value are not counted.
+        """
+
+        counter = 0
+        if x[0] > lower and x[0] < upper:
+            counter += 1
+        
+        x_previous = x[0]
+
+        for x_current in x[1:]:
+            if (abs(x_previous - x_current) >= threshold and
+                x_current > lower and
+                x_current < upper):
+                    counter += 1
+
+            x_previous = x_current
+    
+        return counter
+        
+def count_constant_components_2D(x, threshold = 1e-2, lower = -np.inf, upper = np.inf):
+        """ Returns the number of piecewise constant components in a two-dimensional array
+
+        Parameters
+        ----------
+        x : `np.ndarray` 
+            2D Array to count components of.
+
+        threshold : float
+            Strict theshold on when the difference of neighbouring values is considered zero.
+
+        lower : float
+            Piecewise constant components below this value are not counted.
+
+        upper : float
+            Piecewise constant components above this value are not counted.
+        """
+        filled = np.zeros_like(x, dtype = int)
+        counter = 0
+
+        def process(i, j):
+            queue = []
+            queue.append((i,j))
+            filled[i, j] = 1
+            while len(queue) != 0:
+                (icur, jcur) = queue.pop(0)
+                
+                if icur > 0 and filled[icur - 1, jcur] == 0 and abs(x[icur, jcur] - x[icur - 1, jcur]) <= threshold:
+                    filled[icur - 1, jcur] = 1
+                    queue.append((icur-1, jcur))
+                if jcur > 0 and filled[icur, jcur-1] == 0 and abs(x[icur, jcur] - x[icur, jcur - 1]) <= threshold:
+                    filled[icur, jcur-1] = 1
+                    queue.append((icur, jcur-1))
+                if icur < x.shape[0]-1 and filled[icur + 1, jcur] == 0 and abs(x[icur, jcur] - x[icur + 1, jcur]) <= threshold:
+                    filled[icur + 1, jcur] = 1
+                    queue.append((icur+1, jcur))
+                if jcur < x.shape[1]-1 and filled[icur, jcur + 1] == 0 and abs(x[icur, jcur] - x[icur, jcur + 1]) <= threshold:
+                    filled[icur, jcur + 1] = 1
+                    queue.append((icur, jcur+1))
+        
+        for i in range(x.shape[0]):
+            for j in range(x.shape[1]):
+                if filled[i,j] == 0:
+                    if x[i,j] > lower and x[i,j] < upper:
+                        counter += 1
+                    process(i, j)
+        return counter
+