DOC: Document KDE kwargs for #318 and cleanup unrelated histogram changes

Author: player3zxcvbnm

src/arviz_stats/accessors.py

@@ -116,7 +116,23 @@ def mcse(self, sample_dims=None, method="mean", prob=None, **kwargs):
         return self._apply("mcse", sample_dims=sample_dims, method=method, prob=prob, **kwargs)
 
     def kde(self, dim=None, **kwargs):
-        """Compute the KDE for all variables in the dataset."""
+        """Compute the KDE for all variables in the dataset.
+
+        Parameters
+        ----------
+        dim : str or sequence of str, optional
+            Dimension(s) over which to compute the KDE.
+        **kwargs : dict, optional
+            Additional keyword arguments passed to the underlying KDE 
+            implementations. Supported arguments include `bw`, `adaptive`, 
+            `circular`, and `grid_len`. See the array-level `kde` methods 
+            for full details on these parameters.
+
+        Returns
+        -------
+        xarray.Dataset
+            A dataset containing the KDE grids and pdf values for each variable.
+        """
         return self._apply("kde", dim=dim, **kwargs)
 
     def qds(self, dim=None, **kwargs):

src/arviz_stats/base/array.py

@@ -560,21 +560,29 @@ def histogram(self, ary, bins=None, range=None, weights=None, axis=-1, density=T
         return histogram_ufunc(ary, bins, range, shape_from_1st=True)
 
     def kde(self, ary, axis=-1, circular=False, grid_len=512, **kwargs):
-        """Compute of kde on array-like inputs.
+        """Compute KDE on array-like inputs.
 
         Parameters
         ----------
         ary : array-like
         axis : int, sequence of int or None, default -1
         circular : bool, default False
         grid_len : int, default 512
-        **kwargs
+        **kwargs : dict, optional
+            Additional keyword arguments passed to the KDE implementation.
+            Supported arguments include:
+            
+            * bw : str or float, optional
+                The bandwidth of the kernel. Options include "scott" (default),
+                "silverman", "isj", and "experimental", or a positive float.
+            * adaptive : bool, optional
+                Whether to use an adaptive KDE. Defaults to False.
 
         Returns
         -------
         grid, pdf, bw : array-like
             `grid` and `pdf` will have the same shape: the same as `ary` minus the dimensions
-            in `axis` plus an extra dimension of lenght `grid_len`. Same for `bw`
+            in `axis` plus an extra dimension of length `grid_len`. Same for `bw`
             except it will not have the extra dimension.
         """
         ary, axes = process_ary_axes(ary, axis)

src/arviz_stats/base/dataarray.py

@@ -228,7 +228,29 @@ def histogram(self, da, dim=None, bins=None, range=None, weights=None, density=T
         return out
 
     def kde(self, da, dim=None, circular=False, grid_len=512, **kwargs):
-        """Compute kde on DataArray input."""
+        """Compute KDE on DataArray input.
+
+        Parameters
+        ----------
+        da : xarray.DataArray
+            Input data.
+        dim : str or sequence of str, optional
+            Dimension(s) over which to compute the KDE.
+        circular : bool, default False
+            Whether the data is circular (e.g., angles).
+        grid_len : int, default 512
+            Number of points on the KDE grid.
+        **kwargs : dict, optional
+            Additional keyword arguments passed to the array-level KDE
+            implementation. See the underlying array `kde` method for a 
+            complete list of supported arguments (like `bw` and `adaptive`).
+
+        Returns
+        -------
+        out : xarray.DataArray
+            An xarray DataArray containing the grid and pdf values along the 
+            `plot_axis` dimension, with the bandwidth `bw` stored as a coordinate.
+        """
         dims = validate_dims(dim)
         grid, pdf, bw = apply_ufunc(
             self.array_class.kde,

src/arviz_stats/numba/array.py

@@ -128,6 +128,26 @@ def kde_gufunc(a, grid_in, circular, bw, adaptive, grid, pdf, bw_out):
     def kde(self, ary, axis=-1, circular=False, grid_len=512, **kwargs):
         """Compute the guvectorized kde.
 
+        Parameters
+        ----------
+        ary : array-like
+            Input array.
+        axis : int, sequence of int or None, default -1
+            Axis or axes along which the KDE is computed.
+        circular : bool, default False
+            Whether the data is circular (e.g., angles).
+        grid_len : int, default 512
+            Number of points on the KDE grid.
+        **kwargs : dict, optional
+            Additional keyword arguments passed to the KDE implementation.
+            Supported arguments include:
+
+            * bw : str or float, optional
+                The bandwidth of the kernel. Options include "scott" (default),
+                "silverman", "isj", and "experimental", or a positive float.
+            * adaptive : bool, optional
+                Whether to use an adaptive KDE. Defaults to False.
+
         Notes
         -----
         There currenly is no jit compiling of the kde computation steps other than the