fuzzytool 0.1.0__tar.gz → 0.2.0__tar.gz

{fuzzytool-0.1.0 → fuzzytool-0.2.0}/CHANGELOG.md

@@ -6,12 +6,43 @@ All notable changes to this project are documented here. The format is based on
 
 ## [Unreleased]
 
+## [0.2.0] - 2026-06-24
+
 ### Added
 
+- **Fuzzy numbers & MCDM**: `fuzzytool.fuzzynum` (triangular/trapezoidal numbers
+  with arithmetic, alpha-cuts, centroid, distance, ranking) and `fuzzytool.mcdm`
+  (`fuzzy_topsis`, `fuzzy_ahp`).
+- **Rule learning**: `wang_mendel` generates a Mamdani rule base from data.
+- **Tsukamoto** inference (`fuzzytool.inference.Tsukamoto`) with monotonic
+  consequents; added invertible `ramp_up` / `ramp_down` membership functions and
+  an `inverse` on `sigmoid`.
+- **Batch inference**: `Mamdani.predict` / `TSK.predict` evaluate array-valued
+  inputs in a vectorized pass.
+- **Serialization**: `fz.save` / `fz.load` (JSON) for Mamdani/TSK systems, plus
+  `to_dict`/`from_dict` on membership functions and variables.
+- **scikit-learn compatibility**: `ANFIS.get_params` / `set_params`.
+
+## [0.1.0] - 2026-06-24
+
+### Added
+
+- Core membership functions: triangular, trapezoidal, gaussian, generalized
+  bell, sigmoid (`fuzzytool.membership`).
+- T-norms and s-norms (min/prod/Łukasiewicz, max/probor/Łukasiewicz), resolved
+  by name (`fuzzytool.norms`).
+- `Variable` (linguistic variable) with auto-generated or explicit terms, and an
+  operator-based rule-antecedent expression tree (`&`, `|`, `~`).
+- **Mamdani** inference with configurable implication/aggregation and
+  defuzzification (centroid, bisector, MOM/SOM/LOM).
+- **Takagi-Sugeno (TSK)** inference (zero- and first-order, plus callable
+  consequents).
+- `fuzzytool.viz`: membership-function plots and 2-input control surfaces.
+- `fuzzytool.datasets.credit_risk`: the flagship example system.
 - Example notebooks (`notebooks/`): quickstart, interval type-2, clustering, and
   ANFIS/F-transform — committed executed.
-- Documentation: a comparison page vs scikit-fuzzy and a citing/releasing page;
-  `.zenodo.json` for DOI archival; `notebooks` optional dependency group.
+- Documentation (MkDocs Material), CI, a comparison page vs scikit-fuzzy, a
+  citing/releasing page, and `.zenodo.json` for DOI archival.
 - **ANFIS** (`fuzzytool.anfis.ANFIS`): a trainable first-order Sugeno system over
   a grid partition, fit with Jang's hybrid scheme (least-squares consequents +
   gradient-descent premises). `fit` / `predict` / `history_`.
@@ -32,21 +63,4 @@ All notable changes to this project are documented here. The format is based on
   - `IT2Mamdani` (center-of-sets type reduction) and `IT2TSK` engines.
   - Karnik-Mendel type reduction: `km_endpoint`, `karnik_mendel`, `centroid_it2`.
   - `viz.plot_it2_variable` (shaded FOU); `datasets.credit_risk_it2`.
-
-## [0.1.0] - 2026-06-24
-
-### Added
-
-- Core membership functions: triangular, trapezoidal, gaussian, generalized
-  bell, sigmoid (`fuzzytool.membership`).
-- T-norms and s-norms (min/prod/Łukasiewicz, max/probor/Łukasiewicz), resolved
-  by name (`fuzzytool.norms`).
-- `Variable` (linguistic variable) with auto-generated or explicit terms, and an
-  operator-based rule-antecedent expression tree (`&`, `|`, `~`).
-- **Mamdani** inference with configurable implication/aggregation and
-  defuzzification (centroid, bisector, MOM/SOM/LOM).
-- **Takagi-Sugeno (TSK)** inference (zero- and first-order, plus callable
-  consequents).
-- `fuzzytool.viz`: membership-function plots and 2-input control surfaces.
-- `fuzzytool.datasets.tipper`: the classic example system.
-- Test suite, MkDocs Material documentation, and CI.
+- Test suite covering every module.

{fuzzytool-0.1.0 → fuzzytool-0.2.0}/CITATION.cff

@@ -5,8 +5,9 @@ type: software
 authors:
   - family-names: Salmeron
     given-names: Jose L.
-version: 0.1.0
+version: 0.2.0
 date-released: 2026-06-24
+doi: 10.5281/zenodo.20836712
 license: MIT
 repository-code: "https://github.com/fuzzytool/fuzzytool.github.io"
 url: "https://fuzzytool.github.io"

{fuzzytool-0.1.0 → fuzzytool-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fuzzytool
-Version: 0.1.0
+Version: 0.2.0
 Summary: A clean, extensible fuzzy-logic toolkit in pure Python + NumPy
 Project-URL: Homepage, https://fuzzytool.github.io
 Project-URL: Documentation, https://fuzzytool.github.io
@@ -41,6 +41,7 @@ Description-Content-Type: text/markdown
   <a href="https://fuzzytool.github.io/"><img src="https://img.shields.io/badge/docs-fuzzytool.github.io-3f51b5" alt="Docs"></a>
   <img src="https://img.shields.io/pypi/pyversions/fuzzytool?logo=python&logoColor=white" alt="Python versions">
   <img src="https://img.shields.io/badge/license-MIT-blue" alt="License: MIT">
+  <a href="https://doi.org/10.5281/zenodo.20836712"><img src="https://zenodo.org/badge/DOI/10.5281/zenodo.20836712.svg" alt="DOI"></a>
 </p>
 
 # fuzzytool
@@ -90,7 +91,16 @@ s-norm, `~` the complement.
 | 3 | **Type-2 / interval type-2** sets (footprint of uncertainty) + Karnik-Mendel type reduction | ✅ |
 | 4 | **Fuzzy clustering**: fuzzy c-means, Gustafson-Kessel, possibilistic | ✅ |
 | 5 | **ANFIS** (trainable TSK) + **F-transform** (direct/inverse) | ✅ |
-| 6 | Notebooks, JOSS `paper.md`, Zenodo DOI, PyPI release | ⏳ |
+| 6 | Notebooks, JOSS `paper.md`, Zenodo DOI, PyPI release | ✅ |
+
+### v0.2.0
+
+- **Fuzzy numbers & MCDM:** triangular/trapezoidal fuzzy-number arithmetic,
+  **Fuzzy TOPSIS** and **Fuzzy AHP**.
+- **Rule learning:** **Wang-Mendel** rule-base generation from data; **Tsukamoto**
+  inference (monotonic consequents).
+- **Engineering:** vectorized **batch inference** (`predict`), JSON
+  **save/load**, and a **scikit-learn** estimator interface for ANFIS.
 
 See [`ROADMAP.md`](ROADMAP.md).
 

{fuzzytool-0.1.0 → fuzzytool-0.2.0}/README.md

@@ -4,6 +4,7 @@
   <a href="https://fuzzytool.github.io/"><img src="https://img.shields.io/badge/docs-fuzzytool.github.io-3f51b5" alt="Docs"></a>
   <img src="https://img.shields.io/pypi/pyversions/fuzzytool?logo=python&logoColor=white" alt="Python versions">
   <img src="https://img.shields.io/badge/license-MIT-blue" alt="License: MIT">
+  <a href="https://doi.org/10.5281/zenodo.20836712"><img src="https://zenodo.org/badge/DOI/10.5281/zenodo.20836712.svg" alt="DOI"></a>
 </p>
 
 # fuzzytool
@@ -53,7 +54,16 @@ s-norm, `~` the complement.
 | 3 | **Type-2 / interval type-2** sets (footprint of uncertainty) + Karnik-Mendel type reduction | ✅ |
 | 4 | **Fuzzy clustering**: fuzzy c-means, Gustafson-Kessel, possibilistic | ✅ |
 | 5 | **ANFIS** (trainable TSK) + **F-transform** (direct/inverse) | ✅ |
-| 6 | Notebooks, JOSS `paper.md`, Zenodo DOI, PyPI release | ⏳ |
+| 6 | Notebooks, JOSS `paper.md`, Zenodo DOI, PyPI release | ✅ |
+
+### v0.2.0
+
+- **Fuzzy numbers & MCDM:** triangular/trapezoidal fuzzy-number arithmetic,
+  **Fuzzy TOPSIS** and **Fuzzy AHP**.
+- **Rule learning:** **Wang-Mendel** rule-base generation from data; **Tsukamoto**
+  inference (monotonic consequents).
+- **Engineering:** vectorized **batch inference** (`predict`), JSON
+  **save/load**, and a **scikit-learn** estimator interface for ANFIS.
 
 See [`ROADMAP.md`](ROADMAP.md).
 

{fuzzytool-0.1.0 → fuzzytool-0.2.0}/ROADMAP.md

@@ -42,7 +42,22 @@ self-contained, testable increment.
 - [x] F-transform: direct and inverse over a triangular fuzzy partition
       (partition of unity), with smoothing/denoising.
 
-## ⏳ Phase 6 — Release
+## ✅ v0.2.0 — Decision-making, rule learning, engineering
+
+- [x] Fuzzy numbers (triangular/trapezoidal) + arithmetic; fuzzy MCDM
+      (`fuzzy_topsis`, `fuzzy_ahp`).
+- [x] Rule learning from data (`wang_mendel`); Tsukamoto inference with
+      invertible ramp/sigmoid MFs.
+- [x] Vectorized batch inference (`Mamdani.predict` / `TSK.predict`);
+      JSON serialization (`save`/`load`); scikit-learn estimator interface on ANFIS.
+
+## Ideas for later
+
+- Fuzzy cognitive maps (+ grey FCM).
+- General (non-interval) type-2; more defuzzifiers.
+- FIS tuning via metaheuristics (e.g. PSO).
+
+## ⏳ Phase 6 — Release (v0.1.0)
 
 - [x] Example notebooks (`notebooks/`) and a comparison page vs scikit-fuzzy.
 - [x] JOSS `paper.md`; Zenodo metadata (`.zenodo.json`) and a citing/releasing page.

{fuzzytool-0.1.0 → fuzzytool-0.2.0}/docs/api/python.md

@@ -30,6 +30,26 @@ Generated from docstrings with `mkdocstrings`.
 
 ::: fuzzytool.inference.tsk
 
+## Inference — Tsukamoto
+
+::: fuzzytool.inference.tsukamoto
+
+## Rule learning (Wang-Mendel)
+
+::: fuzzytool.learn
+
+## Fuzzy numbers
+
+::: fuzzytool.fuzzynum
+
+## Fuzzy MCDM
+
+::: fuzzytool.mcdm
+
+## Serialization
+
+::: fuzzytool.serialize
+
 ## Interval type-2 — sets
 
 ::: fuzzytool.type2.sets

{fuzzytool-0.1.0 → fuzzytool-0.2.0}/docs/citing.md

@@ -2,9 +2,10 @@
 
 ## Citing
 
-If you use fuzzytool in academic work, please cite it. Repository metadata lives
-in [`CITATION.cff`](https://github.com/fuzzytool/fuzzytool.github.io/blob/main/CITATION.cff);
-once a release is archived on Zenodo, cite the versioned DOI it mints.
+If you use fuzzytool in academic work, please cite it. The archival DOI (all
+versions) is [10.5281/zenodo.20836712](https://doi.org/10.5281/zenodo.20836712);
+each release also mints its own versioned DOI. Repository citation metadata lives
+in [`CITATION.cff`](https://github.com/fuzzytool/fuzzytool.github.io/blob/main/CITATION.cff).
 
 ## Releasing (maintainers)
 

fuzzytool-0.2.0/docs/guide/batch-and-io.md

@@ -0,0 +1,51 @@
+# Batch inference, serialization & scikit-learn
+
+## Batch (vectorized) inference
+
+Calling a system evaluates one sample. `predict(**arrays)` evaluates many at once
+— pass an array per variable and get an array back. Available on `Mamdani` and
+`TSK`.
+
+```python
+import numpy as np
+from fuzzytool import datasets
+
+sys, *_ = datasets.credit_risk()
+scores = np.array([520.0, 660.0, 800.0])
+dtis   = np.array([42.0, 30.0, 10.0])
+
+sys.predict(score=scores, dti=dtis)   # array of premiums, one per sample
+```
+
+The result matches calling the system once per sample, but the firing, implication
+and aggregation steps run vectorized.
+
+## Saving and loading systems
+
+Serialize a Mamdani or TSK system to JSON and restore it later. Connectives and
+the defuzzifier must be given **by name**, variables must use **built-in**
+membership functions, and TSK consequents must be numbers or coefficient mappings.
+
+```python
+import fuzzytool as fz
+
+fz.save(sys, "credit_risk.json")
+restored = fz.load("credit_risk.json")
+```
+
+`fuzzytool.membership.to_dict`/`from_dict` and `Variable.to_dict`/`from_dict`
+expose the building blocks if you need finer control.
+
+## scikit-learn compatibility
+
+`ANFIS` follows the estimator protocol (`fit` returns `self`, plus `predict`,
+`get_params`, `set_params`), so it drops into a `Pipeline` or `GridSearchCV`
+without importing scikit-learn at all:
+
+```python
+import fuzzytool as fz
+
+model = fz.ANFIS(n_inputs=2, n_mf=3)
+model.get_params()              # {'n_inputs': 2, 'n_mf': 3, 'learning_rate': 0.05}
+clone = fz.ANFIS(**model.get_params())
+```

fuzzytool-0.2.0/docs/guide/mcdm.md

@@ -0,0 +1,60 @@
+# Fuzzy numbers & MCDM
+
+## Fuzzy numbers
+
+[`fuzzytool.fuzzynum`][fuzzytool.fuzzynum] provides triangular (TFN) and
+trapezoidal (TrFN) fuzzy numbers with arithmetic, alpha-cuts, a crisp centroid,
+and a vertex distance.
+
+```python
+from fuzzytool.fuzzynum import tfn, trfn, rank
+
+a, b = tfn(1, 2, 3), tfn(2, 3, 4)
+a + b              # TFN(3, 5, 7)
+a * 2              # TFN(2, 4, 6)
+a.centroid()       # 2.0
+a.alpha_cut(0.5)   # (1.5, 2.5)
+rank([tfn(0,1,2), tfn(5,6,7)])   # [1, 0] (largest first)
+```
+
+`+`/`-` are exact; `*`/`/` use the standard positive-support approximation.
+
+## Fuzzy multi-criteria decision making
+
+[`fuzzytool.mcdm`][fuzzytool.mcdm] offers two classic methods.
+
+### Fuzzy TOPSIS (Chen)
+
+Rank alternatives by closeness to the fuzzy positive-ideal solution. The decision
+matrix and weights are triangular fuzzy numbers; `benefit[j]` says whether
+criterion `j` is maximized.
+
+```python
+from fuzzytool.fuzzynum import tfn
+from fuzzytool.mcdm import fuzzy_topsis
+
+matrix = [
+    [tfn(7, 8, 9), tfn(5, 6, 7)],   # alternative A: ratings per criterion
+    [tfn(3, 4, 5), tfn(8, 9, 9)],   # alternative B
+]
+weights = [tfn(0.4, 0.5, 0.6), tfn(0.3, 0.4, 0.5)]
+res = fuzzy_topsis(matrix, weights, benefit=[True, True])
+res.closeness   # closeness coefficient per alternative
+res.ranking     # alternative indices, best first
+```
+
+### Fuzzy AHP (Chang's extent analysis)
+
+Derive crisp criterion weights from a fuzzy pairwise-comparison matrix.
+
+```python
+from fuzzytool.fuzzynum import tfn
+from fuzzytool.mcdm import fuzzy_ahp
+
+one = tfn(1, 1, 1)
+matrix = [
+    [one,                  tfn(2, 3, 4)],
+    [tfn(1/4, 1/3, 1/2),   one],
+]
+fuzzy_ahp(matrix)   # normalized weights, e.g. [0.74, 0.26]
+```

fuzzytool-0.2.0/docs/guide/rule-learning.md

@@ -0,0 +1,48 @@
+# Rule learning & Tsukamoto
+
+## Learning a rule base from data (Wang-Mendel)
+
+[`wang_mendel`][fuzzytool.learn.wang_mendel] generates a Mamdani rule base from
+data: each sample becomes one rule (picking the highest-membership term per
+variable), and antecedent conflicts are resolved by rule degree.
+
+```python
+import numpy as np
+import fuzzytool as fz
+
+X = np.random.default_rng(0).uniform(0, 10, size=(300, 2))
+y = (X[:, 0] + X[:, 1]) / 2
+
+a = fz.Variable("a", (0, 10), terms=["lo", "mid", "hi"])
+b = fz.Variable("b", (0, 10), terms=["lo", "mid", "hi"])
+out = fz.Variable("out", (0, 10), terms=["lo", "mid", "hi"])
+
+sys = fz.wang_mendel(X, y, [a, b], out)   # a ready-to-use Mamdani system
+sys(a=8, b=7)
+```
+
+The input variables supply the partition; the learned system is a plain
+`Mamdani`, so it also supports batch [`predict`](batch-and-io.md) and
+serialization.
+
+## Tsukamoto inference
+
+[`Tsukamoto`][fuzzytool.inference.tsukamoto.Tsukamoto] consequents are
+**monotonic** membership functions; a rule firing with strength `w` outputs the
+value where its consequent reaches `w` (its inverse), and the system returns the
+firing-weighted average — no defuzzification.
+
+```python
+import fuzzytool as fz
+
+x = fz.Variable("x", (0, 10), terms=["lo", "hi"])
+sys = fz.Tsukamoto()
+sys.rule(x["lo"], fz.ramp_down(0, 30))   # monotonic consequents only
+sys.rule(x["hi"], fz.ramp_up(0, 30))
+sys(x=7)
+```
+
+Use [`ramp_up`][fuzzytool.membership.ramp_up],
+[`ramp_down`][fuzzytool.membership.ramp_down], or
+[`sigmoid`][fuzzytool.membership.sigmoid] — each exposes the `inverse` Tsukamoto
+needs.

fuzzytool-0.2.0/examples/mcdm.py

@@ -0,0 +1,39 @@
+"""Fuzzy MCDM: rank loan applicants with Fuzzy TOPSIS, weight criteria with AHP.
+
+    python examples/mcdm.py
+"""
+
+from fuzzytool.fuzzynum import tfn
+from fuzzytool.mcdm import fuzzy_ahp, fuzzy_topsis
+
+
+def main() -> None:
+    # Criteria: repayment ability (benefit), collateral (benefit), risk (cost).
+    # Weights from a fuzzy pairwise comparison (AHP).
+    one = tfn(1, 1, 1)
+    pairwise = [
+        [one,                tfn(2, 3, 4),       tfn(1, 2, 3)],
+        [tfn(1/4, 1/3, 1/2), one,                tfn(1/3, 1/2, 1)],
+        [tfn(1/3, 1/2, 1),   tfn(1, 2, 3),       one],
+    ]
+    crisp_w = fuzzy_ahp(pairwise)
+    print("AHP criterion weights:", crisp_w.round(3))
+
+    # Fuzzy weights for TOPSIS (triangular around the AHP weights).
+    weights = [tfn(max(0, w - 0.1), w, min(1, w + 0.1)) for w in crisp_w]
+
+    applicants = ["Ana", "Beto", "Carla"]
+    matrix = [
+        [tfn(7, 8, 9), tfn(6, 7, 8), tfn(2, 3, 4)],   # Ana
+        [tfn(4, 5, 6), tfn(8, 9, 9), tfn(5, 6, 7)],   # Beto
+        [tfn(6, 7, 8), tfn(3, 4, 5), tfn(1, 2, 3)],   # Carla
+    ]
+    res = fuzzy_topsis(matrix, weights, benefit=[True, True, False])
+
+    print("\nFuzzy TOPSIS ranking (best first):")
+    for place, i in enumerate(res.ranking, 1):
+        print(f"  {place}. {applicants[i]:6s}  CC = {res.closeness[i]:.3f}")
+
+
+if __name__ == "__main__":
+    main()

{fuzzytool-0.1.0 → fuzzytool-0.2.0}/fuzzytool/__init__.py

@@ -18,12 +18,14 @@ t-/s-norms, defuzzifiers): a new variant is a new callable, never a change to
 the inference loop.
 """
 
-from . import cluster, datasets, defuzz, membership, norms, type2
+from . import cluster, datasets, defuzz, fuzzynum, mcdm, membership, norms, type2
 from .anfis import ANFIS
 from .cluster import fuzzy_cmeans, gustafson_kessel, possibilistic_cmeans
 from .ftransform import FTransform
-from .inference import TSK, Mamdani
-from .membership import gauss, gbell, sigmoid, trap, tri
+from .inference import TSK, Mamdani, Tsukamoto
+from .learn import wang_mendel
+from .membership import gauss, gbell, ramp_down, ramp_up, sigmoid, trap, tri
+from .serialize import load, save
 from .sets import Variable
 from .type2 import (
     IT2TSK,
@@ -34,15 +36,18 @@ from .type2 import (
     it2_scale,
 )
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"
 
 __all__ = [
     "__version__",
     "Variable",
     "Mamdani",
     "TSK",
+    "Tsukamoto",
+    # rule learning
+    "wang_mendel",
     # membership shortcuts
-    "tri", "trap", "gauss", "gbell", "sigmoid",
+    "tri", "trap", "gauss", "gbell", "sigmoid", "ramp_up", "ramp_down",
     # interval type-2
     "IT2Mamdani", "IT2TSK",
     "it2", "it2_scale", "it2_gauss_uncertain_mean", "it2_gauss_uncertain_std",
@@ -50,6 +55,9 @@ __all__ = [
     "fuzzy_cmeans", "gustafson_kessel", "possibilistic_cmeans",
     # learning & approximation
     "ANFIS", "FTransform",
+    # serialization
+    "save", "load",
     # submodules
     "membership", "norms", "defuzz", "datasets", "type2", "cluster",
+    "fuzzynum", "mcdm",
 ]

{fuzzytool-0.1.0 → fuzzytool-0.2.0}/fuzzytool/anfis.py

@@ -134,6 +134,19 @@ class ANFIS:
         *_, wn, _ = self._firing(X)
         return self._outputs(X, wn)[1]
 
+    # --- scikit-learn estimator interface ---------------------------------
+
+    def get_params(self, deep: bool = True) -> dict:
+        """Hyperparameters, for scikit-learn compatibility (Pipeline/GridSearch)."""
+        return {"n_inputs": self.p, "n_mf": self.n_mf, "learning_rate": self.lr}
+
+    def set_params(self, **params) -> ANFIS:
+        """Set hyperparameters (resets trained state), returning ``self``."""
+        merged = self.get_params()
+        merged.update(params)
+        self.__init__(**merged)
+        return self
+
     def __repr__(self) -> str:
         return f"ANFIS(n_inputs={self.p}, n_mf={self.n_mf}, rules={self.R})"
 

fuzzytool-0.2.0/fuzzytool/fuzzynum.py

@@ -0,0 +1,161 @@
+"""Fuzzy numbers and their arithmetic.
+
+A fuzzy number is a convex, normal fuzzy set on the reals. This module provides
+the two most used shapes — triangular (TFN) and trapezoidal (TrFN) — with
+standard fuzzy arithmetic (``+ - * /`` and scalar scaling), alpha-cuts, a crisp
+(centroid) value, and a vertex distance used by fuzzy MCDM (see
+:mod:`fuzzytool.mcdm`).
+
+Multiplication and division use the common positive-support approximation
+(operate on the ordered defining points), which is exact for ``+``/``-`` and a
+good approximation for ``*``/``/`` when supports are positive.
+"""
+
+from __future__ import annotations
+
+from numbers import Real
+
+import numpy as np
+
+
+class FuzzyNumber:
+    """Base class for fuzzy numbers defined by ordered points ``p``."""
+
+    points: tuple[float, ...]
+
+    def __init__(self, *points: float) -> None:
+        pts = tuple(float(x) for x in points)
+        if list(pts) != sorted(pts):
+            raise ValueError(f"fuzzy-number points must be non-decreasing, got {pts}")
+        self.points = pts
+
+    # subclasses implement the membership and the crisp value
+    def __call__(self, x):  # pragma: no cover - overridden
+        raise NotImplementedError
+
+    def centroid(self) -> float:  # pragma: no cover - overridden
+        raise NotImplementedError
+
+    def alpha_cut(self, alpha: float) -> tuple[float, float]:  # pragma: no cover
+        raise NotImplementedError
+
+    def _binary(self, other, op, neg=False):
+        cls = type(self)
+        if isinstance(other, Real):
+            other = cls(*([float(other)] * len(self.points)))
+        if not isinstance(other, cls):
+            return NotImplemented
+        b = other.points[::-1] if neg else other.points
+        return cls(*[op(a, c) for a, c in zip(self.points, b)])
+
+    def __add__(self, other):
+        return self._binary(other, lambda a, b: a + b)
+
+    def __sub__(self, other):
+        return self._binary(other, lambda a, b: a - b, neg=True)
+
+    def __mul__(self, other):
+        if isinstance(other, Real):
+            k = float(other)
+            pts = [k * p for p in self.points]
+            return type(self)(*(pts if k >= 0 else pts[::-1]))
+        return self._binary(other, lambda a, b: a * b)
+
+    __rmul__ = __mul__
+    __radd__ = __add__
+
+    def __truediv__(self, other):
+        return self._binary(other, lambda a, b: a / b, neg=True)
+
+    def distance(self, other: FuzzyNumber) -> float:
+        """Vertex distance to another fuzzy number of the same shape."""
+        if type(self) is not type(other):
+            raise TypeError("distance requires fuzzy numbers of the same shape")
+        a = np.asarray(self.points)
+        b = np.asarray(other.points)
+        return float(np.sqrt(np.mean((a - b) ** 2)))
+
+    def __eq__(self, other) -> bool:
+        return type(self) is type(other) and self.points == other.points
+
+    def __hash__(self) -> int:
+        return hash((type(self).__name__, self.points))
+
+
+class TriangularFuzzyNumber(FuzzyNumber):
+    """Triangular fuzzy number ``(a, b, c)`` with peak at ``b``."""
+
+    def __init__(self, a: float, b: float, c: float) -> None:
+        super().__init__(a, b, c)
+        self.a, self.b, self.c = self.points
+
+    def __call__(self, x):
+        x = np.asarray(x, dtype=float)
+        left = np.divide(x - self.a, self.b - self.a, out=np.zeros_like(x),
+                         where=self.b != self.a)
+        right = np.divide(self.c - x, self.c - self.b, out=np.zeros_like(x),
+                          where=self.c != self.b)
+        left = np.where(self.b == self.a, (x >= self.a).astype(float), left)
+        right = np.where(self.c == self.b, (x <= self.c).astype(float), right)
+        return np.clip(np.minimum(left, right), 0.0, 1.0)
+
+    def centroid(self) -> float:
+        return (self.a + self.b + self.c) / 3.0
+
+    def alpha_cut(self, alpha: float) -> tuple[float, float]:
+        return (self.a + alpha * (self.b - self.a),
+                self.c - alpha * (self.c - self.b))
+
+    def __repr__(self) -> str:
+        return f"TFN({self.a}, {self.b}, {self.c})"
+
+
+class TrapezoidalFuzzyNumber(FuzzyNumber):
+    """Trapezoidal fuzzy number ``(a, b, c, d)`` with flat top ``[b, c]``."""
+
+    def __init__(self, a: float, b: float, c: float, d: float) -> None:
+        super().__init__(a, b, c, d)
+        self.a, self.b, self.c, self.d = self.points
+
+    def __call__(self, x):
+        x = np.asarray(x, dtype=float)
+        left = np.divide(x - self.a, self.b - self.a, out=np.ones_like(x),
+                         where=self.b != self.a)
+        right = np.divide(self.d - x, self.d - self.c, out=np.ones_like(x),
+                          where=self.d != self.c)
+        return np.clip(np.minimum.reduce([left, np.ones_like(x), right]), 0.0, 1.0)
+
+    def centroid(self) -> float:
+        a, b, c, d = self.points
+        # Centroid of a trapezoid (handles the triangular degenerate case).
+        num = (d ** 2 + c ** 2 + c * d) - (a ** 2 + b ** 2 + a * b)
+        den = 3.0 * ((c + d) - (a + b))
+        return num / den if den != 0 else (a + b + c + d) / 4.0
+
+    def alpha_cut(self, alpha: float) -> tuple[float, float]:
+        return (self.a + alpha * (self.b - self.a),
+                self.d - alpha * (self.d - self.c))
+
+    def __repr__(self) -> str:
+        return f"TrFN({self.a}, {self.b}, {self.c}, {self.d})"
+
+
+def tfn(a: float, b: float, c: float) -> TriangularFuzzyNumber:
+    """Shortcut for :class:`TriangularFuzzyNumber`."""
+    return TriangularFuzzyNumber(a, b, c)
+
+
+def trfn(a: float, b: float, c: float, d: float) -> TrapezoidalFuzzyNumber:
+    """Shortcut for :class:`TrapezoidalFuzzyNumber`."""
+    return TrapezoidalFuzzyNumber(a, b, c, d)
+
+
+def rank(numbers: list[FuzzyNumber]) -> list[int]:
+    """Indices that sort ``numbers`` from largest to smallest by centroid."""
+    return sorted(range(len(numbers)), key=lambda i: numbers[i].centroid(), reverse=True)
+
+
+__all__ = [
+    "FuzzyNumber", "TriangularFuzzyNumber", "TrapezoidalFuzzyNumber",
+    "tfn", "trfn", "rank",
+]

{fuzzytool-0.1.0 → fuzzytool-0.2.0}/fuzzytool/inference/__init__.py

@@ -2,5 +2,6 @@
 
 from .mamdani import Mamdani
 from .tsk import TSK
+from .tsukamoto import Tsukamoto
 
-__all__ = ["Mamdani", "TSK"]
+__all__ = ["Mamdani", "TSK", "Tsukamoto"]