fuzzytool 0.1.0__tar.gz

fuzzytool-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,24 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.9", "3.11", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install
+        run: pip install -e ".[dev,viz]"
+      - name: Lint
+        run: ruff check fuzzytool tests
+      - name: Test
+        run: pytest -q

fuzzytool-0.1.0/.github/workflows/docs.yml

@@ -0,0 +1,40 @@
+name: Docs
+
+on:
+  push:
+    branches: [main]
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: pages
+  cancel-in-progress: true
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Install (package + docs deps so mkdocstrings can import it)
+        run: pip install -e ".[docs]"
+      - name: Build
+        run: mkdocs build --strict
+      - uses: actions/upload-pages-artifact@v3
+        with:
+          path: site
+
+  deploy:
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - id: deployment
+        uses: actions/deploy-pages@v4

fuzzytool-0.1.0/.github/workflows/release-pypi.yml

@@ -0,0 +1,23 @@
+name: Release (PyPI)
+
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write          # PyPI Trusted Publishing (OIDC) — no API token needed
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Build sdist + wheel
+        run: |
+          pip install build
+          python -m build
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

fuzzytool-0.1.0/.gitignore

@@ -0,0 +1,27 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+.venv/
+venv/
+
+# Tooling
+.pytest_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+.mypy_cache/
+
+# MkDocs build output
+site/
+
+# Jupyter
+.ipynb_checkpoints/
+
+# OS / editor
+.DS_Store
+.vscode/
+.idea/

fuzzytool-0.1.0/.zenodo.json

@@ -0,0 +1,24 @@
+{
+  "title": "fuzzytool: a clean, extensible fuzzy-logic toolkit in pure Python",
+  "description": "A composable, extensible fuzzy-logic toolkit in pure Python + NumPy: membership functions, t-/s-norms, Mamdani and Takagi-Sugeno inference, interval type-2 sets with Karnik-Mendel type reduction, fuzzy clustering (FCM, Gustafson-Kessel, possibilistic), ANFIS, and the F-transform.",
+  "license": "MIT",
+  "upload_type": "software",
+  "access_right": "open",
+  "creators": [
+    {
+      "name": "Salmeron, Jose L.",
+      "affiliation": "CUNEF Universidad"
+    }
+  ],
+  "keywords": [
+    "fuzzy logic",
+    "fuzzy inference",
+    "Mamdani",
+    "Takagi-Sugeno",
+    "interval type-2",
+    "fuzzy clustering",
+    "ANFIS",
+    "F-transform",
+    "Python"
+  ]
+}

fuzzytool-0.1.0/CHANGELOG.md

@@ -0,0 +1,52 @@
+# Changelog
+
+All notable changes to this project are documented here. The format is based on
+[Keep a Changelog](https://keepachangelog.com/) and the project adheres to
+[Semantic Versioning](https://semver.org/).
+
+## [Unreleased]
+
+### Added
+
+- 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.
+- **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_`.
+- **F-transform** (`fuzzytool.ftransform.FTransform`): direct and inverse fuzzy
+  transform over a triangular partition of unity, with `fit` / `smooth` for
+  denoising and compression.
+- **Fuzzy clustering** (`fuzzytool.cluster`):
+  - `fuzzy_cmeans` (Bezdek FCM), `gustafson_kessel` (adaptive Mahalanobis norm),
+    `possibilistic_cmeans` (typicalities); all seeded for reproducibility.
+  - Validity metrics: `partition_coefficient`, `partition_entropy`, `xie_beni`.
+  - `viz.plot_clusters` and `datasets.make_blobs`.
+- **Interval type-2 (IT2)** support (`fuzzytool.type2`):
+  - IT2 membership functions with a footprint of uncertainty: `it2` (explicit
+    LMF/UMF), `it2_scale` (height), `it2_gauss_uncertain_mean`,
+    `it2_gauss_uncertain_std`.
+  - Interval-valued antecedent evaluation (`Antecedent.eval_interval`); type-1
+    and IT2 terms can be mixed in one rule.
+  - `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.

fuzzytool-0.1.0/CITATION.cff

@@ -0,0 +1,18 @@
+cff-version: 1.2.0
+message: "If you use fuzzytool, please cite it as below."
+title: "fuzzytool: a clean, extensible fuzzy-logic toolkit in pure Python"
+type: software
+authors:
+  - family-names: Salmeron
+    given-names: Jose L.
+version: 0.1.0
+date-released: 2026-06-24
+license: MIT
+repository-code: "https://github.com/fuzzytool/fuzzytool.github.io"
+url: "https://fuzzytool.github.io"
+keywords:
+  - fuzzy logic
+  - fuzzy inference
+  - Mamdani
+  - Takagi-Sugeno
+  - Python

fuzzytool-0.1.0/CLAUDE.md

@@ -0,0 +1,82 @@
+# CLAUDE.md
+
+Guide for working in this repository with Claude Code.
+
+## What this project is
+
+**fuzzytool** — a clean, extensible **fuzzy-logic toolkit** in **pure Python +
+NumPy**, published on PyPI with docs on GitHub Pages. Priorities, in order:
+1) a composable API, 2) algorithm comparison, 3) visualization, 4) code clarity.
+It is the fuzzy-logic sibling of the *turboswarm* PSO library and follows the
+same packaging and extensibility philosophy.
+
+## Architecture
+
+```
+fuzzytool/
+  membership.py     MF Protocol + tri/trap/gauss/gbell/sigmoid
+  norms.py          t-norms (AND) / s-norms (OR), resolved by name
+  sets.py           FuzzySet, Variable, antecedent tree (& | ~)
+  rules.py          Rule dataclass (shared by the engines)
+  defuzz.py         centroid / bisector / mom / som / lom
+  inference/        mamdani.py, tsk.py
+  viz.py            matplotlib: membership plots, control surface
+  datasets.py       example systems (credit_risk)
+tests/  examples/  docs/
+```
+
+### The central design (read before touching the engines)
+
+The inference loop knows **nothing** about concrete variants. Everything that
+changes lives behind small Protocols:
+
+- **`MembershipFunction`** (`membership.py`) — a callable `x -> degree`. A new
+  shape is a new callable; nothing else changes.
+- **`Norm`** (`norms.py`) — t-/s-norms, resolved by name via `get_tnorm` /
+  `get_snorm`. You may also pass a callable directly to an engine.
+- **defuzzifiers** (`defuzz.py`) — resolved by name via `get_defuzzifier`.
+
+Rules compose with operators on `Proposition` objects: `&` → t-norm (AND),
+`|` → s-norm (OR), `~` → complement (NOT). The antecedent tree is evaluated by
+`Antecedent.eval(inputs, tnorm, snorm)`; both engines reuse it.
+
+`Mamdani` consequents are propositions (`output[term]`); `TSK` consequents are
+numbers, coefficient mappings, or callables.
+
+## Commands (verified)
+
+```bash
+python -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev,viz,docs]"
+pytest -q                      # tests + doctests (--doctest-modules)
+ruff check fuzzytool tests
+python examples/credit_risk.py
+mkdocs serve                   # docs at http://127.0.0.1:8000
+mkdocs build --strict
+```
+
+## Conventions
+
+- **Language:** all code, comments, identifiers and prose in **English**
+  (published internationally on GitHub and PyPI).
+- **Vectorize:** membership functions accept scalars *and* NumPy arrays.
+- **NumPy 2 compat:** `np.trapz` was renamed `np.trapezoid`; `defuzz.py` shims
+  both — do not call `np.trapz` directly elsewhere.
+- **Tests:** every new MF / connective / defuzzifier / engine needs a test;
+  engines need a behavioral check (monotonicity or known output).
+- **Docstrings:** Google style (rendered by `mkdocstrings`).
+
+## How to extend (typical tasks)
+
+- **New membership function:** any callable `x -> degree`; add a factory in
+  `membership.py` if it is a standard shape, plus a test.
+- **New connective:** register a `(a, b) -> result` in `norms._TNORMS` /
+  `_SNORMS`, or pass it directly to the engine.
+- **New defuzzifier:** add a `(x, y) -> float` to `defuzz._METHODS`.
+- **New engine:** implement `__call__(**inputs)`, reuse `Antecedent.eval` and the
+  shared `Rule`. Templates: `inference/mamdani.py`, `inference/tsk.py`.
+
+## Status
+
+See `ROADMAP.md`. Phase 1 (core + Mamdani) and Phase 2 (TSK + viz) are done;
+type-2, clustering, ANFIS and F-transform are planned.

fuzzytool-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,36 @@
+# Contributing
+
+Thanks for your interest in fuzzytool!
+
+## Setup
+
+```bash
+python -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev,viz,docs]"
+```
+
+## Checks (run before opening a PR)
+
+```bash
+ruff check fuzzytool tests     # lint
+pytest -q                      # tests + doctests
+mkdocs build --strict          # docs build cleanly
+```
+
+## Conventions
+
+- **Language:** all code, comments, identifiers, and prose are in **English**
+  (the project is published internationally on GitHub and PyPI).
+- **Tests:** every new membership function, connective, defuzzifier, or engine
+  needs a test. Inference engines need at least one behavioral test (e.g. a
+  monotonicity or known-output check).
+- **Docstrings:** Google style (rendered by `mkdocstrings`).
+- **Extensibility first:** prefer adding a callable behind an existing Protocol
+  over special-casing the inference loop. See [`docs/extending.md`](docs/extending.md).
+
+## Adding a feature
+
+1. Implement it in the relevant module.
+2. Export it where appropriate (`__init__.py` for public API).
+3. Add tests and a docs entry.
+4. Update `CHANGELOG.md` and, if it completes a milestone, `ROADMAP.md`.

fuzzytool-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jose L. Salmeron
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fuzzytool-0.1.0/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: fuzzytool
+Version: 0.1.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
+Project-URL: Repository, https://github.com/fuzzytool/fuzzytool.github.io
+Project-URL: Issues, https://github.com/fuzzytool/fuzzytool.github.io/issues
+Author: Jose L. Salmeron
+License: MIT
+License-File: LICENSE
+Keywords: anfis,fuzzy inference,fuzzy logic,mamdani,takagi-sugeno,type-2
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.9
+Requires-Dist: numpy>=1.21
+Provides-Extra: dev
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest>=7; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs-material; extra == 'docs'
+Requires-Dist: mkdocstrings[python]; extra == 'docs'
+Provides-Extra: notebooks
+Requires-Dist: ipykernel; extra == 'notebooks'
+Requires-Dist: jupyter; extra == 'notebooks'
+Requires-Dist: matplotlib>=3.4; extra == 'notebooks'
+Requires-Dist: nbconvert; extra == 'notebooks'
+Requires-Dist: nbformat; extra == 'notebooks'
+Provides-Extra: viz
+Requires-Dist: matplotlib>=3.4; extra == 'viz'
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <a href="https://pypi.org/project/fuzzytool/"><img src="https://img.shields.io/pypi/v/fuzzytool?logo=pypi&logoColor=white" alt="PyPI"></a>
+  <a href="https://github.com/fuzzytool/fuzzytool.github.io/actions/workflows/ci.yml"><img src="https://github.com/fuzzytool/fuzzytool.github.io/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
+  <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">
+</p>
+
+# fuzzytool
+
+A clean, **extensible fuzzy-logic toolkit** in **pure Python + NumPy**. Its
+design priorities are a composable API, algorithm comparison, visualization and
+code clarity — a modern alternative to the verbose control API of scikit-fuzzy.
+
+```python
+import fuzzytool as fz
+
+# Credit-risk premium: a lender turns a credit score + debt-to-income ratio
+# into the risk points it adds on top of its base interest rate.
+score   = fz.Variable("score", (300, 850), terms=["poor", "fair", "good", "excellent"])
+dti     = fz.Variable("dti", (0, 50), terms=["low", "moderate", "high"])
+premium = fz.Variable("premium", (0, 12), terms=["low", "medium", "high"])
+
+sys = fz.Mamdani(defuzz="centroid")
+sys.rule(score["poor"] | dti["high"], premium["high"])        # |=OR  &=AND  ~=NOT
+sys.rule(score["fair"] & dti["moderate"], premium["medium"])
+sys.rule(score["good"] | score["excellent"], premium["low"])
+
+print(sys(score=800, dti=10))    # the system is just callable -> a low premium
+```
+
+## The design idea (extensibility)
+
+The inference loop knows **nothing** about any concrete variant. Everything that
+changes lives behind small Python **Protocols**:
+
+- **`MembershipFunction`** (`fuzzytool/membership.py`) — a callable `x -> degree`.
+  A new shape = a new callable.
+- **`Norm`** (`fuzzytool/norms.py`) — t-norms (AND) and s-norms (OR), resolved by
+  name. A new connective = one registered function.
+- **defuzzifiers** (`fuzzytool/defuzz.py`) — centroid, bisector, MOM/SOM/LOM,
+  resolved by name.
+
+Rules read like logic thanks to operator overloading: `&` is the t-norm, `|` the
+s-norm, `~` the complement.
+
+## What it includes / roadmap
+
+| Phase | Content | Status |
+|------|-----------|--------|
+| 1 | Core: membership functions, t-/s-norms, `Variable`, operator rules, **Mamdani** + defuzzification, tipper example, tests | ✅ |
+| 2 | **Takagi-Sugeno (TSK)** inference + `viz` (membership plots, control surface) | ✅ (TSK + viz) |
+| 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 | ⏳ |
+
+See [`ROADMAP.md`](ROADMAP.md).
+
+## Install
+
+```bash
+pip install fuzzytool            # core (NumPy only)
+pip install fuzzytool[viz]       # + matplotlib visualization
+```
+
+From source, for development:
+
+```bash
+python -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev,viz,docs]"
+pytest -q
+python examples/tipper.py
+```
+
+## Documentation
+
+A documentation portal (narrative guide + API reference from docstrings) is built
+with **MkDocs Material** and published to **GitHub Pages**:
+<https://fuzzytool.github.io/>.
+
+```bash
+pip install -e ".[docs]"
+mkdocs serve        # live portal at http://127.0.0.1:8000
+```
+
+## License
+
+MIT. See [`LICENSE`](LICENSE).

fuzzytool-0.1.0/README.md

@@ -0,0 +1,89 @@
+<p align="center">
+  <a href="https://pypi.org/project/fuzzytool/"><img src="https://img.shields.io/pypi/v/fuzzytool?logo=pypi&logoColor=white" alt="PyPI"></a>
+  <a href="https://github.com/fuzzytool/fuzzytool.github.io/actions/workflows/ci.yml"><img src="https://github.com/fuzzytool/fuzzytool.github.io/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
+  <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">
+</p>
+
+# fuzzytool
+
+A clean, **extensible fuzzy-logic toolkit** in **pure Python + NumPy**. Its
+design priorities are a composable API, algorithm comparison, visualization and
+code clarity — a modern alternative to the verbose control API of scikit-fuzzy.
+
+```python
+import fuzzytool as fz
+
+# Credit-risk premium: a lender turns a credit score + debt-to-income ratio
+# into the risk points it adds on top of its base interest rate.
+score   = fz.Variable("score", (300, 850), terms=["poor", "fair", "good", "excellent"])
+dti     = fz.Variable("dti", (0, 50), terms=["low", "moderate", "high"])
+premium = fz.Variable("premium", (0, 12), terms=["low", "medium", "high"])
+
+sys = fz.Mamdani(defuzz="centroid")
+sys.rule(score["poor"] | dti["high"], premium["high"])        # |=OR  &=AND  ~=NOT
+sys.rule(score["fair"] & dti["moderate"], premium["medium"])
+sys.rule(score["good"] | score["excellent"], premium["low"])
+
+print(sys(score=800, dti=10))    # the system is just callable -> a low premium
+```
+
+## The design idea (extensibility)
+
+The inference loop knows **nothing** about any concrete variant. Everything that
+changes lives behind small Python **Protocols**:
+
+- **`MembershipFunction`** (`fuzzytool/membership.py`) — a callable `x -> degree`.
+  A new shape = a new callable.
+- **`Norm`** (`fuzzytool/norms.py`) — t-norms (AND) and s-norms (OR), resolved by
+  name. A new connective = one registered function.
+- **defuzzifiers** (`fuzzytool/defuzz.py`) — centroid, bisector, MOM/SOM/LOM,
+  resolved by name.
+
+Rules read like logic thanks to operator overloading: `&` is the t-norm, `|` the
+s-norm, `~` the complement.
+
+## What it includes / roadmap
+
+| Phase | Content | Status |
+|------|-----------|--------|
+| 1 | Core: membership functions, t-/s-norms, `Variable`, operator rules, **Mamdani** + defuzzification, tipper example, tests | ✅ |
+| 2 | **Takagi-Sugeno (TSK)** inference + `viz` (membership plots, control surface) | ✅ (TSK + viz) |
+| 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 | ⏳ |
+
+See [`ROADMAP.md`](ROADMAP.md).
+
+## Install
+
+```bash
+pip install fuzzytool            # core (NumPy only)
+pip install fuzzytool[viz]       # + matplotlib visualization
+```
+
+From source, for development:
+
+```bash
+python -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev,viz,docs]"
+pytest -q
+python examples/tipper.py
+```
+
+## Documentation
+
+A documentation portal (narrative guide + API reference from docstrings) is built
+with **MkDocs Material** and published to **GitHub Pages**:
+<https://fuzzytool.github.io/>.
+
+```bash
+pip install -e ".[docs]"
+mkdocs serve        # live portal at http://127.0.0.1:8000
+```
+
+## License
+
+MIT. See [`LICENSE`](LICENSE).

fuzzytool-0.1.0/ROADMAP.md

@@ -0,0 +1,52 @@
+# Roadmap
+
+Phases mirror the structure of the sibling project *turboswarm*: each phase is a
+self-contained, testable increment.
+
+## ✅ Phase 1 — Core + Mamdani
+
+- [x] Membership functions (tri, trap, gauss, gbell, sigmoid) behind the
+      `MembershipFunction` Protocol.
+- [x] T-norms / s-norms resolved by name; standard complement.
+- [x] `Variable` + operator-based antecedent tree (`&`, `|`, `~`).
+- [x] Mamdani inference + defuzzification (centroid, bisector, MOM/SOM/LOM).
+- [x] Tipper example, test suite, packaging, docs, CI.
+
+## ✅ Phase 2 — TSK + visualization
+
+- [x] Takagi-Sugeno inference (zero/first-order + callable consequents).
+- [x] `viz`: membership plots, 2-input control surface.
+- [ ] Example notebooks (tipper, TSK, comparison).
+
+## ✅ Phase 3 — Type-2 / interval type-2
+
+- [x] IT2 membership functions (footprint of uncertainty): explicit LMF/UMF,
+      height scaling, uncertain Gaussian mean, uncertain Gaussian spread.
+- [x] Interval antecedent evaluation (type-1 and IT2 terms mix freely).
+- [x] IT2 inference: `IT2Mamdani` (center-of-sets) and `IT2TSK`.
+- [x] Karnik-Mendel type reduction (`km_endpoint`, `karnik_mendel`,
+      `centroid_it2`) + FOU visualization.
+
+## ✅ Phase 4 — Fuzzy clustering
+
+- [x] Fuzzy c-means (FCM).
+- [x] Gustafson-Kessel.
+- [x] Possibilistic c-means.
+- [x] Cluster-quality metrics (partition coefficient, partition entropy,
+      Xie-Beni) + 2-D cluster visualization and a synthetic-blob generator.
+
+## ✅ Phase 5 — ANFIS + F-transform
+
+- [x] ANFIS: trainable first-order TSK with Jang's hybrid learning (least
+      squares for consequents + gradient descent for premises).
+- [x] F-transform: direct and inverse over a triangular fuzzy partition
+      (partition of unity), with smoothing/denoising.
+
+## ⏳ Phase 6 — Release
+
+- [x] Example notebooks (`notebooks/`) and a comparison page vs scikit-fuzzy.
+- [x] JOSS `paper.md`; Zenodo metadata (`.zenodo.json`) and a citing/releasing page.
+- [x] GitHub Pages live (`https://fuzzytool.github.io`).
+- [ ] Register the PyPI trusted publisher, then tag `v0.1.0` to publish (the
+      `release-pypi.yml` workflow is ready).
+- [ ] Enable the Zenodo GitHub integration and cut a release to mint a DOI.