scm2cpp-learn 0.18.0__py3-none-win_amd64.whl

scm2cpp_learn/_generated/classifiers_capi.cpp

@@ -0,0 +1,115 @@
+// extern "C" wrappers over the translated functions, for Python and
+// any other caller that speaks the C ABI. Array parameters arrive as
+// element pointers: a view parameter takes the pointer as it is, so
+// the caller's buffer is read and written in place with no copy; a
+// fixed-extent one is reinterpreted as the std::array the function
+// expects. The caller guarantees the length either way.
+// Build (boost includes only if the generated header asks for them,
+// which a numeric kernel's does not):
+//   g++ -O2 -std=c++17 -shared -fPIC -I. -o libclassifiers.so classifiers_capi.cpp
+#include "classifiers.hpp"
+#include <vector>
+#include <algorithm>
+
+extern "C" int scm2cpp_svm_liblinear(double* x, double* y, double* w, double* alpha, double* xnorm, double cost, int iters, double tol, int seed, int n, int p) {
+  return svm_liblinear(x, y, w, alpha, xnorm, cost, iters, tol, seed, n, p);
+}
+extern "C" int scm2cpp_svm_smo(double* k, double* y, double* alpha, double* rho, double cost, int iters, double eps, int n) {
+  return svm_smo(k, y, alpha, rho, cost, iters, eps, n);
+}
+extern "C" int scm2cpp_smo_solve(double* k, double* y, double* lin, double* alpha, double* rho, double cost, int iters, double eps, int n, int nk) {
+  return smo_solve(k, y, lin, alpha, *reinterpret_cast<std::array<double,1>*>(rho), cost, iters, eps, n, nk);
+}
+extern "C" int scm2cpp_shrinkable_P(double* yy, double* a, double* g, double cost, double gmax1, double gmax2, int t) {
+  return shrinkable_P(yy, a, g, cost, gmax1, gmax2, t);
+}
+extern "C" int scm2cpp_swap_position(int* index, int* krow, double* pp, double* yy, double* a, double* g, double* gbar, double* qd, int s, int t) {
+  return swap_position(index, krow, pp, yy, a, g, gbar, qd, s, t);
+}
+extern "C" int scm2cpp_reconstruct_gradient(double* k, int* krow, double* pp, double* yy, double* a, double* g, double* gbar, double cost, int active, int n, int nk) {
+  return reconstruct_gradient(k, krow, pp, yy, a, g, gbar, cost, active, n, nk);
+}
+extern "C" int scm2cpp_select_working_set(double* k, int* krow, double* yy, double* a, double* g, double* qd, double cost, double eps, int active, int nk, int* wi) {
+  return select_working_set(k, krow, yy, a, g, qd, cost, eps, active, nk, *reinterpret_cast<std::array<int,2>*>(wi));
+}
+extern "C" int scm2cpp_svr_smo(double* k, double* z, double* beta, double* rho, double cost, double epsilon, int iters, double eps, int n) {
+  return svr_smo(k, z, beta, rho, cost, epsilon, iters, eps, n);
+}
+extern "C" int scm2cpp_rbf_from_products(double* g, double* sa, double* sb, double gamma, int na, int nb) {
+  return rbf_from_products(g, sa, sb, gamma, na, nb);
+}
+extern "C" int scm2cpp_logistic_l1(double* x, double* y, double* w, double cost, double tol, int maxnewton, int seed, int n, int p) {
+  return logistic_l1(x, y, w, cost, tol, maxnewton, seed, n, p);
+}
+extern "C" int scm2cpp_svr_liblinear(double* x, double* y, double* w, double* beta, double* xnorm, double cost, double epsilon, int iters, double tol, int seed, int n, int p) {
+  return svr_liblinear(x, y, w, beta, xnorm, cost, epsilon, iters, tol, seed, n, p);
+}
+extern "C" double scm2cpp_ols_rows(double* x, double* y, int* rows, int m, double* w, double* g, double* c, double* l, double* z, double* xm, int n, int p) {
+  return ols_rows(x, y, rows, m, w, g, c, l, z, xm, n, p);
+}
+extern "C" int scm2cpp_ransac(double* x, double* y, int* subsets, double* coef, double* mask, double* out, double maxtrials, int minsamples, double thresh, double stopprob, int n, int p) {
+  return ransac(x, y, subsets, coef, mask, out, maxtrials, minsamples, thresh, stopprob, n, p);
+}
+extern "C" double scm2cpp_sgd_loss(int loss, double y, double p, double epsilon) {
+  return sgd_loss(loss, y, p, epsilon);
+}
+extern "C" double scm2cpp_sgd_grad(int loss, double y, double p, double epsilon) {
+  return sgd_grad(loss, y, p, epsilon);
+}
+extern "C" int scm2cpp_sgd(double* x, double* y, double* w, double* out, int loss, int lr, int pen, double alpha, double eta0, double powert, double epsilon, int maxiter, double tol, int niternochange, int fitint, int n, int p) {
+  return sgd(x, y, w, out, loss, lr, pen, alpha, eta0, powert, epsilon, maxiter, tol, niternochange, fitint, n, p);
+}
+extern "C" double scm2cpp_sgd_min(double a, double b) {
+  return sgd_min(a, b);
+}
+extern "C" double scm2cpp_min_pos(double* v, int m) {
+  return min_pos(v, m);
+}
+extern "C" double scm2cpp_round_even(double y) {
+  return round_even(y);
+}
+extern "C" int scm2cpp_cholesky_delete(double* l, int go, int n, int k) {
+  return cholesky_delete(l, go, n, k);
+}
+extern "C" int scm2cpp_swap_rc(double* g, int a, int b, int p) {
+  return swap_rc(g, a, b, p);
+}
+extern "C" int scm2cpp_lars(double* g, double* cov, double* coef, double* path, double* alphas, int rec, double nsamples, double alphamin, int method, int maxiter, double eps, int p) {
+  return lars(g, cov, coef, path, alphas, rec, nsamples, alphamin, method, maxiter, eps, p);
+}
+extern "C" int scm2cpp_svm_l1(double* x, double* y, double* w, double cost, double tol, int maxiter, int seed, int n, int p) {
+  return svm_l1(x, y, w, cost, tol, maxiter, seed, n, p);
+}
+extern "C" double scm2cpp_svm_l1_abs(double a) {
+  return svm_l1_abs(a);
+}
+extern "C" double scm2cpp_eig_hypot(double a, double b) {
+  return eig_hypot(a, b);
+}
+extern "C" int scm2cpp_sym_eigen(double* a, double* v, double* ev, double* e, int m) {
+  return sym_eigen(a, v, ev, e, m);
+}
+extern "C" double scm2cpp_eig_abs(double a) {
+  return eig_abs(a);
+}
+extern "C" int scm2cpp_eig_order(double* ev, int* ord, int m) {
+  return eig_order(ev, ord, m);
+}
+extern "C" int scm2cpp_sym_eigen_top(double* a, double* v, double* ev, double* e, int m, int k) {
+  return sym_eigen_top(a, v, ev, e, m, k);
+}
+extern "C" int scm2cpp_sym_eigen_gen(double* a, double* b, double* v, double* ev, double* e, int m) {
+  return sym_eigen_gen(a, b, v, ev, e, m);
+}
+extern "C" int scm2cpp_ts_minnorm(double* x, double* y, int* idx, double* w, double* aa, double* v, double* ev, double* e, double* ab, int s, int ns, int fitint, int p, int d) {
+  return ts_minnorm(x, y, idx, w, aa, v, ev, e, ab, s, ns, fitint, p, d);
+}
+extern "C" int scm2cpp_ts_fit(double* x, double* y, int* idx, double* w, double* a, double* b, double* aa, double* v, double* ev, double* e, double* ab, int s, int ns, int fitint, int p, int d) {
+  return ts_fit(x, y, idx, w, a, b, aa, v, ev, e, ab, s, ns, fitint, p, d);
+}
+extern "C" double scm2cpp_ts_abs(double v) {
+  return ts_abs(v);
+}
+extern "C" int scm2cpp_theilsen(double* x, double* y, int* idx, double* w, double* coef, int nsub, int ns, int fitint, int maxiter, double tol, int p) {
+  return theilsen(x, y, idx, w, coef, nsub, ns, fitint, maxiter, tol, p);
+}

scm2cpp_learn/_generated/derived_blas/lasso_design.cpp

@@ -0,0 +1,5 @@
+
+#include "lasso_design.hpp"
+// #include "scm2cpp.hpp"
+
+

scm2cpp_learn/_generated/derived_blas/lasso_design.hpp

@@ -0,0 +1,156 @@
+
+#ifndef LASSO_DESIGN_HPP
+#define LASSO_DESIGN_HPP
+#define SCM2CPP_MINIMAL
+#include	"scm2cpp-blas.hpp"
+#include	<vector>
+#include	"scm2cpp.hpp"
+
+SCM2CPP_FN double
+soft_threshold( double  z,  double  g );
+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 );
+
+
+
+SCM2CPP_FN inline double
+soft_threshold( double  z,  double  g )
+{
+    if(z > g) {
+        return (z-g) ;
+    }
+    else if(z < (0.0-g)) {
+        return (z+g) ;
+    }
+    else {
+        return 0.0 ;
+    }
+}
+
+
+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 )
+{   int swept = 0;
+    if( p < n ) {
+        for( int i = 0 ; !(i == n) ; i = (i+1) ) {
+            resid[ i ] = y[i]   ;
+        }  ;
+        0  ;
+        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 = c3444[j];
+                    double old = beta[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 ) {
+                            maxmove = (bnew-old)  ;
+                        } else {
+                            0  ;
+                        }  ;
+                        if( (old-bnew) > maxmove ) {
+                            maxmove = (old-bnew)  ;
+                        } else {
+                            0  ;
+                        }  ;
+                        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  ;
+                    }  ;
+                    ;
+                    ;
+                }  ;
+                if( maxmove <= tol ) {
+                    stop = 1  ;
+                } else {
+                    0  ;
+                }  ;
+                ;
+            }  ;
+            ;
+            for( int j = 0 ; !(j == p) ; j = (j+1) ) {
+                betas[ ((l*p)+j) ] = beta[j]   ;
+            }  ;
+            ;
+        }  ;
+        scm2cpp::blas_gemv(resid, x, b03446, -1.0, 1.0, 0, n, p)  ;
+        0  ;
+        ;
+    } else {
+        for( int i = 0 ; !(i == n) ; i = (i+1) ) {
+            resid[ i ] = y[i]   ;
+        }  ;
+        for( int j = 0 ; !(j == p) ; j = (j+1) ) {
+            double acc = 0.0;
+            for( int i = 0 ; !(i == n) ; i = (i+1) ) {
+                acc = (acc+(x[((i*p)+j)]*x[((i*p)+j)]))  ;
+            }  ;
+            xnorm[ j ] = acc   ;
+            ;
+        }  ;
+        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 = 0.0;
+                    double old = beta[j];
+                    for( int i = 0 ; !(i == n) ; i = (i+1) ) {
+                        rho = (rho+(x[((i*p)+j)]*resid[i]))  ;
+                    }  ;
+                    rho = (rho+(old*xnorm[j]))  ;
+                    double bnew = (soft_threshold(rho,double((lam*(1.0*n))))/xnorm[j]);
+                    beta[ j ] = bnew   ;
+                    if( !(bnew == old) ) {
+                        if( (bnew-old) > maxmove ) {
+                            maxmove = (bnew-old)  ;
+                        } else {
+                            0  ;
+                        }  ;
+                        if( (old-bnew) > maxmove ) {
+                            maxmove = (old-bnew)  ;
+                        } else {
+                            0  ;
+                        }  ;
+                        for( int i = 0 ; !(i == n) ; i = (i+1) ) {
+                            resid[ i ] = (resid[i]-(x[((i*p)+j)]*(bnew-old)))   ;
+                        }  ;
+                    } else {
+                        false  ;
+                    }  ;
+                    ;
+                    ;
+                }  ;
+                if( maxmove <= tol ) {
+                    stop = 1  ;
+                } else {
+                    0  ;
+                }  ;
+                ;
+            }  ;
+            ;
+            for( int j = 0 ; !(j == p) ; j = (j+1) ) {
+                betas[ ((l*p)+j) ] = beta[j]   ;
+            }  ;
+            ;
+        }  ;
+    }  ;
+    return swept ;
+}
+#endif // LASSO_DESIGN_HPP

scm2cpp_learn/_generated/derived_blas/lasso_design_capi.cpp

@@ -0,0 +1,19 @@
+// extern "C" wrappers over the translated functions, for Python and
+// any other caller that speaks the C ABI. Array parameters arrive as
+// element pointers: a view parameter takes the pointer as it is, so
+// the caller's buffer is read and written in place with no copy; a
+// fixed-extent one is reinterpreted as the std::array the function
+// expects. The caller guarantees the length either way.
+// Build (boost includes only if the generated header asks for them,
+// which a numeric kernel's does not):
+//   g++ -O2 -std=c++17 -shared -fPIC -I. -o liblasso_design.so lasso_design_capi.cpp
+#include "lasso_design.hpp"
+#include <vector>
+#include <algorithm>
+
+extern "C" double scm2cpp_soft_threshold(double z, double g) {
+  return soft_threshold(z, g);
+}
+extern "C" int scm2cpp_lasso_design(double* x, double* y, double* resid, double* xnorm, double* beta, double* lams, double* betas, int iters, double tol, int n, int p, int nlam) {
+  return lasso_design(x, y, resid, xnorm, beta, lams, betas, iters, tol, n, p, nlam);
+}

scm2cpp_learn/_generated/derived_cublas/lasso_design.cpp

@@ -0,0 +1,5 @@
+
+#include "lasso_design.hpp"
+// #include "scm2cpp.hpp"
+
+

scm2cpp_learn/_generated/derived_cublas/lasso_design.hpp

@@ -0,0 +1,158 @@
+
+#ifndef LASSO_DESIGN_HPP
+#define LASSO_DESIGN_HPP
+#define SCM2CPP_MINIMAL
+#include	"scm2cpp-cublas.hpp"
+#include	<vector>
+#include	"scm2cpp.hpp"
+
+SCM2CPP_FN double
+soft_threshold( double  z,  double  g );
+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 );
+
+
+
+SCM2CPP_FN inline double
+soft_threshold( double  z,  double  g )
+{
+    if(z > g) {
+        return (z-g) ;
+    }
+    else if(z < (0.0-g)) {
+        return (z+g) ;
+    }
+    else {
+        return 0.0 ;
+    }
+}
+
+
+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 )
+{   int swept = 0;
+    if( p < n ) {
+        for( int i = 0 ; !(i == n) ; i = (i+1) ) {
+            resid[ i ] = y[i]   ;
+        }  ;
+        0  ;
+        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 = c3444[j];
+                    double old = beta[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 ) {
+                            maxmove = (bnew-old)  ;
+                        } else {
+                            0  ;
+                        }  ;
+                        if( (old-bnew) > maxmove ) {
+                            maxmove = (old-bnew)  ;
+                        } else {
+                            0  ;
+                        }  ;
+                        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  ;
+                    }  ;
+                    ;
+                    ;
+                }  ;
+                if( maxmove <= tol ) {
+                    stop = 1  ;
+                } else {
+                    0  ;
+                }  ;
+                ;
+            }  ;
+            ;
+            for( int j = 0 ; !(j == p) ; j = (j+1) ) {
+                betas[ ((l*p)+j) ] = beta[j]   ;
+            }  ;
+            ;
+        }  ;
+        scm2cpp::blas_gemv(resid, d3454, b03446, -1.0, 1.0, 0, n, p)  ;
+        0  ;
+        ;
+        ;
+    } else {
+        for( int i = 0 ; !(i == n) ; i = (i+1) ) {
+            resid[ i ] = y[i]   ;
+        }  ;
+        for( int j = 0 ; !(j == p) ; j = (j+1) ) {
+            double acc = 0.0;
+            for( int i = 0 ; !(i == n) ; i = (i+1) ) {
+                acc = (acc+(x[((i*p)+j)]*x[((i*p)+j)]))  ;
+            }  ;
+            xnorm[ j ] = acc   ;
+            ;
+        }  ;
+        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 = 0.0;
+                    double old = beta[j];
+                    for( int i = 0 ; !(i == n) ; i = (i+1) ) {
+                        rho = (rho+(x[((i*p)+j)]*resid[i]))  ;
+                    }  ;
+                    rho = (rho+(old*xnorm[j]))  ;
+                    double bnew = (soft_threshold(rho,double((lam*(1.0*n))))/xnorm[j]);
+                    beta[ j ] = bnew   ;
+                    if( !(bnew == old) ) {
+                        if( (bnew-old) > maxmove ) {
+                            maxmove = (bnew-old)  ;
+                        } else {
+                            0  ;
+                        }  ;
+                        if( (old-bnew) > maxmove ) {
+                            maxmove = (old-bnew)  ;
+                        } else {
+                            0  ;
+                        }  ;
+                        for( int i = 0 ; !(i == n) ; i = (i+1) ) {
+                            resid[ i ] = (resid[i]-(x[((i*p)+j)]*(bnew-old)))   ;
+                        }  ;
+                    } else {
+                        false  ;
+                    }  ;
+                    ;
+                    ;
+                }  ;
+                if( maxmove <= tol ) {
+                    stop = 1  ;
+                } else {
+                    0  ;
+                }  ;
+                ;
+            }  ;
+            ;
+            for( int j = 0 ; !(j == p) ; j = (j+1) ) {
+                betas[ ((l*p)+j) ] = beta[j]   ;
+            }  ;
+            ;
+        }  ;
+    }  ;
+    return swept ;
+}
+#endif // LASSO_DESIGN_HPP

scm2cpp_learn/_generated/derived_cublas/lasso_design_capi.cpp

@@ -0,0 +1,19 @@
+// extern "C" wrappers over the translated functions, for Python and
+// any other caller that speaks the C ABI. Array parameters arrive as
+// element pointers: a view parameter takes the pointer as it is, so
+// the caller's buffer is read and written in place with no copy; a
+// fixed-extent one is reinterpreted as the std::array the function
+// expects. The caller guarantees the length either way.
+// Build (boost includes only if the generated header asks for them,
+// which a numeric kernel's does not):
+//   g++ -O2 -std=c++17 -shared -fPIC -I. -o liblasso_design.so lasso_design_capi.cpp
+#include "lasso_design.hpp"
+#include <vector>
+#include <algorithm>
+
+extern "C" double scm2cpp_soft_threshold(double z, double g) {
+  return soft_threshold(z, g);
+}
+extern "C" int scm2cpp_lasso_design(double* x, double* y, double* resid, double* xnorm, double* beta, double* lams, double* betas, int iters, double tol, int n, int p, int nlam) {
+  return lasso_design(x, y, resid, xnorm, beta, lams, betas, iters, tol, n, p, nlam);
+}

scm2cpp_learn/_generated/derived_loops/lasso_design.cpp

@@ -0,0 +1,5 @@
+
+#include "lasso_design.hpp"
+// #include "scm2cpp.hpp"
+
+

scm2cpp_learn/_generated/derived_loops/lasso_design.hpp

@@ -0,0 +1,179 @@
+
+#ifndef LASSO_DESIGN_HPP
+#define LASSO_DESIGN_HPP
+#define SCM2CPP_MINIMAL
+#include	<vector>
+#include	"scm2cpp.hpp"
+
+SCM2CPP_FN double
+soft_threshold( double  z,  double  g );
+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 );
+
+
+
+SCM2CPP_FN inline double
+soft_threshold( double  z,  double  g )
+{
+    if(z > g) {
+        return (z-g) ;
+    }
+    else if(z < (0.0-g)) {
+        return (z+g) ;
+    }
+    else {
+        return 0.0 ;
+    }
+}
+
+
+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 )
+{   int swept = 0;
+    if( p < n ) {
+        for( int i = 0 ; !(i == n) ; i = (i+1) ) {
+            resid[ i ] = y[i]   ;
+        }  ;
+        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) ) {
+                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; })()   ;
+                g3445[ ((y2492*p)+y2491) ] = g3445[((y2491*p)+y2492)]   ;
+            }  ;
+        }  ;
+        for( int y2494 = 0 ; !(y2494 == p) ; y2494 = (y2494+1) ) {
+            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 = c3444[j];
+                    double old = beta[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 ) {
+                            maxmove = (bnew-old)  ;
+                        } else {
+                            0  ;
+                        }  ;
+                        if( (old-bnew) > maxmove ) {
+                            maxmove = (old-bnew)  ;
+                        } else {
+                            0  ;
+                        }  ;
+                        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  ;
+                    }  ;
+                    ;
+                    ;
+                }  ;
+                if( maxmove <= tol ) {
+                    stop = 1  ;
+                } else {
+                    0  ;
+                }  ;
+                ;
+            }  ;
+            ;
+            for( int j = 0 ; !(j == p) ; j = (j+1) ) {
+                betas[ ((l*p)+j) ] = beta[j]   ;
+            }  ;
+            ;
+        }  ;
+        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_next3458 = (k2497+1);
+                double sum2502_next3459 = (sum2502+(b03446[k2497]*x[((y2496*p)+k2497)]));
+                k2497 = k2497_next3458;
+                sum2502 = sum2502_next3459;
+            } return sum2502; })())   ;
+        }  ;
+        0  ;
+        ;
+    } else {
+        for( int i = 0 ; !(i == n) ; i = (i+1) ) {
+            resid[ i ] = y[i]   ;
+        }  ;
+        for( int j = 0 ; !(j == p) ; j = (j+1) ) {
+            double acc = 0.0;
+            for( int i = 0 ; !(i == n) ; i = (i+1) ) {
+                acc = (acc+(x[((i*p)+j)]*x[((i*p)+j)]))  ;
+            }  ;
+            xnorm[ j ] = acc   ;
+            ;
+        }  ;
+        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 = 0.0;
+                    double old = beta[j];
+                    for( int i = 0 ; !(i == n) ; i = (i+1) ) {
+                        rho = (rho+(x[((i*p)+j)]*resid[i]))  ;
+                    }  ;
+                    rho = (rho+(old*xnorm[j]))  ;
+                    double bnew = (soft_threshold(rho,double((lam*(1.0*n))))/xnorm[j]);
+                    beta[ j ] = bnew   ;
+                    if( !(bnew == old) ) {
+                        if( (bnew-old) > maxmove ) {
+                            maxmove = (bnew-old)  ;
+                        } else {
+                            0  ;
+                        }  ;
+                        if( (old-bnew) > maxmove ) {
+                            maxmove = (old-bnew)  ;
+                        } else {
+                            0  ;
+                        }  ;
+                        for( int i = 0 ; !(i == n) ; i = (i+1) ) {
+                            resid[ i ] = (resid[i]-(x[((i*p)+j)]*(bnew-old)))   ;
+                        }  ;
+                    } else {
+                        false  ;
+                    }  ;
+                    ;
+                    ;
+                }  ;
+                if( maxmove <= tol ) {
+                    stop = 1  ;
+                } else {
+                    0  ;
+                }  ;
+                ;
+            }  ;
+            ;
+            for( int j = 0 ; !(j == p) ; j = (j+1) ) {
+                betas[ ((l*p)+j) ] = beta[j]   ;
+            }  ;
+            ;
+        }  ;
+    }  ;
+    return swept ;
+}
+#endif // LASSO_DESIGN_HPP