robustmodels 0.1.0__tar.gz

robustmodels-0.1.0/.gitignore

@@ -0,0 +1,15 @@
+README_plan.md
+auditoria_investigacion
+
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+build/
+dist/
+.venv/
+.pytest_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+docs/_build/

robustmodels-0.1.0/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+## 0.1.0 (2026-11-09)
+
+First release.
+
+- `scale`: `mad`, `qn`, `sn`, `pn`, `tau_scale`, `m_scale`, `medcouple`, `lmc`, `rmc`.
+  Qn, Sn and Pn apply finite-sample corrections by default (Pn: Tarr 2014,
+  Appendix B.3); pass `finite_correction=False` to disable them.
+- `location`: `hodges_lehmann`, `m_location`, `tau_location`, `trimmed_mean`, `winsorized_mean`.
+- `covariance`: `MCD` (FAST-MCD and DetMCD), `MRCD`, `MVE`, `OGK`, `SEstimator`,
+  `MMEstimator`, with the scikit-learn estimator interface.
+- Input and tuning parameters are validated; invalid values raise `ValueError`
+  naming the parameter.
+- Documentation at https://omarbecerrasierra.github.io/robustmodels/, with a user
+  guide and a reference for every function and class; its examples run as tests.
+- CI tests the installed wheel on Python 3.10 to 3.14 and publishes
+  tagged releases to PyPI with trusted publishing.

robustmodels-0.1.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, omarbecerrasierra
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

robustmodels-0.1.0/PKG-INFO

@@ -0,0 +1,151 @@
+Metadata-Version: 2.5
+Name: robustmodels
+Version: 0.1.0
+Summary: Robust statistics for Python: univariate location and scale, multivariate location and scatter.
+Project-URL: Homepage, https://github.com/omarbecerrasierra/robustmodels
+Project-URL: Documentation, https://omarbecerrasierra.github.io/robustmodels/
+Project-URL: Repository, https://github.com/omarbecerrasierra/robustmodels
+Project-URL: Issues, https://github.com/omarbecerrasierra/robustmodels/issues
+Project-URL: Changelog, https://github.com/omarbecerrasierra/robustmodels/blob/main/CHANGELOG.md
+Author: omarbecerrasierra
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Keywords: MCD,Qn,Sn,covariance,medcouple,outliers,robust statistics
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.24
+Requires-Dist: scikit-learn>=1.6
+Requires-Dist: scipy>=1.10
+Description-Content-Type: text/markdown
+
+# robustmodels
+
+[![PyPI](https://img.shields.io/pypi/v/robustmodels)](https://pypi.org/project/robustmodels/)
+[![Docs](https://github.com/omarbecerrasierra/robustmodels/actions/workflows/docs.yml/badge.svg)](https://omarbecerrasierra.github.io/robustmodels/)
+[![CI](https://github.com/omarbecerrasierra/robustmodels/actions/workflows/ci.yml/badge.svg)](https://github.com/omarbecerrasierra/robustmodels/actions/workflows/ci.yml)
+
+Robust location, scale and covariance estimators for Python. Early development:
+the API may change before version 1.0.
+
+## Install
+
+```bash
+pip install robustmodels
+```
+
+Requires Python 3.10+, NumPy, SciPy and scikit-learn.
+
+## Use
+
+```python
+from robustmodels import location, scale
+
+x = [1, 2, 2, 3, 4, 100]
+location.hodges_lehmann(x)
+scale.mad(x)
+scale.qn(x)
+```
+
+Covariance estimators follow the scikit-learn interface:
+
+```python
+import numpy as np
+from robustmodels.covariance import MCD
+
+X = np.random.default_rng(0).normal(size=(100, 3))
+X[:10] += 8
+
+model = MCD(random_state=0).fit(X)
+model.location_
+model.covariance_
+model.mahalanobis(X)  # squared distances
+model.support_  # observations kept after reweighting
+```
+
+## Estimators
+
+| Module | Contents |
+| --- | --- |
+| `robustmodels.location` | `hodges_lehmann`, `m_location`, `tau_location`, `trimmed_mean`, `winsorized_mean` |
+| `robustmodels.scale` | `mad`, `qn`, `sn`, `pn`, `tau_scale`, `m_scale`; skewness and tail weight: `medcouple`, `lmc`, `rmc` |
+| `robustmodels.covariance` | `MCD`, `MRCD`, `MVE`, `OGK`, `SEstimator`, `MMEstimator`; correction factors: `h_alpha_n`, `mcd_consistency`, `mcd_small_sample` |
+
+The [documentation](https://omarbecerrasierra.github.io/robustmodels/) explains how
+to choose and use each estimator and documents every function and class. The same
+information is in the docstrings: `help(robustmodels.scale.qn)`.
+
+Univariate functions accept finite, one-dimensional samples. Empty samples return
+`NaN`. A single observation has zero scale. Covariance estimators accept matrices
+with observations in rows. MRCD supports more variables than observations and
+uses an identity regularization target. MVE requires `alpha < 1`.
+MRCD needs an explicit positive `rho` when a starting subset has zero scatter.
+
+Qn, Sn and Pn include finite-sample corrections by default. Pass
+`finite_correction=False` to disable them. Pn uses the factors from
+[Tarr (2014), Appendix B.3](https://www.researchgate.net/publication/267927753_Quantile_Based_Estimation_of_Scale_and_Dependence).
+
+## Development
+
+```bash
+uv sync --locked
+uv run pytest
+uv run ruff check .
+uv run ruff format --check .
+```
+
+Build and check the distributions:
+
+```bash
+uv build
+uvx twine check --strict dist/*
+```
+
+Run the docstring examples and build the documentation:
+
+```bash
+uv run pytest --doctest-modules --pyargs robustmodels
+uv run --group docs sphinx-build -W -b html docs docs/_build/html
+```
+
+CI runs the tests against the installed wheel on Python 3.10 to 3.14.
+The Python 3.10 job uses the minimum supported NumPy, SciPy and scikit-learn versions.
+
+The examples in `docs/` and in the docstrings run as tests. The tests cover estimator definitions, statistical properties, edge cases,
+agreement with R's robustbase and rrcov, and
+[scikit-learn compatibility](https://scikit-learn.org/stable/developers/develop.html).
+
+Code lives in `src/robustmodels`:
+
+| File | Contents | Internal dependencies |
+| --- | --- | --- |
+| `location.py` | Location estimators | `scale.py`, `_validation.py` |
+| `scale.py` | Scale, skewness, correction factors and pairwise selection | `_validation.py` |
+| `covariance.py` | Covariance estimators and their fitting steps | `scale.py`, `_validation.py` |
+| `_validation.py` | Input and parameter checks | None |
+
+Each method and its steps stay together. Auditing an estimator requires its file
+and at most two supporting files. `__init__.py` exposes the three public modules.
+
+### Release
+
+1. Set `version` in `pyproject.toml`, run `uv lock`, and replace "unreleased"
+   in [CHANGELOG.md](https://github.com/omarbecerrasierra/robustmodels/blob/main/CHANGELOG.md)
+   with the date.
+2. Merge into `main`, then tag and push: `git tag v0.1.0 && git push origin v0.1.0`.
+3. CI tests, builds and, after approval of the `pypi` environment, publishes to
+   PyPI through trusted publishing. The tag must match the package version.
+
+## License
+
+BSD 3-Clause; see [LICENSE](https://github.com/omarbecerrasierra/robustmodels/blob/main/LICENSE).

robustmodels-0.1.0/README.md

@@ -0,0 +1,120 @@
+# robustmodels
+
+[![PyPI](https://img.shields.io/pypi/v/robustmodels)](https://pypi.org/project/robustmodels/)
+[![Docs](https://github.com/omarbecerrasierra/robustmodels/actions/workflows/docs.yml/badge.svg)](https://omarbecerrasierra.github.io/robustmodels/)
+[![CI](https://github.com/omarbecerrasierra/robustmodels/actions/workflows/ci.yml/badge.svg)](https://github.com/omarbecerrasierra/robustmodels/actions/workflows/ci.yml)
+
+Robust location, scale and covariance estimators for Python. Early development:
+the API may change before version 1.0.
+
+## Install
+
+```bash
+pip install robustmodels
+```
+
+Requires Python 3.10+, NumPy, SciPy and scikit-learn.
+
+## Use
+
+```python
+from robustmodels import location, scale
+
+x = [1, 2, 2, 3, 4, 100]
+location.hodges_lehmann(x)
+scale.mad(x)
+scale.qn(x)
+```
+
+Covariance estimators follow the scikit-learn interface:
+
+```python
+import numpy as np
+from robustmodels.covariance import MCD
+
+X = np.random.default_rng(0).normal(size=(100, 3))
+X[:10] += 8
+
+model = MCD(random_state=0).fit(X)
+model.location_
+model.covariance_
+model.mahalanobis(X)  # squared distances
+model.support_  # observations kept after reweighting
+```
+
+## Estimators
+
+| Module | Contents |
+| --- | --- |
+| `robustmodels.location` | `hodges_lehmann`, `m_location`, `tau_location`, `trimmed_mean`, `winsorized_mean` |
+| `robustmodels.scale` | `mad`, `qn`, `sn`, `pn`, `tau_scale`, `m_scale`; skewness and tail weight: `medcouple`, `lmc`, `rmc` |
+| `robustmodels.covariance` | `MCD`, `MRCD`, `MVE`, `OGK`, `SEstimator`, `MMEstimator`; correction factors: `h_alpha_n`, `mcd_consistency`, `mcd_small_sample` |
+
+The [documentation](https://omarbecerrasierra.github.io/robustmodels/) explains how
+to choose and use each estimator and documents every function and class. The same
+information is in the docstrings: `help(robustmodels.scale.qn)`.
+
+Univariate functions accept finite, one-dimensional samples. Empty samples return
+`NaN`. A single observation has zero scale. Covariance estimators accept matrices
+with observations in rows. MRCD supports more variables than observations and
+uses an identity regularization target. MVE requires `alpha < 1`.
+MRCD needs an explicit positive `rho` when a starting subset has zero scatter.
+
+Qn, Sn and Pn include finite-sample corrections by default. Pass
+`finite_correction=False` to disable them. Pn uses the factors from
+[Tarr (2014), Appendix B.3](https://www.researchgate.net/publication/267927753_Quantile_Based_Estimation_of_Scale_and_Dependence).
+
+## Development
+
+```bash
+uv sync --locked
+uv run pytest
+uv run ruff check .
+uv run ruff format --check .
+```
+
+Build and check the distributions:
+
+```bash
+uv build
+uvx twine check --strict dist/*
+```
+
+Run the docstring examples and build the documentation:
+
+```bash
+uv run pytest --doctest-modules --pyargs robustmodels
+uv run --group docs sphinx-build -W -b html docs docs/_build/html
+```
+
+CI runs the tests against the installed wheel on Python 3.10 to 3.14.
+The Python 3.10 job uses the minimum supported NumPy, SciPy and scikit-learn versions.
+
+The examples in `docs/` and in the docstrings run as tests. The tests cover estimator definitions, statistical properties, edge cases,
+agreement with R's robustbase and rrcov, and
+[scikit-learn compatibility](https://scikit-learn.org/stable/developers/develop.html).
+
+Code lives in `src/robustmodels`:
+
+| File | Contents | Internal dependencies |
+| --- | --- | --- |
+| `location.py` | Location estimators | `scale.py`, `_validation.py` |
+| `scale.py` | Scale, skewness, correction factors and pairwise selection | `_validation.py` |
+| `covariance.py` | Covariance estimators and their fitting steps | `scale.py`, `_validation.py` |
+| `_validation.py` | Input and parameter checks | None |
+
+Each method and its steps stay together. Auditing an estimator requires its file
+and at most two supporting files. `__init__.py` exposes the three public modules.
+
+### Release
+
+1. Set `version` in `pyproject.toml`, run `uv lock`, and replace "unreleased"
+   in [CHANGELOG.md](https://github.com/omarbecerrasierra/robustmodels/blob/main/CHANGELOG.md)
+   with the date.
+2. Merge into `main`, then tag and push: `git tag v0.1.0 && git push origin v0.1.0`.
+3. CI tests, builds and, after approval of the `pypi` environment, publishes to
+   PyPI through trusted publishing. The tag must match the package version.
+
+## License
+
+BSD 3-Clause; see [LICENSE](https://github.com/omarbecerrasierra/robustmodels/blob/main/LICENSE).

robustmodels-0.1.0/docs/changelog.md

@@ -0,0 +1,2 @@
+```{include} ../CHANGELOG.md
+```

robustmodels-0.1.0/docs/conf.py

@@ -0,0 +1,23 @@
+"""Sphinx configuration."""
+
+from importlib.metadata import version as package_version
+
+project = "robustmodels"
+author = "omarbecerrasierra"
+copyright = "2026, omarbecerrasierra"
+release = package_version("robustmodels")
+
+extensions = [
+    "myst_parser",
+    "sphinx.ext.autodoc",
+    "sphinx.ext.napoleon",
+    "sphinx.ext.viewcode",
+]
+exclude_patterns = ["_build"]
+
+autodoc_member_order = "bysource"
+add_module_names = False
+napoleon_google_docstring = False
+
+html_theme = "furo"
+html_title = f"robustmodels {release}"

robustmodels-0.1.0/docs/covariance.md

@@ -0,0 +1,135 @@
+# Covariance
+
+Robust estimators of multivariate location and scatter, in
+`robustmodels.covariance`.
+
+## Choosing an estimator
+
+| Class | Needs | Random | Notes |
+| --- | --- | --- | --- |
+| `MCD` | `n > p` | Optional | The standard choice; `algorithm="deterministic"` avoids random starts |
+| `MRCD` | Any `n`, `p` | No | Regularized MCD for many variables, including `p > n` |
+| `MVE` | `n > p + 1` | Yes | Smallest covering ellipsoid; less efficient than MCD |
+| `OGK` | `n >= 2` | No | Fast for many variables; not rotation equivariant |
+| `SEstimator` | `n > p` | Yes | Smooth weights instead of a hard subset |
+| `MMEstimator` | `n > p` | Yes | S-estimator refined to 95% shape efficiency |
+
+Here `n` is the number of observations and `p` the number of variables. MCD,
+MVE, S and MM are affine equivariant and reach a 50% breakdown point with their
+default settings.
+
+## Use
+
+All classes are scikit-learn estimators: parameters go to the constructor,
+`fit(X)` returns the estimator, and results are attributes ending in `_`.
+
+```pycon
+>>> import numpy as np
+>>> from robustmodels.covariance import MCD
+>>> X = np.random.default_rng(0).normal(size=(100, 2))
+>>> X[:10] += 10  # ten outliers
+>>> mcd = MCD(random_state=0).fit(X)
+>>> mcd.location_.round(2).tolist()
+[0.01, 0.1]
+>>> mcd.covariance_.round(2).tolist()
+[[0.93, 0.15], [0.15, 1.06]]
+
+```
+
+Every fitted estimator has:
+
+| Attribute or method | Meaning |
+| --- | --- |
+| `location_` | Robust location |
+| `covariance_` | Robust covariance matrix |
+| `precision_` | Its (pseudo-)inverse |
+| `dist_` | Squared robust distances of the training data |
+| `mahalanobis(X)` | Squared robust distances of any observations |
+| `score(X)`, `error_norm(...)`, `get_precision()` | As in `sklearn.covariance.EmpiricalCovariance` |
+
+Estimators that select observations (`MCD`, `MRCD`, `MVE`, `OGK`) also have
+`support_`, a boolean mask of the observations used.
+
+### Detecting outliers
+
+Under the normal model, squared robust distances follow approximately a
+chi-square distribution with `p` degrees of freedom. Flag the observations
+above a high quantile:
+
+```pycon
+>>> from scipy.stats import chi2
+>>> flagged = mcd.mahalanobis(X) > chi2.ppf(0.975, df=2)
+>>> np.flatnonzero(flagged).tolist()
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 69]
+
+```
+
+The ten planted outliers are found. Observation 69 is a clean point in the
+tail: with a 0.975 quantile, about 2.5% of the clean data are expected there.
+
+### Reproducibility
+
+`MCD` (with `algorithm="fast"`), `MVE`, `SEstimator` and `MMEstimator` draw
+random subsets. Pass `random_state` to get the same result on every run, or use
+a deterministic estimator:
+
+```pycon
+>>> det = MCD(algorithm="deterministic").fit(X)
+>>> int(det.support_[:10].sum())  # no outlier is used
+0
+
+```
+
+### More variables than observations
+
+`MCD` needs more observations than variables. `MRCD` regularizes the covariance
+and works in any dimension:
+
+```pycon
+>>> from robustmodels.covariance import MRCD
+>>> wide = np.random.default_rng(0).normal(size=(20, 50))
+>>> mrcd = MRCD().fit(wide)
+>>> mrcd.covariance_.shape
+(50, 50)
+>>> 0 < mrcd.rho_ < 1  # regularization weight
+True
+
+```
+
+### With scikit-learn
+
+The estimators work with `clone`, `get_params`, `set_params` and pipelines:
+
+```pycon
+>>> from sklearn.base import clone
+>>> clone(mcd).set_params(alpha=0.75).fit(X).h_
+75
+
+```
+
+## Reference
+
+```{eval-rst}
+.. currentmodule:: robustmodels.covariance
+
+.. autoclass:: MCD
+   :members: fit
+.. autoclass:: MRCD
+   :members: fit
+.. autoclass:: MVE
+   :members: fit
+.. autoclass:: OGK
+   :members: fit
+.. autoclass:: SEstimator
+   :members: fit
+.. autoclass:: MMEstimator
+   :members: fit
+```
+
+### Correction factors
+
+```{eval-rst}
+.. autofunction:: h_alpha_n
+.. autofunction:: mcd_consistency
+.. autofunction:: mcd_small_sample
+```

robustmodels-0.1.0/docs/index.md

@@ -0,0 +1,73 @@
+# robustmodels
+
+Robust statistics for Python: estimators of location, scale and covariance that
+stay reliable when part of the data are outliers.
+
+```bash
+pip install robustmodels
+```
+
+Requires Python 3.10+, NumPy, SciPy and scikit-learn.
+
+## Quick start
+
+One gross outlier ruins the mean and the standard deviation, but not their
+robust counterparts:
+
+```pycon
+>>> import numpy as np
+>>> from robustmodels import location, scale
+>>> x = [1, 2, 2, 3, 4, 100]
+>>> round(float(np.mean(x)), 2), round(float(np.std(x, ddof=1)), 2)
+(18.67, 39.86)
+>>> location.hodges_lehmann(x), round(scale.qn(x), 2)
+(3.0, 1.36)
+
+```
+
+The covariance estimators are scikit-learn estimators:
+
+```pycon
+>>> from robustmodels.covariance import MCD
+>>> X = np.random.default_rng(0).normal(size=(100, 2))
+>>> X[:10] += 10  # ten outliers
+>>> mcd = MCD(random_state=0).fit(X)
+>>> mcd.location_.round(2).tolist()
+[0.01, 0.1]
+>>> mcd.covariance_.round(2).tolist()
+[[0.93, 0.15], [0.15, 1.06]]
+
+```
+
+## Contents
+
+| Page | What it covers |
+| --- | --- |
+| [Location](location.md) | Hodges-Lehmann, M-estimators, tau location, trimmed and winsorized means |
+| [Scale and skewness](scale.md) | MAD, Qn, Sn, Pn, tau scale, M-scale, medcouple and tail weights |
+| [Covariance](covariance.md) | MCD, MRCD, MVE, OGK, S- and MM-estimators; outlier detection |
+
+Each page explains how to choose and use the estimators, then documents every
+function and class: definition, parameters, return value, references and an
+example.
+
+## Conventions
+
+- Univariate functions take a one-dimensional sample of finite values and return
+  a Python `float`. `NaN` or infinite values raise `ValueError`.
+- An empty sample returns `nan`; a single observation has zero scale.
+- Covariance estimators take a matrix with observations in rows and variables
+  in columns.
+- Invalid parameters raise `ValueError` with the name of the parameter.
+- The **breakdown point** is the largest fraction of arbitrary outliers an
+  estimator tolerates. The **Gaussian efficiency** compares its variance with
+  that of the classical estimator on clean normal data.
+
+```{toctree}
+:hidden:
+
+location
+scale
+covariance
+changelog
+```

robustmodels-0.1.0/docs/location.md

@@ -0,0 +1,67 @@
+# Location
+
+Robust alternatives to the sample mean, in `robustmodels.location`.
+
+## Choosing an estimator
+
+| Function | Breakdown point | Gaussian efficiency | Notes |
+| --- | --- | --- | --- |
+| `hodges_lehmann` | 29.3% | 95.5% | No tuning; a good default |
+| `m_location` (Huber) | 50% | 95% | Monotone psi, unique solution |
+| `m_location` (bisquare) | 50% | 95% | Rejects gross outliers completely |
+| `tau_location` | 50% | | One weighted mean; no iteration |
+| `trimmed_mean` | `proportion` | | Removes the tails |
+| `winsorized_mean` | `proportion` | | Clips the tails |
+
+The median itself (`numpy.median`) has a 50% breakdown point and 64% efficiency.
+
+## Use
+
+```pycon
+>>> from robustmodels import location
+>>> x = [1, 2, 2, 3, 4, 100]
+>>> location.hodges_lehmann(x)
+3.0
+>>> round(location.m_location(x), 4)
+2.7988
+>>> round(location.m_location(x, psi="bisquare"), 4)
+2.3869
+>>> round(location.tau_location(x), 4)
+2.3918
+
+```
+
+Trimming works with whole observations: it removes `floor(proportion * n)` values
+from each end, so the default 10% removes nothing from a sample of six.
+
+```pycon
+>>> round(location.trimmed_mean(x), 4)
+18.6667
+>>> location.trimmed_mean(x, proportion=0.2)
+2.75
+>>> round(location.winsorized_mean(x, proportion=0.2), 4)
+2.8333
+
+```
+
+`m_location` keeps the scale fixed. By default it is the MAD; pass another
+estimate with `scale`:
+
+```pycon
+>>> from robustmodels import scale
+>>> round(location.m_location(x, scale=scale.qn(x)), 4)
+2.7655
+
+```
+
+## Reference
+
+```{eval-rst}
+.. currentmodule:: robustmodels.location
+
+.. autofunction:: hodges_lehmann
+.. autofunction:: m_location
+.. autofunction:: tau_location
+.. autofunction:: trimmed_mean
+.. autofunction:: winsorized_mean
+```