scm2cpp-lasso 0.12.0__tar.gz → 0.13.0__tar.gz

{scm2cpp_lasso-0.12.0 → scm2cpp_lasso-0.13.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: scm2cpp-lasso
-Version: 0.12.0
-Summary: scikit-learn estimators (lasso, elastic net, ridge, ARD, SVM, SVR, logistic regression, GLMs, Huber, Theil-Sen, F-score selection, RFE, NMF, Gaussian mixture, FastICA, PCA, graphical lasso, RANSAC, SGD, OMP, LARS) translated from Scheme to C++ by scm2cpp; GPU batch solver included
+Version: 0.13.0
+Summary: scikit-learn estimators (lasso, elastic net, ridge, ARD, SVM, SVR, logistic regression, GLMs, Huber, Theil-Sen, F-score selection, RFE, NMF, Gaussian mixture, FastICA, PCA, graphical lasso, RANSAC, SGD, OMP, LARS) translated from Scheme to C++ by scm2cpp; GPU batch solver and CUDA kernels included
 Author: Hirotaka Niitsuma
 License: MIT
 Project-URL: Homepage, https://github.com/niitsuma/scm2cpp
@@ -733,6 +733,20 @@ estimators (`GramLassoLarsIC`, `GramLarsCV`, `GramLassoLarsCV`,
 `GramLars`, `GramLassoLars`, `CovPCA`) form a large X'X on the device
 when one answers. `SCM2CPP_NO_DEVICE=1` keeps everything on the CPU.
 
+## The GPU build
+
+Where the CUDA toolkit is at install time, `ParallelFastICA`,
+`EMGaussianMixture`, `LBFGSLogisticRegression`,
+`LBFGSLogisticRegressionCV`, `LBFGSHuberRegressor` and the `LBFGS*`
+GLMs also get the same Scheme translated with `--cuda`
+(`libscm2cpp_gpu.so`). Its loops are CUDA kernels and its products
+cuBLAS, on arrays that stay on the device. The classes take it when a
+device answers and the data has a million entries or more, and give
+the CPU build's iterations and results to the last digits. Measured
+against scikit-learn: 10-22x for the L-BFGS fits, 6.7x FastICA, 3x the
+mixture and LogisticRegressionCV (the repository README's table).
+`SCM2CPP_NO_DEVICE=1` keeps everything on the CPU.
+
 ## Logistic regression with L1
 
 `CovLogistic` solves L1-penalized logistic regression by

{scm2cpp_lasso-0.12.0 → scm2cpp_lasso-0.13.0}/README.md

@@ -715,6 +715,20 @@ estimators (`GramLassoLarsIC`, `GramLarsCV`, `GramLassoLarsCV`,
 `GramLars`, `GramLassoLars`, `CovPCA`) form a large X'X on the device
 when one answers. `SCM2CPP_NO_DEVICE=1` keeps everything on the CPU.
 
+## The GPU build
+
+Where the CUDA toolkit is at install time, `ParallelFastICA`,
+`EMGaussianMixture`, `LBFGSLogisticRegression`,
+`LBFGSLogisticRegressionCV`, `LBFGSHuberRegressor` and the `LBFGS*`
+GLMs also get the same Scheme translated with `--cuda`
+(`libscm2cpp_gpu.so`). Its loops are CUDA kernels and its products
+cuBLAS, on arrays that stay on the device. The classes take it when a
+device answers and the data has a million entries or more, and give
+the CPU build's iterations and results to the last digits. Measured
+against scikit-learn: 10-22x for the L-BFGS fits, 6.7x FastICA, 3x the
+mixture and LogisticRegressionCV (the repository README's table).
+`SCM2CPP_NO_DEVICE=1` keeps everything on the CPU.
+
 ## Logistic regression with L1
 
 `CovLogistic` solves L1-penalized logistic regression by

{scm2cpp_lasso-0.12.0 → scm2cpp_lasso-0.13.0}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "scm2cpp-lasso"
-version = "0.12.0"
-description = "scikit-learn estimators (lasso, elastic net, ridge, ARD, SVM, SVR, logistic regression, GLMs, Huber, Theil-Sen, F-score selection, RFE, NMF, Gaussian mixture, FastICA, PCA, graphical lasso, RANSAC, SGD, OMP, LARS) translated from Scheme to C++ by scm2cpp; GPU batch solver included"
+version = "0.13.0"
+description = "scikit-learn estimators (lasso, elastic net, ridge, ARD, SVM, SVR, logistic regression, GLMs, Huber, Theil-Sen, F-score selection, RFE, NMF, Gaussian mixture, FastICA, PCA, graphical lasso, RANSAC, SGD, OMP, LARS) translated from Scheme to C++ by scm2cpp; GPU batch solver and CUDA kernels included"
 readme = "README.md"
 requires-python = ">=3.8"
 license = {text = "MIT"}
@@ -31,4 +31,4 @@ package-dir = {"" = "src"}
 where = ["src"]
 
 [tool.setuptools.package-data]
-scm2cpp_lasso = ["_generated/*.hpp", "_generated/*.cpp", "_generated/derived_*/*.hpp", "_generated/derived_*/*.cpp", "_generated/nmf_*/*.hpp", "_generated/nmf_*/*.cpp", "_generated/gramops_*/*.hpp", "_generated/gramops_*/*.cpp", "_generated/accel_*/*.hpp", "_generated/accel_*/*.cpp", "*.cu"]
+scm2cpp_lasso = ["_generated/*.hpp", "_generated/*.cpp", "_generated/derived_*/*.hpp", "_generated/derived_*/*.cpp", "_generated/nmf_*/*.hpp", "_generated/nmf_*/*.cpp", "_generated/gramops_*/*.hpp", "_generated/gramops_*/*.cpp", "_generated/accel_*/*.hpp", "_generated/accel_*/*.cpp", "_generated/gpu_*/*.hpp", "_generated/gpu_*/*.cpp", "*.cu"]

{scm2cpp_lasso-0.12.0 → scm2cpp_lasso-0.13.0}/setup.py

@@ -120,6 +120,28 @@ class BuildWithCuda(build_ext):
         except (subprocess.CalledProcessError, OSError) as exc:
             print(f"scm2cpp_lasso: no CUDA batch path ({exc}); "
                   "the CPU solver is unaffected", file=sys.stderr)
+        # the --cuda translation (kernels + device-resident cuBLAS):
+        # FastICA, the mixture, the L-BFGS fits
+        gpu = GEN / "gpu_cuda" / "gpu_capi.cpp"
+        if gpu.exists():
+            out2 = Path(self.build_lib) / "scm2cpp_lasso" / "libscm2cpp_gpu.so"
+            # the installed device's architecture when one answers
+            arch = []
+            try:
+                if subprocess.run(["nvidia-smi"], capture_output=True).returncode == 0:
+                    arch = ["-arch=native"]
+            except OSError:
+                pass
+            cmd2 = [nvcc, "-O3", "-std=c++17", "-shared", "-x", "cu", *arch,
+                    "-Xcompiler", "-fPIC", "-I", str(GEN / "gpu_cuda"), "-I", str(GEN),
+                    str(gpu), "-o", str(out2), "-lcublas",
+                    "-Wno-deprecated-gpu-targets", "-diag-suppress", "174,177,550"]
+            try:
+                subprocess.run(cmd2, check=True)
+                print("scm2cpp_lasso: built the --cuda estimators")
+            except (subprocess.CalledProcessError, OSError) as exc:
+                print(f"scm2cpp_lasso: no --cuda estimators ({exc}); "
+                      "the CPU paths are unaffected", file=sys.stderr)
 
 
 # The cuBLAS variant of the derived kernel: host C++ against the CUDA

{scm2cpp_lasso-0.12.0 → scm2cpp_lasso-0.13.0}/src/scm2cpp_lasso/__init__.py

@@ -51,7 +51,7 @@ __all__ = ["CovLasso", "CovRidge", "CovBayesianRidge", "CovLogistic", "CovGroupL
            "SelectPercentile", "GramRFE",
            "CovMultiTaskLasso", "CovMultiTaskLassoCV", "DerivedLasso",
            "cuda_available", "derived_backend", "kernel"]
-__version__ = "0.12.0"
+__version__ = "0.13.0"
 
 _BATCH = load_batch_lib()
 _DP = ctypes.POINTER(ctypes.c_double)
@@ -1350,7 +1350,7 @@ class LBFGSLogisticRegression:
         k = nc if multi else 1
         coef = np.zeros(k * (p + 1))
         out = np.zeros(2)
-        it = _gramops_kernels().logistic_lbfgs(
+        it = _gpu_or_cpu(n * p, getattr(self, "backend", None)).logistic_lbfgs(
             X, yi.astype(np.float64), coef, out, float(self.C), int(self.max_iter),
             float(self.tol), multi, 1 if self.fit_intercept else 0, n, p, k)
         self.coef_ = coef[:k * p].reshape(k, p).copy()
@@ -1418,7 +1418,7 @@ class _LBFGSGLM:
         coef = np.zeros(p + 1)
         out = np.zeros(2)
         fam, power = self._family_power()
-        it = _gramops_kernels().glm(X, y, coef, out, fam, float(power), float(self.alpha),
+        it = _gpu_or_cpu(n * p, getattr(self, "backend", None)).glm(X, y, coef, out, fam, float(power), float(self.alpha),
                                     int(self.max_iter), float(self.tol),
                                     1 if self.fit_intercept else 0, n, p)
         self.coef_, self.intercept_ = coef[:p].copy(), float(coef[p])
@@ -1499,7 +1499,7 @@ class LBFGSLogisticRegressionCV:
 
     def _path(self, X, yi, Cs, coef, multi, k):
         n, p = X.shape
-        lib = _gramops_kernels()
+        lib = _gpu_or_cpu(n * p, getattr(self, "backend", None))
         coefs, iters = [], []
         out = np.zeros(2)
         for C in Cs:
@@ -1582,7 +1582,7 @@ class LBFGSHuberRegressor:
         coef = np.zeros(p + 2)
         coef[-1] = 1.0
         out = np.zeros(2)
-        it = _gramops_kernels().huber(
+        it = _gpu_or_cpu(n * p, getattr(self, "backend", None)).huber(
             X, y, coef, out, float(self.epsilon), float(self.alpha), int(self.max_iter),
             float(self.tol), 1 if self.fit_intercept else 0, n, p)
         self.coef_ = coef[:p].copy()
@@ -1643,7 +1643,7 @@ class EMGaussianMixture:
         self.precisions_cholesky_ = np.zeros((k, p, p))
         labels = np.zeros(n)
         out = np.zeros(2)
-        it = _gramops_kernels().gmm(X, resp, self.weights_, self.means_,
+        it = _gpu_or_cpu(n * p, getattr(self, "backend", None)).gmm(X, resp, self.weights_, self.means_,
                                     self.precisions_cholesky_, labels, out,
                                     int(self.max_iter), float(self.tol),
                                     float(self.reg_covar), n, p, k)
@@ -1744,7 +1744,7 @@ class ParallelFastICA:
         w0 = np.ascontiguousarray(w0)
         self.components_ = np.zeros((k, p)); self.whitening_ = np.zeros((k, p))
         self._unmixing = np.zeros((k, k)); self.mean_ = np.zeros(p)
-        self.n_iter_ = _gramops_kernels().fastica(
+        self.n_iter_ = _gpu_or_cpu(n * p, getattr(self, "backend", None)).fastica(
             X, w0, self.components_, self.whitening_, self._unmixing, self.mean_,
             int(self.max_iter), float(self.tol), n, p, k)
         self.mixing_ = np.linalg.pinv(self.components_)
@@ -1803,6 +1803,19 @@ class CovARDRegression:
         return np.ascontiguousarray(X, dtype=np.float64) @ self.coef_ + self.intercept_
 
 
+def _gpu_or_cpu(size, backend=None):
+    """The --cuda translation (kernels and device-resident cuBLAS) when it
+    was built, a device answers, the backend allows it and the problem has
+    at least a million entries; the CPU library otherwise."""
+    import os
+    from ._libfind import gpu_built
+    if (backend in (None, "cuda") and size >= 1e6 and not os.environ.get("SCM2CPP_NO_DEVICE")
+            and gpu_built() and cuda_available()):
+        import importlib
+        return importlib.import_module(f"{__name__}._generated._loader_gpu_cuda")
+    return _gramops_kernels()
+
+
 def _accel(work):
     """The --cublas build of the selection and Gram products, when it was
     built, a device answers, and WORK (flops) is large enough to pay for

scm2cpp_lasso-0.13.0/src/scm2cpp_lasso/_generated/_loader_gpu_cuda.py

@@ -0,0 +1,294 @@
+# ctypes loader for libgpu.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_gpu_lib as _load_gpu_lib
+
+_lib = _load_gpu_lib()
+
+_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.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, 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)), a.size, v.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), v.size, ev.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), ev.size, e.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), e.size, 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.c_int, ctypes.POINTER(ctypes.c_int), 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)), ev.size, ord.ctypes.data_as(ctypes.POINTER(ctypes.c_int)), ord.size, 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.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, 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)), w.size, a.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), a.size, v.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), v.size, ev.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), ev.size, e.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), e.size, t.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), t.size, m)
+
+_lib.scm2cpp_fastica.restype = ctypes.c_int
+_lib.scm2cpp_fastica.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, 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)), x.size, winit.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), winit.size, comps.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), comps.size, white.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), white.size, unmix.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), unmix.size, mean.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), mean.size, maxiter, tol, n, p, nc)
+
+_lib.scm2cpp_gmm_mstep.restype = ctypes.c_int
+_lib.scm2cpp_gmm_mstep.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, 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)), x.size, resp.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), resp.size, weights.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), weights.size, means.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), means.size, prec.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), prec.size, dw.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), dw.size, cov.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), cov.size, l.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), l.size, u.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), u.size, reg, norm, n, p, kc)
+
+_lib.scm2cpp_gmm_estep.restype = ctypes.c_double
+_lib.scm2cpp_gmm_estep.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, 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)), x.size, resp.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), resp.size, weights.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), weights.size, means.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), means.size, prec.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), prec.size, wlp.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), wlp.size, y.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), y.size, u.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), u.size, mu.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), mu.size, 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.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, 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_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)), x.size, resp.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), resp.size, weights.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), weights.size, means.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), means.size, prec.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), prec.size, labels.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), labels.size, out.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), out.size, maxiter, tol, reg, n, p, kc)
+
+_lib.scm2cpp_logistic_fg.restype = ctypes.c_double
+_lib.scm2cpp_logistic_fg.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(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_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)), coef.size, g.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), g.size, x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), x.size, y.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), y.size, z.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), z.size, 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.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, 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)), x.size, y.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), y.size, coef.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), coef.size, out.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), out.size, 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.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, 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)), coef.size, g.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), g.size, x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), x.size, y.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), y.size, z.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), z.size, epsilon, alpha, fitint, n, p)
+
+_lib.scm2cpp_huber.restype = ctypes.c_int
+_lib.scm2cpp_huber.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, 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 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)), x.size, y.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), y.size, coef.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), coef.size, out.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), out.size, 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.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, 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_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)), coef.size, g.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), g.size, x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), x.size, y.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), y.size, z.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), z.size, family, power, l2, fitint, n, p)
+
+_lib.scm2cpp_glm.restype = ctypes.c_int
+_lib.scm2cpp_glm.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, 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)), x.size, y.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), y.size, coef.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), coef.size, out.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), out.size, 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.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, 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)), a.size, b.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), b.size, 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.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, 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)), mem.size, slot, v.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), v.size, 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.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, 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)), a.size, ra, b.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), b.size, rb, nv)
+
+_lib.scm2cpp_lb_projgr.restype = ctypes.c_double
+_lib.scm2cpp_lb_projgr.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, 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)), g.size, w.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), w.size, ib, lbv, nv)
+
+_lib.scm2cpp_lb_hv.restype = ctypes.c_int
+_lib.scm2cpp_lb_hv.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, 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)), q.size, smem.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), smem.size, ymem.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), ymem.size, rho.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), rho.size, al.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), al.size, theta, col, head, m, nv)
+
+_lib.scm2cpp_lb_vbv.restype = ctypes.c_double
+_lib.scm2cpp_lb_vbv.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, 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)), v.size, smem.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), smem.size, ymem.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), ymem.size, rho.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), rho.size, bm.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), bm.size, sb.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), sb.size, theta, col, head, m, nv)
+
+_lib.scm2cpp_lb_direction.restype = ctypes.c_int
+_lib.scm2cpp_lb_direction.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, 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)), w.size, g.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), g.size, d.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), d.size, q.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), q.size, e.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), e.size, smem.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), smem.size, ymem.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), ymem.size, rho.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), rho.size, al.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), al.size, bm.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), bm.size, sb.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), sb.size, 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.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, 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)), w.size, x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), x.size, y.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), y.size, aux.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), work.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), work.size, out.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), out.size, 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.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int, 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)), w.size, g.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), g.size, x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), x.size, y.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), y.size, aux.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), work.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), work.size, n, p, k)
+

{scm2cpp_lasso-0.12.0 → scm2cpp_lasso-0.13.0}/src/scm2cpp_lasso/_generated/_loader_gramops_blas.py

@@ -377,10 +377,8 @@ def ard_pinvh(a, s, v, ev, e, k):
     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_double), 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.POINTER(ctypes.c_double), ctypes.c_double, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int]
-def ard_sigma_coef(x, g, xy, idx, lam, coef, sigma, a, v, ev, e, xk, gk, alpha, hoist, n, p, k):
-    x = np.ascontiguousarray(x, dtype=np.float64)
-    g = np.ascontiguousarray(g, dtype=np.float64)
+_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)
@@ -390,9 +388,8 @@ def ard_sigma_coef(x, g, xy, idx, lam, coef, sigma, a, v, ev, e, xk, gk, alpha,
     v = np.ascontiguousarray(v, dtype=np.float64)
     ev = np.ascontiguousarray(ev, dtype=np.float64)
     e = np.ascontiguousarray(e, dtype=np.float64)
-    xk = np.ascontiguousarray(xk, dtype=np.float64)
     gk = np.ascontiguousarray(gk, dtype=np.float64)
-    return _lib.scm2cpp_ard_sigma_coef(x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), g.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), 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)), xk.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), gk.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), alpha, hoist, n, p, k)
+    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]

{scm2cpp_lasso-0.12.0 → scm2cpp_lasso-0.13.0}/src/scm2cpp_lasso/_generated/_loader_gramops_loops.py

@@ -377,10 +377,8 @@ def ard_pinvh(a, s, v, ev, e, k):
     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_double), 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.POINTER(ctypes.c_double), ctypes.c_double, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int]
-def ard_sigma_coef(x, g, xy, idx, lam, coef, sigma, a, v, ev, e, xk, gk, alpha, hoist, n, p, k):
-    x = np.ascontiguousarray(x, dtype=np.float64)
-    g = np.ascontiguousarray(g, dtype=np.float64)
+_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)
@@ -390,9 +388,8 @@ def ard_sigma_coef(x, g, xy, idx, lam, coef, sigma, a, v, ev, e, xk, gk, alpha,
     v = np.ascontiguousarray(v, dtype=np.float64)
     ev = np.ascontiguousarray(ev, dtype=np.float64)
     e = np.ascontiguousarray(e, dtype=np.float64)
-    xk = np.ascontiguousarray(xk, dtype=np.float64)
     gk = np.ascontiguousarray(gk, dtype=np.float64)
-    return _lib.scm2cpp_ard_sigma_coef(x.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), g.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), 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)), xk.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), gk.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), alpha, hoist, n, p, k)
+    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]

scm2cpp_lasso-0.13.0/src/scm2cpp_lasso/_generated/gpu_cuda/gpu.cpp

@@ -0,0 +1,35 @@
+
+#include "gpu.hpp"
+// #include "scm2cpp.hpp"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+