scm2cpp-lasso 0.16.0__tar.gz → 0.17.0__tar.gz

{scm2cpp_lasso-0.16.0/src/scm2cpp_lasso.egg-info → scm2cpp_lasso-0.17.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: scm2cpp-lasso
-Version: 0.16.0
-Summary: scikit-learn estimators (lasso, elastic net, ridge, RidgeCV, ARD, SVM, SVR, logistic regression, GLMs, Huber, Theil-Sen, F-score selection, RFE, NMF, Gaussian mixture, FastICA, PCA, KernelPCA, graphical lasso, RANSAC, SGD, OMP, LARS) translated from Scheme to C++ by scm2cpp; GPU batch solver and CUDA kernels included
+Version: 0.17.0
+Summary: scikit-learn estimators (lasso, elastic net, ridge, RidgeCV, ARD, SVM, SVR, logistic regression, GLMs, Huber, Theil-Sen, F-score selection, RFE, NMF, Gaussian mixture, FastICA, PCA, KernelPCA, LDA, 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
@@ -248,6 +248,7 @@ package picks the fastest one present.
 | `ParallelFastICA` | FastICA | `fastica.scm` | loops / BLAS / --cuda | no |
 | `CovPCA` | PCA(svd_solver='covariance_eigh') | `pca.scm` | loops / BLAS / cuBLAS | PCA |
 | `GramKernelPCA` | KernelPCA (no inverse_transform) | `kernel-pca.scm` | loops / BLAS | no |
+| `GramLDA` | LinearDiscriminantAnalysis (svd, lsqr, eigen) | `lda.scm` | loops / BLAS | no |
 | `f_regression, f_classif` | f_regression, f_classif | `fscore.scm` | loops / BLAS / cuBLAS | no |
 | `SelectKBest, SelectPercentile` | SelectKBest, SelectPercentile | `fscore.scm` | loops / BLAS / cuBLAS | no |
 | `GramRFE` | RFE(Ridge), RFE(LinearRegression) | `rfe.scm` | loops / BLAS / cuBLAS | inside: Ridge |
@@ -643,6 +644,43 @@ Eigenvalues, eigenvectors and transforms agree with scikit-learn's to
 The linear row is the algorithm (an n x n problem against a p x p one),
 not the code.
 
+## Linear discriminant analysis: `GramLDA`
+
+`GramLDA` is scikit-learn's `LinearDiscriminantAnalysis` with the n x p
+work moved to the Gram matrix (`examples/kernel-only/lda.scm`): one pass
+gives the class means and X'X (dsyrk), and the within-class covariance
+is Sw = (X'X - sum_k n_k mu_k mu_k') / n. Each solver then runs its own
+steps on p x p matrices:
+
+- `"svd"` (the default) takes the SVD of the standardised within-class
+  design Xc D^-1 / sqrt(n), n x p. Its right singular vectors and values
+  are the eigenvectors and square roots of the eigenvalues of
+  D^-1 Sw D^-1, so one p x p eigenproblem (dsyevd) replaces it; the
+  second, classes x rank SVD and the coefficients follow as in
+  scikit-learn;
+- `"lsqr"` solves Sw W = M' by Cholesky;
+- `"eigen"` solves Sb v = lam Sw v (`sym-eigen-gen`, LAPACK's dsygvd).
+
+```python
+from scm2cpp_lasso import GramLDA
+clf = GramLDA().fit(X, y)          # solver="svd"
+clf.predict(X), clf.transform(X)
+```
+
+`shrinkage` takes None or a float (it is linear in Sw, so the Gram route
+keeps it), not "auto"; custom `priors` form a Gram per class. The
+coefficients, intercepts, probabilities and explained variance agree
+with scikit-learn's to 1e-12, the predictions exactly, and `transform`
+up to the sign of each column. Measured (`bench/eigen-compare.py`, the
+MKL build, best of three):
+
+| case | scikit-learn | `GramLDA` | ratio, one core | ratio, 20 cores |
+|---|---|---|---|---|
+| svd (default), 200,000 x 100, 5 classes | 4.80 s | 0.092 s | 52x | 35x |
+| svd, 50,000 x 500, 10 classes | 4.07 s | 0.25 s | 16x | 14x |
+| lsqr, 200,000 x 100, 5 classes | 0.42 s | 0.089 s | 4.7x | 8.9x |
+| eigen, 200,000 x 100, 5 classes | 0.56 s | 0.094 s | 6.0x | 12x |
+
 ## Bayesian ridge
 
 `CovBayesianRidge` is scikit-learn's `BayesianRidge` -- the same model,

scm2cpp_lasso-0.16.0/PKG-INFO → scm2cpp_lasso-0.17.0/README.md

@@ -1,21 +1,3 @@
-Metadata-Version: 2.4
-Name: scm2cpp-lasso
-Version: 0.16.0
-Summary: scikit-learn estimators (lasso, elastic net, ridge, RidgeCV, ARD, SVM, SVR, logistic regression, GLMs, Huber, Theil-Sen, F-score selection, RFE, NMF, Gaussian mixture, FastICA, PCA, KernelPCA, 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
-Project-URL: Source, https://github.com/niitsuma/scm2cpp/tree/master/python/scm2cpp-lasso
-Keywords: lasso,elastic-net,ridge,svm,logistic-regression,coordinate-descent,cuda,compiler
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: C++
-Classifier: Topic :: Scientific/Engineering :: Mathematics
-Classifier: Intended Audience :: Science/Research
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-Requires-Dist: numpy>=1.17
-
 # scm2cpp-lasso
 
 [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/niitsuma/scm2cpp/blob/master/notebooks/compare-sklearn.ipynb)
@@ -248,6 +230,7 @@ package picks the fastest one present.
 | `ParallelFastICA` | FastICA | `fastica.scm` | loops / BLAS / --cuda | no |
 | `CovPCA` | PCA(svd_solver='covariance_eigh') | `pca.scm` | loops / BLAS / cuBLAS | PCA |
 | `GramKernelPCA` | KernelPCA (no inverse_transform) | `kernel-pca.scm` | loops / BLAS | no |
+| `GramLDA` | LinearDiscriminantAnalysis (svd, lsqr, eigen) | `lda.scm` | loops / BLAS | no |
 | `f_regression, f_classif` | f_regression, f_classif | `fscore.scm` | loops / BLAS / cuBLAS | no |
 | `SelectKBest, SelectPercentile` | SelectKBest, SelectPercentile | `fscore.scm` | loops / BLAS / cuBLAS | no |
 | `GramRFE` | RFE(Ridge), RFE(LinearRegression) | `rfe.scm` | loops / BLAS / cuBLAS | inside: Ridge |
@@ -643,6 +626,43 @@ Eigenvalues, eigenvectors and transforms agree with scikit-learn's to
 The linear row is the algorithm (an n x n problem against a p x p one),
 not the code.
 
+## Linear discriminant analysis: `GramLDA`
+
+`GramLDA` is scikit-learn's `LinearDiscriminantAnalysis` with the n x p
+work moved to the Gram matrix (`examples/kernel-only/lda.scm`): one pass
+gives the class means and X'X (dsyrk), and the within-class covariance
+is Sw = (X'X - sum_k n_k mu_k mu_k') / n. Each solver then runs its own
+steps on p x p matrices:
+
+- `"svd"` (the default) takes the SVD of the standardised within-class
+  design Xc D^-1 / sqrt(n), n x p. Its right singular vectors and values
+  are the eigenvectors and square roots of the eigenvalues of
+  D^-1 Sw D^-1, so one p x p eigenproblem (dsyevd) replaces it; the
+  second, classes x rank SVD and the coefficients follow as in
+  scikit-learn;
+- `"lsqr"` solves Sw W = M' by Cholesky;
+- `"eigen"` solves Sb v = lam Sw v (`sym-eigen-gen`, LAPACK's dsygvd).
+
+```python
+from scm2cpp_lasso import GramLDA
+clf = GramLDA().fit(X, y)          # solver="svd"
+clf.predict(X), clf.transform(X)
+```
+
+`shrinkage` takes None or a float (it is linear in Sw, so the Gram route
+keeps it), not "auto"; custom `priors` form a Gram per class. The
+coefficients, intercepts, probabilities and explained variance agree
+with scikit-learn's to 1e-12, the predictions exactly, and `transform`
+up to the sign of each column. Measured (`bench/eigen-compare.py`, the
+MKL build, best of three):
+
+| case | scikit-learn | `GramLDA` | ratio, one core | ratio, 20 cores |
+|---|---|---|---|---|
+| svd (default), 200,000 x 100, 5 classes | 4.80 s | 0.092 s | 52x | 35x |
+| svd, 50,000 x 500, 10 classes | 4.07 s | 0.25 s | 16x | 14x |
+| lsqr, 200,000 x 100, 5 classes | 0.42 s | 0.089 s | 4.7x | 8.9x |
+| eigen, 200,000 x 100, 5 classes | 0.56 s | 0.094 s | 6.0x | 12x |
+
 ## Bayesian ridge
 
 `CovBayesianRidge` is scikit-learn's `BayesianRidge` -- the same model,

{scm2cpp_lasso-0.16.0 → scm2cpp_lasso-0.17.0}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "scm2cpp-lasso"
-version = "0.16.0"
-description = "scikit-learn estimators (lasso, elastic net, ridge, RidgeCV, ARD, SVM, SVR, logistic regression, GLMs, Huber, Theil-Sen, F-score selection, RFE, NMF, Gaussian mixture, FastICA, PCA, KernelPCA, graphical lasso, RANSAC, SGD, OMP, LARS) translated from Scheme to C++ by scm2cpp; GPU batch solver and CUDA kernels included"
+version = "0.17.0"
+description = "scikit-learn estimators (lasso, elastic net, ridge, RidgeCV, ARD, SVM, SVR, logistic regression, GLMs, Huber, Theil-Sen, F-score selection, RFE, NMF, Gaussian mixture, FastICA, PCA, KernelPCA, LDA, 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"}

{scm2cpp_lasso-0.16.0 → scm2cpp_lasso-0.17.0}/src/scm2cpp_lasso/__init__.py

@@ -23,6 +23,7 @@ to build the Gram matrix of a moving-average design in O(n p) time and
 no design matrix at all.
 """
 import ctypes
+import warnings
 
 import numpy as np
 
@@ -49,14 +50,14 @@ __all__ = ["GramLasso", "GramElasticNet", "GramRidge", "GramRidgeCV", "CovLasso"
            "LBFGSLogisticRegression", "LBFGSHuberRegressor", "LBFGSLogisticRegressionCV",
            "LBFGSPoissonRegressor", "LBFGSGammaRegressor", "LBFGSTweedieRegressor",
            "GramLarsCV", "GramLassoLarsCV", "GramOMPCV",
-           "EMGaussianMixture", "CovPCA", "GramKernelPCA", "ParallelFastICA", "CovARDRegression",
+           "EMGaussianMixture", "CovPCA", "GramKernelPCA", "GramLDA", "ParallelFastICA", "CovARDRegression",
            "L1LinearSVM", "WeiszfeldTheilSen", "f_regression", "f_classif", "SelectKBest",
            "SelectPercentile", "GramRFE",
            "CovMultiTaskLasso", "CovMultiTaskLassoCV", "DerivedLasso",
            "GramLogisticRegression", "GramGroupLasso", "GramMultiTaskLasso",
            "GramMultiTaskElasticNet", "DesignLasso",
            "cuda_available", "derived_backend", "kernel"]
-__version__ = "0.16.0"
+__version__ = "0.17.0"
 
 _BATCH = load_batch_lib()
 _DP = ctypes.POINTER(ctypes.c_double)
@@ -2244,6 +2245,169 @@ class GramKernelPCA(Tagged, TransformerMixin, BaseEstimator):
         return K @ scaled
 
 
+class GramLDA(Tagged, ClassifierMixin, TransformerMixin, BaseEstimator):
+    """scikit-learn's ``LinearDiscriminantAnalysis`` over the Gram matrix
+    (``examples/kernel-only/lda.scm``): X'X by dsyrk and the class means
+    in one pass, then the three solvers' own steps on p x p matrices --
+    ``"svd"`` (the default) takes its first SVD, of the n x p
+    standardised within-class design, as the eigenproblem of
+    D^-1 Sw D^-1 (dsyevd); ``"lsqr"`` solves Sw W = M' by Cholesky;
+    ``"eigen"`` is Sb v = lam Sw v (dsygvd).  ``shrinkage`` takes None or a
+    float (not "auto"); no ``covariance_estimator``.
+
+    Attributes after fit: classes_, coef_, intercept_, means_, priors_,
+    covariance_ (lsqr, eigen, or store_covariance), scalings_ and
+    explained_variance_ratio_ (svd, eigen), xbar_ (svd), n_features_in_.
+    """
+
+    def __init__(self, solver="svd", shrinkage=None, priors=None, n_components=None,
+                 store_covariance=False, tol=1e-4):
+        self.solver, self.shrinkage, self.priors = solver, shrinkage, priors
+        self.n_components, self.store_covariance, self.tol = n_components, store_covariance, tol
+
+    @staticmethod
+    def _shrunk(C, s):
+        # shrunk_covariance: (1 - s) C + s tr(C) / p I
+        if s is None:
+            return C
+        p = C.shape[0]
+        out = (1.0 - s) * C
+        out.flat[::p + 1] += s * np.trace(C) / p
+        return out
+
+    def fit(self, X, y):
+        if self.solver not in ("svd", "lsqr", "eigen"):
+            raise ValueError(f"solver={self.solver!r}: expected 'svd', 'lsqr' or 'eigen'")
+        s = self.shrinkage
+        if s is not None and (isinstance(s, str) or not 0.0 <= float(s) <= 1.0):
+            raise ValueError(f"shrinkage={s!r}: GramLDA takes None or a float in [0, 1]")
+        if self.solver == "svd" and s is not None:
+            raise NotImplementedError("shrinkage not supported with 'svd' solver.")
+        s = None if s is None else float(s)
+        X, y = fit_xy(self, X, y, classifier=True)
+        n, p = X.shape
+        if n < 2:
+            raise ValueError(f"Found array with {n} sample(s) (shape={X.shape}) while a "
+                             "minimum of 2 is required.")
+        self.classes_, yi = classes_of(y)
+        K = len(self.classes_)
+        if n == K:
+            raise ValueError("The number of samples must be more than the number of classes.")
+        if K < 2:
+            raise ValueError("The number of classes has to be greater than one; got 1 class")
+        k = _gramops_kernels()
+        lab = np.ascontiguousarray(yi, dtype=np.int32)
+        G, means, counts = np.zeros((p, p)), np.zeros((K, p)), np.zeros(K)
+        k.lda_moments(X, lab, G, means, counts, n, p, K)
+        if self.priors is None:
+            priors = counts / n
+        else:
+            priors = np.asarray(self.priors, dtype=np.float64)
+            if np.any(priors < 0):
+                raise ValueError("priors must be non-negative")
+            if abs(priors.sum() - 1.0) > 1e-5:
+                warnings.warn("The priors do not sum to 1. Renormalizing", UserWarning)
+                priors = priors / priors.sum()
+        self.priors_, self.means_ = priors, means
+        top = min(K - 1, p)
+        if self.n_components is not None and int(self.n_components) > top:
+            raise ValueError("n_components cannot be larger than min(n_features, n_classes - 1).")
+        self._max_components = top if self.n_components is None else int(self.n_components)
+        xx = np.diagonal(G).copy()
+        k.lda_within(G, means, counts, n, p, K)      # G is now Sw, empirical priors
+        if not np.all(np.diagonal(G) > 1e-8 * xx / n):
+            # a column whose class means dwarf its spread: the correction
+            # cancelled its digits, so take the centred rows instead
+            Xc = np.ascontiguousarray(X - means[yi])
+            G = _gram(Xc) / n
+        Sw_emp = G
+
+        def class_cov():
+            # scikit-learn's _class_cov: sum_k prior_k (shrunk) C_k; with
+            # the empirical priors that is the shrunk Sw, else per class
+            if self.priors is None or np.allclose(priors, counts / n):
+                return self._shrunk(Sw_emp, s)
+            C = np.zeros((p, p))
+            for c in range(K):
+                Xk = np.ascontiguousarray(X[yi == c] - means[c])
+                C += priors[c] * self._shrunk(_gram(Xk) / max(Xk.shape[0], 1), s)
+            return C
+
+        if self.solver == "svd":
+            if self.store_covariance:
+                self.covariance_ = class_cov()
+            self.xbar_ = priors @ means
+            std, V, S = np.zeros(p), np.zeros((p, p)), np.zeros(p)
+            k.lda_svd_first(np.ascontiguousarray(Sw_emp), std, V, S, p)
+            rank = int(np.sum(S > self.tol))
+            scal = (V[:, :rank] / std[:, None]) / S[:rank]
+            fac = 1.0 if K == 1 else 1.0 / (K - 1)
+            Z = (np.sqrt(n * priors * fac) * (means - self.xbar_).T).T @ scal
+            _, S2, Vt2 = np.linalg.svd(Z, full_matrices=False)
+            self.explained_variance_ratio_ = (S2 ** 2 / np.sum(S2 ** 2))[:self._max_components] \
+                if self._max_components else np.empty((0,))
+            rank2 = int(np.sum(S2 > self.tol * S2[0]))
+            self.scalings_ = scal @ Vt2.T[:, :rank2]
+            coef = (means - self.xbar_) @ self.scalings_
+            self.intercept_ = -0.5 * np.sum(coef ** 2, axis=1) + np.log(priors)
+            self.coef_ = coef @ self.scalings_.T
+            self.intercept_ -= self.xbar_ @ self.coef_.T
+        else:
+            Sw = class_cov()
+            self.covariance_ = Sw
+            if self.solver == "lsqr":
+                coef = _ridge_solve(Sw, np.ascontiguousarray(means.T), 0.0)
+                if coef is None:
+                    coef = np.linalg.lstsq(Sw, means.T, rcond=None)[0]
+                self.coef_ = coef.T
+                self.intercept_ = -0.5 * np.diag(means @ self.coef_.T) + np.log(priors)
+            else:
+                xbar = counts @ means / n
+                St = self._shrunk(Sw_emp + (means - xbar).T @ ((counts / n)[:, None] * (means - xbar)), s)
+                V, ev = np.zeros((p, p)), np.zeros(p)
+                k.lda_eigen(np.ascontiguousarray(St - Sw), np.ascontiguousarray(Sw.copy()), V, ev, p)
+                self.explained_variance_ratio_ = (ev / np.sum(ev))[:self._max_components]
+                self.scalings_ = V
+                self.coef_ = means @ V @ V.T
+                self.intercept_ = -0.5 * np.diag(means @ self.coef_.T) + np.log(priors)
+        if K == 2:
+            self.coef_ = (self.coef_[1, :] - self.coef_[0, :]).reshape(1, -1)
+            self.intercept_ = np.asarray(self.intercept_[1] - self.intercept_[0]).reshape(1)
+        return self
+
+    def decision_function(self, X):
+        check_is_fitted(self)
+        d = pred_x(self, X) @ self.coef_.T + self.intercept_
+        return d.ravel() if d.shape[1] == 1 else d
+
+    def predict(self, X):
+        d = self.decision_function(X)
+        idx = (d > 0).astype(int) if d.ndim == 1 else d.argmax(axis=1)
+        return self.classes_[idx]
+
+    def predict_proba(self, X):
+        d = self.decision_function(X)
+        if d.ndim == 1:
+            p1 = 1.0 / (1.0 + np.exp(-d))
+            return np.stack([1 - p1, p1], axis=1)
+        e = np.exp(d - d.max(axis=1, keepdims=True))
+        return e / e.sum(axis=1, keepdims=True)
+
+    def predict_log_proba(self, X):
+        P = self.predict_proba(X)
+        with np.errstate(divide="ignore"):
+            return np.log(P)
+
+    def transform(self, X):
+        if self.solver == "lsqr":
+            raise NotImplementedError(
+                "transform not implemented for 'lsqr' solver (use 'svd' or 'eigen').")
+        check_is_fitted(self)
+        X = pred_x(self, X)
+        Xn = (X - self.xbar_) @ self.scalings_ if self.solver == "svd" else X @ self.scalings_
+        return Xn[:, :self._max_components]
+
+
 class ParallelFastICA(Tagged, TransformerMixin, BaseEstimator):
     """FastICA, scikit-learn's ``FastICA`` at its defaults translated
     whole (``examples/kernel-only/fastica.scm``: algorithm="parallel",

{scm2cpp_lasso-0.16.0 → scm2cpp_lasso-0.17.0}/src/scm2cpp_lasso/_generated/_loader_accel_cublas.py

@@ -122,6 +122,16 @@ def sym_eigen_top(a, v, ev, e, m, k):
     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_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):

{scm2cpp_lasso-0.16.0 → scm2cpp_lasso-0.17.0}/src/scm2cpp_lasso/_generated/_loader_classifiers.py

@@ -251,6 +251,16 @@ def sym_eigen_top(a, v, ev, e, m, k):
     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_ts_minnorm.restype = ctypes.c_int
 _lib.scm2cpp_ts_minnorm.argtypes = [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.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int]
 def ts_minnorm(x, y, idx, w, aa, v, ev, e, ab, s, ns, fitint, p, d):

{scm2cpp_lasso-0.16.0 → scm2cpp_lasso-0.17.0}/src/scm2cpp_lasso/_generated/_loader_gpu_cuda.py

@@ -45,6 +45,16 @@ def sym_eigen_top(a, v, ev, e, m, k):
     e = np.ascontiguousarray(e, dtype=np.float64)
     return _lib.scm2cpp_sym_eigen_top(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, k)
 
+_lib.scm2cpp_sym_eigen_gen.restype = ctypes.c_int
+_lib.scm2cpp_sym_eigen_gen.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]
+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)), a.size, b.ctypes.data_as(ctypes.POINTER(ctypes.c_double)), b.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_ica_tanh.restype = ctypes.c_double
 _lib.scm2cpp_ica_tanh.argtypes = [ctypes.c_double]
 def ica_tanh(x):

scm2cpp_lasso-0.16.0/src/scm2cpp_lasso/_generated/_loader_gramops_loops.py → scm2cpp_lasso-0.17.0/src/scm2cpp_lasso/_generated/_loader_gramops_blas.py

@@ -8,7 +8,7 @@ from pathlib import Path
 
 from .._libfind import load_gramops_lib as _load_gramops_lib
 
-_lib = _load_gramops_lib("loops")
+_lib = _load_gramops_lib("blas")
 
 _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]
@@ -329,15 +329,6 @@ def eig_order(ev, ord, m):
     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_ica_tanh.restype = ctypes.c_double
 _lib.scm2cpp_ica_tanh.argtypes = [ctypes.c_double]
 def ica_tanh(x):
@@ -624,3 +615,39 @@ def kpca_linear(x, xm, g, vecs, vals, n, p, c):
     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)
+

scm2cpp_lasso-0.16.0/src/scm2cpp_lasso/_generated/_loader_gramops_blas.py → scm2cpp_lasso-0.17.0/src/scm2cpp_lasso/_generated/_loader_gramops_loops.py

@@ -8,7 +8,7 @@ from pathlib import Path
 
 from .._libfind import load_gramops_lib as _load_gramops_lib
 
-_lib = _load_gramops_lib("blas")
+_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]
@@ -329,6 +329,25 @@ def eig_order(ev, ord, m):
     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):
@@ -615,3 +634,39 @@ def kpca_linear(x, xm, g, vecs, vals, n, p, c):
     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)
+

{scm2cpp_lasso-0.16.0 → scm2cpp_lasso-0.17.0}/src/scm2cpp_lasso/_generated/accel_cublas/accel.cpp

@@ -19,3 +19,4 @@
 
 
 
+