scm2cpp-lasso 0.15.0__tar.gz → 0.15.1__tar.gz

{scm2cpp_lasso-0.15.0 → scm2cpp_lasso-0.15.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scm2cpp-lasso
-Version: 0.15.0
+Version: 0.15.1
 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
@@ -109,9 +109,7 @@ from scikit-learn's `BaseEstimator` and the matching mixin, so `clone`,
 `get_params` / `set_params`, `GridSearchCV`, `Pipeline` and
 `cross_val_score` take them, and all 44 pass
 `sklearn.utils.estimator_checks.check_estimator` (`check-sklearn.py`
-runs it; the expected failures are `DesignLasso`'s missing `n_iter_`,
-since the derived kernel does not count its sweeps, and
-`LBFGSLogisticRegressionCV`'s
+runs it; the one expected failure is `LBFGSLogisticRegressionCV`'s
 `n_iter_` of 0 for a C whose warm start is already converged, which
 scikit-learn's own `LogisticRegressionCV` reports on the same data).
 scikit-learn stays optional: without it a numpy-only stand-in gives
@@ -645,6 +643,15 @@ matrix (`KernelSVM`) or transposing X into columns
 | `L1LogisticRegression`, 20,000 x 500, C=0.05 | 1.20 s | 2.23 s | 1.9x | 106.77913 / 106.77915 | 100% |
 | `L1LogisticRegression`, 100,000 x 200, C=0.05 | 9.06 s | 18.7 s | 2.1x | 349.61154 / 349.61216 | 100% |
 
+On 2,000 x 20,000 neither side reaches the optimum at tol 1e-4 (the
+objective at tol 1e-10 is 0.0519588), and where each stops depends on
+the coordinate order: over eight seeds ours stops at 0.05240 to
+0.05251 (0.9 to 1.1% above the optimum), `LinearSVC`, whose order is
+random unless `random_state` is given, at 0.05242 to 0.05319 (0.9 to
+2.4%). When `LinearSVC` draws one of its worse orders the gap passes
+the script's 0.5% bound and the row prints `<-- disagrees`; ours is
+then the better solution of the two, so the flag there is not a fault.
+
 The regressors, from the same script (C = 1, epsilon 0.1):
 
 | problem | ours | scikit-learn | ratio | agreement |

{scm2cpp_lasso-0.15.0 → scm2cpp_lasso-0.15.1}/README.md

@@ -91,9 +91,7 @@ from scikit-learn's `BaseEstimator` and the matching mixin, so `clone`,
 `get_params` / `set_params`, `GridSearchCV`, `Pipeline` and
 `cross_val_score` take them, and all 44 pass
 `sklearn.utils.estimator_checks.check_estimator` (`check-sklearn.py`
-runs it; the expected failures are `DesignLasso`'s missing `n_iter_`,
-since the derived kernel does not count its sweeps, and
-`LBFGSLogisticRegressionCV`'s
+runs it; the one expected failure is `LBFGSLogisticRegressionCV`'s
 `n_iter_` of 0 for a C whose warm start is already converged, which
 scikit-learn's own `LogisticRegressionCV` reports on the same data).
 scikit-learn stays optional: without it a numpy-only stand-in gives
@@ -627,6 +625,15 @@ matrix (`KernelSVM`) or transposing X into columns
 | `L1LogisticRegression`, 20,000 x 500, C=0.05 | 1.20 s | 2.23 s | 1.9x | 106.77913 / 106.77915 | 100% |
 | `L1LogisticRegression`, 100,000 x 200, C=0.05 | 9.06 s | 18.7 s | 2.1x | 349.61154 / 349.61216 | 100% |
 
+On 2,000 x 20,000 neither side reaches the optimum at tol 1e-4 (the
+objective at tol 1e-10 is 0.0519588), and where each stops depends on
+the coordinate order: over eight seeds ours stops at 0.05240 to
+0.05251 (0.9 to 1.1% above the optimum), `LinearSVC`, whose order is
+random unless `random_state` is given, at 0.05242 to 0.05319 (0.9 to
+2.4%). When `LinearSVC` draws one of its worse orders the gap passes
+the script's 0.5% bound and the row prints `<-- disagrees`; ours is
+then the better solution of the two, so the flag there is not a fault.
+
 The regressors, from the same script (C = 1, epsilon 0.1):
 
 | problem | ours | scikit-learn | ratio | agreement |

{scm2cpp_lasso-0.15.0 → scm2cpp_lasso-0.15.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "scm2cpp-lasso"
-version = "0.15.0"
+version = "0.15.1"
 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"

{scm2cpp_lasso-0.15.0 → scm2cpp_lasso-0.15.1}/src/scm2cpp_lasso/__init__.py

@@ -56,7 +56,7 @@ __all__ = ["GramLasso", "GramElasticNet", "GramRidge", "CovLasso", "CovRidge", "
            "GramLogisticRegression", "GramGroupLasso", "GramMultiTaskLasso",
            "GramMultiTaskElasticNet", "DesignLasso",
            "cuda_available", "derived_backend", "kernel"]
-__version__ = "0.15.0"
+__version__ = "0.15.1"
 
 _BATCH = load_batch_lib()
 _DP = ctypes.POINTER(ctypes.c_double)
@@ -363,16 +363,18 @@ class DerivedLasso:
         the column norms (folded into the Gram's diagonal when p < n),
         builds the Gram matrix, walks the penalties, and leaves the
         coefficient at each in a row of the result.  tol is the largest move of
-        one coefficient in a sweep below which that lambda is done.
+        one coefficient in a sweep below which that lambda is done.  The
+        kernel's value, the sweeps run over the whole path, is kept as
+        n_iter_.
         """
         lams = np.ascontiguousarray(lambdas, dtype=np.float64).ravel()
         beta = np.zeros(self.p)
         resid = np.empty(self.nobs)      # filled by the kernel from y
         xnorm = np.empty(self.p)         # the column norms, taken inside
         betas = np.zeros(lams.size * self.p)
-        self._kernel.lasso_design(self.X, self.y, resid, xnorm, beta, lams,
-                                  betas, int(max_sweeps), float(tol),
-                                  self.nobs, self.p, lams.size)
+        self.n_iter_ = int(self._kernel.lasso_design(
+            self.X, self.y, resid, xnorm, beta, lams, betas, int(max_sweeps), float(tol),
+            self.nobs, self.p, lams.size))
         return betas.reshape(lams.size, self.p)
 
 
@@ -382,10 +384,9 @@ class DesignLasso(Tagged, RegressorMixin, BaseEstimator):
     at one penalty ``alpha``, same objective as GramLasso.  ``tol`` is
     the kernel's (the largest absolute move of one coefficient in a
     sweep), ``max_iter`` its sweep cap and ``backend`` DerivedLasso's.
-    The kernel does not report how many sweeps it ran, so there is no
-    n_iter_.
 
-    Attributes after fit: coef_, intercept_, n_features_in_.
+    Attributes after fit: coef_, intercept_, n_iter_ (the sweeps the
+    kernel ran), n_features_in_.
     """
 
     def __init__(self, alpha=1.0, *, fit_intercept=True, tol=1e-8, max_iter=100000,
@@ -398,6 +399,7 @@ class DesignLasso(Tagged, RegressorMixin, BaseEstimator):
         Xc, yc, xm, ym = _centered(X, y, self.fit_intercept)
         m = DerivedLasso(Xc, yc, backend=self.backend)
         self.coef_ = m.fit(float(self.alpha), tol=float(self.tol), max_sweeps=int(self.max_iter))
+        self.n_iter_ = m.n_iter_
         self.intercept_ = float(ym - xm @ self.coef_)
         return self
 

{scm2cpp_lasso-0.15.0 → scm2cpp_lasso-0.15.1}/src/scm2cpp_lasso/_generated/derived_blas/lasso_design.hpp

@@ -30,26 +30,28 @@ soft_threshold( double  z,  double  g )
 
 inline int
 lasso_design( scm2cpp::cspan<double> x,  scm2cpp::cspan<double> y,  scm2cpp::span<double> resid,  scm2cpp::span<double> xnorm,  scm2cpp::span<double> beta,  scm2cpp::cspan<double> lams,  scm2cpp::span<double> betas,  int  iters,  double  tol,  int  n,  int  p,  int  nlam )
-{   if( p < n ) {
+{   int swept = 0;
+    if( p < n ) {
         for( int i = 0 ; !(i == n) ; i = (i+1) ) {
             resid[ i ] = y[i]   ;
         }  ;
         0  ;
-        std::vector<double> b024258(p,0.0);
-        std::vector<double> g24257((p*p),0.0);
-        std::vector<double> c24256(p,0.0);
-        scm2cpp::blas_syrk(g24257, x, 1.0, 0.0, 1, p, n)  ;
-        scm2cpp::blas_gemv(c24256, x, resid, 1.0, 0.0, 1, p, n)  ;
+        std::vector<double> b03446(p,0.0);
+        std::vector<double> g3445((p*p),0.0);
+        std::vector<double> c3444(p,0.0);
+        scm2cpp::blas_syrk(g3445, x, 1.0, 0.0, 1, p, n)  ;
+        scm2cpp::blas_gemv(c3444, x, resid, 1.0, 0.0, 1, p, n)  ;
         for( int l = 0 ; !(l == nlam) ; l = (l+1) ) {
             double lam = lams[l];
             int stop = 0;
             for( int sweep = 0 ; !((sweep == iters || stop == 1)) ; sweep = (sweep+1) ) {
+                swept = (swept+1)  ;
                 double maxmove = 0.0;
                 for( int j = 0 ; !(j == p) ; j = (j+1) ) {
-                    double rho = c24256[j];
+                    double rho = c3444[j];
                     double old = beta[j];
-                    rho = (rho+(old*g24257[((j*p)+j)]))  ;
-                    double bnew = (soft_threshold(rho,double((lam*(1.0*n))))/g24257[((j*p)+j)]);
+                    rho = (rho+(old*g3445[((j*p)+j)]))  ;
+                    double bnew = (soft_threshold(rho,double((lam*(1.0*n))))/g3445[((j*p)+j)]);
                     beta[ j ] = bnew   ;
                     if( !(bnew == old) ) {
                         if( (bnew-old) > maxmove ) {
@@ -62,9 +64,9 @@ lasso_design( scm2cpp::cspan<double> x,  scm2cpp::cspan<double> y,  scm2cpp::spa
                         } else {
                             0  ;
                         }  ;
-                        b024258[ j ] = (b024258[j]+(bnew-old))   ;
-                        for( int k24260 = 0 ; !(k24260 == p) ; k24260 = (k24260+1) ) {
-                            c24256[ k24260 ] = (c24256[k24260]-(g24257[((j*p)+k24260)]*(bnew-old)))   ;
+                        b03446[ j ] = (b03446[j]+(bnew-old))   ;
+                        for( int k3448 = 0 ; !(k3448 == p) ; k3448 = (k3448+1) ) {
+                            c3444[ k3448 ] = (c3444[k3448]-(g3445[((j*p)+k3448)]*(bnew-old)))   ;
                         }  ;
                     } else {
                         false  ;
@@ -85,7 +87,7 @@ lasso_design( scm2cpp::cspan<double> x,  scm2cpp::cspan<double> y,  scm2cpp::spa
             }  ;
             ;
         }  ;
-        scm2cpp::blas_gemv(resid, x, b024258, -1.0, 1.0, 0, n, p)  ;
+        scm2cpp::blas_gemv(resid, x, b03446, -1.0, 1.0, 0, n, p)  ;
         0  ;
         ;
     } else {
@@ -104,6 +106,7 @@ lasso_design( scm2cpp::cspan<double> x,  scm2cpp::cspan<double> y,  scm2cpp::spa
             double lam = lams[l];
             int stop = 0;
             for( int sweep = 0 ; !((sweep == iters || stop == 1)) ; sweep = (sweep+1) ) {
+                swept = (swept+1)  ;
                 double maxmove = 0.0;
                 for( int j = 0 ; !(j == p) ; j = (j+1) ) {
                     double rho = 0.0;
@@ -148,6 +151,6 @@ lasso_design( scm2cpp::cspan<double> x,  scm2cpp::cspan<double> y,  scm2cpp::spa
             ;
         }  ;
     }  ;
-    return 0 ;
+    return swept ;
 }
 #endif // LASSO_DESIGN_HPP

{scm2cpp_lasso-0.15.0 → scm2cpp_lasso-0.15.1}/src/scm2cpp_lasso/_generated/derived_cublas/lasso_design.hpp

@@ -30,27 +30,29 @@ soft_threshold( double  z,  double  g )
 
 inline int
 lasso_design( scm2cpp::cspan<double> x,  scm2cpp::cspan<double> y,  scm2cpp::span<double> resid,  scm2cpp::span<double> xnorm,  scm2cpp::span<double> beta,  scm2cpp::cspan<double> lams,  scm2cpp::span<double> betas,  int  iters,  double  tol,  int  n,  int  p,  int  nlam )
-{   if( p < n ) {
+{   int swept = 0;
+    if( p < n ) {
         for( int i = 0 ; !(i == n) ; i = (i+1) ) {
             resid[ i ] = y[i]   ;
         }  ;
         0  ;
-        std::vector<double> b024258(p,0.0);
-        std::vector<double> g24257((p*p),0.0);
-        std::vector<double> c24256(p,0.0);
-        scm2cpp::device_matrix d24266 = scm2cpp::dmat_upload(x, (n*p), 1);
-        scm2cpp::blas_syrk(g24257, d24266, 1.0, 0.0, 1, p, n)  ;
-        scm2cpp::blas_gemv(c24256, d24266, resid, 1.0, 0.0, 1, p, n)  ;
+        std::vector<double> b03446(p,0.0);
+        std::vector<double> g3445((p*p),0.0);
+        std::vector<double> c3444(p,0.0);
+        scm2cpp::device_matrix d3454 = scm2cpp::dmat_upload(x, (n*p), 1);
+        scm2cpp::blas_syrk(g3445, d3454, 1.0, 0.0, 1, p, n)  ;
+        scm2cpp::blas_gemv(c3444, d3454, resid, 1.0, 0.0, 1, p, n)  ;
         for( int l = 0 ; !(l == nlam) ; l = (l+1) ) {
             double lam = lams[l];
             int stop = 0;
             for( int sweep = 0 ; !((sweep == iters || stop == 1)) ; sweep = (sweep+1) ) {
+                swept = (swept+1)  ;
                 double maxmove = 0.0;
                 for( int j = 0 ; !(j == p) ; j = (j+1) ) {
-                    double rho = c24256[j];
+                    double rho = c3444[j];
                     double old = beta[j];
-                    rho = (rho+(old*g24257[((j*p)+j)]))  ;
-                    double bnew = (soft_threshold(rho,double((lam*(1.0*n))))/g24257[((j*p)+j)]);
+                    rho = (rho+(old*g3445[((j*p)+j)]))  ;
+                    double bnew = (soft_threshold(rho,double((lam*(1.0*n))))/g3445[((j*p)+j)]);
                     beta[ j ] = bnew   ;
                     if( !(bnew == old) ) {
                         if( (bnew-old) > maxmove ) {
@@ -63,9 +65,9 @@ lasso_design( scm2cpp::cspan<double> x,  scm2cpp::cspan<double> y,  scm2cpp::spa
                         } else {
                             0  ;
                         }  ;
-                        b024258[ j ] = (b024258[j]+(bnew-old))   ;
-                        for( int k24260 = 0 ; !(k24260 == p) ; k24260 = (k24260+1) ) {
-                            c24256[ k24260 ] = (c24256[k24260]-(g24257[((j*p)+k24260)]*(bnew-old)))   ;
+                        b03446[ j ] = (b03446[j]+(bnew-old))   ;
+                        for( int k3448 = 0 ; !(k3448 == p) ; k3448 = (k3448+1) ) {
+                            c3444[ k3448 ] = (c3444[k3448]-(g3445[((j*p)+k3448)]*(bnew-old)))   ;
                         }  ;
                     } else {
                         false  ;
@@ -86,7 +88,7 @@ lasso_design( scm2cpp::cspan<double> x,  scm2cpp::cspan<double> y,  scm2cpp::spa
             }  ;
             ;
         }  ;
-        scm2cpp::blas_gemv(resid, d24266, b024258, -1.0, 1.0, 0, n, p)  ;
+        scm2cpp::blas_gemv(resid, d3454, b03446, -1.0, 1.0, 0, n, p)  ;
         0  ;
         ;
         ;
@@ -106,6 +108,7 @@ lasso_design( scm2cpp::cspan<double> x,  scm2cpp::cspan<double> y,  scm2cpp::spa
             double lam = lams[l];
             int stop = 0;
             for( int sweep = 0 ; !((sweep == iters || stop == 1)) ; sweep = (sweep+1) ) {
+                swept = (swept+1)  ;
                 double maxmove = 0.0;
                 for( int j = 0 ; !(j == p) ; j = (j+1) ) {
                     double rho = 0.0;
@@ -150,6 +153,6 @@ lasso_design( scm2cpp::cspan<double> x,  scm2cpp::cspan<double> y,  scm2cpp::spa
             ;
         }  ;
     }  ;
-    return 0 ;
+    return swept ;
 }
 #endif // LASSO_DESIGN_HPP

{scm2cpp_lasso-0.15.0 → scm2cpp_lasso-0.15.1}/src/scm2cpp_lasso/_generated/derived_loops/lasso_design.hpp

@@ -29,43 +29,45 @@ soft_threshold( double  z,  double  g )
 
 inline int
 lasso_design( scm2cpp::cspan<double> x,  scm2cpp::cspan<double> y,  scm2cpp::span<double> resid,  scm2cpp::span<double> xnorm,  scm2cpp::span<double> beta,  scm2cpp::cspan<double> lams,  scm2cpp::span<double> betas,  int  iters,  double  tol,  int  n,  int  p,  int  nlam )
-{   if( p < n ) {
+{   int swept = 0;
+    if( p < n ) {
         for( int i = 0 ; !(i == n) ; i = (i+1) ) {
             resid[ i ] = y[i]   ;
         }  ;
         0  ;
-        std::vector<double> b024258(p,0.0);
-        std::vector<double> g24257((p*p),0.0);
-        std::vector<double> c24256(p,0.0);
+        std::vector<double> b03446(p,0.0);
+        std::vector<double> g3445((p*p),0.0);
+        std::vector<double> c3444(p,0.0);
         for( int y2491 = 0 ; !(y2491 == p) ; y2491 = (y2491+1) ) {
             for( int y2492 = y2491 ; !(y2492 == p) ; y2492 = (y2492+1) ) {
-                g24257[ ((y2491*p)+y2492) ] = ([&]() -> double { int k2493 = 0; double sum2498 = 0.0; while (!(k2493 == n)) {
-                int k2493_next24266 = (k2493+1);
-                    double sum2498_next24267 = (sum2498+(x[((k2493*p)+y2491)]*x[((k2493*p)+y2492)]));
-                    k2493 = k2493_next24266;
-                    sum2498 = sum2498_next24267;
+                g3445[ ((y2491*p)+y2492) ] = ([&]() -> double { int k2493 = 0; double sum2498 = 0.0; while (!(k2493 == n)) {
+                int k2493_next3454 = (k2493+1);
+                    double sum2498_next3455 = (sum2498+(x[((k2493*p)+y2491)]*x[((k2493*p)+y2492)]));
+                    k2493 = k2493_next3454;
+                    sum2498 = sum2498_next3455;
                 } return sum2498; })()   ;
-                g24257[ ((y2492*p)+y2491) ] = g24257[((y2491*p)+y2492)]   ;
+                g3445[ ((y2492*p)+y2491) ] = g3445[((y2491*p)+y2492)]   ;
             }  ;
         }  ;
         for( int y2494 = 0 ; !(y2494 == p) ; y2494 = (y2494+1) ) {
-            c24256[ y2494 ] = ([&]() -> double { int k2495 = 0; double sum2500 = 0.0; while (!(k2495 == n)) {
-            int k2495_next24268 = (k2495+1);
-                double sum2500_next24269 = (sum2500+(x[((k2495*p)+y2494)]*resid[k2495]));
-                k2495 = k2495_next24268;
-                sum2500 = sum2500_next24269;
+            c3444[ y2494 ] = ([&]() -> double { int k2495 = 0; double sum2500 = 0.0; while (!(k2495 == n)) {
+            int k2495_next3456 = (k2495+1);
+                double sum2500_next3457 = (sum2500+(x[((k2495*p)+y2494)]*resid[k2495]));
+                k2495 = k2495_next3456;
+                sum2500 = sum2500_next3457;
             } return sum2500; })()   ;
         }  ;
         for( int l = 0 ; !(l == nlam) ; l = (l+1) ) {
             double lam = lams[l];
             int stop = 0;
             for( int sweep = 0 ; !((sweep == iters || stop == 1)) ; sweep = (sweep+1) ) {
+                swept = (swept+1)  ;
                 double maxmove = 0.0;
                 for( int j = 0 ; !(j == p) ; j = (j+1) ) {
-                    double rho = c24256[j];
+                    double rho = c3444[j];
                     double old = beta[j];
-                    rho = (rho+(old*g24257[((j*p)+j)]))  ;
-                    double bnew = (soft_threshold(rho,double((lam*(1.0*n))))/g24257[((j*p)+j)]);
+                    rho = (rho+(old*g3445[((j*p)+j)]))  ;
+                    double bnew = (soft_threshold(rho,double((lam*(1.0*n))))/g3445[((j*p)+j)]);
                     beta[ j ] = bnew   ;
                     if( !(bnew == old) ) {
                         if( (bnew-old) > maxmove ) {
@@ -78,9 +80,9 @@ lasso_design( scm2cpp::cspan<double> x,  scm2cpp::cspan<double> y,  scm2cpp::spa
                         } else {
                             0  ;
                         }  ;
-                        b024258[ j ] = (b024258[j]+(bnew-old))   ;
-                        for( int k24260 = 0 ; !(k24260 == p) ; k24260 = (k24260+1) ) {
-                            c24256[ k24260 ] = (c24256[k24260]-(g24257[((j*p)+k24260)]*(bnew-old)))   ;
+                        b03446[ j ] = (b03446[j]+(bnew-old))   ;
+                        for( int k3448 = 0 ; !(k3448 == p) ; k3448 = (k3448+1) ) {
+                            c3444[ k3448 ] = (c3444[k3448]-(g3445[((j*p)+k3448)]*(bnew-old)))   ;
                         }  ;
                     } else {
                         false  ;
@@ -103,10 +105,10 @@ lasso_design( scm2cpp::cspan<double> x,  scm2cpp::cspan<double> y,  scm2cpp::spa
         }  ;
         for( int y2496 = 0 ; !(y2496 == n) ; y2496 = (y2496+1) ) {
             resid[ y2496 ] = (resid[y2496]-([&]() -> double { int k2497 = 0; double sum2502 = 0.0; while (!(k2497 == p)) {
-            int k2497_next24270 = (k2497+1);
-                double sum2502_next24271 = (sum2502+(b024258[k2497]*x[((y2496*p)+k2497)]));
-                k2497 = k2497_next24270;
-                sum2502 = sum2502_next24271;
+            int k2497_next3458 = (k2497+1);
+                double sum2502_next3459 = (sum2502+(b03446[k2497]*x[((y2496*p)+k2497)]));
+                k2497 = k2497_next3458;
+                sum2502 = sum2502_next3459;
             } return sum2502; })())   ;
         }  ;
         0  ;
@@ -127,6 +129,7 @@ lasso_design( scm2cpp::cspan<double> x,  scm2cpp::cspan<double> y,  scm2cpp::spa
             double lam = lams[l];
             int stop = 0;
             for( int sweep = 0 ; !((sweep == iters || stop == 1)) ; sweep = (sweep+1) ) {
+                swept = (swept+1)  ;
                 double maxmove = 0.0;
                 for( int j = 0 ; !(j == p) ; j = (j+1) ) {
                     double rho = 0.0;
@@ -171,6 +174,6 @@ lasso_design( scm2cpp::cspan<double> x,  scm2cpp::cspan<double> y,  scm2cpp::spa
             ;
         }  ;
     }  ;
-    return 0 ;
+    return swept ;
 }
 #endif // LASSO_DESIGN_HPP

{scm2cpp_lasso-0.15.0 → scm2cpp_lasso-0.15.1}/src/scm2cpp_lasso.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scm2cpp-lasso
-Version: 0.15.0
+Version: 0.15.1
 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
@@ -109,9 +109,7 @@ from scikit-learn's `BaseEstimator` and the matching mixin, so `clone`,
 `get_params` / `set_params`, `GridSearchCV`, `Pipeline` and
 `cross_val_score` take them, and all 44 pass
 `sklearn.utils.estimator_checks.check_estimator` (`check-sklearn.py`
-runs it; the expected failures are `DesignLasso`'s missing `n_iter_`,
-since the derived kernel does not count its sweeps, and
-`LBFGSLogisticRegressionCV`'s
+runs it; the one expected failure is `LBFGSLogisticRegressionCV`'s
 `n_iter_` of 0 for a C whose warm start is already converged, which
 scikit-learn's own `LogisticRegressionCV` reports on the same data).
 scikit-learn stays optional: without it a numpy-only stand-in gives
@@ -645,6 +643,15 @@ matrix (`KernelSVM`) or transposing X into columns
 | `L1LogisticRegression`, 20,000 x 500, C=0.05 | 1.20 s | 2.23 s | 1.9x | 106.77913 / 106.77915 | 100% |
 | `L1LogisticRegression`, 100,000 x 200, C=0.05 | 9.06 s | 18.7 s | 2.1x | 349.61154 / 349.61216 | 100% |
 
+On 2,000 x 20,000 neither side reaches the optimum at tol 1e-4 (the
+objective at tol 1e-10 is 0.0519588), and where each stops depends on
+the coordinate order: over eight seeds ours stops at 0.05240 to
+0.05251 (0.9 to 1.1% above the optimum), `LinearSVC`, whose order is
+random unless `random_state` is given, at 0.05242 to 0.05319 (0.9 to
+2.4%). When `LinearSVC` draws one of its worse orders the gap passes
+the script's 0.5% bound and the row prints `<-- disagrees`; ours is
+then the better solution of the two, so the flag there is not a fault.
+
 The regressors, from the same script (C = 1, epsilon 0.1):
 
 | problem | ours | scikit-learn | ratio | agreement |