bioforge 3.2.0__tar.gz → 3.4.0__tar.gz

{bioforge-3.2.0 → bioforge-3.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bioforge
-Version: 3.2.0
+Version: 3.4.0
 Summary: High-performance bioinformatics engine for Edge Computing — 5-bit encoding, vectorised NumPy core, optional C backend
 Author-email: Aarón Aranda Torrijos <noe9601@gmail.com>
 License: # PolyForm Noncommercial License 1.0.0

{bioforge-3.2.0 → bioforge-3.4.0}/bioforge/__init__.py

@@ -36,7 +36,7 @@ from .biocore import (
 from .genomemap import GenomeAligner, Mapping
 from .smart_translator import SmartTranslator
 
-__version__ = "3.2.0"
+__version__ = "3.4.0"
 __author__  = "Aarón Aranda Torrijos"
 
 __all__ = [

{bioforge-3.2.0 → bioforge-3.4.0}/bioforge/engine/_loader.py

@@ -18,6 +18,7 @@ _DLL_PATH   = _ENGINE_DIR / ("engine.dll" if sys.platform == "win32" else "engin
 _U8P  = ctypes.POINTER(ctypes.c_uint8)
 _I32P = ctypes.POINTER(ctypes.c_int32)
 _I64P = ctypes.POINTER(ctypes.c_int64)
+_U64P = ctypes.POINTER(ctypes.c_uint64)
 _F64P = ctypes.POINTER(ctypes.c_double)
 _I32  = ctypes.c_int32
 _I64  = ctypes.c_int64
@@ -222,11 +223,30 @@ def _check_chain() -> None:
         pass
 
 
+C_MINIMIZERS_AVAILABLE: bool = False
+
+def _check_minimizers() -> None:
+    """Minimizers (w,k) del alineador de genomas (v3). Opcional."""
+    global C_MINIMIZERS_AVAILABLE
+    if not C_AVAILABLE or _lib is None:
+        return
+    try:
+        _lib.bio_minimizers.restype = _I64
+        _lib.bio_minimizers.argtypes = [
+            _U8P, _I64, _I32, _I32,        # codes, n, k, w
+            _U64P, _I64P, _U8P,            # out_hash, out_pos, out_strand
+        ]
+        C_MINIMIZERS_AVAILABLE = True
+    except (AttributeError, OSError):
+        pass
+
+
 _check_parser()
 _check_batch()
 _check_parallel()
 _check_libdeflate()
 _check_chain()
+_check_minimizers()
 
 
 # ── Wrappers Python ────────────────────────────────────────────────────────────
@@ -347,6 +367,24 @@ def c_nw_banded(
     )
 
 
+def c_minimizers(codes: np.ndarray, k: int, w: int):
+    """Minimizers (w,k) canónicos en C. Devuelve (hashes, positions, strands)."""
+    codes = np.ascontiguousarray(codes, dtype=np.uint8)
+    n = int(codes.size)
+    nk = max(0, n - k + 1)
+    out_hash = np.empty(nk, dtype=np.uint64)
+    out_pos = np.empty(nk, dtype=np.int64)
+    out_strand = np.empty(nk, dtype=np.uint8)
+    cnt = _lib.bio_minimizers(
+        codes.ctypes.data_as(_U8P), _I64(n), _I32(int(k)), _I32(int(w)),
+        out_hash.ctypes.data_as(_U64P), out_pos.ctypes.data_as(_I64P),
+        out_strand.ctypes.data_as(_U8P),
+    )
+    if cnt < 0:
+        raise MemoryError("Motor C: fallo de memoria en minimizers")
+    return out_hash[:cnt], out_pos[:cnt], out_strand[:cnt]
+
+
 def c_chain_dp(xs: np.ndarray, ys: np.ndarray, k: int,
                max_gap: int, window: int, gap_w: float):
     """DP de chaining en C. Rellena y devuelve (f, prev).

{bioforge-3.2.0 → bioforge-3.4.0}/bioforge/engine/engine.c

@@ -1570,8 +1570,9 @@ EXPORT void bio_chain_dp(const int64_t* x, const int64_t* y, int32_t n,
             if (gap > max_gap) continue;
             int64_t mn = (dx < dy) ? dx : dy;
             double match = (double)((mn < (int64_t)k) ? mn : (int64_t)k);
+            /* coste de hueco estilo minimap2: gap_w·|l| + 0.5·log2|l| (l≠0) */
             double cost  = gap_w * (double)gap;
-            if (gap > 0) cost += log2((double)gap + 1.0);
+            if (gap > 0) cost += 0.5 * log2((double)gap);
             double sc = f[j] + match - cost;
             if (sc > best) { best = sc; bp = j; }
         }
@@ -1579,3 +1580,87 @@ EXPORT void bio_chain_dp(const int64_t* x, const int64_t* y, int32_t n,
         prev[i] = bp;
     }
 }
+
+/* ── Minimizers (w,k) canónicos en C (alineador v3) ───────────────────────────
+   Réplica exacta del cálculo vectorizado de minimizers.py:
+     - k-mer directo/inverso por hash RODANTE (idéntico al Horner de NumPy),
+     - hash invertible _hash64 (mismo esquema), canónico = menor(hf,hr),
+     - mínimo por ventana deslizante de w k-mers (argmin más a la IZQUIERDA),
+     - dedup de posiciones consecutivas (== np.unique sobre pos no-decrecientes).
+   Escala a genomas donde sliding_window_view de NumPy se ahoga.
+
+   codes: uint8 2-bit (>=4 = base inválida). Salidas (tamaño ≥ n-k+1):
+   out_hash/out_pos/out_strand. Devuelve el nº de minimizers, o -1 si malloc. */
+static uint64_t _hash64_c(uint64_t x, uint64_t mask) {
+    x = x & mask;
+    x = (~x + (x << 21)) & mask;
+    x = x ^ (x >> 24);
+    x = ((x + (x << 3)) + (x << 8)) & mask;
+    x = x ^ (x >> 14);
+    x = ((x + (x << 2)) + (x << 4)) & mask;
+    x = x ^ (x >> 28);
+    x = (x + (x << 31)) & mask;
+    return x;
+}
+
+EXPORT int64_t bio_minimizers(const uint8_t* codes, int64_t n, int32_t k, int32_t w,
+                              uint64_t* out_hash, int64_t* out_pos,
+                              uint8_t* out_strand) {
+    int64_t nk = n - (int64_t)k + 1;
+    if (nk <= 0) return 0;
+
+    uint64_t* h  = (uint64_t*)malloc((size_t)nk * sizeof(uint64_t));
+    uint8_t*  st = (uint8_t*) malloc((size_t)nk * sizeof(uint8_t));
+    if (!h || !st) { free(h); free(st); return -1; }
+
+    const uint64_t SENT  = ~0ULL;
+    uint64_t mask  = (k >= 32) ? ~0ULL : ((1ULL << (2 * k)) - 1);
+    uint64_t shift = (uint64_t)(2 * (k - 1));
+    uint64_t fwd = 0, rev = 0;
+    int32_t  l = 0;                          /* bases válidas consecutivas */
+
+    for (int64_t i = 0; i < n; i++) {
+        uint8_t c = codes[i];
+        if (c < 4) {
+            uint64_t cc = c;
+            fwd = ((fwd << 2) | cc) & mask;
+            rev = (rev >> 2) | ((3ULL - cc) << shift);
+            l++;
+        } else {
+            l = 0; fwd = 0; rev = 0;
+        }
+        int64_t p = i - (int64_t)k + 1;       /* k-mer que termina en i */
+        if (p >= 0) {
+            if (l >= k) {
+                uint64_t hf = _hash64_c(fwd, mask);
+                uint64_t hr = _hash64_c(rev, mask);
+                if (hr < hf) { h[p] = hr; st[p] = 1; }
+                else         { h[p] = hf; st[p] = 0; }
+            } else {
+                h[p] = SENT; st[p] = 0;
+            }
+        }
+    }
+
+    int64_t count = 0, last = -1;
+    if (nk < w) {                             /* una sola ventana */
+        int64_t bi = 0;
+        for (int64_t j = 1; j < nk; j++) if (h[j] < h[bi]) bi = j;
+        if (h[bi] != SENT) {
+            out_hash[0] = h[bi]; out_pos[0] = bi; out_strand[0] = st[bi];
+            count = 1;
+        }
+    } else {
+        for (int64_t i = 0; i + w <= nk; i++) {
+            int64_t bi = i;                   /* argmin más a la izquierda */
+            for (int64_t j = i + 1; j < i + w; j++) if (h[j] < h[bi]) bi = j;
+            if (bi != last && h[bi] != SENT) {
+                out_hash[count] = h[bi]; out_pos[count] = bi;
+                out_strand[count] = st[bi];
+                count++; last = bi;
+            }
+        }
+    }
+    free(h); free(st);
+    return count;
+}

{bioforge-3.2.0 → bioforge-3.4.0}/bioforge/genomemap.py

@@ -101,16 +101,17 @@ class Chain(NamedTuple):
 # Parámetros de chaining (razonables; ajustables).
 _MAX_GAP = 5000      # distancia máxima entre anclas consecutivas
 _WINDOW  = 64        # nº de predecesores que se examinan por ancla
-_GAP_W   = 0.2       # peso lineal de la penalización por hueco
+_GAP_COEF = 0.01     # coste lineal de hueco = 0.01·k (fórmula de minimap2)
 _MIN_ANCHORS = 2
 
 
-def _chain_fill_numpy(xs: np.ndarray, ys: np.ndarray, k: int):
+def _chain_fill_numpy(xs: np.ndarray, ys: np.ndarray, k: int, gap_w: float):
     """Fallback NumPy del DP de chaining (idéntico al C bio_chain_dp).
 
     Bucle EXTERNO secuencial (f[i] depende de f[j<i]); bucle INTERNO sobre la
     ventana de predecesores vectorizado. En empate gana el predecesor más
-    cercano (mismo desempate que el C).
+    cercano (mismo desempate que el C). Coste de hueco estilo minimap2:
+    ``gap_w·|l| + 0.5·log2|l|``.
     """
     n = xs.size
     f = np.full(n, float(k), dtype=np.float64)
@@ -130,8 +131,8 @@ def _chain_fill_numpy(xs: np.ndarray, ys: np.ndarray, k: int):
         if not valid.any():
             continue
         match = np.minimum(np.minimum(dx, dy), k).astype(np.float64)
-        logterm = np.where(gap > 0, np.log2(gap + 1.0), 0.0)
-        sc = np.where(valid, f[lo:i] + match - (_GAP_W * gap + logterm), -np.inf)
+        logterm = np.where(gap > 0, 0.5 * np.log2(np.maximum(gap, 1)), 0.0)
+        sc = np.where(valid, f[lo:i] + match - (gap_w * gap + logterm), -np.inf)
         b = sc.size - 1 - int(sc[::-1].argmax())   # empate → predecesor cercano
         if sc[b] > kf:
             f[i], prev[i] = float(sc[b]), lo + b
@@ -153,11 +154,12 @@ def _chain_one(x: np.ndarray, y: np.ndarray, k: int,
     ys = np.ascontiguousarray(y[order], dtype=np.int64)
 
     # Relleno del DP: C si está disponible (10-50× más rápido), si no NumPy.
+    gap_w = _GAP_COEF * k                     # 0.01·k (coste de hueco minimap2)
     if C_CHAIN_AVAILABLE:
-        f, prev = c_chain_dp(xs, ys, k, _MAX_GAP, _WINDOW, _GAP_W)
+        f, prev = c_chain_dp(xs, ys, k, _MAX_GAP, _WINDOW, gap_w)
         prev = prev.astype(np.int64)
     else:
-        f, prev = _chain_fill_numpy(xs, ys, k)
+        f, prev = _chain_fill_numpy(xs, ys, k, gap_w)
 
     # Backtrack de cadenas no solapadas, por score descendente.
     used = np.zeros(n, dtype=bool)

{bioforge-3.2.0 → bioforge-3.4.0}/bioforge/minimizers.py

@@ -34,6 +34,7 @@ import numpy as np
 from numpy.lib.stride_tricks import sliding_window_view
 
 from .biocore import SequenceValueError
+from .engine._loader import C_MINIMIZERS_AVAILABLE, c_minimizers
 
 # ── LUT ASCII → código 2-bit (A=0, C=1, G=2, T=3; cualquier otra cosa = 4) ──────
 _BASE_LUT = np.full(256, 4, dtype=np.uint8)
@@ -103,6 +104,16 @@ def minimizers(codes: np.ndarray, k: int = 15, w: int = 10) -> MinimizerSketch:
         raise SequenceValueError(f"w debe ser ≥ 1 (se recibió {w}).")
 
     codes = np.ascontiguousarray(codes, dtype=np.uint8)
+    # Motor C si está disponible (mucho más rápido en genomas grandes); si no,
+    # el fallback NumPy, que produce EXACTAMENTE lo mismo (verificado en tests).
+    if C_MINIMIZERS_AVAILABLE:
+        h, pos, strand = c_minimizers(codes, k, w)
+        return MinimizerSketch(h, pos, strand)
+    return _minimizers_numpy(codes, k, w)
+
+
+def _minimizers_numpy(codes: np.ndarray, k: int, w: int) -> MinimizerSketch:
+    """Fallback NumPy de :func:`minimizers` (idéntico al C bio_minimizers)."""
     L = codes.size
     n = L - k + 1                       # nº de k-mers en la secuencia
     if n <= 0:

{bioforge-3.2.0 → bioforge-3.4.0}/bioforge.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bioforge
-Version: 3.2.0
+Version: 3.4.0
 Summary: High-performance bioinformatics engine for Edge Computing — 5-bit encoding, vectorised NumPy core, optional C backend
 Author-email: Aarón Aranda Torrijos <noe9601@gmail.com>
 License: # PolyForm Noncommercial License 1.0.0

{bioforge-3.2.0 → bioforge-3.4.0}/tests/test_minimizers.py

@@ -9,7 +9,13 @@ import numpy as np
 import pytest
 
 from bioforge.biocore import SequenceValueError
-from bioforge.minimizers import MinimizerSketch, encode_bases, minimizers
+from bioforge.engine._loader import C_MINIMIZERS_AVAILABLE
+from bioforge.minimizers import (
+    MinimizerSketch,
+    _minimizers_numpy,
+    encode_bases,
+    minimizers,
+)
 
 _COMP = str.maketrans("ACGTacgt", "TGCAtgca")
 
@@ -122,6 +128,22 @@ def test_hash_canonico_es_el_menor():
 
 # ── Validación de argumentos ────────────────────────────────────────────────────
 
+@pytest.mark.skipif(not C_MINIMIZERS_AVAILABLE, reason="motor C no disponible")
+@pytest.mark.parametrize("seed", [0, 1, 2, 3])
+def test_c_igual_que_numpy(seed):
+    # El camino C y el fallback NumPy deben dar EXACTAMENTE lo mismo.
+    rng = np.random.default_rng(seed)
+    s = list("".join("ACGT"[i] for i in rng.integers(0, 4, 2000)))
+    for p in rng.integers(0, 2000, 25):        # unas cuantas N
+        s[p] = "N"
+    codes = encode_bases("".join(s))
+    c = minimizers(codes, k=15, w=10)          # ruta C (activa)
+    n = _minimizers_numpy(codes, 15, 10)       # fallback NumPy
+    assert np.array_equal(c.hashes, n.hashes)
+    assert np.array_equal(c.positions, n.positions)
+    assert np.array_equal(c.strands, n.strands)
+
+
 @pytest.mark.parametrize("k", [0, 32, -1])
 def test_k_invalido(k):
     with pytest.raises(SequenceValueError):