decision-methods 0.1.0__tar.gz

decision_methods-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jose Francisco Benavente, Jose Antonio Suarez
+
+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.

decision_methods-0.1.0/PKG-INFO

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: decision_methods
+Version: 0.1.0
+Summary: Library for decision threshold and boundary methods
+Author-email: Jose Francisco Benavente Cuevas <jf.benavente@ciemat.es>, Jose Antonio Suarez Navarro <ja.suarez@ciemat.es>, Victor Manuel Exposito Suarez <VictorManuel.Exposito@ciemat.es>
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20
+Requires-Dist: matplotlib>=3.5
+Requires-Dist: scipy
+Dynamic: license-file
+
+# 🚀 decision_methods
+
+**A scientific Python library for computing decision thresholds and limits using numerical methods independent of the analytical expression.**
+
+Includes advanced implementations such as:
+- **UD** — Decision Threshold  
+- **LID** — Decision Limit  
+
+---
+
+## ✨ Key Features
+
+- Numerical methods applicable to **any analytical model**
+- Full **uncertainty propagation**
+- Robust **root-finding algorithms**
+- Scientific computation ready for real-world data
+- Visualization tools for LID analysis
+
+---
+
+## ⚙️ Core Function
+
+### 🔹 `compute_F_ud_lid`
+
+Computes:
+
+- Model value  
+- Associated uncertainty  
+- Decision Threshold (**UD**)  
+- Decision Limit (**LID**)  
+
+#### **Parameters**
+
+- `p` *(array-like)* — Model parameter vector  
+- `t_m` *(float)* — Measurement time  
+- `t_f` *(float)* — Background time  
+- `f` *(callable)* — Multivariable function  
+- `pderivative` *(callable)* — Partial derivative function  
+- `bisection` *(callable)* — Root-finding method  
+- `k` *(float, optional)* — Coverage factor *(default: 1.65)*  
+- `LID_a` *(float)* — Lower bound for LID search  
+- `LID_b` *(float)* — Upper bound for LID search  
+- `cpm_min`*(float)* — Lower bound of the count rate (counts per unit time, e.g., minutes or seconds; CPM) used in the LID search
+- `cpm_max`*(float)* — Upper bound of the count rate (counts per unit time, e.g., minutes or seconds; CPM) used in the LID search
+- `cpm_index`*(integer)* — Index of the parameter corresponding to the count rate (CPM) used in the LID search 
+- `sample_indices` *(tuple of int, optional)* — Indices of parameters corresponding to sample measurements modeled as Poisson-distributed variables, with expected counts defined as the parameter value scaled by the measurement time t_m *(default: (0,))*  
+- `background_indices` *(tuple of int, optional)* — Indices of parameters corresponding to sample measurements modeled as Poisson-distributed variables, with expected counts defined as the parameter value scaled by the measurement time t_f *(default: (1,))*   
+- `rel_map` *(tuple of (int, float), optional)* — Relative uncertainty definitions as *(index, relative_error)* pairs  
+- `frac_fondo` *(float, optional)* — Relative uncertainty for background when `t_f <= 0`  
+
+#### **Returns**
+
+- `value` *(float)* — Evaluated value of the model function  
+- `u_value` *(float)* — Combined uncertainty  
+- `UD` *(float)* — Decision threshold  
+- `LID` *(float)* — Decision limit  
+#### **Returns**
+
+- `value` *(float)* — Evaluated value of the model function  
+- `u_value` *(float)* — Combined uncertainty  
+- `UD` *(float)* — Decision threshold  
+- `LID` *(float)* — Decision limit  
+
+---
+
+## 📊 Visualization
+
+### 🔹 `plot_lid_function`
+
+Generates plots to analyze LID behavior.
+
+#### **Parameters**
+
+- `LID_a` *(float)* — Lower bound  
+- `LID_b` *(float)* — Upper bound  
+- `p` *(array-like)* — Parameters  
+- `f` *(callable)* — Function  
+- `UD` *(float)* — Decision threshold  
+- `t_m` *(float)* — Measurement time  
+- `t_f` *(float)* — Background time  
+- `pderivative` *(callable)* — Partial derivative function  
+- `bisection` *(callable)* — Root-finding method  
+- `cpm_min`*(float)* — Lower bound of the count rate (counts per unit time, e.g., minutes or seconds; CPM) used in the LID search
+- `cpm_max`*(float)* — Upper bound of the count rate (counts per unit time, e.g., minutes or seconds; CPM) used in the LID search
+- `n`*(integer)* — Number of samples or observations used in the LID search
+- `cpm_index`*(integer)* — Index of the parameter corresponding to the count rate (CPM) used in the LID search 
+- `k` *(float, optional)* — Coverage factor *(default: 1.65)*  
+- `rel_map` *(tuple of (int, float), optional)* — Relative uncertainty definitions as *(index, relative_error)* pairs  
+
+---
+
+## 🧪 Activity Functions
+
+### 🔹 `AT` — Total Alpha
+
+Computes total alpha activity.
+
+$AT(Bq\cdot m^{3})= \frac{CPM_M-CPM_F}{60 \cdot ɛ \cdot V_{Alicuot}}$
+
+#### **Parameters**
+
+- `CPM_m` *(float)* — Sample counts  
+- `CPM_f` *(float)* — Background counts  
+- `Eps` *(float)* — Detection efficiency  
+- `V_ali` *(float)* — Aliquot volume  
+
+#### **Returns**
+
+- *(float)* — Activity  
+
+---
+
+### 🔹 `BT` — Total Beta
+
+Computes total beta activity.
+
+$BT(Bq\cdot m^{3})= \frac{CPM_{\beta-M}-CPM_{\beta-F} - γ \cdot(CPM_{α-M}-CPM_{α-F})}{60 \cdot Ef_{Sr} \cdot V_{Alicuot}⋅Fa}$
+
+#### **Parameters**
+
+- `CPM_b_m` *(float)* — Measured beta counts  
+- `CPM_b_f` *(float)* — Background beta counts  
+- `CPM_a_m` *(float)* — Measured alpha counts  
+- `CPM_a_f` *(float)* — Background alpha counts  
+- `Spill` *(float)* — Spillover correction factor  
+- `EFSr` *(float)* — Detection efficiency factor  
+- `Fa` *(float)* — Correction factor  
+- `V_ali` *(float)* — Aliquot volume  
+
+#### **Returns**
+
+- *(float)* — Total beta activity  
+
+---
+
+## 📦 Installation
+
+```bash
+pip install decision_methods

decision_methods-0.1.0/README.md

@@ -0,0 +1,139 @@
+# 🚀 decision_methods
+
+**A scientific Python library for computing decision thresholds and limits using numerical methods independent of the analytical expression.**
+
+Includes advanced implementations such as:
+- **UD** — Decision Threshold  
+- **LID** — Decision Limit  
+
+---
+
+## ✨ Key Features
+
+- Numerical methods applicable to **any analytical model**
+- Full **uncertainty propagation**
+- Robust **root-finding algorithms**
+- Scientific computation ready for real-world data
+- Visualization tools for LID analysis
+
+---
+
+## ⚙️ Core Function
+
+### 🔹 `compute_F_ud_lid`
+
+Computes:
+
+- Model value  
+- Associated uncertainty  
+- Decision Threshold (**UD**)  
+- Decision Limit (**LID**)  
+
+#### **Parameters**
+
+- `p` *(array-like)* — Model parameter vector  
+- `t_m` *(float)* — Measurement time  
+- `t_f` *(float)* — Background time  
+- `f` *(callable)* — Multivariable function  
+- `pderivative` *(callable)* — Partial derivative function  
+- `bisection` *(callable)* — Root-finding method  
+- `k` *(float, optional)* — Coverage factor *(default: 1.65)*  
+- `LID_a` *(float)* — Lower bound for LID search  
+- `LID_b` *(float)* — Upper bound for LID search  
+- `cpm_min`*(float)* — Lower bound of the count rate (counts per unit time, e.g., minutes or seconds; CPM) used in the LID search
+- `cpm_max`*(float)* — Upper bound of the count rate (counts per unit time, e.g., minutes or seconds; CPM) used in the LID search
+- `cpm_index`*(integer)* — Index of the parameter corresponding to the count rate (CPM) used in the LID search 
+- `sample_indices` *(tuple of int, optional)* — Indices of parameters corresponding to sample measurements modeled as Poisson-distributed variables, with expected counts defined as the parameter value scaled by the measurement time t_m *(default: (0,))*  
+- `background_indices` *(tuple of int, optional)* — Indices of parameters corresponding to sample measurements modeled as Poisson-distributed variables, with expected counts defined as the parameter value scaled by the measurement time t_f *(default: (1,))*   
+- `rel_map` *(tuple of (int, float), optional)* — Relative uncertainty definitions as *(index, relative_error)* pairs  
+- `frac_fondo` *(float, optional)* — Relative uncertainty for background when `t_f <= 0`  
+
+#### **Returns**
+
+- `value` *(float)* — Evaluated value of the model function  
+- `u_value` *(float)* — Combined uncertainty  
+- `UD` *(float)* — Decision threshold  
+- `LID` *(float)* — Decision limit  
+#### **Returns**
+
+- `value` *(float)* — Evaluated value of the model function  
+- `u_value` *(float)* — Combined uncertainty  
+- `UD` *(float)* — Decision threshold  
+- `LID` *(float)* — Decision limit  
+
+---
+
+## 📊 Visualization
+
+### 🔹 `plot_lid_function`
+
+Generates plots to analyze LID behavior.
+
+#### **Parameters**
+
+- `LID_a` *(float)* — Lower bound  
+- `LID_b` *(float)* — Upper bound  
+- `p` *(array-like)* — Parameters  
+- `f` *(callable)* — Function  
+- `UD` *(float)* — Decision threshold  
+- `t_m` *(float)* — Measurement time  
+- `t_f` *(float)* — Background time  
+- `pderivative` *(callable)* — Partial derivative function  
+- `bisection` *(callable)* — Root-finding method  
+- `cpm_min`*(float)* — Lower bound of the count rate (counts per unit time, e.g., minutes or seconds; CPM) used in the LID search
+- `cpm_max`*(float)* — Upper bound of the count rate (counts per unit time, e.g., minutes or seconds; CPM) used in the LID search
+- `n`*(integer)* — Number of samples or observations used in the LID search
+- `cpm_index`*(integer)* — Index of the parameter corresponding to the count rate (CPM) used in the LID search 
+- `k` *(float, optional)* — Coverage factor *(default: 1.65)*  
+- `rel_map` *(tuple of (int, float), optional)* — Relative uncertainty definitions as *(index, relative_error)* pairs  
+
+---
+
+## 🧪 Activity Functions
+
+### 🔹 `AT` — Total Alpha
+
+Computes total alpha activity.
+
+$AT(Bq\cdot m^{3})= \frac{CPM_M-CPM_F}{60 \cdot ɛ \cdot V_{Alicuot}}$
+
+#### **Parameters**
+
+- `CPM_m` *(float)* — Sample counts  
+- `CPM_f` *(float)* — Background counts  
+- `Eps` *(float)* — Detection efficiency  
+- `V_ali` *(float)* — Aliquot volume  
+
+#### **Returns**
+
+- *(float)* — Activity  
+
+---
+
+### 🔹 `BT` — Total Beta
+
+Computes total beta activity.
+
+$BT(Bq\cdot m^{3})= \frac{CPM_{\beta-M}-CPM_{\beta-F} - γ \cdot(CPM_{α-M}-CPM_{α-F})}{60 \cdot Ef_{Sr} \cdot V_{Alicuot}⋅Fa}$
+
+#### **Parameters**
+
+- `CPM_b_m` *(float)* — Measured beta counts  
+- `CPM_b_f` *(float)* — Background beta counts  
+- `CPM_a_m` *(float)* — Measured alpha counts  
+- `CPM_a_f` *(float)* — Background alpha counts  
+- `Spill` *(float)* — Spillover correction factor  
+- `EFSr` *(float)* — Detection efficiency factor  
+- `Fa` *(float)* — Correction factor  
+- `V_ali` *(float)* — Aliquot volume  
+
+#### **Returns**
+
+- *(float)* — Total beta activity  
+
+---
+
+## 📦 Installation
+
+```bash
+pip install decision_methods

decision_methods-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "decision_methods"
+version = "0.1.0"
+description = "Library for decision threshold and boundary methods"
+readme = "README.md"
+requires-python = ">=3.8"
+
+authors = [
+  { name = "Jose Francisco Benavente Cuevas", email = "jf.benavente@ciemat.es" },
+  { name = "Jose Antonio Suarez Navarro", email = "ja.suarez@ciemat.es" },
+  { name = "Victor Manuel Exposito Suarez", email = "VictorManuel.Exposito@ciemat.es" }
+]
+
+license = { text = "MIT" }
+
+dependencies = [
+  "numpy>=1.20",
+  "matplotlib>=3.5",
+  "scipy"
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]

decision_methods-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

decision_methods-0.1.0/src/decision_methods/__init__.py

@@ -0,0 +1,10 @@
+from .threshold import compute_F_ud_lid, plot_lid_function, pderivative, bisection, AT, BT
+
+__all__ = [
+    "compute_F_ud_lid",
+    "plot_lid_function",
+    "pderivative",
+    "bisection",
+    "AT",
+    "BT",
+]

decision_methods-0.1.0/src/decision_methods/threshold.py

@@ -0,0 +1,342 @@
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+def pderivative(f, punto, indice, h=1e-12):
+    """
+    Calcula la derivada parcial de f en 'punto'
+    respecto a la variable indicada por 'indice'
+    usando diferencia finita centrada.
+
+    Parámetros:
+        f       : función multivariable
+        punto   : lista o array con el punto donde evaluar
+        indice  : índice de la variable respecto a la cual derivar
+        h       : paso de la diferencia finita
+
+    Devuelve:
+        Aproximación de la derivada parcial
+    """
+    punto = np.array(punto, dtype=float)
+
+    eps = np.finfo(float).eps
+    escala = max(abs(punto[indice]), 1.0)
+    h = np.sqrt(eps) * escala
+
+    punto_mas = punto.copy()
+    punto_menos = punto.copy()
+
+    punto_mas[indice] += h
+    punto_menos[indice] -= h
+
+    return (f(*punto_mas) - f(*punto_menos)) / (2 * h)
+
+
+def bisection(f, a, b, tol=1e-12, max_iter=100):
+    """
+    Encuentra una raíz de f en el intervalo [a, b] usando el método de la bisección.
+
+    Parámetros:
+        f        : función a evaluar
+        a, b     : extremos del intervalo (f(a)*f(b) < 0)
+        tol      : tolerancia para el criterio de parada
+        max_iter : máximo número de iteraciones
+
+    Retorna:
+        Aproximación de la raíz
+    """
+
+    if f(a) * f(b) > 0:
+        raise ValueError(f"No hay cambio de signo: a={a}, f(a)={fa}, b={b}, f(b)={fb}")
+        #raise ValueError("La función debe cambiar de signo en el intervalo [a, b].")
+
+    for i in range(max_iter):
+        c = (a + b) / 2
+        fc = f(c)
+
+        if abs(fc) < tol or (b - a) / 2 < tol:
+            return c
+
+        if f(a) * fc < 0:
+            b = c
+        else:
+            a = c
+
+    raise RuntimeError("No se alcanzó la convergencia en el número máximo de iteraciones.")
+
+def Funcion_Previa_LID(LID, CPM_m, f, p,cpm_index=1):
+  return f(CPM_m, *p[cpm_index:]) - LID
+
+def eval_f(f, p):
+    return f(*p)
+
+def Funcion_LID(LID, CPM_m,UD,f, p_base, t_m=None, t_f=None, poisson_map=((0, "t_m"), (1, "t_f")), rel_map=((2, 0.075), (3, 0.01)),k=1.65, pderivative=None, indices_deriv=None,set_CPM_index=0):
+    """
+    Devuelve: LID - (UD + k * u_comb)  donde u_comb = sqrt(sum((w_i*u_i)^2))
+    """
+    if pderivative is None:
+        raise ValueError("Debes pasar la función pderivative(f, p, indice=...).")
+
+    # Copia de parámetros y fijar CPM_m
+    p_eval = np.array(p_base, dtype=float).copy()
+    p_eval[set_CPM_index] = CPM_m
+
+    # Resolver tiempos por nombre
+    tiempos = {"t_m": t_m, "t_f": t_f}
+    for _, tname in poisson_map:
+        if tiempos.get(tname, None) is None:
+            raise ValueError(f"Falta el tiempo {tname} (pasa {tname}=...).")
+
+    # Elegir índices a derivar si no se especifica
+    if indices_deriv is None:
+        idxs = [i for i, _ in poisson_map] + [i for i, _ in rel_map]
+        # quitar duplicados preservando orden
+        seen = set()
+        indices_deriv = [i for i in idxs if not (i in seen or seen.add(i))]
+
+    # Construir u_i (incertidumbres estándar) y w_i (sensibilidades)
+    u_list = []
+    w_list = []
+
+    # Poisson: sqrt(N*t)/t = sqrt(N*t)/t  (tu forma actual)
+    for i, tname in poisson_map:
+        t = tiempos[tname]
+        u_list.append(np.sqrt(p_eval[i] * t) / t)
+        w_list.append(pderivative(f, p_eval, indice=i))
+
+    # Relativas: u = p * frac
+    for i, frac in rel_map:
+        u_list.append(p_eval[i] * frac)
+        w_list.append(pderivative(f, p_eval, indice=i))
+
+    u = np.array(u_list, dtype=float)
+    w = np.array(w_list, dtype=float)
+
+    u_comb = np.sqrt(np.sum((w**2) * (u**2)))
+    return LID - (UD + k * u_comb)
+
+def compute_F_ud_lid(
+    p, t_m, t_f, f, pderivative, bisection,
+    k=1.65,
+    LID_a=0.0, LID_b=100.0,
+    tol=1e-12, max_iter=100,
+    cpm_min_=0.0, cpm_max_=1.0,
+    cpm_min=0.0, cpm_max=1.0,
+    cpm_index=0,
+    sample_indices=(0,),          # <- ahora varios
+    background_indices=(1,),      # <- ahora varios
+    rel_map=((2, 0.075), (3, 0.01)),
+    frac_fondo=None,              # <- NUEVO: error relativo fondo si t_f<=0
+):
+    p = np.array(p, dtype=float)
+
+    # 1) Actividad
+    actividad = eval_f(f, p)
+
+    # 2) Incertidumbre en p
+    idx_list = []
+    u_list = []
+
+    for i in sample_indices:
+        idx_list.append(i)
+        u_list.append(np.sqrt(p[i] * t_m) / t_m)
+
+    # Fondo: Poisson si t_f>0, si no -> error relativo fijo frac_fondo
+    if t_f is not None and t_f > 0:
+        for j in background_indices:
+            idx_list.append(j)
+            u_list.append(np.sqrt(p[j] * t_f) / t_f)
+    else:
+        if frac_fondo is None:
+            raise ValueError("Si t_f <= 0 debes proporcionar frac_fondo (error relativo del fondo).")
+        for j in background_indices:
+            idx_list.append(j)
+            u_list.append(p[j] * frac_fondo)
+
+    for i, frac in rel_map:
+        idx_list.append(i)
+        u_list.append(p[i] * frac)
+
+    u = np.array(u_list, dtype=float)
+    w = np.array([pderivative(f, p, indice=i) for i in idx_list], dtype=float)
+
+    u_act = np.sqrt(np.sum((w**2) * (u**2)))
+
+    # 3) UD: raíz de f=0 variando p[0]
+    raiz = bisection(
+        lambda x: eval_f(f, np.array([x if j == 0 else p[j] for j in range(len(p))], dtype=float)),
+        cpm_min_, cpm_max_,tol=1e-12, max_iter=400
+    )
+
+    p_UD = p.copy()
+    p_UD[0] = raiz
+
+    # Recalcular incertidumbre en p_UD (mismo criterio)
+    u_list_UD = []
+    for i in sample_indices:
+        u_list_UD.append(np.sqrt(p_UD[i] * t_m) / t_m)
+
+    if t_f is not None and t_f > 0:
+        for j in background_indices:
+            u_list_UD.append(np.sqrt(p_UD[j] * t_f) / t_f)
+    else:
+        if frac_fondo is None:
+            raise ValueError("Si t_f <= 0 debes proporcionar frac_fondo (error relativo del fondo).")
+        for j in background_indices:
+            u_list_UD.append(p_UD[j] * frac_fondo)
+
+    for i, frac in rel_map:
+        u_list_UD.append(p_UD[i] * frac)
+
+    u_UD = np.array(u_list_UD, dtype=float)
+    w_UD = np.array([pderivative(f, p_UD, indice=i) for i in idx_list], dtype=float)
+    u_act_UD = np.sqrt(np.sum((w_UD**2) * (u_UD**2)))
+
+    UD = u_act_UD * k
+
+    # 4) LID por bisección
+    a, b = float(LID_a), float(LID_b)
+
+    CPM_a = bisection(lambda x: Funcion_Previa_LID(a, x, f, p, cpm_index=cpm_index), cpm_min, cpm_max)
+    CPM_b = bisection(lambda x: Funcion_Previa_LID(b, x, f, p, cpm_index=cpm_index), cpm_min, cpm_max)
+    poisson_map = tuple((i, "t_m") for i in sample_indices) + tuple((j, "t_f") for j in background_indices)
+
+    fa = Funcion_LID(a, CPM_a, UD, f, p, t_m, t_f, pderivative=pderivative,
+                     k=k, poisson_map=poisson_map,rel_map=rel_map)
+    fb = Funcion_LID(b, CPM_b, UD, f, p, t_m, t_f, pderivative=pderivative,
+                     k=k, poisson_map=poisson_map,rel_map=rel_map)
+
+    LID = None
+    for _ in range(max_iter):
+        c = (a + b) / 2.0
+        CPM_c = bisection(lambda x: Funcion_Previa_LID(c, x, f, p, cpm_index=cpm_index), cpm_min, cpm_max)
+
+        fc = Funcion_LID(c, CPM_c, UD, f, p, t_m, t_f, poisson_map= poisson_map,pderivative=pderivative,
+                         k=k, rel_map=rel_map)
+
+        if abs(fc) < tol or (b - a) / 2.0 < tol:
+            LID = c
+            break
+
+        if fa * fc < 0:
+            b = c
+            fb = fc
+        else:
+            a = c
+            fa = fc
+
+    if LID is None:
+        LID = (a + b) / 2.0
+
+    return actividad, u_act, UD, LID
+
+
+def plot_lid_function(
+    LID_a,
+    LID_b,
+    p,
+    f,
+    UD,
+    t_m,
+    t_f,
+    pderivative,
+    bisection,
+    cpm_min,
+    cpm_max,
+    n=200,
+    cpm_index=0,
+    k=1.65,
+    rel_map=((2, 0.075), (3, 0.01)),
+    LID_objetivo=None,     # valor de LID para la segunda gráfica
+    n_cpm=200              # número de puntos para la gráfica de Funcion_Previa_LID
+):
+    LIDs = np.linspace(LID_a, LID_b, n)
+    valores = []
+
+    for LID in LIDs:
+        CPM = bisection(
+            lambda x: Funcion_Previa_LID(LID, x, f, p, cpm_index=cpm_index),
+            cpm_min,
+            cpm_max
+        )
+
+        val = Funcion_LID(
+            LID, CPM, UD, f, p, t_m, t_f,
+            pderivative=pderivative,
+            k=k,
+            rel_map=rel_map
+        )
+
+        valores.append(val)
+
+    valores = np.array(valores)
+
+    # ---------------------------
+    # Gráfica 1: Funcion_LID vs LID
+    # ---------------------------
+    plt.figure(figsize=(7, 5))
+    plt.plot(LIDs, valores, label="Funcion_LID(LID)")
+    plt.axhline(0, linestyle="--")
+    plt.xlabel("LID")
+    plt.ylabel("Funcion_LID")
+    plt.title("Curva para encontrar LID")
+    plt.grid(True)
+    plt.legend()
+    plt.show()
+
+    # -----------------------------------------------
+    # Selección del LID para graficar Funcion_Previa_LID
+    # -----------------------------------------------
+    if LID_objetivo is None:
+        # Si no se indica, toma el punto central del intervalo
+        LID_objetivo = LIDs[len(LIDs) // 2]
+
+    # Si el valor no coincide exactamente con la malla, tomamos el más cercano
+    idx = np.argmin(np.abs(LIDs - LID_objetivo))
+    LID_seleccionado = LIDs[idx]
+
+    CPMs = np.linspace(cpm_min, cpm_max, n_cpm)
+    valores_previos = [
+        Funcion_Previa_LID(LID_seleccionado, cpm, f, p, cpm_index=cpm_index)
+        for cpm in CPMs
+    ]
+
+    # Intentamos calcular también la raíz por bisección para marcarla
+    try:
+        CPM_raiz = bisection(
+            lambda x: Funcion_Previa_LID(LID_seleccionado, x, f, p, cpm_index=cpm_index),
+            cpm_min,
+            cpm_max
+        )
+        valor_raiz = Funcion_Previa_LID(LID_seleccionado, CPM_raiz, f, p, cpm_index=cpm_index)
+    except Exception:
+        CPM_raiz = None
+        valor_raiz = None
+
+    # ---------------------------
+    # Gráfica 2: Funcion_Previa_LID vs CPM
+    # ---------------------------
+    plt.figure(figsize=(7, 5))
+    plt.plot(CPMs, valores_previos, label=f"Funcion_Previa_LID para LID={LID_seleccionado:.6g}")
+    plt.axhline(0, linestyle="--")
+    if CPM_raiz is not None:
+        plt.axvline(CPM_raiz, linestyle=":", label=f"Raíz CPM={CPM_raiz:.6g}")
+        plt.plot(CPM_raiz, valor_raiz, "o")
+    plt.xlabel("CPM")
+    plt.ylabel("Funcion_Previa_LID")
+    plt.title(f"Evolución de Funcion_Previa_LID para LID={LID_seleccionado:.6g}")
+    plt.grid(True)
+    plt.legend()
+    plt.show()
+
+def AT(CPM_m,CPM_f,Eps,V_ali):
+  return (CPM_m-CPM_f)/(60*Eps*V_ali)
+
+def BT(CPM_b_m,CPM_b_f,CPM_a_m,CPM_a_f,Spill,EFSr,Fa,V_ali):
+  return (CPM_b_m-CPM_b_f-Spill*(CPM_a_m-CPM_a_f))/(60*EFSr*V_ali*Fa)
+
+def BR(CPM_b_m,CPM_b_f,CPM_a_m,CPM_a_f,Spill,EFSr,Fa,W_k,V_ali):
+  return (CPM_b_m-CPM_b_f-Spill*(CPM_a_m-CPM_a_f)-W_k)/(60*EFSr*V_ali*Fa)
+
+def W_k(V_ali,A_e,Eps_k,C_k):
+  return 60*V_ali*A_e*Eps_k*C_k*1000

decision_methods-0.1.0/src/decision_methods.egg-info/PKG-INFO

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: decision_methods
+Version: 0.1.0
+Summary: Library for decision threshold and boundary methods
+Author-email: Jose Francisco Benavente Cuevas <jf.benavente@ciemat.es>, Jose Antonio Suarez Navarro <ja.suarez@ciemat.es>, Victor Manuel Exposito Suarez <VictorManuel.Exposito@ciemat.es>
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20
+Requires-Dist: matplotlib>=3.5
+Requires-Dist: scipy
+Dynamic: license-file
+
+# 🚀 decision_methods
+
+**A scientific Python library for computing decision thresholds and limits using numerical methods independent of the analytical expression.**
+
+Includes advanced implementations such as:
+- **UD** — Decision Threshold  
+- **LID** — Decision Limit  
+
+---
+
+## ✨ Key Features
+
+- Numerical methods applicable to **any analytical model**
+- Full **uncertainty propagation**
+- Robust **root-finding algorithms**
+- Scientific computation ready for real-world data
+- Visualization tools for LID analysis
+
+---
+
+## ⚙️ Core Function
+
+### 🔹 `compute_F_ud_lid`
+
+Computes:
+
+- Model value  
+- Associated uncertainty  
+- Decision Threshold (**UD**)  
+- Decision Limit (**LID**)  
+
+#### **Parameters**
+
+- `p` *(array-like)* — Model parameter vector  
+- `t_m` *(float)* — Measurement time  
+- `t_f` *(float)* — Background time  
+- `f` *(callable)* — Multivariable function  
+- `pderivative` *(callable)* — Partial derivative function  
+- `bisection` *(callable)* — Root-finding method  
+- `k` *(float, optional)* — Coverage factor *(default: 1.65)*  
+- `LID_a` *(float)* — Lower bound for LID search  
+- `LID_b` *(float)* — Upper bound for LID search  
+- `cpm_min`*(float)* — Lower bound of the count rate (counts per unit time, e.g., minutes or seconds; CPM) used in the LID search
+- `cpm_max`*(float)* — Upper bound of the count rate (counts per unit time, e.g., minutes or seconds; CPM) used in the LID search
+- `cpm_index`*(integer)* — Index of the parameter corresponding to the count rate (CPM) used in the LID search 
+- `sample_indices` *(tuple of int, optional)* — Indices of parameters corresponding to sample measurements modeled as Poisson-distributed variables, with expected counts defined as the parameter value scaled by the measurement time t_m *(default: (0,))*  
+- `background_indices` *(tuple of int, optional)* — Indices of parameters corresponding to sample measurements modeled as Poisson-distributed variables, with expected counts defined as the parameter value scaled by the measurement time t_f *(default: (1,))*   
+- `rel_map` *(tuple of (int, float), optional)* — Relative uncertainty definitions as *(index, relative_error)* pairs  
+- `frac_fondo` *(float, optional)* — Relative uncertainty for background when `t_f <= 0`  
+
+#### **Returns**
+
+- `value` *(float)* — Evaluated value of the model function  
+- `u_value` *(float)* — Combined uncertainty  
+- `UD` *(float)* — Decision threshold  
+- `LID` *(float)* — Decision limit  
+#### **Returns**
+
+- `value` *(float)* — Evaluated value of the model function  
+- `u_value` *(float)* — Combined uncertainty  
+- `UD` *(float)* — Decision threshold  
+- `LID` *(float)* — Decision limit  
+
+---
+
+## 📊 Visualization
+
+### 🔹 `plot_lid_function`
+
+Generates plots to analyze LID behavior.
+
+#### **Parameters**
+
+- `LID_a` *(float)* — Lower bound  
+- `LID_b` *(float)* — Upper bound  
+- `p` *(array-like)* — Parameters  
+- `f` *(callable)* — Function  
+- `UD` *(float)* — Decision threshold  
+- `t_m` *(float)* — Measurement time  
+- `t_f` *(float)* — Background time  
+- `pderivative` *(callable)* — Partial derivative function  
+- `bisection` *(callable)* — Root-finding method  
+- `cpm_min`*(float)* — Lower bound of the count rate (counts per unit time, e.g., minutes or seconds; CPM) used in the LID search
+- `cpm_max`*(float)* — Upper bound of the count rate (counts per unit time, e.g., minutes or seconds; CPM) used in the LID search
+- `n`*(integer)* — Number of samples or observations used in the LID search
+- `cpm_index`*(integer)* — Index of the parameter corresponding to the count rate (CPM) used in the LID search 
+- `k` *(float, optional)* — Coverage factor *(default: 1.65)*  
+- `rel_map` *(tuple of (int, float), optional)* — Relative uncertainty definitions as *(index, relative_error)* pairs  
+
+---
+
+## 🧪 Activity Functions
+
+### 🔹 `AT` — Total Alpha
+
+Computes total alpha activity.
+
+$AT(Bq\cdot m^{3})= \frac{CPM_M-CPM_F}{60 \cdot ɛ \cdot V_{Alicuot}}$
+
+#### **Parameters**
+
+- `CPM_m` *(float)* — Sample counts  
+- `CPM_f` *(float)* — Background counts  
+- `Eps` *(float)* — Detection efficiency  
+- `V_ali` *(float)* — Aliquot volume  
+
+#### **Returns**
+
+- *(float)* — Activity  
+
+---
+
+### 🔹 `BT` — Total Beta
+
+Computes total beta activity.
+
+$BT(Bq\cdot m^{3})= \frac{CPM_{\beta-M}-CPM_{\beta-F} - γ \cdot(CPM_{α-M}-CPM_{α-F})}{60 \cdot Ef_{Sr} \cdot V_{Alicuot}⋅Fa}$
+
+#### **Parameters**
+
+- `CPM_b_m` *(float)* — Measured beta counts  
+- `CPM_b_f` *(float)* — Background beta counts  
+- `CPM_a_m` *(float)* — Measured alpha counts  
+- `CPM_a_f` *(float)* — Background alpha counts  
+- `Spill` *(float)* — Spillover correction factor  
+- `EFSr` *(float)* — Detection efficiency factor  
+- `Fa` *(float)* — Correction factor  
+- `V_ali` *(float)* — Aliquot volume  
+
+#### **Returns**
+
+- *(float)* — Total beta activity  
+
+---
+
+## 📦 Installation
+
+```bash
+pip install decision_methods

decision_methods-0.1.0/src/decision_methods.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+src/decision_methods/__init__.py
+src/decision_methods/threshold.py
+src/decision_methods.egg-info/PKG-INFO
+src/decision_methods.egg-info/SOURCES.txt
+src/decision_methods.egg-info/dependency_links.txt
+src/decision_methods.egg-info/requires.txt
+src/decision_methods.egg-info/top_level.txt
+tests/test_compute_lid.py
+tests/test_inputs.py
+tests/test_poisson_model.py
+tests/test_regression.py

decision_methods-0.1.0/src/decision_methods.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

decision_methods-0.1.0/src/decision_methods.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy>=1.20
+matplotlib>=3.5
+scipy

decision_methods-0.1.0/src/decision_methods.egg-info/top_level.txt

@@ -0,0 +1 @@
+decision_methods

decision_methods-0.1.0/tests/test_compute_lid.py

@@ -0,0 +1,30 @@
+import numpy as np
+import decision_methods.threshold as functions
+
+
+def test_compute_F_ud_lid_basic():
+    p_BT = [3.163, 0.608, 0.154, 0.03, 0.32, 0.444, 0.932164125607044, 0.000375]
+
+    BT_, u_BT, u_BT_UD, LID_BT = functions.compute_F_ud_lid(
+        p_BT, 1000, 2000, functions.BT, functions.pderivative, functions.bisection,
+        k=1.65,
+        LID_a=0.0, LID_b=20.0,
+        tol=1e-12, max_iter=50,
+        cpm_min_=0.0, cpm_max_=0.65,
+        cpm_min=0.0, cpm_max=1.5,
+        cpm_index=1,
+        sample_indices=(0, 2),
+        background_indices=(1, 3),
+        rel_map=((4, 0.1), (5, 0.025), (6, 0.04), (7, 0.01)),
+        frac_fondo=None,
+    )
+
+    assert np.isfinite(BT_)
+    assert np.isfinite(u_BT)
+    assert np.isfinite(u_BT_UD)
+    assert np.isfinite(LID_BT)
+
+    assert BT_ >= 0
+    assert u_BT >= 0
+    assert u_BT_UD >= 0
+    assert LID_BT >= 0

decision_methods-0.1.0/tests/test_inputs.py

@@ -0,0 +1,30 @@
+import numpy as np
+import decision_methods.threshold as functions
+
+
+def test_compute_F_ud_lid_basic():
+    p_BT = [3.163, 0.608, 0.154, 0.03, 0.32, 0.444, 0.932164125607044, 0.000375]
+
+    BT_, u_BT, u_BT_UD, LID_BT = functions.compute_F_ud_lid(
+        p_BT, 1000, 2000, functions.BT, functions.pderivative, functions.bisection,
+        k=1.65,
+        LID_a=0.0, LID_b=20.0,
+        tol=1e-12, max_iter=50,
+        cpm_min_=0.0, cpm_max_=0.65,
+        cpm_min=0.0, cpm_max=1.5,
+        cpm_index=1,
+        sample_indices=(0, 2),
+        background_indices=(1, 3),
+        rel_map=((4, 0.1), (5, 0.025), (6, 0.04), (7, 0.01)),
+        frac_fondo=None,
+    )
+
+    assert np.isfinite(BT_)
+    assert np.isfinite(u_BT)
+    assert np.isfinite(u_BT_UD)
+    assert np.isfinite(LID_BT)
+
+    assert BT_ >= 0
+    assert u_BT >= 0
+    assert u_BT_UD >= 0
+    assert LID_BT >= 0

decision_methods-0.1.0/tests/test_poisson_model.py

@@ -0,0 +1,9 @@
+import numpy as np
+
+def test_poisson_mean_variance():
+    lam = 5.0
+    samples = np.random.poisson(lam, size=10000)
+
+    # En Poisson: media ≈ varianza
+    assert np.isclose(np.mean(samples), lam, rtol=0.1)
+    assert np.isclose(np.var(samples), lam, rtol=0.1)

decision_methods-0.1.0/tests/test_regression.py

@@ -0,0 +1,31 @@
+import numpy as np
+import decision_methods.threshold as functions
+
+EXPECTED_BT = 270.1067085367795
+EXPECTED_U_BT = 14.49093
+EXPECTED_U_BT_UD = 5.56013
+EXPECTED_LID_BT = 11.48531
+
+
+def test_compute_F_ud_lid_regression():
+    np.random.seed(0)  
+    p_BT = [3.163, 0.608, 0.154, 0.03, 0.32, 0.444, 0.932164125607044, 0.000375]
+
+    BT_, u_BT, u_BT_UD, LID_BT = functions.compute_F_ud_lid(
+        p_BT, 1000, 2000, functions.BT, functions.pderivative, functions.bisection,
+        k=1.65,
+        LID_a=0.0, LID_b=20.0,
+        tol=1e-12, max_iter=50,
+        cpm_min_=0.0, cpm_max_=0.65,
+        cpm_min=0.0, cpm_max=1.5,
+        cpm_index=1,
+        sample_indices=(0, 2),
+        background_indices=(1, 3),
+        rel_map=((4, 0.1), (5, 0.025), (6, 0.04), (7, 0.01)),
+        frac_fondo=None,
+    )
+
+    assert np.isclose(BT_, EXPECTED_BT, rtol=1e-5, atol=1e-6)
+    assert np.isclose(u_BT, EXPECTED_U_BT, rtol=1e-5, atol=1e-6)
+    assert np.isclose(u_BT_UD, EXPECTED_U_BT_UD, rtol=1e-5, atol=1e-6)
+    assert np.isclose(LID_BT, EXPECTED_LID_BT, rtol=1e-5, atol=1e-6)