lme4 2.1.0a1__tar.gz

lme4-2.1.0a1/MANIFEST.in

@@ -0,0 +1,6 @@
+include README.md setup.py pyproject.toml
+recursive-include src/cpp *.cpp *.h
+recursive-include third_party/eigen *
+include src/lme4/_fgq_rules.json
+recursive-include src/lme4/datasets *.csv.gz *.json
+recursive-exclude * __pycache__ *.pyc *.pyd *.so *.lib *.pdb

lme4-2.1.0a1/PKG-INFO

@@ -0,0 +1,157 @@
+Metadata-Version: 2.4
+Name: lme4
+Version: 2.1.0a1
+Summary: Linear, generalized linear and nonlinear mixed-effects models: a faithful Python transcription of the R package lme4 with a C++ (Eigen) backend
+License-Expression: GPL-2.0-or-later
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.22
+Requires-Dist: scipy>=1.8
+Requires-Dist: pandas>=1.5
+Requires-Dist: nlopt>=2.7
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+
+# lme4 para Python
+
+Transcripción fiel del paquete de R **lme4 2.1-0** (Bates, Maechler, Bolker, Walker y otros)
+a Python, con el mismo backend numérico en **C++/Eigen** (expuesto con pybind11) y entrada
+de datos con **pandas**.
+
+No es un *wrapper* de R ni requiere R instalado: el código C++ de lme4 (`predModule`,
+`respModule`, `glmFamily`, Nelder-Mead, PIRLS, Laplace/AGQ) y el BOBYQA de `minqa` fueron
+transcritos, y la lógica R (`lFormula`, `mkReTrms`, `mkLmerDevfun`, `optimizeLmer`,
+`mkMerMod`, `summary`, `VarCorr`, ...) se transcribió a Python función por función.
+
+## Uso
+
+Las fórmulas se pueden escribir de forma **simbólica**, con `==` en lugar de `~`:
+
+```python
+from lme4 import lmer, glmer, binomial, V, cbind, load_dataset
+
+sleepstudy = load_dataset("sleepstudy")
+Reaction, Days, Subject = V("Reaction Days Subject")
+
+fm1 = lmer(Reaction == Days + (Days | Subject), data=sleepstudy)
+print(fm1.summary())
+```
+
+o como en R, con un string:
+
+```python
+fm1 = lmer("Reaction ~ Days + (Days | Subject)", data=sleepstudy)
+
+cbpp = load_dataset("cbpp")
+gm1 = glmer("cbind(incidence, size - incidence) ~ period + (1 | herd)",
+            data=cbpp, family=binomial)
+```
+
+Salida (idéntica a la de R):
+
+```
+Linear mixed model fit by REML ['lmerMod']
+Formula: Reaction ~ Days + (Days | Subject)
+   Data: sleepstudy
+
+REML criterion at convergence: 1743.6
+...
+Random effects:
+ Groups   Name        Variance Std.Dev. Corr
+ Subject  (Intercept) 612.10   24.741
+          Days         35.07    5.922   0.07
+ Residual             654.94   25.592
+Number of obs: 180, groups:  Subject, 18
+
+Fixed effects:
+            Estimate Std. Error t value
+(Intercept)  251.405      6.825  36.838
+Days          10.467      1.546   6.771
+```
+
+### Fórmulas simbólicas
+
+| Python                    | R                        |
+|---------------------------|--------------------------|
+| `y == x + z`              | `y ~ x + z`              |
+| `(x | g)`, `(1 + x | g)`  | `(x | g)`, `(1 + x | g)` |
+| `x.dbar(g)`               | `(x || g)`               |
+| `a & b`                   | `a:b`                    |
+| `a * b`, `a / b`          | `a * b`, `a / b`         |
+| `(a + b + c) ** 2`        | `(a + b + c)^2`          |
+| `0 + x`, `x - 1`          | `0 + x`, `x - 1`         |
+| `I(x ** 2)`, `log(x)`, `np.log(x)` | `I(x^2)`, `log(x)` |
+| `cbind(s, n - s)`         | `cbind(s, n - s)`        |
+
+En Python `|` y `&` tienen menor precedencia que `+`: escribe `x + (a & b)` para `x + a:b`
+(igual que `(Days | Subject)` ya necesita paréntesis en R).
+
+### Métodos del modelo ajustado
+
+`fixef()`, `ranef(condVar=True)`, `coef()`, `VarCorr()`, `sigma()`, `logLik()`, `AIC()`,
+`BIC()`, `deviance()`, `REMLcrit()`, `vcov()`, `summary()`, `fitted()`, `residuals()`,
+`predict()`, `simulate()`, `confint()`, `anova()`, `refitML()`, `update()`, `refit()`,
+`getME(name)`, `isSingular()`, `hatvalues()`, `as_function()` (función de devianza), ...
+
+Los resultados se devuelven como objetos pandas (`Series`/`DataFrame`) con los mismos
+nombres que en R.
+
+Los argumentos de control usan `_` en vez de `.`:
+`lmerControl(optimizer="bobyqa", check_conv_grad="ignore")`.
+
+## Instalación
+
+Requisitos: Python ≥ 3.9, numpy, scipy, pandas, nlopt, pybind11 y un compilador C++17.
+
+Con Poetry, directamente desde GitHub:
+
+```bash
+poetry add git+https://github.com/ljofreflor/lme4.git#develop
+```
+
+o con pip:
+
+```bash
+pip install git+https://github.com/ljofreflor/lme4.git@develop
+```
+
+La instalación compila el backend C++. Usa el compilador del sistema (MSVC, gcc,
+clang) y, si no hay ninguno, recurre automáticamente a Zig (paquete `ziglang`,
+que en Windows se instala como dependencia de compilación). La primera
+compilación tarda unos minutos. Para forzar Zig: `LME4_USE_ZIG=1`.
+
+Desarrollo local (compila la extensión dentro de `src/lme4`):
+
+```bash
+pip install numpy scipy pandas nlopt pybind11 ziglang
+python tools/build_ext.py --zig
+```
+
+## Fidelidad respecto de R
+
+- Los tests (`pytest`) reproducen valores numéricos de la suite de tests de lme4 2.1-0
+  (por ejemplo: `Dyestuff` REML 319.654276842342, `sleepstudy` REML 1743.628,
+  `cbpp` deviance 73.47154).
+- Diferencias de implementación:
+  - La factorización de Cholesky dispersa usa `Eigen::SimplicialLLT` con ordenamiento AMD
+    en lugar de CHOLMOD. Es matemáticamente idéntica, pero la permutación de `getME(m, "L")`
+    puede diferir.
+  - `nloptwrap` usa el paquete `nlopt` de Python (la misma biblioteca C que `nloptr`).
+  - `nlminbwrap` usa L-BFGS-B de scipy (el código PORT de R no está disponible).
+  - Las familias GLM se identifican por nombre: no se aceptan familias definidas por el
+    usuario.
+  - Los niveles de factores creados a partir de strings se ordenan por punto de código
+    (R usa el orden del *locale*). Los `Categorical` de pandas conservan su orden.
+
+## Estructura
+
+```
+src/cpp/        backend C++ (transcripción de lme4/src y minqa/src)
+src/lme4/       paquete Python (transcripción de lme4/R y reformulas/R)
+tests/          tests portados de lme4/tests
+tools/          compilación y conversión de datos
+upstream/       código fuente original de lme4, reformulas y minqa (referencia)
+third_party/    Eigen 3.4.0 (MPL2)
+```
+
+Licencia: GPL (>= 2), como lme4.

lme4-2.1.0a1/README.md

@@ -0,0 +1,143 @@
+# lme4 para Python
+
+Transcripción fiel del paquete de R **lme4 2.1-0** (Bates, Maechler, Bolker, Walker y otros)
+a Python, con el mismo backend numérico en **C++/Eigen** (expuesto con pybind11) y entrada
+de datos con **pandas**.
+
+No es un *wrapper* de R ni requiere R instalado: el código C++ de lme4 (`predModule`,
+`respModule`, `glmFamily`, Nelder-Mead, PIRLS, Laplace/AGQ) y el BOBYQA de `minqa` fueron
+transcritos, y la lógica R (`lFormula`, `mkReTrms`, `mkLmerDevfun`, `optimizeLmer`,
+`mkMerMod`, `summary`, `VarCorr`, ...) se transcribió a Python función por función.
+
+## Uso
+
+Las fórmulas se pueden escribir de forma **simbólica**, con `==` en lugar de `~`:
+
+```python
+from lme4 import lmer, glmer, binomial, V, cbind, load_dataset
+
+sleepstudy = load_dataset("sleepstudy")
+Reaction, Days, Subject = V("Reaction Days Subject")
+
+fm1 = lmer(Reaction == Days + (Days | Subject), data=sleepstudy)
+print(fm1.summary())
+```
+
+o como en R, con un string:
+
+```python
+fm1 = lmer("Reaction ~ Days + (Days | Subject)", data=sleepstudy)
+
+cbpp = load_dataset("cbpp")
+gm1 = glmer("cbind(incidence, size - incidence) ~ period + (1 | herd)",
+            data=cbpp, family=binomial)
+```
+
+Salida (idéntica a la de R):
+
+```
+Linear mixed model fit by REML ['lmerMod']
+Formula: Reaction ~ Days + (Days | Subject)
+   Data: sleepstudy
+
+REML criterion at convergence: 1743.6
+...
+Random effects:
+ Groups   Name        Variance Std.Dev. Corr
+ Subject  (Intercept) 612.10   24.741
+          Days         35.07    5.922   0.07
+ Residual             654.94   25.592
+Number of obs: 180, groups:  Subject, 18
+
+Fixed effects:
+            Estimate Std. Error t value
+(Intercept)  251.405      6.825  36.838
+Days          10.467      1.546   6.771
+```
+
+### Fórmulas simbólicas
+
+| Python                    | R                        |
+|---------------------------|--------------------------|
+| `y == x + z`              | `y ~ x + z`              |
+| `(x | g)`, `(1 + x | g)`  | `(x | g)`, `(1 + x | g)` |
+| `x.dbar(g)`               | `(x || g)`               |
+| `a & b`                   | `a:b`                    |
+| `a * b`, `a / b`          | `a * b`, `a / b`         |
+| `(a + b + c) ** 2`        | `(a + b + c)^2`          |
+| `0 + x`, `x - 1`          | `0 + x`, `x - 1`         |
+| `I(x ** 2)`, `log(x)`, `np.log(x)` | `I(x^2)`, `log(x)` |
+| `cbind(s, n - s)`         | `cbind(s, n - s)`        |
+
+En Python `|` y `&` tienen menor precedencia que `+`: escribe `x + (a & b)` para `x + a:b`
+(igual que `(Days | Subject)` ya necesita paréntesis en R).
+
+### Métodos del modelo ajustado
+
+`fixef()`, `ranef(condVar=True)`, `coef()`, `VarCorr()`, `sigma()`, `logLik()`, `AIC()`,
+`BIC()`, `deviance()`, `REMLcrit()`, `vcov()`, `summary()`, `fitted()`, `residuals()`,
+`predict()`, `simulate()`, `confint()`, `anova()`, `refitML()`, `update()`, `refit()`,
+`getME(name)`, `isSingular()`, `hatvalues()`, `as_function()` (función de devianza), ...
+
+Los resultados se devuelven como objetos pandas (`Series`/`DataFrame`) con los mismos
+nombres que en R.
+
+Los argumentos de control usan `_` en vez de `.`:
+`lmerControl(optimizer="bobyqa", check_conv_grad="ignore")`.
+
+## Instalación
+
+Requisitos: Python ≥ 3.9, numpy, scipy, pandas, nlopt, pybind11 y un compilador C++17.
+
+Con Poetry, directamente desde GitHub:
+
+```bash
+poetry add git+https://github.com/ljofreflor/lme4.git#develop
+```
+
+o con pip:
+
+```bash
+pip install git+https://github.com/ljofreflor/lme4.git@develop
+```
+
+La instalación compila el backend C++. Usa el compilador del sistema (MSVC, gcc,
+clang) y, si no hay ninguno, recurre automáticamente a Zig (paquete `ziglang`,
+que en Windows se instala como dependencia de compilación). La primera
+compilación tarda unos minutos. Para forzar Zig: `LME4_USE_ZIG=1`.
+
+Desarrollo local (compila la extensión dentro de `src/lme4`):
+
+```bash
+pip install numpy scipy pandas nlopt pybind11 ziglang
+python tools/build_ext.py --zig
+```
+
+## Fidelidad respecto de R
+
+- Los tests (`pytest`) reproducen valores numéricos de la suite de tests de lme4 2.1-0
+  (por ejemplo: `Dyestuff` REML 319.654276842342, `sleepstudy` REML 1743.628,
+  `cbpp` deviance 73.47154).
+- Diferencias de implementación:
+  - La factorización de Cholesky dispersa usa `Eigen::SimplicialLLT` con ordenamiento AMD
+    en lugar de CHOLMOD. Es matemáticamente idéntica, pero la permutación de `getME(m, "L")`
+    puede diferir.
+  - `nloptwrap` usa el paquete `nlopt` de Python (la misma biblioteca C que `nloptr`).
+  - `nlminbwrap` usa L-BFGS-B de scipy (el código PORT de R no está disponible).
+  - Las familias GLM se identifican por nombre: no se aceptan familias definidas por el
+    usuario.
+  - Los niveles de factores creados a partir de strings se ordenan por punto de código
+    (R usa el orden del *locale*). Los `Categorical` de pandas conservan su orden.
+
+## Estructura
+
+```
+src/cpp/        backend C++ (transcripción de lme4/src y minqa/src)
+src/lme4/       paquete Python (transcripción de lme4/R y reformulas/R)
+tests/          tests portados de lme4/tests
+tools/          compilación y conversión de datos
+upstream/       código fuente original de lme4, reformulas y minqa (referencia)
+third_party/    Eigen 3.4.0 (MPL2)
+```
+
+Licencia: GPL (>= 2), como lme4.

lme4-2.1.0a1/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=77", "wheel", "pybind11>=2.12", "ziglang; platform_system == \"Windows\""]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "lme4"
+version = "2.1.0a1"
+description = "Linear, generalized linear and nonlinear mixed-effects models: a faithful Python transcription of the R package lme4 with a C++ (Eigen) backend"
+readme = "README.md"
+license = "GPL-2.0-or-later"
+requires-python = ">=3.9"
+dependencies = ["numpy>=1.22", "scipy>=1.8", "pandas>=1.5", "nlopt>=2.7"]
+
+[project.optional-dependencies]
+test = ["pytest"]
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+lme4 = ["_fgq_rules.json", "datasets/*.csv.gz", "datasets/_factors.json"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+
+[tool.cibuildwheel]
+build = "cp39-* cp310-* cp311-* cp312-* cp313-*"
+skip = "*-win32 *-manylinux_i686 *-musllinux_*"
+# NumPy 2 wheels need glibc >= 2.28
+manylinux-x86_64-image = "manylinux_2_28"
+manylinux-aarch64-image = "manylinux_2_28"
+test-requires = ["pytest"]
+# test against the installed wheel (override pythonpath=src from the pytest config)
+test-command = "pytest -q -p no:cacheprovider -W ignore -o pythonpath= {project}/tests/test_lmer.py {project}/tests/test_glmer.py {project}/tests/test_reference.py"
+# run the (slower) tests only on one Python version per platform
+test-skip = "cp39-* cp310-* cp311-* cp313-*"

lme4-2.1.0a1/setup.cfg

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

lme4-2.1.0a1/setup.py

@@ -0,0 +1,81 @@
+"""Build script for the C++ backend (lme4._lme4cpp).
+
+Uses pybind11 + the vendored Eigen headers in third_party/eigen.  Any C++17
+compiler works (MSVC, gcc, clang).  If no working compiler is found, the
+extension is built with the Zig toolchain from the ``ziglang`` package
+(declared as a build requirement on Windows in pyproject.toml), so that
+``pip install`` / ``poetry add`` work on machines without Visual Studio.
+"""
+import os
+import subprocess
+import sys
+import sysconfig
+from pathlib import Path
+
+from pybind11.setup_helpers import Pybind11Extension, build_ext
+from setuptools import setup
+
+ROOT = Path(__file__).resolve().parent
+SRC = ["glmFamily.cpp", "predModule.cpp", "respModule.cpp", "optimizer.cpp", "bobyqa.cpp",
+       "external.cpp", "bindings.cpp"]
+
+ext = Pybind11Extension(
+    "lme4._lme4cpp",
+    [f"src/cpp/{f}" for f in SRC],
+    include_dirs=["third_party/eigen"],
+    define_macros=[("NDEBUG", None), ("_USE_MATH_DEFINES", None)],
+    cxx_std=17,
+)
+
+
+def zig_compile(output: Path):
+    """Compile the extension with ``python -m ziglang c++``."""
+    import pybind11
+    cmd = [sys.executable, "-m", "ziglang", "c++", "-std=c++17", "-shared", "-O2",
+           "-DNDEBUG", "-D_USE_MATH_DEFINES", "-fvisibility=hidden",
+           "-Wno-macro-redefined", "-Wno-deprecated-declarations",
+           f"-I{sysconfig.get_paths()['include']}", f"-I{pybind11.get_include()}",
+           f"-I{ROOT / 'third_party' / 'eigen'}",
+           *[str(ROOT / "src" / "cpp" / f) for f in SRC]]
+    if sys.platform == "win32":
+        cmd[4:4] = ["-target", "x86_64-windows-gnu"]
+        cmd += [f"-L{Path(sys.base_prefix) / 'libs'}",
+                f"-lpython{sys.version_info.major}{sys.version_info.minor}"]
+    elif sys.platform == "darwin":
+        cmd += ["-undefined", "dynamic_lookup"]
+    else:
+        cmd += ["-fPIC"]
+    output.parent.mkdir(parents=True, exist_ok=True)
+    cmd += ["-o", str(output)]
+    print("building lme4._lme4cpp with zig:\n  " + " ".join(cmd), flush=True)
+    subprocess.check_call(cmd)
+    for suffix in (".lib", ".pdb"):          # zig leaves import libs next to the .pyd
+        extra = output.with_suffix(suffix)
+        if extra.exists():
+            extra.unlink()
+
+
+class build_ext_with_fallback(build_ext):
+    """Try the platform compiler first; fall back to zig if it is missing."""
+
+    def run(self):
+        if os.environ.get("LME4_USE_ZIG") == "1":
+            return self._zig_all()
+        try:
+            super().run()
+        except Exception as e:  # missing MSVC raises DistutilsPlatformError, etc.
+            print(f"C++ compiler build failed ({e}); trying the zig toolchain", flush=True)
+            self._zig_all()
+
+    def _zig_all(self):
+        try:
+            import ziglang  # noqa: F401
+        except ImportError:
+            raise RuntimeError(
+                "No C++17 compiler was found and the 'ziglang' package is not installed. "
+                "Install a compiler (e.g. Visual Studio Build Tools) or `pip install ziglang`.")
+        for e in self.extensions:
+            zig_compile(Path(self.get_ext_fullpath(e.name)))
+
+
+setup(ext_modules=[ext], cmdclass={"build_ext": build_ext_with_fallback})