aptapy 0.3.1__tar.gz → 0.4.0__tar.gz

{aptapy-0.3.1 → aptapy-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aptapy
-Version: 0.3.1
+Version: 0.4.0
 Summary: Statistical tools for online monitoring and analysis
 Project-URL: Homepage, https://github.com/lucabaldini/aptapy
 Project-URL: Issues, https://github.com/lucabaldini/aptapy/issues
@@ -713,7 +713,6 @@ Description-Content-Type: text/markdown
 ![License](https://img.shields.io/github/license/lucabaldini/aptapy.svg)
 [![CI](https://github.com/lucabaldini/aptapy/actions/workflows/ci.yml/badge.svg)](https://github.com/lucabaldini/aptapy/actions/workflows/ci.yml)
 [![Docs](https://github.com/lucabaldini/aptapy/actions/workflows/docs.yml/badge.svg)](https://github.com/lucabaldini/aptapy/actions/workflows/docs.yml)
-[![Docs](https://img.shields.io/badge/docs-latest-blue.svg)](https://lucabaldini.github.io/aptapy/)
 ![GitHub last commit](https://img.shields.io/github/last-commit/lucabaldini/aptapy)
 
 [![Ceasefire Now](https://badge.techforpalestine.org/default)](https://techforpalestine.org/learn-more)

{aptapy-0.3.1 → aptapy-0.4.0}/README.md

@@ -5,7 +5,6 @@
 ![License](https://img.shields.io/github/license/lucabaldini/aptapy.svg)
 [![CI](https://github.com/lucabaldini/aptapy/actions/workflows/ci.yml/badge.svg)](https://github.com/lucabaldini/aptapy/actions/workflows/ci.yml)
 [![Docs](https://github.com/lucabaldini/aptapy/actions/workflows/docs.yml/badge.svg)](https://github.com/lucabaldini/aptapy/actions/workflows/docs.yml)
-[![Docs](https://img.shields.io/badge/docs-latest-blue.svg)](https://lucabaldini.github.io/aptapy/)
 ![GitHub last commit](https://img.shields.io/github/last-commit/lucabaldini/aptapy)
 
 [![Ceasefire Now](https://badge.techforpalestine.org/default)](https://techforpalestine.org/learn-more)

{aptapy-0.3.1 → aptapy-0.4.0}/docs/examples/constrained_fit.py

@@ -19,9 +19,9 @@ hist.fill(np.random.default_rng().normal(size=100000))
 hist.plot()
 
 model = Gaussian()
-# Fix the prefactor to the histogram area---note this only works because the
-# Gaussian model is normalized to 1 over the full range when the prefactor is 1.
-model.prefactor.freeze(hist.area())
+# Fix the prefactor. This is a generally useful technique, as you should
+# never fit the normalization of a histogram.
+model.prefactor.freeze(hist.area() / model.integral(-5., 5.))
 model.fit_histogram(hist)
 print(model)
 model.plot()

aptapy-0.4.0/docs/examples/simple_hist2d.py

@@ -0,0 +1,22 @@
+"""
+Simple 2-D histogram
+====================
+
+Simple two-dimensional histogram filled with bivariate gaussians random numbers.
+"""
+
+# %%
+
+import numpy as np
+
+from aptapy.hist import Histogram2d
+from aptapy.plotting import plt
+
+edges = np.linspace(-5., 5., 100)
+hist = Histogram2d(edges, edges, label="Random data", xlabel="x", ylabel="y")
+x= np.random.default_rng().normal(loc=1., size=100000)
+y= np.random.default_rng().normal(loc=-1., size=100000)
+hist.fill(x, y)
+hist.plot()
+
+plt.gca().set_aspect("equal")

{aptapy-0.3.1 → aptapy-0.4.0}/docs/release_notes.rst

@@ -4,9 +4,39 @@ Release notes
 =============
 
 
+Version 0.4.0 (2025-10-11)
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+
+* Added 2-dimensional histogram example.
+* Adds several new model classes (Quadratic, PowerLaw, Exponential, Erf, ErfInverse).
+* Implements analytical integration methods for models where possible, with a fallback
+  to numerical integration in the base class.
+* Updates the FitStatus class with a completion check method.
+
+* Pull requests merged:
+
+  - https://github.com/lucabaldini/aptapy/pull/7
+
+
+Version 0.3.2 (2025-10-09)
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+* Adding binned_statistics method in AbstractHistogram base class to calculate
+  statistics from histogram bins
+* Adds extensive test coverage in both 1D and 2D histogram test functions with
+  statistical validation
+
+* Pull requests merged:
+
+  - https://github.com/lucabaldini/aptapy/pull/6
+
+
 Version 0.3.1 (2025-10-09)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
+* Minor changes.
+
 
 Version 0.3.0 (2025-10-08)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~

aptapy-0.4.0/src/aptapy/_version.py

@@ -0,0 +1 @@
+__version__ = "0.4.0"

{aptapy-0.3.1 → aptapy-0.4.0}/src/aptapy/hist.py

@@ -17,13 +17,17 @@
 """
 
 from abc import ABC, abstractmethod
-from typing import List, Sequence
+from typing import List, Sequence, Tuple
 
 import numpy as np
 
 from .plotting import matplotlib, plt, setup_axes
 from .typing_ import ArrayLike
 
+__all__ = [
+    "Histogram1d",
+    "Histogram2d",
+]
 
 class AbstractHistogram(ABC):
 
@@ -93,6 +97,43 @@ class AbstractHistogram(ABC):
         """
         return np.diff(self._edges[axis])
 
+    def binned_statistics(self, axis: int = 0) -> Tuple[float, float]:
+        """Return the mean and standard deviation along a specific axis, based
+        on the binned data.
+
+        .. note::
+
+           This is a crude estimate of the underlying statistics that might be
+           useful for monitoring purposes, but should not be relied upon for
+           quantitative analysis.
+
+           This is not the same as computing the mean and standard deviation of
+           the unbinned data that filled the histogram, as some information is
+           lost in the binning process.
+
+           In addition, note that we are not applying any bias correction to
+           the standard deviation, as we are assuming that the histogram is
+           filled with a sufficiently large number of entries. (In most circumstances
+           the effect should be smaller than that of the binning itself.)
+
+        Arguments
+        ---------
+        axis : int
+            the axis along which to compute the statistics.
+
+        Returns
+        -------
+        mean : float
+            the mean value along the specified axis.
+        stddev : float
+            the standard deviation along the specified axis.
+        """
+        values = self.bin_centers(axis)
+        weights = self.content.sum(axis=tuple(i for i in range(self.content.ndim) if i != axis))
+        mean = np.average(values, weights=weights)
+        variance = np.average((values - mean)**2, weights=weights)
+        return float(mean), float(np.sqrt(variance))
+
     def fill(self, *values: ArrayLike, weights: ArrayLike = None) -> "AbstractHistogram":
         """Fill the histogram from unbinned data.
 
@@ -229,10 +270,18 @@ class Histogram1d(AbstractHistogram):
         """
         # If we are not explicitly providing a label at plotting time, use
         # the one attached to the histogram, if any.
-        kwargs.setdefault('label', self.label)
+        kwargs.setdefault("label", f"{self}")
         axes.hist(self.bin_centers(0), self._edges[0], weights=self.content, **kwargs)
         setup_axes(axes, xlabel=self.axis_labels[0], ylabel=self.axis_labels[1])
 
+    def __str__(self) -> str:
+        """String formatting.
+        """
+        mean, rms = self.binned_statistics()
+        text = self.label or self.__class__.__name__
+        text = f"{text}\nMean: {mean:g}\nRMS: {rms:g}"
+        return text
+
 
 class Histogram2d(AbstractHistogram):
 
@@ -259,10 +308,10 @@ class Histogram2d(AbstractHistogram):
         the text label for the z axis (default: "Entries/bin").
     """
 
-    DEFAULT_PLOT_OPTIONS = dict(cmap=plt.get_cmap('hot'))
+    DEFAULT_PLOT_OPTIONS = dict(cmap=plt.get_cmap("hot"))
 
     def __init__(self, xedges, yedges, label: str = None, xlabel: str = None,
-                 ylabel: str = None, zlabel: str = 'Entries/bin') -> None:
+                 ylabel: str = None, zlabel: str = "Entries/bin") -> None:
         """Constructor.
         """
         super().__init__((xedges, yedges), label, [xlabel, ylabel, zlabel])
@@ -272,9 +321,9 @@ class Histogram2d(AbstractHistogram):
         """
         # pylint: disable=arguments-differ
         if logz:
-            vmin = kwargs.pop('vmin', None)
-            vmax = kwargs.pop('vmax', None)
-            kwargs.setdefault('norm', matplotlib.colors.LogNorm(vmin, vmax))
+            vmin = kwargs.pop("vmin", None)
+            vmax = kwargs.pop("vmax", None)
+            kwargs.setdefault("norm", matplotlib.colors.LogNorm(vmin, vmax))
         mappable = axes.pcolormesh(*self._edges, self.content.T, **kwargs)
         plt.colorbar(mappable, ax=axes, label=self.axis_labels[2])
         setup_axes(axes, xlabel=self.axis_labels[0], ylabel=self.axis_labels[1])

{aptapy-0.3.1 → aptapy-0.4.0}/src/aptapy/modeling.py

@@ -23,17 +23,31 @@ from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from itertools import chain
 from numbers import Number
-from typing import Callable, Iterator, Sequence, Tuple
+from typing import Callable, Dict, Iterator, Sequence, Tuple
 
 import matplotlib.pyplot as plt
 import numpy as np
 import uncertainties
+from scipy.integrate import quad
 from scipy.optimize import curve_fit
+from scipy.special import erf
 from scipy.stats import chi2
 
 from .hist import Histogram1d
 from .typing_ import ArrayLike
 
+__all__ = [
+    "Constant",
+    "Line",
+    "Quadratic",
+    "PowerLaw",
+    "Exponential",
+    "Gaussian",
+    "Erf",
+    "ErfInverse",
+]
+
+# pylint: disable=too-many-lines
 
 class Format(str, enum.Enum):
 
@@ -277,6 +291,17 @@ class FitStatus:
         self.pvalue = None
         self.fit_range = None
 
+    def valid(self) -> bool:
+        """Return True if the fit status is valid, i.e., if the chisquare,
+        dof, and pvalue are all set.
+
+        Returns
+        -------
+        valid : bool
+            True if the fit status is valid.
+        """
+        return self.chisquare is not None and self.dof is not None and self.pvalue is not None
+
     def update(self, chisquare: float, dof: int = None) -> None:
         """Update the fit status, i.e., set the chisquare and calculate the
         corresponding p-value.
@@ -316,10 +341,10 @@ class FitStatus:
         if self.chisquare is None:
             return "N/A"
         if spec.endswith(Format.LATEX):
-            return f"$\\chi^2$ = {self.chisquare:.2f} / {self.dof} dof"
+            return f"$\\chi^2$: {self.chisquare:.2f} / {self.dof} dof"
         if spec.endswith(Format.PRETTY):
-            return f"χ² = {self.chisquare:.2f} / {self.dof} dof"
-        return f"chisquare = {self.chisquare:.2f} / {self.dof} dof"
+            return f"χ²: {self.chisquare:.2f} / {self.dof} dof"
+        return f"chisquare: {self.chisquare:.2f} / {self.dof} dof"
 
     def __str__(self) -> str:
         """String formatting.
@@ -776,7 +801,7 @@ class AbstractFitModelBase(ABC):
             The formatted string.
         """
         text = f"{self.name()}\n"
-        if self.status is not None:
+        if self.status.valid():
             text = f"{text}{format(self.status, spec)}\n"
         for parameter in self:
             text = f"{text}{format(parameter, spec)}\n"
@@ -807,13 +832,47 @@ class AbstractFitModel(AbstractFitModelBase):
         """
         super().__init__()
         self._parameters = []
-        for name, value in self.__class__.__dict__.items():
-            if isinstance(value, FitParameter):
-                parameter = value.copy(name)
-                # Note we also set one instance attribute for each parameter so
-                # that we can use the notation model.parameter
-                setattr(self, name, parameter)
-                self._parameters.append(parameter)
+        # Note we cannot loop over self.__dict__.items() here, as that would
+        # only return the members defined in the actual class, and not the
+        # inherited ones.
+        for name, value in self.__class__._parameter_dict().items():
+            parameter = value.copy(name)
+            # Note we also set one instance attribute for each parameter so
+            # that we can use the notation model.parameter
+            setattr(self, name, parameter)
+            self._parameters.append(parameter)
+
+    @classmethod
+    def _parameter_dict(cls) -> Dict[str, FitParameter]:
+        """Return a dictionary of all the FitParameter objects defined in the class
+        and its base classes.
+
+        This is a subtle one, as what we really want, here, is all members of a class
+        (including inherited ones) that are of a specific type (FitParameter), in the
+        order they were defined. All of these thing are instrumental to make the
+        fit model work, so we need to be careful.
+
+        Also note the we are looping over the MRO in reverse order, so that we
+        preserve the order of definition of the parameters, even when they are
+        inherited from base classes. If a parameter is re-defined in a derived class,
+        the derived class definition takes precedence, as we are using a dictionary
+        to collect the parameters.
+
+        Arguments
+        ---------
+        cls : type
+            The class to inspect.
+
+        Returns
+        -------
+        param_dict : dict
+            A dictionary mapping parameter names to their FitParameter objects.
+        """
+        param_dict = {}
+        for base in reversed(cls.__mro__):
+            param_dict.update({name: value for name, value in base.__dict__.items() if
+                               isinstance(value, FitParameter)})
+        return param_dict
 
     def __len__(self) -> int:
         """Return the `total` number of fit parameters in the model.
@@ -832,6 +891,46 @@ class AbstractFitModel(AbstractFitModelBase):
             raise TypeError(f"{other} is not a fit model")
         return FitModelSum(self, other)
 
+    def quadrature(self, xmin: float, xmax: float) -> float:
+        """Calculate the integral of the model between xmin and xmax using
+        numerical integration.
+
+        Arguments
+        ---------
+        xmin : float
+            The minimum value of the independent variable to integrate over.
+
+        xmax : float
+            The maximum value of the independent variable to integrate over.
+
+        Returns
+        -------
+        integral : float
+            The integral of the model between xmin and xmax.
+        """
+        value, _ = quad(self, xmin, xmax)
+        return value
+
+    def integral(self, xmin: float, xmax: float) -> float:
+        """Default implementation of the integral of the model between xmin and xmax.
+        Subclasses can (and are encouraged to) overload this method with an
+        analytical implementation, when available.
+
+        Arguments
+        ---------
+        xmin : float
+            The minimum value of the independent variable to integrate over.
+
+        xmax : float
+            The maximum value of the independent variable to integrate over.
+
+        Returns
+        -------
+        integral : float
+            The integral of the model between xmin and xmax.
+        """
+        return self.quadrature(xmin, xmax)
+
 
 class FitModelSum(AbstractFitModelBase):
 
@@ -878,6 +977,26 @@ class FitModelSum(AbstractFitModelBase):
             cursor += len(component)
         return value
 
+    def integral(self, xmin: float, xmax: float) -> float:
+        """Calculate the integral of the model between xmin and xmax.
+
+        This is implemented as the sum of the integrals of the components.
+
+        Arguments
+        ---------
+        xmin : float
+            The minimum value of the independent variable to integrate over.
+
+        xmax : float
+            The maximum value of the independent variable to integrate over.
+
+        Returns
+        -------
+        integral : float
+            The integral of the model between xmin and xmax.
+        """
+        return sum(component.integral(xmin, xmax) for component in self._components)
+
     def plot(self, xmin: float = None, xmax: float = None, num_points: int = 200) -> None:
         """Overloaded method for plotting the model.
         """
@@ -931,8 +1050,13 @@ class Constant(AbstractFitModel):
     @staticmethod
     def evaluate(x: ArrayLike, value: float) -> ArrayLike:
         # pylint: disable=arguments-differ
+        if isinstance(x, Number):
+            return value
         return np.full(x.shape, value)
 
+    def integral(self, xmin: float, xmax: float) -> float:
+        return self.value.value * (xmax - xmin)
+
 
 class Line(AbstractFitModel):
 
@@ -947,6 +1071,29 @@ class Line(AbstractFitModel):
         # pylint: disable=arguments-differ
         return slope * x + intercept
 
+    def integral(self, xmin: float, xmax: float) -> float:
+        slope, intercept = self.parameter_values()
+        return 0.5 * slope * (xmax**2 - xmin**2) + intercept * (xmax - xmin)
+
+
+class Quadratic(AbstractFitModel):
+
+    """Quadratic model.
+    """
+
+    a = FitParameter(1.)
+    b = FitParameter(1.)
+    c = FitParameter(0.)
+
+    @staticmethod
+    def evaluate(x: ArrayLike, a: float, b: float, c: float) -> ArrayLike:
+        # pylint: disable=arguments-differ
+        return a * x**2 + b * x + c
+
+    def integral(self, xmin: float, xmax: float) -> float:
+        a, b, c = self.parameter_values()
+        return a * (xmax**3 - xmin**3) / 3. + b * (xmax**2 - xmin**2) / 2. + c * (xmax - xmin)
+
 
 class PowerLaw(AbstractFitModel):
 
@@ -954,33 +1101,88 @@ class PowerLaw(AbstractFitModel):
     """
 
     prefactor = FitParameter(1.)
-    index = FitParameter(-1.)
+    index = FitParameter(-2.)
 
     @staticmethod
     def evaluate(x: ArrayLike, prefactor: float, index: float) -> ArrayLike:
         # pylint: disable=arguments-differ
         return prefactor * x**index
 
+    def integral(self, xmin: float, xmax: float) -> float:
+        prefactor, index = self.parameter_values()
+        if index == -1.:
+            return prefactor * np.log(xmax / xmin)
+        return prefactor / (index + 1.) * (xmax**(index + 1.) - xmin**(index + 1.))
 
-class Gaussian(AbstractFitModel):
+    def default_plotting_range(self) -> Tuple[float, float]:
+        return (0.1, 10.)
 
-    """Gaussian model.
+    def plot(self, xmin: float = None, xmax: float = None, num_points: int = 200) -> None:
+        super().plot(xmin, xmax, num_points)
+        plt.xscale("log")
+        plt.yscale("log")
+
+
+class Exponential(AbstractFitModel):
+
+    """Exponential model.
+    """
+
+    prefactor = FitParameter(1.)
+    scale = FitParameter(1.)
+
+    @staticmethod
+    def evaluate(x: ArrayLike, prefactor: float, scale: float) -> ArrayLike:
+        # pylint: disable=arguments-differ
+        return prefactor * np.exp(-x / scale)
+
+    def integral(self, xmin: float, xmax: float) -> float:
+        prefactor, scale = self.parameter_values()
+        return prefactor * scale * (np.exp(-xmin / scale) - np.exp(-xmax / scale))
+
+    def default_plotting_range(self, scale_factor: int = 5) -> Tuple[float, float]:
+        return (0., scale_factor * self.scale.value)
+
+
+class _GaussianBase(AbstractFitModel):
+
+    """Common base class for Gaussian-like models.
+
+    This provides a couple of convenience methods that are useful for all the
+    models derived from a gaussian (e.g., the gaussian itself, the error function,
+    and its inverse). Note that, for the right method to be picked up,
+    subclasses should derive from this class *before* deriving from
+    AbstractFitModel, so that the method resolution order (MRO) works as expected.
+
+    Note the evaluate() method is not implemented here, which means that the class
+    cannot be instantiated directly.
     """
 
     prefactor = FitParameter(1.)
     mean = FitParameter(0.)
     sigma = FitParameter(1., minimum=0.)
 
+    # A few useful constants.
+    _SQRT2 = np.sqrt(2.)
     _NORM_CONSTANT = 1. / np.sqrt(2. * np.pi)
     _SIGMA_TO_FWHM = 2. * np.sqrt(2. * np.log(2.))
 
-    @staticmethod
-    def evaluate(x: ArrayLike, prefactor: float, mean: float, sigma: float) -> ArrayLike:
-        # pylint: disable=arguments-differ
-        z = (x - mean) / sigma
-        return prefactor * Gaussian._NORM_CONSTANT / sigma * np.exp(-0.5 * z**2.)
-
     def default_plotting_range(self, num_sigma: int = 5) -> Tuple[float, float]:
+        """Convenience function to return a default plotting range for all the
+        models derived from a gaussian (e.g., the gaussian itself, the error
+        function, and its inverse).
+
+        Arguments
+        ---------
+        num_sigma : int, optional
+            The number of sigmas to use for the plotting range (default 5).
+
+        Returns
+        -------
+        Tuple[float, float]
+            The default plotting range for the model.
+        """
+        # pylint: disable=no-member
         mean, half_width = self.mean.value, num_sigma * self.sigma.value
         return (mean - half_width, mean + half_width)
 
@@ -992,4 +1194,46 @@ class Gaussian(AbstractFitModel):
         fwhm : uncertainties.ufloat
             The FWHM of the gaussian.
         """
+        # pylint: disable=no-member
         return self.sigma.ufloat() * self._SIGMA_TO_FWHM
+
+
+class Gaussian(_GaussianBase):
+
+    """Gaussian model.
+    """
+
+    @staticmethod
+    def evaluate(x: ArrayLike, prefactor: float, mean: float, sigma: float) -> ArrayLike:
+        # pylint: disable=arguments-differ
+        z = (x - mean) / sigma
+        return prefactor * _GaussianBase._NORM_CONSTANT / sigma * np.exp(-0.5 * z**2.)
+
+    def integral(self, xmin: float, xmax: float) -> float:
+        prefactor, mean, sigma = self.parameter_values()
+        zmin = (xmin - mean) / (sigma * self._SQRT2)
+        zmax = (xmax - mean) / (sigma * self._SQRT2)
+        return prefactor * 0.5 * (erf(zmax) - erf(zmin))
+
+
+class Erf(_GaussianBase):
+
+    """Error function model.
+    """
+
+    @staticmethod
+    def evaluate(x: ArrayLike, prefactor: float, mean: float, sigma: float) -> ArrayLike:
+        # pylint: disable=arguments-differ
+        z = (x - mean) / sigma
+        return prefactor * 0.5 * (1. + erf(z / _GaussianBase._SQRT2))
+
+
+class ErfInverse(_GaussianBase):
+
+    """Inverse error function model.
+    """
+
+    @staticmethod
+    def evaluate(x: ArrayLike, prefactor: float, mean: float, sigma: float) -> ArrayLike:
+        # pylint: disable=arguments-differ
+        return prefactor - Erf.evaluate(x, prefactor, mean, sigma)

{aptapy-0.3.1 → aptapy-0.4.0}/tests/test_hist.py

@@ -101,22 +101,43 @@ def test_plotting1d(size: int = 100000):
     plt.figure(inspect.currentframe().f_code.co_name)
     # Create the first histogram. This has no label attached, so we will have to
     # provide one at plotting time, if we want to have a corresponding legend entry.
+    mean = 0.
+    sigma = 1.
     hist1 = Histogram1d(np.linspace(-5., 5., 100), xlabel='x')
-    hist1.fill(_RNG.normal(size=size))
+    hist1.fill(_RNG.normal(size=size, loc=mean, scale=sigma))
     hist1.plot(label='Standard histogram')
+    m, s = hist1.binned_statistics()
+    # Rough checks on the binned statistics---we want the mean to be within 10
+    # sigma/sqrt(N) and the stddev to be within 2% of the true value.
+    # (Note the binning has an effect on the actual values, so we cannot
+    # expect perfect agreement.)
+    assert abs((m - mean) / sigma * np.sqrt(size)) < 10.
+    assert abs(s / sigma - 1.) < 0.02
+
     # Create a second histogram, this time with a label---this should have a
     # proper entry in the legend automatically.
+    mean = 1.
+    sigma = 1.5
     hist2 = Histogram1d(np.linspace(-5., 5., 100), label='Offset histogram')
-    hist2.fill(_RNG.normal(size=size, loc=1.))
+    hist2.fill(_RNG.normal(size=size, loc=mean, scale=sigma))
     hist2.plot()
+    m, s = hist2.binned_statistics()
+    assert abs((m - mean) / sigma * np.sqrt(size)) < 10.
+    assert abs(s / sigma - 1.) < 0.02
+
     # And this one should end up with no legend entry, as it has no label
+    mean = -1.
+    sigma = 0.5
     hist3 = Histogram1d(np.linspace(-5., 5., 100))
-    hist3.fill(_RNG.normal(size=size // 2, loc=-1.))
+    hist3.fill(_RNG.normal(size=size, loc=mean, scale=sigma))
     hist3.plot()
+    m, s = hist3.binned_statistics()
+    assert abs((m - mean) / sigma * np.sqrt(size)) < 10.
+    assert abs(s / sigma - 1.) < 0.02
     plt.legend()
 
 
-def test_plotting2d(size: int = 100000):
+def test_plotting2d(size: int = 100000, x0: float = 1., y0: float = -1.):
     """Test plotting.
     """
     plt.figure(inspect.currentframe().f_code.co_name)
@@ -124,8 +145,14 @@ def test_plotting2d(size: int = 100000):
     hist = Histogram2d(edges, edges, 'x', 'y')
     # Note we are adding different offsets to x and y so that we can see
     # the effect on the plot.
-    hist.fill(_RNG.normal(size=size) + 1., _RNG.normal(size=size) - 1.)
+    hist.fill(_RNG.normal(size=size, loc=x0), _RNG.normal(size=size, loc=y0))
     hist.plot()
+    mx, sx = hist.binned_statistics(0)
+    my, sy = hist.binned_statistics(1)
+    assert abs((mx - x0) * np.sqrt(size)) < 10.
+    assert abs((my - y0) * np.sqrt(size)) < 10.
+    assert abs(sx - 1.) < 0.02
+    assert abs(sy - 1.) < 0.02
     plt.gca().set_aspect('equal')
 
 

{aptapy-0.3.1 → aptapy-0.4.0}/tests/test_modeling.py

@@ -19,14 +19,25 @@
 import inspect
 
 import numpy as np
+import pytest
 
 from aptapy.hist import Histogram1d
-from aptapy.modeling import Constant, FitParameter, Gaussian, Line
+from aptapy.modeling import (
+    Constant,
+    Erf,
+    ErfInverse,
+    Exponential,
+    FitParameter,
+    Gaussian,
+    Line,
+    PowerLaw,
+    Quadratic,
+)
 from aptapy.plotting import plt
 
 _RNG = np.random.default_rng(313)
 
-TEST_HISTOGRAM = Histogram1d(np.linspace(-5., 5., 100), label="Test data")
+TEST_HISTOGRAM = Histogram1d(np.linspace(-5., 5., 100), label="Random data")
 TEST_HISTOGRAM.fill(_RNG.normal(size=100000))
 NUM_SIGMA = 4.
 
@@ -82,6 +93,89 @@ def test_model_parameters():
     assert id(p1) != id(p2)
 
 
+def test_plot():
+    """Test the plot method of the models.
+    """
+    for model in (Constant(), Line(), Quadratic(), PowerLaw(), Exponential(),
+                  Gaussian(), Erf(), ErfInverse()):
+        plt.figure(f"{inspect.currentframe().f_code.co_name}_{model.__class__.__name__}")
+        model.plot()
+        plt.legend()
+
+
+def test_integral():
+    """Test the integral method of the models.
+    """
+    # pylint: disable=too-many-statements
+    # Constant.
+    xmin = 0.
+    xmax = 1.
+    value = 1.
+    target = value * (xmax - xmin)
+    model = Constant()
+    model.value.freeze(1.)
+    assert model.quadrature(xmin, xmax) == pytest.approx(target)
+    assert model.integral(xmin, xmax) == pytest.approx(target)
+    # Line.
+    slope = 1.
+    intercept = 1.
+    target = 0.5 * slope * (xmax**2 - xmin**2) + intercept * (xmax - xmin)
+    model = Line()
+    model.slope.freeze(slope)
+    model.intercept.freeze(intercept)
+    assert model.quadrature(xmin, xmax) == pytest.approx(target)
+    assert model.integral(xmin, xmax) == pytest.approx(target)
+    # Quadratic.
+    a = 1.
+    b = 1.
+    c = 1.
+    target = a * (xmax**3 - xmin**3) / 3. + b * (xmax**2 - xmin**2) / 2. + c * (xmax - xmin)
+    model = Quadratic()
+    model.a.freeze(a)
+    model.b.freeze(b)
+    model.c.freeze(c)
+    assert model.quadrature(xmin, xmax) == pytest.approx(target)
+    assert model.integral(xmin, xmax) == pytest.approx(target)
+    # PowerLaw.
+    xmin = 1.
+    xmax = 10.
+    prefactor = 1.
+    for index in (-2., -1.):
+        if index == -1.:
+            target = prefactor * np.log(xmax / xmin)
+        else:
+            target = prefactor / (index + 1.) * (xmax**(index + 1.) - xmin**(index + 1.))
+        model = PowerLaw()
+        model.prefactor.freeze(prefactor)
+        model.index.freeze(index)
+        assert model.quadrature(xmin, xmax) == pytest.approx(target)
+        assert model.integral(xmin, xmax) == pytest.approx(target)
+    # Exponential.
+    xmin = 0.
+    xmax = 10.
+    prefactor = 1.
+    scale = 1.
+    target = prefactor * scale * (np.exp(-xmin / scale) - np.exp(-xmax / scale))
+    model = Exponential()
+    model.prefactor.freeze(prefactor)
+    model.scale.freeze(scale)
+    assert model.quadrature(xmin, xmax) == pytest.approx(target)
+    assert model.integral(xmin, xmax) == pytest.approx(target)
+    # Gaussian.
+    xmin = -5.
+    xmax = 5.
+    prefactor = 1.
+    mean = 0.
+    sigma = 1.
+    target = 1.
+    model = Gaussian()
+    model.prefactor.freeze(prefactor)
+    model.mean.freeze(mean)
+    model.sigma.freeze(sigma)
+    assert model.quadrature(xmin, xmax) == pytest.approx(target)
+    assert model.integral(xmin, xmax) == pytest.approx(target)
+
+
 def test_gaussian_fit():
     """Simple Gaussian fit.
     """
@@ -181,6 +275,7 @@ def test_multiple_sum():
 
 
 if __name__ == '__main__':
+    test_plot()
     test_gaussian_fit()
     test_gaussian_fit_subrange()
     test_gaussian_fit_bound()

aptapy-0.3.1/src/aptapy/_version.py

@@ -1 +0,0 @@
-__version__ = "0.3.1"