evtools-dst 0.1.0__py3-none-any.whl

evtools/__init__.py

@@ -0,0 +1,29 @@
+"""
+evtools — Evidence Theory Tools
+================================
+
+A growing collection of utilities for working with belief functions
+in the Dempster-Shafer theory of evidence.
+
+Submodules
+----------
+evtools.conversions
+    Conversion functions between all standard belief function
+    representations (m, bel, pl, b, q, v, w).
+
+Usage
+-----
+Import the submodule::
+
+    from evtools import conversions
+    conversions.mtob(m)
+
+Or import functions directly::
+
+    from evtools.conversions import mtob, mtopl
+"""
+
+from . import conversions
+
+__version__ = "0.1.0"
+__all__ = ["conversions"]

evtools/conversions.py

@@ -0,0 +1,329 @@
+"""
+Conversion functions between the different representations of belief functions
+in the Dempster-Shafer theory of evidence.
+
+Supported representations:
+    - b   : commonality function
+    - bel : belief function
+    - m   : basic belief assignment (mass function)
+    - pl  : plausibility function
+    - q   : implicability function
+    - v   : conjunctive weight function
+    - w   : disjunctive weight function
+
+Each function is named ``<source>to<target>``, e.g. ``mtob`` converts a mass
+function to a commonality function.
+
+References:
+    Smets, P. (2002). The application of the transferable belief model to
+    diagnostic problems. International Journal of Intelligent Systems.
+
+    Denoeux, T. (2008). Conjunctive and disjunctive combination of belief
+    functions induced by non-distinct bodies of evidence. Artificial
+    Intelligence.
+"""
+
+import numpy as np
+
+
+# ---------------------------------------------------------------------------
+# bto* — from commonality function
+# ---------------------------------------------------------------------------
+
+def btobel(b: np.ndarray) -> np.ndarray:
+    """Convert commonality *b* to belief function *bel*.
+
+    bel(A) = b(A) - m(∅)
+    """
+    return b - b[0]
+
+
+def btom(b: np.ndarray) -> np.ndarray:
+    """Convert commonality *b* to mass function *m* using the FMT (Smets)."""
+    b = np.copy(b)
+    lb = len(b)
+    natoms = int(np.round(np.log2(lb)))
+    for step in range(1, natoms + 1):
+        i124 = 2 ** (step - 1)
+        i842 = 2 ** (natoms + 1 - step)
+        i421 = 2 ** (natoms - step)
+        b = b.reshape(i124, i842, order="F")
+        b[:, np.arange(1, i421 + 1) * 2 - 1] -= b[:, np.arange(1, i421 + 1) * 2 - 2]
+    return b.reshape(1, lb, order="F").ravel()
+
+
+def btopl(b: np.ndarray) -> np.ndarray:
+    """Convert commonality *b* to plausibility function *pl*.
+
+    pl(A) = 1 - b(Ā)
+    """
+    b = np.copy(b)
+    lb = len(b)
+    b = b.reshape(1, lb, order="F")
+    b = b[0][-1] - np.fliplr(b).ravel()
+    b[0] = 0
+    return b
+
+
+def btoq(b: np.ndarray) -> np.ndarray:
+    """Convert commonality *b* to implicability function *q*."""
+    return pltoq(btopl(b))
+
+
+def btov(b: np.ndarray) -> np.ndarray:
+    """Convert commonality *b* to conjunctive weight function *v* (Denoeux 2008)."""
+    v = np.exp(-btom(np.log(b)))
+    v[0] = 1
+    return v
+
+
+def btow(b: np.ndarray) -> np.ndarray:
+    """Convert commonality *b* to disjunctive weight function *w*."""
+    return qtow(btoq(b))
+
+
+# ---------------------------------------------------------------------------
+# belto* — from belief function
+# ---------------------------------------------------------------------------
+
+def beltob(bel: np.ndarray) -> np.ndarray:
+    """Convert belief function *bel* to commonality *b*.
+
+    b(A) = bel(A) + m(∅)
+    """
+    m_emptyset = 1 - bel[-1]
+    return bel + m_emptyset
+
+
+def beltom(bel: np.ndarray) -> np.ndarray:
+    """Convert belief function *bel* to mass function *m*."""
+    return btom(beltob(bel))
+
+
+def beltopl(bel: np.ndarray) -> np.ndarray:
+    """Convert belief function *bel* to plausibility function *pl*."""
+    return btopl(bel)
+
+
+def beltoq(bel: np.ndarray) -> np.ndarray:
+    """Convert belief function *bel* to implicability function *q*."""
+    return btoq(bel)
+
+
+def beltov(bel: np.ndarray) -> np.ndarray:
+    """Convert belief function *bel* to conjunctive weight function *v*."""
+    return btov(beltob(bel))
+
+
+def beltow(bel: np.ndarray) -> np.ndarray:
+    """Convert belief function *bel* to disjunctive weight function *w*."""
+    return qtow(beltoq(bel))
+
+
+# ---------------------------------------------------------------------------
+# mto* — from mass function
+# ---------------------------------------------------------------------------
+
+def mtob(m: np.ndarray) -> np.ndarray:
+    """Convert mass function *m* to commonality *b* using the FMT (Smets)."""
+    m = np.copy(m)
+    lm = len(m)
+    natoms = int(np.round(np.log2(lm)))
+    for step in range(1, natoms + 1):
+        i124 = 2 ** (step - 1)
+        i842 = 2 ** (natoms + 1 - step)
+        i421 = 2 ** (natoms - step)
+        m = m.reshape(i124, i842, order="F")
+        m[:, np.arange(1, i421 + 1) * 2 - 1] += m[:, np.arange(1, i421 + 1) * 2 - 2]
+    return m.reshape(1, lm, order="F").ravel()
+
+
+def mtobel(m: np.ndarray) -> np.ndarray:
+    """Convert mass function *m* to belief function *bel*."""
+    return btobel(mtob(m))
+
+
+def mtopl(m: np.ndarray) -> np.ndarray:
+    """Convert mass function *m* to plausibility function *pl*."""
+    return btopl(mtob(m))
+
+
+def mtoq(m: np.ndarray) -> np.ndarray:
+    """Convert mass function *m* to implicability function *q* using the FMT (Smets)."""
+    m = np.copy(m)
+    lm = len(m)
+    natoms = int(np.round(np.log2(lm)))
+    for step in range(1, natoms + 1):
+        i124 = 2 ** (step - 1)
+        i842 = 2 ** (natoms + 1 - step)
+        i421 = 2 ** (natoms - step)
+        m = m.reshape(i124, i842, order="F")
+        m[:, np.arange(1, i421 + 1) * 2 - 2] += m[:, np.arange(1, i421 + 1) * 2 - 1]
+    return m.reshape(1, lm, order="F").ravel()
+
+
+def mtov(m: np.ndarray) -> np.ndarray:
+    """Convert mass function *m* to conjunctive weight function *v*."""
+    return btov(mtob(m))
+
+
+def mtow(m: np.ndarray) -> np.ndarray:
+    """Convert mass function *m* to disjunctive weight function *w*."""
+    return qtow(mtoq(m))
+
+
+# ---------------------------------------------------------------------------
+# plto* — from plausibility function
+# ---------------------------------------------------------------------------
+
+def pltob(pl: np.ndarray) -> np.ndarray:
+    """Convert plausibility function *pl* to commonality *b*.
+
+    b(A) = 1 - pl(Ā)
+    """
+    pl = np.copy(pl)
+    lpl = len(pl)
+    pl = pl.reshape(1, lpl, order="F")
+    return 1 - np.fliplr(pl).ravel()
+
+
+def pltobel(pl: np.ndarray) -> np.ndarray:
+    """Convert plausibility function *pl* to belief function *bel*."""
+    return btobel(pltob(pl))
+
+
+def pltom(pl: np.ndarray) -> np.ndarray:
+    """Convert plausibility function *pl* to mass function *m*."""
+    return btom(pltob(pl))
+
+
+def pltoq(pl: np.ndarray) -> np.ndarray:
+    """Convert plausibility function *pl* to implicability function *q* (Smets 2002)."""
+    q = np.abs(btom(pl))
+    q[0] = 1
+    return q
+
+
+def pltov(pl: np.ndarray) -> np.ndarray:
+    """Convert plausibility function *pl* to conjunctive weight function *v*."""
+    return btov(pltob(pl))
+
+
+def pltow(pl: np.ndarray) -> np.ndarray:
+    """Convert plausibility function *pl* to disjunctive weight function *w*."""
+    return qtow(pltoq(pl))
+
+
+# ---------------------------------------------------------------------------
+# qto* — from implicability function
+# ---------------------------------------------------------------------------
+
+def qtob(q: np.ndarray) -> np.ndarray:
+    """Convert implicability function *q* to commonality *b*."""
+    return pltob(qtopl(q))
+
+
+def qtobel(q: np.ndarray) -> np.ndarray:
+    """Convert implicability function *q* to belief function *bel*."""
+    return btobel(qtob(q))
+
+
+def qtom(q: np.ndarray) -> np.ndarray:
+    """Convert implicability function *q* to mass function *m* using the FMT (Smets)."""
+    q = np.copy(q)
+    lq = len(q)
+    natoms = int(np.round(np.log2(lq)))
+    for step in range(1, natoms + 1):
+        i124 = 2 ** (step - 1)
+        i842 = 2 ** (natoms + 1 - step)
+        i421 = 2 ** (natoms - step)
+        q = q.reshape(i124, i842, order="F")
+        q[:, np.arange(1, i421 + 1) * 2 - 2] -= q[:, np.arange(1, i421 + 1) * 2 - 1]
+    return q.reshape(1, lq, order="F").ravel()
+
+
+def qtopl(q: np.ndarray) -> np.ndarray:
+    """Convert implicability function *q* to plausibility function *pl* (Smets 2002)."""
+    q = np.copy(q)
+    q[0] = 0
+    return np.abs(btom(q))
+
+
+def qtov(q: np.ndarray) -> np.ndarray:
+    """Convert implicability function *q* to conjunctive weight function *v*."""
+    return btov(qtob(q))
+
+
+def qtow(q: np.ndarray) -> np.ndarray:
+    """Convert implicability function *q* to disjunctive weight function *w* (Denoeux 2008)."""
+    w = np.exp(-qtom(np.log(q)))
+    w[-1] = 1
+    return w
+
+
+# ---------------------------------------------------------------------------
+# vto* — from conjunctive weight function
+# ---------------------------------------------------------------------------
+
+def vtob(v: np.ndarray) -> np.ndarray:
+    """Convert conjunctive weight function *v* to commonality *b* (Denoeux 2008)."""
+    return np.prod(v) / np.exp(mtob(np.log(v)))
+
+
+def vtobel(v: np.ndarray) -> np.ndarray:
+    """Convert conjunctive weight function *v* to belief function *bel*."""
+    return btobel(vtob(v))
+
+
+def vtom(v: np.ndarray) -> np.ndarray:
+    """Convert conjunctive weight function *v* to mass function *m*."""
+    return btom(vtob(v))
+
+
+def vtopl(v: np.ndarray) -> np.ndarray:
+    """Convert conjunctive weight function *v* to plausibility function *pl*."""
+    return btopl(vtob(v))
+
+
+def vtoq(v: np.ndarray) -> np.ndarray:
+    """Convert conjunctive weight function *v* to implicability function *q*."""
+    return btoq(vtob(v))
+
+
+def vtow(v: np.ndarray) -> np.ndarray:
+    """Convert conjunctive weight function *v* to disjunctive weight function *w*."""
+    return btow(vtob(v))
+
+
+# ---------------------------------------------------------------------------
+# wto* — from disjunctive weight function
+# ---------------------------------------------------------------------------
+
+def wtob(w: np.ndarray) -> np.ndarray:
+    """Convert disjunctive weight function *w* to commonality *b*."""
+    return qtob(wtoq(w))
+
+
+def wtobel(w: np.ndarray) -> np.ndarray:
+    """Convert disjunctive weight function *w* to belief function *bel*."""
+    return qtobel(wtoq(w))
+
+
+def wtom(w: np.ndarray) -> np.ndarray:
+    """Convert disjunctive weight function *w* to mass function *m*."""
+    return qtom(wtoq(w))
+
+
+def wtopl(w: np.ndarray) -> np.ndarray:
+    """Convert disjunctive weight function *w* to plausibility function *pl*."""
+    return qtopl(wtoq(w))
+
+
+def wtoq(w: np.ndarray) -> np.ndarray:
+    """Convert disjunctive weight function *w* to implicability function *q* (Denoeux 2008)."""
+    return np.prod(w) / np.exp(mtoq(np.log(w)))
+
+
+def wtov(w: np.ndarray) -> np.ndarray:
+    """Convert disjunctive weight function *w* to conjunctive weight function *v*."""
+    return qtov(wtoq(w))

evtools_dst-0.1.0.dist-info/METADATA

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: evtools-dst
+Version: 0.1.0
+Summary: Evidence Theory Tools — utilities for Dempster-Shafer theory of belief functions
+Project-URL: Homepage, https://github.com/ton-username/evtools
+Project-URL: Repository, https://github.com/ton-username/evtools
+Project-URL: Issues, https://github.com/ton-username/evtools/issues
+Keywords: belief functions,Dempster-Shafer,evidence theory,mass function,plausibility,transferable belief model
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.24
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+
+# evtools
+
+**Evidence Theory Tools** — a growing Python library of utilities for working
+with belief functions in the Dempster-Shafer theory of evidence.
+
+## Modules
+
+| Module | Description |
+|--------|-------------|
+| `evtools.conversions` | Conversions between all standard belief function representations |
+
+---
+
+## `evtools.conversions`
+
+Converts between all standard representations of belief functions using the
+**Fast Möbius Transform** (FMT) from Smets (2002) and Denoeux (2008).
+
+### Supported representations
+
+| Symbol | Name |
+|--------|------|
+| `m`   | Basic Belief Assignment (mass function) |
+| `bel` | Belief function |
+| `pl`  | Plausibility function |
+| `b`   | Commonality function |
+| `q`   | Implicability function |
+| `v`   | Conjunctive weight function |
+| `w`   | Disjunctive weight function |
+
+Every conversion is available as a `<source>to<target>` function.
+For example `mtob`, `pltom`, `qtow`, `beltov`, etc.
+
+---
+
+## Installation
+
+```bash
+pip install evtools
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/<your-username>/evtools.git
+cd evtools
+pip install -e .
+```
+
+## Quick start
+
+```python
+import numpy as np
+from evtools.conversions import mtob, mtopl, mtobel, mtow
+
+# Mass function over a 2-atom frame {a, b}
+# Index order: ∅, {a}, {b}, {a,b}
+m = np.array([0.0, 0.3, 0.5, 0.2])
+
+print(mtob(m))    # commonality function
+print(mtopl(m))   # plausibility function
+print(mtobel(m))  # belief function
+print(mtow(m))    # disjunctive weight function
+```
+
+## Running tests
+
+```bash
+pip install -e ".[dev]"
+pytest tests/
+```
+
+## References
+
+- Smets, P. (2002). *The application of the transferable belief model to diagnostic problems.* International Journal of Intelligent Systems.
+- Denoeux, T. (2008). *Conjunctive and disjunctive combination of belief functions induced by non-distinct bodies of evidence.* Artificial Intelligence.
+
+## License
+
+MIT

evtools_dst-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+evtools/__init__.py,sha256=dT51vadV8RJuDLuQv66ubEC_vYFurr5SEe4AzO4zLkc,592
+evtools/conversions.py,sha256=14qtcgyTYqsjfsTMkCea7rjh27nnvjx6DkSFQ1wesbA,10296
+evtools_dst-0.1.0.dist-info/METADATA,sha256=ScZ38a7Gb1O0lvRDprIj6XWf7LL5k17PCdF4wqpxtms,3072
+evtools_dst-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+evtools_dst-0.1.0.dist-info/top_level.txt,sha256=2yDR1wgq5Z6XeHVKOu4LSDzFAvetUUEVrmUF2nkARUg,8
+evtools_dst-0.1.0.dist-info/RECORD,,

evtools_dst-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

evtools_dst-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+evtools