A High-Performance Framework for Sparse Matrices

remotes::install_github("esmail-abdulfattah/sTiles", subdir = "R/sTiles")

library(sTiles); library(Matrix)

# Q: a symmetric positive-definite sparse matrix
Q <- as(bandSparse(6, k = c(0, 1),
        diagonals = list(rep(4, 6), rep(-1, 5)), symmetric = TRUE), "CsparseMatrix")

s <- sTiles(Q, cores = 4, inverse = TRUE)   # analyze + Cholesky factorize

sTiles_logdet(s)            # log|Q|
sTiles_solve(s, rep(1, 6))  # solve Q x = b
sTiles_selinv_diag(s)       # diag(Q^-1), the marginal variances
sTiles_selinv_elm(s, 1, 1)  # any inverse element within the factor pattern
sTiles_close(s)

# Easiest: let pkg-config supply the paths (the .pc is relocatable,
# so it resolves against wherever you unpacked the archive).
export PKG_CONFIG_PATH=/path/to/stiles/lib/pkgconfig
g++ -O3 -fopenmp app.cpp $(pkg-config --cflags --libs stiles) -o app

# Linux  (libstiles.so)
g++ -O3 -fopenmp app.cpp \
  -I/path/to/stiles/include \
  -L/path/to/stiles/lib -Wl,-rpath,/path/to/stiles/lib -lstiles -o app

# macOS, Apple Silicon  (libstiles.dylib -- self-contained;
# -lomp here is for YOUR app's own OpenMP, not for sTiles)
clang++ -O3 -Xpreprocessor -fopenmp app.cpp \
  -I/path/to/stiles/include \
  -L/path/to/stiles/lib -Wl,-rpath,/path/to/stiles/lib -lstiles -lomp -o app

# Windows, MinGW-w64 UCRT64  (libstiles.dll)
g++ -O3 -fopenmp app.cpp \
  -I/path/to/stiles/include \
  -L/path/to/stiles/lib -lstiles -o app.exe
# then run app.exe with the archive's lib\ on PATH -- the .dll ships
# beside its runtime dependencies (OpenBLAS, gfortran, gomp, ...).

#include "stiles.h"
#include <vector>
#include <cstdio>

int main() {
    int N = 4, NNZ = 7;                    // 4x4 SPD, one triangle (row >= col)
    std::vector<int>    rows = {0,1,1,2,2,3,3};
    std::vector<int>    cols = {0,0,1,1,2,2,3};
    std::vector<double> vals = {10,-1,10,-1,10,-1,10};

    int  calls[]={1}, cores[]={4}, variant[]={0};
    bool need_inv[]={true};

    void* h = nullptr;
    sTiles_create(&h, 1, calls, cores, variant, need_inv);
    sTiles_assign_graph_one_call(0, 0, &h, N, NNZ, rows.data(), cols.data());
    sTiles_init_group(0, &h);              // symbolic factorization
    sTiles_assign_values(0, 0, &h, vals.data());

    sTiles_bind(0, 0, &h);
    sTiles_chol(0, 0, &h);                 // Cholesky
    sTiles_selinv(0, 0, &h);               // selected inverse
    sTiles_unbind(0, 0, &h);

    printf("logdet = %.6f\n", sTiles_get_logdet(0, 0, &h));
    printf("Var[0] = %.6f\n", sTiles_get_selinv_elm(0, 0, 0, 0, &h));
    sTiles_quit();
}

#include "stiles.h"
#include <vector>
#include <cstdio>

int main() {
    int N = 4, NNZ = 7;
    std::vector<int>    rows = {0,1,1,2,2,3,3};
    std::vector<int>    cols = {0,0,1,1,2,2,3};
    std::vector<double> vals = {10,-1,10,-1,10,-1,10};

    int  calls[]={1}, cores[]={4}, variant[]={0};
    bool need_inv[]={false};

    void* h = nullptr;
    sTiles_create(&h, 1, calls, cores, variant, need_inv);
    sTiles_assign_graph_one_call(0, 0, &h, N, NNZ, rows.data(), cols.data());
    sTiles_init_group(0, &h);
    sTiles_assign_values(0, 0, &h, vals.data());

    sTiles_bind(0, 0, &h);
    sTiles_chol(0, 0, &h);
    double b[4] = {1, 2, 3, 4};            // b, overwritten with the solution x
    sTiles_solve_LLT(0, 0, &h, b, 1);      // solve A x = b  (nrhs = 1)
    sTiles_unbind(0, 0, &h);

    printf("x = [%.4f %.4f %.4f %.4f]\n", b[0], b[1], b[2], b[3]);
    sTiles_quit();
}