fuzzyroutines 2.0.0

A mathematically explicit Python foundation for fuzzy sets, membership functions, linguistic models, and compatibility-safe modernization.

FuzzyRoutines 2.0 combines a modern typed API with the protected historical API. See the current implementation boundary.

At a glance

FuzzyRoutines targets scientific-grade behavior within fuzzy computing: explicit domains, traceable formulas, analytical results where practical, controlled numerical methods elsewhere, and executable evidence for important boundaries and invariants. It is a focused library, not a computer-algebra system or notebook environment.

Start with the canonical mathematical model for the integrated definitions, formulas, compatibility spellings, and explicit implemented-versus-roadmap boundary.

Install

Use CPython 3.13 or 3.14:

python -m pip install fuzzyroutines==2.0.0

Historical 1.x packages do not provide the modern API shown below. For a source checkout, see Development.

The quick start explains installation and classifies a 24 °C measurement. Explore nine worked scenarios, with independent numerical checks and eleven reproducible scientific figures, or reconstruct the historical Universal Fuzzy Scale, or browse the membership gallery. The computation diagrams explain the different workflows; the public example index links all 193 inventoried public symbols to executed examples. From a checkout with the package installed, python -I examples/guide.py runs every scenario without NumPy, Matplotlib, network access, or file creation.

Choose the API surface

Modern example

from fuzzyroutines import ContinuousUniverse, DeriveProperties, ScalarFuzzySet, Triangle

universe = ContinuousUniverse(0.0, 1.0, leftClosed=True, rightClosed=True)
membership = Triangle(left=0.0, peak=0.5, right=1.0)
fuzzySet = ScalarFuzzySet(universe, membership)
properties = DeriveProperties(membership, universe)

assert fuzzySet.Membership(0.5) == 1.0
assert properties.core.Contains(0.5)
assert properties.height == 1.0

A declared ContinuousUniverse is part of fuzzy-set identity. An IntegrationDomain is only a finite interval used by a numerical method; it is never mathematical support.

Historical compatibility example

from fuzzyroutines.FuzzyRoutines import FuzzySet, MFunction, TNorm

membership = MFunction("triangle", a=0.0, b=1.0, c=0.5)
fuzzySet = FuzzySet(
    membership,
    supportSet=(0.0, 1.0),
    linguisticName="Medium",
)

print(TNorm(0.4, 0.7, normType="algebraic"))
print(fuzzySet.Defuz())

The legacy triangle order is a, b, c, where c is the apex. Protected names and corrected historical defects are tracked in the compatibility ledger.

Core contracts

Documentation map

Development

For an editable source checkout:

git clone --branch master https://github.com/Fuzzy-Technologies/FuzzyRoutines.git
cd FuzzyRoutines
python -m pip install -e .
python -m pip install -r requirements.txt
python -m pytest -q tests/test_membership_function_contracts.py
python -m ruff check fuzzyroutines/membership.py

Choose the tests and lint paths for the files and contracts being changed. PR CI runs the complete deterministic suite, typing, documentation builds, and package installation gates. Full local regression and build runs are reserved for an explicit maintainer request.

The canonical full-suite runner, python -m tools.test_runner, discovers the complete suite, uses independent pytest-xdist worker processes by default, caps automatic parallelism at 12, and moves tests marked serial into a separate sequential phase. Use --jobs N, --timeout N, --serial, or --fail-fast for an explicit run. It never retries failures automatically.

The project intentionally does not use ruff format. Markdown tables are source-aligned and checked automatically. Generated API HTML is disposable output under _build/api-reference/; annotations, English Google-style Markdown docstrings, and tracked Markdown remain the sources of truth.

Roadmap boundary

The current typed surface already includes explicit scalar universes, immutable fuzzy sets, operations, derived properties, alpha-cuts, comparison policies, and linguistic representations. Inline modern annotations, py.typed, strict source checks, and installed-wheel consumer checks are implemented; see the typing contract. Symmetric difference, executable convexity, defuzzification methods beyond the implemented centroid contract, vectorized backends, and free-threaded CPython support remain roadmap work. Performance and concurrency claims require numerical-parity, timing, memory, and race-safety evidence.

The generated reference is composed with the FuzzyRoutines GitHub Pages site. Pull requests and develop produce preview artifacts; production deployment occurs only from the approved master branch. Stable routes separate the moving references in English, Russian and Simplified Chinese. The version index links to tagged sources for historical versions. Separately hosted documentation snapshots for individual releases are not currently provided.

License

Source code, tests, documentation, examples, tools, workflows, and project-owned site assets are licensed under the Apache License 2.0. Redistributions must preserve the license, copyright, and attribution notices, including NOTICE.

The license does not grant permission to use Fuzzy Technologies trade names or marks beyond reasonable attribution and the NOTICE requirements. See the licensing and provenance policy.