scm2cpp-learn 0.18.0__py3-none-win_amd64.whl

scm2cpp_learn/_generated/_loader_gramops_loops.py

@@ -0,0 +1,711 @@
+# ctypes loader for libgramops.so, generated alongside it.
+# Arrays are numpy arrays of the declared dtype; they are made
+# contiguous on the way in and mutated in place where the translated
+# function mutates them.
+import ctypes
+import numpy as np
+from pathlib import Path
+
+from .._libfind import load_gramops_lib as _load_gramops_lib
+
+_lib = _load_gramops_lib("loops")
+
+_lib.scm2cpp_spd_inverse.restype = ctypes.c_int
+_lib.scm2cpp_spd_inverse.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int]
+def spd_inverse(a, inv, l, z, p):
+    a = np.ascontiguousarray(a, dtype=np.float64)
+    inv = np.ascontiguousarray(inv, dtype=np.float64)
+    l = np.ascontiguousarray(l, dtype=np.float64)
+    z = np.ascontiguousarray(z, dtype=np.float64)
+    return _lib.scm2cpp_spd_inverse(a.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), inv.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), l.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), z.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), p)
+
+_lib.scm2cpp_enet_gap.restype = ctypes.c_int
+_lib.scm2cpp_enet_gap.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_double, ctypes.c_double, ctypes.c_int]
+def enet_gap(w, q, qw, xta, out, alpha, ynorm2, m):
+    w = np.ascontiguousarray(w, dtype=np.float64)
+    q = np.ascontiguousarray(q, dtype=np.float64)
+    qw = np.ascontiguousarray(qw, dtype=np.float64)
+    xta = np.ascontiguousarray(xta, dtype=np.float64)
+    out = np.ascontiguousarray(out, dtype=np.float64)
+    assert out.size == 2, "out: expected 2 elements"
+    return _lib.scm2cpp_enet_gap(w.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), q.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), qw.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), xta.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), out.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), alpha, ynorm2, m)
+
+_lib.scm2cpp_enet_safe_rule.restype = ctypes.c_int
+_lib.scm2cpp_enet_safe_rule.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_double), ctypes.c_double, ctypes.c_int]
+def enet_safe_rule(w, qm, qw, xta, active, excl, out, alpha, m):
+    w = np.ascontiguousarray(w, dtype=np.float64)
+    qm = np.ascontiguousarray(qm, dtype=np.float64)
+    qw = np.ascontiguousarray(qw, dtype=np.float64)
+    xta = np.ascontiguousarray(xta, dtype=np.float64)
+    active = np.ascontiguousarray(active, dtype=np.int32)
+    excl = np.ascontiguousarray(excl, dtype=np.int32)
+    out = np.ascontiguousarray(out, dtype=np.float64)
+    assert out.size == 2, "out: expected 2 elements"
+    return _lib.scm2cpp_enet_safe_rule(w.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), qm.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), qw.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), xta.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), active.ctypes.data_as(ctypes.POINTER(ctypes.c_int)), excl.ctypes.data_as(ctypes.POINTER(ctypes.c_int)), out.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), alpha, m)
+
+_lib.scm2cpp_enet_gram.restype = ctypes.c_int
+_lib.scm2cpp_enet_gram.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_double), ctypes.c_double, ctypes.c_int, ctypes.c_double, ctypes.c_int]
+def enet_gram(w, qm, q, qw, xta, active, excl, out, alpha, maxiter, tol, m):
+    w = np.ascontiguousarray(w, dtype=np.float64)
+    qm = np.ascontiguousarray(qm, dtype=np.float64)
+    q = np.ascontiguousarray(q, dtype=np.float64)
+    qw = np.ascontiguousarray(qw, dtype=np.float64)
+    xta = np.ascontiguousarray(xta, dtype=np.float64)
+    active = np.ascontiguousarray(active, dtype=np.int32)
+    excl = np.ascontiguousarray(excl, dtype=np.int32)
+    out = np.ascontiguousarray(out, dtype=np.float64)
+    assert out.size == 2, "out: expected 2 elements"
+    return _lib.scm2cpp_enet_gram(w.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), qm.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), q.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), qw.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), xta.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), active.ctypes.data_as(ctypes.POINTER(ctypes.c_int)), excl.ctypes.data_as(ctypes.POINTER(ctypes.c_int)), out.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), alpha, maxiter, tol, m)
+
+_lib.scm2cpp_graphical_lasso.restype = ctypes.c_int
+_lib.scm2cpp_graphical_lasso.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_double, ctypes.c_int, ctypes.c_double, ctypes.c_double, ctypes.c_int]
+def graphical_lasso(emp, cov, prec, alpha, maxiter, tol, enettol, p):
+    emp = np.ascontiguousarray(emp, dtype=np.float64)
+    cov = np.ascontiguousarray(cov, dtype=np.float64)
+    prec = np.ascontiguousarray(prec, dtype=np.float64)
+    return _lib.scm2cpp_graphical_lasso(emp.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), cov.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), prec.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), alpha, maxiter, tol, enettol, p)
+
+_lib.scm2cpp_omp.restype = ctypes.c_int
+_lib.scm2cpp_omp.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int]
+def omp(x, y, coef, path, rec, kmax, n, p):
+    x = np.ascontiguousarray(x, dtype=np.float64)
+    y = np.ascontiguousarray(y, dtype=np.float64)
+    coef = np.ascontiguousarray(coef, dtype=np.float64)
+    path = np.ascontiguousarray(path, dtype=np.float64)
+    return _lib.scm2cpp_omp(x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), y.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), coef.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), path.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), rec, kmax, n, p)
+
+_lib.scm2cpp_logistic_fg.restype = ctypes.c_double
+_lib.scm2cpp_logistic_fg.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_double, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int]
+def logistic_fg(coef, g, x, y, z, l2, multi, fitint, n, p, k):
+    coef = np.ascontiguousarray(coef, dtype=np.float64)
+    g = np.ascontiguousarray(g, dtype=np.float64)
+    x = np.ascontiguousarray(x, dtype=np.float64)
+    y = np.ascontiguousarray(y, dtype=np.float64)
+    z = np.ascontiguousarray(z, dtype=np.float64)
+    return _lib.scm2cpp_logistic_fg(coef.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), g.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), y.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), z.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), l2, multi, fitint, n, p, k)
+
+_lib.scm2cpp_logistic_lbfgs.restype = ctypes.c_int
+_lib.scm2cpp_logistic_lbfgs.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_double, ctypes.c_int, ctypes.c_double, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int]
+def logistic_lbfgs(x, y, coef, out, c, maxiter, tol, multi, fitint, n, p, k):
+    x = np.ascontiguousarray(x, dtype=np.float64)
+    y = np.ascontiguousarray(y, dtype=np.float64)
+    coef = np.ascontiguousarray(coef, dtype=np.float64)
+    out = np.ascontiguousarray(out, dtype=np.float64)
+    return _lib.scm2cpp_logistic_lbfgs(x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), y.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), coef.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), out.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), c, maxiter, tol, multi, fitint, n, p, k)
+
+_lib.scm2cpp_huber_fg.restype = ctypes.c_double
+_lib.scm2cpp_huber_fg.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_double, ctypes.c_double, ctypes.c_int, ctypes.c_int, ctypes.c_int]
+def huber_fg(coef, g, x, y, z, epsilon, alpha, fitint, n, p):
+    coef = np.ascontiguousarray(coef, dtype=np.float64)
+    g = np.ascontiguousarray(g, dtype=np.float64)
+    x = np.ascontiguousarray(x, dtype=np.float64)
+    y = np.ascontiguousarray(y, dtype=np.float64)
+    z = np.ascontiguousarray(z, dtype=np.float64)
+    return _lib.scm2cpp_huber_fg(coef.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), g.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), y.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), z.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), epsilon, alpha, fitint, n, p)
+
+_lib.scm2cpp_huber.restype = ctypes.c_int
+_lib.scm2cpp_huber.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_double, ctypes.c_double, ctypes.c_int, ctypes.c_double, ctypes.c_int, ctypes.c_int, ctypes.c_int]
+def huber(x, y, coef, out, epsilon, alpha, maxiter, tol, fitint, n, p):
+    x = np.ascontiguousarray(x, dtype=np.float64)
+    y = np.ascontiguousarray(y, dtype=np.float64)
+    coef = np.ascontiguousarray(coef, dtype=np.float64)
+    out = np.ascontiguousarray(out, dtype=np.float64)
+    return _lib.scm2cpp_huber(x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), y.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), coef.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), out.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), epsilon, alpha, maxiter, tol, fitint, n, p)
+
+_lib.scm2cpp_glm_fg.restype = ctypes.c_double
+_lib.scm2cpp_glm_fg.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_double, ctypes.c_double, ctypes.c_int, ctypes.c_int, ctypes.c_int]
+def glm_fg(coef, g, x, y, z, family, power, l2, fitint, n, p):
+    coef = np.ascontiguousarray(coef, dtype=np.float64)
+    g = np.ascontiguousarray(g, dtype=np.float64)
+    x = np.ascontiguousarray(x, dtype=np.float64)
+    y = np.ascontiguousarray(y, dtype=np.float64)
+    z = np.ascontiguousarray(z, dtype=np.float64)
+    return _lib.scm2cpp_glm_fg(coef.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), g.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), y.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), z.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), family, power, l2, fitint, n, p)
+
+_lib.scm2cpp_glm.restype = ctypes.c_int
+_lib.scm2cpp_glm.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_double, ctypes.c_double, ctypes.c_int, ctypes.c_double, ctypes.c_int, ctypes.c_int, ctypes.c_int]
+def glm(x, y, coef, out, family, power, alpha, maxiter, tol, fitint, n, p):
+    x = np.ascontiguousarray(x, dtype=np.float64)
+    y = np.ascontiguousarray(y, dtype=np.float64)
+    coef = np.ascontiguousarray(coef, dtype=np.float64)
+    out = np.ascontiguousarray(out, dtype=np.float64)
+    return _lib.scm2cpp_glm(x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), y.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), coef.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), out.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), family, power, alpha, maxiter, tol, fitint, n, p)
+
+_lib.scm2cpp_lb_abs.restype = ctypes.c_double
+_lib.scm2cpp_lb_abs.argtypes = [ctypes.c_double]
+def lb_abs(a):
+    return _lib.scm2cpp_lb_abs(a)
+
+_lib.scm2cpp_lb_max.restype = ctypes.c_double
+_lib.scm2cpp_lb_max.argtypes = [ctypes.c_double, ctypes.c_double]
+def lb_max(a, b):
+    return _lib.scm2cpp_lb_max(a, b)
+
+_lib.scm2cpp_lb_min.restype = ctypes.c_double
+_lib.scm2cpp_lb_min.argtypes = [ctypes.c_double, ctypes.c_double]
+def lb_min(a, b):
+    return _lib.scm2cpp_lb_min(a, b)
+
+_lib.scm2cpp_lb_dcstep.restype = ctypes.c_int
+_lib.scm2cpp_lb_dcstep.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.c_double, ctypes.c_double, ctypes.c_double, ctypes.c_double]
+def lb_dcstep(cs, fp, dp, stpmin, stpmax):
+    cs = np.ascontiguousarray(cs, dtype=np.float64)
+    assert cs.size == 8, "cs: expected 8 elements"
+    return _lib.scm2cpp_lb_dcstep(cs.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), fp, dp, stpmin, stpmax)
+
+_lib.scm2cpp_lb_search_start.restype = ctypes.c_int
+_lib.scm2cpp_lb_search_start.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.c_double, ctypes.c_double, ctypes.c_double, ctypes.c_double, ctypes.c_double, ctypes.c_double]
+def lb_search_start(ls, f, g, stp, stpmin, stpmax, ftol):
+    ls = np.ascontiguousarray(ls, dtype=np.float64)
+    assert ls.size == 16, "ls: expected 16 elements"
+    return _lib.scm2cpp_lb_search_start(ls.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), f, g, stp, stpmin, stpmax, ftol)
+
+_lib.scm2cpp_lb_search_step.restype = ctypes.c_int
+_lib.scm2cpp_lb_search_step.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_double, ctypes.c_double, ctypes.c_double, ctypes.c_double, ctypes.c_double, ctypes.c_double, ctypes.c_double]
+def lb_search_step(ls, cs, f, g, ftol, gtol, xtol, stpmin, stpmax):
+    ls = np.ascontiguousarray(ls, dtype=np.float64)
+    assert ls.size == 16, "ls: expected 16 elements"
+    cs = np.ascontiguousarray(cs, dtype=np.float64)
+    assert cs.size == 8, "cs: expected 8 elements"
+    return _lib.scm2cpp_lb_search_step(ls.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), cs.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), f, g, ftol, gtol, xtol, stpmin, stpmax)
+
+_lib.scm2cpp_lb_dot.restype = ctypes.c_double
+_lib.scm2cpp_lb_dot.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int]
+def lb_dot(a, b, nv):
+    a = np.ascontiguousarray(a, dtype=np.float64)
+    b = np.ascontiguousarray(b, dtype=np.float64)
+    return _lib.scm2cpp_lb_dot(a.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), b.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), nv)
+
+_lib.scm2cpp_lb_dot_row.restype = ctypes.c_double
+_lib.scm2cpp_lb_dot_row.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int]
+def lb_dot_row(mem, slot, v, nv):
+    mem = np.ascontiguousarray(mem, dtype=np.float64)
+    v = np.ascontiguousarray(v, dtype=np.float64)
+    return _lib.scm2cpp_lb_dot_row(mem.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), slot, v.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), nv)
+
+_lib.scm2cpp_lb_dot_rows.restype = ctypes.c_double
+_lib.scm2cpp_lb_dot_rows.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_int]
+def lb_dot_rows(a, ra, b, rb, nv):
+    a = np.ascontiguousarray(a, dtype=np.float64)
+    b = np.ascontiguousarray(b, dtype=np.float64)
+    return _lib.scm2cpp_lb_dot_rows(a.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), ra, b.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), rb, nv)
+
+_lib.scm2cpp_lb_projgr.restype = ctypes.c_double
+_lib.scm2cpp_lb_projgr.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_double, ctypes.c_int]
+def lb_projgr(g, w, ib, lbv, nv):
+    g = np.ascontiguousarray(g, dtype=np.float64)
+    w = np.ascontiguousarray(w, dtype=np.float64)
+    return _lib.scm2cpp_lb_projgr(g.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), w.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), ib, lbv, nv)
+
+_lib.scm2cpp_lb_hv.restype = ctypes.c_int
+_lib.scm2cpp_lb_hv.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_double, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int]
+def lb_hv(q, smem, ymem, rho, al, theta, col, head, m, nv):
+    q = np.ascontiguousarray(q, dtype=np.float64)
+    smem = np.ascontiguousarray(smem, dtype=np.float64)
+    ymem = np.ascontiguousarray(ymem, dtype=np.float64)
+    rho = np.ascontiguousarray(rho, dtype=np.float64)
+    al = np.ascontiguousarray(al, dtype=np.float64)
+    return _lib.scm2cpp_lb_hv(q.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), smem.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), ymem.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), rho.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), al.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), theta, col, head, m, nv)
+
+_lib.scm2cpp_lb_vbv.restype = ctypes.c_double
+_lib.scm2cpp_lb_vbv.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_double, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int]
+def lb_vbv(v, smem, ymem, rho, bm, sb, theta, col, head, m, nv):
+    v = np.ascontiguousarray(v, dtype=np.float64)
+    smem = np.ascontiguousarray(smem, dtype=np.float64)
+    ymem = np.ascontiguousarray(ymem, dtype=np.float64)
+    rho = np.ascontiguousarray(rho, dtype=np.float64)
+    bm = np.ascontiguousarray(bm, dtype=np.float64)
+    sb = np.ascontiguousarray(sb, dtype=np.float64)
+    return _lib.scm2cpp_lb_vbv(v.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), smem.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), ymem.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), rho.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), bm.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), sb.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), theta, col, head, m, nv)
+
+_lib.scm2cpp_lb_direction.restype = ctypes.c_int
+_lib.scm2cpp_lb_direction.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_double, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_double, ctypes.c_int]
+def lb_direction(w, g, d, q, e, smem, ymem, rho, al, bm, sb, theta, col, head, m, ib, lbv, nv):
+    w = np.ascontiguousarray(w, dtype=np.float64)
+    g = np.ascontiguousarray(g, dtype=np.float64)
+    d = np.ascontiguousarray(d, dtype=np.float64)
+    q = np.ascontiguousarray(q, dtype=np.float64)
+    e = np.ascontiguousarray(e, dtype=np.float64)
+    smem = np.ascontiguousarray(smem, dtype=np.float64)
+    ymem = np.ascontiguousarray(ymem, dtype=np.float64)
+    rho = np.ascontiguousarray(rho, dtype=np.float64)
+    al = np.ascontiguousarray(al, dtype=np.float64)
+    bm = np.ascontiguousarray(bm, dtype=np.float64)
+    sb = np.ascontiguousarray(sb, dtype=np.float64)
+    return _lib.scm2cpp_lb_direction(w.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), g.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), d.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), q.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), e.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), smem.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), ymem.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), rho.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), al.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), bm.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), sb.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), theta, col, head, m, ib, lbv, nv)
+
+_lib.scm2cpp_lbfgs.restype = ctypes.c_int
+_lib.scm2cpp_lbfgs.argtypes = [ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_int, ctypes.c_double, ctypes.c_double, ctypes.c_int, ctypes.c_int, ctypes.c_double, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int]
+def lbfgs(kind, w, x, y, aux, work, out, m, maxiter, pgtol, ftol, maxls, ib, lbv, nv, n, p, k):
+    w = np.ascontiguousarray(w, dtype=np.float64)
+    x = np.ascontiguousarray(x, dtype=np.float64)
+    y = np.ascontiguousarray(y, dtype=np.float64)
+    aux = np.ascontiguousarray(aux, dtype=np.float64)
+    assert aux.size == 4, "aux: expected 4 elements"
+    work = np.ascontiguousarray(work, dtype=np.float64)
+    out = np.ascontiguousarray(out, dtype=np.float64)
+    return _lib.scm2cpp_lbfgs(kind, w.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), y.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), aux.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), work.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), out.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), m, maxiter, pgtol, ftol, maxls, ib, lbv, nv, n, p, k)
+
+_lib.scm2cpp_lbfgs_fg.restype = ctypes.c_double
+_lib.scm2cpp_lbfgs_fg.argtypes = [ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_int, ctypes.c_int]
+def lbfgs_fg(kind, w, g, x, y, aux, work, n, p, k):
+    w = np.ascontiguousarray(w, dtype=np.float64)
+    g = np.ascontiguousarray(g, dtype=np.float64)
+    x = np.ascontiguousarray(x, dtype=np.float64)
+    y = np.ascontiguousarray(y, dtype=np.float64)
+    aux = np.ascontiguousarray(aux, dtype=np.float64)
+    assert aux.size == 4, "aux: expected 4 elements"
+    work = np.ascontiguousarray(work, dtype=np.float64)
+    return _lib.scm2cpp_lbfgs_fg(kind, w.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), g.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), y.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), aux.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), work.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), n, p, k)
+
+_lib.scm2cpp_gmm_mstep.restype = ctypes.c_int
+_lib.scm2cpp_gmm_mstep.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_double, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int]
+def gmm_mstep(x, resp, weights, means, prec, dw, cov, l, u, reg, norm, n, p, kc):
+    x = np.ascontiguousarray(x, dtype=np.float64)
+    resp = np.ascontiguousarray(resp, dtype=np.float64)
+    weights = np.ascontiguousarray(weights, dtype=np.float64)
+    means = np.ascontiguousarray(means, dtype=np.float64)
+    prec = np.ascontiguousarray(prec, dtype=np.float64)
+    dw = np.ascontiguousarray(dw, dtype=np.float64)
+    cov = np.ascontiguousarray(cov, dtype=np.float64)
+    l = np.ascontiguousarray(l, dtype=np.float64)
+    u = np.ascontiguousarray(u, dtype=np.float64)
+    return _lib.scm2cpp_gmm_mstep(x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), resp.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), weights.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), means.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), prec.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), dw.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), cov.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), l.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), u.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), reg, norm, n, p, kc)
+
+_lib.scm2cpp_gmm_estep.restype = ctypes.c_double
+_lib.scm2cpp_gmm_estep.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_int, ctypes.c_int]
+def gmm_estep(x, resp, weights, means, prec, wlp, y, u, mu, n, p, kc):
+    x = np.ascontiguousarray(x, dtype=np.float64)
+    resp = np.ascontiguousarray(resp, dtype=np.float64)
+    weights = np.ascontiguousarray(weights, dtype=np.float64)
+    means = np.ascontiguousarray(means, dtype=np.float64)
+    prec = np.ascontiguousarray(prec, dtype=np.float64)
+    wlp = np.ascontiguousarray(wlp, dtype=np.float64)
+    y = np.ascontiguousarray(y, dtype=np.float64)
+    u = np.ascontiguousarray(u, dtype=np.float64)
+    mu = np.ascontiguousarray(mu, dtype=np.float64)
+    return _lib.scm2cpp_gmm_estep(x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), resp.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), weights.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), means.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), prec.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), wlp.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), y.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), u.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), mu.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), n, p, kc)
+
+_lib.scm2cpp_gmm_abs.restype = ctypes.c_double
+_lib.scm2cpp_gmm_abs.argtypes = [ctypes.c_double]
+def gmm_abs(a):
+    return _lib.scm2cpp_gmm_abs(a)
+
+_lib.scm2cpp_gmm.restype = ctypes.c_int
+_lib.scm2cpp_gmm.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_double, ctypes.c_double, ctypes.c_int, ctypes.c_int, ctypes.c_int]
+def gmm(x, resp, weights, means, prec, labels, out, maxiter, tol, reg, n, p, kc):
+    x = np.ascontiguousarray(x, dtype=np.float64)
+    resp = np.ascontiguousarray(resp, dtype=np.float64)
+    weights = np.ascontiguousarray(weights, dtype=np.float64)
+    means = np.ascontiguousarray(means, dtype=np.float64)
+    prec = np.ascontiguousarray(prec, dtype=np.float64)
+    labels = np.ascontiguousarray(labels, dtype=np.float64)
+    out = np.ascontiguousarray(out, dtype=np.float64)
+    return _lib.scm2cpp_gmm(x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), resp.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), weights.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), means.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), prec.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), labels.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), out.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), maxiter, tol, reg, n, p, kc)
+
+_lib.scm2cpp_eig_hypot.restype = ctypes.c_double
+_lib.scm2cpp_eig_hypot.argtypes = [ctypes.c_double, ctypes.c_double]
+def eig_hypot(a, b):
+    return _lib.scm2cpp_eig_hypot(a, b)
+
+_lib.scm2cpp_sym_eigen.restype = ctypes.c_int
+_lib.scm2cpp_sym_eigen.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int]
+def sym_eigen(a, v, ev, e, m):
+    a = np.ascontiguousarray(a, dtype=np.float64)
+    v = np.ascontiguousarray(v, dtype=np.float64)
+    ev = np.ascontiguousarray(ev, dtype=np.float64)
+    e = np.ascontiguousarray(e, dtype=np.float64)
+    return _lib.scm2cpp_sym_eigen(a.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), v.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), ev.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), e.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), m)
+
+_lib.scm2cpp_eig_abs.restype = ctypes.c_double
+_lib.scm2cpp_eig_abs.argtypes = [ctypes.c_double]
+def eig_abs(a):
+    return _lib.scm2cpp_eig_abs(a)
+
+_lib.scm2cpp_eig_order.restype = ctypes.c_int
+_lib.scm2cpp_eig_order.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_int), ctypes.c_int]
+def eig_order(ev, ord, m):
+    ev = np.ascontiguousarray(ev, dtype=np.float64)
+    ord = np.ascontiguousarray(ord, dtype=np.int32)
+    return _lib.scm2cpp_eig_order(ev.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), ord.ctypes.data_as(ctypes.POINTER(ctypes.c_int)), m)
+
+_lib.scm2cpp_sym_eigen_top.restype = ctypes.c_int
+_lib.scm2cpp_sym_eigen_top.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_int]
+def sym_eigen_top(a, v, ev, e, m, k):
+    a = np.ascontiguousarray(a, dtype=np.float64)
+    v = np.ascontiguousarray(v, dtype=np.float64)
+    ev = np.ascontiguousarray(ev, dtype=np.float64)
+    e = np.ascontiguousarray(e, dtype=np.float64)
+    return _lib.scm2cpp_sym_eigen_top(a.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), v.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), ev.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), e.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), m, k)
+
+_lib.scm2cpp_sym_eigen_gen.restype = ctypes.c_int
+_lib.scm2cpp_sym_eigen_gen.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int]
+def sym_eigen_gen(a, b, v, ev, e, m):
+    a = np.ascontiguousarray(a, dtype=np.float64)
+    b = np.ascontiguousarray(b, dtype=np.float64)
+    v = np.ascontiguousarray(v, dtype=np.float64)
+    ev = np.ascontiguousarray(ev, dtype=np.float64)
+    e = np.ascontiguousarray(e, dtype=np.float64)
+    return _lib.scm2cpp_sym_eigen_gen(a.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), b.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), v.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), ev.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), e.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), m)
+
+_lib.scm2cpp_ica_tanh.restype = ctypes.c_double
+_lib.scm2cpp_ica_tanh.argtypes = [ctypes.c_double]
+def ica_tanh(x):
+    return _lib.scm2cpp_ica_tanh(x)
+
+_lib.scm2cpp_ica_sym.restype = ctypes.c_int
+_lib.scm2cpp_ica_sym.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int]
+def ica_sym(w, a, v, ev, e, t, m):
+    w = np.ascontiguousarray(w, dtype=np.float64)
+    a = np.ascontiguousarray(a, dtype=np.float64)
+    v = np.ascontiguousarray(v, dtype=np.float64)
+    ev = np.ascontiguousarray(ev, dtype=np.float64)
+    e = np.ascontiguousarray(e, dtype=np.float64)
+    t = np.ascontiguousarray(t, dtype=np.float64)
+    return _lib.scm2cpp_ica_sym(w.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), a.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), v.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), ev.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), e.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), t.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), m)
+
+_lib.scm2cpp_fastica.restype = ctypes.c_int
+_lib.scm2cpp_fastica.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_double, ctypes.c_int, ctypes.c_int, ctypes.c_int]
+def fastica(x, winit, comps, white, unmix, mean, maxiter, tol, n, p, nc):
+    x = np.ascontiguousarray(x, dtype=np.float64)
+    winit = np.ascontiguousarray(winit, dtype=np.float64)
+    comps = np.ascontiguousarray(comps, dtype=np.float64)
+    white = np.ascontiguousarray(white, dtype=np.float64)
+    unmix = np.ascontiguousarray(unmix, dtype=np.float64)
+    mean = np.ascontiguousarray(mean, dtype=np.float64)
+    return _lib.scm2cpp_fastica(x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), winit.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), comps.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), white.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), unmix.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), mean.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), maxiter, tol, n, p, nc)
+
+_lib.scm2cpp_pca.restype = ctypes.c_int
+_lib.scm2cpp_pca.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_int]
+def pca(x, comps, ev, sv, mean, n, p):
+    x = np.ascontiguousarray(x, dtype=np.float64)
+    comps = np.ascontiguousarray(comps, dtype=np.float64)
+    ev = np.ascontiguousarray(ev, dtype=np.float64)
+    sv = np.ascontiguousarray(sv, dtype=np.float64)
+    mean = np.ascontiguousarray(mean, dtype=np.float64)
+    return _lib.scm2cpp_pca(x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), comps.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), ev.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), sv.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), mean.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), n, p)
+
+_lib.scm2cpp_ard_pinvh.restype = ctypes.c_int
+_lib.scm2cpp_ard_pinvh.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int]
+def ard_pinvh(a, s, v, ev, e, k):
+    a = np.ascontiguousarray(a, dtype=np.float64)
+    s = np.ascontiguousarray(s, dtype=np.float64)
+    v = np.ascontiguousarray(v, dtype=np.float64)
+    ev = np.ascontiguousarray(ev, dtype=np.float64)
+    e = np.ascontiguousarray(e, dtype=np.float64)
+    return _lib.scm2cpp_ard_pinvh(a.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), s.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), v.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), ev.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), e.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), k)
+
+_lib.scm2cpp_ard_sigma_coef.restype = ctypes.c_int
+_lib.scm2cpp_ard_sigma_coef.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_double, ctypes.c_int]
+def ard_sigma_coef(xy, idx, lam, coef, sigma, a, v, ev, e, gk, alpha, k):
+    xy = np.ascontiguousarray(xy, dtype=np.float64)
+    idx = np.ascontiguousarray(idx, dtype=np.int32)
+    lam = np.ascontiguousarray(lam, dtype=np.float64)
+    coef = np.ascontiguousarray(coef, dtype=np.float64)
+    sigma = np.ascontiguousarray(sigma, dtype=np.float64)
+    a = np.ascontiguousarray(a, dtype=np.float64)
+    v = np.ascontiguousarray(v, dtype=np.float64)
+    ev = np.ascontiguousarray(ev, dtype=np.float64)
+    e = np.ascontiguousarray(e, dtype=np.float64)
+    gk = np.ascontiguousarray(gk, dtype=np.float64)
+    return _lib.scm2cpp_ard_sigma_coef(xy.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), idx.ctypes.data_as(ctypes.POINTER(ctypes.c_int)), lam.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), coef.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), sigma.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), a.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), v.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), ev.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), e.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), gk.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), alpha, k)
+
+_lib.scm2cpp_ard.restype = ctypes.c_int
+_lib.scm2cpp_ard.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_double, ctypes.c_double, ctypes.c_double, ctypes.c_double, ctypes.c_double, ctypes.c_double, ctypes.c_int, ctypes.c_int, ctypes.c_int]
+def ard(x, y, coef, sigma, lam, out, maxiter, tol, alpha1, alpha2, lambda1, lambda2, thresh, hoist, n, p):
+    x = np.ascontiguousarray(x, dtype=np.float64)
+    y = np.ascontiguousarray(y, dtype=np.float64)
+    coef = np.ascontiguousarray(coef, dtype=np.float64)
+    sigma = np.ascontiguousarray(sigma, dtype=np.float64)
+    lam = np.ascontiguousarray(lam, dtype=np.float64)
+    out = np.ascontiguousarray(out, dtype=np.float64)
+    return _lib.scm2cpp_ard(x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), y.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), coef.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), sigma.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), lam.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), out.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), maxiter, tol, alpha1, alpha2, lambda1, lambda2, thresh, hoist, n, p)
+
+_lib.scm2cpp_f_regression.restype = ctypes.c_int
+_lib.scm2cpp_f_regression.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int]
+def f_regression(x, y, r, f, center, n, p, q):
+    x = np.ascontiguousarray(x, dtype=np.float64)
+    y = np.ascontiguousarray(y, dtype=np.float64)
+    r = np.ascontiguousarray(r, dtype=np.float64)
+    f = np.ascontiguousarray(f, dtype=np.float64)
+    return _lib.scm2cpp_f_regression(x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), y.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), r.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), f.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), center, n, p, q)
+
+_lib.scm2cpp_f_classif.restype = ctypes.c_int
+_lib.scm2cpp_f_classif.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_int, ctypes.c_int]
+def f_classif(x, lab, f, n, p, k):
+    x = np.ascontiguousarray(x, dtype=np.float64)
+    lab = np.ascontiguousarray(lab, dtype=np.int32)
+    f = np.ascontiguousarray(f, dtype=np.float64)
+    return _lib.scm2cpp_f_classif(x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), lab.ctypes.data_as(ctypes.POINTER(ctypes.c_int)), f.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), n, p, k)
+
+_lib.scm2cpp_min_pos.restype = ctypes.c_double
+_lib.scm2cpp_min_pos.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.c_int]
+def min_pos(v, m):
+    v = np.ascontiguousarray(v, dtype=np.float64)
+    return _lib.scm2cpp_min_pos(v.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), m)
+
+_lib.scm2cpp_round_even.restype = ctypes.c_double
+_lib.scm2cpp_round_even.argtypes = [ctypes.c_double]
+def round_even(y):
+    return _lib.scm2cpp_round_even(y)
+
+_lib.scm2cpp_cholesky_delete.restype = ctypes.c_int
+_lib.scm2cpp_cholesky_delete.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_int, ctypes.c_int]
+def cholesky_delete(l, go, n, k):
+    l = np.ascontiguousarray(l, dtype=np.float64)
+    return _lib.scm2cpp_cholesky_delete(l.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), go, n, k)
+
+_lib.scm2cpp_swap_rc.restype = ctypes.c_int
+_lib.scm2cpp_swap_rc.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_int, ctypes.c_int]
+def swap_rc(g, a, b, p):
+    g = np.ascontiguousarray(g, dtype=np.float64)
+    return _lib.scm2cpp_swap_rc(g.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), a, b, p)
+
+_lib.scm2cpp_lars.restype = ctypes.c_int
+_lib.scm2cpp_lars.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_double, ctypes.c_double, ctypes.c_int, ctypes.c_int, ctypes.c_double, ctypes.c_int]
+def lars(g, cov, coef, path, alphas, rec, nsamples, alphamin, method, maxiter, eps, p):
+    g = np.ascontiguousarray(g, dtype=np.float64)
+    cov = np.ascontiguousarray(cov, dtype=np.float64)
+    coef = np.ascontiguousarray(coef, dtype=np.float64)
+    path = np.ascontiguousarray(path, dtype=np.float64)
+    alphas = np.ascontiguousarray(alphas, dtype=np.float64)
+    return _lib.scm2cpp_lars(g.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), cov.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), coef.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), path.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), alphas.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), rec, nsamples, alphamin, method, maxiter, eps, p)
+
+_lib.scm2cpp_rfe_chol.restype = ctypes.c_int
+_lib.scm2cpp_rfe_chol.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_double), ctypes.c_double, ctypes.c_int, ctypes.c_int]
+def rfe_chol(g, idx, l, alpha, k, p):
+    g = np.ascontiguousarray(g, dtype=np.float64)
+    idx = np.ascontiguousarray(idx, dtype=np.int32)
+    l = np.ascontiguousarray(l, dtype=np.float64)
+    return _lib.scm2cpp_rfe_chol(g.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), idx.ctypes.data_as(ctypes.POINTER(ctypes.c_int)), l.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), alpha, k, p)
+
+_lib.scm2cpp_rfe_solve.restype = ctypes.c_int
+_lib.scm2cpp_rfe_solve.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_int]
+def rfe_solve(c, idx, w, l, k, p):
+    c = np.ascontiguousarray(c, dtype=np.float64)
+    idx = np.ascontiguousarray(idx, dtype=np.int32)
+    w = np.ascontiguousarray(w, dtype=np.float64)
+    l = np.ascontiguousarray(l, dtype=np.float64)
+    return _lib.scm2cpp_rfe_solve(c.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), idx.ctypes.data_as(ctypes.POINTER(ctypes.c_int)), w.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), l.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), k, p)
+
+_lib.scm2cpp_rfe.restype = ctypes.c_int
+_lib.scm2cpp_rfe.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_int), ctypes.c_double, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int]
+def rfe(x, y, coef, support, ranking, alpha, nsel, step, n, p):
+    x = np.ascontiguousarray(x, dtype=np.float64)
+    y = np.ascontiguousarray(y, dtype=np.float64)
+    coef = np.ascontiguousarray(coef, dtype=np.float64)
+    support = np.ascontiguousarray(support, dtype=np.int32)
+    ranking = np.ascontiguousarray(ranking, dtype=np.int32)
+    return _lib.scm2cpp_rfe(x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), y.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), coef.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), support.ctypes.data_as(ctypes.POINTER(ctypes.c_int)), ranking.ctypes.data_as(ctypes.POINTER(ctypes.c_int)), alpha, nsel, step, n, p)
+
+_lib.scm2cpp_gram_xx.restype = ctypes.c_int
+_lib.scm2cpp_gram_xx.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_int]
+def gram_xx(x, g, n, p):
+    x = np.ascontiguousarray(x, dtype=np.float64)
+    g = np.ascontiguousarray(g, dtype=np.float64)
+    return _lib.scm2cpp_gram_xx(x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), g.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), n, p)
+
+_lib.scm2cpp_gram_xy.restype = ctypes.c_int
+_lib.scm2cpp_gram_xy.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_int, ctypes.c_int]
+def gram_xy(x, y, c, n, p, q):
+    x = np.ascontiguousarray(x, dtype=np.float64)
+    y = np.ascontiguousarray(y, dtype=np.float64)
+    c = np.ascontiguousarray(c, dtype=np.float64)
+    return _lib.scm2cpp_gram_xy(x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), y.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), c.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), n, p, q)
+
+_lib.scm2cpp_spd_solve.restype = ctypes.c_int
+_lib.scm2cpp_spd_solve.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_int]
+def spd_solve(a, b, m, q):
+    a = np.ascontiguousarray(a, dtype=np.float64)
+    b = np.ascontiguousarray(b, dtype=np.float64)
+    return _lib.scm2cpp_spd_solve(a.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), b.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), m, q)
+
+_lib.scm2cpp_gram_ridge_solve.restype = ctypes.c_int
+_lib.scm2cpp_gram_ridge_solve.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_double, ctypes.c_int, ctypes.c_int]
+def gram_ridge_solve(g, c, alpha, m, q):
+    g = np.ascontiguousarray(g, dtype=np.float64)
+    c = np.ascontiguousarray(c, dtype=np.float64)
+    return _lib.scm2cpp_gram_ridge_solve(g.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), c.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), alpha, m, q)
+
+_lib.scm2cpp_ridge_gcv_primal.restype = ctypes.c_int
+_lib.scm2cpp_ridge_gcv_primal.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_int, ctypes.c_int]
+def ridge_gcv_primal(x, xm, yc, g, v, lam, z, r, n, p, t):
+    x = np.ascontiguousarray(x, dtype=np.float64)
+    xm = np.ascontiguousarray(xm, dtype=np.float64)
+    yc = np.ascontiguousarray(yc, dtype=np.float64)
+    g = np.ascontiguousarray(g, dtype=np.float64)
+    v = np.ascontiguousarray(v, dtype=np.float64)
+    lam = np.ascontiguousarray(lam, dtype=np.float64)
+    z = np.ascontiguousarray(z, dtype=np.float64)
+    r = np.ascontiguousarray(r, dtype=np.float64)
+    return _lib.scm2cpp_ridge_gcv_primal(x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), xm.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), yc.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), g.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), v.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), lam.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), z.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), r.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), n, p, t)
+
+_lib.scm2cpp_ridge_gcv_dual.restype = ctypes.c_int
+_lib.scm2cpp_ridge_gcv_dual.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_int]
+def ridge_gcv_dual(k, q, mu, yc, z, r, n, t):
+    k = np.ascontiguousarray(k, dtype=np.float64)
+    q = np.ascontiguousarray(q, dtype=np.float64)
+    mu = np.ascontiguousarray(mu, dtype=np.float64)
+    yc = np.ascontiguousarray(yc, dtype=np.float64)
+    z = np.ascontiguousarray(z, dtype=np.float64)
+    r = np.ascontiguousarray(r, dtype=np.float64)
+    return _lib.scm2cpp_ridge_gcv_dual(k.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), q.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), mu.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), yc.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), z.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), r.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), n, t)
+
+_lib.scm2cpp_ridge_gcv_scan.restype = ctypes.c_int
+_lib.scm2cpp_ridge_gcv_scan.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_double, ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int]
+def ridge_gcv_scan(z, lam, r, yc, alphas, h0, mse, loo, store, n, m, t, na):
+    z = np.ascontiguousarray(z, dtype=np.float64)
+    lam = np.ascontiguousarray(lam, dtype=np.float64)
+    r = np.ascontiguousarray(r, dtype=np.float64)
+    yc = np.ascontiguousarray(yc, dtype=np.float64)
+    alphas = np.ascontiguousarray(alphas, dtype=np.float64)
+    mse = np.ascontiguousarray(mse, dtype=np.float64)
+    loo = np.ascontiguousarray(loo, dtype=np.float64)
+    return _lib.scm2cpp_ridge_gcv_scan(z.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), lam.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), r.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), yc.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), alphas.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), h0, mse.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), loo.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), store, n, m, t, na)
+
+_lib.scm2cpp_kpca_row_norms.restype = ctypes.c_int
+_lib.scm2cpp_kpca_row_norms.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_int]
+def kpca_row_norms(x, s, n, p):
+    x = np.ascontiguousarray(x, dtype=np.float64)
+    s = np.ascontiguousarray(s, dtype=np.float64)
+    return _lib.scm2cpp_kpca_row_norms(x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), s.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), n, p)
+
+_lib.scm2cpp_kpca_apply.restype = ctypes.c_int
+_lib.scm2cpp_kpca_apply.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_double, ctypes.c_double, ctypes.c_double, ctypes.c_int, ctypes.c_int]
+def kpca_apply(g, sa, sb, kind, gamma, degree, coef0, na, nb):
+    g = np.ascontiguousarray(g, dtype=np.float64)
+    sa = np.ascontiguousarray(sa, dtype=np.float64)
+    sb = np.ascontiguousarray(sb, dtype=np.float64)
+    return _lib.scm2cpp_kpca_apply(g.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), sa.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), sb.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), kind, gamma, degree, coef0, na, nb)
+
+_lib.scm2cpp_kpca_kernel.restype = ctypes.c_int
+_lib.scm2cpp_kpca_kernel.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_double, ctypes.c_double, ctypes.c_double, ctypes.c_int, ctypes.c_int, ctypes.c_int]
+def kpca_kernel(x, y, k, kind, gamma, degree, coef0, na, nb, p):
+    x = np.ascontiguousarray(x, dtype=np.float64)
+    y = np.ascontiguousarray(y, dtype=np.float64)
+    k = np.ascontiguousarray(k, dtype=np.float64)
+    return _lib.scm2cpp_kpca_kernel(x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), y.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), k.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), kind, gamma, degree, coef0, na, nb, p)
+
+_lib.scm2cpp_kpca_kernel_self.restype = ctypes.c_int
+_lib.scm2cpp_kpca_kernel_self.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_double, ctypes.c_double, ctypes.c_double, ctypes.c_int, ctypes.c_int]
+def kpca_kernel_self(x, k, kind, gamma, degree, coef0, n, p):
+    x = np.ascontiguousarray(x, dtype=np.float64)
+    k = np.ascontiguousarray(k, dtype=np.float64)
+    return _lib.scm2cpp_kpca_kernel_self(x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), k.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), kind, gamma, degree, coef0, n, p)
+
+_lib.scm2cpp_kpca_centre.restype = ctypes.c_int
+_lib.scm2cpp_kpca_centre.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int]
+def kpca_centre(k, m, n):
+    k = np.ascontiguousarray(k, dtype=np.float64)
+    m = np.ascontiguousarray(m, dtype=np.float64)
+    return _lib.scm2cpp_kpca_centre(k.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), m.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), n)
+
+_lib.scm2cpp_kpca_centre_new.restype = ctypes.c_int
+_lib.scm2cpp_kpca_centre_new.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_int]
+def kpca_centre_new(k, m, nb, n):
+    k = np.ascontiguousarray(k, dtype=np.float64)
+    m = np.ascontiguousarray(m, dtype=np.float64)
+    return _lib.scm2cpp_kpca_centre_new(k.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), m.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), nb, n)
+
+_lib.scm2cpp_kpca_flip.restype = ctypes.c_int
+_lib.scm2cpp_kpca_flip.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_int]
+def kpca_flip(vecs, vals, n, c):
+    vecs = np.ascontiguousarray(vecs, dtype=np.float64)
+    vals = np.ascontiguousarray(vals, dtype=np.float64)
+    return _lib.scm2cpp_kpca_flip(vecs.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), vals.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), n, c)
+
+_lib.scm2cpp_kpca_top_dense.restype = ctypes.c_int
+_lib.scm2cpp_kpca_top_dense.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_int]
+def kpca_top_dense(k, vecs, vals, n, c):
+    k = np.ascontiguousarray(k, dtype=np.float64)
+    vecs = np.ascontiguousarray(vecs, dtype=np.float64)
+    vals = np.ascontiguousarray(vals, dtype=np.float64)
+    return _lib.scm2cpp_kpca_top_dense(k.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), vecs.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), vals.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), n, c)
+
+_lib.scm2cpp_kpca_orth.restype = ctypes.c_int
+_lib.scm2cpp_kpca_orth.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_int]
+def kpca_orth(y, g, n, b):
+    y = np.ascontiguousarray(y, dtype=np.float64)
+    g = np.ascontiguousarray(g, dtype=np.float64)
+    return _lib.scm2cpp_kpca_orth(y.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), g.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), n, b)
+
+_lib.scm2cpp_kpca_top_subspace.restype = ctypes.c_int
+_lib.scm2cpp_kpca_top_subspace.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_double, ctypes.c_int]
+def kpca_top_subspace(k, q, vecs, vals, n, b, c, tol, maxit):
+    k = np.ascontiguousarray(k, dtype=np.float64)
+    q = np.ascontiguousarray(q, dtype=np.float64)
+    vecs = np.ascontiguousarray(vecs, dtype=np.float64)
+    vals = np.ascontiguousarray(vals, dtype=np.float64)
+    return _lib.scm2cpp_kpca_top_subspace(k.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), q.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), vecs.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), vals.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), n, b, c, tol, maxit)
+
+_lib.scm2cpp_kpca_linear.restype = ctypes.c_int
+_lib.scm2cpp_kpca_linear.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_int, ctypes.c_int]
+def kpca_linear(x, xm, g, vecs, vals, n, p, c):
+    x = np.ascontiguousarray(x, dtype=np.float64)
+    xm = np.ascontiguousarray(xm, dtype=np.float64)
+    g = np.ascontiguousarray(g, dtype=np.float64)
+    vecs = np.ascontiguousarray(vecs, dtype=np.float64)
+    vals = np.ascontiguousarray(vals, dtype=np.float64)
+    return _lib.scm2cpp_kpca_linear(x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), xm.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), g.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), vecs.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), vals.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), n, p, c)
+
+_lib.scm2cpp_lda_moments.restype = ctypes.c_int
+_lib.scm2cpp_lda_moments.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_int, ctypes.c_int]
+def lda_moments(x, lab, g, means, counts, n, p, k):
+    x = np.ascontiguousarray(x, dtype=np.float64)
+    lab = np.ascontiguousarray(lab, dtype=np.int32)
+    g = np.ascontiguousarray(g, dtype=np.float64)
+    means = np.ascontiguousarray(means, dtype=np.float64)
+    counts = np.ascontiguousarray(counts, dtype=np.float64)
+    return _lib.scm2cpp_lda_moments(x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), lab.ctypes.data_as(ctypes.POINTER(ctypes.c_int)), g.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), means.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), counts.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), n, p, k)
+
+_lib.scm2cpp_lda_within.restype = ctypes.c_int
+_lib.scm2cpp_lda_within.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_double, ctypes.c_int, ctypes.c_int]
+def lda_within(g, means, counts, n, p, k):
+    g = np.ascontiguousarray(g, dtype=np.float64)
+    means = np.ascontiguousarray(means, dtype=np.float64)
+    counts = np.ascontiguousarray(counts, dtype=np.float64)
+    return _lib.scm2cpp_lda_within(g.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), means.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), counts.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), n, p, k)
+
+_lib.scm2cpp_lda_svd_first.restype = ctypes.c_int
+_lib.scm2cpp_lda_svd_first.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int]
+def lda_svd_first(sw, std, v, s, p):
+    sw = np.ascontiguousarray(sw, dtype=np.float64)
+    std = np.ascontiguousarray(std, dtype=np.float64)
+    v = np.ascontiguousarray(v, dtype=np.float64)
+    s = np.ascontiguousarray(s, dtype=np.float64)
+    return _lib.scm2cpp_lda_svd_first(sw.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), std.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), v.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), s.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), p)
+
+_lib.scm2cpp_lda_eigen.restype = ctypes.c_int
+_lib.scm2cpp_lda_eigen.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int]
+def lda_eigen(sb, sw, v, ev, p):
+    sb = np.ascontiguousarray(sb, dtype=np.float64)
+    sw = np.ascontiguousarray(sw, dtype=np.float64)
+    v = np.ascontiguousarray(v, dtype=np.float64)
+    ev = np.ascontiguousarray(ev, dtype=np.float64)
+    return _lib.scm2cpp_lda_eigen(sb.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), sw.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), v.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), ev.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), p)
+
+_lib.scm2cpp_tsvd_flip.restype = ctypes.c_int
+_lib.scm2cpp_tsvd_flip.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_int, ctypes.c_int]
+def tsvd_flip(v, z, n, p, k):
+    v = np.ascontiguousarray(v, dtype=np.float64)
+    z = np.ascontiguousarray(z, dtype=np.float64)
+    return _lib.scm2cpp_tsvd_flip(v.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), z.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), n, p, k)
+
+_lib.scm2cpp_tsvd_tall.restype = ctypes.c_int
+_lib.scm2cpp_tsvd_tall.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_int, ctypes.c_int]
+def tsvd_tall(x, v, s, z, n, p, k):
+    x = np.ascontiguousarray(x, dtype=np.float64)
+    v = np.ascontiguousarray(v, dtype=np.float64)
+    s = np.ascontiguousarray(s, dtype=np.float64)
+    z = np.ascontiguousarray(z, dtype=np.float64)
+    return _lib.scm2cpp_tsvd_tall(x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), v.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), s.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), z.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), n, p, k)
+
+_lib.scm2cpp_tsvd_wide.restype = ctypes.c_int
+_lib.scm2cpp_tsvd_wide.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.c_int, ctypes.c_int]
+def tsvd_wide(x, v, s, z, n, p, k):
+    x = np.ascontiguousarray(x, dtype=np.float64)
+    v = np.ascontiguousarray(v, dtype=np.float64)
+    s = np.ascontiguousarray(s, dtype=np.float64)
+    z = np.ascontiguousarray(z, dtype=np.float64)
+    return _lib.scm2cpp_tsvd_wide(x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), v.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), s.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), z.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), n, p, k)
+