lme-python 0.1.2__tar.gz → 0.1.4__tar.gz

lme_python-0.1.4/.github/workflows/benchmarks.yml

@@ -0,0 +1,234 @@
+name: Benchmarks
+
+on:
+  workflow_dispatch:
+    inputs:
+      warmups:
+        description: Warmup runs per benchmark command
+        required: true
+        default: "1"
+      repeats:
+        description: Measured runs per benchmark command
+        required: true
+        default: "3"
+  push:
+    tags:
+      - "v*"
+
+permissions:
+  contents: write
+  pages: write
+  id-token: write
+
+env:
+  CARGO_TERM_COLOR: always
+  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: true
+  JULIA_VERSION: "1.10.11"
+
+jobs:
+  criterion:
+    name: Criterion Benchmarks
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - uses: dtolnay/rust-toolchain@stable
+
+      - name: Install OpenBLAS
+        run: sudo apt-get update && sudo apt-get install -y libopenblas-dev
+
+      - name: Cache cargo registry and build outputs
+        uses: actions/cache@v5
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ runner.os }}-bench-cargo-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: ${{ runner.os }}-bench-cargo-
+
+      - name: Run Criterion benchmarks
+        run: cargo bench
+
+      - name: Package Criterion baseline
+        run: |
+          mkdir -p benchmark-results
+          tar -czf "benchmark-results/criterion-${{ github.sha }}.tar.gz" target/criterion
+
+      - name: Upload Criterion artifact
+        uses: actions/upload-artifact@v7
+        with:
+          name: criterion-${{ github.sha }}
+          path: benchmark-results/criterion-${{ github.sha }}.tar.gz
+
+      - name: Attach Criterion artifact to GitHub Release
+        if: startsWith(github.ref, 'refs/tags/')
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          gh release view "${GITHUB_REF_NAME}" >/dev/null 2>&1 || {
+            if [[ "${GITHUB_REF_NAME}" == *-* ]]; then
+              gh release create "${GITHUB_REF_NAME}" --title "${GITHUB_REF_NAME}" --prerelease --latest=false
+            else
+              gh release create "${GITHUB_REF_NAME}" --title "${GITHUB_REF_NAME}"
+            fi
+          }
+          gh release upload "${GITHUB_REF_NAME}" "benchmark-results/criterion-${{ github.sha }}.tar.gz" --clobber
+
+  cross-language:
+    name: Cross-Language Benchmarks
+    runs-on: ubuntu-latest
+    env:
+      BENCH_WARMUPS: ${{ github.event_name == 'workflow_dispatch' && inputs.warmups || '1' }}
+      BENCH_REPEATS: ${{ github.event_name == 'workflow_dispatch' && inputs.repeats || '3' }}
+      R_LIBS_USER: ${{ github.workspace }}/.r-lib
+    steps:
+      - uses: actions/checkout@v6
+
+      - uses: dtolnay/rust-toolchain@stable
+
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.11"
+
+      - name: Install system dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libopenblas-dev libcurl4-openssl-dev libssl-dev libxml2-dev r-base
+          curl -fsSL "https://julialang-s3.julialang.org/bin/linux/x64/1.10/julia-${JULIA_VERSION}-linux-x86_64.tar.gz" -o /tmp/julia.tar.gz
+          sudo tar -xzf /tmp/julia.tar.gz -C /opt
+          sudo ln -sf "/opt/julia-${JULIA_VERSION}/bin/julia" /usr/local/bin/julia
+          Rscript --version
+          julia --version
+
+      - name: Cache cargo registry and build outputs
+        uses: actions/cache@v5
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ runner.os }}-crosslang-cargo-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: ${{ runner.os }}-crosslang-cargo-
+
+      - name: Install Python benchmark dependencies
+        run: python -m pip install maturin polars pandas statsmodels
+
+      - name: Build Python wheel
+        run: maturin build --release --manifest-path python/Cargo.toml
+
+      - name: Install Python bindings
+        run: python -m pip install --force-reinstall python/target/wheels/*.whl
+
+      - name: Install R benchmark dependencies
+        run: |
+          mkdir -p "$R_LIBS_USER"
+          Rscript -e 'install.packages("lme4", repos="https://cloud.r-project.org", lib=Sys.getenv("R_LIBS_USER"))'
+
+      - name: Install Julia benchmark dependencies
+        run: julia -e 'using Pkg; Pkg.add(["CSV", "DataFrames", "MixedModels"])'
+
+      - name: Build Rust examples
+        run: cargo build --release --examples
+
+      - name: Run cross-language benchmark script
+        id: cross_language_run
+        run: |
+          mkdir -p benchmark-results
+          set +e
+          python scripts/run_cross_language_benchmarks.py \
+            --warmups "$BENCH_WARMUPS" \
+            --repeats "$BENCH_REPEATS" \
+            --output "benchmark-results/cross-language-${{ github.sha }}.json" \
+            --skip-rust-build
+          status=$?
+          echo "status=$status" >> "$GITHUB_OUTPUT"
+          exit 0
+
+      - name: Upload cross-language artifact
+        if: always()
+        uses: actions/upload-artifact@v7
+        with:
+          name: cross-language-${{ github.sha }}
+          path: benchmark-results/cross-language-${{ github.sha }}.json
+
+      - name: Attach cross-language artifact to GitHub Release
+        if: always() && startsWith(github.ref, 'refs/tags/')
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          gh release view "${GITHUB_REF_NAME}" >/dev/null 2>&1 || {
+            if [[ "${GITHUB_REF_NAME}" == *-* ]]; then
+              gh release create "${GITHUB_REF_NAME}" --title "${GITHUB_REF_NAME}" --prerelease --latest=false
+            else
+              gh release create "${GITHUB_REF_NAME}" --title "${GITHUB_REF_NAME}"
+            fi
+          }
+          gh release upload "${GITHUB_REF_NAME}" "benchmark-results/cross-language-${{ github.sha }}.json" --clobber
+
+      - name: Fail if cross-language benchmarks failed
+        if: steps.cross_language_run.outputs.status != '0'
+        run: |
+          echo "Cross-language benchmark script failed with exit code ${{ steps.cross_language_run.outputs.status }}." >&2
+          exit 1
+
+  pages:
+    name: Publish Benchmark Dashboard
+    runs-on: ubuntu-latest
+    needs:
+      - criterion
+      - cross-language
+    if: needs.criterion.result == 'success' && needs.cross-language.result == 'success' && (github.ref == 'refs/heads/master' || startsWith(github.ref, 'refs/tags/'))
+    environment:
+      name: github-pages
+      url: ${{ steps.deploy.outputs.page_url }}
+    steps:
+      - uses: actions/checkout@v6
+
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.11"
+
+      - name: Download cross-language artifact
+        uses: actions/download-artifact@v5
+        with:
+          name: cross-language-${{ github.sha }}
+          path: site-input
+
+      - name: Resolve release URL
+        id: release_url
+        run: |
+          if [[ "${GITHUB_REF}" == refs/tags/* ]]; then
+            echo "value=${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}/releases/tag/${GITHUB_REF_NAME}" >> "$GITHUB_OUTPUT"
+          else
+            echo "value=" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Build benchmark dashboard
+        run: |
+          set -euo pipefail
+          mkdir -p site
+          cp -R docs/. site/
+          mkdir -p site/benchmarks/data
+          cross_json="$(find site-input -name 'cross-language-*.json' -print -quit)"
+          python scripts/build_benchmark_site.py \
+            --cross-language-json "$cross_json" \
+            --output-dir "site/benchmarks/data" \
+            --run-url "${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}/actions/runs/${GITHUB_RUN_ID}" \
+            --release-url "${{ steps.release_url.outputs.value }}" \
+            --criterion-asset-name "criterion-${GITHUB_SHA}.tar.gz" \
+            --cross-language-asset-name "cross-language-${GITHUB_SHA}.json" \
+            --ref-name "${GITHUB_REF_NAME}"
+
+      - uses: actions/configure-pages@v5
+        with:
+          token: ${{ secrets.REPO_ADMIN_TOKEN != '' && secrets.REPO_ADMIN_TOKEN || github.token }}
+          enablement: ${{ secrets.REPO_ADMIN_TOKEN != '' }}
+
+      - uses: actions/upload-pages-artifact@v3
+        with:
+          path: site
+
+      - name: Deploy to GitHub Pages
+        id: deploy
+        uses: actions/deploy-pages@v4

lme_python-0.1.4/.github/workflows/repo-metadata.yml

@@ -0,0 +1,35 @@
+name: Sync Repository Metadata
+
+on:
+  push:
+    branches: [master]
+    paths:
+      - Cargo.toml
+      - scripts/sync_github_repo_metadata.py
+      - .github/workflows/repo-metadata.yml
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  sync:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Verify admin token is configured
+        env:
+          REPO_ADMIN_TOKEN: ${{ secrets.REPO_ADMIN_TOKEN }}
+        run: |
+          if [ -z "$REPO_ADMIN_TOKEN" ]; then
+            echo "REPO_ADMIN_TOKEN is not set."
+            echo "Create a fine-grained PAT or GitHub App token with repository Administration: write."
+            exit 1
+          fi
+
+      - name: Sync repository metadata
+        env:
+          REPO_ADMIN_TOKEN: ${{ secrets.REPO_ADMIN_TOKEN }}
+          GITHUB_REPOSITORY: ${{ github.repository }}
+        run: python scripts/sync_github_repo_metadata.py

{lme_python-0.1.2 → lme_python-0.1.4}/.gitignore

@@ -4,6 +4,10 @@ rlib/
 julia-portable/
 julia-portable.zip
 flamegraph.svg
+artifacts/
+benchmark-results/
+benchmark-site/
+site/
 
 # Python bindings
 python/target/

lme_python-0.1.4/BENCHMARKS.md

@@ -0,0 +1,183 @@
+# Benchmarks
+
+This repository includes Criterion benchmarks for the Rust crate. Performance is an important selling point of `lme-rs`, but the benchmark suite should be described accurately: it is useful and non-trivial, yet it is not comprehensive enough to support blanket speed claims on its own.
+
+## Current benchmark coverage
+
+The existing benchmark target is [benches/bench_math.rs](benches/bench_math.rs).
+
+It currently covers these benchmark families:
+
+- formula parsing for representative random-slope, nested, and crossed formulas
+- model-matrix construction for representative random-slope, nested, and crossed datasets
+- internal REML deviance evaluation on a fixture-backed random-slopes model
+- isolated large-scale REML deviance evaluation on a synthetic sparse model (`50k` observations)
+- end-to-end `lmer()` fitting on `sleepstudy`
+- end-to-end weighted `lmer_weighted()` fitting on fixture-backed and large synthetic cases
+- end-to-end `glmer()` fitting on `grouseticks` and `cbpp`
+- population-level and conditional prediction on a larger repeated `sleepstudy` frame
+- response-scale and conditional response-scale GLMM prediction on repeated Poisson and Binomial frames
+- GLMM post-fit helpers such as Wald confidence intervals
+- end-to-end `lmer()` fitting on a large synthetic random-intercept model (`100k` observations)
+- end-to-end large crossed-effects and nested-effects fits
+- parameterized size and complexity sweeps for random-intercept, crossed-effects, and nested-effects fits
+- inference helpers: `with_robust_se()`, `with_satterthwaite()`, `with_kenward_roger()`, and ANOVA paths
+
+That is enough to catch obvious regressions in the parser, design-matrix path, core math path, several end-to-end fits, and a meaningful slice of the inference and post-fit surface.
+
+## What the current suite does well
+
+- Exercises both internal evaluation and public API entry points.
+- Covers multiple stages of the modeling pipeline instead of only full-model fits.
+- Covers both LMM and GLMM workflows.
+- Includes both fixture-backed and synthetic large-scale cases.
+- Includes nested and crossed random-effects structures.
+- Includes weighted-model coverage.
+- Includes parameterized size and complexity sweeps instead of only a few one-off scales.
+- Includes several inference-heavy operations that are materially more expensive than fitting alone.
+- Uses Criterion, which gives stable repeated measurements and report generation.
+
+## What it does not cover yet
+
+The current benchmark suite is still narrow in a few important ways.
+
+### Missing comparisons
+
+The repo now includes automated cross-language timing for representative example workloads through [scripts/run_cross_language_benchmarks.py](scripts/run_cross_language_benchmarks.py), including Rust, Python, R, and Julia runs where the required runtimes are installed.
+
+What it still does not provide is a fully normalized cross-ecosystem benchmark harness with carefully matched optimizer settings, dataset loading rules, and machine-locked baselines for publication-grade claims.
+
+### Missing workload diversity
+
+It does not yet isolate or compare:
+
+- prediction throughput on large crossed and nested structures
+- weighted GLMM-style workflows if those are added later
+- GLMM inference and post-fit helper costs beyond the currently benchmarked paths
+- confidence interval and simulation throughput across multiple model sizes
+
+### Missing benchmark dimensions
+
+It does not currently sweep over controlled workload dimensions such as:
+
+- number of observations
+- number of groups
+- random intercept vs random slope structure
+- family and link combinations
+- dense-like vs sparse-like random-effect structure
+
+## Cross-language benchmark methodology
+
+If you want to make public performance claims against R, Python, or Julia, use a fixed methodology and record it alongside the results. The repo now automates example-level cross-language timing, but the methodology still matters because the ecosystems do not all expose exactly the same optimizers or post-fit APIs.
+
+Recommended rules:
+
+- run all languages on the same machine
+- record CPU model, RAM, OS, compiler/interpreter versions, and BLAS backend
+- use fixed datasets and fixed formulas
+- compare like with like: REML vs REML, ML vs ML, same family, same link, same random-effects structure
+- exclude file I/O from timed sections unless I/O is the thing being compared
+- warm up the runtime before collecting measurements
+- run multiple repetitions and report medians or confidence intervals, not a single best run
+- note when optimizers are not directly comparable across ecosystems
+- keep output artifacts or raw logs so later releases can be compared to the same baseline
+
+For this repo, the most defensible cross-language benchmark set would start with the same reference datasets already used in `comparisons/COMPARISONS.md`:
+
+- `sleepstudy`
+- `dyestuff`
+- `pastes`
+- `penicillin`
+- `cbpp`
+- `grouseticks`
+
+## How to run the benchmarks
+
+Run from the repository root:
+
+```bash
+cargo bench
+```
+
+To compile the benchmarks without executing them:
+
+```bash
+cargo bench --no-run
+```
+
+Criterion will emit reports under `target/criterion/`.
+
+For automated cross-language timing, run:
+
+```bash
+python scripts/run_cross_language_benchmarks.py
+```
+
+This script writes JSON output with runtime versions, machine metadata, and per-command timing summaries.
+
+The repository also includes a dedicated workflow in [.github/workflows/benchmarks.yml](.github/workflows/benchmarks.yml) that:
+
+- runs Criterion benchmarks
+- archives `target/criterion`
+- runs the cross-language benchmark script
+- uploads the resulting artifacts in CI
+- attaches them to GitHub Releases on tag pushes
+- publishes the latest benchmark dashboard to GitHub Pages at `https://x4g4p3x.github.io/lme-rs/benchmarks/`
+
+## Latest published results
+
+The latest published benchmark artifacts are attached to the [v0.1.3 release](https://github.com/x4g4p3x/lme-rs/releases/tag/v0.1.3).
+
+That release currently includes:
+
+- `criterion-e8a82e0b97b88c5549bc61e89c22dc12c9060a02.tar.gz`
+- `cross-language-e8a82e0b97b88c5549bc61e89c22dc12c9060a02.json`
+
+The cross-language JSON includes representative timings for:
+
+- `sleepstudy`
+- `pastes`
+- `cbpp`
+- `grouseticks`
+
+across:
+
+- Rust
+- Python
+- R
+- Julia
+
+Treat those numbers as versioned release artifacts, not as universal constants. They were produced on GitHub-hosted runners with the workflow's pinned toolchain setup, so they are useful for release-to-release comparison and public transparency, but not as machine-independent proof of absolute speed.
+
+If you want to cite benchmark results in release notes or external docs, prefer linking the release asset directly instead of copying raw numbers into the README. That keeps the landing page stable while still making the measured outputs inspectable.
+
+## How to interpret results
+
+Use the existing suite primarily for:
+
+- detecting regressions after changes to fitting logic
+- tracking the cost of core LMM and GLMM paths over time
+- sanity-checking large synthetic scaling cases
+
+Do not use the current suite alone as evidence that `lme-rs` is universally faster than `lme4`, `statsmodels`, or `MixedModels.jl`.
+
+## Recommended next extensions
+
+If performance is going to remain a central public claim, the benchmark suite should be extended. The highest-value additions are:
+
+1. Version-to-version regression tracking with saved benchmark outputs in CI or release notes.
+2. More controlled cross-language benchmark cases with tighter optimizer comparability notes.
+3. Prediction and post-fit sweeps for larger crossed and nested structures than the current medium-scale cases.
+4. More explicit GLMM post-fit benchmarks beyond fitting, prediction, and Wald intervals.
+5. Benchmarks that isolate optimizer iteration cost separately from formula parsing and matrix construction.
+
+## Recommendation for this repo today
+
+The current benchmarking is meaningful, but not comprehensive.
+
+That means:
+
+- yes, keep performance as a selling point
+- no, avoid absolute claims without extending the suite further
+- yes, run benchmarks for performance-sensitive changes before release
+- yes, extend the benchmark surface if performance is going to stay front-and-center in the README and release notes

lme_python-0.1.4/CHANGELOG.md

@@ -0,0 +1,72 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.4] - 2026-03-22
+
+### Added
+
+- Formula-string entry point `lm()` and corresponding Python binding for fitting ordinary least squares models using DataFrames.
+- New Python examples directory `python/examples` with five runnable demonstration scripts mapping to common mixed-modeling workflows.
+
+### Changed
+
+- Renamed `examples/` directory to `comparisons/` to clarify that it contains cross-language parity scripts, updating all build and documentation references accordingly.
+- Promoted Kenward-Roger degrees of freedom from "provisional" status after validating numerical parity (within 0.01 df) against R's `pbkrtest`.
+
+## [0.1.3] - 2026-03-12
+
+### Added
+
+- Expanded the benchmark suite to cover parsing, matrix construction, prediction paths, inference helpers, weighted fits, Kenward-Roger timing, and size sweeps.
+- Added automated cross-language benchmark scripting and a GitHub workflow that saves benchmark artifacts in CI and on release tags.
+- Added `CONTRIBUTING.md`, `RELEASING.md`, and `BENCHMARKS.md` to document contributor setup, release flow, and benchmark methodology.
+
+### Changed
+
+- Reworked the README, Rust guide, Python guide, and comparison documentation to better reflect current capabilities, limitations, and release workflow.
+- Switched the crate homepage to the docs.rs site and expanded repository metadata sync for GitHub description, topics, and website fields.
+- Hardened the benchmark automation and example scripts so cross-language benchmark runs complete consistently on GitHub Actions.
+
+## [0.1.2] - 2026-03-09
+
+### Fixed
+
+- Fixed a NaN deviance issue in the fitting path.
+- Expanded Python test coverage for the 0.1.2 release.
+
+### Changed
+
+- Aligned `Cargo.lock` with the 0.1.2 version bump.
+
+## [0.1.1] - 2026-03-09
+
+### Changed
+
+- Bumped the crate and Python extension versions for the 0.1.1 release.
+- Updated lockfiles to remove yanked dependencies.
+- Fixed missing documentation warnings needed for publishing.
+
+### Fixed
+
+- Hardened the GitHub Actions and wheel build pipeline across Linux, macOS, and Windows.
+- Restored missing dependencies and build flags needed for OpenBLAS-based wheel builds.
+- Fixed several maturin and PyO3 packaging workflow issues for the Python release path.
+
+## [0.1.0] - 2026-03-08
+
+### Added
+
+- **Core LMM** - `lmer()` with REML and ML estimation, matching R's `lme4` to 4 decimal places
+- **GLMM** - `glmer()` with Poisson, Binomial, Gaussian, and Gamma families via Laplace approximation
+- **Predictions** - `predict()`, `predict_conditional()`, `predict_response()`, `predict_conditional_response()` with `allow_new_levels` support
+- **Inference** - Satterthwaite and Kenward-Roger degrees of freedom, robust sandwich standard errors
+- **Model comparison** - `anova()` for likelihood ratio tests between nested models
+- **Diagnostics** - `confint()` for Wald confidence intervals, `simulate()` for parametric bootstrap
+- **Formula parser** - Wilkinson notation with nested (`a/b`), crossed (`a + b`), and correlated slope+intercept (`x | group`) random effects
+- **Sparse matrix architecture** - Compressed sparse column format with sparse Cholesky for large datasets
+- **Python bindings** - `lme_python` package via PyO3/maturin with `lmer()`, `glmer()`, `predict()`
+- **Documentation** - `GUIDE.md`, `PYTHON_GUIDE.md`, and cross-language `COMPARISONS.md`

lme_python-0.1.4/CONTRIBUTING.md

@@ -0,0 +1,91 @@
+# Contributing
+
+## Scope
+
+This repository contains:
+
+- the Rust crate in the repository root
+- the Python bindings in `python/`
+- cross-language comparison scripts in `comparisons/`
+- regression fixtures and integration tests in `tests/`
+
+## Local setup
+
+### Rust
+
+Install a stable Rust toolchain via [rustup](https://rustup.rs).
+
+Useful commands:
+
+```bash
+cargo build
+cargo test
+cargo test --doc
+cargo fmt --check
+cargo clippy -- -D warnings
+```
+
+### Python bindings
+
+If you are changing `python/` or verifying the Python package locally:
+
+```bash
+cd python
+python -m venv .venv
+
+# Windows
+.venv\Scripts\activate
+
+# macOS / Linux
+source .venv/bin/activate
+
+pip install maturin polars pytest
+maturin develop --release
+pytest
+```
+
+## Working on numerical changes
+
+If you change fitting logic, optimizer behavior, variance calculations, or inference code:
+
+- add or update Rust tests in `tests/`
+- prefer fixture-backed tests for parity-sensitive behavior
+- update `comparisons/COMPARISONS.md` when the reference output changes materially
+- validate hard cases against R `lme4` where practical
+
+Relevant files and directories:
+
+- `src/` for the crate implementation
+- `tests/data/` for fixture inputs
+- `tests/generate_test_data.R` for R-backed fixture generation
+- `comparisons/` for cross-language parity scripts (R, Python/statsmodels, Julia)
+
+## Working on documentation
+
+When documentation changes affect user-visible behavior, keep these files aligned:
+
+- `README.md` for the repository landing page
+- `GUIDE.md` for Rust usage
+- `python/PYTHON_GUIDE.md` for Python usage
+- `CHANGELOG.md` for release-facing notes
+
+Do not describe a feature as supported unless it is exposed by the public API and covered by tests or concrete examples.
+
+## Repository metadata sync
+
+The GitHub About box is synced from `Cargo.toml` using:
+
+- `.github/workflows/repo-metadata.yml`
+- `scripts/sync_github_repo_metadata.py`
+
+If you change `package.description`, `homepage`, `keywords`, or `categories`, the metadata workflow will update the GitHub repository metadata on the next run.
+
+## Pull request expectations
+
+Keep changes focused. For non-trivial changes, include:
+
+- the user-visible behavior change
+- the tests you ran
+- any compatibility or migration note if behavior changed
+
+If a change is provisional or only partially mirrors R behavior, document that explicitly instead of implying full parity.

{lme_python-0.1.2 → lme_python-0.1.4}/Cargo.lock

@@ -1528,7 +1528,7 @@ checksum = "11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092"
 
 [[package]]
 name = "lme-rs"
-version = "0.1.2"
+version = "0.1.4"
 dependencies = [
  "anyhow",
  "argmin",

{lme_python-0.1.2 → lme_python-0.1.4}/Cargo.toml

@@ -1,12 +1,12 @@
 [package]
 name = "lme-rs"
-version = "0.1.2"
+version = "0.1.4"
 edition = "2021"
 authors = ["Martin Huck <x4g4p3x@users.noreply.github.com>"]
 description = "Rust port of R's lme4: linear mixed-effects models with 1:1 numerical compatibility"
 license = "MIT"
 repository = "https://github.com/x4g4p3x/lme-rs"
-homepage = "https://github.com/x4g4p3x/lme-rs"
+homepage = "https://docs.rs/lme-rs/latest/lme_rs/"
 readme = "README.md"
 keywords = ["statistics", "lme4", "mixed-effects", "glmm", "regression"]
 categories = ["science", "mathematics"]
@@ -38,6 +38,35 @@ debug = true
 
 [[bench]]
 name = "bench_math"
+harness = false
+
+[[example]]
+name = "glmm_cbpp"
+path = "comparisons/glmm_cbpp.rs"
+
+[[example]]
+name = "glmm_grouseticks"
+path = "comparisons/glmm_grouseticks.rs"
+
+[[example]]
+name = "lmm_dyestuff"
+path = "comparisons/lmm_dyestuff.rs"
+
+[[example]]
+name = "lmm_pastes"
+path = "comparisons/lmm_pastes.rs"
+
+[[example]]
+name = "lmm_penicillin"
+path = "comparisons/lmm_penicillin.rs"
+
+[[example]]
+name = "sleepstudy"
+path = "comparisons/sleepstudy.rs"
+
+[[example]]
+name = "sleepstudy_ml"
+path = "comparisons/sleepstudy_ml.rs"
 
 [target.'cfg(target_arch = "x86_64")'.dependencies]
 ndarray-linalg = { version = "0.17", features = ["intel-mkl-static"] }