From cbfcb0224fce12ad7668dfa1feb35e37592778e1 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Sat, 21 Aug 2021 16:53:41 -0500 Subject: [PATCH 001/125] refactored for shared src format --- .gitignore | 1 + R/.Rbuildignore | 4 + DESCRIPTION => R/DESCRIPTION | 0 NAMESPACE => R/NAMESPACE | 0 R/{ => R}/L0Learn.R | 0 R/R/RcppExports.R | 23 + R/{ => R}/coef.R | 0 R/{ => R}/cvfit.R | 3 +- R/{ => R}/fit.R | 0 R/{ => R}/genhighcorr.R | 0 R/{ => R}/genlogistic.R | 0 R/{ => R}/gensynthetic.R | 0 R/{ => R}/plot.R | 0 R/{ => R}/predict.R | 0 R/{ => R}/print.R | 0 R/RcppExports.R | 95 ---- cleanup => R/cleanup | 0 configure => R/configure | 0 configure.ac => R/configure.ac | 0 {man => R/man}/GenSynthetic.Rd | 0 {man => R/man}/GenSyntheticHighCorr.Rd | 0 {man => R/man}/GenSyntheticLogistic.Rd | 0 {man => R/man}/L0Learn-package.Rd | 0 {man => R/man}/L0Learn.cvfit.Rd | 0 {man => R/man}/L0Learn.fit.Rd | 0 {man => R/man}/coef.L0Learn.Rd | 0 {man => R/man}/plot.L0Learn.Rd | 0 {man => R/man}/plot.L0LearnCV.Rd | 0 {man => R/man}/predict.L0Learn.Rd | 0 {man => R/man}/print.L0Learn.Rd | 0 R/src/CDL012LogisticSwaps.cpp | 168 ++++++ R/src/CDL012SquaredHingeSwaps.cpp | 135 +++++ R/src/CDL012Swaps.cpp | 99 ++++ R/src/Grid.cpp | 66 +++ R/src/Grid1D.cpp | 237 ++++++++ R/src/Grid2D.cpp | 126 +++++ {src => R/src}/Makevars | 2 +- {src => R/src}/Makevars.in | 2 +- {src => R/src}/Makevars.win | 0 R/src/Normalize.cpp | 14 + R/src/R_L0Learn_Interface.cpp | 12 + R/src/R_L0Learn_Interface.h | 149 +++++ R/src/RcppExports.cpp | 178 ++++++ {src => R/src}/Test_Interface.cpp | 5 +- R/src/Test_Interface.h | 8 + .../src/include/BetaVector.hpp | 46 +- src/include/CD.h => R/src/include/CD.hpp | 13 +- src/include/CDL0.h => R/src/include/CDL0.hpp | 12 +- .../CDL012.h => R/src/include/CDL012.hpp | 10 +- .../src/include/CDL012Logistic.hpp | 12 +- .../src/include/CDL012LogisticSwaps.hpp | 19 +- .../src/include/CDL012SquaredHinge.hpp | 12 +- .../src/include/CDL012SquaredHingeSwaps.hpp | 16 +- .../src/include/CDL012Swaps.hpp | 16 +- .../CDSwaps.h => R/src/include/CDSwaps.hpp | 2 +- .../src/include/FitResult.hpp | 4 +- src/include/Grid.h => R/src/include/Grid.hpp | 12 +- .../Grid1D.h => R/src/include/Grid1D.hpp | 10 +- .../Grid2D.h => R/src/include/Grid2D.hpp | 12 +- .../src/include/GridParams.hpp | 4 +- R/src/include/L0Learn.hpp | 340 +++++++++++ .../MakeCD.h => R/src/include/MakeCD.hpp | 20 +- .../Model.h => R/src/include/Model.hpp | 0 .../src/include/Normalize.hpp | 6 +- .../Params.h => R/src/include/Params.hpp | 6 +- .../utils.h => R/src/include/utils.hpp | 113 +++- {tests => R/tests}/testthat.R | 0 .../tests}/testthat/test-L0Learn_accuracy.R | 0 .../tests}/testthat/test-L0Learn_gen.R | 0 {tests => R/tests}/testthat/test_L0Learn.R | 0 .../tests}/testthat/test_L0Learn_bounds.R | 0 .../tests}/testthat/test_L0Learn_highcorr.R | 0 .../tests}/testthat/test_L0Learn_intercept.R | 0 .../tests}/testthat/test_L0Learn_usergrids.R | 0 .../tests}/testthat/test_L0Learn_utils.R | 0 .../vignettes}/L0Learn-vignette.Rmd | 0 .../vignettes}/profile/L0Learn_Profile.R | 0 .../profile/L0Learn_Profile_Install.R | 0 .../vignettes}/profile/L0Learn_Profile_Run.R | 0 .../vignettes}/profile/L0Learn_Profile_Run.py | 0 .../vignettes}/profile/ProfilePlotting.ipynb | 0 src/CDL012LogisticSwaps.cpp | 2 +- src/CDL012SquaredHingeSwaps.cpp | 2 +- src/CDL012Swaps.cpp | 2 +- src/Grid.cpp | 10 +- src/Grid1D.cpp | 4 +- src/Grid2D.cpp | 2 +- src/Interface.cpp | 376 ------------- src/Normalize.cpp | 2 +- src/RcppExports.cpp | 418 -------------- src/include/BetaVector.h | 31 - src/include/BetaVector.hpp | 103 ++++ src/include/CD.hpp | 529 ++++++++++++++++++ src/include/CDL0.hpp | 182 ++++++ src/include/CDL012.hpp | 180 ++++++ src/include/CDL012Logistic.hpp | 194 +++++++ src/include/CDL012LogisticSwaps.hpp | 49 ++ src/include/CDL012SquaredHinge.hpp | 208 +++++++ src/include/CDL012SquaredHingeSwaps.hpp | 49 ++ src/include/CDL012Swaps.hpp | 39 ++ src/include/CDSwaps.hpp | 5 + src/include/FitResult.hpp | 22 + src/include/Grid.hpp | 41 ++ src/include/Grid1D.hpp | 39 ++ src/include/Grid2D.hpp | 39 ++ src/include/GridParams.hpp | 28 + src/include/Interface.h | 16 - src/include/L0Learn.hpp | 324 +++++++++++ src/include/MakeCD.hpp | 44 ++ src/include/Model.hpp | 22 + src/include/Normalize.hpp | 52 ++ src/include/Params.hpp | 40 ++ src/include/Test_Interface.h | 8 - src/include/utils.hpp | 216 +++++++ src/profile.cpp | 16 - src/utils.cpp | 98 ---- 116 files changed, 4201 insertions(+), 1203 deletions(-) create mode 100644 R/.Rbuildignore rename DESCRIPTION => R/DESCRIPTION (100%) rename NAMESPACE => R/NAMESPACE (100%) rename R/{ => R}/L0Learn.R (100%) create mode 100644 R/R/RcppExports.R rename R/{ => R}/coef.R (100%) rename R/{ => R}/cvfit.R (98%) rename R/{ => R}/fit.R (100%) rename R/{ => R}/genhighcorr.R (100%) rename R/{ => R}/genlogistic.R (100%) rename R/{ => R}/gensynthetic.R (100%) rename R/{ => R}/plot.R (100%) rename R/{ => R}/predict.R (100%) rename R/{ => R}/print.R (100%) delete mode 100644 R/RcppExports.R rename cleanup => R/cleanup (100%) rename configure => R/configure (100%) rename configure.ac => R/configure.ac (100%) rename {man => R/man}/GenSynthetic.Rd (100%) rename {man => R/man}/GenSyntheticHighCorr.Rd (100%) rename {man => R/man}/GenSyntheticLogistic.Rd (100%) rename {man => R/man}/L0Learn-package.Rd (100%) rename {man => R/man}/L0Learn.cvfit.Rd (100%) rename {man => R/man}/L0Learn.fit.Rd (100%) rename {man => R/man}/coef.L0Learn.Rd (100%) rename {man => R/man}/plot.L0Learn.Rd (100%) rename {man => R/man}/plot.L0LearnCV.Rd (100%) rename {man => R/man}/predict.L0Learn.Rd (100%) rename {man => R/man}/print.L0Learn.Rd (100%) create mode 100644 R/src/CDL012LogisticSwaps.cpp create mode 100644 R/src/CDL012SquaredHingeSwaps.cpp create mode 100644 R/src/CDL012Swaps.cpp create mode 100644 R/src/Grid.cpp create mode 100644 R/src/Grid1D.cpp create mode 100644 R/src/Grid2D.cpp rename {src => R/src}/Makevars (69%) rename {src => R/src}/Makevars.in (65%) rename {src => R/src}/Makevars.win (100%) create mode 100644 R/src/Normalize.cpp create mode 100644 R/src/R_L0Learn_Interface.cpp create mode 100644 R/src/R_L0Learn_Interface.h create mode 100644 R/src/RcppExports.cpp rename {src => R/src}/Test_Interface.cpp (98%) create mode 100644 R/src/Test_Interface.h rename src/BetaVector.cpp => R/src/include/BetaVector.hpp (81%) rename src/include/CD.h => R/src/include/CD.hpp (99%) rename src/include/CDL0.h => R/src/include/CDL0.hpp (97%) rename src/include/CDL012.h => R/src/include/CDL012.hpp (97%) rename src/include/CDL012Logistic.h => R/src/include/CDL012Logistic.hpp (98%) rename src/include/CDL012LogisticSwaps.h => R/src/include/CDL012LogisticSwaps.hpp (73%) rename src/include/CDL012SquaredHinge.h => R/src/include/CDL012SquaredHinge.hpp (98%) rename src/include/CDL012SquaredHingeSwaps.h => R/src/include/CDL012SquaredHingeSwaps.hpp (86%) rename src/include/CDL012Swaps.h => R/src/include/CDL012Swaps.hpp (82%) rename src/include/CDSwaps.h => R/src/include/CDSwaps.hpp (70%) rename src/include/FitResult.h => R/src/include/FitResult.hpp (91%) rename src/include/Grid.h => R/src/include/Grid.hpp (84%) rename src/include/Grid1D.h => R/src/include/Grid1D.hpp (87%) rename src/include/Grid2D.h => R/src/include/Grid2D.hpp (84%) rename src/include/GridParams.h => R/src/include/GridParams.hpp (92%) create mode 100644 R/src/include/L0Learn.hpp rename src/include/MakeCD.h => R/src/include/MakeCD.hpp (78%) rename src/include/Model.h => R/src/include/Model.hpp (100%) rename src/include/Normalize.h => R/src/include/Normalize.hpp (96%) rename src/include/Params.h => R/src/include/Params.hpp (93%) rename src/include/utils.h => R/src/include/utils.hpp (51%) rename {tests => R/tests}/testthat.R (100%) rename {tests => R/tests}/testthat/test-L0Learn_accuracy.R (100%) rename {tests => R/tests}/testthat/test-L0Learn_gen.R (100%) rename {tests => R/tests}/testthat/test_L0Learn.R (100%) rename {tests => R/tests}/testthat/test_L0Learn_bounds.R (100%) rename {tests => R/tests}/testthat/test_L0Learn_highcorr.R (100%) rename {tests => R/tests}/testthat/test_L0Learn_intercept.R (100%) rename {tests => R/tests}/testthat/test_L0Learn_usergrids.R (100%) rename {tests => R/tests}/testthat/test_L0Learn_utils.R (100%) rename {vignettes => R/vignettes}/L0Learn-vignette.Rmd (100%) rename {vignettes => R/vignettes}/profile/L0Learn_Profile.R (100%) rename {vignettes => R/vignettes}/profile/L0Learn_Profile_Install.R (100%) rename {vignettes => R/vignettes}/profile/L0Learn_Profile_Run.R (100%) rename {vignettes => R/vignettes}/profile/L0Learn_Profile_Run.py (100%) rename {vignettes => R/vignettes}/profile/ProfilePlotting.ipynb (100%) delete mode 100644 src/Interface.cpp delete mode 100644 src/RcppExports.cpp delete mode 100644 src/include/BetaVector.h create mode 100644 src/include/BetaVector.hpp create mode 100644 src/include/CD.hpp create mode 100644 src/include/CDL0.hpp create mode 100644 src/include/CDL012.hpp create mode 100644 src/include/CDL012Logistic.hpp create mode 100644 src/include/CDL012LogisticSwaps.hpp create mode 100644 src/include/CDL012SquaredHinge.hpp create mode 100644 src/include/CDL012SquaredHingeSwaps.hpp create mode 100644 src/include/CDL012Swaps.hpp create mode 100644 src/include/CDSwaps.hpp create mode 100644 src/include/FitResult.hpp create mode 100644 src/include/Grid.hpp create mode 100644 src/include/Grid1D.hpp create mode 100644 src/include/Grid2D.hpp create mode 100644 src/include/GridParams.hpp delete mode 100644 src/include/Interface.h create mode 100644 src/include/L0Learn.hpp create mode 100644 src/include/MakeCD.hpp create mode 100644 src/include/Model.hpp create mode 100644 src/include/Normalize.hpp create mode 100644 src/include/Params.hpp delete mode 100644 src/include/Test_Interface.h create mode 100644 src/include/utils.hpp delete mode 100644 src/profile.cpp delete mode 100644 src/utils.cpp diff --git a/.gitignore b/.gitignore index 858a36f..70026c1 100644 --- a/.gitignore +++ b/.gitignore @@ -16,3 +16,4 @@ L0Learn.Rproj config.status debug_log.ipynb tests/profile/ +L0LearnClean.Rproj diff --git a/R/.Rbuildignore b/R/.Rbuildignore new file mode 100644 index 0000000..02bcd26 --- /dev/null +++ b/R/.Rbuildignore @@ -0,0 +1,4 @@ +^\.travis\.yml$ +^\.astylerc$ +^.*\.Rproj$ +^\.Rproj\.user$ diff --git a/DESCRIPTION b/R/DESCRIPTION similarity index 100% rename from DESCRIPTION rename to R/DESCRIPTION diff --git a/NAMESPACE b/R/NAMESPACE similarity index 100% rename from NAMESPACE rename to R/NAMESPACE diff --git a/R/L0Learn.R b/R/R/L0Learn.R similarity index 100% rename from R/L0Learn.R rename to R/R/L0Learn.R diff --git a/R/R/RcppExports.R b/R/R/RcppExports.R new file mode 100644 index 0000000..c2abdf4 --- /dev/null +++ b/R/R/RcppExports.R @@ -0,0 +1,23 @@ +# Generated by using Rcpp::compileAttributes() -> do not edit by hand +# Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393 + +cor_matrix <- function(p, base_cor) { + .Call('_L0Learn_cor_matrix', PACKAGE = 'L0Learn', p, base_cor) +} + +L0LearnFit_sparse <- function(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs) { + invisible(.Call('_L0Learn_L0LearnFit_sparse', PACKAGE = 'L0Learn', X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs)) +} + +L0LearnFit_dense <- function(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs) { + invisible(.Call('_L0Learn_L0LearnFit_dense', PACKAGE = 'L0Learn', X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs)) +} + +L0LearnCV_sparse <- function(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs) { + invisible(.Call('_L0Learn_L0LearnCV_sparse', PACKAGE = 'L0Learn', X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs)) +} + +L0LearnCV_dense <- function(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs) { + invisible(.Call('_L0Learn_L0LearnCV_dense', PACKAGE = 'L0Learn', X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs)) +} + diff --git a/R/coef.R b/R/R/coef.R similarity index 100% rename from R/coef.R rename to R/R/coef.R diff --git a/R/cvfit.R b/R/R/cvfit.R similarity index 98% rename from R/cvfit.R rename to R/R/cvfit.R index 0b6b173..d8c823c 100644 --- a/R/cvfit.R +++ b/R/R/cvfit.R @@ -217,7 +217,8 @@ L0Learn.cvfit <- function(x,y, loss="SquaredError", penalty="L0", algorithm="CD" last = length(M$SuppSize[[i]]) if (M$SuppSize[[i]][last] > maxSuppSize){ if (last == 1){ - warning("Warning! Only 1 element in path with support size > maxSuppSize. \n Try increasing maxSuppSize to resolve the issue.") + print("Warning! Only 1 element in path with support size > maxSuppSize.") + print("Try increasing maxSuppSize to resolve the issue.") } else{ M$SuppSize[[i]] = M$SuppSize[[i]][-last] diff --git a/R/fit.R b/R/R/fit.R similarity index 100% rename from R/fit.R rename to R/R/fit.R diff --git a/R/genhighcorr.R b/R/R/genhighcorr.R similarity index 100% rename from R/genhighcorr.R rename to R/R/genhighcorr.R diff --git a/R/genlogistic.R b/R/R/genlogistic.R similarity index 100% rename from R/genlogistic.R rename to R/R/genlogistic.R diff --git a/R/gensynthetic.R b/R/R/gensynthetic.R similarity index 100% rename from R/gensynthetic.R rename to R/R/gensynthetic.R diff --git a/R/plot.R b/R/R/plot.R similarity index 100% rename from R/plot.R rename to R/R/plot.R diff --git a/R/predict.R b/R/R/predict.R similarity index 100% rename from R/predict.R rename to R/R/predict.R diff --git a/R/print.R b/R/R/print.R similarity index 100% rename from R/print.R rename to R/R/print.R diff --git a/R/RcppExports.R b/R/RcppExports.R deleted file mode 100644 index 4c6db75..0000000 --- a/R/RcppExports.R +++ /dev/null @@ -1,95 +0,0 @@ -# Generated by using Rcpp::compileAttributes() -> do not edit by hand -# Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393 - -L0LearnFit_sparse <- function(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs) { - .Call('_L0Learn_L0LearnFit_sparse', PACKAGE = 'L0Learn', X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs) -} - -L0LearnFit_dense <- function(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs) { - .Call('_L0Learn_L0LearnFit_dense', PACKAGE = 'L0Learn', X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs) -} - -L0LearnCV_sparse <- function(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs) { - .Call('_L0Learn_L0LearnCV_sparse', PACKAGE = 'L0Learn', X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs) -} - -L0LearnCV_dense <- function(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs) { - .Call('_L0Learn_L0LearnCV_dense', PACKAGE = 'L0Learn', X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs) -} - -cor_matrix <- function(p, base_cor) { - .Call('_L0Learn_cor_matrix', PACKAGE = 'L0Learn', p, base_cor) -} - -R_matrix_column_get_dense <- function(mat, col) { - .Call('_L0Learn_R_matrix_column_get_dense', PACKAGE = 'L0Learn', mat, col) -} - -R_matrix_column_get_sparse <- function(mat, col) { - .Call('_L0Learn_R_matrix_column_get_sparse', PACKAGE = 'L0Learn', mat, col) -} - -R_matrix_rows_get_dense <- function(mat, rows) { - .Call('_L0Learn_R_matrix_rows_get_dense', PACKAGE = 'L0Learn', mat, rows) -} - -R_matrix_rows_get_sparse <- function(mat, rows) { - .Call('_L0Learn_R_matrix_rows_get_sparse', PACKAGE = 'L0Learn', mat, rows) -} - -R_matrix_vector_schur_product_dense <- function(mat, u) { - .Call('_L0Learn_R_matrix_vector_schur_product_dense', PACKAGE = 'L0Learn', mat, u) -} - -R_matrix_vector_schur_product_sparse <- function(mat, u) { - .Call('_L0Learn_R_matrix_vector_schur_product_sparse', PACKAGE = 'L0Learn', mat, u) -} - -R_matrix_vector_divide_dense <- function(mat, u) { - .Call('_L0Learn_R_matrix_vector_divide_dense', PACKAGE = 'L0Learn', mat, u) -} - -R_matrix_vector_divide_sparse <- function(mat, u) { - .Call('_L0Learn_R_matrix_vector_divide_sparse', PACKAGE = 'L0Learn', mat, u) -} - -R_matrix_column_sums_dense <- function(mat) { - .Call('_L0Learn_R_matrix_column_sums_dense', PACKAGE = 'L0Learn', mat) -} - -R_matrix_column_sums_sparse <- function(mat) { - .Call('_L0Learn_R_matrix_column_sums_sparse', PACKAGE = 'L0Learn', mat) -} - -R_matrix_column_dot_dense <- function(mat, col, u) { - .Call('_L0Learn_R_matrix_column_dot_dense', PACKAGE = 'L0Learn', mat, col, u) -} - -R_matrix_column_dot_sparse <- function(mat, col, u) { - .Call('_L0Learn_R_matrix_column_dot_sparse', PACKAGE = 'L0Learn', mat, col, u) -} - -R_matrix_column_mult_dense <- function(mat, col, u) { - .Call('_L0Learn_R_matrix_column_mult_dense', PACKAGE = 'L0Learn', mat, col, u) -} - -R_matrix_column_mult_sparse <- function(mat, col, u) { - .Call('_L0Learn_R_matrix_column_mult_sparse', PACKAGE = 'L0Learn', mat, col, u) -} - -R_matrix_normalize_dense <- function(mat_norm) { - .Call('_L0Learn_R_matrix_normalize_dense', PACKAGE = 'L0Learn', mat_norm) -} - -R_matrix_normalize_sparse <- function(mat_norm) { - .Call('_L0Learn_R_matrix_normalize_sparse', PACKAGE = 'L0Learn', mat_norm) -} - -R_matrix_center_dense <- function(mat, X_normalized, intercept) { - .Call('_L0Learn_R_matrix_center_dense', PACKAGE = 'L0Learn', mat, X_normalized, intercept) -} - -R_matrix_center_sparse <- function(mat, X_normalized, intercept) { - .Call('_L0Learn_R_matrix_center_sparse', PACKAGE = 'L0Learn', mat, X_normalized, intercept) -} - diff --git a/cleanup b/R/cleanup similarity index 100% rename from cleanup rename to R/cleanup diff --git a/configure b/R/configure similarity index 100% rename from configure rename to R/configure diff --git a/configure.ac b/R/configure.ac similarity index 100% rename from configure.ac rename to R/configure.ac diff --git a/man/GenSynthetic.Rd b/R/man/GenSynthetic.Rd similarity index 100% rename from man/GenSynthetic.Rd rename to R/man/GenSynthetic.Rd diff --git a/man/GenSyntheticHighCorr.Rd b/R/man/GenSyntheticHighCorr.Rd similarity index 100% rename from man/GenSyntheticHighCorr.Rd rename to R/man/GenSyntheticHighCorr.Rd diff --git a/man/GenSyntheticLogistic.Rd b/R/man/GenSyntheticLogistic.Rd similarity index 100% rename from man/GenSyntheticLogistic.Rd rename to R/man/GenSyntheticLogistic.Rd diff --git a/man/L0Learn-package.Rd b/R/man/L0Learn-package.Rd similarity index 100% rename from man/L0Learn-package.Rd rename to R/man/L0Learn-package.Rd diff --git a/man/L0Learn.cvfit.Rd b/R/man/L0Learn.cvfit.Rd similarity index 100% rename from man/L0Learn.cvfit.Rd rename to R/man/L0Learn.cvfit.Rd diff --git a/man/L0Learn.fit.Rd b/R/man/L0Learn.fit.Rd similarity index 100% rename from man/L0Learn.fit.Rd rename to R/man/L0Learn.fit.Rd diff --git a/man/coef.L0Learn.Rd b/R/man/coef.L0Learn.Rd similarity index 100% rename from man/coef.L0Learn.Rd rename to R/man/coef.L0Learn.Rd diff --git a/man/plot.L0Learn.Rd b/R/man/plot.L0Learn.Rd similarity index 100% rename from man/plot.L0Learn.Rd rename to R/man/plot.L0Learn.Rd diff --git a/man/plot.L0LearnCV.Rd b/R/man/plot.L0LearnCV.Rd similarity index 100% rename from man/plot.L0LearnCV.Rd rename to R/man/plot.L0LearnCV.Rd diff --git a/man/predict.L0Learn.Rd b/R/man/predict.L0Learn.Rd similarity index 100% rename from man/predict.L0Learn.Rd rename to R/man/predict.L0Learn.Rd diff --git a/man/print.L0Learn.Rd b/R/man/print.L0Learn.Rd similarity index 100% rename from man/print.L0Learn.Rd rename to R/man/print.L0Learn.Rd diff --git a/R/src/CDL012LogisticSwaps.cpp b/R/src/CDL012LogisticSwaps.cpp new file mode 100644 index 0000000..29dad24 --- /dev/null +++ b/R/src/CDL012LogisticSwaps.cpp @@ -0,0 +1,168 @@ +#include "CDL012LogisticSwaps.hpp" + +template +CDL012LogisticSwaps::CDL012LogisticSwaps(const T& Xi, const arma::vec& yi, const Params& Pi) : CDSwaps(Xi, yi, Pi) { + twolambda2 = 2 * this->lambda2; + qp2lamda2 = (LipschitzConst + twolambda2); // this is the univariate lipschitz const of the differentiable objective + this->thr2 = (2 * this->lambda0) / qp2lamda2; + this->thr = std::sqrt(this->thr2); + stl0Lc = std::sqrt((2 * this->lambda0) * qp2lamda2); + lambda1ol = this->lambda1 / qp2lamda2; + Xy = Pi.Xy; +} + +template +FitResult CDL012LogisticSwaps::_FitWithBounds() { + throw "This Error should not happen. Please report it as an issue to https://github.com/hazimehh/L0Learn "; +} + +template +FitResult CDL012LogisticSwaps::_Fit() { + auto result = CDL012Logistic(*(this->X), this->y, this->P).Fit(); // result will be maintained till the end + this->b0 = result.b0; // Initialize from previous later....! + this->B = result.B; + ExpyXB = result.ExpyXB; // Maintained throughout the algorithm + + double objective = result.Objective; + double Fmin = objective; + std::size_t maxindex; + double Bmaxindex; + + this->P.Init = 'u'; + + bool foundbetter = false; + bool foundbetter_i = false; + + for (std::size_t t = 0; t < this->MaxNumSwaps; ++t) { + + std::vector NnzIndices = nnzIndicies(this->B, this->NoSelectK); + + // TODO: Add shuffle of Order + //std::shuffle(std::begin(Order), std::end(Order), engine); + + foundbetter = false; + + // TODO: Check if this should be Templated Operation + arma::mat ExpyXBnojs = arma::zeros(this->n, NnzIndices.size()); + + int j_index = -1; + for (auto& j : NnzIndices) + { + // Remove NnzIndices[j] + ++j_index; + ExpyXBnojs.col(j_index) = ExpyXB % arma::exp( - this->B.at(j) * matrix_column_get(*(this->Xy), j)); + + } + arma::mat gradients = - 1/(1 + ExpyXBnojs).t() * *Xy; + arma::mat abs_gradients = arma::abs(gradients); + + + j_index = -1; + for (auto& j : NnzIndices) { + // Set B[j] = 0 + ++j_index; + arma::vec ExpyXBnoj = ExpyXBnojs.col(j_index); + arma::rowvec gradient = gradients.row(j_index); + arma::rowvec abs_gradient = abs_gradients.row(j_index); + + arma::uvec indices = arma::sort_index(arma::abs(gradient), "descend"); + foundbetter_i = false; + + // TODO: make sure this scans at least 100 coordinates from outside supp (now it does not) + for(std::size_t ll = 0; ll < std::min(50, (int) this->p); ++ll) { + std::size_t i = indices(ll); + + if(this->B[i] == 0 && i >= this->NoSelectK) { + // Do not swap B[i] if i between 0 and NoSelectK; + + arma::vec ExpyXBnoji = ExpyXBnoj; + + double Biold = 0; + double partial_i = gradient[i]; + bool converged = false; + + beta_vector Btemp = this->B; + Btemp[j] = 0; + double ObjTemp = Objective(ExpyXBnoji, Btemp); + std::size_t innerindex = 0; + + double x = Biold - partial_i/qp2lamda2; + double z = std::abs(x) - lambda1ol; + double Binew = std::copysign(z, x); + // double Binew = clamp(std::copysign(z, x), this->Lows[i], this->Highs[i]); // no need to check if >= sqrt(2lambda_0/Lc) + + while(!converged && innerindex < 10 && ObjTemp >= Fmin) { // ObjTemp >= Fmin + ExpyXBnoji %= arma::exp( (Binew - Biold) * matrix_column_get(*Xy, i)); + //partial_i = - arma::sum( matrix_column_get(*Xy, i) / (1 + ExpyXBnoji) ) + twolambda2 * Binew; + partial_i = - arma::dot( matrix_column_get(*Xy, i), 1/(1 + ExpyXBnoji) ) + twolambda2 * Binew; + + if (std::abs((Binew - Biold)/Biold) < 0.0001) { + converged = true; + //std::cout<<"swaps converged!!!"<Lows[i], this->Highs[i]); // no need to check if >= sqrt(2lambda_0/Lc) + innerindex += 1; + } + + + Btemp[i] = Binew; + ObjTemp = Objective(ExpyXBnoji, Btemp); + + if (ObjTemp < Fmin) { + Fmin = ObjTemp; + maxindex = i; + Bmaxindex = Binew; + foundbetter_i = true; + } + + // Can be made much faster (later) + Btemp[i] = Binew; + + } + + if (foundbetter_i) { + this->B[j] = 0; + this->B[maxindex] = Bmaxindex; + this->P.InitialSol = &(this->B); + + // TODO: Check if this line is necessary. P should already have b0. + this->P.b0 = this->b0; + + result = CDL012Logistic(*(this->X), this->y, this->P).Fit(); + + ExpyXB = result.ExpyXB; + this->B = result.B; + this->b0 = result.b0; + objective = result.Objective; + Fmin = objective; + foundbetter = true; + break; + } + } + + //auto end2 = std::chrono::high_resolution_clock::now(); + //std::cout<<"restricted: "<(end2-start2).count() << " ms " << std::endl; + + if (foundbetter){ + break; + } + + } + + if(!foundbetter) { + // Early exit to prevent looping + return result; + } + } + + //result.Model = this; + return result; +} + +template class CDL012LogisticSwaps; +template class CDL012LogisticSwaps; diff --git a/R/src/CDL012SquaredHingeSwaps.cpp b/R/src/CDL012SquaredHingeSwaps.cpp new file mode 100644 index 0000000..0f14d11 --- /dev/null +++ b/R/src/CDL012SquaredHingeSwaps.cpp @@ -0,0 +1,135 @@ +#include "CDL012SquaredHingeSwaps.hpp" + +template +CDL012SquaredHingeSwaps::CDL012SquaredHingeSwaps(const T& Xi, const arma::vec& yi, const Params& Pi) : CDSwaps(Xi, yi, Pi) { + twolambda2 = 2 * this->lambda2; + qp2lamda2 = (LipschitzConst + twolambda2); // this is the univariate lipschitz constant of the differentiable objective + this->thr2 = (2 * this->lambda0) / qp2lamda2; + this->thr = std::sqrt(this->thr2); + stl0Lc = std::sqrt((2 * this->lambda0) * qp2lamda2); + lambda1ol = this->lambda1 / qp2lamda2; +} + +template +FitResult CDL012SquaredHingeSwaps::_FitWithBounds() { + throw "This Error should not happen. Please report it as an issue to https://github.com/hazimehh/L0Learn "; +} + +template +FitResult CDL012SquaredHingeSwaps::_Fit() { + auto result = CDL012SquaredHinge(*(this->X), this->y, this->P).Fit(); // result will be maintained till the end + this->b0 = result.b0; // Initialize from previous later....! + this->B = result.B; + + arma::vec onemyxb = result.onemyxb; + + this->objective = result.Objective; + double Fmin = this->objective; + std::size_t maxindex; + double Bmaxindex; + + this->P.Init = 'u'; + + bool foundbetter = false; + + for (std::size_t t = 0; t < this->MaxNumSwaps; ++t) { + // Rcpp::Rcout << "Swap Number: " << t << "|mean(onemyxb): " << arma::mean(onemyxb) << "\n"; + + std::vector NnzIndices = nnzIndicies(this->B, this->NoSelectK); + + // TODO: Implement shuffle of NnzIndices Indicies + + foundbetter = false; + + for (auto& j : NnzIndices) { + + arma::vec onemyxbnoj = onemyxb + this->B[j] * this->y % matrix_column_get(*(this->X), j); + arma::uvec indices = arma::find(onemyxbnoj > 0); + + + for(std::size_t i = 0; i < this->p; ++i) { + if(this->B[i] == 0 && i>=this->NoSelectK) { + + double Biold = 0; + double Binew; + + + double partial_i = arma::sum(2 * onemyxbnoj.elem(indices) % (- (this->y.elem(indices) % matrix_column_get(*(this->X), i).elem(indices)))); + + bool converged = false; + if (std::abs(partial_i) >= this->lambda1 + stl0Lc){ + + //std::cout<<"Adding: "<B; + Btemp[j] = 0; + //double ObjTemp = Objective(onemyxbnoj,Btemp); + //double Biolddescent = 0; + while(!converged) { + + double x = Biold - partial_i / qp2lamda2; + double z = std::abs(x) - lambda1ol; + Binew = std::copysign(z, x); + + // Binew = clamp(std::copysign(z, x), this->Lows[i], this->Highs[i]); // no need to check if >= sqrt(2lambda_0/Lc) + onemyxbnoji += (Biold - Binew) * this->y % matrix_column_get(*(this->X), i); + + arma::uvec indicesi = arma::find(onemyxbnoji > 0); + partial_i = arma::sum(2 * onemyxbnoji.elem(indicesi) % (- this->y.elem(indicesi) % matrix_column_get(*(this->X), i).elem(indicesi))); + + if (std::abs((Binew - Biold) / Biold) < 0.0001){ + converged = true; + } + + Biold = Binew; + l += 1; + + } + + Btemp[i] = Binew; + double Fnew = Objective(onemyxbnoji, Btemp); + + if (Fnew < Fmin) { + Fmin = Fnew; + maxindex = i; + Bmaxindex = Binew; + } + } + } + } + + if (Fmin < this->objective) { + this->B[j] = 0; + this->B[maxindex] = Bmaxindex; + + this->P.InitialSol = &(this->B); + + // TODO: Check if this line is needed. P should already have b0. + this->P.b0 = this->b0; + + result = CDL012SquaredHinge(*(this->X), this->y, this->P).Fit(); + + this->B = result.B; + this->b0 = result.b0; + + onemyxb = result.onemyxb; + this->objective = result.Objective; + Fmin = this->objective; + foundbetter = true; + break; + } + if (foundbetter){break;} + } + + if(!foundbetter) { + return result; + } + } + + return result; +} + +template class CDL012SquaredHingeSwaps; +template class CDL012SquaredHingeSwaps; diff --git a/R/src/CDL012Swaps.cpp b/R/src/CDL012Swaps.cpp new file mode 100644 index 0000000..4fe97ed --- /dev/null +++ b/R/src/CDL012Swaps.cpp @@ -0,0 +1,99 @@ +#include "CDL012Swaps.hpp" + +template +CDL012Swaps::CDL012Swaps(const T& Xi, const arma::vec& yi, const Params& Pi) : CDSwaps(Xi, yi, Pi) {} + + +template +FitResult CDL012Swaps::_FitWithBounds() { + throw "This Error should not happen. Please report it as an issue to https://github.com/hazimehh/L0Learn "; +} + +template +FitResult CDL012Swaps::_Fit() { + auto result = CDL012(*(this->X), this->y, this->P).Fit(); // result will be maintained till the end + this->B = result.B; + this->b0 = result.b0; + double objective = result.Objective; + this->P.Init = 'u'; + + bool foundbetter = false; + + for (std::size_t t = 0; t < this->MaxNumSwaps; ++t) { + + std::vector NnzIndices = nnzIndicies(this->B, this->NoSelectK); + + foundbetter = false; + + // TODO: shuffle NNz Indices to prevent bias. + //std::shuffle(std::begin(Order), std::end(Order), engine); + + // TODO: This calculation is already preformed in a previous step + // Can be pulled/stored + arma::vec r = this->y - *(this->X) * this->B - this->b0; + + for (auto& i : NnzIndices) { + arma::rowvec riX = (r + this->B[i] * matrix_column_get(*(this->X), i)).t() * *(this->X); + + double maxcorr = -1; + std::size_t maxindex = -1; + + for(std::size_t j = this->NoSelectK; j < this->p; ++j) { + // TODO: Account for bounds when determining best swap + // Loops through each column and finds the column with the highest correlation to residuals + // In non-constrained cases, the highest correlation will always be the best option + // However, if bounds restrict the value of B[j], it is possible that swapping column 'i' + // and column 'j' might be rejected as B[j], when constrained, is not able to take a value + // with sufficient magnitude to utilize the correlation. + // Therefore, we must ensure that 'j' was not already rejected. + if (std::fabs(riX[j]) > maxcorr && this->B[j] == 0) { + maxcorr = std::fabs(riX[j]); + maxindex = j; + } + } + + // Check if the correlation is sufficiently large to make up for regularization + if(maxcorr > (1 + 2 * this->ModelParams[2])*std::fabs(this->B[i]) + this->ModelParams[1]) { + // Rcpp::Rcout << t << ": Proposing Swap " << i << " => NNZ and " << maxindex << " => 0 \n"; + // Proposed new Swap + // Value (without considering bounds are solvable in closed form) + // Must be clamped to bounds + + this->B[i] = 0; + + // Bi with No Bounds (nb); + double Bi_nb = (riX[maxindex] - std::copysign(this->ModelParams[1],riX[maxindex])) / (1 + 2 * this->ModelParams[2]); + //double Bi_wb = clamp(Bi_nb, this->Lows[maxindex], this->Highs[maxindex]); // Bi With Bounds (wb) + this->B[maxindex] = Bi_nb; + + // Change initial solution to Swapped value to seed standard CD algorithm. + this->P.InitialSol = &(this->B); + *this->P.r = this->y - *(this->X) * (this->B) - this->b0; + // this->P already has access to b0. + + // proposed_result object. + // Keep tack of previous_best result object + // Only override previous_best if proposed_result has a better objective. + result = CDL012(*(this->X), this->y, this->P).Fit(); + + // Rcpp::Rcout << "Swap Objective " << result.Objective << " \n"; + // Rcpp::Rcout << "Old Objective " << objective << " \n"; + this->B = result.B; + objective = result.Objective; + foundbetter = true; + break; + } + } + + if(!foundbetter) { + // Early exit to prevent looping + return result; + } + } + + return result; +} + +template class CDL012Swaps; +template class CDL012Swaps; + \ No newline at end of file diff --git a/R/src/Grid.cpp b/R/src/Grid.cpp new file mode 100644 index 0000000..53af1fa --- /dev/null +++ b/R/src/Grid.cpp @@ -0,0 +1,66 @@ +#include "Grid.hpp" + +// Assumes PG.P.Specs have been already set +template +Grid::Grid(const T& X, const arma::vec& y, const GridParams& PGi) { + PG = PGi; + + std::tie(BetaMultiplier, meanX, meany, scaley) = Normalize(X, + y, Xscaled, yscaled, !PG.P.Specs.Classification, PG.intercept); + + // Must rescale bounds by BetaMultiplier in order for final result to conform to bounds + if (PG.P.withBounds){ + PG.P.Lows /= BetaMultiplier; + PG.P.Highs /= BetaMultiplier; + } +} + +template +void Grid::Fit() { + + std::vector>>> G; + + if (PG.P.Specs.L0) { + G.push_back(std::move(Grid1D(Xscaled, yscaled, PG).Fit())); + Lambda12.push_back(0); + } else { + G = std::move(Grid2D(Xscaled, yscaled, PG).Fit()); + } + + Lambda0 = std::vector< std::vector >(G.size()); + NnzCount = std::vector< std::vector >(G.size()); + Solutions = std::vector< std::vector >(G.size()); + Intercepts = std::vector< std::vector >(G.size()); + Converged = std::vector< std::vector >(G.size()); + + for (std::size_t i=0; iModelParams[1]); + } else if (PG.P.Specs.L0L2) { + Lambda12.push_back(G[i][0]->ModelParams[2]); + } + + for (auto &g : G[i]) { + Lambda0[i].push_back(g->ModelParams[0]); + + NnzCount[i].push_back(n_nonzero(g->B)); + + Converged[i].push_back(g->IterNum != PG.P.MaxIters); + + beta_vector B_unscaled; + double b0; + + std::tie(B_unscaled, b0) = DeNormalize(g->B, BetaMultiplier, meanX, meany); + Solutions[i].push_back(arma::sp_mat(B_unscaled)); + /* scaley is 1 for classification problems. + * g->intercept is 0 unless specifically optimized for in: + * classification + * sparse regression and intercept = true + */ + Intercepts[i].push_back(scaley*g->b0 + b0); + } + } +} + +template class Grid; +template class Grid; diff --git a/R/src/Grid1D.cpp b/R/src/Grid1D.cpp new file mode 100644 index 0000000..397a1b8 --- /dev/null +++ b/R/src/Grid1D.cpp @@ -0,0 +1,237 @@ +#include "Grid1D.hpp" + +template +Grid1D::Grid1D(const T& Xi, const arma::vec& yi, const GridParams& PG) { + // automatically selects lambda_0 (but assumes other lambdas are given in PG.P.ModelParams) + + X = Ξ + y = &yi; + p = Xi.n_cols; + LambdaMinFactor = PG.LambdaMinFactor; + ScaleDownFactor = PG.ScaleDownFactor; + P = PG.P; + P.Xtr = new std::vector(X->n_cols); // needed! careful + P.ytX = new arma::rowvec(X->n_cols); + P.D = new std::map(); + P.r = new arma::vec(Xi.n_rows); + Xtr = P.Xtr; + ytX = P.ytX; + NoSelectK = P.NoSelectK; + + LambdaU = PG.LambdaU; + + if (!LambdaU) { + G_ncols = PG.G_ncols; + } else { + G_ncols = PG.Lambdas.n_rows; // override the user's ncols if LambdaU = 1 + } + + G.reserve(G_ncols); + if (LambdaU) { + Lambdas = PG.Lambdas; + } // user-defined lambda0 grid + /* + else { + Lambdas.reserve(G_ncols); + Lambdas.push_back((0.5*arma::square(y->t() * *X)).max()); + } + */ + NnzStopNum = PG.NnzStopNum; + PartialSort = PG.PartialSort; + XtrAvailable = PG.XtrAvailable; + if (XtrAvailable) { + ytXmax2d = PG.ytXmax; + Xtr = PG.Xtr; + } +} + +template +Grid1D::~Grid1D() { + // delete all dynamically allocated memory + delete P.Xtr; + delete P.ytX; + delete P.D; + delete P.r; +} + + +template +std::vector>> Grid1D::Fit() { + + if (P.Specs.L0 || P.Specs.L0L2 || P.Specs.L0L1) { + bool scaledown = false; + + double Lipconst; + arma::vec Xtrarma; + if (P.Specs.Logistic) { + if (!XtrAvailable) { + Xtrarma = 0.5 * arma::abs(y->t() * *X).t(); + } // = gradient of logistic loss at zero} + Lipconst = 0.25 + 2 * P.ModelParams[2]; + } else if (P.Specs.SquaredHinge) { + if (!XtrAvailable) { + // gradient of loss function at zero + Xtrarma = 2 * arma::abs(y->t() * *X).t(); + } + Lipconst = 2 + 2 * P.ModelParams[2]; + } else { + if (!XtrAvailable) { + *ytX = y->t() * *X; + Xtrarma = arma::abs(*ytX).t(); // Least squares + } + Lipconst = 1 + 2 * P.ModelParams[2]; + *P.r = *y - P.b0; // B = 0 initially + } + + double ytXmax; + if (!XtrAvailable) { + *Xtr = arma::conv_to< std::vector >::from(Xtrarma); + ytXmax = arma::max(Xtrarma); + } else { + ytXmax = ytXmax2d; + } + + double lambdamax = ((ytXmax - P.ModelParams[1]) * (ytXmax - P.ModelParams[1])) / (2 * (Lipconst)); + + // Rcpp::Rcout << "lambdamax: " << lambdamax << "\n"; + + if (!LambdaU) { + P.ModelParams[0] = lambdamax; + } else { + P.ModelParams[0] = Lambdas[0]; + } + + // Rcpp::Rcout << "P ModelParams: {" << P.ModelParams[0] << ", " << P.ModelParams[1] << ", " << P.ModelParams[2] << ", " << P.ModelParams[3] << "}\n"; + + P.Init = 'z'; + + + //std::cout<< "Lambda max: "<< lambdamax << std::endl; + //double lambdamin = lambdamax*LambdaMinFactor; + //Lambdas = arma::logspace(std::log10(lambdamin), std::log10(lambdamax), G_ncols); + //Lambdas = arma::flipud(Lambdas); + + + //std::size_t StopNum = (X->n_rows < NnzStopNum) ? X->n_rows : NnzStopNum; + std::size_t StopNum = NnzStopNum; + //std::vector* Xtr = P.Xtr; + std::vector idx(p); + double Xrmax; + bool prevskip = false; //previous grid point was skipped + bool currentskip = false; // current grid point should be skipped + + for (std::size_t i = 0; i < G_ncols; ++i) { + // Rcpp::checkUserInterrupt(); + // Rcpp::Rcout << "Grid1D: " << i << "\n"; + FitResult * prevresult = new FitResult; // prevresult is ptr to the prev result object + //std::unique_ptr prevresult; + if (i > 0) { + //prevresult = std::move(G.back()); + *prevresult = *(G.back()); + + } + + currentskip = false; + + if (!prevskip) { + + std::iota(idx.begin(), idx.end(), 0); // make global class var later + // Exclude the first NoSelectK features from sorting. + if (PartialSort && p > 5000 + NoSelectK) + std::partial_sort(idx.begin() + NoSelectK, idx.begin() + 5000 + NoSelectK, idx.end(), [this](std::size_t i1, std::size_t i2) {return (*Xtr)[i1] > (*Xtr)[i2] ;}); + else + std::sort(idx.begin() + NoSelectK, idx.end(), [this](std::size_t i1, std::size_t i2) {return (*Xtr)[i1] > (*Xtr)[i2] ;}); + P.CyclingOrder = 'u'; + P.Uorder = idx; // can be made faster + + // + Xrmax = (*Xtr)[idx[NoSelectK]]; + + if (i > 0) { + std::vector Sp = nnzIndicies(prevresult->B); + + for(std::size_t l = NoSelectK; l < p; ++l) { + if ( std::binary_search(Sp.begin(), Sp.end(), idx[l]) == false ) { + Xrmax = (*Xtr)[idx[l]]; + //std::cout<<"Grid Iteration: "<> result(new FitResult); + *result = Model->Fit(); + + delete Model; + + scaledown = false; + if (i >= 1) { + std::vector Spold = nnzIndicies(prevresult->B); + + std::vector Spnew = nnzIndicies(result->B); + + bool samesupp = false; + + if (Spold == Spnew) { + samesupp = true; + scaledown = true; + } + + // // + // + // if (samesupp) { + // scaledown = true; + // } // got same solution + } + + //else {scaledown = false;} + G.push_back(std::move(result)); + + + if(n_nonzero(G.back()->B) >= StopNum) { + break; + } + //result->B.t().print(); + P.InitialSol = &(G.back()->B); + P.b0 = G.back()->b0; + // Udate: After 1.1.0, P.r is automatically updated by the previous call to CD + //*P.r = G.back()->r; + + } + + delete prevresult; + + + P.Init = 'u'; + P.Iter += 1; + prevskip = currentskip; + } + } + + return std::move(G); +} + + +template class Grid1D; +template class Grid1D; diff --git a/R/src/Grid2D.cpp b/R/src/Grid2D.cpp new file mode 100644 index 0000000..56c98df --- /dev/null +++ b/R/src/Grid2D.cpp @@ -0,0 +1,126 @@ +#include "Grid2D.hpp" + +template +Grid2D::Grid2D(const T& Xi, const arma::vec& yi, const GridParams& PGi) +{ + // automatically selects lambda_0 (but assumes other lambdas are given in PG.P.ModelParams) + X = Ξ + y = &yi; + p = Xi.n_cols; + PG = PGi; + G_nrows = PG.G_nrows; + G_ncols = PG.G_ncols; + G.reserve(G_nrows); + Lambda2Max = PG.Lambda2Max; + Lambda2Min = PG.Lambda2Min; + LambdaMinFactor = PG.LambdaMinFactor; + + P = PG.P; +} + +template +Grid2D::~Grid2D(){ + delete Xtr; + if (PG.P.Specs.Logistic) + delete PG.P.Xy; + if (PG.P.Specs.SquaredHinge) + delete PG.P.Xy; +} + +template +std::vector< std::vector> > > Grid2D::Fit() { + arma::vec Xtrarma; + + if (PG.P.Specs.Logistic) { + auto n = X->n_rows; + double b0 = 0; + arma::vec ExpyXB = arma::ones(n); + if (PG.intercept) { + for (std::size_t t = 0; t < 50; ++t) { + double partial_b0 = - arma::sum( *y / (1 + ExpyXB) ); + b0 -= partial_b0 / (n * 0.25); // intercept is not regularized + ExpyXB = arma::exp(b0 * *y); + } + } + PG.P.b0 = b0; + Xtrarma = arma::abs(- arma::trans(*y /(1+ExpyXB)) * *X).t(); // = gradient of logistic loss at zero + //Xtrarma = 0.5 * arma::abs(y->t() * *X).t(); // = gradient of logistic loss at zero + + T Xy = matrix_vector_schur_product(*X, y); // X->each_col() % *y; + + PG.P.Xy = new T; + *PG.P.Xy = Xy; + } + + else if (PG.P.Specs.SquaredHinge) { + auto n = X->n_rows; + double b0 = 0; + arma::vec onemyxb = arma::ones(n); + arma::uvec indices = arma::find(onemyxb > 0); + if (PG.intercept){ + for (std::size_t t = 0; t < 50; ++t){ + double partial_b0 = arma::sum(2 * onemyxb.elem(indices) % (- y->elem(indices) ) ); + b0 -= partial_b0 / (n * 2); // intercept is not regularized + onemyxb = 1 - (*y * b0); + indices = arma::find(onemyxb > 0); + } + } + PG.P.b0 = b0; + T indices_rows = matrix_rows_get(*X, indices); + Xtrarma = 2 * arma::abs(arma::trans(y->elem(indices) % onemyxb.elem(indices))* indices_rows).t(); // = gradient of loss function at zero + //Xtrarma = 2 * arma::abs(y->t() * *X).t(); // = gradient of loss function at zero + T Xy = matrix_vector_schur_product(*X, y); // X->each_col() % *y; + PG.P.Xy = new T; + *PG.P.Xy = Xy; + } else { + Xtrarma = arma::abs(y->t() * *X).t(); + } + + + double ytXmax = arma::max(Xtrarma); + + std::size_t index; + if (PG.P.Specs.L0L1) { + index = 1; + if(G_nrows != 1) { + Lambda2Max = ytXmax; + Lambda2Min = Lambda2Max * LambdaMinFactor; + } + } else if (PG.P.Specs.L0L2) { + index = 2; + } + + arma::vec Lambdas2 = arma::logspace(std::log10(Lambda2Min), std::log10(Lambda2Max), G_nrows); + Lambdas2 = arma::flipud(Lambdas2); + + std::vector Xtrvec = arma::conv_to< std::vector >::from(Xtrarma); + + Xtr = new std::vector(X->n_cols); // needed! careful + + + PG.XtrAvailable = true; + // Rcpp::Rcout << "Grid2D Start\n"; + for(std::size_t i=0; i> Gl(); + //auto Gl = Grid1D(*X, *y, PG).Fit(); + // Rcpp::Rcout << "Grid1D Start: " << i << "\n"; + G.push_back(std::move(Grid1D(*X, *y, PG).Fit())); + } + + return std::move(G); + +} + +template class Grid2D; +template class Grid2D; diff --git a/src/Makevars b/R/src/Makevars similarity index 69% rename from src/Makevars rename to R/src/Makevars index 990fa39..7970b9f 100644 --- a/src/Makevars +++ b/R/src/Makevars @@ -1,3 +1,3 @@ CXX_STD = CXX11 -PKG_CXXFLAGS = "-Iinclude" +PKG_CXXFLAGS = PKG_LIBS= $(LAPACK_LIBS) $(BLAS_LIBS) $(FLIBS) diff --git a/src/Makevars.in b/R/src/Makevars.in similarity index 65% rename from src/Makevars.in rename to R/src/Makevars.in index 32eb0f5..455bdee 100644 --- a/src/Makevars.in +++ b/R/src/Makevars.in @@ -1,3 +1,3 @@ CXX_STD = CXX11 -PKG_CXXFLAGS = "-Iinclude" @OPENMP_FLAG@ +PKG_CXXFLAGS = @OPENMP_FLAG@ PKG_LIBS= @OPENMP_FLAG@ $(LAPACK_LIBS) $(BLAS_LIBS) $(FLIBS) diff --git a/src/Makevars.win b/R/src/Makevars.win similarity index 100% rename from src/Makevars.win rename to R/src/Makevars.win diff --git a/R/src/Normalize.cpp b/R/src/Normalize.cpp new file mode 100644 index 0000000..8b1e6f6 --- /dev/null +++ b/R/src/Normalize.cpp @@ -0,0 +1,14 @@ +#include "Normalize.hpp" + +std::tuple DeNormalize(beta_vector & B_scaled, + arma::vec & BetaMultiplier, + arma::vec & meanX, double meany) { + beta_vector B_unscaled = B_scaled % BetaMultiplier; + double intercept = meany - arma::dot(B_unscaled, meanX); + // Matrix Type, Intercept + // Dense, True -> meanX = colMeans(X) + // Dense, False -> meanX = 0 Vector (meany = 0) + // Sparse, True -> meanX = 0 Vector + // Sparse, False -> meanX = 0 Vector + return std::make_tuple(B_unscaled, intercept); +} diff --git a/R/src/R_L0Learn_Interface.cpp b/R/src/R_L0Learn_Interface.cpp new file mode 100644 index 0000000..dc55490 --- /dev/null +++ b/R/src/R_L0Learn_Interface.cpp @@ -0,0 +1,12 @@ +#include "R_L0Learn_Interface.h" + +// [[Rcpp::export]] +Rcpp::NumericMatrix cor_matrix(const int p, const double base_cor) { + Rcpp::NumericMatrix cor(p, p); + for (int i = 0; i < p; i++){ + for (int j = 0; j < p; j++){ + cor(i, j) = std::pow(base_cor, std::abs(i - j)); + } + } + return cor; +} \ No newline at end of file diff --git a/R/src/R_L0Learn_Interface.h b/R/src/R_L0Learn_Interface.h new file mode 100644 index 0000000..93372a7 --- /dev/null +++ b/R/src/R_L0Learn_Interface.h @@ -0,0 +1,149 @@ +// [[Rcpp::depends(RcppArmadillo)]] +#ifndef R_L0LEARN_INTERFACE_H +#define R_L0LEARN_INTERFACE_H + +#include +#include +#include +#include "RcppArmadillo.h" +#include "L0Learn.hpp" +#include +#include + +// [[Rcpp::export]] +void L0LearnFit_sparse(const arma::sp_mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, + const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, + const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, + const bool PartialSort, const std::size_t MaxIters, const double rtol, + const double atol, const bool ActiveSet, const std::size_t ActiveSetNum, + const std::size_t MaxNumSwaps, const double ScaleDownFactor, + const std::size_t ScreenSize, const bool LambdaU, + const std::vector< std::vector > Lambdas, + const std::size_t ExcludeFirstK, const bool Intercept, + const bool withBounds, const arma::vec &Lows, const arma::vec &Highs) { + L0LearnFit(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, + PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, + Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs); + + // fitmodel l = L0LearnFit(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, + // PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, + // Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs); + // + // return Rcpp::List::create(Rcpp::Named("lambda") = l.Lambda0, + // Rcpp::Named("gamma") = l.Lambda12, + // Rcpp::Named("SuppSize") = l.NnzCount, + // Rcpp::Named("beta") = l.Beta, + // Rcpp::Named("a0") = l.Intercept, + // Rcpp::Named("Converged") = l.Converged); + +} + + +// [[Rcpp::export]] +void L0LearnFit_dense(const arma::mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, + const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, + const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, + const bool PartialSort, const std::size_t MaxIters, const double rtol, + const double atol, const bool ActiveSet, const std::size_t ActiveSetNum, + const std::size_t MaxNumSwaps, const double ScaleDownFactor, + const std::size_t ScreenSize, const bool LambdaU, + const std::vector< std::vector > Lambdas, + const std::size_t ExcludeFirstK, const bool Intercept, + const bool withBounds, const arma::vec &Lows, const arma::vec &Highs) { + + Rcpp::Rcout << "L0LearnFit_dense Start\n"; + Rcpp::Rcout << "Lambdas: \n"; + for (std::vector>::const_iterator i = Lambdas.begin(); i != Lambdas.end(); ++i){ + for (std::vector::const_iterator j = (*i).begin(); j != (*i).end(); ++j) + Rcpp::Rcout << *j << ' '; + } + std::this_thread::sleep_for(std::chrono::milliseconds(1000)); + + L0LearnFit(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, + PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, + ScreenSize, LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs); + + // fitmodel l = L0LearnFit(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, + // PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, + // ScreenSize, LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs); + + // return Rcpp::List::create(Rcpp::Named("lambda") = l.Lambda0, + // Rcpp::Named("gamma") = l.Lambda12, + // Rcpp::Named("SuppSize") = l.NnzCount, + // Rcpp::Named("beta") = l.Beta, + // Rcpp::Named("a0") = l.Intercept, + // Rcpp::Named("Converged") = l.Converged); +} + + +// [[Rcpp::export]] +void L0LearnCV_sparse(const arma::sp_mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, + const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, + const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, + const bool PartialSort, const std::size_t MaxIters, const double rtol, const double atol, + const bool ActiveSet, const std::size_t ActiveSetNum, const std::size_t MaxNumSwaps, + const double ScaleDownFactor, const std::size_t ScreenSize, const bool LambdaU, + const std::vector< std::vector > Lambdas, const std::size_t nfolds, + const double seed, const std::size_t ExcludeFirstK, const bool Intercept, + const bool withBounds, const arma::vec &Lows, const arma::vec &Highs){ + + L0LearnCV(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, + G_nrows, Lambda2Max, Lambda2Min, PartialSort, + MaxIters, rtol, atol, ActiveSet, ActiveSetNum, + MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, + Lambdas, nfolds, seed, ExcludeFirstK, Intercept, + withBounds, Lows, Highs); + + // cvfitmodel l = L0LearnCV(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, + // G_nrows, Lambda2Max, Lambda2Min, PartialSort, + // MaxIters, rtol, atol, ActiveSet, ActiveSetNum, + // MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, + // Lambdas, nfolds, seed, ExcludeFirstK, Intercept, + // withBounds, Lows, Highs); + // + // return Rcpp::List::create(Rcpp::Named("lambda") = l.Lambda0, + // Rcpp::Named("gamma") = l.Lambda12, + // Rcpp::Named("SuppSize") = l.NnzCount, + // Rcpp::Named("beta") = l.Beta, + // Rcpp::Named("a0") = l.Intercept, + // Rcpp::Named("Converged") = l.Converged, + // Rcpp::Named("CVMeans") = l.CVMeans, + // Rcpp::Named("CVSDs") = l.CVSDs); +} + +// [[Rcpp::export]] +void L0LearnCV_dense(const arma::mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, + const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, + const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, + const bool PartialSort, const std::size_t MaxIters, const double rtol, const double atol, + const bool ActiveSet, const std::size_t ActiveSetNum, const std::size_t MaxNumSwaps, + const double ScaleDownFactor, const std::size_t ScreenSize, const bool LambdaU, + const std::vector< std::vector > Lambdas, const std::size_t nfolds, + const double seed, const std::size_t ExcludeFirstK, const bool Intercept, + const bool withBounds, const arma::vec &Lows, const arma::vec &Highs){ + + L0LearnCV(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, + G_nrows, Lambda2Max, Lambda2Min, PartialSort, + MaxIters, rtol, atol, ActiveSet, ActiveSetNum, + MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, + Lambdas, nfolds, seed, ExcludeFirstK, Intercept, + withBounds, Lows, Highs); + // cvfitmodel l = L0LearnCV(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, + // G_nrows, Lambda2Max, Lambda2Min, PartialSort, + // MaxIters, rtol, atol, ActiveSet, ActiveSetNum, + // MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, + // Lambdas, nfolds, seed, ExcludeFirstK, Intercept, + // withBounds, Lows, Highs); + // + // return Rcpp::List::create(Rcpp::Named("lambda") = l.Lambda0, + // Rcpp::Named("gamma") = l.Lambda12, + // Rcpp::Named("SuppSize") = l.NnzCount, + // Rcpp::Named("beta") = l.Beta, + // Rcpp::Named("a0") = l.Intercept, + // Rcpp::Named("Converged") = l.Converged, + // Rcpp::Named("CVMeans") = l.CVMeans, + // Rcpp::Named("CVSDs") = l.CVSDs); +} + + +#endif // R_L0LEARN_INTERFACE_H diff --git a/R/src/RcppExports.cpp b/R/src/RcppExports.cpp new file mode 100644 index 0000000..4011796 --- /dev/null +++ b/R/src/RcppExports.cpp @@ -0,0 +1,178 @@ +// Generated by using Rcpp::compileAttributes() -> do not edit by hand +// Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393 + +#include +#include + +using namespace Rcpp; + +// cor_matrix +Rcpp::NumericMatrix cor_matrix(const int p, const double base_cor); +RcppExport SEXP _L0Learn_cor_matrix(SEXP pSEXP, SEXP base_corSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< const int >::type p(pSEXP); + Rcpp::traits::input_parameter< const double >::type base_cor(base_corSEXP); + rcpp_result_gen = Rcpp::wrap(cor_matrix(p, base_cor)); + return rcpp_result_gen; +END_RCPP +} +// L0LearnFit_sparse +void L0LearnFit_sparse(const arma::sp_mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, const bool PartialSort, const std::size_t MaxIters, const double rtol, const double atol, const bool ActiveSet, const std::size_t ActiveSetNum, const std::size_t MaxNumSwaps, const double ScaleDownFactor, const std::size_t ScreenSize, const bool LambdaU, const std::vector< std::vector > Lambdas, const std::size_t ExcludeFirstK, const bool Intercept, const bool withBounds, const arma::vec& Lows, const arma::vec& Highs); +RcppExport SEXP _L0Learn_L0LearnFit_sparse(SEXP XSEXP, SEXP ySEXP, SEXP LossSEXP, SEXP PenaltySEXP, SEXP AlgorithmSEXP, SEXP NnzStopNumSEXP, SEXP G_ncolsSEXP, SEXP G_nrowsSEXP, SEXP Lambda2MaxSEXP, SEXP Lambda2MinSEXP, SEXP PartialSortSEXP, SEXP MaxItersSEXP, SEXP rtolSEXP, SEXP atolSEXP, SEXP ActiveSetSEXP, SEXP ActiveSetNumSEXP, SEXP MaxNumSwapsSEXP, SEXP ScaleDownFactorSEXP, SEXP ScreenSizeSEXP, SEXP LambdaUSEXP, SEXP LambdasSEXP, SEXP ExcludeFirstKSEXP, SEXP InterceptSEXP, SEXP withBoundsSEXP, SEXP LowsSEXP, SEXP HighsSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< const arma::sp_mat& >::type X(XSEXP); + Rcpp::traits::input_parameter< const arma::vec& >::type y(ySEXP); + Rcpp::traits::input_parameter< const std::string >::type Loss(LossSEXP); + Rcpp::traits::input_parameter< const std::string >::type Penalty(PenaltySEXP); + Rcpp::traits::input_parameter< const std::string >::type Algorithm(AlgorithmSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type NnzStopNum(NnzStopNumSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type G_ncols(G_ncolsSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type G_nrows(G_nrowsSEXP); + Rcpp::traits::input_parameter< const double >::type Lambda2Max(Lambda2MaxSEXP); + Rcpp::traits::input_parameter< const double >::type Lambda2Min(Lambda2MinSEXP); + Rcpp::traits::input_parameter< const bool >::type PartialSort(PartialSortSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type MaxIters(MaxItersSEXP); + Rcpp::traits::input_parameter< const double >::type rtol(rtolSEXP); + Rcpp::traits::input_parameter< const double >::type atol(atolSEXP); + Rcpp::traits::input_parameter< const bool >::type ActiveSet(ActiveSetSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type ActiveSetNum(ActiveSetNumSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type MaxNumSwaps(MaxNumSwapsSEXP); + Rcpp::traits::input_parameter< const double >::type ScaleDownFactor(ScaleDownFactorSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type ScreenSize(ScreenSizeSEXP); + Rcpp::traits::input_parameter< const bool >::type LambdaU(LambdaUSEXP); + Rcpp::traits::input_parameter< const std::vector< std::vector > >::type Lambdas(LambdasSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type ExcludeFirstK(ExcludeFirstKSEXP); + Rcpp::traits::input_parameter< const bool >::type Intercept(InterceptSEXP); + Rcpp::traits::input_parameter< const bool >::type withBounds(withBoundsSEXP); + Rcpp::traits::input_parameter< const arma::vec& >::type Lows(LowsSEXP); + Rcpp::traits::input_parameter< const arma::vec& >::type Highs(HighsSEXP); + L0LearnFit_sparse(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs); + return R_NilValue; +END_RCPP +} +// L0LearnFit_dense +void L0LearnFit_dense(const arma::mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, const bool PartialSort, const std::size_t MaxIters, const double rtol, const double atol, const bool ActiveSet, const std::size_t ActiveSetNum, const std::size_t MaxNumSwaps, const double ScaleDownFactor, const std::size_t ScreenSize, const bool LambdaU, const std::vector< std::vector > Lambdas, const std::size_t ExcludeFirstK, const bool Intercept, const bool withBounds, const arma::vec& Lows, const arma::vec& Highs); +RcppExport SEXP _L0Learn_L0LearnFit_dense(SEXP XSEXP, SEXP ySEXP, SEXP LossSEXP, SEXP PenaltySEXP, SEXP AlgorithmSEXP, SEXP NnzStopNumSEXP, SEXP G_ncolsSEXP, SEXP G_nrowsSEXP, SEXP Lambda2MaxSEXP, SEXP Lambda2MinSEXP, SEXP PartialSortSEXP, SEXP MaxItersSEXP, SEXP rtolSEXP, SEXP atolSEXP, SEXP ActiveSetSEXP, SEXP ActiveSetNumSEXP, SEXP MaxNumSwapsSEXP, SEXP ScaleDownFactorSEXP, SEXP ScreenSizeSEXP, SEXP LambdaUSEXP, SEXP LambdasSEXP, SEXP ExcludeFirstKSEXP, SEXP InterceptSEXP, SEXP withBoundsSEXP, SEXP LowsSEXP, SEXP HighsSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP); + Rcpp::traits::input_parameter< const arma::vec& >::type y(ySEXP); + Rcpp::traits::input_parameter< const std::string >::type Loss(LossSEXP); + Rcpp::traits::input_parameter< const std::string >::type Penalty(PenaltySEXP); + Rcpp::traits::input_parameter< const std::string >::type Algorithm(AlgorithmSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type NnzStopNum(NnzStopNumSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type G_ncols(G_ncolsSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type G_nrows(G_nrowsSEXP); + Rcpp::traits::input_parameter< const double >::type Lambda2Max(Lambda2MaxSEXP); + Rcpp::traits::input_parameter< const double >::type Lambda2Min(Lambda2MinSEXP); + Rcpp::traits::input_parameter< const bool >::type PartialSort(PartialSortSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type MaxIters(MaxItersSEXP); + Rcpp::traits::input_parameter< const double >::type rtol(rtolSEXP); + Rcpp::traits::input_parameter< const double >::type atol(atolSEXP); + Rcpp::traits::input_parameter< const bool >::type ActiveSet(ActiveSetSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type ActiveSetNum(ActiveSetNumSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type MaxNumSwaps(MaxNumSwapsSEXP); + Rcpp::traits::input_parameter< const double >::type ScaleDownFactor(ScaleDownFactorSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type ScreenSize(ScreenSizeSEXP); + Rcpp::traits::input_parameter< const bool >::type LambdaU(LambdaUSEXP); + Rcpp::traits::input_parameter< const std::vector< std::vector > >::type Lambdas(LambdasSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type ExcludeFirstK(ExcludeFirstKSEXP); + Rcpp::traits::input_parameter< const bool >::type Intercept(InterceptSEXP); + Rcpp::traits::input_parameter< const bool >::type withBounds(withBoundsSEXP); + Rcpp::traits::input_parameter< const arma::vec& >::type Lows(LowsSEXP); + Rcpp::traits::input_parameter< const arma::vec& >::type Highs(HighsSEXP); + L0LearnFit_dense(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs); + return R_NilValue; +END_RCPP +} +// L0LearnCV_sparse +void L0LearnCV_sparse(const arma::sp_mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, const bool PartialSort, const std::size_t MaxIters, const double rtol, const double atol, const bool ActiveSet, const std::size_t ActiveSetNum, const std::size_t MaxNumSwaps, const double ScaleDownFactor, const std::size_t ScreenSize, const bool LambdaU, const std::vector< std::vector > Lambdas, const std::size_t nfolds, const double seed, const std::size_t ExcludeFirstK, const bool Intercept, const bool withBounds, const arma::vec& Lows, const arma::vec& Highs); +RcppExport SEXP _L0Learn_L0LearnCV_sparse(SEXP XSEXP, SEXP ySEXP, SEXP LossSEXP, SEXP PenaltySEXP, SEXP AlgorithmSEXP, SEXP NnzStopNumSEXP, SEXP G_ncolsSEXP, SEXP G_nrowsSEXP, SEXP Lambda2MaxSEXP, SEXP Lambda2MinSEXP, SEXP PartialSortSEXP, SEXP MaxItersSEXP, SEXP rtolSEXP, SEXP atolSEXP, SEXP ActiveSetSEXP, SEXP ActiveSetNumSEXP, SEXP MaxNumSwapsSEXP, SEXP ScaleDownFactorSEXP, SEXP ScreenSizeSEXP, SEXP LambdaUSEXP, SEXP LambdasSEXP, SEXP nfoldsSEXP, SEXP seedSEXP, SEXP ExcludeFirstKSEXP, SEXP InterceptSEXP, SEXP withBoundsSEXP, SEXP LowsSEXP, SEXP HighsSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< const arma::sp_mat& >::type X(XSEXP); + Rcpp::traits::input_parameter< const arma::vec& >::type y(ySEXP); + Rcpp::traits::input_parameter< const std::string >::type Loss(LossSEXP); + Rcpp::traits::input_parameter< const std::string >::type Penalty(PenaltySEXP); + Rcpp::traits::input_parameter< const std::string >::type Algorithm(AlgorithmSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type NnzStopNum(NnzStopNumSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type G_ncols(G_ncolsSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type G_nrows(G_nrowsSEXP); + Rcpp::traits::input_parameter< const double >::type Lambda2Max(Lambda2MaxSEXP); + Rcpp::traits::input_parameter< const double >::type Lambda2Min(Lambda2MinSEXP); + Rcpp::traits::input_parameter< const bool >::type PartialSort(PartialSortSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type MaxIters(MaxItersSEXP); + Rcpp::traits::input_parameter< const double >::type rtol(rtolSEXP); + Rcpp::traits::input_parameter< const double >::type atol(atolSEXP); + Rcpp::traits::input_parameter< const bool >::type ActiveSet(ActiveSetSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type ActiveSetNum(ActiveSetNumSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type MaxNumSwaps(MaxNumSwapsSEXP); + Rcpp::traits::input_parameter< const double >::type ScaleDownFactor(ScaleDownFactorSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type ScreenSize(ScreenSizeSEXP); + Rcpp::traits::input_parameter< const bool >::type LambdaU(LambdaUSEXP); + Rcpp::traits::input_parameter< const std::vector< std::vector > >::type Lambdas(LambdasSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type nfolds(nfoldsSEXP); + Rcpp::traits::input_parameter< const double >::type seed(seedSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type ExcludeFirstK(ExcludeFirstKSEXP); + Rcpp::traits::input_parameter< const bool >::type Intercept(InterceptSEXP); + Rcpp::traits::input_parameter< const bool >::type withBounds(withBoundsSEXP); + Rcpp::traits::input_parameter< const arma::vec& >::type Lows(LowsSEXP); + Rcpp::traits::input_parameter< const arma::vec& >::type Highs(HighsSEXP); + L0LearnCV_sparse(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs); + return R_NilValue; +END_RCPP +} +// L0LearnCV_dense +void L0LearnCV_dense(const arma::mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, const bool PartialSort, const std::size_t MaxIters, const double rtol, const double atol, const bool ActiveSet, const std::size_t ActiveSetNum, const std::size_t MaxNumSwaps, const double ScaleDownFactor, const std::size_t ScreenSize, const bool LambdaU, const std::vector< std::vector > Lambdas, const std::size_t nfolds, const double seed, const std::size_t ExcludeFirstK, const bool Intercept, const bool withBounds, const arma::vec& Lows, const arma::vec& Highs); +RcppExport SEXP _L0Learn_L0LearnCV_dense(SEXP XSEXP, SEXP ySEXP, SEXP LossSEXP, SEXP PenaltySEXP, SEXP AlgorithmSEXP, SEXP NnzStopNumSEXP, SEXP G_ncolsSEXP, SEXP G_nrowsSEXP, SEXP Lambda2MaxSEXP, SEXP Lambda2MinSEXP, SEXP PartialSortSEXP, SEXP MaxItersSEXP, SEXP rtolSEXP, SEXP atolSEXP, SEXP ActiveSetSEXP, SEXP ActiveSetNumSEXP, SEXP MaxNumSwapsSEXP, SEXP ScaleDownFactorSEXP, SEXP ScreenSizeSEXP, SEXP LambdaUSEXP, SEXP LambdasSEXP, SEXP nfoldsSEXP, SEXP seedSEXP, SEXP ExcludeFirstKSEXP, SEXP InterceptSEXP, SEXP withBoundsSEXP, SEXP LowsSEXP, SEXP HighsSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP); + Rcpp::traits::input_parameter< const arma::vec& >::type y(ySEXP); + Rcpp::traits::input_parameter< const std::string >::type Loss(LossSEXP); + Rcpp::traits::input_parameter< const std::string >::type Penalty(PenaltySEXP); + Rcpp::traits::input_parameter< const std::string >::type Algorithm(AlgorithmSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type NnzStopNum(NnzStopNumSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type G_ncols(G_ncolsSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type G_nrows(G_nrowsSEXP); + Rcpp::traits::input_parameter< const double >::type Lambda2Max(Lambda2MaxSEXP); + Rcpp::traits::input_parameter< const double >::type Lambda2Min(Lambda2MinSEXP); + Rcpp::traits::input_parameter< const bool >::type PartialSort(PartialSortSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type MaxIters(MaxItersSEXP); + Rcpp::traits::input_parameter< const double >::type rtol(rtolSEXP); + Rcpp::traits::input_parameter< const double >::type atol(atolSEXP); + Rcpp::traits::input_parameter< const bool >::type ActiveSet(ActiveSetSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type ActiveSetNum(ActiveSetNumSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type MaxNumSwaps(MaxNumSwapsSEXP); + Rcpp::traits::input_parameter< const double >::type ScaleDownFactor(ScaleDownFactorSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type ScreenSize(ScreenSizeSEXP); + Rcpp::traits::input_parameter< const bool >::type LambdaU(LambdaUSEXP); + Rcpp::traits::input_parameter< const std::vector< std::vector > >::type Lambdas(LambdasSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type nfolds(nfoldsSEXP); + Rcpp::traits::input_parameter< const double >::type seed(seedSEXP); + Rcpp::traits::input_parameter< const std::size_t >::type ExcludeFirstK(ExcludeFirstKSEXP); + Rcpp::traits::input_parameter< const bool >::type Intercept(InterceptSEXP); + Rcpp::traits::input_parameter< const bool >::type withBounds(withBoundsSEXP); + Rcpp::traits::input_parameter< const arma::vec& >::type Lows(LowsSEXP); + Rcpp::traits::input_parameter< const arma::vec& >::type Highs(HighsSEXP); + L0LearnCV_dense(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs); + return R_NilValue; +END_RCPP +} + +static const R_CallMethodDef CallEntries[] = { + {"_L0Learn_cor_matrix", (DL_FUNC) &_L0Learn_cor_matrix, 2}, + {"_L0Learn_L0LearnFit_sparse", (DL_FUNC) &_L0Learn_L0LearnFit_sparse, 26}, + {"_L0Learn_L0LearnFit_dense", (DL_FUNC) &_L0Learn_L0LearnFit_dense, 26}, + {"_L0Learn_L0LearnCV_sparse", (DL_FUNC) &_L0Learn_L0LearnCV_sparse, 28}, + {"_L0Learn_L0LearnCV_dense", (DL_FUNC) &_L0Learn_L0LearnCV_dense, 28}, + {NULL, NULL, 0} +}; + +RcppExport void R_init_L0Learn(DllInfo *dll) { + R_registerRoutines(dll, NULL, CallEntries, NULL, NULL); + R_useDynamicSymbols(dll, FALSE); +} diff --git a/src/Test_Interface.cpp b/R/src/Test_Interface.cpp similarity index 98% rename from src/Test_Interface.cpp rename to R/src/Test_Interface.cpp index a6e95da..b128db9 100644 --- a/src/Test_Interface.cpp +++ b/R/src/Test_Interface.cpp @@ -1,4 +1,5 @@ -#include "Test_Interface.h" +/* +#include "Test_Interface.h" // [[Rcpp::depends(RcppArmadillo)]] @@ -100,4 +101,4 @@ Rcpp::List R_matrix_center_sparse(const arma::sp_mat mat, arma::sp_mat X_normali arma::rowvec meanX = matrix_center(mat, X_normalized, intercept); return Rcpp::List::create(Rcpp::Named("mat_norm") = X_normalized, Rcpp::Named("MeanX") = meanX); -}; \ No newline at end of file +};*/ diff --git a/R/src/Test_Interface.h b/R/src/Test_Interface.h new file mode 100644 index 0000000..6cd096a --- /dev/null +++ b/R/src/Test_Interface.h @@ -0,0 +1,8 @@ +// #ifndef R_TEST_INTERFACE_H +// #define R_TEST_INTERFACE_H +// +// #include +// #include "utils.h" +// #include "BetaVector.h" +// +// #endif //R_TEST_INTERFACE_H \ No newline at end of file diff --git a/src/BetaVector.cpp b/R/src/include/BetaVector.hpp similarity index 81% rename from src/BetaVector.cpp rename to R/src/include/BetaVector.hpp index c6f5d1b..2b694f2 100644 --- a/src/BetaVector.cpp +++ b/R/src/include/BetaVector.hpp @@ -1,13 +1,20 @@ -#include "BetaVector.h" +#ifndef BETA_VECTOR_H +#define BETA_VECTOR_H +#include +#include /* * arma::vec implementation */ -std::vector nnzIndicies(const arma::vec& B){ + +using beta_vector = arma::vec; +//using beta_vector = arma::sp_mat; + +inline std::vector nnzIndicies(const arma::vec& B){ // Returns a vector of the Non Zero Indicies of B const arma::ucolvec nnzs_indicies = arma::find(B); - return arma::conv_to>::from(nnzs_indicies); + return arma::conv_to>::from(nnzs_indicies); } // std::vector nnzIndicies(const arma::sp_mat& B){ @@ -19,53 +26,53 @@ std::vector nnzIndicies(const arma::vec& B){ // { // S.push_back(it.row()); // } -// return S; +// return S; // } -std::vector nnzIndicies(const arma::vec& B, const std::size_t low){ +inline std::vector nnzIndicies(const arma::vec& B, const std::size_t low){ // Returns a vector of the Non Zero Indicies of a slice of B starting at low // This is for NoSelectK situations const arma::vec B_slice = B.subvec(low, B.n_rows-1); const arma::ucolvec nnzs_indicies = arma::find(B_slice); - return arma::conv_to>::from(nnzs_indicies); + return arma::conv_to>::from(nnzs_indicies); } // std::vector nnzIndicies(const arma::sp_mat& B, const std::size_t low){ // // Returns a vector of the Non Zero Indicies of B // std::vector S; -// -// +// +// // arma::sp_mat::const_iterator it; // const arma::sp_mat::const_iterator it_end = B.end(); -// -// +// +// // for(it = B.begin(); it != it_end; ++it) // { // if (it.row() >= low){ // S.push_back(it.row()); // } // } -// return S; +// return S; // } -std::size_t n_nonzero(const arma::vec& B){ +inline std::size_t n_nonzero(const arma::vec& B){ const arma::vec nnzs = arma::nonzeros(B); return nnzs.n_rows; - + } // std::size_t n_nonzero(const arma::sp_mat& B){ // return B.n_nonzero; -// +// // } -bool has_same_support(const arma::vec& B1, const arma::vec& B2){ +inline bool has_same_support(const arma::vec& B1, const arma::vec& B2){ if (B1.size() != B2.size()){ return false; } std::size_t n = B1.n_rows; - + bool same_support = true; for (std::size_t i = 0; i < n; i++){ same_support = same_support && ((B1.at(i) != 0) == (B2.at(i) != 0)); @@ -74,14 +81,14 @@ bool has_same_support(const arma::vec& B1, const arma::vec& B2){ } // bool has_same_support(const arma::sp_mat& B1, const arma::sp_mat& B2){ -// +// // if (B1.n_nonzero != B2.n_nonzero) { // return false; // } else { // same number of nnz and Supp is sorted // arma::sp_mat::const_iterator i1, i2; // const arma::sp_mat::const_iterator i1_end = B1.end(); -// -// +// +// // for(i1 = B1.begin(), i2 = B2.begin(); i1 != i1_end; ++i1, ++i2) // { // if(i1.row() != i2.row()) @@ -93,3 +100,4 @@ bool has_same_support(const arma::vec& B1, const arma::vec& B2){ // } // } +#endif // BETA_VECTOR_H \ No newline at end of file diff --git a/src/include/CD.h b/R/src/include/CD.hpp similarity index 99% rename from src/include/CD.h rename to R/src/include/CD.hpp index db0af06..0c142a0 100644 --- a/src/include/CD.h +++ b/R/src/include/CD.hpp @@ -1,12 +1,13 @@ #ifndef CD_H #define CD_H #include -#include "RcppArmadillo.h" -#include "BetaVector.h" -#include "FitResult.h" -#include "Params.h" -#include "Model.h" -#include "utils.h" +#include +#include +#include "BetaVector.hpp" +#include "FitResult.hpp" +#include "Params.hpp" +#include "Model.hpp" +#include "utils.hpp" constexpr double lambda1_fudge_factor = 1e-15; diff --git a/src/include/CDL0.h b/R/src/include/CDL0.hpp similarity index 97% rename from src/include/CDL0.h rename to R/src/include/CDL0.hpp index 7eda481..0e47612 100644 --- a/src/include/CDL0.h +++ b/R/src/include/CDL0.hpp @@ -1,12 +1,12 @@ #ifndef CDL0_H #define CDL0_H #include -#include "RcppArmadillo.h" -#include "CD.h" -#include "Params.h" -#include "FitResult.h" -#include "utils.h" -#include "BetaVector.h" +#include +#include "CD.hpp" +#include "Params.hpp" +#include "FitResult.hpp" +#include "utils.hpp" +#include "BetaVector.hpp" template diff --git a/src/include/CDL012.h b/R/src/include/CDL012.hpp similarity index 97% rename from src/include/CDL012.h rename to R/src/include/CDL012.hpp index 1a8f3cf..a14c11a 100644 --- a/src/include/CDL012.h +++ b/R/src/include/CDL012.hpp @@ -1,10 +1,10 @@ #ifndef CDL012_H #define CDL012_H -#include "RcppArmadillo.h" -#include "CD.h" -#include "FitResult.h" -#include "utils.h" -#include "BetaVector.h" +#include +#include "CD.hpp" +#include "FitResult.hpp" +#include "utils.hpp" +#include "BetaVector.hpp" template class CDL012 : public CD>{ diff --git a/src/include/CDL012Logistic.h b/R/src/include/CDL012Logistic.hpp similarity index 98% rename from src/include/CDL012Logistic.h rename to R/src/include/CDL012Logistic.hpp index a9a6356..29770d9 100644 --- a/src/include/CDL012Logistic.h +++ b/R/src/include/CDL012Logistic.hpp @@ -1,11 +1,11 @@ #ifndef CDL012Logistic_H #define CDL012Logistic_H -#include "RcppArmadillo.h" -#include "CD.h" -#include "FitResult.h" -#include "Params.h" -#include "utils.h" -#include "BetaVector.h" +#include +#include "CD.hpp" +#include "FitResult.hpp" +#include "Params.hpp" +#include "utils.hpp" +#include "BetaVector.hpp" template class CDL012Logistic : public CD> { diff --git a/src/include/CDL012LogisticSwaps.h b/R/src/include/CDL012LogisticSwaps.hpp similarity index 73% rename from src/include/CDL012LogisticSwaps.h rename to R/src/include/CDL012LogisticSwaps.hpp index cd098f3..d183357 100644 --- a/src/include/CDL012LogisticSwaps.h +++ b/R/src/include/CDL012LogisticSwaps.hpp @@ -1,13 +1,13 @@ #ifndef CDL012LogisticSwaps_H #define CDL012LogisticSwaps_H -#include "RcppArmadillo.h" -#include "CD.h" -#include "CDSwaps.h" -#include "CDL012Logistic.h" -#include "FitResult.h" -#include "Params.h" -#include "utils.h" -#include "BetaVector.h" +#include +#include "CD.hpp" +#include "CDSwaps.hpp" +#include "CDL012Logistic.hpp" +#include "FitResult.hpp" +#include "Params.hpp" +#include "utils.hpp" +#include "BetaVector.hpp" template class CDL012LogisticSwaps : public CDSwaps { @@ -43,8 +43,7 @@ inline double CDL012LogisticSwaps::Objective(const arma::vec & r, const beta_ template inline double CDL012LogisticSwaps::Objective() { - auto l2norm = arma::norm(this->B, 2); - return arma::sum(arma::log(1 + 1 / ExpyXB)) + this->lambda0 * n_nonzero(this->B) + this->lambda1 * arma::norm(this->B, 1) + this->lambda2 * l2norm * l2norm; + return this->Objective(ExpyXB, this->B); } #endif diff --git a/src/include/CDL012SquaredHinge.h b/R/src/include/CDL012SquaredHinge.hpp similarity index 98% rename from src/include/CDL012SquaredHinge.h rename to R/src/include/CDL012SquaredHinge.hpp index da318ca..68fa3be 100644 --- a/src/include/CDL012SquaredHinge.h +++ b/R/src/include/CDL012SquaredHinge.hpp @@ -1,11 +1,11 @@ #ifndef CDL012SquaredHinge_H #define CDL012SquaredHinge_H -#include "RcppArmadillo.h" -#include "CD.h" -#include "FitResult.h" -#include "Params.h" -#include "utils.h" -#include "BetaVector.h" +#include +#include "CD.hpp" +#include "FitResult.hpp" +#include "Params.hpp" +#include "utils.hpp" +#include "BetaVector.hpp" template class CDL012SquaredHinge : public CD> { diff --git a/src/include/CDL012SquaredHingeSwaps.h b/R/src/include/CDL012SquaredHingeSwaps.hpp similarity index 86% rename from src/include/CDL012SquaredHingeSwaps.h rename to R/src/include/CDL012SquaredHingeSwaps.hpp index fb3ccff..a639384 100644 --- a/src/include/CDL012SquaredHingeSwaps.h +++ b/R/src/include/CDL012SquaredHingeSwaps.hpp @@ -1,13 +1,13 @@ #ifndef CDL012SquredHingeSwaps_H #define CDL012SquredHingeSwaps_H -#include "RcppArmadillo.h" -#include "CD.h" -#include "CDSwaps.h" -#include "CDL012SquaredHinge.h" -#include "Params.h" -#include "FitResult.h" -#include "utils.h" -#include "BetaVector.h" +#include +#include "CD.hpp" +#include "CDSwaps.hpp" +#include "CDL012SquaredHinge.hpp" +#include "Params.hpp" +#include "FitResult.hpp" +#include "utils.hpp" +#include "BetaVector.hpp" template class CDL012SquaredHingeSwaps : public CDSwaps { diff --git a/src/include/CDL012Swaps.h b/R/src/include/CDL012Swaps.hpp similarity index 82% rename from src/include/CDL012Swaps.h rename to R/src/include/CDL012Swaps.hpp index ac322fb..5819725 100644 --- a/src/include/CDL012Swaps.h +++ b/R/src/include/CDL012Swaps.hpp @@ -1,14 +1,14 @@ #ifndef CDL012SWAPS_H #define CDL012SWAPS_H #include -#include "RcppArmadillo.h" -#include "CD.h" -#include "CDSwaps.h" -#include "CDL012.h" -#include "FitResult.h" -#include "Params.h" -#include "utils.h" -#include "BetaVector.h" +#include +#include "CD.hpp" +#include "CDSwaps.hpp" +#include "CDL012.hpp" +#include "FitResult.hpp" +#include "Params.hpp" +#include "utils.hpp" +#include "BetaVector.hpp" template class CDL012Swaps : public CDSwaps { diff --git a/src/include/CDSwaps.h b/R/src/include/CDSwaps.hpp similarity index 70% rename from src/include/CDSwaps.h rename to R/src/include/CDSwaps.hpp index b13632c..280e469 100644 --- a/src/include/CDSwaps.h +++ b/R/src/include/CDSwaps.hpp @@ -1,5 +1,5 @@ #ifndef CDSWAPS_H #define CDSWAPS_H -#include "CD.h" +#include "CD.hpp" #endif \ No newline at end of file diff --git a/src/include/FitResult.h b/R/src/include/FitResult.hpp similarity index 91% rename from src/include/FitResult.h rename to R/src/include/FitResult.hpp index b95e4f2..3000090 100644 --- a/src/include/FitResult.h +++ b/R/src/include/FitResult.hpp @@ -1,7 +1,7 @@ #ifndef FITRESULT_H #define FITRESULT_H -#include "RcppArmadillo.h" -#include "BetaVector.h" +#include +#include "BetaVector.hpp" template // Forward Reference to prevent circular dependencies class CDBase; diff --git a/src/include/Grid.h b/R/src/include/Grid.hpp similarity index 84% rename from src/include/Grid.h rename to R/src/include/Grid.hpp index 6eacfbc..bdf265d 100644 --- a/src/include/Grid.h +++ b/R/src/include/Grid.hpp @@ -3,12 +3,12 @@ #include #include #include -#include "RcppArmadillo.h" -#include "GridParams.h" -#include "FitResult.h" -#include "Grid1D.h" -#include "Grid2D.h" -#include "Normalize.h" +#include +#include "GridParams.hpp" +#include "FitResult.hpp" +#include "Grid1D.hpp" +#include "Grid2D.hpp" +#include "Normalize.hpp" template class Grid { diff --git a/src/include/Grid1D.h b/R/src/include/Grid1D.hpp similarity index 87% rename from src/include/Grid1D.h rename to R/src/include/Grid1D.hpp index 35fc2db..26c7a06 100644 --- a/src/include/Grid1D.h +++ b/R/src/include/Grid1D.hpp @@ -3,11 +3,11 @@ #include #include #include -#include "RcppArmadillo.h" -#include "Params.h" -#include "GridParams.h" -#include "FitResult.h" -#include "MakeCD.h" +#include +#include "Params.hpp" +#include "GridParams.hpp" +#include "FitResult.hpp" +#include "MakeCD.hpp" template class Grid1D { diff --git a/src/include/Grid2D.h b/R/src/include/Grid2D.hpp similarity index 84% rename from src/include/Grid2D.h rename to R/src/include/Grid2D.hpp index d7be15d..cff76e2 100644 --- a/src/include/Grid2D.h +++ b/R/src/include/Grid2D.hpp @@ -1,12 +1,12 @@ #ifndef GRID2D_H #define GRID2D_H #include -#include "RcppArmadillo.h" -#include "GridParams.h" -#include "Params.h" -#include "FitResult.h" -#include "Grid1D.h" -#include "utils.h" +#include +#include "GridParams.hpp" +#include "Params.hpp" +#include "FitResult.hpp" +#include "Grid1D.hpp" +#include "utils.hpp" template class Grid2D diff --git a/src/include/GridParams.h b/R/src/include/GridParams.hpp similarity index 92% rename from src/include/GridParams.h rename to R/src/include/GridParams.hpp index 1d2206d..9e9c242 100644 --- a/src/include/GridParams.h +++ b/R/src/include/GridParams.hpp @@ -1,7 +1,7 @@ #ifndef GRIDPARAMS_H #define GRIDPARAMS_H -#include "RcppArmadillo.h" -#include "Params.h" +#include +#include "Params.hpp" template struct GridParams diff --git a/R/src/include/L0Learn.hpp b/R/src/include/L0Learn.hpp new file mode 100644 index 0000000..6d312bf --- /dev/null +++ b/R/src/include/L0Learn.hpp @@ -0,0 +1,340 @@ +#ifndef INTERFACE_H +#define INTERFACE_H + +#include +#include +#include +#include +#include +#include "FitResult.hpp" +#include "Grid.hpp" +#include "GridParams.hpp" + +#include +#include + +// Make an external struct + +struct fitmodel +{ + const std::vector> Lambda0; + const std::vector Lambda12; + const std::vector> NnzCount; + const arma::field Beta; + const std::vector> Intercept; + const std::vector> Converged; + + fitmodel(std::vector> lambda0, + std::vector lambda12, + std::vector> nnzCount, + arma::field beta, + std::vector> intercept, + std::vector> converged): + Lambda0(std::move(lambda0)), + Lambda12(std::move(lambda12)), + NnzCount(std::move(nnzCount)), + Beta(std::move(beta)), + Intercept(std::move(intercept)), + Converged(std::move(converged)){} +}; + +struct cvfitmodel : fitmodel +{ + const arma::field CVMeans; + const arma::field CVSDs; + + cvfitmodel(std::vector> lambda0, + std::vector lambda12, + std::vector> nnzCount, + arma::field beta, + std::vector> intercept, + std::vector> converged, + arma::field cVMeans, + arma::field cVSDs) : + fitmodel(std::move(lambda0), + std::move(lambda12), + std::move(nnzCount), + std::move(beta), + std::move(intercept), + std::move(converged)), + CVMeans(std::move(cVMeans)), + CVSDs(std::move(cVSDs)){} +}; + + + +template +GridParams makeGridParams(const std::string Loss, const std::string Penalty, + const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, + const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, + const bool PartialSort, const std::size_t MaxIters, const double rtol, + const double atol, const bool ActiveSet, const std::size_t ActiveSetNum, + const std::size_t MaxNumSwaps, const double ScaleDownFactor, + const std::size_t ScreenSize, const bool LambdaU, + const std::vector< std::vector > Lambdas, + const std::size_t ExcludeFirstK, const bool Intercept, + const bool withBounds, const arma::vec &Lows, const arma::vec &Highs){ + GridParams PG; + PG.NnzStopNum = NnzStopNum; + PG.G_ncols = G_ncols; + PG.G_nrows = G_nrows; + PG.Lambda2Max = Lambda2Max; + PG.Lambda2Min = Lambda2Min; + PG.LambdaMinFactor = Lambda2Min; // + PG.PartialSort = PartialSort; + PG.ScaleDownFactor = ScaleDownFactor; + PG.LambdaU = LambdaU; + PG.LambdasGrid = Lambdas; + PG.Lambdas = Lambdas[0]; // to handle the case of L0 (i.e., Grid1D) + PG.intercept = Intercept; + + Params P; + PG.P = P; + PG.P.MaxIters = MaxIters; + PG.P.rtol = rtol; + PG.P.atol = atol; + PG.P.ActiveSet = ActiveSet; + PG.P.ActiveSetNum = ActiveSetNum; + PG.P.MaxNumSwaps = MaxNumSwaps; + PG.P.ScreenSize = ScreenSize; + PG.P.NoSelectK = ExcludeFirstK; + PG.P.intercept = Intercept; + PG.P.withBounds = withBounds; + PG.P.Lows = Lows; + PG.P.Highs = Highs; + + if (Loss == "SquaredError") { + PG.P.Specs.SquaredError = true; + } else if (Loss == "Logistic") { + PG.P.Specs.Logistic = true; + PG.P.Specs.Classification = true; + } else if (Loss == "SquaredHinge") { + PG.P.Specs.SquaredHinge = true; + PG.P.Specs.Classification = true; + } + + if (Algorithm == "CD") { + PG.P.Specs.CD = true; + } else if (Algorithm == "CDPSI") { + PG.P.Specs.PSI = true; + } + + if (Penalty == "L0") { + PG.P.Specs.L0 = true; + } else if (Penalty == "L0L2") { + PG.P.Specs.L0L2 = true; + } else if (Penalty == "L0L1") { + PG.P.Specs.L0L1 = true; + } + return PG; +} + + +template +void L0LearnFit(const T& X, const arma::vec& y, const std::string Loss, const std::string Penalty, + const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, + const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, + const bool PartialSort, const std::size_t MaxIters, const double rtol, const double atol, + const bool ActiveSet, const std::size_t ActiveSetNum, const std::size_t MaxNumSwaps, + const double ScaleDownFactor, const std::size_t ScreenSize, const bool LambdaU, + const std::vector< std::vector > Lambdas, const std::size_t ExcludeFirstK, + const bool Intercept, const bool withBounds, const arma::vec &Lows, + const arma::vec &Highs){ + + Rcpp::Rcout << "makeGridParams Start\n"; + std::this_thread::sleep_for(std::chrono::milliseconds(1000)); + + GridParams PG = makeGridParams(Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, + Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, + ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, + LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs); + Rcpp::Rcout << "makeGridParams End\n"; + Rcpp::Rcout << "makeGridParams Grid(...) start\n"; + std::this_thread::sleep_for(std::chrono::milliseconds(1000)); + + Grid G(X, y, PG); + Rcpp::Rcout << "makeGridParams Grid(...)\n"; + Rcpp::Rcout << "makeGridParams Grid.fit() start\n"; + std::this_thread::sleep_for(std::chrono::milliseconds(1000)); + G.Fit(); + + Rcpp::Rcout << "makeGridParams Grid.fit() end\n"; + std::this_thread::sleep_for(std::chrono::milliseconds(1000)); + + + // Next Construct the list of Sparse Beta Matrices. + + auto p = X.n_cols; + arma::field Bs(G.Lambda12.size()); + + for (std::size_t i=0; i +cvfitmodel L0LearnCV(const T& X, const arma::vec& y, const std::string Loss, + const std::string Penalty, const std::string Algorithm, + const unsigned int NnzStopNum, const unsigned int G_ncols, + const unsigned int G_nrows, const double Lambda2Max, + const double Lambda2Min, const bool PartialSort, + const unsigned int MaxIters, const double rtol, + const double atol, const bool ActiveSet, + const unsigned int ActiveSetNum, + const unsigned int MaxNumSwaps, const double ScaleDownFactor, + const unsigned int ScreenSize, const bool LambdaU, + const std::vector< std::vector > Lambdas, + const unsigned int nfolds, const double seed, + const unsigned int ExcludeFirstK, const bool Intercept, + const bool withBounds, const arma::vec &Lows, + const arma::vec &Highs){ + + GridParams PG = makeGridParams(Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, + Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, + ActiveSet,ActiveSetNum, MaxNumSwaps, ScaleDownFactor, + ScreenSize,LambdaU, Lambdas, ExcludeFirstK, Intercept, + withBounds, Lows, Highs); + + Grid G(X, y, PG); + G.Fit(); + + // Next Construct the list of Sparse Beta Matrices. + + auto p = X.n_cols; + auto n = X.n_rows; + arma::field Bs(G.Lambda12.size()); + + for (std::size_t i=0; i >(G.size()); + //Intercepts = std::vector< std::vector >(G.size()); + + std::size_t Ngamma = G.Lambda12.size(); + + //std::vector< arma::mat > CVError (G.Solutions.size()); + arma::field< arma::mat > CVError (G.Solutions.size()); + + for (std::size_t i=0; i(0, X.n_rows-1, X.n_rows); + + arma::uvec indices = arma::shuffle(a); + + int samplesperfold = std::ceil(n/double(nfolds)); + int samplesinlastfold = samplesperfold - (samplesperfold*nfolds - n); + + std::vector fullindices(X.n_rows); + std::iota(fullindices.begin(), fullindices.end(), 0); + + + for (std::size_t j=0; j validationindices; + if (j < nfolds-1) + validationindices.resize(samplesperfold); + else + validationindices.resize(samplesinlastfold); + + std::iota(validationindices.begin(), validationindices.end(), samplesperfold*j); + + std::vector trainingindices; + + std::set_difference(fullindices.begin(), fullindices.end(), validationindices.begin(), validationindices.end(), + std::inserter(trainingindices, trainingindices.begin())); + + + // validationindicesarma contains the randomly permuted validation indices as a uvec + arma::uvec validationindicesarma; + arma::uvec validationindicestemp = arma::conv_to< arma::uvec >::from(validationindices); + validationindicesarma = indices.elem(validationindicestemp); + + // trainingindicesarma is similar to validationindicesarma but for training + arma::uvec trainingindicesarma; + + arma::uvec trainingindicestemp = arma::conv_to< arma::uvec >::from(trainingindices); + + + trainingindicesarma = indices.elem(trainingindicestemp); + + + T Xtraining = matrix_rows_get(X, trainingindicesarma); + + arma::mat ytraining = y.elem(trainingindicesarma); + + T Xvalidation = matrix_rows_get(X, validationindicesarma); + + arma::mat yvalidation = y.elem(validationindicesarma); + + PG.LambdaU = true; + PG.XtrAvailable = false; // reset XtrAvailable since its changed upon every call + PG.LambdasGrid = G.Lambda0; + PG.NnzStopNum = p+1; // remove any constraints on the supp size when fitting over the cv folds // +1 is imp to avoid =p edge case + if (PG.P.Specs.L0 == true){ + PG.Lambdas = PG.LambdasGrid[0]; + } + Grid Gtraining(Xtraining, ytraining, PG); + Gtraining.Fit(); + + for (std::size_t i=0; i 0); + CVError[i](k,j) = arma::sum(onemyxb.elem(indices) % onemyxb.elem(indices)) / yvalidation.n_rows; + } + } + } + } + + arma::field CVMeans(Ngamma); + arma::field CVSDs(Ngamma); + + for (std::size_t i=0; i +#include "Params.hpp" +#include "CD.hpp" +#include "CDL0.hpp" +#include "CDL012.hpp" +#include "CDL012Swaps.hpp" +#include "CDL012Logistic.hpp" +#include "CDL012SquaredHinge.hpp" +#include "CDL012LogisticSwaps.hpp" +#include "CDL012SquaredHingeSwaps.hpp" template diff --git a/src/include/Model.h b/R/src/include/Model.hpp similarity index 100% rename from src/include/Model.h rename to R/src/include/Model.hpp diff --git a/src/include/Normalize.h b/R/src/include/Normalize.hpp similarity index 96% rename from src/include/Normalize.h rename to R/src/include/Normalize.hpp index 241b89e..12aa665 100644 --- a/src/include/Normalize.h +++ b/R/src/include/Normalize.hpp @@ -2,9 +2,9 @@ #define NORMALIZE_H #include -#include "RcppArmadillo.h" -#include "utils.h" -#include "BetaVector.h" +#include +#include "utils.hpp" +#include "BetaVector.hpp" std::tuple DeNormalize(beta_vector & B_scaled, arma::vec & BetaMultiplier, diff --git a/src/include/Params.h b/R/src/include/Params.hpp similarity index 93% rename from src/include/Params.h rename to R/src/include/Params.hpp index ec583c7..34f970c 100644 --- a/src/include/Params.h +++ b/R/src/include/Params.hpp @@ -1,9 +1,9 @@ #ifndef PARAMS_H #define PARAMS_H #include -#include "RcppArmadillo.h" -#include "Model.h" -#include "BetaVector.h" +#include +#include "Model.hpp" +#include "BetaVector.hpp" template struct Params { diff --git a/src/include/utils.h b/R/src/include/utils.hpp similarity index 51% rename from src/include/utils.h rename to R/src/include/utils.hpp index 167a27d..44eaafc 100644 --- a/src/include/utils.h +++ b/R/src/include/utils.hpp @@ -1,8 +1,8 @@ -#ifndef L0LEARN_UTILS_H -#define L0LEARN_UTILS_H +#ifndef L0LEARN_UTILS_HPP +#define L0LEARN_UTILS_HPP #include -#include "RcppArmadillo.h" -#include "BetaVector.h" +#include +#include "BetaVector.hpp" template @@ -15,11 +15,6 @@ inline T clamp(T x, T low, T high) { return x; } -void clamp_by_vector(arma::vec &B, const arma::vec& lows, const arma::vec& highs); - -void clamp_by_vector(arma::sp_mat &B, const arma::vec& lows, const arma::vec& highs); - - template arma::vec inline matrix_column_get(const arma::mat &mat, T1 col){ return mat.unsafe_col(col); @@ -120,12 +115,102 @@ arma::vec inline matrix_column_mult(const arma::sp_mat &mat, T1 col, const T2 &u return matrix_column_get(mat, col)*u; } -arma::rowvec matrix_normalize(arma::sp_mat &mat_norm); +void inline clamp_by_vector(arma::vec &B, const arma::vec& lows, const arma::vec& highs){ + const std::size_t n = B.n_rows; + for (std::size_t i = 0; i < n; i++){ + B.at(i) = clamp(B.at(i), lows.at(i), highs.at(i)); + } +} + +// void clamp_by_vector(arma::sp_mat &B, const arma::vec& lows, const arma::vec& highs){ +// // See above implementation without filter for error. +// auto begin = B.begin(); +// auto end = B.end(); +// +// std::vector inds; +// for (; begin != end; ++begin) +// inds.push_back(begin.row()); +// +// auto n = B.size(); +// inds.erase(std::remove_if(inds.begin(), +// inds.end(), +// [n](size_t x){return (x > n) && (x < 0);}), +// inds.end()); +// for (auto& it : inds) { +// double B_item = B(it, 0); +// const double low = lows(it); +// const double high = highs(it); +// B(it, 0) = clamp(B_item, low, high); +// } +// } + +arma::rowvec inline matrix_normalize(arma::sp_mat &mat_norm){ + auto p = mat_norm.n_cols; + arma::rowvec scaleX = arma::zeros(p); // will contain the l2norm of every col + + for (auto col = 0; col < p; col++){ + double l2norm = arma::norm(matrix_column_get(mat_norm, col), 2); + scaleX(col) = l2norm; + } + + scaleX.replace(0, -1); + + for (auto col = 0; col < p; col++){ + arma::sp_mat::col_iterator begin = mat_norm.begin_col(col); + arma::sp_mat::col_iterator end = mat_norm.end_col(col); + for (; begin != end; ++begin) + (*begin) = (*begin)/scaleX(col); + } + + if (mat_norm.has_nan()) + mat_norm.replace(arma::datum::nan, 0); // can handle numerical instabilities. + + return scaleX; +} + +arma::rowvec inline matrix_normalize(arma::mat& mat_norm){ + + auto p = mat_norm.n_cols; + arma::rowvec scaleX = arma::zeros(p); // will contain the l2norm of every col + + for (auto col = 0; col < p; col++) { + double l2norm = arma::norm(matrix_column_get(mat_norm, col), 2); + scaleX(col) = l2norm; + } -arma::rowvec matrix_normalize(arma::mat &mat_norm); + scaleX.replace(0, -1); + mat_norm.each_row() /= scaleX; -arma::rowvec matrix_center(const arma::mat& X, arma::mat& X_normalized, bool intercept); + if (mat_norm.has_nan()){ + mat_norm.replace(arma::datum::nan, 0); // can handle numerical instabilities. + } + + return scaleX; +} + +arma::rowvec inline matrix_center(const arma::mat& X, arma::mat& X_normalized, + bool intercept){ + auto p = X.n_cols; + arma::rowvec meanX; + + if (intercept){ + meanX = arma::mean(X, 0); + X_normalized = X.each_row() - meanX; + } else { + meanX = arma::zeros(p); + X_normalized = arma::mat(X); + } + + return meanX; +} + +arma::rowvec inline matrix_center(const arma::sp_mat& X, arma::sp_mat& X_normalized, + bool intercept){ + auto p = X.n_cols; + arma::rowvec meanX = arma::zeros(p); + X_normalized = arma::sp_mat(X); + return meanX; +} -arma::rowvec matrix_center(const arma::sp_mat& X, arma::sp_mat& X_normalized, bool intercept); -#endif //L0LEARN_UTILS_H \ No newline at end of file +#endif //L0LEARN_UTILS_HPP \ No newline at end of file diff --git a/tests/testthat.R b/R/tests/testthat.R similarity index 100% rename from tests/testthat.R rename to R/tests/testthat.R diff --git a/tests/testthat/test-L0Learn_accuracy.R b/R/tests/testthat/test-L0Learn_accuracy.R similarity index 100% rename from tests/testthat/test-L0Learn_accuracy.R rename to R/tests/testthat/test-L0Learn_accuracy.R diff --git a/tests/testthat/test-L0Learn_gen.R b/R/tests/testthat/test-L0Learn_gen.R similarity index 100% rename from tests/testthat/test-L0Learn_gen.R rename to R/tests/testthat/test-L0Learn_gen.R diff --git a/tests/testthat/test_L0Learn.R b/R/tests/testthat/test_L0Learn.R similarity index 100% rename from tests/testthat/test_L0Learn.R rename to R/tests/testthat/test_L0Learn.R diff --git a/tests/testthat/test_L0Learn_bounds.R b/R/tests/testthat/test_L0Learn_bounds.R similarity index 100% rename from tests/testthat/test_L0Learn_bounds.R rename to R/tests/testthat/test_L0Learn_bounds.R diff --git a/tests/testthat/test_L0Learn_highcorr.R b/R/tests/testthat/test_L0Learn_highcorr.R similarity index 100% rename from tests/testthat/test_L0Learn_highcorr.R rename to R/tests/testthat/test_L0Learn_highcorr.R diff --git a/tests/testthat/test_L0Learn_intercept.R b/R/tests/testthat/test_L0Learn_intercept.R similarity index 100% rename from tests/testthat/test_L0Learn_intercept.R rename to R/tests/testthat/test_L0Learn_intercept.R diff --git a/tests/testthat/test_L0Learn_usergrids.R b/R/tests/testthat/test_L0Learn_usergrids.R similarity index 100% rename from tests/testthat/test_L0Learn_usergrids.R rename to R/tests/testthat/test_L0Learn_usergrids.R diff --git a/tests/testthat/test_L0Learn_utils.R b/R/tests/testthat/test_L0Learn_utils.R similarity index 100% rename from tests/testthat/test_L0Learn_utils.R rename to R/tests/testthat/test_L0Learn_utils.R diff --git a/vignettes/L0Learn-vignette.Rmd b/R/vignettes/L0Learn-vignette.Rmd similarity index 100% rename from vignettes/L0Learn-vignette.Rmd rename to R/vignettes/L0Learn-vignette.Rmd diff --git a/vignettes/profile/L0Learn_Profile.R b/R/vignettes/profile/L0Learn_Profile.R similarity index 100% rename from vignettes/profile/L0Learn_Profile.R rename to R/vignettes/profile/L0Learn_Profile.R diff --git a/vignettes/profile/L0Learn_Profile_Install.R b/R/vignettes/profile/L0Learn_Profile_Install.R similarity index 100% rename from vignettes/profile/L0Learn_Profile_Install.R rename to R/vignettes/profile/L0Learn_Profile_Install.R diff --git a/vignettes/profile/L0Learn_Profile_Run.R b/R/vignettes/profile/L0Learn_Profile_Run.R similarity index 100% rename from vignettes/profile/L0Learn_Profile_Run.R rename to R/vignettes/profile/L0Learn_Profile_Run.R diff --git a/vignettes/profile/L0Learn_Profile_Run.py b/R/vignettes/profile/L0Learn_Profile_Run.py similarity index 100% rename from vignettes/profile/L0Learn_Profile_Run.py rename to R/vignettes/profile/L0Learn_Profile_Run.py diff --git a/vignettes/profile/ProfilePlotting.ipynb b/R/vignettes/profile/ProfilePlotting.ipynb similarity index 100% rename from vignettes/profile/ProfilePlotting.ipynb rename to R/vignettes/profile/ProfilePlotting.ipynb diff --git a/src/CDL012LogisticSwaps.cpp b/src/CDL012LogisticSwaps.cpp index 75de90f..29dad24 100644 --- a/src/CDL012LogisticSwaps.cpp +++ b/src/CDL012LogisticSwaps.cpp @@ -1,4 +1,4 @@ -#include "CDL012LogisticSwaps.h" +#include "CDL012LogisticSwaps.hpp" template CDL012LogisticSwaps::CDL012LogisticSwaps(const T& Xi, const arma::vec& yi, const Params& Pi) : CDSwaps(Xi, yi, Pi) { diff --git a/src/CDL012SquaredHingeSwaps.cpp b/src/CDL012SquaredHingeSwaps.cpp index c24ba82..0f14d11 100644 --- a/src/CDL012SquaredHingeSwaps.cpp +++ b/src/CDL012SquaredHingeSwaps.cpp @@ -1,4 +1,4 @@ -#include "CDL012SquaredHingeSwaps.h" +#include "CDL012SquaredHingeSwaps.hpp" template CDL012SquaredHingeSwaps::CDL012SquaredHingeSwaps(const T& Xi, const arma::vec& yi, const Params& Pi) : CDSwaps(Xi, yi, Pi) { diff --git a/src/CDL012Swaps.cpp b/src/CDL012Swaps.cpp index 246ec4c..4fe97ed 100644 --- a/src/CDL012Swaps.cpp +++ b/src/CDL012Swaps.cpp @@ -1,4 +1,4 @@ -#include "CDL012Swaps.h" +#include "CDL012Swaps.hpp" template CDL012Swaps::CDL012Swaps(const T& Xi, const arma::vec& yi, const Params& Pi) : CDSwaps(Xi, yi, Pi) {} diff --git a/src/Grid.cpp b/src/Grid.cpp index 79d430b..53af1fa 100644 --- a/src/Grid.cpp +++ b/src/Grid.cpp @@ -1,4 +1,4 @@ -#include "Grid.h" +#include "Grid.hpp" // Assumes PG.P.Specs have been already set template @@ -44,12 +44,8 @@ void Grid::Fit() { Lambda0[i].push_back(g->ModelParams[0]); NnzCount[i].push_back(n_nonzero(g->B)); - - if (g->IterNum != PG.P.MaxIters){ - Converged[i].push_back(true); - } else { - Converged[i].push_back(false); - } + + Converged[i].push_back(g->IterNum != PG.P.MaxIters); beta_vector B_unscaled; double b0; diff --git a/src/Grid1D.cpp b/src/Grid1D.cpp index 59555b4..397a1b8 100644 --- a/src/Grid1D.cpp +++ b/src/Grid1D.cpp @@ -1,4 +1,4 @@ -#include "Grid1D.h" +#include "Grid1D.hpp" template Grid1D::Grid1D(const T& Xi, const arma::vec& yi, const GridParams& PG) { @@ -121,7 +121,7 @@ std::vector>> Grid1D::Fit() { bool currentskip = false; // current grid point should be skipped for (std::size_t i = 0; i < G_ncols; ++i) { - Rcpp::checkUserInterrupt(); + // Rcpp::checkUserInterrupt(); // Rcpp::Rcout << "Grid1D: " << i << "\n"; FitResult * prevresult = new FitResult; // prevresult is ptr to the prev result object //std::unique_ptr prevresult; diff --git a/src/Grid2D.cpp b/src/Grid2D.cpp index ec2c55e..56c98df 100644 --- a/src/Grid2D.cpp +++ b/src/Grid2D.cpp @@ -1,4 +1,4 @@ -#include "Grid2D.h" +#include "Grid2D.hpp" template Grid2D::Grid2D(const T& Xi, const arma::vec& yi, const GridParams& PGi) diff --git a/src/Interface.cpp b/src/Interface.cpp deleted file mode 100644 index 07edc03..0000000 --- a/src/Interface.cpp +++ /dev/null @@ -1,376 +0,0 @@ -#include "Interface.h" -#include "GridParams.h" -#include "RcppArmadillo.h" -#include "Grid.h" -#include "utils.h" -// [[Rcpp::depends(RcppArmadillo)]] - -template -GridParams makeGridParams(const std::string Loss, const std::string Penalty, - const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, - const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, - const bool PartialSort, const std::size_t MaxIters, const double rtol, - const double atol, const bool ActiveSet, const std::size_t ActiveSetNum, - const std::size_t MaxNumSwaps, const double ScaleDownFactor, - const std::size_t ScreenSize, const bool LambdaU, - const std::vector< std::vector > Lambdas, - const std::size_t ExcludeFirstK, const bool Intercept, - const bool withBounds, const arma::vec &Lows, const arma::vec &Highs){ - GridParams PG; - PG.NnzStopNum = NnzStopNum; - PG.G_ncols = G_ncols; - PG.G_nrows = G_nrows; - PG.Lambda2Max = Lambda2Max; - PG.Lambda2Min = Lambda2Min; - PG.LambdaMinFactor = Lambda2Min; // - PG.PartialSort = PartialSort; - PG.ScaleDownFactor = ScaleDownFactor; - PG.LambdaU = LambdaU; - PG.LambdasGrid = Lambdas; - PG.Lambdas = Lambdas[0]; // to handle the case of L0 (i.e., Grid1D) - PG.intercept = Intercept; - - Params P; - PG.P = P; - PG.P.MaxIters = MaxIters; - PG.P.rtol = rtol; - PG.P.atol = atol; - PG.P.ActiveSet = ActiveSet; - PG.P.ActiveSetNum = ActiveSetNum; - PG.P.MaxNumSwaps = MaxNumSwaps; - PG.P.ScreenSize = ScreenSize; - PG.P.NoSelectK = ExcludeFirstK; - PG.P.intercept = Intercept; - PG.P.withBounds = withBounds; - PG.P.Lows = Lows; - PG.P.Highs = Highs; - - if (Loss == "SquaredError") { - PG.P.Specs.SquaredError = true; - } else if (Loss == "Logistic") { - PG.P.Specs.Logistic = true; - PG.P.Specs.Classification = true; - } else if (Loss == "SquaredHinge") { - PG.P.Specs.SquaredHinge = true; - PG.P.Specs.Classification = true; - } - - if (Algorithm == "CD") { - PG.P.Specs.CD = true; - } else if (Algorithm == "CDPSI") { - PG.P.Specs.PSI = true; - } - - if (Penalty == "L0") { - PG.P.Specs.L0 = true; - } else if (Penalty == "L0L2") { - PG.P.Specs.L0L2 = true; - } else if (Penalty == "L0L1") { - PG.P.Specs.L0L1 = true; - } - return PG; -} - - -template -Rcpp::List _L0LearnFit(const T& X, const arma::vec& y, const std::string Loss, const std::string Penalty, - const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, - const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, - const bool PartialSort, const std::size_t MaxIters, const double rtol, const double atol, - const bool ActiveSet, const std::size_t ActiveSetNum, const std::size_t MaxNumSwaps, - const double ScaleDownFactor, const std::size_t ScreenSize, const bool LambdaU, - const std::vector< std::vector > Lambdas, const std::size_t ExcludeFirstK, - const bool Intercept, const bool withBounds, const arma::vec &Lows, - const arma::vec &Highs){ - - GridParams PG = makeGridParams(Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, - Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, - ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, - LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs); - - Grid G(X, y, PG); - G.Fit(); - - std::string FirstParameter = "lambda"; - std::string SecondParameter = "gamma"; - - // Next Construct the list of Sparse Beta Matrices. - - auto p = X.n_cols; - arma::field Bs(G.Lambda12.size()); - - for (std::size_t i=0; i -Rcpp::List _L0LearnCV(const T& X, const arma::vec& y, const std::string Loss, - const std::string Penalty, const std::string Algorithm, - const unsigned int NnzStopNum, const unsigned int G_ncols, - const unsigned int G_nrows, const double Lambda2Max, - const double Lambda2Min, const bool PartialSort, - const unsigned int MaxIters, const double rtol, - const double atol, const bool ActiveSet, - const unsigned int ActiveSetNum, - const unsigned int MaxNumSwaps, const double ScaleDownFactor, - const unsigned int ScreenSize, const bool LambdaU, - const std::vector< std::vector > Lambdas, - const unsigned int nfolds, const double seed, - const unsigned int ExcludeFirstK, const bool Intercept, - const bool withBounds, const arma::vec &Lows, - const arma::vec &Highs){ - - GridParams PG = makeGridParams(Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, - Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, - ActiveSet,ActiveSetNum, MaxNumSwaps, ScaleDownFactor, - ScreenSize,LambdaU, Lambdas, ExcludeFirstK, Intercept, - withBounds, Lows, Highs); - - Grid G(X, y, PG); - G.Fit(); - - std::string FirstParameter = "lambda"; - std::string SecondParameter = "gamma"; - - // Next Construct the list of Sparse Beta Matrices. - - auto p = X.n_cols; - auto n = X.n_rows; - arma::field Bs(G.Lambda12.size()); - - for (std::size_t i=0; i >(G.size()); - //Intercepts = std::vector< std::vector >(G.size()); - - std::size_t Ngamma = G.Lambda12.size(); - - //std::vector< arma::mat > CVError (G.Solutions.size()); - arma::field< arma::mat > CVError (G.Solutions.size()); - - for (std::size_t i=0; i(0, X.n_rows-1, X.n_rows); - - arma::uvec indices = arma::shuffle(a); - - int samplesperfold = std::ceil(n/double(nfolds)); - int samplesinlastfold = samplesperfold - (samplesperfold*nfolds - n); - - std::vector fullindices(X.n_rows); - std::iota(fullindices.begin(), fullindices.end(), 0); - - - for (std::size_t j=0; j validationindices; - if (j < nfolds-1) - validationindices.resize(samplesperfold); - else - validationindices.resize(samplesinlastfold); - - std::iota(validationindices.begin(), validationindices.end(), samplesperfold*j); - - std::vector trainingindices; - - std::set_difference(fullindices.begin(), fullindices.end(), validationindices.begin(), validationindices.end(), - std::inserter(trainingindices, trainingindices.begin())); - - - // validationindicesarma contains the randomly permuted validation indices as a uvec - arma::uvec validationindicesarma; - arma::uvec validationindicestemp = arma::conv_to< arma::uvec >::from(validationindices); - validationindicesarma = indices.elem(validationindicestemp); - - // trainingindicesarma is similar to validationindicesarma but for training - arma::uvec trainingindicesarma; - - arma::uvec trainingindicestemp = arma::conv_to< arma::uvec >::from(trainingindices); - - - trainingindicesarma = indices.elem(trainingindicestemp); - - - T Xtraining = matrix_rows_get(X, trainingindicesarma); - - arma::mat ytraining = y.elem(trainingindicesarma); - - T Xvalidation = matrix_rows_get(X, validationindicesarma); - - arma::mat yvalidation = y.elem(validationindicesarma); - - PG.LambdaU = true; - PG.XtrAvailable = false; // reset XtrAvailable since its changed upon every call - PG.LambdasGrid = G.Lambda0; - PG.NnzStopNum = p+1; // remove any constraints on the supp size when fitting over the cv folds // +1 is imp to avoid =p edge case - if (PG.P.Specs.L0 == true){ - PG.Lambdas = PG.LambdasGrid[0]; - } - Grid Gtraining(Xtraining, ytraining, PG); - Gtraining.Fit(); - - for (std::size_t i=0; i 0); - CVError[i](k,j) = arma::sum(onemyxb.elem(indices) % onemyxb.elem(indices)) / yvalidation.n_rows; - } - } - } - } - - arma::field CVMeans(Ngamma); - arma::field CVSDs(Ngamma); - - for (std::size_t i=0; i > Lambdas, - const std::size_t ExcludeFirstK, const bool Intercept, - const bool withBounds, const arma::vec &Lows, const arma::vec &Highs) { - - return _L0LearnFit(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, - PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, - Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs); -} - - -// [[Rcpp::export]] -Rcpp::List L0LearnFit_dense(const arma::mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, - const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, - const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, - const bool PartialSort, const std::size_t MaxIters, const double rtol, - const double atol, const bool ActiveSet, const std::size_t ActiveSetNum, - const std::size_t MaxNumSwaps, const double ScaleDownFactor, - const std::size_t ScreenSize, const bool LambdaU, - const std::vector< std::vector > Lambdas, - const std::size_t ExcludeFirstK, const bool Intercept, - const bool withBounds, const arma::vec &Lows, const arma::vec &Highs) { - - return _L0LearnFit(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, - PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, - Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs); -} - - -// [[Rcpp::export]] -Rcpp::List L0LearnCV_sparse(const arma::sp_mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, - const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, - const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, - const bool PartialSort, const std::size_t MaxIters, const double rtol, const double atol, - const bool ActiveSet, const std::size_t ActiveSetNum, const std::size_t MaxNumSwaps, - const double ScaleDownFactor, const std::size_t ScreenSize, const bool LambdaU, - const std::vector< std::vector > Lambdas, const std::size_t nfolds, - const double seed, const std::size_t ExcludeFirstK, const bool Intercept, - const bool withBounds, const arma::vec &Lows, const arma::vec &Highs){ - - return _L0LearnCV(X, y, Loss, Penalty, - Algorithm, NnzStopNum, G_ncols, G_nrows, - Lambda2Max, Lambda2Min, PartialSort, - MaxIters, rtol,atol, ActiveSet, - ActiveSetNum, MaxNumSwaps, - ScaleDownFactor, ScreenSize, LambdaU, Lambdas, - nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs); -} - -// [[Rcpp::export]] -Rcpp::List L0LearnCV_dense(const arma::mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, - const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, - const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, - const bool PartialSort, const std::size_t MaxIters, const double rtol, const double atol, - const bool ActiveSet, const std::size_t ActiveSetNum, const std::size_t MaxNumSwaps, - const double ScaleDownFactor, const std::size_t ScreenSize, const bool LambdaU, - const std::vector< std::vector > Lambdas, const std::size_t nfolds, - const double seed, const std::size_t ExcludeFirstK, const bool Intercept, - const bool withBounds, const arma::vec &Lows, const arma::vec &Highs){ - - return _L0LearnCV(X, y, Loss, Penalty, - Algorithm, NnzStopNum, G_ncols, G_nrows, - Lambda2Max, Lambda2Min, PartialSort, - MaxIters, rtol,atol, ActiveSet, - ActiveSetNum, MaxNumSwaps, - ScaleDownFactor, ScreenSize, LambdaU, Lambdas, - nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs); -} - -// [[Rcpp::export]] -Rcpp::NumericMatrix cor_matrix(const int p, const double base_cor) { - Rcpp::NumericMatrix cor(p, p); - for (int i = 0; i < p; i++){ - for (int j = 0; j < p; j++){ - cor(i, j) = std::pow(base_cor, std::abs(i - j)); - } - } - return cor; -} - diff --git a/src/Normalize.cpp b/src/Normalize.cpp index ac9a055..8b1e6f6 100644 --- a/src/Normalize.cpp +++ b/src/Normalize.cpp @@ -1,4 +1,4 @@ -#include "Normalize.h" +#include "Normalize.hpp" std::tuple DeNormalize(beta_vector & B_scaled, arma::vec & BetaMultiplier, diff --git a/src/RcppExports.cpp b/src/RcppExports.cpp deleted file mode 100644 index d9470a7..0000000 --- a/src/RcppExports.cpp +++ /dev/null @@ -1,418 +0,0 @@ -// Generated by using Rcpp::compileAttributes() -> do not edit by hand -// Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393 - -#include -#include - -using namespace Rcpp; - -// L0LearnFit_sparse -Rcpp::List L0LearnFit_sparse(const arma::sp_mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, const bool PartialSort, const std::size_t MaxIters, const double rtol, const double atol, const bool ActiveSet, const std::size_t ActiveSetNum, const std::size_t MaxNumSwaps, const double ScaleDownFactor, const std::size_t ScreenSize, const bool LambdaU, const std::vector< std::vector > Lambdas, const std::size_t ExcludeFirstK, const bool Intercept, const bool withBounds, const arma::vec& Lows, const arma::vec& Highs); -RcppExport SEXP _L0Learn_L0LearnFit_sparse(SEXP XSEXP, SEXP ySEXP, SEXP LossSEXP, SEXP PenaltySEXP, SEXP AlgorithmSEXP, SEXP NnzStopNumSEXP, SEXP G_ncolsSEXP, SEXP G_nrowsSEXP, SEXP Lambda2MaxSEXP, SEXP Lambda2MinSEXP, SEXP PartialSortSEXP, SEXP MaxItersSEXP, SEXP rtolSEXP, SEXP atolSEXP, SEXP ActiveSetSEXP, SEXP ActiveSetNumSEXP, SEXP MaxNumSwapsSEXP, SEXP ScaleDownFactorSEXP, SEXP ScreenSizeSEXP, SEXP LambdaUSEXP, SEXP LambdasSEXP, SEXP ExcludeFirstKSEXP, SEXP InterceptSEXP, SEXP withBoundsSEXP, SEXP LowsSEXP, SEXP HighsSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const arma::sp_mat& >::type X(XSEXP); - Rcpp::traits::input_parameter< const arma::vec& >::type y(ySEXP); - Rcpp::traits::input_parameter< const std::string >::type Loss(LossSEXP); - Rcpp::traits::input_parameter< const std::string >::type Penalty(PenaltySEXP); - Rcpp::traits::input_parameter< const std::string >::type Algorithm(AlgorithmSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type NnzStopNum(NnzStopNumSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type G_ncols(G_ncolsSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type G_nrows(G_nrowsSEXP); - Rcpp::traits::input_parameter< const double >::type Lambda2Max(Lambda2MaxSEXP); - Rcpp::traits::input_parameter< const double >::type Lambda2Min(Lambda2MinSEXP); - Rcpp::traits::input_parameter< const bool >::type PartialSort(PartialSortSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type MaxIters(MaxItersSEXP); - Rcpp::traits::input_parameter< const double >::type rtol(rtolSEXP); - Rcpp::traits::input_parameter< const double >::type atol(atolSEXP); - Rcpp::traits::input_parameter< const bool >::type ActiveSet(ActiveSetSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type ActiveSetNum(ActiveSetNumSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type MaxNumSwaps(MaxNumSwapsSEXP); - Rcpp::traits::input_parameter< const double >::type ScaleDownFactor(ScaleDownFactorSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type ScreenSize(ScreenSizeSEXP); - Rcpp::traits::input_parameter< const bool >::type LambdaU(LambdaUSEXP); - Rcpp::traits::input_parameter< const std::vector< std::vector > >::type Lambdas(LambdasSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type ExcludeFirstK(ExcludeFirstKSEXP); - Rcpp::traits::input_parameter< const bool >::type Intercept(InterceptSEXP); - Rcpp::traits::input_parameter< const bool >::type withBounds(withBoundsSEXP); - Rcpp::traits::input_parameter< const arma::vec& >::type Lows(LowsSEXP); - Rcpp::traits::input_parameter< const arma::vec& >::type Highs(HighsSEXP); - rcpp_result_gen = Rcpp::wrap(L0LearnFit_sparse(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs)); - return rcpp_result_gen; -END_RCPP -} -// L0LearnFit_dense -Rcpp::List L0LearnFit_dense(const arma::mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, const bool PartialSort, const std::size_t MaxIters, const double rtol, const double atol, const bool ActiveSet, const std::size_t ActiveSetNum, const std::size_t MaxNumSwaps, const double ScaleDownFactor, const std::size_t ScreenSize, const bool LambdaU, const std::vector< std::vector > Lambdas, const std::size_t ExcludeFirstK, const bool Intercept, const bool withBounds, const arma::vec& Lows, const arma::vec& Highs); -RcppExport SEXP _L0Learn_L0LearnFit_dense(SEXP XSEXP, SEXP ySEXP, SEXP LossSEXP, SEXP PenaltySEXP, SEXP AlgorithmSEXP, SEXP NnzStopNumSEXP, SEXP G_ncolsSEXP, SEXP G_nrowsSEXP, SEXP Lambda2MaxSEXP, SEXP Lambda2MinSEXP, SEXP PartialSortSEXP, SEXP MaxItersSEXP, SEXP rtolSEXP, SEXP atolSEXP, SEXP ActiveSetSEXP, SEXP ActiveSetNumSEXP, SEXP MaxNumSwapsSEXP, SEXP ScaleDownFactorSEXP, SEXP ScreenSizeSEXP, SEXP LambdaUSEXP, SEXP LambdasSEXP, SEXP ExcludeFirstKSEXP, SEXP InterceptSEXP, SEXP withBoundsSEXP, SEXP LowsSEXP, SEXP HighsSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP); - Rcpp::traits::input_parameter< const arma::vec& >::type y(ySEXP); - Rcpp::traits::input_parameter< const std::string >::type Loss(LossSEXP); - Rcpp::traits::input_parameter< const std::string >::type Penalty(PenaltySEXP); - Rcpp::traits::input_parameter< const std::string >::type Algorithm(AlgorithmSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type NnzStopNum(NnzStopNumSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type G_ncols(G_ncolsSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type G_nrows(G_nrowsSEXP); - Rcpp::traits::input_parameter< const double >::type Lambda2Max(Lambda2MaxSEXP); - Rcpp::traits::input_parameter< const double >::type Lambda2Min(Lambda2MinSEXP); - Rcpp::traits::input_parameter< const bool >::type PartialSort(PartialSortSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type MaxIters(MaxItersSEXP); - Rcpp::traits::input_parameter< const double >::type rtol(rtolSEXP); - Rcpp::traits::input_parameter< const double >::type atol(atolSEXP); - Rcpp::traits::input_parameter< const bool >::type ActiveSet(ActiveSetSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type ActiveSetNum(ActiveSetNumSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type MaxNumSwaps(MaxNumSwapsSEXP); - Rcpp::traits::input_parameter< const double >::type ScaleDownFactor(ScaleDownFactorSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type ScreenSize(ScreenSizeSEXP); - Rcpp::traits::input_parameter< const bool >::type LambdaU(LambdaUSEXP); - Rcpp::traits::input_parameter< const std::vector< std::vector > >::type Lambdas(LambdasSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type ExcludeFirstK(ExcludeFirstKSEXP); - Rcpp::traits::input_parameter< const bool >::type Intercept(InterceptSEXP); - Rcpp::traits::input_parameter< const bool >::type withBounds(withBoundsSEXP); - Rcpp::traits::input_parameter< const arma::vec& >::type Lows(LowsSEXP); - Rcpp::traits::input_parameter< const arma::vec& >::type Highs(HighsSEXP); - rcpp_result_gen = Rcpp::wrap(L0LearnFit_dense(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs)); - return rcpp_result_gen; -END_RCPP -} -// L0LearnCV_sparse -Rcpp::List L0LearnCV_sparse(const arma::sp_mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, const bool PartialSort, const std::size_t MaxIters, const double rtol, const double atol, const bool ActiveSet, const std::size_t ActiveSetNum, const std::size_t MaxNumSwaps, const double ScaleDownFactor, const std::size_t ScreenSize, const bool LambdaU, const std::vector< std::vector > Lambdas, const std::size_t nfolds, const double seed, const std::size_t ExcludeFirstK, const bool Intercept, const bool withBounds, const arma::vec& Lows, const arma::vec& Highs); -RcppExport SEXP _L0Learn_L0LearnCV_sparse(SEXP XSEXP, SEXP ySEXP, SEXP LossSEXP, SEXP PenaltySEXP, SEXP AlgorithmSEXP, SEXP NnzStopNumSEXP, SEXP G_ncolsSEXP, SEXP G_nrowsSEXP, SEXP Lambda2MaxSEXP, SEXP Lambda2MinSEXP, SEXP PartialSortSEXP, SEXP MaxItersSEXP, SEXP rtolSEXP, SEXP atolSEXP, SEXP ActiveSetSEXP, SEXP ActiveSetNumSEXP, SEXP MaxNumSwapsSEXP, SEXP ScaleDownFactorSEXP, SEXP ScreenSizeSEXP, SEXP LambdaUSEXP, SEXP LambdasSEXP, SEXP nfoldsSEXP, SEXP seedSEXP, SEXP ExcludeFirstKSEXP, SEXP InterceptSEXP, SEXP withBoundsSEXP, SEXP LowsSEXP, SEXP HighsSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const arma::sp_mat& >::type X(XSEXP); - Rcpp::traits::input_parameter< const arma::vec& >::type y(ySEXP); - Rcpp::traits::input_parameter< const std::string >::type Loss(LossSEXP); - Rcpp::traits::input_parameter< const std::string >::type Penalty(PenaltySEXP); - Rcpp::traits::input_parameter< const std::string >::type Algorithm(AlgorithmSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type NnzStopNum(NnzStopNumSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type G_ncols(G_ncolsSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type G_nrows(G_nrowsSEXP); - Rcpp::traits::input_parameter< const double >::type Lambda2Max(Lambda2MaxSEXP); - Rcpp::traits::input_parameter< const double >::type Lambda2Min(Lambda2MinSEXP); - Rcpp::traits::input_parameter< const bool >::type PartialSort(PartialSortSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type MaxIters(MaxItersSEXP); - Rcpp::traits::input_parameter< const double >::type rtol(rtolSEXP); - Rcpp::traits::input_parameter< const double >::type atol(atolSEXP); - Rcpp::traits::input_parameter< const bool >::type ActiveSet(ActiveSetSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type ActiveSetNum(ActiveSetNumSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type MaxNumSwaps(MaxNumSwapsSEXP); - Rcpp::traits::input_parameter< const double >::type ScaleDownFactor(ScaleDownFactorSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type ScreenSize(ScreenSizeSEXP); - Rcpp::traits::input_parameter< const bool >::type LambdaU(LambdaUSEXP); - Rcpp::traits::input_parameter< const std::vector< std::vector > >::type Lambdas(LambdasSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type nfolds(nfoldsSEXP); - Rcpp::traits::input_parameter< const double >::type seed(seedSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type ExcludeFirstK(ExcludeFirstKSEXP); - Rcpp::traits::input_parameter< const bool >::type Intercept(InterceptSEXP); - Rcpp::traits::input_parameter< const bool >::type withBounds(withBoundsSEXP); - Rcpp::traits::input_parameter< const arma::vec& >::type Lows(LowsSEXP); - Rcpp::traits::input_parameter< const arma::vec& >::type Highs(HighsSEXP); - rcpp_result_gen = Rcpp::wrap(L0LearnCV_sparse(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs)); - return rcpp_result_gen; -END_RCPP -} -// L0LearnCV_dense -Rcpp::List L0LearnCV_dense(const arma::mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, const bool PartialSort, const std::size_t MaxIters, const double rtol, const double atol, const bool ActiveSet, const std::size_t ActiveSetNum, const std::size_t MaxNumSwaps, const double ScaleDownFactor, const std::size_t ScreenSize, const bool LambdaU, const std::vector< std::vector > Lambdas, const std::size_t nfolds, const double seed, const std::size_t ExcludeFirstK, const bool Intercept, const bool withBounds, const arma::vec& Lows, const arma::vec& Highs); -RcppExport SEXP _L0Learn_L0LearnCV_dense(SEXP XSEXP, SEXP ySEXP, SEXP LossSEXP, SEXP PenaltySEXP, SEXP AlgorithmSEXP, SEXP NnzStopNumSEXP, SEXP G_ncolsSEXP, SEXP G_nrowsSEXP, SEXP Lambda2MaxSEXP, SEXP Lambda2MinSEXP, SEXP PartialSortSEXP, SEXP MaxItersSEXP, SEXP rtolSEXP, SEXP atolSEXP, SEXP ActiveSetSEXP, SEXP ActiveSetNumSEXP, SEXP MaxNumSwapsSEXP, SEXP ScaleDownFactorSEXP, SEXP ScreenSizeSEXP, SEXP LambdaUSEXP, SEXP LambdasSEXP, SEXP nfoldsSEXP, SEXP seedSEXP, SEXP ExcludeFirstKSEXP, SEXP InterceptSEXP, SEXP withBoundsSEXP, SEXP LowsSEXP, SEXP HighsSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP); - Rcpp::traits::input_parameter< const arma::vec& >::type y(ySEXP); - Rcpp::traits::input_parameter< const std::string >::type Loss(LossSEXP); - Rcpp::traits::input_parameter< const std::string >::type Penalty(PenaltySEXP); - Rcpp::traits::input_parameter< const std::string >::type Algorithm(AlgorithmSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type NnzStopNum(NnzStopNumSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type G_ncols(G_ncolsSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type G_nrows(G_nrowsSEXP); - Rcpp::traits::input_parameter< const double >::type Lambda2Max(Lambda2MaxSEXP); - Rcpp::traits::input_parameter< const double >::type Lambda2Min(Lambda2MinSEXP); - Rcpp::traits::input_parameter< const bool >::type PartialSort(PartialSortSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type MaxIters(MaxItersSEXP); - Rcpp::traits::input_parameter< const double >::type rtol(rtolSEXP); - Rcpp::traits::input_parameter< const double >::type atol(atolSEXP); - Rcpp::traits::input_parameter< const bool >::type ActiveSet(ActiveSetSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type ActiveSetNum(ActiveSetNumSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type MaxNumSwaps(MaxNumSwapsSEXP); - Rcpp::traits::input_parameter< const double >::type ScaleDownFactor(ScaleDownFactorSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type ScreenSize(ScreenSizeSEXP); - Rcpp::traits::input_parameter< const bool >::type LambdaU(LambdaUSEXP); - Rcpp::traits::input_parameter< const std::vector< std::vector > >::type Lambdas(LambdasSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type nfolds(nfoldsSEXP); - Rcpp::traits::input_parameter< const double >::type seed(seedSEXP); - Rcpp::traits::input_parameter< const std::size_t >::type ExcludeFirstK(ExcludeFirstKSEXP); - Rcpp::traits::input_parameter< const bool >::type Intercept(InterceptSEXP); - Rcpp::traits::input_parameter< const bool >::type withBounds(withBoundsSEXP); - Rcpp::traits::input_parameter< const arma::vec& >::type Lows(LowsSEXP); - Rcpp::traits::input_parameter< const arma::vec& >::type Highs(HighsSEXP); - rcpp_result_gen = Rcpp::wrap(L0LearnCV_dense(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs)); - return rcpp_result_gen; -END_RCPP -} -// cor_matrix -Rcpp::NumericMatrix cor_matrix(const int p, const double base_cor); -RcppExport SEXP _L0Learn_cor_matrix(SEXP pSEXP, SEXP base_corSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const int >::type p(pSEXP); - Rcpp::traits::input_parameter< const double >::type base_cor(base_corSEXP); - rcpp_result_gen = Rcpp::wrap(cor_matrix(p, base_cor)); - return rcpp_result_gen; -END_RCPP -} -// R_matrix_column_get_dense -arma::vec R_matrix_column_get_dense(const arma::mat& mat, int col); -RcppExport SEXP _L0Learn_R_matrix_column_get_dense(SEXP matSEXP, SEXP colSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const arma::mat& >::type mat(matSEXP); - Rcpp::traits::input_parameter< int >::type col(colSEXP); - rcpp_result_gen = Rcpp::wrap(R_matrix_column_get_dense(mat, col)); - return rcpp_result_gen; -END_RCPP -} -// R_matrix_column_get_sparse -arma::vec R_matrix_column_get_sparse(const arma::sp_mat& mat, int col); -RcppExport SEXP _L0Learn_R_matrix_column_get_sparse(SEXP matSEXP, SEXP colSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const arma::sp_mat& >::type mat(matSEXP); - Rcpp::traits::input_parameter< int >::type col(colSEXP); - rcpp_result_gen = Rcpp::wrap(R_matrix_column_get_sparse(mat, col)); - return rcpp_result_gen; -END_RCPP -} -// R_matrix_rows_get_dense -arma::mat R_matrix_rows_get_dense(const arma::mat& mat, const arma::ucolvec rows); -RcppExport SEXP _L0Learn_R_matrix_rows_get_dense(SEXP matSEXP, SEXP rowsSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const arma::mat& >::type mat(matSEXP); - Rcpp::traits::input_parameter< const arma::ucolvec >::type rows(rowsSEXP); - rcpp_result_gen = Rcpp::wrap(R_matrix_rows_get_dense(mat, rows)); - return rcpp_result_gen; -END_RCPP -} -// R_matrix_rows_get_sparse -arma::sp_mat R_matrix_rows_get_sparse(const arma::sp_mat& mat, const arma::ucolvec rows); -RcppExport SEXP _L0Learn_R_matrix_rows_get_sparse(SEXP matSEXP, SEXP rowsSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const arma::sp_mat& >::type mat(matSEXP); - Rcpp::traits::input_parameter< const arma::ucolvec >::type rows(rowsSEXP); - rcpp_result_gen = Rcpp::wrap(R_matrix_rows_get_sparse(mat, rows)); - return rcpp_result_gen; -END_RCPP -} -// R_matrix_vector_schur_product_dense -arma::mat R_matrix_vector_schur_product_dense(const arma::mat& mat, const arma::vec& u); -RcppExport SEXP _L0Learn_R_matrix_vector_schur_product_dense(SEXP matSEXP, SEXP uSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const arma::mat& >::type mat(matSEXP); - Rcpp::traits::input_parameter< const arma::vec& >::type u(uSEXP); - rcpp_result_gen = Rcpp::wrap(R_matrix_vector_schur_product_dense(mat, u)); - return rcpp_result_gen; -END_RCPP -} -// R_matrix_vector_schur_product_sparse -arma::sp_mat R_matrix_vector_schur_product_sparse(const arma::sp_mat& mat, const arma::vec& u); -RcppExport SEXP _L0Learn_R_matrix_vector_schur_product_sparse(SEXP matSEXP, SEXP uSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const arma::sp_mat& >::type mat(matSEXP); - Rcpp::traits::input_parameter< const arma::vec& >::type u(uSEXP); - rcpp_result_gen = Rcpp::wrap(R_matrix_vector_schur_product_sparse(mat, u)); - return rcpp_result_gen; -END_RCPP -} -// R_matrix_vector_divide_dense -arma::mat R_matrix_vector_divide_dense(const arma::mat& mat, const arma::vec& u); -RcppExport SEXP _L0Learn_R_matrix_vector_divide_dense(SEXP matSEXP, SEXP uSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const arma::mat& >::type mat(matSEXP); - Rcpp::traits::input_parameter< const arma::vec& >::type u(uSEXP); - rcpp_result_gen = Rcpp::wrap(R_matrix_vector_divide_dense(mat, u)); - return rcpp_result_gen; -END_RCPP -} -// R_matrix_vector_divide_sparse -arma::sp_mat R_matrix_vector_divide_sparse(const arma::sp_mat& mat, const arma::vec& u); -RcppExport SEXP _L0Learn_R_matrix_vector_divide_sparse(SEXP matSEXP, SEXP uSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const arma::sp_mat& >::type mat(matSEXP); - Rcpp::traits::input_parameter< const arma::vec& >::type u(uSEXP); - rcpp_result_gen = Rcpp::wrap(R_matrix_vector_divide_sparse(mat, u)); - return rcpp_result_gen; -END_RCPP -} -// R_matrix_column_sums_dense -arma::rowvec R_matrix_column_sums_dense(const arma::mat& mat); -RcppExport SEXP _L0Learn_R_matrix_column_sums_dense(SEXP matSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const arma::mat& >::type mat(matSEXP); - rcpp_result_gen = Rcpp::wrap(R_matrix_column_sums_dense(mat)); - return rcpp_result_gen; -END_RCPP -} -// R_matrix_column_sums_sparse -arma::rowvec R_matrix_column_sums_sparse(const arma::sp_mat& mat); -RcppExport SEXP _L0Learn_R_matrix_column_sums_sparse(SEXP matSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const arma::sp_mat& >::type mat(matSEXP); - rcpp_result_gen = Rcpp::wrap(R_matrix_column_sums_sparse(mat)); - return rcpp_result_gen; -END_RCPP -} -// R_matrix_column_dot_dense -double R_matrix_column_dot_dense(const arma::mat& mat, int col, const arma::vec u); -RcppExport SEXP _L0Learn_R_matrix_column_dot_dense(SEXP matSEXP, SEXP colSEXP, SEXP uSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const arma::mat& >::type mat(matSEXP); - Rcpp::traits::input_parameter< int >::type col(colSEXP); - Rcpp::traits::input_parameter< const arma::vec >::type u(uSEXP); - rcpp_result_gen = Rcpp::wrap(R_matrix_column_dot_dense(mat, col, u)); - return rcpp_result_gen; -END_RCPP -} -// R_matrix_column_dot_sparse -double R_matrix_column_dot_sparse(const arma::sp_mat& mat, int col, const arma::vec u); -RcppExport SEXP _L0Learn_R_matrix_column_dot_sparse(SEXP matSEXP, SEXP colSEXP, SEXP uSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const arma::sp_mat& >::type mat(matSEXP); - Rcpp::traits::input_parameter< int >::type col(colSEXP); - Rcpp::traits::input_parameter< const arma::vec >::type u(uSEXP); - rcpp_result_gen = Rcpp::wrap(R_matrix_column_dot_sparse(mat, col, u)); - return rcpp_result_gen; -END_RCPP -} -// R_matrix_column_mult_dense -arma::vec R_matrix_column_mult_dense(const arma::mat& mat, int col, double u); -RcppExport SEXP _L0Learn_R_matrix_column_mult_dense(SEXP matSEXP, SEXP colSEXP, SEXP uSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const arma::mat& >::type mat(matSEXP); - Rcpp::traits::input_parameter< int >::type col(colSEXP); - Rcpp::traits::input_parameter< double >::type u(uSEXP); - rcpp_result_gen = Rcpp::wrap(R_matrix_column_mult_dense(mat, col, u)); - return rcpp_result_gen; -END_RCPP -} -// R_matrix_column_mult_sparse -arma::vec R_matrix_column_mult_sparse(const arma::sp_mat& mat, int col, double u); -RcppExport SEXP _L0Learn_R_matrix_column_mult_sparse(SEXP matSEXP, SEXP colSEXP, SEXP uSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const arma::sp_mat& >::type mat(matSEXP); - Rcpp::traits::input_parameter< int >::type col(colSEXP); - Rcpp::traits::input_parameter< double >::type u(uSEXP); - rcpp_result_gen = Rcpp::wrap(R_matrix_column_mult_sparse(mat, col, u)); - return rcpp_result_gen; -END_RCPP -} -// R_matrix_normalize_dense -Rcpp::List R_matrix_normalize_dense(arma::mat mat_norm); -RcppExport SEXP _L0Learn_R_matrix_normalize_dense(SEXP mat_normSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< arma::mat >::type mat_norm(mat_normSEXP); - rcpp_result_gen = Rcpp::wrap(R_matrix_normalize_dense(mat_norm)); - return rcpp_result_gen; -END_RCPP -} -// R_matrix_normalize_sparse -Rcpp::List R_matrix_normalize_sparse(arma::sp_mat mat_norm); -RcppExport SEXP _L0Learn_R_matrix_normalize_sparse(SEXP mat_normSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< arma::sp_mat >::type mat_norm(mat_normSEXP); - rcpp_result_gen = Rcpp::wrap(R_matrix_normalize_sparse(mat_norm)); - return rcpp_result_gen; -END_RCPP -} -// R_matrix_center_dense -Rcpp::List R_matrix_center_dense(const arma::mat mat, arma::mat X_normalized, bool intercept); -RcppExport SEXP _L0Learn_R_matrix_center_dense(SEXP matSEXP, SEXP X_normalizedSEXP, SEXP interceptSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const arma::mat >::type mat(matSEXP); - Rcpp::traits::input_parameter< arma::mat >::type X_normalized(X_normalizedSEXP); - Rcpp::traits::input_parameter< bool >::type intercept(interceptSEXP); - rcpp_result_gen = Rcpp::wrap(R_matrix_center_dense(mat, X_normalized, intercept)); - return rcpp_result_gen; -END_RCPP -} -// R_matrix_center_sparse -Rcpp::List R_matrix_center_sparse(const arma::sp_mat mat, arma::sp_mat X_normalized, bool intercept); -RcppExport SEXP _L0Learn_R_matrix_center_sparse(SEXP matSEXP, SEXP X_normalizedSEXP, SEXP interceptSEXP) { -BEGIN_RCPP - Rcpp::RObject rcpp_result_gen; - Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< const arma::sp_mat >::type mat(matSEXP); - Rcpp::traits::input_parameter< arma::sp_mat >::type X_normalized(X_normalizedSEXP); - Rcpp::traits::input_parameter< bool >::type intercept(interceptSEXP); - rcpp_result_gen = Rcpp::wrap(R_matrix_center_sparse(mat, X_normalized, intercept)); - return rcpp_result_gen; -END_RCPP -} - -static const R_CallMethodDef CallEntries[] = { - {"_L0Learn_L0LearnFit_sparse", (DL_FUNC) &_L0Learn_L0LearnFit_sparse, 26}, - {"_L0Learn_L0LearnFit_dense", (DL_FUNC) &_L0Learn_L0LearnFit_dense, 26}, - {"_L0Learn_L0LearnCV_sparse", (DL_FUNC) &_L0Learn_L0LearnCV_sparse, 28}, - {"_L0Learn_L0LearnCV_dense", (DL_FUNC) &_L0Learn_L0LearnCV_dense, 28}, - {"_L0Learn_cor_matrix", (DL_FUNC) &_L0Learn_cor_matrix, 2}, - {"_L0Learn_R_matrix_column_get_dense", (DL_FUNC) &_L0Learn_R_matrix_column_get_dense, 2}, - {"_L0Learn_R_matrix_column_get_sparse", (DL_FUNC) &_L0Learn_R_matrix_column_get_sparse, 2}, - {"_L0Learn_R_matrix_rows_get_dense", (DL_FUNC) &_L0Learn_R_matrix_rows_get_dense, 2}, - {"_L0Learn_R_matrix_rows_get_sparse", (DL_FUNC) &_L0Learn_R_matrix_rows_get_sparse, 2}, - {"_L0Learn_R_matrix_vector_schur_product_dense", (DL_FUNC) &_L0Learn_R_matrix_vector_schur_product_dense, 2}, - {"_L0Learn_R_matrix_vector_schur_product_sparse", (DL_FUNC) &_L0Learn_R_matrix_vector_schur_product_sparse, 2}, - {"_L0Learn_R_matrix_vector_divide_dense", (DL_FUNC) &_L0Learn_R_matrix_vector_divide_dense, 2}, - {"_L0Learn_R_matrix_vector_divide_sparse", (DL_FUNC) &_L0Learn_R_matrix_vector_divide_sparse, 2}, - {"_L0Learn_R_matrix_column_sums_dense", (DL_FUNC) &_L0Learn_R_matrix_column_sums_dense, 1}, - {"_L0Learn_R_matrix_column_sums_sparse", (DL_FUNC) &_L0Learn_R_matrix_column_sums_sparse, 1}, - {"_L0Learn_R_matrix_column_dot_dense", (DL_FUNC) &_L0Learn_R_matrix_column_dot_dense, 3}, - {"_L0Learn_R_matrix_column_dot_sparse", (DL_FUNC) &_L0Learn_R_matrix_column_dot_sparse, 3}, - {"_L0Learn_R_matrix_column_mult_dense", (DL_FUNC) &_L0Learn_R_matrix_column_mult_dense, 3}, - {"_L0Learn_R_matrix_column_mult_sparse", (DL_FUNC) &_L0Learn_R_matrix_column_mult_sparse, 3}, - {"_L0Learn_R_matrix_normalize_dense", (DL_FUNC) &_L0Learn_R_matrix_normalize_dense, 1}, - {"_L0Learn_R_matrix_normalize_sparse", (DL_FUNC) &_L0Learn_R_matrix_normalize_sparse, 1}, - {"_L0Learn_R_matrix_center_dense", (DL_FUNC) &_L0Learn_R_matrix_center_dense, 3}, - {"_L0Learn_R_matrix_center_sparse", (DL_FUNC) &_L0Learn_R_matrix_center_sparse, 3}, - {NULL, NULL, 0} -}; - -RcppExport void R_init_L0Learn(DllInfo *dll) { - R_registerRoutines(dll, NULL, CallEntries, NULL, NULL); - R_useDynamicSymbols(dll, FALSE); -} diff --git a/src/include/BetaVector.h b/src/include/BetaVector.h deleted file mode 100644 index efc5d92..0000000 --- a/src/include/BetaVector.h +++ /dev/null @@ -1,31 +0,0 @@ -#ifndef BETA_VECTOR_H -#define BETA_VECTOR_H -#include -#include "RcppArmadillo.h" - -/* - * arma::vec implementation - */ - - -using beta_vector = arma::vec; -//using beta_vector = arma::sp_mat; - -std::vector nnzIndicies(const arma::vec& B); - -std::vector nnzIndicies(const arma::sp_mat& B); - -std::vector nnzIndicies(const arma::vec& B, const std::size_t low); - -std::vector nnzIndicies(const arma::sp_mat& B, const std::size_t low); - -std::size_t n_nonzero(const arma::vec& B); - -std::size_t n_nonzero(const arma::sp_mat& B); - -bool has_same_support(const arma::vec& B1, const arma::vec& B2); - -bool has_same_support(const arma::sp_mat& B1, const arma::sp_mat& B2); - - -#endif // BETA_VECTOR_H \ No newline at end of file diff --git a/src/include/BetaVector.hpp b/src/include/BetaVector.hpp new file mode 100644 index 0000000..2b694f2 --- /dev/null +++ b/src/include/BetaVector.hpp @@ -0,0 +1,103 @@ +#ifndef BETA_VECTOR_H +#define BETA_VECTOR_H +#include +#include + +/* + * arma::vec implementation + */ + + +using beta_vector = arma::vec; +//using beta_vector = arma::sp_mat; + +inline std::vector nnzIndicies(const arma::vec& B){ + // Returns a vector of the Non Zero Indicies of B + const arma::ucolvec nnzs_indicies = arma::find(B); + return arma::conv_to>::from(nnzs_indicies); +} + +// std::vector nnzIndicies(const arma::sp_mat& B){ +// // Returns a vector of the Non Zero Indicies of B +// std::vector S; +// arma::sp_mat::const_iterator it; +// const arma::sp_mat::const_iterator it_end = B.end(); +// for(it = B.begin(); it != it_end; ++it) +// { +// S.push_back(it.row()); +// } +// return S; +// } + +inline std::vector nnzIndicies(const arma::vec& B, const std::size_t low){ + // Returns a vector of the Non Zero Indicies of a slice of B starting at low + // This is for NoSelectK situations + const arma::vec B_slice = B.subvec(low, B.n_rows-1); + const arma::ucolvec nnzs_indicies = arma::find(B_slice); + return arma::conv_to>::from(nnzs_indicies); +} + +// std::vector nnzIndicies(const arma::sp_mat& B, const std::size_t low){ +// // Returns a vector of the Non Zero Indicies of B +// std::vector S; +// +// +// arma::sp_mat::const_iterator it; +// const arma::sp_mat::const_iterator it_end = B.end(); +// +// +// for(it = B.begin(); it != it_end; ++it) +// { +// if (it.row() >= low){ +// S.push_back(it.row()); +// } +// } +// return S; +// } + + +inline std::size_t n_nonzero(const arma::vec& B){ + const arma::vec nnzs = arma::nonzeros(B); + return nnzs.n_rows; + +} + +// std::size_t n_nonzero(const arma::sp_mat& B){ +// return B.n_nonzero; +// +// } + +inline bool has_same_support(const arma::vec& B1, const arma::vec& B2){ + if (B1.size() != B2.size()){ + return false; + } + std::size_t n = B1.n_rows; + + bool same_support = true; + for (std::size_t i = 0; i < n; i++){ + same_support = same_support && ((B1.at(i) != 0) == (B2.at(i) != 0)); + } + return same_support; +} + +// bool has_same_support(const arma::sp_mat& B1, const arma::sp_mat& B2){ +// +// if (B1.n_nonzero != B2.n_nonzero) { +// return false; +// } else { // same number of nnz and Supp is sorted +// arma::sp_mat::const_iterator i1, i2; +// const arma::sp_mat::const_iterator i1_end = B1.end(); +// +// +// for(i1 = B1.begin(), i2 = B2.begin(); i1 != i1_end; ++i1, ++i2) +// { +// if(i1.row() != i2.row()) +// { +// return false; +// } +// } +// return true; +// } +// } + +#endif // BETA_VECTOR_H \ No newline at end of file diff --git a/src/include/CD.hpp b/src/include/CD.hpp new file mode 100644 index 0000000..0c142a0 --- /dev/null +++ b/src/include/CD.hpp @@ -0,0 +1,529 @@ +#ifndef CD_H +#define CD_H +#include +#include +#include +#include "BetaVector.hpp" +#include "FitResult.hpp" +#include "Params.hpp" +#include "Model.hpp" +#include "utils.hpp" + +constexpr double lambda1_fudge_factor = 1e-15; + + +template +class CDBase { + protected: + std::size_t NoSelectK; + std::vector * Xtr; + std::size_t n, p; + std::size_t Iter; + + beta_vector B; + beta_vector Bprev; + + std::size_t SameSuppCounter = 0; + double objective; + std::vector Order; // Cycling order + std::vector OldOrder; // Cycling order to be used after support stabilization + convergence. + FitResult result; + + /* Intercept and b0 are used for: + * 1. Classification as b0 is updated iteratively in the CD algorithm + * 2. Regression on Sparse Matrices as we cannot adjust the support of + * the columns of X and thus b0 must be updated iteraveily from the + * residuals + */ + double b0 = 0; + const double lambda0; + const double lambda1; + const double lambda2; + double thr; + double thr2; // threshold squared; + + bool isSparse; + const bool intercept; + const bool withBounds; + + public: + const T * X; + const arma::vec y; + std::vector ModelParams; + + char CyclingOrder; + std::size_t MaxIters; + std::size_t CurrentIters; // current number of iterations - maintained by Converged() + const double rtol; + const double atol; + arma::vec Lows; + arma::vec Highs; + bool ActiveSet; + std::size_t ActiveSetNum; + bool Stabilized = false; + + + CDBase(const T& Xi, const arma::vec& yi, const Params& P); + + FitResult Fit(); + + virtual ~CDBase(){} + + virtual inline double Objective(const arma::vec &, const beta_vector &)=0; + + virtual inline double Objective()=0; + + virtual FitResult _FitWithBounds() = 0; + + virtual FitResult _Fit() = 0; + + static CDBase * make_CD(const T& Xi, const arma::vec& yi, const Params& P); + +}; + +template +class CDSwaps : public CDBase { + +protected: + std::size_t MaxNumSwaps; + Params P; + +public: + + CDSwaps(const T& Xi, const arma::vec& yi, const Params& P); + + virtual ~CDSwaps(){}; + +}; + +class NotImplemented : public std::logic_error{ + public: + NotImplemented() : std::logic_error("Function not yet implemented") { }; +}; + +template +class CD : public CDBase{ + protected: + std::size_t ScreenSize; + std::vector Range1p; + + public: + CD(const T& Xi, const arma::vec& yi, const Params& P); + + virtual ~CD(){}; + + inline double GetBiGrad(const std::size_t i){ + // Must be implemented in Child Classes + throw NotImplemented(); + }; + + inline double GetBiValue(const double old_Bi, const double grd_Bi){ + // Must be implemented in Child Classes + throw NotImplemented(); + }; + + inline double GetBiReg(const double nrb_Bi){ + // Must be implemented in Child Classes + throw NotImplemented(); + }; + + inline void ApplyNewBi(const std::size_t i, const double old_Bi, const double new_Bi){ + // Must be implemented in Child Classes + throw NotImplemented(); + }; + + inline void ApplyNewBiCWMinCheck(const std::size_t i, const double old_Bi, const double new_Bi){ + // Must be implemented in Child Classes + throw NotImplemented(); + }; + + void UpdateBi(const std::size_t i); + + void UpdateBiWithBounds(const std::size_t i); + + bool UpdateBiCWMinCheck(const std::size_t i, const bool Cwmin); + + bool UpdateBiCWMinCheckWithBounds(const std::size_t i, const bool Cwmin); + + void RestrictSupport(); + + void UpdateSparse_b0(arma::vec &r); + + bool isConverged(); + + bool CWMinCheck(); + + bool CWMinCheckWithBounds(); + +}; + + +template +void CD::UpdateBiWithBounds(const std::size_t i){ + // Update a single coefficient of B for various CD Settings + // The following functions are virtual and must be defined for any CD implementation. + // GetBiValue + // GetBiValue + // GetBiReg + // ApplyNewBi + // ApplyNewBiCWMinCheck (found in UpdateBiCWMinCheck) + + + const double grd_Bi = static_cast(this)->GetBiGrad(i); // Gradient of Loss wrt to Bi + + (*this->Xtr)[i] = std::abs(grd_Bi); // Store absolute value of gradient for later steps + + const double old_Bi = this->B[i]; // copy of old Bi to adjust residuals if Bi updates + + const double nrb_Bi = static_cast(this)->GetBiValue(old_Bi, grd_Bi); + // Update Step for New No regularization No Bounds Bi: + // n r b _Bi => nrb_Bi + // Example + // For CDL0: the update step is nrb_Bi = old_Bi + grd_Bi + + const double reg_Bi = static_cast(this)->GetBiReg(nrb_Bi); + // Ideal Bi with L1 and L2 regularization (no bounds) + // Does not account for L0 regularziaton + // Example + // For CDL0: reg_Bi = nrb_Bi as there is no L1, L2 parameters + + const double bnd_Bi = clamp(std::copysign(reg_Bi, nrb_Bi), + this->Lows[i], this->Highs[i]); + // Ideal Bi with regularization and bounds + + // Rcpp::Rcout << "reg_Bi: " << reg_Bi << "\n"; + // Rcpp::Rcout << "new_Bi: " << bnd_Bi << "\n"; + // Rcpp::Rcout << "this->thr: " << this->thr << "\n"; + + if (i < this->NoSelectK){ + // L0 penalty is not applied for NoSelectK Variables. + // Only L1 and L2 (if either are used) + if (std::abs(nrb_Bi) > this->lambda1){ + static_cast(this)->ApplyNewBi(i, old_Bi, bnd_Bi); + // Rcpp::Rcout << "No Select k, Old: " << old_Bi << ", New: " << bnd_Bi << "\n"; + } else if (old_Bi != 0) { + static_cast(this)->ApplyNewBi(i, old_Bi, 0); + // Rcpp::Rcout << "No Select k, Old: " << old_Bi << ", New: " << 0 << "\n"; + } + } else if (reg_Bi < this->thr){ + // If ideal non-bounded reg_Bi is less than threshold, coefficient is not worth setting. + if (old_Bi != 0){ + static_cast(this)->ApplyNewBi(i, old_Bi, 0); + // Rcpp::Rcout << "Below Thresh, Old: " << old_Bi << ", New: " << 0 << "\n"; + } + } else { + // Thus reg_Bi >= this->thr + + const double delta_tmp = std::sqrt(reg_Bi*reg_Bi - this->thr2); + // Due to numerical precision delta_tmp might be nan + // Turns nans to 0. + const double delta = (delta_tmp == delta_tmp) ? delta_tmp : 0; + + const double range_Bi = std::copysign(reg_Bi, nrb_Bi); + + + if ((range_Bi - delta < bnd_Bi) && (bnd_Bi < range_Bi + delta)){ + // bnd_Bi exists in [bnd_Bi - delta, bnd_Bi + delta] + // Therefore accept bnd_Bi + static_cast(this)->ApplyNewBi(i, old_Bi, bnd_Bi); + // Rcpp::Rcout << "Old: " << old_Bi << ", New: " << bnd_Bi << "\n"; + } else if (old_Bi != 0) { + // Otherwise, reject bnd_Bi + static_cast(this)->ApplyNewBi(i, old_Bi, 0); + // Rcpp::Rcout << "Old: " << old_Bi << ", New: " << 0 << "\n"; + } + } +} + +template +void CD::UpdateBi(const std::size_t i){ + // Update a single coefficient of B for various CD Settings + // The following functions are virtual and must be defined for any CD implementation. + // GetBiValue + // GetBiValue + // GetBiReg + // ApplyNewBi + // ApplyNewBiCWMinCheck (found in UpdateBiCWMinCheck) + + + const double grd_Bi = static_cast(this)->GetBiGrad(i); // Gradient of Loss wrt to Bi + + (*this->Xtr)[i] = std::abs(grd_Bi); // Store absolute value of gradient for later steps + + const double old_Bi = this->B[i]; // copy of old Bi to adjust residuals if Bi updates + + const double nrb_Bi = static_cast(this)->GetBiValue(old_Bi, grd_Bi); + // Update Step for New No regularization No Bounds Bi: + // n r b _Bi => nrb_Bi + // Example + // For CDL0: the update step is nrb_Bi = old_Bi + grd_Bi + + const double reg_Bi = static_cast(this)->GetBiReg(nrb_Bi); + // Ideal Bi with L1 and L2 regularization (no bounds) + // Does not account for L0 regularization + // Example + // For CDL0: reg_Bi = nrb_Bi as there is no L1, L2 parameters + + const double new_Bi = std::copysign(reg_Bi, nrb_Bi); + + if (i < this->NoSelectK){ + // L0 penalty is not applied for NoSelectK Variables. + // Only L1 and L2 (if either are used) + if (std::abs(nrb_Bi) > this->lambda1){ + static_cast(this)->ApplyNewBi(i, old_Bi, new_Bi); + } else if (old_Bi != 0) { + static_cast(this)->ApplyNewBi(i, old_Bi, 0); + } + } else if (reg_Bi < this->thr + lambda1_fudge_factor){ + // If ideal non-bounded reg_Bi is less than threshold, coefficient is not worth setting. + if (old_Bi != 0){ + static_cast(this)->ApplyNewBi(i, old_Bi, 0); + // Rcpp::Rcout << "Z" << i <<" "; + } + } else { + static_cast(this)->ApplyNewBi(i, old_Bi, new_Bi); + // Rcpp::Rcout << "NZ" << i <<" "; + } +} + +template +bool CD::UpdateBiCWMinCheck(const std::size_t i, const bool Cwmin){ + // See CD::UpdateBi for documentation + const double grd_Bi = static_cast(this)->GetBiGrad(i); + const double old_Bi = 0; + + (*this->Xtr)[i] = std::abs(grd_Bi); + + const double nrb_Bi = static_cast(this)->GetBiValue(old_Bi, grd_Bi); + const double reg_Bi = static_cast(this)->GetBiReg(nrb_Bi); + const double new_Bi = std::copysign(reg_Bi, nrb_Bi); + + if (reg_Bi < this->thr + lambda1_fudge_factor){ + return Cwmin; + } else { + // Rcpp::Rcout << "Old B[" << i << "] = " << old_Bi << ", New B[" << i << "] = " << new_Bi << "\n"; + static_cast(this)->ApplyNewBiCWMinCheck(i, old_Bi, new_Bi); + return false; + } +} + +template +bool CD::UpdateBiCWMinCheckWithBounds(const std::size_t i, const bool Cwmin){ + // See CD::UpdateBi for documentation + const double grd_Bi = static_cast(this)->GetBiGrad(i); + const double old_Bi = 0; + + (*this->Xtr)[i] = std::abs(grd_Bi); + + const double nrb_Bi = static_cast(this)->GetBiValue(old_Bi, grd_Bi); + const double reg_Bi = static_cast(this)->GetBiReg(nrb_Bi); + const double bnd_Bi = clamp(std::copysign(reg_Bi, nrb_Bi), + this->Lows[i], this->Highs[i]); + + if (reg_Bi < this->thr){ + return Cwmin; + } else { + + const double delta_tmp = std::sqrt(reg_Bi*reg_Bi - this->thr2); + const double delta = (delta_tmp == delta_tmp) ? delta_tmp : 0; + + const double range_Bi = std::copysign(reg_Bi, nrb_Bi); + if ((range_Bi - delta < bnd_Bi) && (bnd_Bi < range_Bi + delta)){ + static_cast(this)->ApplyNewBiCWMinCheck(i, old_Bi, bnd_Bi); + return false; + } else { + return Cwmin; + } + } +} + +/* + * + * CDBase + * + */ + +template +CDBase::CDBase(const T& Xi, const arma::vec& yi, const Params& P) : + lambda0{P.ModelParams[0]}, lambda1{P.ModelParams[1]}, + lambda2{P.ModelParams[2]}, intercept{P.intercept}, withBounds{P.withBounds}, y{yi}, + ModelParams{P.ModelParams}, CyclingOrder{P.CyclingOrder}, MaxIters{P.MaxIters}, + rtol{P.rtol}, atol{P.atol}, Lows{P.Lows}, Highs{P.Highs}, ActiveSet{P.ActiveSet}, + ActiveSetNum{P.ActiveSetNum} + { + this->result.ModelParams = P.ModelParams; + this->NoSelectK = P.NoSelectK; + + this->Xtr = P.Xtr; + this->Iter = P.Iter; + + this->isSparse = std::is_same::value; + + this->b0 = P.b0; + + this->X = Ξ + + this->n = X->n_rows; + this->p = X->n_cols; + + if (P.Init == 'u') { + this->B = *(P.InitialSol); + } else { + //this->B = arma::zeros(p); + this->B = this->B.zeros(p); + } + + if (CyclingOrder == 'u') { + this->Order = P.Uorder; + } else if (CyclingOrder == 'c') { + std::vector cyclic(p); + std::iota(std::begin(cyclic), std::end(cyclic), 0); + this->Order = cyclic; + } + + this->CurrentIters = 0; + } + +template +FitResult CDBase::Fit(){ + if (this->withBounds){ + return this->_FitWithBounds(); + } else{ + return this->_Fit(); + } +} + +template class CDBase; +template class CDBase; + +/* + * + * CD + * + */ + +template +void CD::UpdateSparse_b0(arma::vec& r){ + // Only run for regression when T is arma::sp_mat and intercept is True. + // r is this->r on outer scope; + const double new_b0 = arma::mean(r); + r -= new_b0; + this->b0 += new_b0; +} + + +template +bool CD::isConverged() { + this->CurrentIters += 1; // keeps track of the number of calls to Converged + const double objectiveold = this->objective; + this->objective = this->Objective(); + + // Rcpp::Rcout << "Old: "<< objectiveold << ", New: " << this->objective << "\n"; + // Rcpp::Rcout << "Exit 1: " << (std::abs(objectiveold - this->objective) <= this->rtol*objectiveold) << ", Exit 2: " << (this->objective <= 1e-12) << "\n"; + return std::abs(objectiveold - this->objective) <= this->rtol*objectiveold || this->objective <= this->atol; +} + +template +void CD::RestrictSupport() { + + if (has_same_support(this->B, this->Bprev)) { + this->SameSuppCounter += 1; + + if (this->SameSuppCounter == this->ActiveSetNum - 1) { + std::vector NewOrder = nnzIndicies(this->B); + + /// Map m of {Order[i] -> i}: + std::unordered_map m; + + std::size_t index = 0; + for (const auto &i : this->Order){ + m.insert(std::make_pair(i, index)); + index++; + } + + std::sort(NewOrder.begin(), NewOrder.end(), + [&m](std::size_t i, std::size_t j) {return m[i] < m[j] ;}); + + this->OldOrder = this->Order; + this->Order = NewOrder; + this->ActiveSet = false; + this->Stabilized = true; + + } + + } else { + this->SameSuppCounter = 0; + } + +} + +template +bool CD::CWMinCheckWithBounds() { + std::vector S = nnzIndicies(this->B); + + std::vector Sc; + set_difference( + this->Range1p.begin(), + this->Range1p.end(), + S.begin(), + S.end(), + back_inserter(Sc)); + + bool Cwmin = true; + for (auto& i : Sc) { + Cwmin = this->UpdateBiCWMinCheckWithBounds(i, Cwmin); + } + return Cwmin; +} + +template +bool CD::CWMinCheck() { + std::vector S = nnzIndicies(this->B); + + std::vector Sc; + set_difference( + this->Range1p.begin(), + this->Range1p.end(), + S.begin(), + S.end(), + back_inserter(Sc)); + + bool Cwmin = true; + for (auto& i : Sc) { + // Rcpp::Rcout << "CW Iteration: " << i << "\n"; + // std::this_thread::sleep_for(std::chrono::milliseconds(100)); + Cwmin = this->UpdateBiCWMinCheck(i, Cwmin); + } + + // Rcpp::Rcout << "CWMinCheckL " << Cwmin << "\n"; + + return Cwmin; +} + + +template +CD::CD(const T& Xi, const arma::vec& yi, const Params& P) : CDBase(Xi, yi, P){ + Range1p.resize(this->p); + std::iota(std::begin(Range1p), std::end(Range1p), 0); + ScreenSize = P.ScreenSize; +} + +// template class CD; +// template class CD; + +/* + * + * CDSwaps + * + */ + +template +CDSwaps::CDSwaps(const T& Xi, const arma::vec& yi, const Params& Pi) : CDBase(Xi, yi, Pi){ + MaxNumSwaps = Pi.MaxNumSwaps; + P = Pi; +} + +template class CDSwaps; +template class CDSwaps; + +#endif diff --git a/src/include/CDL0.hpp b/src/include/CDL0.hpp new file mode 100644 index 0000000..0e47612 --- /dev/null +++ b/src/include/CDL0.hpp @@ -0,0 +1,182 @@ +#ifndef CDL0_H +#define CDL0_H +#include +#include +#include "CD.hpp" +#include "Params.hpp" +#include "FitResult.hpp" +#include "utils.hpp" +#include "BetaVector.hpp" + + +template +class CDL0: public CD>{ + private: + + arma::vec r; //vector of residuals + + public: + CDL0(const T& Xi, const arma::vec& yi, const Params& P); + //~CDL0(){} + + FitResult _FitWithBounds() final; + + FitResult _Fit() final; + + inline double Objective(const arma::vec &, const beta_vector &) final; + + inline double Objective() final; + + inline double GetBiGrad(const std::size_t i); + + inline double GetBiValue(const double old_Bi, const double grd_Bi); + + inline double GetBiReg(const double nrb_Bi); + + inline void ApplyNewBi(const std::size_t i, const double old_Bi, const double new_Bi); + + inline void ApplyNewBiCWMinCheck(const std::size_t i, const double old_Bi, const double new_Bi); +}; + +template +inline double CDL0::GetBiGrad(const std::size_t i){ + return matrix_column_dot(*(this->X), i, this->r); +} + +template +inline double CDL0::GetBiValue(const double old_Bi, const double grd_Bi){ + return grd_Bi + old_Bi; +} + +template +inline double CDL0::GetBiReg(const double nrb_Bi){ + return std::abs(nrb_Bi); +} + +template +inline void CDL0::ApplyNewBi(const std::size_t i, const double old_Bi, const double new_Bi){ + this->r += matrix_column_mult(*(this->X), i, old_Bi - new_Bi); + this->B[i] = new_Bi; +} + +template +inline void CDL0::ApplyNewBiCWMinCheck(const std::size_t i, const double old_Bi, const double new_Bi){ + this->r += matrix_column_mult(*(this->X), i, old_Bi - new_Bi); + this->B[i] = new_Bi; + this->Order.push_back(i); +} + +template +inline double CDL0::Objective(const arma::vec & r, const beta_vector & B) { + return 0.5 * arma::dot(r, r) + this->lambda0 * n_nonzero(B); +} + +template +inline double CDL0::Objective() { + return 0.5 * arma::dot(this->r, this->r) + this->lambda0 * n_nonzero(this->B); +} + +template +CDL0::CDL0(const T& Xi, const arma::vec& yi, const Params& P) : CD>(Xi, yi, P){ + this->thr2 = 2 * this->lambda0; + this->thr = sqrt(this->thr2); + this->r = *P.r; + this->result.r = P.r; +} + +template +FitResult CDL0::_Fit() { + // Rcpp::Rcout << "CDL0 Fit:"; + this->objective = Objective(this->r, this->B); + + std::vector FullOrder = this->Order; + + if (this->ActiveSet) { + this->Order.resize(std::min((int) (n_nonzero(this->B) + this->ScreenSize + this->NoSelectK), (int)(this->p))); // std::min(1000,Order.size()) + } + + for (std::size_t t = 0; t < this->MaxIters; ++t) { + this->Bprev = this->B; + + if (this->isSparse && this->intercept){ + this->UpdateSparse_b0(this->r); + } + + //Rcpp::Rcout << "{" << this->Order.size() << "}"; + for (auto& i : this->Order) { + this->UpdateBi(i); + } + + this->RestrictSupport(); + + if (this->isConverged() && this->CWMinCheck()) { + //Rcpp::Rcout << " |Converged on iter:" << t << "CWMinCheck \n"; + break; + } + } + + + // Re-optimize b0 after convergence. + if (this->isSparse && this->intercept){ + this->UpdateSparse_b0(this->r); + } + + this->result.Objective = this->objective; + this->result.B = this->B; + *(this->result.r) = this->r; // change to pointer later + this->result.IterNum = this->CurrentIters; + this->result.b0 = this->b0; + + return this->result; +} + +template +FitResult CDL0::_FitWithBounds() { + // Rcpp::Rcout << "CDL0 Fit: "; + clamp_by_vector(this->B, this->Lows, this->Highs); + + this->objective = Objective(this->r, this->B); + + std::vector FullOrder = this->Order; + + if (this->ActiveSet) { + this->Order.resize(std::min((int) (n_nonzero(this->B) + this->ScreenSize + this->NoSelectK), (int)(this->p))); // std::min(1000,Order.size()) + } + + for (std::size_t t = 0; t < this->MaxIters; ++t) { + this->Bprev = this->B; + + if (this->isSparse && this->intercept){ + this->UpdateSparse_b0(this->r); + } + + for (auto& i : this->Order) { + this->UpdateBiWithBounds(i); + } + + this->RestrictSupport(); + + if (this->isConverged() && this->CWMinCheckWithBounds()) { + // Rcpp::Rcout << "Converged on iter:" << t << "\n"; + break; + } + } + + // Re-optimize b0 after convergence. + if (this->isSparse && this->intercept){ + this->UpdateSparse_b0(this->r); + } + + this->result.Objective = this->objective; + this->result.B = this->B; + *(this->result.r) = this->r; // change to pointer later + this->result.IterNum = this->CurrentIters; + this->result.b0 = this->b0; + + return this->result; +} + +template class CDL0; +template class CDL0; + +#endif diff --git a/src/include/CDL012.hpp b/src/include/CDL012.hpp new file mode 100644 index 0000000..a14c11a --- /dev/null +++ b/src/include/CDL012.hpp @@ -0,0 +1,180 @@ +#ifndef CDL012_H +#define CDL012_H +#include +#include "CD.hpp" +#include "FitResult.hpp" +#include "utils.hpp" +#include "BetaVector.hpp" + +template +class CDL012 : public CD>{ + private: + double Onep2lamda2; + arma::vec r; //vector of residuals + + public: + CDL012(const T& Xi, const arma::vec& yi, const Params& P); + //~CDL012(){} + + FitResult _FitWithBounds() final; + + FitResult _Fit() final; + + inline double Objective(const arma::vec & r, const beta_vector & B) final; + + inline double Objective() final; + + inline double GetBiGrad(const std::size_t i); + + inline double GetBiValue(const double old_Bi, const double grd_Bi); + + inline double GetBiReg(const double nrb_Bi); + + inline void ApplyNewBi(const std::size_t i, const double old_Bi, const double new_Bi); + + inline void ApplyNewBiCWMinCheck(const std::size_t i, const double old_Bi, const double new_Bi); + +}; + + +template +inline double CDL012::GetBiGrad(const std::size_t i){ + return matrix_column_dot(*(this->X), i, this->r); +} + +template +inline double CDL012::GetBiValue(const double old_Bi, const double grd_Bi){ + return grd_Bi + old_Bi; +} + +template +inline double CDL012::GetBiReg(const double nrb_Bi){ + // sign(nrb_Bi)*(|nrb_Bi| - lambda1)/(1 + 2*lambda2) + return (std::abs(nrb_Bi) - this->lambda1) / Onep2lamda2; +} + +template +inline void CDL012::ApplyNewBi(const std::size_t i, const double Bi_old, const double Bi_new){ + this->r += matrix_column_mult(*(this->X), i, Bi_old - Bi_new); + this->B[i] = Bi_new; +} + +template +inline void CDL012::ApplyNewBiCWMinCheck(const std::size_t i, const double Bi_old, const double Bi_new){ + this->r += matrix_column_mult(*(this->X), i, Bi_old - Bi_new); + this->B[i] = Bi_new; + this->Order.push_back(i); +} + +template +inline double CDL012::Objective(const arma::vec & r, const beta_vector & B) { + auto l2norm = arma::norm(B, 2); + return 0.5 * arma::dot(r, r) + this->lambda0 * n_nonzero(this->B) + this->lambda1 * arma::norm(B, 1) + this->lambda2 * l2norm * l2norm; +} + +template +inline double CDL012::Objective() { + auto l2norm = arma::norm(this->B, 2); + return 0.5 * arma::dot(this->r, this->r) + this->lambda0 * n_nonzero(this->B) + this->lambda1 * arma::norm(this->B, 1) + this->lambda2 * l2norm * l2norm; +} + +template +CDL012::CDL012(const T& Xi, const arma::vec& yi, const Params& P) : CD>(Xi, yi, P) { + Onep2lamda2 = 1 + 2 * this->lambda2; + + this->thr2 = 2 * this->lambda0 / Onep2lamda2; + this->thr = std::sqrt(this->thr2); + this->r = *P.r; + this->result.r = P.r; +} + +template +FitResult CDL012::_Fit() { + + this->objective = Objective(this->r, this->B); + + std::vector FullOrder = this->Order; + + if (this->ActiveSet) { + this->Order.resize(std::min((int) (n_nonzero(this->B) + this->ScreenSize + this->NoSelectK), (int)(this->p))); + } + + for (std::size_t t = 0; t < this->MaxIters; ++t) { + this->Bprev = this->B; + + if (this->isSparse && this->intercept){ + this->UpdateSparse_b0(this->r); + } + + for (auto& i : this->Order) { + this->UpdateBi(i); + } + + this->RestrictSupport(); + + if (this->isConverged() && this->CWMinCheck()) { + break; + } + } + + if (this->isSparse && this->intercept){ + this->UpdateSparse_b0(this->r); + } + + this->result.Objective = this->objective; + this->result.B = this->B; + *(this->result.r) = this->r; // change to pointer later + this->result.IterNum = this->CurrentIters; + this->result.b0 = this->b0; + return this->result; +} + +template +FitResult CDL012::_FitWithBounds() { + + clamp_by_vector(this->B, this->Lows, this->Highs); + + this->objective = Objective(this->r, this->B); + + std::vector FullOrder = this->Order; + + if (this->ActiveSet) { + this->Order.resize(std::min((int) (n_nonzero(this->B) + this->ScreenSize + this->NoSelectK), (int)(this->p))); + } + + for (std::size_t t = 0; t < this->MaxIters; ++t) { + this->Bprev = this->B; + + if (this->isSparse && this->intercept){ + this->UpdateSparse_b0(this->r); + } + + for (auto& i : this->Order) { + this->UpdateBiWithBounds(i); + } + + this->RestrictSupport(); + + //B.print(); + if (this->isConverged() && this->CWMinCheckWithBounds()) { + break; + } + + } + + if (this->isSparse && this->intercept){ + this->UpdateSparse_b0(this->r); + } + + this->result.Objective = this->objective; + this->result.B = this->B; + *(this->result.r) = this->r; // change to pointer later + this->result.IterNum = this->CurrentIters; + this->result.b0 = this->b0; + return this->result; +} + +template class CDL012; +template class CDL012; + +#endif diff --git a/src/include/CDL012Logistic.hpp b/src/include/CDL012Logistic.hpp new file mode 100644 index 0000000..29770d9 --- /dev/null +++ b/src/include/CDL012Logistic.hpp @@ -0,0 +1,194 @@ +#ifndef CDL012Logistic_H +#define CDL012Logistic_H +#include +#include "CD.hpp" +#include "FitResult.hpp" +#include "Params.hpp" +#include "utils.hpp" +#include "BetaVector.hpp" + +template +class CDL012Logistic : public CD> { + private: + const double LipschitzConst = 0.25; + double twolambda2; + double qp2lamda2; + double lambda1ol; + arma::vec ExpyXB; + // std::vector * Xtr; + T * Xy; + + public: + CDL012Logistic(const T& Xi, const arma::vec& yi, const Params& P); + //~CDL012Logistic(){} + + FitResult _FitWithBounds() final; + + FitResult _Fit() final; + + inline double Objective(const arma::vec & r, const beta_vector & B) final; + + inline double Objective() final; + + inline double GetBiGrad(const std::size_t i); + + inline double GetBiValue(const double old_Bi, const double grd_Bi); + + inline double GetBiReg(const double Bi_step); + + inline void ApplyNewBi(const std::size_t i, const double Bi_old, const double Bi_new); + + inline void ApplyNewBiCWMinCheck(const std::size_t i, const double old_Bi, const double new_Bi); + +}; + +template +inline double CDL012Logistic::GetBiGrad(const std::size_t i){ + /* + * Notes: + * When called in CWMinCheck, we know that this->B[i] is 0. + */ + return -arma::dot(matrix_column_get(*(this->Xy), i), 1 / (1 + ExpyXB) ) + twolambda2 * this->B[i]; + //return -arma::sum( matrix_column_get(*(this->Xy), i) / (1 + ExpyXB) ) + twolambda2 * this->B[i]; +} + +template +inline double CDL012Logistic::GetBiValue(const double old_Bi, const double grd_Bi){ + return old_Bi - grd_Bi/qp2lamda2; +} + +template +inline double CDL012Logistic::GetBiReg(const double Bi_step){ + return std::abs(Bi_step) - lambda1ol; +} + +template +inline void CDL012Logistic::ApplyNewBi(const std::size_t i, const double old_Bi, const double new_Bi){ + ExpyXB %= arma::exp( (new_Bi - old_Bi) * matrix_column_get(*(this->Xy), i)); + this->B[i] = new_Bi; +} + +template +inline void CDL012Logistic::ApplyNewBiCWMinCheck(const std::size_t i, + const double old_Bi, + const double new_Bi){ + ExpyXB %= arma::exp( (new_Bi - old_Bi) * matrix_column_get(*(this->Xy), i)); + this->B[i] = new_Bi; + this->Order.push_back(i); +} + +template +inline double CDL012Logistic::Objective(const arma::vec & expyXB, const beta_vector & B) { // hint inline + const auto l2norm = arma::norm(B, 2); + // arma::sum(arma::log(1 + 1 / expyXB)) is the negative log-likelihood + return arma::sum(arma::log(1 + 1 / expyXB)) + this->lambda0 * n_nonzero(B) + this->lambda1 * arma::norm(B, 1) + this->lambda2 * l2norm * l2norm; +} + +template +inline double CDL012Logistic::Objective() { + return this->Objective(ExpyXB, this->B); +} + +template +CDL012Logistic::CDL012Logistic(const T& Xi, const arma::vec& yi, const Params& P) : CD>(Xi, yi, P) { + twolambda2 = 2 * this->lambda2; + qp2lamda2 = (LipschitzConst + twolambda2); // this is the univariate lipschitz const of the differentiable objective + this->thr2 = (2 * this->lambda0) / qp2lamda2; + this->thr = std::sqrt(this->thr2); + lambda1ol = this->lambda1 / qp2lamda2; + + ExpyXB = arma::exp(this->y % (*(this->X) * this->B + this->b0)); // Maintained throughout the algorithm + Xy = P.Xy; +} + +template +FitResult CDL012Logistic::_Fit() { + this->objective = Objective(); // Implicitly used ExpyXB + + std::vector FullOrder = this->Order; // never used in LR + this->Order.resize(std::min((int) (n_nonzero(this->B) + this->ScreenSize + this->NoSelectK), (int)(this->p))); + + for (std::size_t t = 0; t < this->MaxIters; ++t) { + this->Bprev = this->B; + + // Update the intercept + if (this->intercept){ + const double b0old = this->b0; + // const double partial_b0 = - arma::sum( *(this->y) / (1 + ExpyXB) ); + const double partial_b0 = - arma::dot( (this->y) , 1/(1 + ExpyXB) ); + this->b0 -= partial_b0 / (this->n * LipschitzConst); // intercept is not regularized + ExpyXB %= arma::exp( (this->b0 - b0old) * (this->y)); + } + + for (auto& i : this->Order) { + this->UpdateBi(i); + } + + this->RestrictSupport(); + + // only way to terminate is by (i) converging on active set and (ii) CWMinCheck + if (this->isConverged() && this->CWMinCheck()) { + break; + } + } + + this->result.Objective = this->objective; + this->result.B = this->B; + this->result.Model = this; + this->result.b0 = this->b0; + this->result.ExpyXB = ExpyXB; + this->result.IterNum = this->CurrentIters; + + return this->result; +} + +template +FitResult CDL012Logistic::_FitWithBounds() { // always uses active sets + + //arma::sp_mat B2 = this->B; + clamp_by_vector(this->B, this->Lows, this->Highs); + + this->objective = Objective(); // Implicitly used ExpyXB + + std::vector FullOrder = this->Order; // never used in LR + this->Order.resize(std::min((int) (n_nonzero(this->B) + this->ScreenSize + this->NoSelectK), (int)(this->p))); + + for (std::size_t t = 0; t < this->MaxIters; ++t) { + this->Bprev = this->B; + + // Update the intercept + if (this->intercept){ + const double b0old = this->b0; + // const double partial_b0 = - arma::sum( *(this->y) / (1 + ExpyXB) ); + const double partial_b0 = - arma::dot( (this->y) , 1/(1 + ExpyXB) ); + this->b0 -= partial_b0 / (this->n * LipschitzConst); // intercept is not regularized + ExpyXB %= arma::exp( (this->b0 - b0old) * (this->y)); + } + + for (auto& i : this->Order) { + this->UpdateBiWithBounds(i); + } + + this->RestrictSupport(); + + // only way to terminate is by (i) converging on active set and (ii) CWMinCheck + if (this->isConverged() && this->CWMinCheckWithBounds()) { + break; + } + } + + this->result.Objective = this->objective; + this->result.B = this->B; + this->result.Model = this; + this->result.b0 = this->b0; + this->result.ExpyXB = ExpyXB; + this->result.IterNum = this->CurrentIters; + + return this->result; +} + +template class CDL012Logistic; +template class CDL012Logistic; + + +#endif diff --git a/src/include/CDL012LogisticSwaps.hpp b/src/include/CDL012LogisticSwaps.hpp new file mode 100644 index 0000000..d183357 --- /dev/null +++ b/src/include/CDL012LogisticSwaps.hpp @@ -0,0 +1,49 @@ +#ifndef CDL012LogisticSwaps_H +#define CDL012LogisticSwaps_H +#include +#include "CD.hpp" +#include "CDSwaps.hpp" +#include "CDL012Logistic.hpp" +#include "FitResult.hpp" +#include "Params.hpp" +#include "utils.hpp" +#include "BetaVector.hpp" + +template +class CDL012LogisticSwaps : public CDSwaps { + private: + const double LipschitzConst = 0.25; + double twolambda2; + double qp2lamda2; + double lambda1ol; + double stl0Lc; + arma::vec ExpyXB; + // std::vector * Xtr; + T * Xy; + + public: + CDL012LogisticSwaps(const T& Xi, const arma::vec& yi, const Params& P); + + FitResult _FitWithBounds() final; + + FitResult _Fit() final; + + inline double Objective(const arma::vec & r, const beta_vector & B) final; + + inline double Objective() final; + +}; + + +template +inline double CDL012LogisticSwaps::Objective(const arma::vec & r, const beta_vector & B) { + auto l2norm = arma::norm(B, 2); + return arma::sum(arma::log(1 + 1 / r)) + this->lambda0 * n_nonzero(B) + this->lambda1 * arma::norm(B, 1) + this->lambda2 * l2norm * l2norm; +} + +template +inline double CDL012LogisticSwaps::Objective() { + return this->Objective(ExpyXB, this->B); +} + +#endif diff --git a/src/include/CDL012SquaredHinge.hpp b/src/include/CDL012SquaredHinge.hpp new file mode 100644 index 0000000..68fa3be --- /dev/null +++ b/src/include/CDL012SquaredHinge.hpp @@ -0,0 +1,208 @@ +#ifndef CDL012SquaredHinge_H +#define CDL012SquaredHinge_H +#include +#include "CD.hpp" +#include "FitResult.hpp" +#include "Params.hpp" +#include "utils.hpp" +#include "BetaVector.hpp" + +template +class CDL012SquaredHinge : public CD> { + private: + const double LipschitzConst = 2; // for f (without regularization) + double twolambda2; + double qp2lamda2; + double lambda1ol; + // std::vector * Xtr; + arma::vec onemyxb; + arma::uvec indices; + T * Xy; + + + public: + CDL012SquaredHinge(const T& Xi, const arma::vec& yi, const Params& P); + + //~CDL012SquaredHinge(){} + + FitResult _FitWithBounds() final; + + FitResult _Fit() final; + + inline double Objective(const arma::vec & r, const beta_vector & B) final; + + inline double Objective() final; + + inline double GetBiGrad(const std::size_t i); + + inline double GetBiValue(const double old_Bi, const double grd_Bi); + + inline double GetBiReg(const double Bi_step); + + inline void ApplyNewBi(const std::size_t i, const double Bi_old, const double Bi_new); + + inline void ApplyNewBiCWMinCheck(const std::size_t i, const double old_Bi, const double new_Bi); + +}; + +template +inline double CDL012SquaredHinge::GetBiGrad(const std::size_t i){ + // Rcpp::Rcout << "Grad stuff: " << arma::sum(2 * onemyxb.elem(indices) % (- matrix_column_get(*Xy, i).elem(indices)) ) << "\n"; + return arma::sum(2 * onemyxb.elem(indices) % (- matrix_column_get(*Xy, i).elem(indices)) ) + twolambda2 * this->B[i]; +} + +template +inline double CDL012SquaredHinge::GetBiValue(const double old_Bi, const double grd_Bi){ + return old_Bi - grd_Bi / qp2lamda2; +} + +template +inline double CDL012SquaredHinge::GetBiReg(const double Bi_step){ + return std::abs(Bi_step) - lambda1ol; +} + +template +inline void CDL012SquaredHinge::ApplyNewBi(const std::size_t i, const double Bi_old, const double Bi_new){ + onemyxb += (Bi_old - Bi_new) * matrix_column_get(*(this->Xy), i); + this->B[i] = Bi_new; + indices = arma::find(onemyxb > 0); +} + +template +inline void CDL012SquaredHinge::ApplyNewBiCWMinCheck(const std::size_t i, const double Bi_old, const double Bi_new){ + onemyxb += (Bi_old - Bi_new) * matrix_column_get(*(this->Xy), i); + this->B[i] = Bi_new; + indices = arma::find(onemyxb > 0); + this->Order.push_back(i); +} + +template +inline double CDL012SquaredHinge::Objective(const arma::vec & onemyxb, const beta_vector & B) { + + auto l2norm = arma::norm(B, 2); + arma::uvec indices = arma::find(onemyxb > 0); + + return arma::sum(onemyxb.elem(indices) % onemyxb.elem(indices)) + this->lambda0 * n_nonzero(B) + this->lambda1 * arma::norm(B, 1) + this->lambda2 * l2norm * l2norm; +} + + +template +inline double CDL012SquaredHinge::Objective() { + + auto l2norm = arma::norm(this->B, 2); + return arma::sum(onemyxb.elem(indices) % onemyxb.elem(indices)) + this->lambda0 * n_nonzero(this->B) + this->lambda1 * arma::norm(this->B, 1) + this->lambda2 * l2norm * l2norm; +} + +template +CDL012SquaredHinge::CDL012SquaredHinge(const T& Xi, const arma::vec& yi, const Params& P) : CD>(Xi, yi, P) { + twolambda2 = 2 * this->lambda2; + qp2lamda2 = (LipschitzConst + twolambda2); // this is the univariate lipschitz const of the differentiable objective + this->thr2 = (2 * this->lambda0) / qp2lamda2; + this->thr = std::sqrt(this->thr2); + lambda1ol = this->lambda1 / qp2lamda2; + + // TODO: Review this line + // TODO: Pass work from previous solution. + onemyxb = 1 - this->y % (*(this->X) * this->B + this->b0); + + // TODO: Add comment for purpose of 'indices' + indices = arma::find(onemyxb > 0); + Xy = P.Xy; +} + +template +FitResult CDL012SquaredHinge::_Fit() { + + this->objective = Objective(); // Implicitly uses onemyx + + + std::vector FullOrder = this->Order; // never used in LR + this->Order.resize(std::min((int) (n_nonzero(this->B) + this->ScreenSize + this->NoSelectK), (int)(this->p))); + + + for (auto t = 0; t < this->MaxIters; ++t) { + + this->Bprev = this->B; + + // Update the intercept + if (this->intercept) { + const double b0old = this->b0; + const double partial_b0 = arma::sum(2 * onemyxb.elem(indices) % -this->y.elem(indices)); + this->b0 -= partial_b0 / (this->n * LipschitzConst); // intercept is not regularized + onemyxb += this->y * (b0old - this->b0); + indices = arma::find(onemyxb > 0); + } + + for (auto& i : this->Order) { + this->UpdateBi(i); + } + + this->RestrictSupport(); + + // only way to terminate is by (i) converging on active set and (ii) CWMinCheck + if ((this->isConverged()) && this->CWMinCheck()) { + break; + } + } + + this->result.Objective = this->objective; + this->result.B = this->B; + this->result.Model = this; + this->result.b0 = this->b0; + this->result.IterNum = this->CurrentIters; + this->result.onemyxb = this->onemyxb; + return this->result; +} + + +template +FitResult CDL012SquaredHinge::_FitWithBounds() { + + clamp_by_vector(this->B, this->Lows, this->Highs); + + this->objective = Objective(); // Implicitly uses onemyx + + std::vector FullOrder = this->Order; // never used in LR + this->Order.resize(std::min((int) (n_nonzero(this->B) + this->ScreenSize + this->NoSelectK), (int)(this->p))); + + + for (auto t = 0; t < this->MaxIters; ++t) { + + this->Bprev = this->B; + + // Update the intercept + if (this->intercept) { + const double b0old = this->b0; + const double partial_b0 = arma::sum(2 * onemyxb.elem(indices) % -this->y.elem(indices)); + this->b0 -= partial_b0 / (this->n * LipschitzConst); // intercept is not regularized + onemyxb += this->y * (b0old - this->b0); + indices = arma::find(onemyxb > 0); + } + + for (auto& i : this->Order) { + this->UpdateBiWithBounds(i); + } + + this->RestrictSupport(); + + // only way to terminate is by (i) converging on active set and (ii) CWMinCheck + if (this->isConverged()) { + if (this->CWMinCheckWithBounds()) { + break; + } + } + } + + this->result.Objective = this->objective; + this->result.B = this->B; + this->result.Model = this; + this->result.b0 = this->b0; + this->result.IterNum = this->CurrentIters; + this->result.onemyxb = this->onemyxb; + return this->result; +} + +template class CDL012SquaredHinge; +template class CDL012SquaredHinge; + +#endif diff --git a/src/include/CDL012SquaredHingeSwaps.hpp b/src/include/CDL012SquaredHingeSwaps.hpp new file mode 100644 index 0000000..a639384 --- /dev/null +++ b/src/include/CDL012SquaredHingeSwaps.hpp @@ -0,0 +1,49 @@ +#ifndef CDL012SquredHingeSwaps_H +#define CDL012SquredHingeSwaps_H +#include +#include "CD.hpp" +#include "CDSwaps.hpp" +#include "CDL012SquaredHinge.hpp" +#include "Params.hpp" +#include "FitResult.hpp" +#include "utils.hpp" +#include "BetaVector.hpp" + +template +class CDL012SquaredHingeSwaps : public CDSwaps { + private: + const double LipschitzConst = 2; + double twolambda2; + double qp2lamda2; + double lambda1ol; + double stl0Lc; + // std::vector * Xtr; + + public: + CDL012SquaredHingeSwaps(const T& Xi, const arma::vec& yi, const Params& P); + + FitResult _FitWithBounds() final; + + FitResult _Fit() final; + + inline double Objective(const arma::vec & r, const beta_vector & B) final; + + inline double Objective() final; + + +}; + +template +inline double CDL012SquaredHingeSwaps::Objective(const arma::vec & onemyxb, const beta_vector & B) { + auto l2norm = arma::norm(B, 2); + arma::uvec indices = arma::find(onemyxb > 0); + return arma::sum(onemyxb.elem(indices) % onemyxb.elem(indices)) + this->lambda0 * n_nonzero(B) + this->lambda1 * arma::norm(B, 1) + this->lambda2 * l2norm * l2norm; +} + +template +inline double CDL012SquaredHingeSwaps::Objective() { + throw std::runtime_error("CDL012SquaredHingeSwaps does not have this->onemyxb"); +} + + +#endif diff --git a/src/include/CDL012Swaps.hpp b/src/include/CDL012Swaps.hpp new file mode 100644 index 0000000..5819725 --- /dev/null +++ b/src/include/CDL012Swaps.hpp @@ -0,0 +1,39 @@ +#ifndef CDL012SWAPS_H +#define CDL012SWAPS_H +#include +#include +#include "CD.hpp" +#include "CDSwaps.hpp" +#include "CDL012.hpp" +#include "FitResult.hpp" +#include "Params.hpp" +#include "utils.hpp" +#include "BetaVector.hpp" + +template +class CDL012Swaps : public CDSwaps { + public: + CDL012Swaps(const T& Xi, const arma::vec& yi, const Params& Pi); + + FitResult _FitWithBounds() final; + + FitResult _Fit() final; + + double Objective(const arma::vec & r, const beta_vector & B) final; + + double Objective() final; + +}; + +template +inline double CDL012Swaps::Objective(const arma::vec & r, const beta_vector & B) { + auto l2norm = arma::norm(B, 2); + return 0.5 * arma::dot(r, r) + this->lambda0 * n_nonzero(B) + this->lambda1 * arma::norm(B, 1) + this->lambda2 * l2norm * l2norm; +} + +template +inline double CDL012Swaps::Objective() { + throw std::runtime_error("CDL012Swaps does not have this->r."); +} + +#endif diff --git a/src/include/CDSwaps.hpp b/src/include/CDSwaps.hpp new file mode 100644 index 0000000..280e469 --- /dev/null +++ b/src/include/CDSwaps.hpp @@ -0,0 +1,5 @@ +#ifndef CDSWAPS_H +#define CDSWAPS_H +#include "CD.hpp" + +#endif \ No newline at end of file diff --git a/src/include/FitResult.hpp b/src/include/FitResult.hpp new file mode 100644 index 0000000..3000090 --- /dev/null +++ b/src/include/FitResult.hpp @@ -0,0 +1,22 @@ +#ifndef FITRESULT_H +#define FITRESULT_H +#include +#include "BetaVector.hpp" + +template // Forward Reference to prevent circular dependencies +class CDBase; + +template +struct FitResult { + double Objective; + beta_vector B; + CDBase * Model; + std::size_t IterNum; + arma::vec * r; + std::vector ModelParams; + double b0 = 0; // used by classification models and sparse regression models + arma::vec ExpyXB; // Used by Logistic regression + arma::vec onemyxb; // Used by SquaredHinge regression +}; + +#endif diff --git a/src/include/Grid.hpp b/src/include/Grid.hpp new file mode 100644 index 0000000..bdf265d --- /dev/null +++ b/src/include/Grid.hpp @@ -0,0 +1,41 @@ +#ifndef GRID_H +#define GRID_H +#include +#include +#include +#include +#include "GridParams.hpp" +#include "FitResult.hpp" +#include "Grid1D.hpp" +#include "Grid2D.hpp" +#include "Normalize.hpp" + +template +class Grid { + private: + T Xscaled; + arma::vec yscaled; + arma::vec BetaMultiplier; + arma::vec meanX; + double meany; + double scaley; + + public: + + GridParams PG; + + std::vector< std::vector > Lambda0; + std::vector Lambda12; + std::vector< std::vector > NnzCount; + std::vector< std::vector > Solutions; + std::vector< std::vector >Intercepts; + std::vector< std::vector > Converged; + + Grid(const T& X, const arma::vec& y, const GridParams& PG); + //~Grid(); + + void Fit(); + +}; + +#endif diff --git a/src/include/Grid1D.hpp b/src/include/Grid1D.hpp new file mode 100644 index 0000000..26c7a06 --- /dev/null +++ b/src/include/Grid1D.hpp @@ -0,0 +1,39 @@ +#ifndef GRID1D_H +#define GRID1D_H +#include +#include +#include +#include +#include "Params.hpp" +#include "GridParams.hpp" +#include "FitResult.hpp" +#include "MakeCD.hpp" + +template +class Grid1D { + private: + std::size_t G_ncols; + Params P; + const T * X; + const arma::vec * y; + std::size_t p; + std::vector>> G; + arma::vec Lambdas; + bool LambdaU; + std::size_t NnzStopNum; + std::vector * Xtr; + arma::rowvec * ytX; + double LambdaMinFactor; + bool PartialSort; + bool XtrAvailable; + double ytXmax2d; + double ScaleDownFactor; + std::size_t NoSelectK; + + public: + Grid1D(const T& Xi, const arma::vec& yi, const GridParams& PG); + ~Grid1D(); + std::vector>> Fit(); +}; + +#endif diff --git a/src/include/Grid2D.hpp b/src/include/Grid2D.hpp new file mode 100644 index 0000000..cff76e2 --- /dev/null +++ b/src/include/Grid2D.hpp @@ -0,0 +1,39 @@ +#ifndef GRID2D_H +#define GRID2D_H +#include +#include +#include "GridParams.hpp" +#include "Params.hpp" +#include "FitResult.hpp" +#include "Grid1D.hpp" +#include "utils.hpp" + +template +class Grid2D +{ + private: + std::size_t G_nrows; + std::size_t G_ncols; + GridParams PG; + const T * X; + const arma::vec * y; + std::size_t p; + std::vector>>> G; + // each inner vector corresponds to a single lambda_1/lambda_2 + + double Lambda2Max; + double Lambda2Min; + double LambdaMinFactor; + std::vector * Xtr; + Params P; + + + public: + Grid2D(const T& Xi, const arma::vec& yi, const GridParams& PGi); + ~Grid2D(); + std::vector>>> Fit(); + +}; + + +#endif diff --git a/src/include/GridParams.hpp b/src/include/GridParams.hpp new file mode 100644 index 0000000..9e9c242 --- /dev/null +++ b/src/include/GridParams.hpp @@ -0,0 +1,28 @@ +#ifndef GRIDPARAMS_H +#define GRIDPARAMS_H +#include +#include "Params.hpp" + +template +struct GridParams +{ + Params P; + std::size_t G_ncols = 100; + std::size_t G_nrows = 10; + bool LambdaU = false; + std::size_t NnzStopNum = 200; + double LambdaMinFactor = 0.01; + arma::vec Lambdas; + std::vector< std::vector > LambdasGrid; + double Lambda2Max = 0.1; + double Lambda2Min = 0.001; + std::string Type = "L0"; + bool PartialSort = true; + bool XtrAvailable = false; + double ytXmax; + std::vector * Xtr; + double ScaleDownFactor = 0.8; + bool intercept; +}; + +#endif diff --git a/src/include/Interface.h b/src/include/Interface.h deleted file mode 100644 index 4f33daf..0000000 --- a/src/include/Interface.h +++ /dev/null @@ -1,16 +0,0 @@ -#ifndef RINTERFACE_H -#define RINTERFACE_H - -#include -#include -#include "RcppArmadillo.h" -#include "Grid.h" -#include "GridParams.h" -#include "FitResult.h" - - -inline void to_arma_error() { - Rcpp::stop("L0Learn.fit only supports sparse matricies (dgCMatrix), 2D arrays (Dense Matricies)"); -} - -#endif // RINTERFACE_H diff --git a/src/include/L0Learn.hpp b/src/include/L0Learn.hpp new file mode 100644 index 0000000..0003f26 --- /dev/null +++ b/src/include/L0Learn.hpp @@ -0,0 +1,324 @@ +#ifndef INTERFACE_H +#define INTERFACE_H + +#include +#include +#include +#include +#include +#include "FitResult.hpp" +#include "Grid.hpp" +#include "GridParams.hpp" + +// Make an external struct + +struct fitmodel +{ + const std::vector > Lambda0; + const std::vector Lambda12; + const std::vector > NnzCount; + const arma::field Beta; + const std::vector > Intercept; + const std::vector > Converged; + + fitmodel(std::vector > lambda0, + std::vector lambda12, + std::vector > nnzCount, + arma::field beta, + std::vector > intercept, + std::vector > converged): + Lambda0(std::move(lambda0)), + Lambda12(std::move(lambda12)), + NnzCount(std::move(nnzCount)), + Beta(std::move(beta)), + Intercept(std::move(intercept)), + Converged(std::move(converged)){} +}; + +struct cvfitmodel : fitmodel +{ + const arma::field CVMeans; + const arma::field CVSDs; + + cvfitmodel(std::vector > lambda0, + std::vector lambda12, + std::vector > nnzCount, + arma::field beta, + std::vector > intercept, + std::vector > converged, + arma::field cVMeans, + arma::field cVSDs) : + fitmodel(std::move(lambda0), + std::move(lambda12), + std::move(nnzCount), + std::move(beta), + std::move(intercept), + std::move(converged)), + CVMeans(std::move(cVMeans)), + CVSDs(std::move(cVSDs)){} +}; + + + +template +GridParams makeGridParams(const std::string Loss, const std::string Penalty, + const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, + const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, + const bool PartialSort, const std::size_t MaxIters, const double rtol, + const double atol, const bool ActiveSet, const std::size_t ActiveSetNum, + const std::size_t MaxNumSwaps, const double ScaleDownFactor, + const std::size_t ScreenSize, const bool LambdaU, + const std::vector< std::vector > Lambdas, + const std::size_t ExcludeFirstK, const bool Intercept, + const bool withBounds, const arma::vec &Lows, const arma::vec &Highs){ + GridParams PG; + PG.NnzStopNum = NnzStopNum; + PG.G_ncols = G_ncols; + PG.G_nrows = G_nrows; + PG.Lambda2Max = Lambda2Max; + PG.Lambda2Min = Lambda2Min; + PG.LambdaMinFactor = Lambda2Min; // + PG.PartialSort = PartialSort; + PG.ScaleDownFactor = ScaleDownFactor; + PG.LambdaU = LambdaU; + PG.LambdasGrid = Lambdas; + PG.Lambdas = Lambdas[0]; // to handle the case of L0 (i.e., Grid1D) + PG.intercept = Intercept; + + Params P; + PG.P = P; + PG.P.MaxIters = MaxIters; + PG.P.rtol = rtol; + PG.P.atol = atol; + PG.P.ActiveSet = ActiveSet; + PG.P.ActiveSetNum = ActiveSetNum; + PG.P.MaxNumSwaps = MaxNumSwaps; + PG.P.ScreenSize = ScreenSize; + PG.P.NoSelectK = ExcludeFirstK; + PG.P.intercept = Intercept; + PG.P.withBounds = withBounds; + PG.P.Lows = Lows; + PG.P.Highs = Highs; + + if (Loss == "SquaredError") { + PG.P.Specs.SquaredError = true; + } else if (Loss == "Logistic") { + PG.P.Specs.Logistic = true; + PG.P.Specs.Classification = true; + } else if (Loss == "SquaredHinge") { + PG.P.Specs.SquaredHinge = true; + PG.P.Specs.Classification = true; + } + + if (Algorithm == "CD") { + PG.P.Specs.CD = true; + } else if (Algorithm == "CDPSI") { + PG.P.Specs.PSI = true; + } + + if (Penalty == "L0") { + PG.P.Specs.L0 = true; + } else if (Penalty == "L0L2") { + PG.P.Specs.L0L2 = true; + } else if (Penalty == "L0L1") { + PG.P.Specs.L0L1 = true; + } + return PG; +} + + +template +fitmodel L0LearnFit(const T& X, const arma::vec& y, const std::string Loss, const std::string Penalty, + const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, + const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, + const bool PartialSort, const std::size_t MaxIters, const double rtol, const double atol, + const bool ActiveSet, const std::size_t ActiveSetNum, const std::size_t MaxNumSwaps, + const double ScaleDownFactor, const std::size_t ScreenSize, const bool LambdaU, + const std::vector< std::vector > Lambdas, const std::size_t ExcludeFirstK, + const bool Intercept, const bool withBounds, const arma::vec &Lows, + const arma::vec &Highs){ + + GridParams PG = makeGridParams(Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, + Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, + ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, + LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs); + + Grid G(X, y, PG); + G.Fit(); + + // Next Construct the list of Sparse Beta Matrices. + + auto p = X.n_cols; + arma::field Bs(G.Lambda12.size()); + + for (std::size_t i=0; i +cvfitmodel L0LearnCV(const T& X, const arma::vec& y, const std::string Loss, + const std::string Penalty, const std::string Algorithm, + const unsigned int NnzStopNum, const unsigned int G_ncols, + const unsigned int G_nrows, const double Lambda2Max, + const double Lambda2Min, const bool PartialSort, + const unsigned int MaxIters, const double rtol, + const double atol, const bool ActiveSet, + const unsigned int ActiveSetNum, + const unsigned int MaxNumSwaps, const double ScaleDownFactor, + const unsigned int ScreenSize, const bool LambdaU, + const std::vector< std::vector > Lambdas, + const unsigned int nfolds, const double seed, + const unsigned int ExcludeFirstK, const bool Intercept, + const bool withBounds, const arma::vec &Lows, + const arma::vec &Highs){ + + GridParams PG = makeGridParams(Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, + Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, + ActiveSet,ActiveSetNum, MaxNumSwaps, ScaleDownFactor, + ScreenSize,LambdaU, Lambdas, ExcludeFirstK, Intercept, + withBounds, Lows, Highs); + + Grid G(X, y, PG); + G.Fit(); + + // Next Construct the list of Sparse Beta Matrices. + + auto p = X.n_cols; + auto n = X.n_rows; + arma::field Bs(G.Lambda12.size()); + + for (std::size_t i=0; i >(G.size()); + //Intercepts = std::vector< std::vector >(G.size()); + + std::size_t Ngamma = G.Lambda12.size(); + + //std::vector< arma::mat > CVError (G.Solutions.size()); + arma::field< arma::mat > CVError (G.Solutions.size()); + + for (std::size_t i=0; i(0, X.n_rows-1, X.n_rows); + + arma::uvec indices = arma::shuffle(a); + + int samplesperfold = std::ceil(n/double(nfolds)); + int samplesinlastfold = samplesperfold - (samplesperfold*nfolds - n); + + std::vector fullindices(X.n_rows); + std::iota(fullindices.begin(), fullindices.end(), 0); + + + for (std::size_t j=0; j validationindices; + if (j < nfolds-1) + validationindices.resize(samplesperfold); + else + validationindices.resize(samplesinlastfold); + + std::iota(validationindices.begin(), validationindices.end(), samplesperfold*j); + + std::vector trainingindices; + + std::set_difference(fullindices.begin(), fullindices.end(), validationindices.begin(), validationindices.end(), + std::inserter(trainingindices, trainingindices.begin())); + + + // validationindicesarma contains the randomly permuted validation indices as a uvec + arma::uvec validationindicesarma; + arma::uvec validationindicestemp = arma::conv_to< arma::uvec >::from(validationindices); + validationindicesarma = indices.elem(validationindicestemp); + + // trainingindicesarma is similar to validationindicesarma but for training + arma::uvec trainingindicesarma; + + arma::uvec trainingindicestemp = arma::conv_to< arma::uvec >::from(trainingindices); + + + trainingindicesarma = indices.elem(trainingindicestemp); + + + T Xtraining = matrix_rows_get(X, trainingindicesarma); + + arma::mat ytraining = y.elem(trainingindicesarma); + + T Xvalidation = matrix_rows_get(X, validationindicesarma); + + arma::mat yvalidation = y.elem(validationindicesarma); + + PG.LambdaU = true; + PG.XtrAvailable = false; // reset XtrAvailable since its changed upon every call + PG.LambdasGrid = G.Lambda0; + PG.NnzStopNum = p+1; // remove any constraints on the supp size when fitting over the cv folds // +1 is imp to avoid =p edge case + if (PG.P.Specs.L0 == true){ + PG.Lambdas = PG.LambdasGrid[0]; + } + Grid Gtraining(Xtraining, ytraining, PG); + Gtraining.Fit(); + + for (std::size_t i=0; i 0); + CVError[i](k,j) = arma::sum(onemyxb.elem(indices) % onemyxb.elem(indices)) / yvalidation.n_rows; + } + } + } + } + + arma::field CVMeans(Ngamma); + arma::field CVSDs(Ngamma); + + for (std::size_t i=0; i +#include "Params.hpp" +#include "CD.hpp" +#include "CDL0.hpp" +#include "CDL012.hpp" +#include "CDL012Swaps.hpp" +#include "CDL012Logistic.hpp" +#include "CDL012SquaredHinge.hpp" +#include "CDL012LogisticSwaps.hpp" +#include "CDL012SquaredHingeSwaps.hpp" + + +template +CDBase * make_CD(const T& Xi, const arma::vec& yi, const Params& P) { + if (P.Specs.SquaredError) { + if (P.Specs.CD) { + if (P.Specs.L0) { + return new CDL0(Xi, yi, P); + } else { + return new CDL012(Xi, yi, P); + } + } else if (P.Specs.PSI) { + return new CDL012Swaps(Xi, yi, P); + } + } else if (P.Specs.Logistic) { + if (P.Specs.CD) { + return new CDL012Logistic(Xi, yi, P); + } else if (P.Specs.PSI) { + return new CDL012LogisticSwaps(Xi, yi, P); + } + } else if (P.Specs.SquaredHinge) { + if (P.Specs.CD) { + return new CDL012SquaredHinge(Xi, yi, P); + } else if (P.Specs.PSI) { + return new CDL012SquaredHingeSwaps(Xi, yi, P); + } + } + return new CDL0(Xi, yi, P); // handle later +} + + +#endif \ No newline at end of file diff --git a/src/include/Model.hpp b/src/include/Model.hpp new file mode 100644 index 0000000..a1be074 --- /dev/null +++ b/src/include/Model.hpp @@ -0,0 +1,22 @@ +#ifndef MODEL_H +#define MODEL_H + +struct Model { + + bool SquaredError = false; + bool Logistic = false; + bool SquaredHinge = false; + bool Classification = false; + + bool CD = false; + bool PSI = false; + + bool L0 = false; + bool L0L1 = false; + bool L0L2 = false; + bool L1 = false; + bool L1Relaxed = false; + +}; + +#endif diff --git a/src/include/Normalize.hpp b/src/include/Normalize.hpp new file mode 100644 index 0000000..12aa665 --- /dev/null +++ b/src/include/Normalize.hpp @@ -0,0 +1,52 @@ +#ifndef NORMALIZE_H +#define NORMALIZE_H + +#include +#include +#include "utils.hpp" +#include "BetaVector.hpp" + +std::tuple DeNormalize(beta_vector & B_scaled, + arma::vec & BetaMultiplier, + arma::vec & meanX, double meany); + +template +std::tuple Normalize(const T& X, + const arma::vec& y, + T& X_normalized, + arma::vec & y_normalized, + bool Normalizey, + bool intercept) { + + arma::rowvec meanX = matrix_center(X, X_normalized, intercept); + arma::rowvec scaleX = matrix_normalize(X_normalized); + + arma::vec BetaMultiplier; + double meany = 0; + double scaley; + if (Normalizey) { + if (intercept){ + meany = arma::mean(y); + } + y_normalized = y - meany; + + // TODO: Use l2_norm + scaley = arma::norm(y_normalized, 2); + + // properly handle cases where y is constant + if (scaley == 0){ + scaley = 1; + } + + y_normalized = y_normalized / scaley; + BetaMultiplier = scaley / (scaleX.t()); // transpose scale to get a col vec + // Multiplying the learned Beta by BetaMultiplier gives the optimal Beta on the original scale + } else { + y_normalized = y; + BetaMultiplier = 1 / (scaleX.t()); // transpose scale to get a col vec + scaley = 1; + } + return std::make_tuple(BetaMultiplier, meanX.t(), meany, scaley); +} + +#endif // NORMALIZE_H diff --git a/src/include/Params.hpp b/src/include/Params.hpp new file mode 100644 index 0000000..34f970c --- /dev/null +++ b/src/include/Params.hpp @@ -0,0 +1,40 @@ +#ifndef PARAMS_H +#define PARAMS_H +#include +#include +#include "Model.hpp" +#include "BetaVector.hpp" + +template +struct Params { + + Model Specs; + std::vector ModelParams {0, 0, 0, 2}; + std::size_t MaxIters = 500; + double rtol = 1e-8; + double atol = 1e-12; + char Init = 'z'; // 'z' => zeros + std::size_t RandomStartSize = 10; + beta_vector * InitialSol; + double b0 = 0; // intercept + char CyclingOrder = 'c'; + std::vector Uorder; + bool ActiveSet = true; + std::size_t ActiveSetNum = 6; + std::size_t MaxNumSwaps = 200; // Used by CDSwaps + std::vector * Xtr; + arma::rowvec * ytX; + std::map * D; + std::size_t Iter = 0; // Current iteration number in the grid + std::size_t ScreenSize = 1000; + arma::vec * r; + T * Xy; // used for classification. + std::size_t NoSelectK = 0; + bool intercept = false; + bool withBounds = false; + arma::vec Lows; + arma::vec Highs; + +}; + +#endif diff --git a/src/include/Test_Interface.h b/src/include/Test_Interface.h deleted file mode 100644 index 788aa7a..0000000 --- a/src/include/Test_Interface.h +++ /dev/null @@ -1,8 +0,0 @@ -#ifndef R_TEST_INTERFACE_H -#define R_TEST_INTERFACE_H - -#include -#include "utils.h" -#include "BetaVector.h" - -#endif //R_TEST_INTERFACE_H \ No newline at end of file diff --git a/src/include/utils.hpp b/src/include/utils.hpp new file mode 100644 index 0000000..44eaafc --- /dev/null +++ b/src/include/utils.hpp @@ -0,0 +1,216 @@ +#ifndef L0LEARN_UTILS_HPP +#define L0LEARN_UTILS_HPP +#include +#include +#include "BetaVector.hpp" + + +template +inline T clamp(T x, T low, T high) { + // -O3 Compiler should remove branches + if (x < low) + x = low; + if (x > high) + x = high; + return x; +} + +template +arma::vec inline matrix_column_get(const arma::mat &mat, T1 col){ + return mat.unsafe_col(col); +} + +template +arma::vec inline matrix_column_get(const arma::sp_mat &mat, T1 col){ + return arma::vec(mat.col(col)); +} + +template +arma::mat inline matrix_rows_get(const arma::mat &mat, const T1 vector_of_row_indices){ + return mat.rows(vector_of_row_indices); +} + +template +arma::sp_mat inline matrix_rows_get(const arma::sp_mat &mat, const T1 vector_of_row_indices){ + // Option for CV for random splitting or contiguous splitting. + // 1 - N without permutations splitting at floor(N/n_folds) + arma::sp_mat row_mat = arma::sp_mat(vector_of_row_indices.n_elem, mat.n_cols); + + for (auto i = 0; i < vector_of_row_indices.n_elem; i++){ + auto row_index = vector_of_row_indices(i); + arma::sp_mat::const_row_iterator begin = mat.begin_row(row_index); + arma::sp_mat::const_row_iterator end = mat.end_row(row_index); + + for (; begin != end; ++begin){ + row_mat(i, begin.col()) = *begin; + } + } + return row_mat; +} + +template +arma::mat inline matrix_vector_schur_product(const arma::mat &mat, const T1 &y){ + // return mat[i, j] * y[i] for each j + return mat.each_col() % *y; +} + +template +arma::sp_mat inline matrix_vector_schur_product(const arma::sp_mat &mat, const T1 &y){ + + arma::sp_mat Xy = arma::sp_mat(mat); + arma::sp_mat::iterator begin = Xy.begin(); + arma::sp_mat::iterator end = Xy.end(); + + auto yp = (*y); + for (; begin != end; ++begin){ + auto row = begin.row(); + *begin = (*begin) * yp(row); + } + return Xy; +} + +template +arma::sp_mat inline matrix_vector_divide(const arma::sp_mat& mat, const T1 &u){ + arma::sp_mat divided_mat = arma::sp_mat(mat); + + //auto up = (*u); + arma::sp_mat::iterator begin = divided_mat.begin(); + arma::sp_mat::iterator end = divided_mat.end(); + for ( ; begin != end; ++begin){ + *begin = (*begin) / u(begin.row()); + } + return divided_mat; +} + +template +arma::mat inline matrix_vector_divide(const arma::mat& mat, const T1 &u){ + return mat.each_col() / u; +} + +arma::rowvec inline matrix_column_sums(const arma::mat& mat){ + return arma::sum(mat, 0); +} + +arma::rowvec inline matrix_column_sums(const arma::sp_mat& mat){ + return arma::rowvec(arma::sum(mat, 0)); +} + +template +double inline matrix_column_dot(const arma::mat &mat, T1 col, const T2 &u){ + return arma::dot(matrix_column_get(mat, col), u); +} + +template +double inline matrix_column_dot(const arma::sp_mat &mat, T1 col, const T2 &u){ + return arma::dot(matrix_column_get(mat, col), u); +} + +template +arma::vec inline matrix_column_mult(const arma::mat &mat, T1 col, const T2 &u){ + return matrix_column_get(mat, col)*u; +} + +template +arma::vec inline matrix_column_mult(const arma::sp_mat &mat, T1 col, const T2 &u){ + return matrix_column_get(mat, col)*u; +} + +void inline clamp_by_vector(arma::vec &B, const arma::vec& lows, const arma::vec& highs){ + const std::size_t n = B.n_rows; + for (std::size_t i = 0; i < n; i++){ + B.at(i) = clamp(B.at(i), lows.at(i), highs.at(i)); + } +} + +// void clamp_by_vector(arma::sp_mat &B, const arma::vec& lows, const arma::vec& highs){ +// // See above implementation without filter for error. +// auto begin = B.begin(); +// auto end = B.end(); +// +// std::vector inds; +// for (; begin != end; ++begin) +// inds.push_back(begin.row()); +// +// auto n = B.size(); +// inds.erase(std::remove_if(inds.begin(), +// inds.end(), +// [n](size_t x){return (x > n) && (x < 0);}), +// inds.end()); +// for (auto& it : inds) { +// double B_item = B(it, 0); +// const double low = lows(it); +// const double high = highs(it); +// B(it, 0) = clamp(B_item, low, high); +// } +// } + +arma::rowvec inline matrix_normalize(arma::sp_mat &mat_norm){ + auto p = mat_norm.n_cols; + arma::rowvec scaleX = arma::zeros(p); // will contain the l2norm of every col + + for (auto col = 0; col < p; col++){ + double l2norm = arma::norm(matrix_column_get(mat_norm, col), 2); + scaleX(col) = l2norm; + } + + scaleX.replace(0, -1); + + for (auto col = 0; col < p; col++){ + arma::sp_mat::col_iterator begin = mat_norm.begin_col(col); + arma::sp_mat::col_iterator end = mat_norm.end_col(col); + for (; begin != end; ++begin) + (*begin) = (*begin)/scaleX(col); + } + + if (mat_norm.has_nan()) + mat_norm.replace(arma::datum::nan, 0); // can handle numerical instabilities. + + return scaleX; +} + +arma::rowvec inline matrix_normalize(arma::mat& mat_norm){ + + auto p = mat_norm.n_cols; + arma::rowvec scaleX = arma::zeros(p); // will contain the l2norm of every col + + for (auto col = 0; col < p; col++) { + double l2norm = arma::norm(matrix_column_get(mat_norm, col), 2); + scaleX(col) = l2norm; + } + + scaleX.replace(0, -1); + mat_norm.each_row() /= scaleX; + + if (mat_norm.has_nan()){ + mat_norm.replace(arma::datum::nan, 0); // can handle numerical instabilities. + } + + return scaleX; +} + +arma::rowvec inline matrix_center(const arma::mat& X, arma::mat& X_normalized, + bool intercept){ + auto p = X.n_cols; + arma::rowvec meanX; + + if (intercept){ + meanX = arma::mean(X, 0); + X_normalized = X.each_row() - meanX; + } else { + meanX = arma::zeros(p); + X_normalized = arma::mat(X); + } + + return meanX; +} + +arma::rowvec inline matrix_center(const arma::sp_mat& X, arma::sp_mat& X_normalized, + bool intercept){ + auto p = X.n_cols; + arma::rowvec meanX = arma::zeros(p); + X_normalized = arma::sp_mat(X); + return meanX; +} + + +#endif //L0LEARN_UTILS_HPP \ No newline at end of file diff --git a/src/profile.cpp b/src/profile.cpp deleted file mode 100644 index 40490e9..0000000 --- a/src/profile.cpp +++ /dev/null @@ -1,16 +0,0 @@ -// #include "RcppArmadillo.h" -// #include "gperftools/profiler.h" -// -// using namespace Rcpp; -// -// // [[Rcpp::export]] -// SEXP start_profiler(SEXP str) { -// ProfilerStart(as(str)); -// return R_NilValue; -// } -// -// // [[Rcpp::export]] -// SEXP stop_profiler() { -// ProfilerStop(); -// return R_NilValue; -// } \ No newline at end of file diff --git a/src/utils.cpp b/src/utils.cpp deleted file mode 100644 index eadecb5..0000000 --- a/src/utils.cpp +++ /dev/null @@ -1,98 +0,0 @@ -#include "utils.h" - -void clamp_by_vector(arma::vec &B, const arma::vec& lows, const arma::vec& highs){ - const std::size_t n = B.n_rows; - for (std::size_t i = 0; i < n; i++){ - B.at(i) = clamp(B.at(i), lows.at(i), highs.at(i)); - } -} - -// void clamp_by_vector(arma::sp_mat &B, const arma::vec& lows, const arma::vec& highs){ -// // See above implementation without filter for error. -// auto begin = B.begin(); -// auto end = B.end(); -// -// std::vector inds; -// for (; begin != end; ++begin) -// inds.push_back(begin.row()); -// -// auto n = B.size(); -// inds.erase(std::remove_if(inds.begin(), -// inds.end(), -// [n](size_t x){return (x > n) && (x < 0);}), -// inds.end()); -// for (auto& it : inds) { -// double B_item = B(it, 0); -// const double low = lows(it); -// const double high = highs(it); -// B(it, 0) = clamp(B_item, low, high); -// } -// } - -arma::rowvec matrix_normalize(arma::sp_mat &mat_norm){ - auto p = mat_norm.n_cols; - arma::rowvec scaleX = arma::zeros(p); // will contain the l2norm of every col - - for (auto col = 0; col < p; col++){ - double l2norm = arma::norm(matrix_column_get(mat_norm, col), 2); - scaleX(col) = l2norm; - } - - scaleX.replace(0, -1); - - for (auto col = 0; col < p; col++){ - arma::sp_mat::col_iterator begin = mat_norm.begin_col(col); - arma::sp_mat::col_iterator end = mat_norm.end_col(col); - for (; begin != end; ++begin) - (*begin) = (*begin)/scaleX(col); - } - - if (mat_norm.has_nan()) - mat_norm.replace(arma::datum::nan, 0); // can handle numerical instabilities. - - return scaleX; -} - -arma::rowvec matrix_normalize(arma::mat& mat_norm){ - - auto p = mat_norm.n_cols; - arma::rowvec scaleX = arma::zeros(p); // will contain the l2norm of every col - - for (auto col = 0; col < p; col++) { - double l2norm = arma::norm(matrix_column_get(mat_norm, col), 2); - scaleX(col) = l2norm; - } - - scaleX.replace(0, -1); - mat_norm.each_row() /= scaleX; - - if (mat_norm.has_nan()){ - mat_norm.replace(arma::datum::nan, 0); // can handle numerical instabilities. - } - - return scaleX; -} - -arma::rowvec matrix_center(const arma::mat& X, arma::mat& X_normalized, - bool intercept){ - auto p = X.n_cols; - arma::rowvec meanX; - - if (intercept){ - meanX = arma::mean(X, 0); - X_normalized = X.each_row() - meanX; - } else { - meanX = arma::zeros(p); - X_normalized = arma::mat(X); - } - - return meanX; -} - -arma::rowvec matrix_center(const arma::sp_mat& X, arma::sp_mat& X_normalized, - bool intercept){ - auto p = X.n_cols; - arma::rowvec meanX = arma::zeros(p); - X_normalized = arma::sp_mat(X); - return meanX; -} From 84da25faea4e88b9d52c4931533a3fde8b4c14cf Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Sun, 29 Aug 2021 16:52:06 -0500 Subject: [PATCH 002/125] Reintroduced RcppArmadillo due to segmentation faults --- R/R/RcppExports.R | 80 +++++- R/R/cvfit.R | 3 +- R/src/CDL012LogisticSwaps.cpp | 2 +- R/src/CDL012SquaredHingeSwaps.cpp | 2 +- R/src/CDL012Swaps.cpp | 4 +- R/src/Grid.cpp | 2 +- R/src/Grid1D.cpp | 2 +- R/src/Grid2D.cpp | 2 +- R/src/Makevars | 2 +- R/src/Makevars.in | 4 +- R/src/Normalize.cpp | 2 +- R/src/R_L0Learn_Interface.h | 138 ++++----- R/src/RcppExports.cpp | 264 +++++++++++++++++- R/src/Test_Interface.cpp | 5 +- R/src/Test_Interface.h | 18 +- .../include/{BetaVector.hpp => BetaVector.h} | 4 +- R/src/include/{CD.hpp => CD.h} | 16 +- R/src/include/{CDL0.hpp => CDL0.h} | 12 +- R/src/include/{CDL012.hpp => CDL012.h} | 10 +- .../{CDL012Logistic.hpp => CDL012Logistic.h} | 12 +- ...ogisticSwaps.hpp => CDL012LogisticSwaps.h} | 16 +- ...2SquaredHinge.hpp => CDL012SquaredHinge.h} | 12 +- ...ngeSwaps.hpp => CDL012SquaredHingeSwaps.h} | 16 +- .../{CDL012Swaps.hpp => CDL012Swaps.h} | 16 +- R/src/include/{CDSwaps.hpp => CDSwaps.h} | 4 +- R/src/include/{FitResult.hpp => FitResult.h} | 4 +- R/src/include/{Grid.hpp => Grid.h} | 12 +- R/src/include/{Grid1D.hpp => Grid1D.h} | 10 +- R/src/include/{Grid2D.hpp => Grid2D.h} | 12 +- .../include/{GridParams.hpp => GridParams.h} | 4 +- R/src/include/{L0Learn.hpp => L0LearnCore.h} | 27 +- R/src/include/{MakeCD.hpp => MakeCD.h} | 22 +- R/src/include/{Model.hpp => Model.h} | 0 R/src/include/{Normalize.hpp => Normalize.h} | 6 +- R/src/include/{Params.hpp => Params.h} | 6 +- R/src/include/{utils.hpp => utils.h} | 6 +- 36 files changed, 512 insertions(+), 245 deletions(-) rename R/src/include/{BetaVector.hpp => BetaVector.h} (98%) rename R/src/include/{CD.hpp => CD.h} (98%) rename R/src/include/{CDL0.hpp => CDL0.h} (97%) rename R/src/include/{CDL012.hpp => CDL012.h} (97%) rename R/src/include/{CDL012Logistic.hpp => CDL012Logistic.h} (98%) rename R/src/include/{CDL012LogisticSwaps.hpp => CDL012LogisticSwaps.h} (85%) rename R/src/include/{CDL012SquaredHinge.hpp => CDL012SquaredHinge.h} (98%) rename R/src/include/{CDL012SquaredHingeSwaps.hpp => CDL012SquaredHingeSwaps.h} (86%) rename R/src/include/{CDL012Swaps.hpp => CDL012Swaps.h} (82%) rename R/src/include/{CDSwaps.hpp => CDSwaps.h} (60%) rename R/src/include/{FitResult.hpp => FitResult.h} (91%) rename R/src/include/{Grid.hpp => Grid.h} (84%) rename R/src/include/{Grid1D.hpp => Grid1D.h} (87%) rename R/src/include/{Grid2D.hpp => Grid2D.h} (84%) rename R/src/include/{GridParams.hpp => GridParams.h} (92%) rename R/src/include/{L0Learn.hpp => L0LearnCore.h} (92%) rename R/src/include/{MakeCD.hpp => MakeCD.h} (77%) rename R/src/include/{Model.hpp => Model.h} (100%) rename R/src/include/{Normalize.hpp => Normalize.h} (96%) rename R/src/include/{Params.hpp => Params.h} (93%) rename R/src/include/{utils.hpp => utils.h} (98%) diff --git a/R/R/RcppExports.R b/R/R/RcppExports.R index c2abdf4..fd57c74 100644 --- a/R/R/RcppExports.R +++ b/R/R/RcppExports.R @@ -6,18 +6,90 @@ cor_matrix <- function(p, base_cor) { } L0LearnFit_sparse <- function(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs) { - invisible(.Call('_L0Learn_L0LearnFit_sparse', PACKAGE = 'L0Learn', X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs)) + .Call('_L0Learn_L0LearnFit_sparse', PACKAGE = 'L0Learn', X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs) } L0LearnFit_dense <- function(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs) { - invisible(.Call('_L0Learn_L0LearnFit_dense', PACKAGE = 'L0Learn', X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs)) + .Call('_L0Learn_L0LearnFit_dense', PACKAGE = 'L0Learn', X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs) } L0LearnCV_sparse <- function(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs) { - invisible(.Call('_L0Learn_L0LearnCV_sparse', PACKAGE = 'L0Learn', X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs)) + .Call('_L0Learn_L0LearnCV_sparse', PACKAGE = 'L0Learn', X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs) } L0LearnCV_dense <- function(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs) { - invisible(.Call('_L0Learn_L0LearnCV_dense', PACKAGE = 'L0Learn', X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs)) + .Call('_L0Learn_L0LearnCV_dense', PACKAGE = 'L0Learn', X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs) +} + +R_matrix_column_get_dense <- function(mat, col) { + .Call('_L0Learn_R_matrix_column_get_dense', PACKAGE = 'L0Learn', mat, col) +} + +R_matrix_column_get_sparse <- function(mat, col) { + .Call('_L0Learn_R_matrix_column_get_sparse', PACKAGE = 'L0Learn', mat, col) +} + +R_matrix_rows_get_dense <- function(mat, rows) { + .Call('_L0Learn_R_matrix_rows_get_dense', PACKAGE = 'L0Learn', mat, rows) +} + +R_matrix_rows_get_sparse <- function(mat, rows) { + .Call('_L0Learn_R_matrix_rows_get_sparse', PACKAGE = 'L0Learn', mat, rows) +} + +R_matrix_vector_schur_product_dense <- function(mat, u) { + .Call('_L0Learn_R_matrix_vector_schur_product_dense', PACKAGE = 'L0Learn', mat, u) +} + +R_matrix_vector_schur_product_sparse <- function(mat, u) { + .Call('_L0Learn_R_matrix_vector_schur_product_sparse', PACKAGE = 'L0Learn', mat, u) +} + +R_matrix_vector_divide_dense <- function(mat, u) { + .Call('_L0Learn_R_matrix_vector_divide_dense', PACKAGE = 'L0Learn', mat, u) +} + +R_matrix_vector_divide_sparse <- function(mat, u) { + .Call('_L0Learn_R_matrix_vector_divide_sparse', PACKAGE = 'L0Learn', mat, u) +} + +R_matrix_column_sums_dense <- function(mat) { + .Call('_L0Learn_R_matrix_column_sums_dense', PACKAGE = 'L0Learn', mat) +} + +R_matrix_column_sums_sparse <- function(mat) { + .Call('_L0Learn_R_matrix_column_sums_sparse', PACKAGE = 'L0Learn', mat) +} + +R_matrix_column_dot_dense <- function(mat, col, u) { + .Call('_L0Learn_R_matrix_column_dot_dense', PACKAGE = 'L0Learn', mat, col, u) +} + +R_matrix_column_dot_sparse <- function(mat, col, u) { + .Call('_L0Learn_R_matrix_column_dot_sparse', PACKAGE = 'L0Learn', mat, col, u) +} + +R_matrix_column_mult_dense <- function(mat, col, u) { + .Call('_L0Learn_R_matrix_column_mult_dense', PACKAGE = 'L0Learn', mat, col, u) +} + +R_matrix_column_mult_sparse <- function(mat, col, u) { + .Call('_L0Learn_R_matrix_column_mult_sparse', PACKAGE = 'L0Learn', mat, col, u) +} + +R_matrix_normalize_dense <- function(mat_norm) { + .Call('_L0Learn_R_matrix_normalize_dense', PACKAGE = 'L0Learn', mat_norm) +} + +R_matrix_normalize_sparse <- function(mat_norm) { + .Call('_L0Learn_R_matrix_normalize_sparse', PACKAGE = 'L0Learn', mat_norm) +} + +R_matrix_center_dense <- function(mat, X_normalized, intercept) { + .Call('_L0Learn_R_matrix_center_dense', PACKAGE = 'L0Learn', mat, X_normalized, intercept) +} + +R_matrix_center_sparse <- function(mat, X_normalized, intercept) { + .Call('_L0Learn_R_matrix_center_sparse', PACKAGE = 'L0Learn', mat, X_normalized, intercept) } diff --git a/R/R/cvfit.R b/R/R/cvfit.R index d8c823c..0b6b173 100644 --- a/R/R/cvfit.R +++ b/R/R/cvfit.R @@ -217,8 +217,7 @@ L0Learn.cvfit <- function(x,y, loss="SquaredError", penalty="L0", algorithm="CD" last = length(M$SuppSize[[i]]) if (M$SuppSize[[i]][last] > maxSuppSize){ if (last == 1){ - print("Warning! Only 1 element in path with support size > maxSuppSize.") - print("Try increasing maxSuppSize to resolve the issue.") + warning("Warning! Only 1 element in path with support size > maxSuppSize. \n Try increasing maxSuppSize to resolve the issue.") } else{ M$SuppSize[[i]] = M$SuppSize[[i]][-last] diff --git a/R/src/CDL012LogisticSwaps.cpp b/R/src/CDL012LogisticSwaps.cpp index 29dad24..75de90f 100644 --- a/R/src/CDL012LogisticSwaps.cpp +++ b/R/src/CDL012LogisticSwaps.cpp @@ -1,4 +1,4 @@ -#include "CDL012LogisticSwaps.hpp" +#include "CDL012LogisticSwaps.h" template CDL012LogisticSwaps::CDL012LogisticSwaps(const T& Xi, const arma::vec& yi, const Params& Pi) : CDSwaps(Xi, yi, Pi) { diff --git a/R/src/CDL012SquaredHingeSwaps.cpp b/R/src/CDL012SquaredHingeSwaps.cpp index 0f14d11..c24ba82 100644 --- a/R/src/CDL012SquaredHingeSwaps.cpp +++ b/R/src/CDL012SquaredHingeSwaps.cpp @@ -1,4 +1,4 @@ -#include "CDL012SquaredHingeSwaps.hpp" +#include "CDL012SquaredHingeSwaps.h" template CDL012SquaredHingeSwaps::CDL012SquaredHingeSwaps(const T& Xi, const arma::vec& yi, const Params& Pi) : CDSwaps(Xi, yi, Pi) { diff --git a/R/src/CDL012Swaps.cpp b/R/src/CDL012Swaps.cpp index 4fe97ed..0438e6c 100644 --- a/R/src/CDL012Swaps.cpp +++ b/R/src/CDL012Swaps.cpp @@ -1,4 +1,4 @@ -#include "CDL012Swaps.hpp" +#include "CDL012Swaps.h" template CDL012Swaps::CDL012Swaps(const T& Xi, const arma::vec& yi, const Params& Pi) : CDSwaps(Xi, yi, Pi) {} @@ -96,4 +96,4 @@ FitResult CDL012Swaps::_Fit() { template class CDL012Swaps; template class CDL012Swaps; - \ No newline at end of file + diff --git a/R/src/Grid.cpp b/R/src/Grid.cpp index 53af1fa..06c40ce 100644 --- a/R/src/Grid.cpp +++ b/R/src/Grid.cpp @@ -1,4 +1,4 @@ -#include "Grid.hpp" +#include "Grid.h" // Assumes PG.P.Specs have been already set template diff --git a/R/src/Grid1D.cpp b/R/src/Grid1D.cpp index 397a1b8..6e064a9 100644 --- a/R/src/Grid1D.cpp +++ b/R/src/Grid1D.cpp @@ -1,4 +1,4 @@ -#include "Grid1D.hpp" +#include "Grid1D.h" template Grid1D::Grid1D(const T& Xi, const arma::vec& yi, const GridParams& PG) { diff --git a/R/src/Grid2D.cpp b/R/src/Grid2D.cpp index 56c98df..ec2c55e 100644 --- a/R/src/Grid2D.cpp +++ b/R/src/Grid2D.cpp @@ -1,4 +1,4 @@ -#include "Grid2D.hpp" +#include "Grid2D.h" template Grid2D::Grid2D(const T& Xi, const arma::vec& yi, const GridParams& PGi) diff --git a/R/src/Makevars b/R/src/Makevars index 7970b9f..990fa39 100644 --- a/R/src/Makevars +++ b/R/src/Makevars @@ -1,3 +1,3 @@ CXX_STD = CXX11 -PKG_CXXFLAGS = +PKG_CXXFLAGS = "-Iinclude" PKG_LIBS= $(LAPACK_LIBS) $(BLAS_LIBS) $(FLIBS) diff --git a/R/src/Makevars.in b/R/src/Makevars.in index 455bdee..740030f 100644 --- a/R/src/Makevars.in +++ b/R/src/Makevars.in @@ -1,3 +1,3 @@ CXX_STD = CXX11 -PKG_CXXFLAGS = @OPENMP_FLAG@ -PKG_LIBS= @OPENMP_FLAG@ $(LAPACK_LIBS) $(BLAS_LIBS) $(FLIBS) +PKG_CXXFLAGS = "-Iinclude" @OPENMP_FLAG@ +PKG_LIBS= @OPENMP_FLAG@ $(LAPACK_LIBS) $(BLAS_LIBS) $(FLIBS) \ No newline at end of file diff --git a/R/src/Normalize.cpp b/R/src/Normalize.cpp index 8b1e6f6..ac9a055 100644 --- a/R/src/Normalize.cpp +++ b/R/src/Normalize.cpp @@ -1,4 +1,4 @@ -#include "Normalize.hpp" +#include "Normalize.h" std::tuple DeNormalize(beta_vector & B_scaled, arma::vec & BetaMultiplier, diff --git a/R/src/R_L0Learn_Interface.h b/R/src/R_L0Learn_Interface.h index 93372a7..f5bba71 100644 --- a/R/src/R_L0Learn_Interface.h +++ b/R/src/R_L0Learn_Interface.h @@ -6,12 +6,12 @@ #include #include #include "RcppArmadillo.h" -#include "L0Learn.hpp" +#include "L0LearnCore.h" #include #include // [[Rcpp::export]] -void L0LearnFit_sparse(const arma::sp_mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, +Rcpp::List L0LearnFit_sparse(const arma::sp_mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, const bool PartialSort, const std::size_t MaxIters, const double rtol, @@ -21,26 +21,23 @@ void L0LearnFit_sparse(const arma::sp_mat& X, const arma::vec& y, const std::str const std::vector< std::vector > Lambdas, const std::size_t ExcludeFirstK, const bool Intercept, const bool withBounds, const arma::vec &Lows, const arma::vec &Highs) { - L0LearnFit(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, - PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, - Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs); - // fitmodel l = L0LearnFit(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, - // PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, - // Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs); - // - // return Rcpp::List::create(Rcpp::Named("lambda") = l.Lambda0, - // Rcpp::Named("gamma") = l.Lambda12, - // Rcpp::Named("SuppSize") = l.NnzCount, - // Rcpp::Named("beta") = l.Beta, - // Rcpp::Named("a0") = l.Intercept, - // Rcpp::Named("Converged") = l.Converged); + fitmodel l = L0LearnFit(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, + PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, + Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs); + + return Rcpp::List::create(Rcpp::Named("lambda") = l.Lambda0, + Rcpp::Named("gamma") = l.Lambda12, + Rcpp::Named("SuppSize") = l.NnzCount, + Rcpp::Named("beta") = l.Beta, + Rcpp::Named("a0") = l.Intercept, + Rcpp::Named("Converged") = l.Converged); } // [[Rcpp::export]] -void L0LearnFit_dense(const arma::mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, +Rcpp::List L0LearnFit_dense(const arma::mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, const bool PartialSort, const std::size_t MaxIters, const double rtol, @@ -51,33 +48,21 @@ void L0LearnFit_dense(const arma::mat& X, const arma::vec& y, const std::string const std::size_t ExcludeFirstK, const bool Intercept, const bool withBounds, const arma::vec &Lows, const arma::vec &Highs) { - Rcpp::Rcout << "L0LearnFit_dense Start\n"; - Rcpp::Rcout << "Lambdas: \n"; - for (std::vector>::const_iterator i = Lambdas.begin(); i != Lambdas.end(); ++i){ - for (std::vector::const_iterator j = (*i).begin(); j != (*i).end(); ++j) - Rcpp::Rcout << *j << ' '; - } - std::this_thread::sleep_for(std::chrono::milliseconds(1000)); - - L0LearnFit(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, - PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, - ScreenSize, LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs); - - // fitmodel l = L0LearnFit(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, - // PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, - // ScreenSize, LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs); - - // return Rcpp::List::create(Rcpp::Named("lambda") = l.Lambda0, - // Rcpp::Named("gamma") = l.Lambda12, - // Rcpp::Named("SuppSize") = l.NnzCount, - // Rcpp::Named("beta") = l.Beta, - // Rcpp::Named("a0") = l.Intercept, - // Rcpp::Named("Converged") = l.Converged); + fitmodel l = L0LearnFit(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, + PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, + ScreenSize, LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs); + + return Rcpp::List::create(Rcpp::Named("lambda") = l.Lambda0, + Rcpp::Named("gamma") = l.Lambda12, + Rcpp::Named("SuppSize") = l.NnzCount, + Rcpp::Named("beta") = l.Beta, + Rcpp::Named("a0") = l.Intercept, + Rcpp::Named("Converged") = l.Converged); } // [[Rcpp::export]] -void L0LearnCV_sparse(const arma::sp_mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, +Rcpp::List L0LearnCV_sparse(const arma::sp_mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, const bool PartialSort, const std::size_t MaxIters, const double rtol, const double atol, @@ -86,33 +71,26 @@ void L0LearnCV_sparse(const arma::sp_mat& X, const arma::vec& y, const std::stri const std::vector< std::vector > Lambdas, const std::size_t nfolds, const double seed, const std::size_t ExcludeFirstK, const bool Intercept, const bool withBounds, const arma::vec &Lows, const arma::vec &Highs){ - - L0LearnCV(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, - G_nrows, Lambda2Max, Lambda2Min, PartialSort, - MaxIters, rtol, atol, ActiveSet, ActiveSetNum, - MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, - Lambdas, nfolds, seed, ExcludeFirstK, Intercept, - withBounds, Lows, Highs); - // cvfitmodel l = L0LearnCV(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, - // G_nrows, Lambda2Max, Lambda2Min, PartialSort, - // MaxIters, rtol, atol, ActiveSet, ActiveSetNum, - // MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, - // Lambdas, nfolds, seed, ExcludeFirstK, Intercept, - // withBounds, Lows, Highs); - // - // return Rcpp::List::create(Rcpp::Named("lambda") = l.Lambda0, - // Rcpp::Named("gamma") = l.Lambda12, - // Rcpp::Named("SuppSize") = l.NnzCount, - // Rcpp::Named("beta") = l.Beta, - // Rcpp::Named("a0") = l.Intercept, - // Rcpp::Named("Converged") = l.Converged, - // Rcpp::Named("CVMeans") = l.CVMeans, - // Rcpp::Named("CVSDs") = l.CVSDs); + cvfitmodel l = L0LearnCV(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, + G_nrows, Lambda2Max, Lambda2Min, PartialSort, + MaxIters, rtol, atol, ActiveSet, ActiveSetNum, + MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, + Lambdas, nfolds, seed, ExcludeFirstK, Intercept, + withBounds, Lows, Highs); + + return Rcpp::List::create(Rcpp::Named("lambda") = l.Lambda0, + Rcpp::Named("gamma") = l.Lambda12, + Rcpp::Named("SuppSize") = l.NnzCount, + Rcpp::Named("beta") = l.Beta, + Rcpp::Named("a0") = l.Intercept, + Rcpp::Named("Converged") = l.Converged, + Rcpp::Named("CVMeans") = l.CVMeans, + Rcpp::Named("CVSDs") = l.CVSDs); } // [[Rcpp::export]] -void L0LearnCV_dense(const arma::mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, +Rcpp::List L0LearnCV_dense(const arma::mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, const bool PartialSort, const std::size_t MaxIters, const double rtol, const double atol, @@ -122,27 +100,21 @@ void L0LearnCV_dense(const arma::mat& X, const arma::vec& y, const std::string L const double seed, const std::size_t ExcludeFirstK, const bool Intercept, const bool withBounds, const arma::vec &Lows, const arma::vec &Highs){ - L0LearnCV(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, - G_nrows, Lambda2Max, Lambda2Min, PartialSort, - MaxIters, rtol, atol, ActiveSet, ActiveSetNum, - MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, - Lambdas, nfolds, seed, ExcludeFirstK, Intercept, - withBounds, Lows, Highs); - // cvfitmodel l = L0LearnCV(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, - // G_nrows, Lambda2Max, Lambda2Min, PartialSort, - // MaxIters, rtol, atol, ActiveSet, ActiveSetNum, - // MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, - // Lambdas, nfolds, seed, ExcludeFirstK, Intercept, - // withBounds, Lows, Highs); - // - // return Rcpp::List::create(Rcpp::Named("lambda") = l.Lambda0, - // Rcpp::Named("gamma") = l.Lambda12, - // Rcpp::Named("SuppSize") = l.NnzCount, - // Rcpp::Named("beta") = l.Beta, - // Rcpp::Named("a0") = l.Intercept, - // Rcpp::Named("Converged") = l.Converged, - // Rcpp::Named("CVMeans") = l.CVMeans, - // Rcpp::Named("CVSDs") = l.CVSDs); + cvfitmodel l = L0LearnCV(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, + G_nrows, Lambda2Max, Lambda2Min, PartialSort, + MaxIters, rtol, atol, ActiveSet, ActiveSetNum, + MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, + Lambdas, nfolds, seed, ExcludeFirstK, Intercept, + withBounds, Lows, Highs); + + return Rcpp::List::create(Rcpp::Named("lambda") = l.Lambda0, + Rcpp::Named("gamma") = l.Lambda12, + Rcpp::Named("SuppSize") = l.NnzCount, + Rcpp::Named("beta") = l.Beta, + Rcpp::Named("a0") = l.Intercept, + Rcpp::Named("Converged") = l.Converged, + Rcpp::Named("CVMeans") = l.CVMeans, + Rcpp::Named("CVSDs") = l.CVSDs); } diff --git a/R/src/RcppExports.cpp b/R/src/RcppExports.cpp index 4011796..1e56f64 100644 --- a/R/src/RcppExports.cpp +++ b/R/src/RcppExports.cpp @@ -19,9 +19,10 @@ BEGIN_RCPP END_RCPP } // L0LearnFit_sparse -void L0LearnFit_sparse(const arma::sp_mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, const bool PartialSort, const std::size_t MaxIters, const double rtol, const double atol, const bool ActiveSet, const std::size_t ActiveSetNum, const std::size_t MaxNumSwaps, const double ScaleDownFactor, const std::size_t ScreenSize, const bool LambdaU, const std::vector< std::vector > Lambdas, const std::size_t ExcludeFirstK, const bool Intercept, const bool withBounds, const arma::vec& Lows, const arma::vec& Highs); +Rcpp::List L0LearnFit_sparse(const arma::sp_mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, const bool PartialSort, const std::size_t MaxIters, const double rtol, const double atol, const bool ActiveSet, const std::size_t ActiveSetNum, const std::size_t MaxNumSwaps, const double ScaleDownFactor, const std::size_t ScreenSize, const bool LambdaU, const std::vector< std::vector > Lambdas, const std::size_t ExcludeFirstK, const bool Intercept, const bool withBounds, const arma::vec& Lows, const arma::vec& Highs); RcppExport SEXP _L0Learn_L0LearnFit_sparse(SEXP XSEXP, SEXP ySEXP, SEXP LossSEXP, SEXP PenaltySEXP, SEXP AlgorithmSEXP, SEXP NnzStopNumSEXP, SEXP G_ncolsSEXP, SEXP G_nrowsSEXP, SEXP Lambda2MaxSEXP, SEXP Lambda2MinSEXP, SEXP PartialSortSEXP, SEXP MaxItersSEXP, SEXP rtolSEXP, SEXP atolSEXP, SEXP ActiveSetSEXP, SEXP ActiveSetNumSEXP, SEXP MaxNumSwapsSEXP, SEXP ScaleDownFactorSEXP, SEXP ScreenSizeSEXP, SEXP LambdaUSEXP, SEXP LambdasSEXP, SEXP ExcludeFirstKSEXP, SEXP InterceptSEXP, SEXP withBoundsSEXP, SEXP LowsSEXP, SEXP HighsSEXP) { BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const arma::sp_mat& >::type X(XSEXP); Rcpp::traits::input_parameter< const arma::vec& >::type y(ySEXP); @@ -49,14 +50,15 @@ BEGIN_RCPP Rcpp::traits::input_parameter< const bool >::type withBounds(withBoundsSEXP); Rcpp::traits::input_parameter< const arma::vec& >::type Lows(LowsSEXP); Rcpp::traits::input_parameter< const arma::vec& >::type Highs(HighsSEXP); - L0LearnFit_sparse(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs); - return R_NilValue; + rcpp_result_gen = Rcpp::wrap(L0LearnFit_sparse(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs)); + return rcpp_result_gen; END_RCPP } // L0LearnFit_dense -void L0LearnFit_dense(const arma::mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, const bool PartialSort, const std::size_t MaxIters, const double rtol, const double atol, const bool ActiveSet, const std::size_t ActiveSetNum, const std::size_t MaxNumSwaps, const double ScaleDownFactor, const std::size_t ScreenSize, const bool LambdaU, const std::vector< std::vector > Lambdas, const std::size_t ExcludeFirstK, const bool Intercept, const bool withBounds, const arma::vec& Lows, const arma::vec& Highs); +Rcpp::List L0LearnFit_dense(const arma::mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, const bool PartialSort, const std::size_t MaxIters, const double rtol, const double atol, const bool ActiveSet, const std::size_t ActiveSetNum, const std::size_t MaxNumSwaps, const double ScaleDownFactor, const std::size_t ScreenSize, const bool LambdaU, const std::vector< std::vector > Lambdas, const std::size_t ExcludeFirstK, const bool Intercept, const bool withBounds, const arma::vec& Lows, const arma::vec& Highs); RcppExport SEXP _L0Learn_L0LearnFit_dense(SEXP XSEXP, SEXP ySEXP, SEXP LossSEXP, SEXP PenaltySEXP, SEXP AlgorithmSEXP, SEXP NnzStopNumSEXP, SEXP G_ncolsSEXP, SEXP G_nrowsSEXP, SEXP Lambda2MaxSEXP, SEXP Lambda2MinSEXP, SEXP PartialSortSEXP, SEXP MaxItersSEXP, SEXP rtolSEXP, SEXP atolSEXP, SEXP ActiveSetSEXP, SEXP ActiveSetNumSEXP, SEXP MaxNumSwapsSEXP, SEXP ScaleDownFactorSEXP, SEXP ScreenSizeSEXP, SEXP LambdaUSEXP, SEXP LambdasSEXP, SEXP ExcludeFirstKSEXP, SEXP InterceptSEXP, SEXP withBoundsSEXP, SEXP LowsSEXP, SEXP HighsSEXP) { BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP); Rcpp::traits::input_parameter< const arma::vec& >::type y(ySEXP); @@ -84,14 +86,15 @@ BEGIN_RCPP Rcpp::traits::input_parameter< const bool >::type withBounds(withBoundsSEXP); Rcpp::traits::input_parameter< const arma::vec& >::type Lows(LowsSEXP); Rcpp::traits::input_parameter< const arma::vec& >::type Highs(HighsSEXP); - L0LearnFit_dense(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs); - return R_NilValue; + rcpp_result_gen = Rcpp::wrap(L0LearnFit_dense(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs)); + return rcpp_result_gen; END_RCPP } // L0LearnCV_sparse -void L0LearnCV_sparse(const arma::sp_mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, const bool PartialSort, const std::size_t MaxIters, const double rtol, const double atol, const bool ActiveSet, const std::size_t ActiveSetNum, const std::size_t MaxNumSwaps, const double ScaleDownFactor, const std::size_t ScreenSize, const bool LambdaU, const std::vector< std::vector > Lambdas, const std::size_t nfolds, const double seed, const std::size_t ExcludeFirstK, const bool Intercept, const bool withBounds, const arma::vec& Lows, const arma::vec& Highs); +Rcpp::List L0LearnCV_sparse(const arma::sp_mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, const bool PartialSort, const std::size_t MaxIters, const double rtol, const double atol, const bool ActiveSet, const std::size_t ActiveSetNum, const std::size_t MaxNumSwaps, const double ScaleDownFactor, const std::size_t ScreenSize, const bool LambdaU, const std::vector< std::vector > Lambdas, const std::size_t nfolds, const double seed, const std::size_t ExcludeFirstK, const bool Intercept, const bool withBounds, const arma::vec& Lows, const arma::vec& Highs); RcppExport SEXP _L0Learn_L0LearnCV_sparse(SEXP XSEXP, SEXP ySEXP, SEXP LossSEXP, SEXP PenaltySEXP, SEXP AlgorithmSEXP, SEXP NnzStopNumSEXP, SEXP G_ncolsSEXP, SEXP G_nrowsSEXP, SEXP Lambda2MaxSEXP, SEXP Lambda2MinSEXP, SEXP PartialSortSEXP, SEXP MaxItersSEXP, SEXP rtolSEXP, SEXP atolSEXP, SEXP ActiveSetSEXP, SEXP ActiveSetNumSEXP, SEXP MaxNumSwapsSEXP, SEXP ScaleDownFactorSEXP, SEXP ScreenSizeSEXP, SEXP LambdaUSEXP, SEXP LambdasSEXP, SEXP nfoldsSEXP, SEXP seedSEXP, SEXP ExcludeFirstKSEXP, SEXP InterceptSEXP, SEXP withBoundsSEXP, SEXP LowsSEXP, SEXP HighsSEXP) { BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const arma::sp_mat& >::type X(XSEXP); Rcpp::traits::input_parameter< const arma::vec& >::type y(ySEXP); @@ -121,14 +124,15 @@ BEGIN_RCPP Rcpp::traits::input_parameter< const bool >::type withBounds(withBoundsSEXP); Rcpp::traits::input_parameter< const arma::vec& >::type Lows(LowsSEXP); Rcpp::traits::input_parameter< const arma::vec& >::type Highs(HighsSEXP); - L0LearnCV_sparse(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs); - return R_NilValue; + rcpp_result_gen = Rcpp::wrap(L0LearnCV_sparse(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs)); + return rcpp_result_gen; END_RCPP } // L0LearnCV_dense -void L0LearnCV_dense(const arma::mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, const bool PartialSort, const std::size_t MaxIters, const double rtol, const double atol, const bool ActiveSet, const std::size_t ActiveSetNum, const std::size_t MaxNumSwaps, const double ScaleDownFactor, const std::size_t ScreenSize, const bool LambdaU, const std::vector< std::vector > Lambdas, const std::size_t nfolds, const double seed, const std::size_t ExcludeFirstK, const bool Intercept, const bool withBounds, const arma::vec& Lows, const arma::vec& Highs); +Rcpp::List L0LearnCV_dense(const arma::mat& X, const arma::vec& y, const std::string Loss, const std::string Penalty, const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, const bool PartialSort, const std::size_t MaxIters, const double rtol, const double atol, const bool ActiveSet, const std::size_t ActiveSetNum, const std::size_t MaxNumSwaps, const double ScaleDownFactor, const std::size_t ScreenSize, const bool LambdaU, const std::vector< std::vector > Lambdas, const std::size_t nfolds, const double seed, const std::size_t ExcludeFirstK, const bool Intercept, const bool withBounds, const arma::vec& Lows, const arma::vec& Highs); RcppExport SEXP _L0Learn_L0LearnCV_dense(SEXP XSEXP, SEXP ySEXP, SEXP LossSEXP, SEXP PenaltySEXP, SEXP AlgorithmSEXP, SEXP NnzStopNumSEXP, SEXP G_ncolsSEXP, SEXP G_nrowsSEXP, SEXP Lambda2MaxSEXP, SEXP Lambda2MinSEXP, SEXP PartialSortSEXP, SEXP MaxItersSEXP, SEXP rtolSEXP, SEXP atolSEXP, SEXP ActiveSetSEXP, SEXP ActiveSetNumSEXP, SEXP MaxNumSwapsSEXP, SEXP ScaleDownFactorSEXP, SEXP ScreenSizeSEXP, SEXP LambdaUSEXP, SEXP LambdasSEXP, SEXP nfoldsSEXP, SEXP seedSEXP, SEXP ExcludeFirstKSEXP, SEXP InterceptSEXP, SEXP withBoundsSEXP, SEXP LowsSEXP, SEXP HighsSEXP) { BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; Rcpp::traits::input_parameter< const arma::mat& >::type X(XSEXP); Rcpp::traits::input_parameter< const arma::vec& >::type y(ySEXP); @@ -158,8 +162,226 @@ BEGIN_RCPP Rcpp::traits::input_parameter< const bool >::type withBounds(withBoundsSEXP); Rcpp::traits::input_parameter< const arma::vec& >::type Lows(LowsSEXP); Rcpp::traits::input_parameter< const arma::vec& >::type Highs(HighsSEXP); - L0LearnCV_dense(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs); - return R_NilValue; + rcpp_result_gen = Rcpp::wrap(L0LearnCV_dense(X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs)); + return rcpp_result_gen; +END_RCPP +} +// R_matrix_column_get_dense +arma::vec R_matrix_column_get_dense(const arma::mat& mat, int col); +RcppExport SEXP _L0Learn_R_matrix_column_get_dense(SEXP matSEXP, SEXP colSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< const arma::mat& >::type mat(matSEXP); + Rcpp::traits::input_parameter< int >::type col(colSEXP); + rcpp_result_gen = Rcpp::wrap(R_matrix_column_get_dense(mat, col)); + return rcpp_result_gen; +END_RCPP +} +// R_matrix_column_get_sparse +arma::vec R_matrix_column_get_sparse(const arma::sp_mat& mat, int col); +RcppExport SEXP _L0Learn_R_matrix_column_get_sparse(SEXP matSEXP, SEXP colSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< const arma::sp_mat& >::type mat(matSEXP); + Rcpp::traits::input_parameter< int >::type col(colSEXP); + rcpp_result_gen = Rcpp::wrap(R_matrix_column_get_sparse(mat, col)); + return rcpp_result_gen; +END_RCPP +} +// R_matrix_rows_get_dense +arma::mat R_matrix_rows_get_dense(const arma::mat& mat, const arma::ucolvec rows); +RcppExport SEXP _L0Learn_R_matrix_rows_get_dense(SEXP matSEXP, SEXP rowsSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< const arma::mat& >::type mat(matSEXP); + Rcpp::traits::input_parameter< const arma::ucolvec >::type rows(rowsSEXP); + rcpp_result_gen = Rcpp::wrap(R_matrix_rows_get_dense(mat, rows)); + return rcpp_result_gen; +END_RCPP +} +// R_matrix_rows_get_sparse +arma::sp_mat R_matrix_rows_get_sparse(const arma::sp_mat& mat, const arma::ucolvec rows); +RcppExport SEXP _L0Learn_R_matrix_rows_get_sparse(SEXP matSEXP, SEXP rowsSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< const arma::sp_mat& >::type mat(matSEXP); + Rcpp::traits::input_parameter< const arma::ucolvec >::type rows(rowsSEXP); + rcpp_result_gen = Rcpp::wrap(R_matrix_rows_get_sparse(mat, rows)); + return rcpp_result_gen; +END_RCPP +} +// R_matrix_vector_schur_product_dense +arma::mat R_matrix_vector_schur_product_dense(const arma::mat& mat, const arma::vec& u); +RcppExport SEXP _L0Learn_R_matrix_vector_schur_product_dense(SEXP matSEXP, SEXP uSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< const arma::mat& >::type mat(matSEXP); + Rcpp::traits::input_parameter< const arma::vec& >::type u(uSEXP); + rcpp_result_gen = Rcpp::wrap(R_matrix_vector_schur_product_dense(mat, u)); + return rcpp_result_gen; +END_RCPP +} +// R_matrix_vector_schur_product_sparse +arma::sp_mat R_matrix_vector_schur_product_sparse(const arma::sp_mat& mat, const arma::vec& u); +RcppExport SEXP _L0Learn_R_matrix_vector_schur_product_sparse(SEXP matSEXP, SEXP uSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< const arma::sp_mat& >::type mat(matSEXP); + Rcpp::traits::input_parameter< const arma::vec& >::type u(uSEXP); + rcpp_result_gen = Rcpp::wrap(R_matrix_vector_schur_product_sparse(mat, u)); + return rcpp_result_gen; +END_RCPP +} +// R_matrix_vector_divide_dense +arma::mat R_matrix_vector_divide_dense(const arma::mat& mat, const arma::vec& u); +RcppExport SEXP _L0Learn_R_matrix_vector_divide_dense(SEXP matSEXP, SEXP uSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< const arma::mat& >::type mat(matSEXP); + Rcpp::traits::input_parameter< const arma::vec& >::type u(uSEXP); + rcpp_result_gen = Rcpp::wrap(R_matrix_vector_divide_dense(mat, u)); + return rcpp_result_gen; +END_RCPP +} +// R_matrix_vector_divide_sparse +arma::sp_mat R_matrix_vector_divide_sparse(const arma::sp_mat& mat, const arma::vec& u); +RcppExport SEXP _L0Learn_R_matrix_vector_divide_sparse(SEXP matSEXP, SEXP uSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< const arma::sp_mat& >::type mat(matSEXP); + Rcpp::traits::input_parameter< const arma::vec& >::type u(uSEXP); + rcpp_result_gen = Rcpp::wrap(R_matrix_vector_divide_sparse(mat, u)); + return rcpp_result_gen; +END_RCPP +} +// R_matrix_column_sums_dense +arma::rowvec R_matrix_column_sums_dense(const arma::mat& mat); +RcppExport SEXP _L0Learn_R_matrix_column_sums_dense(SEXP matSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< const arma::mat& >::type mat(matSEXP); + rcpp_result_gen = Rcpp::wrap(R_matrix_column_sums_dense(mat)); + return rcpp_result_gen; +END_RCPP +} +// R_matrix_column_sums_sparse +arma::rowvec R_matrix_column_sums_sparse(const arma::sp_mat& mat); +RcppExport SEXP _L0Learn_R_matrix_column_sums_sparse(SEXP matSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< const arma::sp_mat& >::type mat(matSEXP); + rcpp_result_gen = Rcpp::wrap(R_matrix_column_sums_sparse(mat)); + return rcpp_result_gen; +END_RCPP +} +// R_matrix_column_dot_dense +double R_matrix_column_dot_dense(const arma::mat& mat, int col, const arma::vec u); +RcppExport SEXP _L0Learn_R_matrix_column_dot_dense(SEXP matSEXP, SEXP colSEXP, SEXP uSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< const arma::mat& >::type mat(matSEXP); + Rcpp::traits::input_parameter< int >::type col(colSEXP); + Rcpp::traits::input_parameter< const arma::vec >::type u(uSEXP); + rcpp_result_gen = Rcpp::wrap(R_matrix_column_dot_dense(mat, col, u)); + return rcpp_result_gen; +END_RCPP +} +// R_matrix_column_dot_sparse +double R_matrix_column_dot_sparse(const arma::sp_mat& mat, int col, const arma::vec u); +RcppExport SEXP _L0Learn_R_matrix_column_dot_sparse(SEXP matSEXP, SEXP colSEXP, SEXP uSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< const arma::sp_mat& >::type mat(matSEXP); + Rcpp::traits::input_parameter< int >::type col(colSEXP); + Rcpp::traits::input_parameter< const arma::vec >::type u(uSEXP); + rcpp_result_gen = Rcpp::wrap(R_matrix_column_dot_sparse(mat, col, u)); + return rcpp_result_gen; +END_RCPP +} +// R_matrix_column_mult_dense +arma::vec R_matrix_column_mult_dense(const arma::mat& mat, int col, double u); +RcppExport SEXP _L0Learn_R_matrix_column_mult_dense(SEXP matSEXP, SEXP colSEXP, SEXP uSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< const arma::mat& >::type mat(matSEXP); + Rcpp::traits::input_parameter< int >::type col(colSEXP); + Rcpp::traits::input_parameter< double >::type u(uSEXP); + rcpp_result_gen = Rcpp::wrap(R_matrix_column_mult_dense(mat, col, u)); + return rcpp_result_gen; +END_RCPP +} +// R_matrix_column_mult_sparse +arma::vec R_matrix_column_mult_sparse(const arma::sp_mat& mat, int col, double u); +RcppExport SEXP _L0Learn_R_matrix_column_mult_sparse(SEXP matSEXP, SEXP colSEXP, SEXP uSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< const arma::sp_mat& >::type mat(matSEXP); + Rcpp::traits::input_parameter< int >::type col(colSEXP); + Rcpp::traits::input_parameter< double >::type u(uSEXP); + rcpp_result_gen = Rcpp::wrap(R_matrix_column_mult_sparse(mat, col, u)); + return rcpp_result_gen; +END_RCPP +} +// R_matrix_normalize_dense +Rcpp::List R_matrix_normalize_dense(arma::mat mat_norm); +RcppExport SEXP _L0Learn_R_matrix_normalize_dense(SEXP mat_normSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< arma::mat >::type mat_norm(mat_normSEXP); + rcpp_result_gen = Rcpp::wrap(R_matrix_normalize_dense(mat_norm)); + return rcpp_result_gen; +END_RCPP +} +// R_matrix_normalize_sparse +Rcpp::List R_matrix_normalize_sparse(arma::sp_mat mat_norm); +RcppExport SEXP _L0Learn_R_matrix_normalize_sparse(SEXP mat_normSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< arma::sp_mat >::type mat_norm(mat_normSEXP); + rcpp_result_gen = Rcpp::wrap(R_matrix_normalize_sparse(mat_norm)); + return rcpp_result_gen; +END_RCPP +} +// R_matrix_center_dense +Rcpp::List R_matrix_center_dense(const arma::mat mat, arma::mat X_normalized, bool intercept); +RcppExport SEXP _L0Learn_R_matrix_center_dense(SEXP matSEXP, SEXP X_normalizedSEXP, SEXP interceptSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< const arma::mat >::type mat(matSEXP); + Rcpp::traits::input_parameter< arma::mat >::type X_normalized(X_normalizedSEXP); + Rcpp::traits::input_parameter< bool >::type intercept(interceptSEXP); + rcpp_result_gen = Rcpp::wrap(R_matrix_center_dense(mat, X_normalized, intercept)); + return rcpp_result_gen; +END_RCPP +} +// R_matrix_center_sparse +Rcpp::List R_matrix_center_sparse(const arma::sp_mat mat, arma::sp_mat X_normalized, bool intercept); +RcppExport SEXP _L0Learn_R_matrix_center_sparse(SEXP matSEXP, SEXP X_normalizedSEXP, SEXP interceptSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< const arma::sp_mat >::type mat(matSEXP); + Rcpp::traits::input_parameter< arma::sp_mat >::type X_normalized(X_normalizedSEXP); + Rcpp::traits::input_parameter< bool >::type intercept(interceptSEXP); + rcpp_result_gen = Rcpp::wrap(R_matrix_center_sparse(mat, X_normalized, intercept)); + return rcpp_result_gen; END_RCPP } @@ -169,6 +391,24 @@ static const R_CallMethodDef CallEntries[] = { {"_L0Learn_L0LearnFit_dense", (DL_FUNC) &_L0Learn_L0LearnFit_dense, 26}, {"_L0Learn_L0LearnCV_sparse", (DL_FUNC) &_L0Learn_L0LearnCV_sparse, 28}, {"_L0Learn_L0LearnCV_dense", (DL_FUNC) &_L0Learn_L0LearnCV_dense, 28}, + {"_L0Learn_R_matrix_column_get_dense", (DL_FUNC) &_L0Learn_R_matrix_column_get_dense, 2}, + {"_L0Learn_R_matrix_column_get_sparse", (DL_FUNC) &_L0Learn_R_matrix_column_get_sparse, 2}, + {"_L0Learn_R_matrix_rows_get_dense", (DL_FUNC) &_L0Learn_R_matrix_rows_get_dense, 2}, + {"_L0Learn_R_matrix_rows_get_sparse", (DL_FUNC) &_L0Learn_R_matrix_rows_get_sparse, 2}, + {"_L0Learn_R_matrix_vector_schur_product_dense", (DL_FUNC) &_L0Learn_R_matrix_vector_schur_product_dense, 2}, + {"_L0Learn_R_matrix_vector_schur_product_sparse", (DL_FUNC) &_L0Learn_R_matrix_vector_schur_product_sparse, 2}, + {"_L0Learn_R_matrix_vector_divide_dense", (DL_FUNC) &_L0Learn_R_matrix_vector_divide_dense, 2}, + {"_L0Learn_R_matrix_vector_divide_sparse", (DL_FUNC) &_L0Learn_R_matrix_vector_divide_sparse, 2}, + {"_L0Learn_R_matrix_column_sums_dense", (DL_FUNC) &_L0Learn_R_matrix_column_sums_dense, 1}, + {"_L0Learn_R_matrix_column_sums_sparse", (DL_FUNC) &_L0Learn_R_matrix_column_sums_sparse, 1}, + {"_L0Learn_R_matrix_column_dot_dense", (DL_FUNC) &_L0Learn_R_matrix_column_dot_dense, 3}, + {"_L0Learn_R_matrix_column_dot_sparse", (DL_FUNC) &_L0Learn_R_matrix_column_dot_sparse, 3}, + {"_L0Learn_R_matrix_column_mult_dense", (DL_FUNC) &_L0Learn_R_matrix_column_mult_dense, 3}, + {"_L0Learn_R_matrix_column_mult_sparse", (DL_FUNC) &_L0Learn_R_matrix_column_mult_sparse, 3}, + {"_L0Learn_R_matrix_normalize_dense", (DL_FUNC) &_L0Learn_R_matrix_normalize_dense, 1}, + {"_L0Learn_R_matrix_normalize_sparse", (DL_FUNC) &_L0Learn_R_matrix_normalize_sparse, 1}, + {"_L0Learn_R_matrix_center_dense", (DL_FUNC) &_L0Learn_R_matrix_center_dense, 3}, + {"_L0Learn_R_matrix_center_sparse", (DL_FUNC) &_L0Learn_R_matrix_center_sparse, 3}, {NULL, NULL, 0} }; diff --git a/R/src/Test_Interface.cpp b/R/src/Test_Interface.cpp index b128db9..77a755c 100644 --- a/R/src/Test_Interface.cpp +++ b/R/src/Test_Interface.cpp @@ -1,4 +1,3 @@ -/* #include "Test_Interface.h" // [[Rcpp::depends(RcppArmadillo)]] @@ -17,7 +16,7 @@ arma::vec R_matrix_column_get_sparse(const arma::sp_mat &mat, int col) { arma::mat R_matrix_rows_get_dense(const arma::mat &mat, const arma::ucolvec rows){ return matrix_rows_get(mat, rows); } - + // [[Rcpp::export]] arma::sp_mat R_matrix_rows_get_sparse(const arma::sp_mat &mat, const arma::ucolvec rows){ return matrix_rows_get(mat, rows); @@ -101,4 +100,4 @@ Rcpp::List R_matrix_center_sparse(const arma::sp_mat mat, arma::sp_mat X_normali arma::rowvec meanX = matrix_center(mat, X_normalized, intercept); return Rcpp::List::create(Rcpp::Named("mat_norm") = X_normalized, Rcpp::Named("MeanX") = meanX); -};*/ +}; diff --git a/R/src/Test_Interface.h b/R/src/Test_Interface.h index 6cd096a..ae550de 100644 --- a/R/src/Test_Interface.h +++ b/R/src/Test_Interface.h @@ -1,8 +1,10 @@ -// #ifndef R_TEST_INTERFACE_H -// #define R_TEST_INTERFACE_H -// -// #include -// #include "utils.h" -// #include "BetaVector.h" -// -// #endif //R_TEST_INTERFACE_H \ No newline at end of file +#ifndef R_TEST_INTERFACE_H +#define R_TEST_INTERFACE_H + +#include +#include "RcppArmadillo.h" +#include "utils.h" +#include "BetaVector.h" + + +#endif //R_TEST_INTERFACE_H \ No newline at end of file diff --git a/R/src/include/BetaVector.hpp b/R/src/include/BetaVector.h similarity index 98% rename from R/src/include/BetaVector.hpp rename to R/src/include/BetaVector.h index 2b694f2..a15491b 100644 --- a/R/src/include/BetaVector.hpp +++ b/R/src/include/BetaVector.h @@ -1,7 +1,7 @@ #ifndef BETA_VECTOR_H #define BETA_VECTOR_H #include -#include +#include "RcppArmadillo.h" /* * arma::vec implementation @@ -100,4 +100,4 @@ inline bool has_same_support(const arma::vec& B1, const arma::vec& B2){ // } // } -#endif // BETA_VECTOR_H \ No newline at end of file +#endif // BETA_VECTOR_H diff --git a/R/src/include/CD.hpp b/R/src/include/CD.h similarity index 98% rename from R/src/include/CD.hpp rename to R/src/include/CD.h index 0c142a0..b6e8616 100644 --- a/R/src/include/CD.hpp +++ b/R/src/include/CD.h @@ -2,12 +2,12 @@ #define CD_H #include #include -#include -#include "BetaVector.hpp" -#include "FitResult.hpp" -#include "Params.hpp" -#include "Model.hpp" -#include "utils.hpp" +#include "RcppArmadillo.h" +#include "BetaVector.h" +#include "FitResult.h" +#include "Params.h" +#include "Model.h" +#include "utils.h" constexpr double lambda1_fudge_factor = 1e-15; @@ -490,13 +490,9 @@ bool CD::CWMinCheck() { bool Cwmin = true; for (auto& i : Sc) { - // Rcpp::Rcout << "CW Iteration: " << i << "\n"; - // std::this_thread::sleep_for(std::chrono::milliseconds(100)); Cwmin = this->UpdateBiCWMinCheck(i, Cwmin); } - // Rcpp::Rcout << "CWMinCheckL " << Cwmin << "\n"; - return Cwmin; } diff --git a/R/src/include/CDL0.hpp b/R/src/include/CDL0.h similarity index 97% rename from R/src/include/CDL0.hpp rename to R/src/include/CDL0.h index 0e47612..7eda481 100644 --- a/R/src/include/CDL0.hpp +++ b/R/src/include/CDL0.h @@ -1,12 +1,12 @@ #ifndef CDL0_H #define CDL0_H #include -#include -#include "CD.hpp" -#include "Params.hpp" -#include "FitResult.hpp" -#include "utils.hpp" -#include "BetaVector.hpp" +#include "RcppArmadillo.h" +#include "CD.h" +#include "Params.h" +#include "FitResult.h" +#include "utils.h" +#include "BetaVector.h" template diff --git a/R/src/include/CDL012.hpp b/R/src/include/CDL012.h similarity index 97% rename from R/src/include/CDL012.hpp rename to R/src/include/CDL012.h index a14c11a..1a8f3cf 100644 --- a/R/src/include/CDL012.hpp +++ b/R/src/include/CDL012.h @@ -1,10 +1,10 @@ #ifndef CDL012_H #define CDL012_H -#include -#include "CD.hpp" -#include "FitResult.hpp" -#include "utils.hpp" -#include "BetaVector.hpp" +#include "RcppArmadillo.h" +#include "CD.h" +#include "FitResult.h" +#include "utils.h" +#include "BetaVector.h" template class CDL012 : public CD>{ diff --git a/R/src/include/CDL012Logistic.hpp b/R/src/include/CDL012Logistic.h similarity index 98% rename from R/src/include/CDL012Logistic.hpp rename to R/src/include/CDL012Logistic.h index 29770d9..a9a6356 100644 --- a/R/src/include/CDL012Logistic.hpp +++ b/R/src/include/CDL012Logistic.h @@ -1,11 +1,11 @@ #ifndef CDL012Logistic_H #define CDL012Logistic_H -#include -#include "CD.hpp" -#include "FitResult.hpp" -#include "Params.hpp" -#include "utils.hpp" -#include "BetaVector.hpp" +#include "RcppArmadillo.h" +#include "CD.h" +#include "FitResult.h" +#include "Params.h" +#include "utils.h" +#include "BetaVector.h" template class CDL012Logistic : public CD> { diff --git a/R/src/include/CDL012LogisticSwaps.hpp b/R/src/include/CDL012LogisticSwaps.h similarity index 85% rename from R/src/include/CDL012LogisticSwaps.hpp rename to R/src/include/CDL012LogisticSwaps.h index d183357..9bbcc53 100644 --- a/R/src/include/CDL012LogisticSwaps.hpp +++ b/R/src/include/CDL012LogisticSwaps.h @@ -1,13 +1,13 @@ #ifndef CDL012LogisticSwaps_H #define CDL012LogisticSwaps_H -#include -#include "CD.hpp" -#include "CDSwaps.hpp" -#include "CDL012Logistic.hpp" -#include "FitResult.hpp" -#include "Params.hpp" -#include "utils.hpp" -#include "BetaVector.hpp" +#include "RcppArmadillo.h" +#include "CD.h" +#include "CDSwaps.h" +#include "CDL012Logistic.h" +#include "FitResult.h" +#include "Params.h" +#include "utils.h" +#include "BetaVector.h" template class CDL012LogisticSwaps : public CDSwaps { diff --git a/R/src/include/CDL012SquaredHinge.hpp b/R/src/include/CDL012SquaredHinge.h similarity index 98% rename from R/src/include/CDL012SquaredHinge.hpp rename to R/src/include/CDL012SquaredHinge.h index 68fa3be..da318ca 100644 --- a/R/src/include/CDL012SquaredHinge.hpp +++ b/R/src/include/CDL012SquaredHinge.h @@ -1,11 +1,11 @@ #ifndef CDL012SquaredHinge_H #define CDL012SquaredHinge_H -#include -#include "CD.hpp" -#include "FitResult.hpp" -#include "Params.hpp" -#include "utils.hpp" -#include "BetaVector.hpp" +#include "RcppArmadillo.h" +#include "CD.h" +#include "FitResult.h" +#include "Params.h" +#include "utils.h" +#include "BetaVector.h" template class CDL012SquaredHinge : public CD> { diff --git a/R/src/include/CDL012SquaredHingeSwaps.hpp b/R/src/include/CDL012SquaredHingeSwaps.h similarity index 86% rename from R/src/include/CDL012SquaredHingeSwaps.hpp rename to R/src/include/CDL012SquaredHingeSwaps.h index a639384..fb3ccff 100644 --- a/R/src/include/CDL012SquaredHingeSwaps.hpp +++ b/R/src/include/CDL012SquaredHingeSwaps.h @@ -1,13 +1,13 @@ #ifndef CDL012SquredHingeSwaps_H #define CDL012SquredHingeSwaps_H -#include -#include "CD.hpp" -#include "CDSwaps.hpp" -#include "CDL012SquaredHinge.hpp" -#include "Params.hpp" -#include "FitResult.hpp" -#include "utils.hpp" -#include "BetaVector.hpp" +#include "RcppArmadillo.h" +#include "CD.h" +#include "CDSwaps.h" +#include "CDL012SquaredHinge.h" +#include "Params.h" +#include "FitResult.h" +#include "utils.h" +#include "BetaVector.h" template class CDL012SquaredHingeSwaps : public CDSwaps { diff --git a/R/src/include/CDL012Swaps.hpp b/R/src/include/CDL012Swaps.h similarity index 82% rename from R/src/include/CDL012Swaps.hpp rename to R/src/include/CDL012Swaps.h index 5819725..ac322fb 100644 --- a/R/src/include/CDL012Swaps.hpp +++ b/R/src/include/CDL012Swaps.h @@ -1,14 +1,14 @@ #ifndef CDL012SWAPS_H #define CDL012SWAPS_H #include -#include -#include "CD.hpp" -#include "CDSwaps.hpp" -#include "CDL012.hpp" -#include "FitResult.hpp" -#include "Params.hpp" -#include "utils.hpp" -#include "BetaVector.hpp" +#include "RcppArmadillo.h" +#include "CD.h" +#include "CDSwaps.h" +#include "CDL012.h" +#include "FitResult.h" +#include "Params.h" +#include "utils.h" +#include "BetaVector.h" template class CDL012Swaps : public CDSwaps { diff --git a/R/src/include/CDSwaps.hpp b/R/src/include/CDSwaps.h similarity index 60% rename from R/src/include/CDSwaps.hpp rename to R/src/include/CDSwaps.h index 280e469..752d0a1 100644 --- a/R/src/include/CDSwaps.hpp +++ b/R/src/include/CDSwaps.h @@ -1,5 +1,5 @@ #ifndef CDSWAPS_H #define CDSWAPS_H -#include "CD.hpp" +#include "CD.h" -#endif \ No newline at end of file +#endif diff --git a/R/src/include/FitResult.hpp b/R/src/include/FitResult.h similarity index 91% rename from R/src/include/FitResult.hpp rename to R/src/include/FitResult.h index 3000090..b95e4f2 100644 --- a/R/src/include/FitResult.hpp +++ b/R/src/include/FitResult.h @@ -1,7 +1,7 @@ #ifndef FITRESULT_H #define FITRESULT_H -#include -#include "BetaVector.hpp" +#include "RcppArmadillo.h" +#include "BetaVector.h" template // Forward Reference to prevent circular dependencies class CDBase; diff --git a/R/src/include/Grid.hpp b/R/src/include/Grid.h similarity index 84% rename from R/src/include/Grid.hpp rename to R/src/include/Grid.h index bdf265d..6eacfbc 100644 --- a/R/src/include/Grid.hpp +++ b/R/src/include/Grid.h @@ -3,12 +3,12 @@ #include #include #include -#include -#include "GridParams.hpp" -#include "FitResult.hpp" -#include "Grid1D.hpp" -#include "Grid2D.hpp" -#include "Normalize.hpp" +#include "RcppArmadillo.h" +#include "GridParams.h" +#include "FitResult.h" +#include "Grid1D.h" +#include "Grid2D.h" +#include "Normalize.h" template class Grid { diff --git a/R/src/include/Grid1D.hpp b/R/src/include/Grid1D.h similarity index 87% rename from R/src/include/Grid1D.hpp rename to R/src/include/Grid1D.h index 26c7a06..35fc2db 100644 --- a/R/src/include/Grid1D.hpp +++ b/R/src/include/Grid1D.h @@ -3,11 +3,11 @@ #include #include #include -#include -#include "Params.hpp" -#include "GridParams.hpp" -#include "FitResult.hpp" -#include "MakeCD.hpp" +#include "RcppArmadillo.h" +#include "Params.h" +#include "GridParams.h" +#include "FitResult.h" +#include "MakeCD.h" template class Grid1D { diff --git a/R/src/include/Grid2D.hpp b/R/src/include/Grid2D.h similarity index 84% rename from R/src/include/Grid2D.hpp rename to R/src/include/Grid2D.h index cff76e2..d7be15d 100644 --- a/R/src/include/Grid2D.hpp +++ b/R/src/include/Grid2D.h @@ -1,12 +1,12 @@ #ifndef GRID2D_H #define GRID2D_H #include -#include -#include "GridParams.hpp" -#include "Params.hpp" -#include "FitResult.hpp" -#include "Grid1D.hpp" -#include "utils.hpp" +#include "RcppArmadillo.h" +#include "GridParams.h" +#include "Params.h" +#include "FitResult.h" +#include "Grid1D.h" +#include "utils.h" template class Grid2D diff --git a/R/src/include/GridParams.hpp b/R/src/include/GridParams.h similarity index 92% rename from R/src/include/GridParams.hpp rename to R/src/include/GridParams.h index 9e9c242..1d2206d 100644 --- a/R/src/include/GridParams.hpp +++ b/R/src/include/GridParams.h @@ -1,7 +1,7 @@ #ifndef GRIDPARAMS_H #define GRIDPARAMS_H -#include -#include "Params.hpp" +#include "RcppArmadillo.h" +#include "Params.h" template struct GridParams diff --git a/R/src/include/L0Learn.hpp b/R/src/include/L0LearnCore.h similarity index 92% rename from R/src/include/L0Learn.hpp rename to R/src/include/L0LearnCore.h index 6d312bf..ef2a6b4 100644 --- a/R/src/include/L0Learn.hpp +++ b/R/src/include/L0LearnCore.h @@ -5,10 +5,10 @@ #include #include #include -#include -#include "FitResult.hpp" -#include "Grid.hpp" -#include "GridParams.hpp" +#include "RcppArmadillo.h" +#include "FitResult.h" +#include "Grid.h" +#include "GridParams.h" #include #include @@ -131,37 +131,24 @@ GridParams makeGridParams(const std::string Loss, const std::string Penalty, template -void L0LearnFit(const T& X, const arma::vec& y, const std::string Loss, const std::string Penalty, +fitmodel L0LearnFit(const T& X, const arma::vec& y, const std::string Loss, const std::string Penalty, const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, const bool PartialSort, const std::size_t MaxIters, const double rtol, const double atol, const bool ActiveSet, const std::size_t ActiveSetNum, const std::size_t MaxNumSwaps, const double ScaleDownFactor, const std::size_t ScreenSize, const bool LambdaU, - const std::vector< std::vector > Lambdas, const std::size_t ExcludeFirstK, + const std::vector< std::vector >& Lambdas, const std::size_t ExcludeFirstK, const bool Intercept, const bool withBounds, const arma::vec &Lows, const arma::vec &Highs){ - - Rcpp::Rcout << "makeGridParams Start\n"; - std::this_thread::sleep_for(std::chrono::milliseconds(1000)); GridParams PG = makeGridParams(Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs); - Rcpp::Rcout << "makeGridParams End\n"; - Rcpp::Rcout << "makeGridParams Grid(...) start\n"; - std::this_thread::sleep_for(std::chrono::milliseconds(1000)); Grid G(X, y, PG); - Rcpp::Rcout << "makeGridParams Grid(...)\n"; - Rcpp::Rcout << "makeGridParams Grid.fit() start\n"; - std::this_thread::sleep_for(std::chrono::milliseconds(1000)); G.Fit(); - Rcpp::Rcout << "makeGridParams Grid.fit() end\n"; - std::this_thread::sleep_for(std::chrono::milliseconds(1000)); - - // Next Construct the list of Sparse Beta Matrices. auto p = X.n_cols; @@ -178,7 +165,7 @@ void L0LearnFit(const T& X, const arma::vec& y, const std::string Loss, const st Bs[i] = B; } - //return fitmodel(G.Lambda0, G.Lambda12, G.NnzCount, Bs, G.Intercepts, G.Converged); + return fitmodel(G.Lambda0, G.Lambda12, G.NnzCount, Bs, G.Intercepts, G.Converged); } diff --git a/R/src/include/MakeCD.hpp b/R/src/include/MakeCD.h similarity index 77% rename from R/src/include/MakeCD.hpp rename to R/src/include/MakeCD.h index 944714b..bb4fe6f 100644 --- a/R/src/include/MakeCD.hpp +++ b/R/src/include/MakeCD.h @@ -1,15 +1,15 @@ #ifndef MAKECD_H #define MAKECD_H -#include -#include "Params.hpp" -#include "CD.hpp" -#include "CDL0.hpp" -#include "CDL012.hpp" -#include "CDL012Swaps.hpp" -#include "CDL012Logistic.hpp" -#include "CDL012SquaredHinge.hpp" -#include "CDL012LogisticSwaps.hpp" -#include "CDL012SquaredHingeSwaps.hpp" +#include "RcppArmadillo.h" +#include "Params.h" +#include "CD.h" +#include "CDL0.h" +#include "CDL012.h" +#include "CDL012Swaps.h" +#include "CDL012Logistic.h" +#include "CDL012SquaredHinge.h" +#include "CDL012LogisticSwaps.h" +#include "CDL012SquaredHingeSwaps.h" template @@ -41,4 +41,4 @@ CDBase * make_CD(const T& Xi, const arma::vec& yi, const Params& P) { } -#endif \ No newline at end of file +#endif diff --git a/R/src/include/Model.hpp b/R/src/include/Model.h similarity index 100% rename from R/src/include/Model.hpp rename to R/src/include/Model.h diff --git a/R/src/include/Normalize.hpp b/R/src/include/Normalize.h similarity index 96% rename from R/src/include/Normalize.hpp rename to R/src/include/Normalize.h index 12aa665..241b89e 100644 --- a/R/src/include/Normalize.hpp +++ b/R/src/include/Normalize.h @@ -2,9 +2,9 @@ #define NORMALIZE_H #include -#include -#include "utils.hpp" -#include "BetaVector.hpp" +#include "RcppArmadillo.h" +#include "utils.h" +#include "BetaVector.h" std::tuple DeNormalize(beta_vector & B_scaled, arma::vec & BetaMultiplier, diff --git a/R/src/include/Params.hpp b/R/src/include/Params.h similarity index 93% rename from R/src/include/Params.hpp rename to R/src/include/Params.h index 34f970c..ec583c7 100644 --- a/R/src/include/Params.hpp +++ b/R/src/include/Params.h @@ -1,9 +1,9 @@ #ifndef PARAMS_H #define PARAMS_H #include -#include -#include "Model.hpp" -#include "BetaVector.hpp" +#include "RcppArmadillo.h" +#include "Model.h" +#include "BetaVector.h" template struct Params { diff --git a/R/src/include/utils.hpp b/R/src/include/utils.h similarity index 98% rename from R/src/include/utils.hpp rename to R/src/include/utils.h index 44eaafc..98cfd37 100644 --- a/R/src/include/utils.hpp +++ b/R/src/include/utils.h @@ -1,8 +1,8 @@ #ifndef L0LEARN_UTILS_HPP #define L0LEARN_UTILS_HPP #include -#include -#include "BetaVector.hpp" +#include "RcppArmadillo.h" +#include "BetaVector.h" template @@ -213,4 +213,4 @@ arma::rowvec inline matrix_center(const arma::sp_mat& X, arma::sp_mat& X_normali } -#endif //L0LEARN_UTILS_HPP \ No newline at end of file +#endif //L0LEARN_UTILS_HPP From 7d24c35daeaab9eb28a8a6584066325292b7573a Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 10 Sep 2021 07:43:57 -0500 Subject: [PATCH 003/125] Python API first commit --- .gitignore | 141 +- python/l0learn/__init__.pxd | 0 python/l0learn/cyarma.cpp | 9207 ++++++++ python/l0learn/cyarma.pxd | 112 + python/l0learn/cyarma.pyx | 240 + python/l0learn/interface.cpp | 17451 ++++++++++++++++ python/l0learn/interface.pxd | 199 + python/l0learn/interface.pyx | 726 + python/l0learn/src/CDL012LogisticSwaps.cpp | 168 + .../l0learn/src/CDL012SquaredHingeSwaps.cpp | 135 + python/l0learn/src/CDL012Swaps.cpp | 99 + python/l0learn/src/Grid.cpp | 69 + python/l0learn/src/Grid1D.cpp | 248 + python/l0learn/src/Grid2D.cpp | 126 + python/l0learn/src/Normalize.cpp | 14 + python/l0learn/src/include/BetaVector.h | 103 + python/l0learn/src/include/CD.h | 529 + python/l0learn/src/include/CDL0.h | 182 + python/l0learn/src/include/CDL012.h | 180 + python/l0learn/src/include/CDL012Logistic.h | 194 + .../l0learn/src/include/CDL012LogisticSwaps.h | 49 + .../l0learn/src/include/CDL012SquaredHinge.h | 208 + .../src/include/CDL012SquaredHingeSwaps.h | 49 + python/l0learn/src/include/CDL012Swaps.h | 39 + python/l0learn/src/include/CDSwaps.h | 5 + python/l0learn/src/include/FitResult.h | 22 + python/l0learn/src/include/Grid.h | 41 + python/l0learn/src/include/Grid1D.h | 39 + python/l0learn/src/include/Grid2D.h | 39 + python/l0learn/src/include/GridParams.h | 28 + python/l0learn/src/include/L0LearnCore.h | 341 + python/l0learn/src/include/MakeCD.h | 44 + python/l0learn/src/include/Model.h | 22 + python/l0learn/src/include/Normalize.h | 52 + python/l0learn/src/include/Params.h | 40 + python/l0learn/src/include/utils.h | 216 + python/l0learn/testing_utils.cpp | 7268 +++++++ python/l0learn/testing_utils.pxd | 17 + python/l0learn/testing_utils.pyx | 95 + python/setup.py | 181 + python/tests/test_cyarma.py | 87 + 41 files changed, 39004 insertions(+), 1 deletion(-) create mode 100644 python/l0learn/__init__.pxd create mode 100644 python/l0learn/cyarma.cpp create mode 100644 python/l0learn/cyarma.pxd create mode 100644 python/l0learn/cyarma.pyx create mode 100644 python/l0learn/interface.cpp create mode 100644 python/l0learn/interface.pxd create mode 100644 python/l0learn/interface.pyx create mode 100644 python/l0learn/src/CDL012LogisticSwaps.cpp create mode 100644 python/l0learn/src/CDL012SquaredHingeSwaps.cpp create mode 100644 python/l0learn/src/CDL012Swaps.cpp create mode 100644 python/l0learn/src/Grid.cpp create mode 100644 python/l0learn/src/Grid1D.cpp create mode 100644 python/l0learn/src/Grid2D.cpp create mode 100644 python/l0learn/src/Normalize.cpp create mode 100644 python/l0learn/src/include/BetaVector.h create mode 100644 python/l0learn/src/include/CD.h create mode 100644 python/l0learn/src/include/CDL0.h create mode 100644 python/l0learn/src/include/CDL012.h create mode 100644 python/l0learn/src/include/CDL012Logistic.h create mode 100644 python/l0learn/src/include/CDL012LogisticSwaps.h create mode 100644 python/l0learn/src/include/CDL012SquaredHinge.h create mode 100644 python/l0learn/src/include/CDL012SquaredHingeSwaps.h create mode 100644 python/l0learn/src/include/CDL012Swaps.h create mode 100644 python/l0learn/src/include/CDSwaps.h create mode 100644 python/l0learn/src/include/FitResult.h create mode 100644 python/l0learn/src/include/Grid.h create mode 100644 python/l0learn/src/include/Grid1D.h create mode 100644 python/l0learn/src/include/Grid2D.h create mode 100644 python/l0learn/src/include/GridParams.h create mode 100644 python/l0learn/src/include/L0LearnCore.h create mode 100644 python/l0learn/src/include/MakeCD.h create mode 100644 python/l0learn/src/include/Model.h create mode 100644 python/l0learn/src/include/Normalize.h create mode 100644 python/l0learn/src/include/Params.h create mode 100644 python/l0learn/src/include/utils.h create mode 100644 python/l0learn/testing_utils.cpp create mode 100644 python/l0learn/testing_utils.pxd create mode 100644 python/l0learn/testing_utils.pyx create mode 100644 python/setup.py create mode 100644 python/tests/test_cyarma.py diff --git a/.gitignore b/.gitignore index 70026c1..2efdd70 100644 --- a/.gitignore +++ b/.gitignore @@ -16,4 +16,143 @@ L0Learn.Rproj config.status debug_log.ipynb tests/profile/ -L0LearnClean.Rproj +.*idea + +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ diff --git a/python/l0learn/__init__.pxd b/python/l0learn/__init__.pxd new file mode 100644 index 0000000..e69de29 diff --git a/python/l0learn/cyarma.cpp b/python/l0learn/cyarma.cpp new file mode 100644 index 0000000..3843ec1 --- /dev/null +++ b/python/l0learn/cyarma.cpp @@ -0,0 +1,9207 @@ +/* Generated by Cython 0.29.21 */ + +/* BEGIN: Cython Metadata +{ + "distutils": { + "depends": [ + "/Users/tnonet/opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/core/include/numpy/arrayobject.h", + "/Users/tnonet/opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/core/include/numpy/ufuncobject.h" + ], + "extra_compile_args": [ + "-std=c++11" + ], + "extra_link_args": [ + "-std=c++11" + ], + "include_dirs": [ + ".", + "/Users/tnonet/opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/core/include" + ], + "language": "c++", + "libraries": [ + "armadillo", + "lapack", + "blas" + ], + "name": "l0learn.cyarma", + "sources": [ + "l0learn/cyarma.pyx" + ] + }, + "module_name": "l0learn.cyarma" +} +END: Cython Metadata */ + +#define PY_SSIZE_T_CLEAN +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.6+ or Python 3.3+. +#else +#define CYTHON_ABI "0_29_21" +#define CYTHON_HEX_VERSION 0x001D15F0 +#define CYTHON_FUTURE_DIVISION 1 +#include +#ifndef offsetof + #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#define __PYX_COMMA , +#ifndef HAVE_LONG_LONG + #if PY_VERSION_HEX >= 0x02070000 + #define HAVE_LONG_LONG + #endif +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION + #define CYTHON_COMPILING_IN_PYPY 1 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 +#elif defined(PYSTON_VERSION) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 1 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 +#else + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) + #define CYTHON_USE_PYTYPE_LOOKUP 1 + #endif + #if PY_MAJOR_VERSION < 3 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #define CYTHON_USE_PYLONG_INTERNALS 1 + #endif + #ifndef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 1 + #endif + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #if PY_VERSION_HEX < 0x030300F0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #elif !defined(CYTHON_USE_UNICODE_WRITER) + #define CYTHON_USE_UNICODE_WRITER 1 + #endif + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #ifndef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #ifndef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 1 + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) + #endif + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #endif + #ifndef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) + #endif + #ifndef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #endif +#endif +#if !defined(CYTHON_FAST_PYCCALL) +#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) +#endif +#if CYTHON_USE_PYLONG_INTERNALS + #include "longintrepr.h" + #undef SHIFT + #undef BASE + #undef MASK + #ifdef SIZEOF_VOID_P + enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; + #endif +#endif +#ifndef __has_attribute + #define __has_attribute(x) 0 +#endif +#ifndef __has_cpp_attribute + #define __has_cpp_attribute(x) 0 +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_MAYBE_UNUSED_VAR +# if defined(__cplusplus) + template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } +# else +# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# endif +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) +#ifdef _MSC_VER + #ifndef _MSC_STDINT_H_ + #if _MSC_VER < 1300 + typedef unsigned char uint8_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int32 uint32_t; + #endif + #endif +#else + #include +#endif +#ifndef CYTHON_FALLTHROUGH + #if defined(__cplusplus) && __cplusplus >= 201103L + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #elif __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_attribute(fallthrough) + #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) + #else + #define CYTHON_FALLTHROUGH + #endif + #endif + #if defined(__clang__ ) && defined(__apple_build_version__) + #if __apple_build_version__ < 7000000 + #undef CYTHON_FALLTHROUGH + #define CYTHON_FALLTHROUGH + #endif + #endif +#endif + +#ifndef __cplusplus + #error "Cython files generated with the C++ option must be compiled with a C++ compiler." +#endif +#ifndef CYTHON_INLINE + #if defined(__clang__) + #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) + #else + #define CYTHON_INLINE inline + #endif +#endif +template +void __Pyx_call_destructor(T& x) { + x.~T(); +} +template +class __Pyx_FakeReference { + public: + __Pyx_FakeReference() : ptr(NULL) { } + __Pyx_FakeReference(const T& ref) : ptr(const_cast(&ref)) { } + T *operator->() { return ptr; } + T *operator&() { return ptr; } + operator T&() { return *ptr; } + template bool operator ==(U other) { return *ptr == other; } + template bool operator !=(U other) { return *ptr != other; } + private: + T *ptr; +}; + +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) + #define Py_OptimizeFlag 0 +#endif +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyClass_Type +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" +#if PY_VERSION_HEX >= 0x030800A4 && PY_VERSION_HEX < 0x030800B2 + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, 0, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#else + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#endif + #define __Pyx_DefaultClassType PyType_Type +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#ifndef METH_STACKLESS + #define METH_STACKLESS 0 +#endif +#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) + #ifndef METH_FASTCALL + #define METH_FASTCALL 0x80 + #endif + typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); + typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, + Py_ssize_t nargs, PyObject *kwnames); +#else + #define __Pyx_PyCFunctionFast _PyCFunctionFast + #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords +#endif +#if CYTHON_FAST_PYCCALL +#define __Pyx_PyFastCFunction_Check(func)\ + ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) +#else +#define __Pyx_PyFastCFunction_Check(func) 0 +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) + #define PyObject_Malloc(s) PyMem_Malloc(s) + #define PyObject_Free(p) PyMem_Free(p) + #define PyObject_Realloc(p) PyMem_Realloc(p) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 + #define PyMem_RawMalloc(n) PyMem_Malloc(n) + #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) + #define PyMem_RawFree(p) PyMem_Free(p) +#endif +#if CYTHON_COMPILING_IN_PYSTON + #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) +#else + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) +#endif +#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x03060000 + #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() +#elif PY_VERSION_HEX >= 0x03000000 + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#else + #define __Pyx_PyThreadState_Current _PyThreadState_Current +#endif +#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) +#include "pythread.h" +#define Py_tss_NEEDS_INIT 0 +typedef int Py_tss_t; +static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { + *key = PyThread_create_key(); + return 0; +} +static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { + Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); + *key = Py_tss_NEEDS_INIT; + return key; +} +static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { + PyObject_Free(key); +} +static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { + return *key != Py_tss_NEEDS_INIT; +} +static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { + PyThread_delete_key(*key); + *key = Py_tss_NEEDS_INIT; +} +static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { + return PyThread_set_key_value(*key, value); +} +static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { + return PyThread_get_key_value(*key); +} +#endif +#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) +#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) +#else +#define __Pyx_PyDict_NewPresized(n) PyDict_New() +#endif +#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +#else +#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) + #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) + #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #endif +#else + #define CYTHON_PEP393_ENABLED 0 + #define PyUnicode_1BYTE_KIND 1 + #define PyUnicode_2BYTE_KIND 2 + #define PyUnicode_4BYTE_KIND 4 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) + #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#endif +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#else + #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#endif +#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) + #define PyObject_ASCII(o) PyObject_Repr(o) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBaseString_Type PyUnicode_Type + #define PyStringObject PyUnicodeObject + #define PyString_Type PyUnicode_Type + #define PyString_Check PyUnicode_Check + #define PyString_CheckExact PyUnicode_CheckExact +#ifndef PyObject_Unicode + #define PyObject_Unicode PyObject_Str +#endif +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#endif +#if PY_VERSION_HEX >= 0x030900A4 + #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) +#else + #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) +#endif +#if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) +#else + #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask + #define PyNumber_Int PyNumber_Long +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY + #ifndef PyUnicode_InternFromString + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) + #endif +#endif +#if PY_VERSION_HEX < 0x030200A4 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t PyInt_AsLong +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) +#else + #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) +#endif +#if CYTHON_USE_ASYNC_SLOTS + #if PY_VERSION_HEX >= 0x030500B1 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods + #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) + #else + #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) + #endif +#else + #define __Pyx_PyType_AsAsync(obj) NULL +#endif +#ifndef __Pyx_PyAsyncMethodsStruct + typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + } __Pyx_PyAsyncMethodsStruct; +#endif + +#if defined(WIN32) || defined(MS_WINDOWS) + #define _USE_MATH_DEFINES +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif +#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) +#define __Pyx_truncl trunc +#else +#define __Pyx_truncl truncl +#endif + +#define __PYX_MARK_ERR_POS(f_index, lineno) \ + { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } +#define __PYX_ERR(f_index, lineno, Ln_error) \ + { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__l0learn__cyarma +#define __PYX_HAVE_API__l0learn__cyarma +/* Early includes */ +#include +#include +#include "numpy/arrayobject.h" +#include "numpy/ufuncobject.h" + + /* NumPy API declarations from "numpy/__init__.pxd" */ + +#include "armadillo" +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { + return (size_t) i < (size_t) limit; +} +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) + #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#else + #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize +#endif +#define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); +#define __Pyx_PySequence_Tuple(obj)\ + (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +#if CYTHON_ASSUME_SAFE_MACROS +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) +#else +#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) +#endif +#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + const char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + if (strcmp(default_encoding_c, "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (!ascii_chars_u) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { + PyErr_Format( + PyExc_ValueError, + "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + Py_DECREF(ascii_chars_u); + Py_DECREF(ascii_chars_b); + } + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); + if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ +static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } + +static PyObject *__pyx_m = NULL; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_cython_runtime = NULL; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static PyObject *__pyx_empty_unicode; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + +/* Header.proto */ +#if !defined(CYTHON_CCOMPLEX) + #if defined(__cplusplus) + #define CYTHON_CCOMPLEX 1 + #elif defined(_Complex_I) + #define CYTHON_CCOMPLEX 1 + #else + #define CYTHON_CCOMPLEX 0 + #endif +#endif +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #include + #else + #include + #endif +#endif +#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) + #undef _Complex_I + #define _Complex_I 1.0fj +#endif + + +static const char *__pyx_f[] = { + "l0learn/cyarma.pyx", + "__init__.pxd", + "type.pxd", +}; +/* BufferFormatStructs.proto */ +#define IS_UNSIGNED(type) (((type) -1) > 0) +struct __Pyx_StructField_; +#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0) +typedef struct { + const char* name; + struct __Pyx_StructField_* fields; + size_t size; + size_t arraysize[8]; + int ndim; + char typegroup; + char is_unsigned; + int flags; +} __Pyx_TypeInfo; +typedef struct __Pyx_StructField_ { + __Pyx_TypeInfo* type; + const char* name; + size_t offset; +} __Pyx_StructField; +typedef struct { + __Pyx_StructField* field; + size_t parent_offset; +} __Pyx_BufFmt_StackElem; +typedef struct { + __Pyx_StructField root; + __Pyx_BufFmt_StackElem* head; + size_t fmt_offset; + size_t new_count, enc_count; + size_t struct_alignment; + int is_complex; + char enc_type; + char new_packmode; + char enc_packmode; + char is_valid_array; +} __Pyx_BufFmt_Context; + + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":689 + * # in Cython to enable them only on the right systems. + * + * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + */ +typedef npy_int8 __pyx_t_5numpy_int8_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":690 + * + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t + */ +typedef npy_int16 __pyx_t_5numpy_int16_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":691 + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< + * ctypedef npy_int64 int64_t + * #ctypedef npy_int96 int96_t + */ +typedef npy_int32 __pyx_t_5numpy_int32_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":692 + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< + * #ctypedef npy_int96 int96_t + * #ctypedef npy_int128 int128_t + */ +typedef npy_int64 __pyx_t_5numpy_int64_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":696 + * #ctypedef npy_int128 int128_t + * + * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + */ +typedef npy_uint8 __pyx_t_5numpy_uint8_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":697 + * + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t + */ +typedef npy_uint16 __pyx_t_5numpy_uint16_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":698 + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< + * ctypedef npy_uint64 uint64_t + * #ctypedef npy_uint96 uint96_t + */ +typedef npy_uint32 __pyx_t_5numpy_uint32_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":699 + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< + * #ctypedef npy_uint96 uint96_t + * #ctypedef npy_uint128 uint128_t + */ +typedef npy_uint64 __pyx_t_5numpy_uint64_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":703 + * #ctypedef npy_uint128 uint128_t + * + * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< + * ctypedef npy_float64 float64_t + * #ctypedef npy_float80 float80_t + */ +typedef npy_float32 __pyx_t_5numpy_float32_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":704 + * + * ctypedef npy_float32 float32_t + * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< + * #ctypedef npy_float80 float80_t + * #ctypedef npy_float128 float128_t + */ +typedef npy_float64 __pyx_t_5numpy_float64_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":713 + * # The int types are mapped a bit surprising -- + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t + */ +typedef npy_long __pyx_t_5numpy_int_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":714 + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong longlong_t + * + */ +typedef npy_longlong __pyx_t_5numpy_long_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":715 + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_ulong uint_t + */ +typedef npy_longlong __pyx_t_5numpy_longlong_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":717 + * ctypedef npy_longlong longlong_t + * + * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t + */ +typedef npy_ulong __pyx_t_5numpy_uint_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":718 + * + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulonglong_t + * + */ +typedef npy_ulonglong __pyx_t_5numpy_ulong_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":719 + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_intp intp_t + */ +typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":721 + * ctypedef npy_ulonglong ulonglong_t + * + * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< + * ctypedef npy_uintp uintp_t + * + */ +typedef npy_intp __pyx_t_5numpy_intp_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":722 + * + * ctypedef npy_intp intp_t + * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< + * + * ctypedef npy_double float_t + */ +typedef npy_uintp __pyx_t_5numpy_uintp_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":724 + * ctypedef npy_uintp uintp_t + * + * ctypedef npy_double float_t # <<<<<<<<<<<<<< + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t + */ +typedef npy_double __pyx_t_5numpy_float_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":725 + * + * ctypedef npy_double float_t + * ctypedef npy_double double_t # <<<<<<<<<<<<<< + * ctypedef npy_longdouble longdouble_t + * + */ +typedef npy_double __pyx_t_5numpy_double_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":726 + * ctypedef npy_double float_t + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cfloat cfloat_t + */ +typedef npy_longdouble __pyx_t_5numpy_longdouble_t; +/* Declarations.proto */ +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< float > __pyx_t_float_complex; + #else + typedef float _Complex __pyx_t_float_complex; + #endif +#else + typedef struct { float real, imag; } __pyx_t_float_complex; +#endif +static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); + +/* Declarations.proto */ +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< double > __pyx_t_double_complex; + #else + typedef double _Complex __pyx_t_double_complex; + #endif +#else + typedef struct { double real, imag; } __pyx_t_double_complex; +#endif +static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); + + +/*--- Type declarations ---*/ + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":728 + * ctypedef npy_longdouble longdouble_t + * + * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t + */ +typedef npy_cfloat __pyx_t_5numpy_cfloat_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":729 + * + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< + * ctypedef npy_clongdouble clongdouble_t + * + */ +typedef npy_cdouble __pyx_t_5numpy_cdouble_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":730 + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cdouble complex_t + */ +typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":732 + * ctypedef npy_clongdouble clongdouble_t + * + * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew1(a): + */ +typedef npy_cdouble __pyx_t_5numpy_complex_t; + +/* --- Runtime support code (head) --- */ +/* Refnanny.proto */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* PyDictVersioning.proto */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) +#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ + (version_var) = __PYX_GET_DICT_VERSION(dict);\ + (cache_var) = (value); +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ + (VAR) = __pyx_dict_cached_value;\ + } else {\ + (VAR) = __pyx_dict_cached_value = (LOOKUP);\ + __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ + }\ +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); +#else +#define __PYX_GET_DICT_VERSION(dict) (0) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); +#endif + +/* GetModuleGlobalName.proto */ +#if CYTHON_USE_DICT_VERSIONS +#define __Pyx_GetModuleGlobalName(var, name) {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ + (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ + __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} +#define __Pyx_GetModuleGlobalNameUncached(var, name) {\ + PY_UINT64_T __pyx_dict_version;\ + PyObject *__pyx_dict_cached_value;\ + (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); +#else +#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) +#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); +#endif + +/* PyIntCompare.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_NeObjC(PyObject *op1, PyObject *op2, long intval, long inplace); + +/* PyCFunctionFastCall.proto */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); +#else +#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) +#endif + +/* PyFunctionFastCall.proto */ +#if CYTHON_FAST_PYCALL +#define __Pyx_PyFunction_FastCall(func, args, nargs)\ + __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); +#else +#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) +#endif +#define __Pyx_BUILD_ASSERT_EXPR(cond)\ + (sizeof(char [1 - 2*!(cond)]) - 1) +#ifndef Py_MEMBER_SIZE +#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) +#endif + static size_t __pyx_pyframe_localsplus_offset = 0; + #include "frameobject.h" + #define __Pxy_PyFrame_Initialize_Offsets()\ + ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ + (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) + #define __Pyx_PyFrame_GetLocalsplus(frame)\ + (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) +#endif + +/* PyObjectCall.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +/* PyObjectCall2Args.proto */ +static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); + +/* PyObjectCallMethO.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* PyObjectFormatSimple.proto */ +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + PyObject_Format(s, f)) +#elif PY_MAJOR_VERSION < 3 + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + likely(PyString_CheckExact(s)) ? PyUnicode_FromEncodedObject(s, NULL, "strict") :\ + PyObject_Format(s, f)) +#elif CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + likely(PyLong_CheckExact(s)) ? PyLong_Type.tp_str(s) :\ + likely(PyFloat_CheckExact(s)) ? PyFloat_Type.tp_str(s) :\ + PyObject_Format(s, f)) +#else + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + PyObject_Format(s, f)) +#endif + +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() PyErr_Occurred() +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +#else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* WriteUnraisableException.proto */ +static void __Pyx_WriteUnraisable(const char *name, int clineno, + int lineno, const char *filename, + int full_traceback, int nogil); + +/* ExtTypeTest.proto */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + +/* IsLittleEndian.proto */ +static CYTHON_INLINE int __Pyx_Is_Little_Endian(void); + +/* BufferFormatCheck.proto */ +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts); +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + __Pyx_TypeInfo* type); + +/* BufferGetAndValidate.proto */ +#define __Pyx_GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)\ + ((obj == Py_None || obj == NULL) ?\ + (__Pyx_ZeroBuffer(buf), 0) :\ + __Pyx__GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)) +static int __Pyx__GetBufferAndValidate(Py_buffer* buf, PyObject* obj, + __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack); +static void __Pyx_ZeroBuffer(Py_buffer* buf); +static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info); +static Py_ssize_t __Pyx_minusones[] = { -1, -1, -1, -1, -1, -1, -1, -1 }; +static Py_ssize_t __Pyx_zeros[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; + +/* BufferFallbackError.proto */ +static void __Pyx_RaiseBufferFallbackError(void); + +/* PyObjectCallNoArg.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); +#else +#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) +#endif + +/* IncludeStringH.proto */ +#include + +/* JoinPyUnicode.proto */ +static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, + Py_UCS4 max_char); + +/* GetItemInt.proto */ +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ + __Pyx_GetItemInt_Generic(o, to_py_func(i)))) +#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, + int is_list, int wraparound, int boundscheck); + +/* ListAppend.proto */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { + PyListObject* L = (PyListObject*) list; + Py_ssize_t len = Py_SIZE(list); + if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { + Py_INCREF(x); + PyList_SET_ITEM(list, len, x); + __Pyx_SET_SIZE(list, len + 1); + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_PyList_Append(L,x) PyList_Append(L,x) +#endif + +#define __Pyx_BufPtrStrided1d(type, buf, i0, s0) (type)((char*)buf + i0 * s0) +/* GetTopmostException.proto */ +#if CYTHON_USE_EXC_INFO_STACK +static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); +#endif + +/* SaveResetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +#else +#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) +#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) +#endif + +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +#else +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +#endif + +/* GetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* TypeImport.proto */ +#ifndef __PYX_HAVE_RT_ImportType_proto +#define __PYX_HAVE_RT_ImportType_proto +enum __Pyx_ImportType_CheckSize { + __Pyx_ImportType_CheckSize_Error = 0, + __Pyx_ImportType_CheckSize_Warn = 1, + __Pyx_ImportType_CheckSize_Ignore = 2 +}; +static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size); +#endif + +/* Import.proto */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +/* ImportFrom.proto */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); + +/* CLineInTraceback.proto */ +#ifdef CYTHON_CLINE_IN_TRACEBACK +#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) +#else +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); +#endif + +/* CodeObjectCache.proto */ +typedef struct { + PyCodeObject* code_object; + int code_line; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; +}; +static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static PyCodeObject *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); + +/* AddTraceback.proto */ +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +/* BufferStructDeclare.proto */ +typedef struct { + Py_ssize_t shape, strides, suboffsets; +} __Pyx_Buf_DimInfo; +typedef struct { + size_t refcount; + Py_buffer pybuffer; +} __Pyx_Buffer; +typedef struct { + __Pyx_Buffer *rcbuffer; + char *data; + __Pyx_Buf_DimInfo diminfo[8]; +} __Pyx_LocalBuf_ND; + +#if PY_MAJOR_VERSION < 3 + static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags); + static void __Pyx_ReleaseBuffer(Py_buffer *view); +#else + #define __Pyx_GetBuffer PyObject_GetBuffer + #define __Pyx_ReleaseBuffer PyBuffer_Release +#endif + + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + +/* RealImag.proto */ +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #define __Pyx_CREAL(z) ((z).real()) + #define __Pyx_CIMAG(z) ((z).imag()) + #else + #define __Pyx_CREAL(z) (__real__(z)) + #define __Pyx_CIMAG(z) (__imag__(z)) + #endif +#else + #define __Pyx_CREAL(z) ((z).real) + #define __Pyx_CIMAG(z) ((z).imag) +#endif +#if defined(__cplusplus) && CYTHON_CCOMPLEX\ + && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103) + #define __Pyx_SET_CREAL(z,x) ((z).real(x)) + #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) +#else + #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) + #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) +#endif + +/* Arithmetic.proto */ +#if CYTHON_CCOMPLEX + #define __Pyx_c_eq_float(a, b) ((a)==(b)) + #define __Pyx_c_sum_float(a, b) ((a)+(b)) + #define __Pyx_c_diff_float(a, b) ((a)-(b)) + #define __Pyx_c_prod_float(a, b) ((a)*(b)) + #define __Pyx_c_quot_float(a, b) ((a)/(b)) + #define __Pyx_c_neg_float(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero_float(z) ((z)==(float)0) + #define __Pyx_c_conj_float(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_abs_float(z) (::std::abs(z)) + #define __Pyx_c_pow_float(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero_float(z) ((z)==0) + #define __Pyx_c_conj_float(z) (conjf(z)) + #if 1 + #define __Pyx_c_abs_float(z) (cabsf(z)) + #define __Pyx_c_pow_float(a, b) (cpowf(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex); + static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex); + #if 1 + static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex, __pyx_t_float_complex); + #endif +#endif + +/* Arithmetic.proto */ +#if CYTHON_CCOMPLEX + #define __Pyx_c_eq_double(a, b) ((a)==(b)) + #define __Pyx_c_sum_double(a, b) ((a)+(b)) + #define __Pyx_c_diff_double(a, b) ((a)-(b)) + #define __Pyx_c_prod_double(a, b) ((a)*(b)) + #define __Pyx_c_quot_double(a, b) ((a)/(b)) + #define __Pyx_c_neg_double(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero_double(z) ((z)==(double)0) + #define __Pyx_c_conj_double(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_abs_double(z) (::std::abs(z)) + #define __Pyx_c_pow_double(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero_double(z) ((z)==0) + #define __Pyx_c_conj_double(z) (conj(z)) + #if 1 + #define __Pyx_c_abs_double(z) (cabs(z)) + #define __Pyx_c_pow_double(a, b) (cpow(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex); + static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex); + #if 1 + static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex, __pyx_t_double_complex); + #endif +#endif + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +/* FastTypeChecks.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); +#else +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) +#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) +#endif +#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) + +/* CheckBinaryVersion.proto */ +static int __Pyx_check_binary_version(void); + +/* FunctionExport.proto */ +static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig); + +/* InitStrings.proto */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); + + +/* Module declarations from 'libcpp' */ + +/* Module declarations from 'cpython.buffer' */ + +/* Module declarations from 'libc.string' */ + +/* Module declarations from 'libc.stdio' */ + +/* Module declarations from '__builtin__' */ + +/* Module declarations from 'cpython.type' */ +static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; + +/* Module declarations from 'cpython' */ + +/* Module declarations from 'cpython.object' */ + +/* Module declarations from 'cpython.ref' */ + +/* Module declarations from 'cpython.mem' */ + +/* Module declarations from 'numpy' */ + +/* Module declarations from 'numpy' */ +static PyTypeObject *__pyx_ptype_5numpy_dtype = 0; +static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; +static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; +static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; +static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; + +/* Module declarations from 'cython' */ + +/* Module declarations from 'l0learn.cyarma' */ +static arma::dmat *__pyx_f_7l0learn_6cyarma_numpy_to_dmat(PyArrayObject *); /*proto*/ +static arma::dvec *__pyx_f_7l0learn_6cyarma_numpy_to_dvec(PyArrayObject *); /*proto*/ +static arma::dvec __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(PyArrayObject *); /*proto*/ +static arma::uvec *__pyx_f_7l0learn_6cyarma_numpy_to_uvec(PyArrayObject *); /*proto*/ +static arma::uvec __pyx_f_7l0learn_6cyarma_numpy_to_uvec_d(PyArrayObject *); /*proto*/ +static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *); /*proto*/ +static arma::sp_dmat __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(PyObject *); /*proto*/ +static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &, PyArrayObject *); /*proto*/ +static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const &, PyArrayObject *, PyArrayObject *, PyArrayObject *); /*proto*/ +static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_double_t = { "double_t", NULL, sizeof(__pyx_t_5numpy_double_t), { 0 }, 0, 'R', 0, 0 }; +static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t = { "uint64_t", NULL, sizeof(__pyx_t_5numpy_uint64_t), { 0 }, 0, IS_UNSIGNED(__pyx_t_5numpy_uint64_t) ? 'U' : 'I', IS_UNSIGNED(__pyx_t_5numpy_uint64_t), 0 }; +#define __Pyx_MODULE_NAME "l0learn.cyarma" +extern int __pyx_module_is_main_l0learn__cyarma; +int __pyx_module_is_main_l0learn__cyarma = 0; + +/* Implementation of 'l0learn.cyarma' */ +static PyObject *__pyx_builtin_enumerate; +static PyObject *__pyx_builtin_TypeError; +static PyObject *__pyx_builtin_ValueError; +static PyObject *__pyx_builtin_range; +static PyObject *__pyx_builtin_ImportError; +static const char __pyx_k_F[] = "F"; +static const char __pyx_k_np[] = "np"; +static const char __pyx_k_copy[] = "copy"; +static const char __pyx_k_data[] = "data"; +static const char __pyx_k_main[] = "__main__"; +static const char __pyx_k_name[] = "__name__"; +static const char __pyx_k_ndim[] = "ndim"; +static const char __pyx_k_test[] = "__test__"; +static const char __pyx_k_dtype[] = "dtype"; +static const char __pyx_k_empty[] = "empty"; +static const char __pyx_k_flags[] = "flags"; +static const char __pyx_k_numpy[] = "numpy"; +static const char __pyx_k_order[] = "order"; +static const char __pyx_k_range[] = "range"; +static const char __pyx_k_shape[] = "shape"; +static const char __pyx_k_astype[] = "astype"; +static const char __pyx_k_double[] = "double"; +static const char __pyx_k_import[] = "__import__"; +static const char __pyx_k_indptr[] = "indptr"; +static const char __pyx_k_isreal[] = "isreal"; +static const char __pyx_k_uint64[] = "uint64"; +static const char __pyx_k_but_got[] = ", but got "; +static const char __pyx_k_indices[] = "indices"; +static const char __pyx_k_owndata[] = "owndata"; +static const char __pyx_k_TypeError[] = "TypeError"; +static const char __pyx_k_enumerate[] = "enumerate"; +static const char __pyx_k_ValueError[] = "ValueError"; +static const char __pyx_k_csc_matrix[] = "csc_matrix"; +static const char __pyx_k_ImportError[] = "ImportError"; +static const char __pyx_k_f_contiguous[] = "f_contiguous"; +static const char __pyx_k_scipy_sparse_csc[] = "scipy.sparse.csc"; +static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; +static const char __pyx_k_expected_x_to_be_of_type[] = "expected x to be of type "; +static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import"; +static const char __pyx_k_expected_each_value_in_values_to[] = "expected each value in values to be a 2D real csc_matrix, but got "; +static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import"; +static const char __pyx_k_expected_each_value_in_values_to_2[] = "expected each value in values to be a 1D real numpy matrix, but got "; +static PyObject *__pyx_n_u_F; +static PyObject *__pyx_n_s_ImportError; +static PyObject *__pyx_n_s_TypeError; +static PyObject *__pyx_n_s_ValueError; +static PyObject *__pyx_n_s_astype; +static PyObject *__pyx_kp_u_but_got; +static PyObject *__pyx_n_s_cline_in_traceback; +static PyObject *__pyx_n_s_copy; +static PyObject *__pyx_n_s_csc_matrix; +static PyObject *__pyx_n_s_data; +static PyObject *__pyx_n_s_double; +static PyObject *__pyx_n_s_dtype; +static PyObject *__pyx_n_s_empty; +static PyObject *__pyx_n_s_enumerate; +static PyObject *__pyx_kp_u_expected_each_value_in_values_to; +static PyObject *__pyx_kp_u_expected_each_value_in_values_to_2; +static PyObject *__pyx_kp_u_expected_x_to_be_of_type; +static PyObject *__pyx_n_s_f_contiguous; +static PyObject *__pyx_n_s_flags; +static PyObject *__pyx_n_s_import; +static PyObject *__pyx_n_s_indices; +static PyObject *__pyx_n_s_indptr; +static PyObject *__pyx_n_s_isreal; +static PyObject *__pyx_n_s_main; +static PyObject *__pyx_n_s_name; +static PyObject *__pyx_n_s_ndim; +static PyObject *__pyx_n_s_np; +static PyObject *__pyx_n_s_numpy; +static PyObject *__pyx_kp_u_numpy_core_multiarray_failed_to; +static PyObject *__pyx_kp_u_numpy_core_umath_failed_to_impor; +static PyObject *__pyx_n_s_order; +static PyObject *__pyx_n_s_owndata; +static PyObject *__pyx_n_s_range; +static PyObject *__pyx_n_s_scipy_sparse_csc; +static PyObject *__pyx_n_s_shape; +static PyObject *__pyx_n_s_test; +static PyObject *__pyx_n_s_uint64; +static PyObject *__pyx_int_1; +static PyObject *__pyx_int_2; +static PyObject *__pyx_tuple_; +static PyObject *__pyx_tuple__2; +/* Late includes */ + +/* "l0learn/cyarma.pyx":86 + * + * ##### Tools to convert numpy arrays to armadillo arrays ###### + * cdef field[sp_dmat] list_to_sp_dmat_field(list values): # <<<<<<<<<<<<<< + * cdef field[sp_dmat] f = field[sp_dmat](len(values)) + * for i, value in enumerate(values): + */ + +static arma::field __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_field(PyObject *__pyx_v_values) { + arma::field __pyx_v_f; + Py_ssize_t __pyx_v_i; + PyObject *__pyx_v_value = NULL; + arma::field __pyx_r; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("list_to_sp_dmat_field", 0); + + /* "l0learn/cyarma.pyx":87 + * ##### Tools to convert numpy arrays to armadillo arrays ###### + * cdef field[sp_dmat] list_to_sp_dmat_field(list values): + * cdef field[sp_dmat] f = field[sp_dmat](len(values)) # <<<<<<<<<<<<<< + * for i, value in enumerate(values): + * if not isinstance(value, csc_matrix) or value.ndim != 2 or np.isreal(value): + */ + if (unlikely(__pyx_v_values == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(0, 87, __pyx_L1_error) + } + __pyx_t_1 = PyList_GET_SIZE(__pyx_v_values); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 87, __pyx_L1_error) + __pyx_v_f = arma::field (__pyx_t_1); + + /* "l0learn/cyarma.pyx":88 + * cdef field[sp_dmat] list_to_sp_dmat_field(list values): + * cdef field[sp_dmat] f = field[sp_dmat](len(values)) + * for i, value in enumerate(values): # <<<<<<<<<<<<<< + * if not isinstance(value, csc_matrix) or value.ndim != 2 or np.isreal(value): + * raise TypeError(f"expected each value in values to be a 2D real csc_matrix, but got {value}") + */ + __pyx_t_1 = 0; + __pyx_t_2 = __pyx_v_values; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; + for (;;) { + if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_4); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 88, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_v_i = __pyx_t_1; + __pyx_t_1 = (__pyx_t_1 + 1); + + /* "l0learn/cyarma.pyx":89 + * cdef field[sp_dmat] f = field[sp_dmat](len(values)) + * for i, value in enumerate(values): + * if not isinstance(value, csc_matrix) or value.ndim != 2 or np.isreal(value): # <<<<<<<<<<<<<< + * raise TypeError(f"expected each value in values to be a 2D real csc_matrix, but got {value}") + * f[i] = numpy_to_sp_dmat_d(value) + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = PyObject_IsInstance(__pyx_v_value, __pyx_t_4); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_7 = ((!(__pyx_t_6 != 0)) != 0); + if (!__pyx_t_7) { + } else { + __pyx_t_5 = __pyx_t_7; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_value, __pyx_n_s_ndim); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = __Pyx_PyInt_NeObjC(__pyx_t_4, __pyx_int_2, 2, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (!__pyx_t_7) { + } else { + __pyx_t_5 = __pyx_t_7; + goto __pyx_L6_bool_binop_done; + } + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_isreal); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + } + } + __pyx_t_8 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_4, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_v_value); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_5 = __pyx_t_7; + __pyx_L6_bool_binop_done:; + if (unlikely(__pyx_t_5)) { + + /* "l0learn/cyarma.pyx":90 + * for i, value in enumerate(values): + * if not isinstance(value, csc_matrix) or value.ndim != 2 or np.isreal(value): + * raise TypeError(f"expected each value in values to be a 2D real csc_matrix, but got {value}") # <<<<<<<<<<<<<< + * f[i] = numpy_to_sp_dmat_d(value) + * return f + */ + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_value, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_each_value_in_values_to, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(0, 90, __pyx_L1_error) + + /* "l0learn/cyarma.pyx":89 + * cdef field[sp_dmat] f = field[sp_dmat](len(values)) + * for i, value in enumerate(values): + * if not isinstance(value, csc_matrix) or value.ndim != 2 or np.isreal(value): # <<<<<<<<<<<<<< + * raise TypeError(f"expected each value in values to be a 2D real csc_matrix, but got {value}") + * f[i] = numpy_to_sp_dmat_d(value) + */ + } + + /* "l0learn/cyarma.pyx":91 + * if not isinstance(value, csc_matrix) or value.ndim != 2 or np.isreal(value): + * raise TypeError(f"expected each value in values to be a 2D real csc_matrix, but got {value}") + * f[i] = numpy_to_sp_dmat_d(value) # <<<<<<<<<<<<<< + * return f + * + */ + (__pyx_v_f[__pyx_v_i]) = __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(__pyx_v_value); + + /* "l0learn/cyarma.pyx":88 + * cdef field[sp_dmat] list_to_sp_dmat_field(list values): + * cdef field[sp_dmat] f = field[sp_dmat](len(values)) + * for i, value in enumerate(values): # <<<<<<<<<<<<<< + * if not isinstance(value, csc_matrix) or value.ndim != 2 or np.isreal(value): + * raise TypeError(f"expected each value in values to be a 2D real csc_matrix, but got {value}") + */ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "l0learn/cyarma.pyx":92 + * raise TypeError(f"expected each value in values to be a 2D real csc_matrix, but got {value}") + * f[i] = numpy_to_sp_dmat_d(value) + * return f # <<<<<<<<<<<<<< + * + * cdef field[dvec] list_to_dvec_field(list values): + */ + __pyx_r = __pyx_v_f; + goto __pyx_L0; + + /* "l0learn/cyarma.pyx":86 + * + * ##### Tools to convert numpy arrays to armadillo arrays ###### + * cdef field[sp_dmat] list_to_sp_dmat_field(list values): # <<<<<<<<<<<<<< + * cdef field[sp_dmat] f = field[sp_dmat](len(values)) + * for i, value in enumerate(values): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_WriteUnraisable("l0learn.cyarma.list_to_sp_dmat_field", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_value); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/cyarma.pyx":94 + * return f + * + * cdef field[dvec] list_to_dvec_field(list values): # <<<<<<<<<<<<<< + * cdef field[dvec] f = field[dvec](len(values)) + * for i, value in enumerate(values): + */ + +static arma::field __pyx_f_7l0learn_6cyarma_list_to_dvec_field(PyObject *__pyx_v_values) { + arma::field __pyx_v_f; + Py_ssize_t __pyx_v_i; + PyObject *__pyx_v_value = NULL; + arma::field __pyx_r; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("list_to_dvec_field", 0); + + /* "l0learn/cyarma.pyx":95 + * + * cdef field[dvec] list_to_dvec_field(list values): + * cdef field[dvec] f = field[dvec](len(values)) # <<<<<<<<<<<<<< + * for i, value in enumerate(values): + * if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isreal(value): + */ + if (unlikely(__pyx_v_values == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(0, 95, __pyx_L1_error) + } + __pyx_t_1 = PyList_GET_SIZE(__pyx_v_values); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 95, __pyx_L1_error) + __pyx_v_f = arma::field (__pyx_t_1); + + /* "l0learn/cyarma.pyx":96 + * cdef field[dvec] list_to_dvec_field(list values): + * cdef field[dvec] f = field[dvec](len(values)) + * for i, value in enumerate(values): # <<<<<<<<<<<<<< + * if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isreal(value): + * raise TypeError(f"expected each value in values to be a 1D real numpy matrix, but got {value}") + */ + __pyx_t_1 = 0; + __pyx_t_2 = __pyx_v_values; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; + for (;;) { + if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_4); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 96, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 96, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_v_i = __pyx_t_1; + __pyx_t_1 = (__pyx_t_1 + 1); + + /* "l0learn/cyarma.pyx":97 + * cdef field[dvec] f = field[dvec](len(values)) + * for i, value in enumerate(values): + * if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isreal(value): # <<<<<<<<<<<<<< + * raise TypeError(f"expected each value in values to be a 1D real numpy matrix, but got {value}") + * f[i] = numpy_to_dvec_d(value) + */ + __pyx_t_6 = __Pyx_TypeCheck(__pyx_v_value, __pyx_ptype_5numpy_ndarray); + __pyx_t_7 = ((!(__pyx_t_6 != 0)) != 0); + if (!__pyx_t_7) { + } else { + __pyx_t_5 = __pyx_t_7; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_value, __pyx_n_s_ndim); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = __Pyx_PyInt_NeObjC(__pyx_t_4, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (!__pyx_t_7) { + } else { + __pyx_t_5 = __pyx_t_7; + goto __pyx_L6_bool_binop_done; + } + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_isreal); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + } + } + __pyx_t_8 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_4, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_v_value); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_6 = ((!__pyx_t_7) != 0); + __pyx_t_5 = __pyx_t_6; + __pyx_L6_bool_binop_done:; + if (unlikely(__pyx_t_5)) { + + /* "l0learn/cyarma.pyx":98 + * for i, value in enumerate(values): + * if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isreal(value): + * raise TypeError(f"expected each value in values to be a 1D real numpy matrix, but got {value}") # <<<<<<<<<<<<<< + * f[i] = numpy_to_dvec_d(value) + * return f + */ + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_value, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 98, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_each_value_in_values_to_2, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 98, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 98, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(0, 98, __pyx_L1_error) + + /* "l0learn/cyarma.pyx":97 + * cdef field[dvec] f = field[dvec](len(values)) + * for i, value in enumerate(values): + * if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isreal(value): # <<<<<<<<<<<<<< + * raise TypeError(f"expected each value in values to be a 1D real numpy matrix, but got {value}") + * f[i] = numpy_to_dvec_d(value) + */ + } + + /* "l0learn/cyarma.pyx":99 + * if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isreal(value): + * raise TypeError(f"expected each value in values to be a 1D real numpy matrix, but got {value}") + * f[i] = numpy_to_dvec_d(value) # <<<<<<<<<<<<<< + * return f + * + */ + if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 99, __pyx_L1_error) + (__pyx_v_f[__pyx_v_i]) = __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_value)); + + /* "l0learn/cyarma.pyx":96 + * cdef field[dvec] list_to_dvec_field(list values): + * cdef field[dvec] f = field[dvec](len(values)) + * for i, value in enumerate(values): # <<<<<<<<<<<<<< + * if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isreal(value): + * raise TypeError(f"expected each value in values to be a 1D real numpy matrix, but got {value}") + */ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "l0learn/cyarma.pyx":100 + * raise TypeError(f"expected each value in values to be a 1D real numpy matrix, but got {value}") + * f[i] = numpy_to_dvec_d(value) + * return f # <<<<<<<<<<<<<< + * + * cdef dmat * numpy_to_dmat(np.ndarray[np.double_t, ndim=2] X): + */ + __pyx_r = __pyx_v_f; + goto __pyx_L0; + + /* "l0learn/cyarma.pyx":94 + * return f + * + * cdef field[dvec] list_to_dvec_field(list values): # <<<<<<<<<<<<<< + * cdef field[dvec] f = field[dvec](len(values)) + * for i, value in enumerate(values): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_WriteUnraisable("l0learn.cyarma.list_to_dvec_field", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_value); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/cyarma.pyx":102 + * return f + * + * cdef dmat * numpy_to_dmat(np.ndarray[np.double_t, ndim=2] X): # <<<<<<<<<<<<<< + * # TODO: Add checks on X (Size, ...) + * # TODO: Add flags for new dmat. See: Advanced constructors in http://arma.sourceforge.net/docs.html#Mat + */ + +static arma::dmat *__pyx_f_7l0learn_6cyarma_numpy_to_dmat(PyArrayObject *__pyx_v_X) { + arma::dmat *__pyx_v_aR_p; + __Pyx_LocalBuf_ND __pyx_pybuffernd_X; + __Pyx_Buffer __pyx_pybuffer_X; + arma::dmat *__pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyArrayObject *__pyx_t_6 = NULL; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("numpy_to_dmat", 0); + __Pyx_INCREF((PyObject *)__pyx_v_X); + __pyx_pybuffer_X.pybuffer.buf = NULL; + __pyx_pybuffer_X.refcount = 0; + __pyx_pybuffernd_X.data = NULL; + __pyx_pybuffernd_X.rcbuffer = &__pyx_pybuffer_X; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_X.rcbuffer->pybuffer, (PyObject*)__pyx_v_X, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 102, __pyx_L1_error) + } + __pyx_pybuffernd_X.diminfo[0].strides = __pyx_pybuffernd_X.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_X.diminfo[0].shape = __pyx_pybuffernd_X.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_X.diminfo[1].strides = __pyx_pybuffernd_X.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_X.diminfo[1].shape = __pyx_pybuffernd_X.rcbuffer->pybuffer.shape[1]; + + /* "l0learn/cyarma.pyx":107 + * # mat(ptr_aux_mem, n_rows, n_cols, copy_aux_mem = true, strict = false) + * # TODO: raise Warning on copy or replication of data + * if not (X.flags.f_contiguous or X.flags.owndata): # <<<<<<<<<<<<<< + * X = X.copy(order="F") + * cdef dmat *aR_p = new dmat( X.data, X.shape[0], X.shape[1], False, True) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_X), __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_f_contiguous); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 107, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!__pyx_t_4) { + } else { + __pyx_t_1 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_X), __pyx_n_s_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_owndata); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 107, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_1 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + __pyx_t_4 = ((!__pyx_t_1) != 0); + if (__pyx_t_4) { + + /* "l0learn/cyarma.pyx":108 + * # TODO: raise Warning on copy or replication of data + * if not (X.flags.f_contiguous or X.flags.owndata): + * X = X.copy(order="F") # <<<<<<<<<<<<<< + * cdef dmat *aR_p = new dmat( X.data, X.shape[0], X.shape[1], False, True) + * return aR_p + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_X), __pyx_n_s_copy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_order, __pyx_n_u_F) < 0) __PYX_ERR(0, 108, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 108, __pyx_L1_error) + __pyx_t_6 = ((PyArrayObject *)__pyx_t_5); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_X.rcbuffer->pybuffer); + __pyx_t_7 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_X.rcbuffer->pybuffer, (PyObject*)__pyx_t_6, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack); + if (unlikely(__pyx_t_7 < 0)) { + PyErr_Fetch(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10); + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_X.rcbuffer->pybuffer, (PyObject*)__pyx_v_X, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) { + Py_XDECREF(__pyx_t_8); Py_XDECREF(__pyx_t_9); Py_XDECREF(__pyx_t_10); + __Pyx_RaiseBufferFallbackError(); + } else { + PyErr_Restore(__pyx_t_8, __pyx_t_9, __pyx_t_10); + } + __pyx_t_8 = __pyx_t_9 = __pyx_t_10 = 0; + } + __pyx_pybuffernd_X.diminfo[0].strides = __pyx_pybuffernd_X.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_X.diminfo[0].shape = __pyx_pybuffernd_X.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_X.diminfo[1].strides = __pyx_pybuffernd_X.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_X.diminfo[1].shape = __pyx_pybuffernd_X.rcbuffer->pybuffer.shape[1]; + if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 108, __pyx_L1_error) + } + __pyx_t_6 = 0; + __Pyx_DECREF_SET(__pyx_v_X, ((PyArrayObject *)__pyx_t_5)); + __pyx_t_5 = 0; + + /* "l0learn/cyarma.pyx":107 + * # mat(ptr_aux_mem, n_rows, n_cols, copy_aux_mem = true, strict = false) + * # TODO: raise Warning on copy or replication of data + * if not (X.flags.f_contiguous or X.flags.owndata): # <<<<<<<<<<<<<< + * X = X.copy(order="F") + * cdef dmat *aR_p = new dmat( X.data, X.shape[0], X.shape[1], False, True) + */ + } + + /* "l0learn/cyarma.pyx":109 + * if not (X.flags.f_contiguous or X.flags.owndata): + * X = X.copy(order="F") + * cdef dmat *aR_p = new dmat( X.data, X.shape[0], X.shape[1], False, True) # <<<<<<<<<<<<<< + * return aR_p + * + */ + __pyx_v_aR_p = new arma::dmat(((double *)__pyx_v_X->data), (__pyx_v_X->dimensions[0]), (__pyx_v_X->dimensions[1]), 0, 1); + + /* "l0learn/cyarma.pyx":110 + * X = X.copy(order="F") + * cdef dmat *aR_p = new dmat( X.data, X.shape[0], X.shape[1], False, True) + * return aR_p # <<<<<<<<<<<<<< + * + * cdef dmat numpy_to_dmat_d(np.ndarray[np.double_t, ndim=2] X): + */ + __pyx_r = __pyx_v_aR_p; + goto __pyx_L0; + + /* "l0learn/cyarma.pyx":102 + * return f + * + * cdef dmat * numpy_to_dmat(np.ndarray[np.double_t, ndim=2] X): # <<<<<<<<<<<<<< + * # TODO: Add checks on X (Size, ...) + * # TODO: Add flags for new dmat. See: Advanced constructors in http://arma.sourceforge.net/docs.html#Mat + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_X.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_WriteUnraisable("l0learn.cyarma.numpy_to_dmat", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_X.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_X); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/cyarma.pyx":112 + * return aR_p + * + * cdef dmat numpy_to_dmat_d(np.ndarray[np.double_t, ndim=2] X): # <<<<<<<<<<<<<< + * cdef dmat * aR_p = numpy_to_dmat(X) + * cdef dmat aR = deref(aR_p) + */ + +static arma::dmat __pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(PyArrayObject *__pyx_v_X) { + arma::dmat *__pyx_v_aR_p; + arma::dmat __pyx_v_aR; + __Pyx_LocalBuf_ND __pyx_pybuffernd_X; + __Pyx_Buffer __pyx_pybuffer_X; + arma::dmat __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("numpy_to_dmat_d", 0); + __pyx_pybuffer_X.pybuffer.buf = NULL; + __pyx_pybuffer_X.refcount = 0; + __pyx_pybuffernd_X.data = NULL; + __pyx_pybuffernd_X.rcbuffer = &__pyx_pybuffer_X; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_X.rcbuffer->pybuffer, (PyObject*)__pyx_v_X, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 112, __pyx_L1_error) + } + __pyx_pybuffernd_X.diminfo[0].strides = __pyx_pybuffernd_X.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_X.diminfo[0].shape = __pyx_pybuffernd_X.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_X.diminfo[1].strides = __pyx_pybuffernd_X.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_X.diminfo[1].shape = __pyx_pybuffernd_X.rcbuffer->pybuffer.shape[1]; + + /* "l0learn/cyarma.pyx":113 + * + * cdef dmat numpy_to_dmat_d(np.ndarray[np.double_t, ndim=2] X): + * cdef dmat * aR_p = numpy_to_dmat(X) # <<<<<<<<<<<<<< + * cdef dmat aR = deref(aR_p) + * del aR_p + */ + __pyx_v_aR_p = __pyx_f_7l0learn_6cyarma_numpy_to_dmat(((PyArrayObject *)__pyx_v_X)); + + /* "l0learn/cyarma.pyx":114 + * cdef dmat numpy_to_dmat_d(np.ndarray[np.double_t, ndim=2] X): + * cdef dmat * aR_p = numpy_to_dmat(X) + * cdef dmat aR = deref(aR_p) # <<<<<<<<<<<<<< + * del aR_p + * return aR + */ + __pyx_v_aR = (*__pyx_v_aR_p); + + /* "l0learn/cyarma.pyx":115 + * cdef dmat * aR_p = numpy_to_dmat(X) + * cdef dmat aR = deref(aR_p) + * del aR_p # <<<<<<<<<<<<<< + * return aR + * + */ + delete __pyx_v_aR_p; + + /* "l0learn/cyarma.pyx":116 + * cdef dmat aR = deref(aR_p) + * del aR_p + * return aR # <<<<<<<<<<<<<< + * + * cdef dvec * numpy_to_dvec(np.ndarray[np.double_t, ndim=1] x): + */ + __pyx_r = __pyx_v_aR; + goto __pyx_L0; + + /* "l0learn/cyarma.pyx":112 + * return aR_p + * + * cdef dmat numpy_to_dmat_d(np.ndarray[np.double_t, ndim=2] X): # <<<<<<<<<<<<<< + * cdef dmat * aR_p = numpy_to_dmat(X) + * cdef dmat aR = deref(aR_p) + */ + + /* function exit code */ + __pyx_L1_error:; + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_X.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_WriteUnraisable("l0learn.cyarma.numpy_to_dmat_d", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __Pyx_pretend_to_initialize(&__pyx_r); + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_X.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/cyarma.pyx":118 + * return aR + * + * cdef dvec * numpy_to_dvec(np.ndarray[np.double_t, ndim=1] x): # <<<<<<<<<<<<<< + * if not (x.flags.f_contiguous or x.flags.owndata): + * x = x.copy() + */ + +static arma::dvec *__pyx_f_7l0learn_6cyarma_numpy_to_dvec(PyArrayObject *__pyx_v_x) { + arma::dvec *__pyx_v_ar_p; + __Pyx_LocalBuf_ND __pyx_pybuffernd_x; + __Pyx_Buffer __pyx_pybuffer_x; + arma::dvec *__pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyArrayObject *__pyx_t_6 = NULL; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("numpy_to_dvec", 0); + __Pyx_INCREF((PyObject *)__pyx_v_x); + __pyx_pybuffer_x.pybuffer.buf = NULL; + __pyx_pybuffer_x.refcount = 0; + __pyx_pybuffernd_x.data = NULL; + __pyx_pybuffernd_x.rcbuffer = &__pyx_pybuffer_x; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_v_x, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 118, __pyx_L1_error) + } + __pyx_pybuffernd_x.diminfo[0].strides = __pyx_pybuffernd_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x.diminfo[0].shape = __pyx_pybuffernd_x.rcbuffer->pybuffer.shape[0]; + + /* "l0learn/cyarma.pyx":119 + * + * cdef dvec * numpy_to_dvec(np.ndarray[np.double_t, ndim=1] x): + * if not (x.flags.f_contiguous or x.flags.owndata): # <<<<<<<<<<<<<< + * x = x.copy() + * cdef dvec *ar_p = new dvec( x.data, x.shape[0], False, True) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_x), __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_f_contiguous); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 119, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!__pyx_t_4) { + } else { + __pyx_t_1 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_x), __pyx_n_s_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_owndata); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 119, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_1 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + __pyx_t_4 = ((!__pyx_t_1) != 0); + if (__pyx_t_4) { + + /* "l0learn/cyarma.pyx":120 + * cdef dvec * numpy_to_dvec(np.ndarray[np.double_t, ndim=1] x): + * if not (x.flags.f_contiguous or x.flags.owndata): + * x = x.copy() # <<<<<<<<<<<<<< + * cdef dvec *ar_p = new dvec( x.data, x.shape[0], False, True) + * return ar_p + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_x), __pyx_n_s_copy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 120, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 120, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 120, __pyx_L1_error) + __pyx_t_6 = ((PyArrayObject *)__pyx_t_2); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); + __pyx_t_7 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_t_6, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack); + if (unlikely(__pyx_t_7 < 0)) { + PyErr_Fetch(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10); + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_v_x, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + Py_XDECREF(__pyx_t_8); Py_XDECREF(__pyx_t_9); Py_XDECREF(__pyx_t_10); + __Pyx_RaiseBufferFallbackError(); + } else { + PyErr_Restore(__pyx_t_8, __pyx_t_9, __pyx_t_10); + } + __pyx_t_8 = __pyx_t_9 = __pyx_t_10 = 0; + } + __pyx_pybuffernd_x.diminfo[0].strides = __pyx_pybuffernd_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x.diminfo[0].shape = __pyx_pybuffernd_x.rcbuffer->pybuffer.shape[0]; + if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 120, __pyx_L1_error) + } + __pyx_t_6 = 0; + __Pyx_DECREF_SET(__pyx_v_x, ((PyArrayObject *)__pyx_t_2)); + __pyx_t_2 = 0; + + /* "l0learn/cyarma.pyx":119 + * + * cdef dvec * numpy_to_dvec(np.ndarray[np.double_t, ndim=1] x): + * if not (x.flags.f_contiguous or x.flags.owndata): # <<<<<<<<<<<<<< + * x = x.copy() + * cdef dvec *ar_p = new dvec( x.data, x.shape[0], False, True) + */ + } + + /* "l0learn/cyarma.pyx":121 + * if not (x.flags.f_contiguous or x.flags.owndata): + * x = x.copy() + * cdef dvec *ar_p = new dvec( x.data, x.shape[0], False, True) # <<<<<<<<<<<<<< + * return ar_p + * + */ + __pyx_v_ar_p = new arma::dvec(((double *)__pyx_v_x->data), (__pyx_v_x->dimensions[0]), 0, 1); + + /* "l0learn/cyarma.pyx":122 + * x = x.copy() + * cdef dvec *ar_p = new dvec( x.data, x.shape[0], False, True) + * return ar_p # <<<<<<<<<<<<<< + * + * cdef dvec numpy_to_dvec_d(np.ndarray[np.double_t, ndim=1] x): + */ + __pyx_r = __pyx_v_ar_p; + goto __pyx_L0; + + /* "l0learn/cyarma.pyx":118 + * return aR + * + * cdef dvec * numpy_to_dvec(np.ndarray[np.double_t, ndim=1] x): # <<<<<<<<<<<<<< + * if not (x.flags.f_contiguous or x.flags.owndata): + * x = x.copy() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_WriteUnraisable("l0learn.cyarma.numpy_to_dvec", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_x); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/cyarma.pyx":124 + * return ar_p + * + * cdef dvec numpy_to_dvec_d(np.ndarray[np.double_t, ndim=1] x): # <<<<<<<<<<<<<< + * cdef dvec *ar_p = numpy_to_dvec(x) + * cdef dvec ar = deref(ar_p) + */ + +static arma::dvec __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(PyArrayObject *__pyx_v_x) { + arma::dvec *__pyx_v_ar_p; + arma::dvec __pyx_v_ar; + __Pyx_LocalBuf_ND __pyx_pybuffernd_x; + __Pyx_Buffer __pyx_pybuffer_x; + arma::dvec __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("numpy_to_dvec_d", 0); + __pyx_pybuffer_x.pybuffer.buf = NULL; + __pyx_pybuffer_x.refcount = 0; + __pyx_pybuffernd_x.data = NULL; + __pyx_pybuffernd_x.rcbuffer = &__pyx_pybuffer_x; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_v_x, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 124, __pyx_L1_error) + } + __pyx_pybuffernd_x.diminfo[0].strides = __pyx_pybuffernd_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x.diminfo[0].shape = __pyx_pybuffernd_x.rcbuffer->pybuffer.shape[0]; + + /* "l0learn/cyarma.pyx":125 + * + * cdef dvec numpy_to_dvec_d(np.ndarray[np.double_t, ndim=1] x): + * cdef dvec *ar_p = numpy_to_dvec(x) # <<<<<<<<<<<<<< + * cdef dvec ar = deref(ar_p) + * del ar_p + */ + __pyx_v_ar_p = __pyx_f_7l0learn_6cyarma_numpy_to_dvec(((PyArrayObject *)__pyx_v_x)); + + /* "l0learn/cyarma.pyx":126 + * cdef dvec numpy_to_dvec_d(np.ndarray[np.double_t, ndim=1] x): + * cdef dvec *ar_p = numpy_to_dvec(x) + * cdef dvec ar = deref(ar_p) # <<<<<<<<<<<<<< + * del ar_p + * return ar + */ + __pyx_v_ar = (*__pyx_v_ar_p); + + /* "l0learn/cyarma.pyx":127 + * cdef dvec *ar_p = numpy_to_dvec(x) + * cdef dvec ar = deref(ar_p) + * del ar_p # <<<<<<<<<<<<<< + * return ar + * + */ + delete __pyx_v_ar_p; + + /* "l0learn/cyarma.pyx":128 + * cdef dvec ar = deref(ar_p) + * del ar_p + * return ar # <<<<<<<<<<<<<< + * + * cdef uvec * numpy_to_uvec(np.ndarray[np.uint64_t, ndim=1] x): + */ + __pyx_r = __pyx_v_ar; + goto __pyx_L0; + + /* "l0learn/cyarma.pyx":124 + * return ar_p + * + * cdef dvec numpy_to_dvec_d(np.ndarray[np.double_t, ndim=1] x): # <<<<<<<<<<<<<< + * cdef dvec *ar_p = numpy_to_dvec(x) + * cdef dvec ar = deref(ar_p) + */ + + /* function exit code */ + __pyx_L1_error:; + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_WriteUnraisable("l0learn.cyarma.numpy_to_dvec_d", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __Pyx_pretend_to_initialize(&__pyx_r); + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/cyarma.pyx":130 + * return ar + * + * cdef uvec * numpy_to_uvec(np.ndarray[np.uint64_t, ndim=1] x): # <<<<<<<<<<<<<< + * if not (x.flags.f_contiguous or x.flags.owndata): + * x = x.copy() + */ + +static arma::uvec *__pyx_f_7l0learn_6cyarma_numpy_to_uvec(PyArrayObject *__pyx_v_x) { + arma::uvec *__pyx_v_ar_p; + __Pyx_LocalBuf_ND __pyx_pybuffernd_x; + __Pyx_Buffer __pyx_pybuffer_x; + arma::uvec *__pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyArrayObject *__pyx_t_6 = NULL; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("numpy_to_uvec", 0); + __Pyx_INCREF((PyObject *)__pyx_v_x); + __pyx_pybuffer_x.pybuffer.buf = NULL; + __pyx_pybuffer_x.refcount = 0; + __pyx_pybuffernd_x.data = NULL; + __pyx_pybuffernd_x.rcbuffer = &__pyx_pybuffer_x; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_v_x, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 130, __pyx_L1_error) + } + __pyx_pybuffernd_x.diminfo[0].strides = __pyx_pybuffernd_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x.diminfo[0].shape = __pyx_pybuffernd_x.rcbuffer->pybuffer.shape[0]; + + /* "l0learn/cyarma.pyx":131 + * + * cdef uvec * numpy_to_uvec(np.ndarray[np.uint64_t, ndim=1] x): + * if not (x.flags.f_contiguous or x.flags.owndata): # <<<<<<<<<<<<<< + * x = x.copy() + * cdef uvec *ar_p = new uvec( x.data, x.shape[0], False, True) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_x), __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_f_contiguous); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!__pyx_t_4) { + } else { + __pyx_t_1 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_x), __pyx_n_s_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_owndata); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_1 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + __pyx_t_4 = ((!__pyx_t_1) != 0); + if (__pyx_t_4) { + + /* "l0learn/cyarma.pyx":132 + * cdef uvec * numpy_to_uvec(np.ndarray[np.uint64_t, ndim=1] x): + * if not (x.flags.f_contiguous or x.flags.owndata): + * x = x.copy() # <<<<<<<<<<<<<< + * cdef uvec *ar_p = new uvec( x.data, x.shape[0], False, True) + * return ar_p + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_x), __pyx_n_s_copy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 132, __pyx_L1_error) + __pyx_t_6 = ((PyArrayObject *)__pyx_t_2); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); + __pyx_t_7 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_t_6, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack); + if (unlikely(__pyx_t_7 < 0)) { + PyErr_Fetch(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10); + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_v_x, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + Py_XDECREF(__pyx_t_8); Py_XDECREF(__pyx_t_9); Py_XDECREF(__pyx_t_10); + __Pyx_RaiseBufferFallbackError(); + } else { + PyErr_Restore(__pyx_t_8, __pyx_t_9, __pyx_t_10); + } + __pyx_t_8 = __pyx_t_9 = __pyx_t_10 = 0; + } + __pyx_pybuffernd_x.diminfo[0].strides = __pyx_pybuffernd_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x.diminfo[0].shape = __pyx_pybuffernd_x.rcbuffer->pybuffer.shape[0]; + if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 132, __pyx_L1_error) + } + __pyx_t_6 = 0; + __Pyx_DECREF_SET(__pyx_v_x, ((PyArrayObject *)__pyx_t_2)); + __pyx_t_2 = 0; + + /* "l0learn/cyarma.pyx":131 + * + * cdef uvec * numpy_to_uvec(np.ndarray[np.uint64_t, ndim=1] x): + * if not (x.flags.f_contiguous or x.flags.owndata): # <<<<<<<<<<<<<< + * x = x.copy() + * cdef uvec *ar_p = new uvec( x.data, x.shape[0], False, True) + */ + } + + /* "l0learn/cyarma.pyx":133 + * if not (x.flags.f_contiguous or x.flags.owndata): + * x = x.copy() + * cdef uvec *ar_p = new uvec( x.data, x.shape[0], False, True) # <<<<<<<<<<<<<< + * return ar_p + * + */ + __pyx_v_ar_p = new arma::uvec(((unsigned PY_LONG_LONG *)__pyx_v_x->data), (__pyx_v_x->dimensions[0]), 0, 1); + + /* "l0learn/cyarma.pyx":134 + * x = x.copy() + * cdef uvec *ar_p = new uvec( x.data, x.shape[0], False, True) + * return ar_p # <<<<<<<<<<<<<< + * + * cdef uvec numpy_to_uvec_d(np.ndarray[np.uint64_t, ndim=1] x): + */ + __pyx_r = __pyx_v_ar_p; + goto __pyx_L0; + + /* "l0learn/cyarma.pyx":130 + * return ar + * + * cdef uvec * numpy_to_uvec(np.ndarray[np.uint64_t, ndim=1] x): # <<<<<<<<<<<<<< + * if not (x.flags.f_contiguous or x.flags.owndata): + * x = x.copy() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_WriteUnraisable("l0learn.cyarma.numpy_to_uvec", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_x); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/cyarma.pyx":136 + * return ar_p + * + * cdef uvec numpy_to_uvec_d(np.ndarray[np.uint64_t, ndim=1] x): # <<<<<<<<<<<<<< + * cdef uvec *ar_p = numpy_to_uvec(x) + * cdef uvec ar = deref(ar_p) + */ + +static arma::uvec __pyx_f_7l0learn_6cyarma_numpy_to_uvec_d(PyArrayObject *__pyx_v_x) { + arma::uvec *__pyx_v_ar_p; + arma::uvec __pyx_v_ar; + __Pyx_LocalBuf_ND __pyx_pybuffernd_x; + __Pyx_Buffer __pyx_pybuffer_x; + arma::uvec __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("numpy_to_uvec_d", 0); + __pyx_pybuffer_x.pybuffer.buf = NULL; + __pyx_pybuffer_x.refcount = 0; + __pyx_pybuffernd_x.data = NULL; + __pyx_pybuffernd_x.rcbuffer = &__pyx_pybuffer_x; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_v_x, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 136, __pyx_L1_error) + } + __pyx_pybuffernd_x.diminfo[0].strides = __pyx_pybuffernd_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x.diminfo[0].shape = __pyx_pybuffernd_x.rcbuffer->pybuffer.shape[0]; + + /* "l0learn/cyarma.pyx":137 + * + * cdef uvec numpy_to_uvec_d(np.ndarray[np.uint64_t, ndim=1] x): + * cdef uvec *ar_p = numpy_to_uvec(x) # <<<<<<<<<<<<<< + * cdef uvec ar = deref(ar_p) + * del ar_p + */ + __pyx_v_ar_p = __pyx_f_7l0learn_6cyarma_numpy_to_uvec(((PyArrayObject *)__pyx_v_x)); + + /* "l0learn/cyarma.pyx":138 + * cdef uvec numpy_to_uvec_d(np.ndarray[np.uint64_t, ndim=1] x): + * cdef uvec *ar_p = numpy_to_uvec(x) + * cdef uvec ar = deref(ar_p) # <<<<<<<<<<<<<< + * del ar_p + * return ar + */ + __pyx_v_ar = (*__pyx_v_ar_p); + + /* "l0learn/cyarma.pyx":139 + * cdef uvec *ar_p = numpy_to_uvec(x) + * cdef uvec ar = deref(ar_p) + * del ar_p # <<<<<<<<<<<<<< + * return ar + * + */ + delete __pyx_v_ar_p; + + /* "l0learn/cyarma.pyx":140 + * cdef uvec ar = deref(ar_p) + * del ar_p + * return ar # <<<<<<<<<<<<<< + * + * cdef sp_dmat * numpy_to_sp_dmat(x): + */ + __pyx_r = __pyx_v_ar; + goto __pyx_L0; + + /* "l0learn/cyarma.pyx":136 + * return ar_p + * + * cdef uvec numpy_to_uvec_d(np.ndarray[np.uint64_t, ndim=1] x): # <<<<<<<<<<<<<< + * cdef uvec *ar_p = numpy_to_uvec(x) + * cdef uvec ar = deref(ar_p) + */ + + /* function exit code */ + __pyx_L1_error:; + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_WriteUnraisable("l0learn.cyarma.numpy_to_uvec_d", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __Pyx_pretend_to_initialize(&__pyx_r); + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/cyarma.pyx":142 + * return ar + * + * cdef sp_dmat * numpy_to_sp_dmat(x): # <<<<<<<<<<<<<< + * if not isinstance(x, csc_matrix): + * raise ValueError(f"expected x to be of type {csc_matrix}, but got {type(x)}") + */ + +static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_v_x) { + PyArrayObject *__pyx_v_data = 0; + arma::dvec __pyx_v_values; + PyArrayObject *__pyx_v_indptr = 0; + arma::uvec __pyx_v_colptr; + PyArrayObject *__pyx_v_indices = 0; + arma::uvec __pyx_v_rowind; + arma::sp_dmat *__pyx_v_ar; + __Pyx_LocalBuf_ND __pyx_pybuffernd_data; + __Pyx_Buffer __pyx_pybuffer_data; + __Pyx_LocalBuf_ND __pyx_pybuffernd_indices; + __Pyx_Buffer __pyx_pybuffer_indices; + __Pyx_LocalBuf_ND __pyx_pybuffernd_indptr; + __Pyx_Buffer __pyx_pybuffer_indptr; + arma::sp_dmat *__pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + Py_ssize_t __pyx_t_4; + Py_UCS4 __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyArrayObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyArrayObject *__pyx_t_10 = NULL; + PyArrayObject *__pyx_t_11 = NULL; + int __pyx_t_12; + int __pyx_t_13; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("numpy_to_sp_dmat", 0); + __pyx_pybuffer_data.pybuffer.buf = NULL; + __pyx_pybuffer_data.refcount = 0; + __pyx_pybuffernd_data.data = NULL; + __pyx_pybuffernd_data.rcbuffer = &__pyx_pybuffer_data; + __pyx_pybuffer_indptr.pybuffer.buf = NULL; + __pyx_pybuffer_indptr.refcount = 0; + __pyx_pybuffernd_indptr.data = NULL; + __pyx_pybuffernd_indptr.rcbuffer = &__pyx_pybuffer_indptr; + __pyx_pybuffer_indices.pybuffer.buf = NULL; + __pyx_pybuffer_indices.refcount = 0; + __pyx_pybuffernd_indices.data = NULL; + __pyx_pybuffernd_indices.rcbuffer = &__pyx_pybuffer_indices; + + /* "l0learn/cyarma.pyx":143 + * + * cdef sp_dmat * numpy_to_sp_dmat(x): + * if not isinstance(x, csc_matrix): # <<<<<<<<<<<<<< + * raise ValueError(f"expected x to be of type {csc_matrix}, but got {type(x)}") + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyObject_IsInstance(__pyx_v_x, __pyx_t_1); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 143, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = ((!(__pyx_t_2 != 0)) != 0); + if (unlikely(__pyx_t_3)) { + + /* "l0learn/cyarma.pyx":144 + * cdef sp_dmat * numpy_to_sp_dmat(x): + * if not isinstance(x, csc_matrix): + * raise ValueError(f"expected x to be of type {csc_matrix}, but got {type(x)}") # <<<<<<<<<<<<<< + * + * cdef np.ndarray[np.double_t, ndim=1] data = x.data + */ + __pyx_t_1 = PyTuple_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = 0; + __pyx_t_5 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_x_to_be_of_type); + __pyx_t_4 += 25; + __Pyx_GIVEREF(__pyx_kp_u_expected_x_to_be_of_type); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_expected_x_to_be_of_type); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_6, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_5 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_5) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_5; + __pyx_t_4 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_7); + __pyx_t_7 = 0; + __Pyx_INCREF(__pyx_kp_u_but_got); + __pyx_t_4 += 10; + __Pyx_GIVEREF(__pyx_kp_u_but_got); + PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_but_got); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(((PyObject *)Py_TYPE(__pyx_v_x)), __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_5) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_5; + __pyx_t_4 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_1, 4, __pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 144, __pyx_L1_error) + + /* "l0learn/cyarma.pyx":143 + * + * cdef sp_dmat * numpy_to_sp_dmat(x): + * if not isinstance(x, csc_matrix): # <<<<<<<<<<<<<< + * raise ValueError(f"expected x to be of type {csc_matrix}, but got {type(x)}") + * + */ + } + + /* "l0learn/cyarma.pyx":146 + * raise ValueError(f"expected x to be of type {csc_matrix}, but got {type(x)}") + * + * cdef np.ndarray[np.double_t, ndim=1] data = x.data # <<<<<<<<<<<<<< + * cdef dvec values = numpy_to_dvec_d(data) + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 146, __pyx_L1_error) + __pyx_t_8 = ((PyArrayObject *)__pyx_t_1); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_data.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + __pyx_v_data = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_data.rcbuffer->pybuffer.buf = NULL; + __PYX_ERR(0, 146, __pyx_L1_error) + } else {__pyx_pybuffernd_data.diminfo[0].strides = __pyx_pybuffernd_data.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_data.diminfo[0].shape = __pyx_pybuffernd_data.rcbuffer->pybuffer.shape[0]; + } + } + __pyx_t_8 = 0; + __pyx_v_data = ((PyArrayObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "l0learn/cyarma.pyx":147 + * + * cdef np.ndarray[np.double_t, ndim=1] data = x.data + * cdef dvec values = numpy_to_dvec_d(data) # <<<<<<<<<<<<<< + * + * cdef np.ndarray[np.uint64_t, ndim=1] indptr = x.indptr.astype(np.uint64) + */ + __pyx_v_values = __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_data)); + + /* "l0learn/cyarma.pyx":149 + * cdef dvec values = numpy_to_dvec_d(data) + * + * cdef np.ndarray[np.uint64_t, ndim=1] indptr = x.indptr.astype(np.uint64) # <<<<<<<<<<<<<< + * cdef uvec colptr = numpy_to_uvec_d(indptr) + * + */ + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_indptr); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_astype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_uint64); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + __pyx_t_1 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_t_9) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_9); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 149, __pyx_L1_error) + __pyx_t_10 = ((PyArrayObject *)__pyx_t_1); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_indptr.rcbuffer->pybuffer, (PyObject*)__pyx_t_10, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + __pyx_v_indptr = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_indptr.rcbuffer->pybuffer.buf = NULL; + __PYX_ERR(0, 149, __pyx_L1_error) + } else {__pyx_pybuffernd_indptr.diminfo[0].strides = __pyx_pybuffernd_indptr.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_indptr.diminfo[0].shape = __pyx_pybuffernd_indptr.rcbuffer->pybuffer.shape[0]; + } + } + __pyx_t_10 = 0; + __pyx_v_indptr = ((PyArrayObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "l0learn/cyarma.pyx":150 + * + * cdef np.ndarray[np.uint64_t, ndim=1] indptr = x.indptr.astype(np.uint64) + * cdef uvec colptr = numpy_to_uvec_d(indptr) # <<<<<<<<<<<<<< + * + * cdef np.ndarray[np.uint64_t, ndim=1] indices = x.indices.astype(np.uint64) + */ + __pyx_v_colptr = __pyx_f_7l0learn_6cyarma_numpy_to_uvec_d(((PyArrayObject *)__pyx_v_indptr)); + + /* "l0learn/cyarma.pyx":152 + * cdef uvec colptr = numpy_to_uvec_d(indptr) + * + * cdef np.ndarray[np.uint64_t, ndim=1] indices = x.indices.astype(np.uint64) # <<<<<<<<<<<<<< + * cdef uvec rowind = numpy_to_uvec_d(indices) + * + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_indices); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_astype); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_uint64); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + } + } + __pyx_t_1 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_6, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 152, __pyx_L1_error) + __pyx_t_11 = ((PyArrayObject *)__pyx_t_1); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_indices.rcbuffer->pybuffer, (PyObject*)__pyx_t_11, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + __pyx_v_indices = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_indices.rcbuffer->pybuffer.buf = NULL; + __PYX_ERR(0, 152, __pyx_L1_error) + } else {__pyx_pybuffernd_indices.diminfo[0].strides = __pyx_pybuffernd_indices.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_indices.diminfo[0].shape = __pyx_pybuffernd_indices.rcbuffer->pybuffer.shape[0]; + } + } + __pyx_t_11 = 0; + __pyx_v_indices = ((PyArrayObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "l0learn/cyarma.pyx":153 + * + * cdef np.ndarray[np.uint64_t, ndim=1] indices = x.indices.astype(np.uint64) + * cdef uvec rowind = numpy_to_uvec_d(indices) # <<<<<<<<<<<<<< + * + * cdef sp_dmat * ar = new sp_dmat(rowind, colptr, values, x.shape[0], x.shape[1]) + */ + __pyx_v_rowind = __pyx_f_7l0learn_6cyarma_numpy_to_uvec_d(((PyArrayObject *)__pyx_v_indices)); + + /* "l0learn/cyarma.pyx":155 + * cdef uvec rowind = numpy_to_uvec_d(indices) + * + * cdef sp_dmat * ar = new sp_dmat(rowind, colptr, values, x.shape[0], x.shape[1]) # <<<<<<<<<<<<<< + * + * return ar + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_9); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 155, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_shape); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_9, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_13 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_13 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 155, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_ar = new arma::sp_dmat(__pyx_v_rowind, __pyx_v_colptr, __pyx_v_values, __pyx_t_12, __pyx_t_13); + + /* "l0learn/cyarma.pyx":157 + * cdef sp_dmat * ar = new sp_dmat(rowind, colptr, values, x.shape[0], x.shape[1]) + * + * return ar # <<<<<<<<<<<<<< + * + * cdef sp_dmat numpy_to_sp_dmat_d(x): + */ + __pyx_r = __pyx_v_ar; + goto __pyx_L0; + + /* "l0learn/cyarma.pyx":142 + * return ar + * + * cdef sp_dmat * numpy_to_sp_dmat(x): # <<<<<<<<<<<<<< + * if not isinstance(x, csc_matrix): + * raise ValueError(f"expected x to be of type {csc_matrix}, but got {type(x)}") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_9); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_data.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_indices.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_indptr.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_WriteUnraisable("l0learn.cyarma.numpy_to_sp_dmat", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_data.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_indices.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_indptr.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_data); + __Pyx_XDECREF((PyObject *)__pyx_v_indptr); + __Pyx_XDECREF((PyObject *)__pyx_v_indices); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/cyarma.pyx":159 + * return ar + * + * cdef sp_dmat numpy_to_sp_dmat_d(x): # <<<<<<<<<<<<<< + * cdef sp_dmat *ar_p = numpy_to_sp_dmat(x) + * cdef sp_dmat ar = deref(ar_p) + */ + +static arma::sp_dmat __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(PyObject *__pyx_v_x) { + arma::sp_dmat *__pyx_v_ar_p; + arma::sp_dmat __pyx_v_ar; + arma::sp_dmat __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("numpy_to_sp_dmat_d", 0); + + /* "l0learn/cyarma.pyx":160 + * + * cdef sp_dmat numpy_to_sp_dmat_d(x): + * cdef sp_dmat *ar_p = numpy_to_sp_dmat(x) # <<<<<<<<<<<<<< + * cdef sp_dmat ar = deref(ar_p) + * del ar_p + */ + __pyx_v_ar_p = __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(__pyx_v_x); + + /* "l0learn/cyarma.pyx":161 + * cdef sp_dmat numpy_to_sp_dmat_d(x): + * cdef sp_dmat *ar_p = numpy_to_sp_dmat(x) + * cdef sp_dmat ar = deref(ar_p) # <<<<<<<<<<<<<< + * del ar_p + * return ar + */ + __pyx_v_ar = (*__pyx_v_ar_p); + + /* "l0learn/cyarma.pyx":162 + * cdef sp_dmat *ar_p = numpy_to_sp_dmat(x) + * cdef sp_dmat ar = deref(ar_p) + * del ar_p # <<<<<<<<<<<<<< + * return ar + * + */ + delete __pyx_v_ar_p; + + /* "l0learn/cyarma.pyx":163 + * cdef sp_dmat ar = deref(ar_p) + * del ar_p + * return ar # <<<<<<<<<<<<<< + * + * ##### Converting back to l0learn arrays, must pass preallocated memory or None + */ + __pyx_r = __pyx_v_ar; + goto __pyx_L0; + + /* "l0learn/cyarma.pyx":159 + * return ar + * + * cdef sp_dmat numpy_to_sp_dmat_d(x): # <<<<<<<<<<<<<< + * cdef sp_dmat *ar_p = numpy_to_sp_dmat(x) + * cdef sp_dmat ar = deref(ar_p) + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/cyarma.pyx":170 + * + * @cython.boundscheck(False) + * cdef list sp_dmat_field_to_list(field[sp_dmat] f): # <<<<<<<<<<<<<< + * cdef list lst = [] + * for i in range(f.n_elem): + */ + +static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(arma::field __pyx_v_f) { + PyObject *__pyx_v_lst = 0; + int __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("sp_dmat_field_to_list", 0); + + /* "l0learn/cyarma.pyx":171 + * @cython.boundscheck(False) + * cdef list sp_dmat_field_to_list(field[sp_dmat] f): + * cdef list lst = [] # <<<<<<<<<<<<<< + * for i in range(f.n_elem): + * lst.append(sp_dmat_to_numpy(f[i], None, None, None)) + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 171, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_lst = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "l0learn/cyarma.pyx":172 + * cdef list sp_dmat_field_to_list(field[sp_dmat] f): + * cdef list lst = [] + * for i in range(f.n_elem): # <<<<<<<<<<<<<< + * lst.append(sp_dmat_to_numpy(f[i], None, None, None)) + * return lst + */ + __pyx_t_2 = __pyx_v_f.n_elem; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "l0learn/cyarma.pyx":173 + * cdef list lst = [] + * for i in range(f.n_elem): + * lst.append(sp_dmat_to_numpy(f[i], None, None, None)) # <<<<<<<<<<<<<< + * return lst + * + */ + __pyx_t_1 = __pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy((__pyx_v_f[__pyx_v_i]), ((PyArrayObject *)Py_None), ((PyArrayObject *)Py_None), ((PyArrayObject *)Py_None)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 173, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_lst, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 173, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "l0learn/cyarma.pyx":174 + * for i in range(f.n_elem): + * lst.append(sp_dmat_to_numpy(f[i], None, None, None)) + * return lst # <<<<<<<<<<<<<< + * + * @cython.boundscheck(False) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_lst); + __pyx_r = __pyx_v_lst; + goto __pyx_L0; + + /* "l0learn/cyarma.pyx":170 + * + * @cython.boundscheck(False) + * cdef list sp_dmat_field_to_list(field[sp_dmat] f): # <<<<<<<<<<<<<< + * cdef list lst = [] + * for i in range(f.n_elem): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("l0learn.cyarma.sp_dmat_field_to_list", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_lst); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/cyarma.pyx":177 + * + * @cython.boundscheck(False) + * cdef list dvec_field_to_list(field[dvec] f): # <<<<<<<<<<<<<< + * cdef list lst = [] + * for i in range(f.n_elem): + */ + +static PyObject *__pyx_f_7l0learn_6cyarma_dvec_field_to_list(arma::field __pyx_v_f) { + PyObject *__pyx_v_lst = 0; + int __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("dvec_field_to_list", 0); + + /* "l0learn/cyarma.pyx":178 + * @cython.boundscheck(False) + * cdef list dvec_field_to_list(field[dvec] f): + * cdef list lst = [] # <<<<<<<<<<<<<< + * for i in range(f.n_elem): + * lst.append(dvec_to_numpy(f[i], None)) + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_lst = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "l0learn/cyarma.pyx":179 + * cdef list dvec_field_to_list(field[dvec] f): + * cdef list lst = [] + * for i in range(f.n_elem): # <<<<<<<<<<<<<< + * lst.append(dvec_to_numpy(f[i], None)) + * return lst + */ + __pyx_t_2 = __pyx_v_f.n_elem; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "l0learn/cyarma.pyx":180 + * cdef list lst = [] + * for i in range(f.n_elem): + * lst.append(dvec_to_numpy(f[i], None)) # <<<<<<<<<<<<<< + * return lst + * + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7l0learn_6cyarma_dvec_to_numpy((__pyx_v_f[__pyx_v_i]), ((PyArrayObject *)Py_None))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 180, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_lst, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 180, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "l0learn/cyarma.pyx":181 + * for i in range(f.n_elem): + * lst.append(dvec_to_numpy(f[i], None)) + * return lst # <<<<<<<<<<<<<< + * + * @cython.boundscheck(False) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_lst); + __pyx_r = __pyx_v_lst; + goto __pyx_L0; + + /* "l0learn/cyarma.pyx":177 + * + * @cython.boundscheck(False) + * cdef list dvec_field_to_list(field[dvec] f): # <<<<<<<<<<<<<< + * cdef list lst = [] + * for i in range(f.n_elem): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("l0learn.cyarma.dvec_field_to_list", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_lst); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/cyarma.pyx":184 + * + * @cython.boundscheck(False) + * cdef np.ndarray[np.double_t, ndim=2] dmat_to_numpy(const dmat & X, np.ndarray[np.double_t, ndim=2] D): # <<<<<<<<<<<<<< + * # TODO: Check order of X and D + * cdef const double * Xptr = X.memptr() + */ + +static PyArrayObject *__pyx_f_7l0learn_6cyarma_dmat_to_numpy(arma::dmat const &__pyx_v_X, PyArrayObject *__pyx_v_D) { + double const *__pyx_v_Xptr; + double *__pyx_v_Dptr; + int __pyx_v_i; + __Pyx_LocalBuf_ND __pyx_pybuffernd_D; + __Pyx_Buffer __pyx_pybuffer_D; + PyArrayObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyArrayObject *__pyx_t_8 = NULL; + int __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + int __pyx_t_13; + int __pyx_t_14; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("dmat_to_numpy", 0); + __Pyx_INCREF((PyObject *)__pyx_v_D); + __pyx_pybuffer_D.pybuffer.buf = NULL; + __pyx_pybuffer_D.refcount = 0; + __pyx_pybuffernd_D.data = NULL; + __pyx_pybuffernd_D.rcbuffer = &__pyx_pybuffer_D; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_D.rcbuffer->pybuffer, (PyObject*)__pyx_v_D, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 184, __pyx_L1_error) + } + __pyx_pybuffernd_D.diminfo[0].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_D.diminfo[0].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_D.diminfo[1].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_D.diminfo[1].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[1]; + + /* "l0learn/cyarma.pyx":186 + * cdef np.ndarray[np.double_t, ndim=2] dmat_to_numpy(const dmat & X, np.ndarray[np.double_t, ndim=2] D): + * # TODO: Check order of X and D + * cdef const double * Xptr = X.memptr() # <<<<<<<<<<<<<< + * + * if D is None: + */ + __pyx_v_Xptr = __pyx_v_X.memptr(); + + /* "l0learn/cyarma.pyx":188 + * cdef const double * Xptr = X.memptr() + * + * if D is None: # <<<<<<<<<<<<<< + * D = np.empty((X.n_rows, X.n_cols), dtype=np.double, order="F") + * cdef double * Dptr = D.data + */ + __pyx_t_1 = (((PyObject *)__pyx_v_D) == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "l0learn/cyarma.pyx":189 + * + * if D is None: + * D = np.empty((X.n_rows, X.n_cols), dtype=np.double, order="F") # <<<<<<<<<<<<<< + * cdef double * Dptr = D.data + * for i in range(X.n_rows*X.n_cols): + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_X.n_rows); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_X.n_cols); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_5); + __pyx_t_3 = 0; + __pyx_t_5 = 0; + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_double); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_7) < 0) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_order, __pyx_n_u_F) < 0) __PYX_ERR(0, 189, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (!(likely(((__pyx_t_7) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_7, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 189, __pyx_L1_error) + __pyx_t_8 = ((PyArrayObject *)__pyx_t_7); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_D.rcbuffer->pybuffer); + __pyx_t_9 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_D.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack); + if (unlikely(__pyx_t_9 < 0)) { + PyErr_Fetch(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12); + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_D.rcbuffer->pybuffer, (PyObject*)__pyx_v_D, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) { + Py_XDECREF(__pyx_t_10); Py_XDECREF(__pyx_t_11); Py_XDECREF(__pyx_t_12); + __Pyx_RaiseBufferFallbackError(); + } else { + PyErr_Restore(__pyx_t_10, __pyx_t_11, __pyx_t_12); + } + __pyx_t_10 = __pyx_t_11 = __pyx_t_12 = 0; + } + __pyx_pybuffernd_D.diminfo[0].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_D.diminfo[0].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_D.diminfo[1].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_D.diminfo[1].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[1]; + if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 189, __pyx_L1_error) + } + __pyx_t_8 = 0; + __Pyx_DECREF_SET(__pyx_v_D, ((PyArrayObject *)__pyx_t_7)); + __pyx_t_7 = 0; + + /* "l0learn/cyarma.pyx":188 + * cdef const double * Xptr = X.memptr() + * + * if D is None: # <<<<<<<<<<<<<< + * D = np.empty((X.n_rows, X.n_cols), dtype=np.double, order="F") + * cdef double * Dptr = D.data + */ + } + + /* "l0learn/cyarma.pyx":190 + * if D is None: + * D = np.empty((X.n_rows, X.n_cols), dtype=np.double, order="F") + * cdef double * Dptr = D.data # <<<<<<<<<<<<<< + * for i in range(X.n_rows*X.n_cols): + * Dptr[i] = Xptr[i] + */ + __pyx_v_Dptr = ((double *)__pyx_v_D->data); + + /* "l0learn/cyarma.pyx":191 + * D = np.empty((X.n_rows, X.n_cols), dtype=np.double, order="F") + * cdef double * Dptr = D.data + * for i in range(X.n_rows*X.n_cols): # <<<<<<<<<<<<<< + * Dptr[i] = Xptr[i] + * return D + */ + __pyx_t_9 = (__pyx_v_X.n_rows * __pyx_v_X.n_cols); + __pyx_t_13 = __pyx_t_9; + for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { + __pyx_v_i = __pyx_t_14; + + /* "l0learn/cyarma.pyx":192 + * cdef double * Dptr = D.data + * for i in range(X.n_rows*X.n_cols): + * Dptr[i] = Xptr[i] # <<<<<<<<<<<<<< + * return D + * + */ + (__pyx_v_Dptr[__pyx_v_i]) = (__pyx_v_Xptr[__pyx_v_i]); + } + + /* "l0learn/cyarma.pyx":193 + * for i in range(X.n_rows*X.n_cols): + * Dptr[i] = Xptr[i] + * return D # <<<<<<<<<<<<<< + * + * @cython.boundscheck(False) + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_D)); + __pyx_r = ((PyArrayObject *)__pyx_v_D); + goto __pyx_L0; + + /* "l0learn/cyarma.pyx":184 + * + * @cython.boundscheck(False) + * cdef np.ndarray[np.double_t, ndim=2] dmat_to_numpy(const dmat & X, np.ndarray[np.double_t, ndim=2] D): # <<<<<<<<<<<<<< + * # TODO: Check order of X and D + * cdef const double * Xptr = X.memptr() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_D.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("l0learn.cyarma.dmat_to_numpy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_D.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_D); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/cyarma.pyx":196 + * + * @cython.boundscheck(False) + * cdef np.ndarray[np.double_t, ndim=1] dvec_to_numpy(const dvec & X, np.ndarray[np.double_t, ndim=1] D): # <<<<<<<<<<<<<< + * cdef const double * Xptr = X.memptr() + * + */ + +static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &__pyx_v_X, PyArrayObject *__pyx_v_D) { + double const *__pyx_v_Xptr; + double *__pyx_v_Dptr; + int __pyx_v_i; + __Pyx_LocalBuf_ND __pyx_pybuffernd_D; + __Pyx_Buffer __pyx_pybuffer_D; + PyArrayObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyArrayObject *__pyx_t_8 = NULL; + int __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + int __pyx_t_13; + int __pyx_t_14; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("dvec_to_numpy", 0); + __Pyx_INCREF((PyObject *)__pyx_v_D); + __pyx_pybuffer_D.pybuffer.buf = NULL; + __pyx_pybuffer_D.refcount = 0; + __pyx_pybuffernd_D.data = NULL; + __pyx_pybuffernd_D.rcbuffer = &__pyx_pybuffer_D; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_D.rcbuffer->pybuffer, (PyObject*)__pyx_v_D, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 196, __pyx_L1_error) + } + __pyx_pybuffernd_D.diminfo[0].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_D.diminfo[0].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[0]; + + /* "l0learn/cyarma.pyx":197 + * @cython.boundscheck(False) + * cdef np.ndarray[np.double_t, ndim=1] dvec_to_numpy(const dvec & X, np.ndarray[np.double_t, ndim=1] D): + * cdef const double * Xptr = X.memptr() # <<<<<<<<<<<<<< + * + * if D is None: + */ + __pyx_v_Xptr = __pyx_v_X.memptr(); + + /* "l0learn/cyarma.pyx":199 + * cdef const double * Xptr = X.memptr() + * + * if D is None: # <<<<<<<<<<<<<< + * D = np.empty(X.n_elem, dtype=np.double) + * cdef double * Dptr = D.data + */ + __pyx_t_1 = (((PyObject *)__pyx_v_D) == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "l0learn/cyarma.pyx":200 + * + * if D is None: + * D = np.empty(X.n_elem, dtype=np.double) # <<<<<<<<<<<<<< + * cdef double * Dptr = D.data + * for i in range(X.n_elem): + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_X.n_elem); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_double); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_7) < 0) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!(likely(((__pyx_t_7) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_7, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 200, __pyx_L1_error) + __pyx_t_8 = ((PyArrayObject *)__pyx_t_7); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_D.rcbuffer->pybuffer); + __pyx_t_9 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_D.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack); + if (unlikely(__pyx_t_9 < 0)) { + PyErr_Fetch(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12); + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_D.rcbuffer->pybuffer, (PyObject*)__pyx_v_D, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + Py_XDECREF(__pyx_t_10); Py_XDECREF(__pyx_t_11); Py_XDECREF(__pyx_t_12); + __Pyx_RaiseBufferFallbackError(); + } else { + PyErr_Restore(__pyx_t_10, __pyx_t_11, __pyx_t_12); + } + __pyx_t_10 = __pyx_t_11 = __pyx_t_12 = 0; + } + __pyx_pybuffernd_D.diminfo[0].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_D.diminfo[0].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[0]; + if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 200, __pyx_L1_error) + } + __pyx_t_8 = 0; + __Pyx_DECREF_SET(__pyx_v_D, ((PyArrayObject *)__pyx_t_7)); + __pyx_t_7 = 0; + + /* "l0learn/cyarma.pyx":199 + * cdef const double * Xptr = X.memptr() + * + * if D is None: # <<<<<<<<<<<<<< + * D = np.empty(X.n_elem, dtype=np.double) + * cdef double * Dptr = D.data + */ + } + + /* "l0learn/cyarma.pyx":201 + * if D is None: + * D = np.empty(X.n_elem, dtype=np.double) + * cdef double * Dptr = D.data # <<<<<<<<<<<<<< + * for i in range(X.n_elem): + * Dptr[i] = Xptr[i] + */ + __pyx_v_Dptr = ((double *)__pyx_v_D->data); + + /* "l0learn/cyarma.pyx":202 + * D = np.empty(X.n_elem, dtype=np.double) + * cdef double * Dptr = D.data + * for i in range(X.n_elem): # <<<<<<<<<<<<<< + * Dptr[i] = Xptr[i] + * return D + */ + __pyx_t_9 = __pyx_v_X.n_elem; + __pyx_t_13 = __pyx_t_9; + for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { + __pyx_v_i = __pyx_t_14; + + /* "l0learn/cyarma.pyx":203 + * cdef double * Dptr = D.data + * for i in range(X.n_elem): + * Dptr[i] = Xptr[i] # <<<<<<<<<<<<<< + * return D + * + */ + (__pyx_v_Dptr[__pyx_v_i]) = (__pyx_v_Xptr[__pyx_v_i]); + } + + /* "l0learn/cyarma.pyx":204 + * for i in range(X.n_elem): + * Dptr[i] = Xptr[i] + * return D # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_D)); + __pyx_r = ((PyArrayObject *)__pyx_v_D); + goto __pyx_L0; + + /* "l0learn/cyarma.pyx":196 + * + * @cython.boundscheck(False) + * cdef np.ndarray[np.double_t, ndim=1] dvec_to_numpy(const dvec & X, np.ndarray[np.double_t, ndim=1] D): # <<<<<<<<<<<<<< + * cdef const double * Xptr = X.memptr() + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_D.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("l0learn.cyarma.dvec_to_numpy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_D.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_D); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/cyarma.pyx":208 + * + * @cython.boundscheck(False) + * cdef np.ndarray[np.uint64_t, ndim=1] uvec_to_numpy(const uvec & X, np.ndarray[np.uint64_t, ndim=1] D): # <<<<<<<<<<<<<< + * cdef const unsigned long long * Xptr = X.memptr() + * + */ + +static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &__pyx_v_X, PyArrayObject *__pyx_v_D) { + unsigned PY_LONG_LONG const *__pyx_v_Xptr; + unsigned PY_LONG_LONG *__pyx_v_Dptr; + int __pyx_v_i; + __Pyx_LocalBuf_ND __pyx_pybuffernd_D; + __Pyx_Buffer __pyx_pybuffer_D; + PyArrayObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyArrayObject *__pyx_t_8 = NULL; + int __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + int __pyx_t_13; + int __pyx_t_14; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("uvec_to_numpy", 0); + __Pyx_INCREF((PyObject *)__pyx_v_D); + __pyx_pybuffer_D.pybuffer.buf = NULL; + __pyx_pybuffer_D.refcount = 0; + __pyx_pybuffernd_D.data = NULL; + __pyx_pybuffernd_D.rcbuffer = &__pyx_pybuffer_D; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_D.rcbuffer->pybuffer, (PyObject*)__pyx_v_D, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 208, __pyx_L1_error) + } + __pyx_pybuffernd_D.diminfo[0].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_D.diminfo[0].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[0]; + + /* "l0learn/cyarma.pyx":209 + * @cython.boundscheck(False) + * cdef np.ndarray[np.uint64_t, ndim=1] uvec_to_numpy(const uvec & X, np.ndarray[np.uint64_t, ndim=1] D): + * cdef const unsigned long long * Xptr = X.memptr() # <<<<<<<<<<<<<< + * + * if D is None: + */ + __pyx_v_Xptr = __pyx_v_X.memptr(); + + /* "l0learn/cyarma.pyx":211 + * cdef const unsigned long long * Xptr = X.memptr() + * + * if D is None: # <<<<<<<<<<<<<< + * D = np.empty(X.n_elem, dtype=np.uint64) + * cdef unsigned long long * Dptr = D.data + */ + __pyx_t_1 = (((PyObject *)__pyx_v_D) == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "l0learn/cyarma.pyx":212 + * + * if D is None: + * D = np.empty(X.n_elem, dtype=np.uint64) # <<<<<<<<<<<<<< + * cdef unsigned long long * Dptr = D.data + * for i in range(X.n_elem): + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_X.n_elem); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_uint64); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_7) < 0) __PYX_ERR(0, 212, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!(likely(((__pyx_t_7) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_7, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 212, __pyx_L1_error) + __pyx_t_8 = ((PyArrayObject *)__pyx_t_7); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_D.rcbuffer->pybuffer); + __pyx_t_9 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_D.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack); + if (unlikely(__pyx_t_9 < 0)) { + PyErr_Fetch(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12); + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_D.rcbuffer->pybuffer, (PyObject*)__pyx_v_D, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + Py_XDECREF(__pyx_t_10); Py_XDECREF(__pyx_t_11); Py_XDECREF(__pyx_t_12); + __Pyx_RaiseBufferFallbackError(); + } else { + PyErr_Restore(__pyx_t_10, __pyx_t_11, __pyx_t_12); + } + __pyx_t_10 = __pyx_t_11 = __pyx_t_12 = 0; + } + __pyx_pybuffernd_D.diminfo[0].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_D.diminfo[0].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[0]; + if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 212, __pyx_L1_error) + } + __pyx_t_8 = 0; + __Pyx_DECREF_SET(__pyx_v_D, ((PyArrayObject *)__pyx_t_7)); + __pyx_t_7 = 0; + + /* "l0learn/cyarma.pyx":211 + * cdef const unsigned long long * Xptr = X.memptr() + * + * if D is None: # <<<<<<<<<<<<<< + * D = np.empty(X.n_elem, dtype=np.uint64) + * cdef unsigned long long * Dptr = D.data + */ + } + + /* "l0learn/cyarma.pyx":213 + * if D is None: + * D = np.empty(X.n_elem, dtype=np.uint64) + * cdef unsigned long long * Dptr = D.data # <<<<<<<<<<<<<< + * for i in range(X.n_elem): + * Dptr[i] = Xptr[i] + */ + __pyx_v_Dptr = ((unsigned PY_LONG_LONG *)__pyx_v_D->data); + + /* "l0learn/cyarma.pyx":214 + * D = np.empty(X.n_elem, dtype=np.uint64) + * cdef unsigned long long * Dptr = D.data + * for i in range(X.n_elem): # <<<<<<<<<<<<<< + * Dptr[i] = Xptr[i] + * return D + */ + __pyx_t_9 = __pyx_v_X.n_elem; + __pyx_t_13 = __pyx_t_9; + for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { + __pyx_v_i = __pyx_t_14; + + /* "l0learn/cyarma.pyx":215 + * cdef unsigned long long * Dptr = D.data + * for i in range(X.n_elem): + * Dptr[i] = Xptr[i] # <<<<<<<<<<<<<< + * return D + * + */ + (__pyx_v_Dptr[__pyx_v_i]) = (__pyx_v_Xptr[__pyx_v_i]); + } + + /* "l0learn/cyarma.pyx":216 + * for i in range(X.n_elem): + * Dptr[i] = Xptr[i] + * return D # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_D)); + __pyx_r = ((PyArrayObject *)__pyx_v_D); + goto __pyx_L0; + + /* "l0learn/cyarma.pyx":208 + * + * @cython.boundscheck(False) + * cdef np.ndarray[np.uint64_t, ndim=1] uvec_to_numpy(const uvec & X, np.ndarray[np.uint64_t, ndim=1] D): # <<<<<<<<<<<<<< + * cdef const unsigned long long * Xptr = X.memptr() + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_D.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("l0learn.cyarma.uvec_to_numpy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_D.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_D); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/cyarma.pyx":220 + * + * @cython.boundscheck(False) + * cdef sp_dmat_to_numpy(const sp_dmat & X, np.ndarray[np.uint64_t, ndim=1] rowind, # <<<<<<<<<<<<<< + * np.ndarray[np.uint64_t, ndim=1] colind, np.ndarray[np.double_t, ndim=1] values): + * # TODO: Check order of X and D + */ + +static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const &__pyx_v_X, PyArrayObject *__pyx_v_rowind, PyArrayObject *__pyx_v_colind, PyArrayObject *__pyx_v_values) { + arma::sp_dmat::const_iterator __pyx_v_it; + int __pyx_v_i; + __Pyx_LocalBuf_ND __pyx_pybuffernd_colind; + __Pyx_Buffer __pyx_pybuffer_colind; + __Pyx_LocalBuf_ND __pyx_pybuffernd_rowind; + __Pyx_Buffer __pyx_pybuffer_rowind; + __Pyx_LocalBuf_ND __pyx_pybuffernd_values; + __Pyx_Buffer __pyx_pybuffer_values; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyArrayObject *__pyx_t_8 = NULL; + int __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + PyArrayObject *__pyx_t_13 = NULL; + PyArrayObject *__pyx_t_14 = NULL; + int __pyx_t_15; + int __pyx_t_16; + Py_ssize_t __pyx_t_17; + PyObject *__pyx_t_18 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("sp_dmat_to_numpy", 0); + __Pyx_INCREF((PyObject *)__pyx_v_rowind); + __Pyx_INCREF((PyObject *)__pyx_v_colind); + __Pyx_INCREF((PyObject *)__pyx_v_values); + __pyx_pybuffer_rowind.pybuffer.buf = NULL; + __pyx_pybuffer_rowind.refcount = 0; + __pyx_pybuffernd_rowind.data = NULL; + __pyx_pybuffernd_rowind.rcbuffer = &__pyx_pybuffer_rowind; + __pyx_pybuffer_colind.pybuffer.buf = NULL; + __pyx_pybuffer_colind.refcount = 0; + __pyx_pybuffernd_colind.data = NULL; + __pyx_pybuffernd_colind.rcbuffer = &__pyx_pybuffer_colind; + __pyx_pybuffer_values.pybuffer.buf = NULL; + __pyx_pybuffer_values.refcount = 0; + __pyx_pybuffernd_values.data = NULL; + __pyx_pybuffernd_values.rcbuffer = &__pyx_pybuffer_values; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_rowind.rcbuffer->pybuffer, (PyObject*)__pyx_v_rowind, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 220, __pyx_L1_error) + } + __pyx_pybuffernd_rowind.diminfo[0].strides = __pyx_pybuffernd_rowind.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_rowind.diminfo[0].shape = __pyx_pybuffernd_rowind.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_colind.rcbuffer->pybuffer, (PyObject*)__pyx_v_colind, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 220, __pyx_L1_error) + } + __pyx_pybuffernd_colind.diminfo[0].strides = __pyx_pybuffernd_colind.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_colind.diminfo[0].shape = __pyx_pybuffernd_colind.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_values.rcbuffer->pybuffer, (PyObject*)__pyx_v_values, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 220, __pyx_L1_error) + } + __pyx_pybuffernd_values.diminfo[0].strides = __pyx_pybuffernd_values.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_values.diminfo[0].shape = __pyx_pybuffernd_values.rcbuffer->pybuffer.shape[0]; + + /* "l0learn/cyarma.pyx":223 + * np.ndarray[np.uint64_t, ndim=1] colind, np.ndarray[np.double_t, ndim=1] values): + * # TODO: Check order of X and D + * if rowind is None: # <<<<<<<<<<<<<< + * rowind = np.empty(X.n_nonzero, dtype=np.uint64) + * if colind is None: + */ + __pyx_t_1 = (((PyObject *)__pyx_v_rowind) == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "l0learn/cyarma.pyx":224 + * # TODO: Check order of X and D + * if rowind is None: + * rowind = np.empty(X.n_nonzero, dtype=np.uint64) # <<<<<<<<<<<<<< + * if colind is None: + * colind = np.empty(X.n_nonzero, dtype=np.uint64) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_X.n_nonzero); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_uint64); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_7) < 0) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!(likely(((__pyx_t_7) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_7, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 224, __pyx_L1_error) + __pyx_t_8 = ((PyArrayObject *)__pyx_t_7); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_rowind.rcbuffer->pybuffer); + __pyx_t_9 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_rowind.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack); + if (unlikely(__pyx_t_9 < 0)) { + PyErr_Fetch(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12); + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_rowind.rcbuffer->pybuffer, (PyObject*)__pyx_v_rowind, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) { + Py_XDECREF(__pyx_t_10); Py_XDECREF(__pyx_t_11); Py_XDECREF(__pyx_t_12); + __Pyx_RaiseBufferFallbackError(); + } else { + PyErr_Restore(__pyx_t_10, __pyx_t_11, __pyx_t_12); + } + __pyx_t_10 = __pyx_t_11 = __pyx_t_12 = 0; + } + __pyx_pybuffernd_rowind.diminfo[0].strides = __pyx_pybuffernd_rowind.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_rowind.diminfo[0].shape = __pyx_pybuffernd_rowind.rcbuffer->pybuffer.shape[0]; + if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 224, __pyx_L1_error) + } + __pyx_t_8 = 0; + __Pyx_DECREF_SET(__pyx_v_rowind, ((PyArrayObject *)__pyx_t_7)); + __pyx_t_7 = 0; + + /* "l0learn/cyarma.pyx":223 + * np.ndarray[np.uint64_t, ndim=1] colind, np.ndarray[np.double_t, ndim=1] values): + * # TODO: Check order of X and D + * if rowind is None: # <<<<<<<<<<<<<< + * rowind = np.empty(X.n_nonzero, dtype=np.uint64) + * if colind is None: + */ + } + + /* "l0learn/cyarma.pyx":225 + * if rowind is None: + * rowind = np.empty(X.n_nonzero, dtype=np.uint64) + * if colind is None: # <<<<<<<<<<<<<< + * colind = np.empty(X.n_nonzero, dtype=np.uint64) + * if values is None: + */ + __pyx_t_2 = (((PyObject *)__pyx_v_colind) == Py_None); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "l0learn/cyarma.pyx":226 + * rowind = np.empty(X.n_nonzero, dtype=np.uint64) + * if colind is None: + * colind = np.empty(X.n_nonzero, dtype=np.uint64) # <<<<<<<<<<<<<< + * if values is None: + * values = np.empty(X.n_nonzero, dtype=np.double) + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_empty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_X.n_nonzero); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_uint64); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 226, __pyx_L1_error) + __pyx_t_13 = ((PyArrayObject *)__pyx_t_6); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_colind.rcbuffer->pybuffer); + __pyx_t_9 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_colind.rcbuffer->pybuffer, (PyObject*)__pyx_t_13, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack); + if (unlikely(__pyx_t_9 < 0)) { + PyErr_Fetch(&__pyx_t_12, &__pyx_t_11, &__pyx_t_10); + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_colind.rcbuffer->pybuffer, (PyObject*)__pyx_v_colind, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) { + Py_XDECREF(__pyx_t_12); Py_XDECREF(__pyx_t_11); Py_XDECREF(__pyx_t_10); + __Pyx_RaiseBufferFallbackError(); + } else { + PyErr_Restore(__pyx_t_12, __pyx_t_11, __pyx_t_10); + } + __pyx_t_12 = __pyx_t_11 = __pyx_t_10 = 0; + } + __pyx_pybuffernd_colind.diminfo[0].strides = __pyx_pybuffernd_colind.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_colind.diminfo[0].shape = __pyx_pybuffernd_colind.rcbuffer->pybuffer.shape[0]; + if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 226, __pyx_L1_error) + } + __pyx_t_13 = 0; + __Pyx_DECREF_SET(__pyx_v_colind, ((PyArrayObject *)__pyx_t_6)); + __pyx_t_6 = 0; + + /* "l0learn/cyarma.pyx":225 + * if rowind is None: + * rowind = np.empty(X.n_nonzero, dtype=np.uint64) + * if colind is None: # <<<<<<<<<<<<<< + * colind = np.empty(X.n_nonzero, dtype=np.uint64) + * if values is None: + */ + } + + /* "l0learn/cyarma.pyx":227 + * if colind is None: + * colind = np.empty(X.n_nonzero, dtype=np.uint64) + * if values is None: # <<<<<<<<<<<<<< + * values = np.empty(X.n_nonzero, dtype=np.double) + * + */ + __pyx_t_1 = (((PyObject *)__pyx_v_values) == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "l0learn/cyarma.pyx":228 + * colind = np.empty(X.n_nonzero, dtype=np.uint64) + * if values is None: + * values = np.empty(X.n_nonzero, dtype=np.double) # <<<<<<<<<<<<<< + * + * cdef sp_dmat.const_iterator it = X.begin() + */ + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_empty); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_X.n_nonzero); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_double); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(0, 228, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 228, __pyx_L1_error) + __pyx_t_14 = ((PyArrayObject *)__pyx_t_4); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_values.rcbuffer->pybuffer); + __pyx_t_9 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_values.rcbuffer->pybuffer, (PyObject*)__pyx_t_14, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack); + if (unlikely(__pyx_t_9 < 0)) { + PyErr_Fetch(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12); + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_values.rcbuffer->pybuffer, (PyObject*)__pyx_v_values, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) { + Py_XDECREF(__pyx_t_10); Py_XDECREF(__pyx_t_11); Py_XDECREF(__pyx_t_12); + __Pyx_RaiseBufferFallbackError(); + } else { + PyErr_Restore(__pyx_t_10, __pyx_t_11, __pyx_t_12); + } + __pyx_t_10 = __pyx_t_11 = __pyx_t_12 = 0; + } + __pyx_pybuffernd_values.diminfo[0].strides = __pyx_pybuffernd_values.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_values.diminfo[0].shape = __pyx_pybuffernd_values.rcbuffer->pybuffer.shape[0]; + if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 228, __pyx_L1_error) + } + __pyx_t_14 = 0; + __Pyx_DECREF_SET(__pyx_v_values, ((PyArrayObject *)__pyx_t_4)); + __pyx_t_4 = 0; + + /* "l0learn/cyarma.pyx":227 + * if colind is None: + * colind = np.empty(X.n_nonzero, dtype=np.uint64) + * if values is None: # <<<<<<<<<<<<<< + * values = np.empty(X.n_nonzero, dtype=np.double) + * + */ + } + + /* "l0learn/cyarma.pyx":230 + * values = np.empty(X.n_nonzero, dtype=np.double) + * + * cdef sp_dmat.const_iterator it = X.begin() # <<<<<<<<<<<<<< + * + * for i in range(X.n_nonzero): + */ + __pyx_v_it = __pyx_v_X.begin(); + + /* "l0learn/cyarma.pyx":232 + * cdef sp_dmat.const_iterator it = X.begin() + * + * for i in range(X.n_nonzero): # <<<<<<<<<<<<<< + * # TODO: Double check the following comment... + * # Arma is column major so rows are columns and columns are rows when converting back to l0learn (row major) + */ + __pyx_t_9 = __pyx_v_X.n_nonzero; + __pyx_t_15 = __pyx_t_9; + for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_15; __pyx_t_16+=1) { + __pyx_v_i = __pyx_t_16; + + /* "l0learn/cyarma.pyx":235 + * # TODO: Double check the following comment... + * # Arma is column major so rows are columns and columns are rows when converting back to l0learn (row major) + * rowind[i] = it.col() # <<<<<<<<<<<<<< + * colind[i] = it.row() + * values[i] = deref(it) + */ + __pyx_t_17 = __pyx_v_i; + if (__pyx_t_17 < 0) __pyx_t_17 += __pyx_pybuffernd_rowind.diminfo[0].shape; + *__Pyx_BufPtrStrided1d(__pyx_t_5numpy_uint64_t *, __pyx_pybuffernd_rowind.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_rowind.diminfo[0].strides) = __pyx_v_it.col(); + + /* "l0learn/cyarma.pyx":236 + * # Arma is column major so rows are columns and columns are rows when converting back to l0learn (row major) + * rowind[i] = it.col() + * colind[i] = it.row() # <<<<<<<<<<<<<< + * values[i] = deref(it) + * inc(it) + */ + __pyx_t_17 = __pyx_v_i; + if (__pyx_t_17 < 0) __pyx_t_17 += __pyx_pybuffernd_colind.diminfo[0].shape; + *__Pyx_BufPtrStrided1d(__pyx_t_5numpy_uint64_t *, __pyx_pybuffernd_colind.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_colind.diminfo[0].strides) = __pyx_v_it.row(); + + /* "l0learn/cyarma.pyx":237 + * rowind[i] = it.col() + * colind[i] = it.row() + * values[i] = deref(it) # <<<<<<<<<<<<<< + * inc(it) + * + */ + __pyx_t_17 = __pyx_v_i; + if (__pyx_t_17 < 0) __pyx_t_17 += __pyx_pybuffernd_values.diminfo[0].shape; + *__Pyx_BufPtrStrided1d(__pyx_t_5numpy_double_t *, __pyx_pybuffernd_values.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_values.diminfo[0].strides) = (*__pyx_v_it); + + /* "l0learn/cyarma.pyx":238 + * colind[i] = it.row() + * values[i] = deref(it) + * inc(it) # <<<<<<<<<<<<<< + * + * return csc_matrix((values, (colind, rowind)), shape=(X.n_rows, X.n_cols)) + */ + (void)((++__pyx_v_it)); + } + + /* "l0learn/cyarma.pyx":240 + * inc(it) + * + * return csc_matrix((values, (colind, rowind)), shape=(X.n_rows, X.n_cols)) # <<<<<<<<<<<<<< + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_INCREF(((PyObject *)__pyx_v_colind)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_colind)); + PyTuple_SET_ITEM(__pyx_t_6, 0, ((PyObject *)__pyx_v_colind)); + __Pyx_INCREF(((PyObject *)__pyx_v_rowind)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_rowind)); + PyTuple_SET_ITEM(__pyx_t_6, 1, ((PyObject *)__pyx_v_rowind)); + __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(((PyObject *)__pyx_v_values)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_values)); + PyTuple_SET_ITEM(__pyx_t_5, 0, ((PyObject *)__pyx_v_values)); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_X.n_rows); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_X.n_cols); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_18 = PyTuple_New(2); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_7); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_18, 1, __pyx_t_3); + __pyx_t_7 = 0; + __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_shape, __pyx_t_18) < 0) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __pyx_t_18 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, __pyx_t_5); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_r = __pyx_t_18; + __pyx_t_18 = 0; + goto __pyx_L0; + + /* "l0learn/cyarma.pyx":220 + * + * @cython.boundscheck(False) + * cdef sp_dmat_to_numpy(const sp_dmat & X, np.ndarray[np.uint64_t, ndim=1] rowind, # <<<<<<<<<<<<<< + * np.ndarray[np.uint64_t, ndim=1] colind, np.ndarray[np.double_t, ndim=1] values): + * # TODO: Check order of X and D + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_18); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_colind.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_rowind.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_values.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("l0learn.cyarma.sp_dmat_to_numpy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_colind.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_rowind.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_values.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_rowind); + __Pyx_XDECREF((PyObject *)__pyx_v_colind); + __Pyx_XDECREF((PyObject *)__pyx_v_values); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":734 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":735 + * + * cdef inline object PyArray_MultiIterNew1(a): + * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew2(a, b): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 735, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":734 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":737 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":738 + * + * cdef inline object PyArray_MultiIterNew2(a, b): + * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 738, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":737 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":740 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":741 + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 741, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":740 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":743 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":744 + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 744, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":743 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":746 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":747 + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< + * + * cdef inline tuple PyDataType_SHAPE(dtype d): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 747, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":746 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":749 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":750 + * + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< + * return d.subarray.shape + * else: + */ + __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); + if (__pyx_t_1) { + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":751 + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape # <<<<<<<<<<<<<< + * else: + * return () + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); + __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":750 + * + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< + * return d.subarray.shape + * else: + */ + } + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":753 + * return d.subarray.shape + * else: + * return () # <<<<<<<<<<<<<< + * + * + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_empty_tuple); + __pyx_r = __pyx_empty_tuple; + goto __pyx_L0; + } + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":749 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":868 + * int _import_umath() except -1 + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) + */ + +static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_array_base", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":869 + * + * cdef inline void set_array_base(ndarray arr, object base): + * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< + * PyArray_SetBaseObject(arr, base) + * + */ + Py_INCREF(__pyx_v_base); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":870 + * cdef inline void set_array_base(ndarray arr, object base): + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< + * + * cdef inline object get_array_base(ndarray arr): + */ + (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":868 + * int _import_umath() except -1 + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":872 + * PyArray_SetBaseObject(arr, base) + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) + * if base is NULL: + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { + PyObject *__pyx_v_base; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("get_array_base", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":873 + * + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< + * if base is NULL: + * return None + */ + __pyx_v_base = PyArray_BASE(__pyx_v_arr); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":874 + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) + * if base is NULL: # <<<<<<<<<<<<<< + * return None + * return base + */ + __pyx_t_1 = ((__pyx_v_base == NULL) != 0); + if (__pyx_t_1) { + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":875 + * base = PyArray_BASE(arr) + * if base is NULL: + * return None # <<<<<<<<<<<<<< + * return base + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":874 + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) + * if base is NULL: # <<<<<<<<<<<<<< + * return None + * return base + */ + } + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":876 + * if base is NULL: + * return None + * return base # <<<<<<<<<<<<<< + * + * # Versions of the import_* functions which are more suitable for + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_base)); + __pyx_r = ((PyObject *)__pyx_v_base); + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":872 + * PyArray_SetBaseObject(arr, base) + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) + * if base is NULL: + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":880 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * __pyx_import_array() + */ + +static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("import_array", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":881 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * __pyx_import_array() + * except Exception: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":882 + * cdef inline int import_array() except -1: + * try: + * __pyx_import_array() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") + */ + __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 882, __pyx_L3_error) + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":881 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * __pyx_import_array() + * except Exception: + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":883 + * try: + * __pyx_import_array() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.multiarray failed to import") + * + */ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 883, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":884 + * __pyx_import_array() + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_umath() except -1: + */ + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 884, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 884, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":881 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * __pyx_import_array() + * except Exception: + */ + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":880 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * __pyx_import_array() + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":886 + * raise ImportError("numpy.core.multiarray failed to import") + * + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + +static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("import_umath", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":887 + * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":888 + * cdef inline int import_umath() except -1: + * try: + * _import_umath() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.umath failed to import") + */ + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 888, __pyx_L3_error) + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":887 + * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":889 + * try: + * _import_umath() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.umath failed to import") + * + */ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 889, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":890 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_ufunc() except -1: + */ + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 890, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 890, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":887 + * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":886 + * raise ImportError("numpy.core.multiarray failed to import") + * + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":892 + * raise ImportError("numpy.core.umath failed to import") + * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + +static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("import_ufunc", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":893 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":894 + * cdef inline int import_ufunc() except -1: + * try: + * _import_umath() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.umath failed to import") + */ + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 894, __pyx_L3_error) + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":893 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":895 + * try: + * _import_umath() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.umath failed to import") + * + */ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 895, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":896 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< + * + * cdef extern from *: + */ + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 896, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 896, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":893 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":892 + * raise ImportError("numpy.core.umath failed to import") + * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; + +#if PY_MAJOR_VERSION >= 3 +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_cyarma(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_cyarma}, + {0, NULL} +}; +#endif + +static struct PyModuleDef __pyx_moduledef = { + PyModuleDef_HEAD_INIT, + "cyarma", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif +#ifndef CYTHON_SMALL_CODE +#if defined(__clang__) + #define CYTHON_SMALL_CODE +#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) + #define CYTHON_SMALL_CODE __attribute__((cold)) +#else + #define CYTHON_SMALL_CODE +#endif +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_u_F, __pyx_k_F, sizeof(__pyx_k_F), 0, 1, 0, 1}, + {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1}, + {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s_astype, __pyx_k_astype, sizeof(__pyx_k_astype), 0, 0, 1, 1}, + {&__pyx_kp_u_but_got, __pyx_k_but_got, sizeof(__pyx_k_but_got), 0, 1, 0, 0}, + {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_n_s_copy, __pyx_k_copy, sizeof(__pyx_k_copy), 0, 0, 1, 1}, + {&__pyx_n_s_csc_matrix, __pyx_k_csc_matrix, sizeof(__pyx_k_csc_matrix), 0, 0, 1, 1}, + {&__pyx_n_s_data, __pyx_k_data, sizeof(__pyx_k_data), 0, 0, 1, 1}, + {&__pyx_n_s_double, __pyx_k_double, sizeof(__pyx_k_double), 0, 0, 1, 1}, + {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1}, + {&__pyx_n_s_empty, __pyx_k_empty, sizeof(__pyx_k_empty), 0, 0, 1, 1}, + {&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1}, + {&__pyx_kp_u_expected_each_value_in_values_to, __pyx_k_expected_each_value_in_values_to, sizeof(__pyx_k_expected_each_value_in_values_to), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_each_value_in_values_to_2, __pyx_k_expected_each_value_in_values_to_2, sizeof(__pyx_k_expected_each_value_in_values_to_2), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_x_to_be_of_type, __pyx_k_expected_x_to_be_of_type, sizeof(__pyx_k_expected_x_to_be_of_type), 0, 1, 0, 0}, + {&__pyx_n_s_f_contiguous, __pyx_k_f_contiguous, sizeof(__pyx_k_f_contiguous), 0, 0, 1, 1}, + {&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_indices, __pyx_k_indices, sizeof(__pyx_k_indices), 0, 0, 1, 1}, + {&__pyx_n_s_indptr, __pyx_k_indptr, sizeof(__pyx_k_indptr), 0, 0, 1, 1}, + {&__pyx_n_s_isreal, __pyx_k_isreal, sizeof(__pyx_k_isreal), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_n_s_ndim, __pyx_k_ndim, sizeof(__pyx_k_ndim), 0, 0, 1, 1}, + {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, + {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, + {&__pyx_kp_u_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 1, 0, 0}, + {&__pyx_kp_u_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 1, 0, 0}, + {&__pyx_n_s_order, __pyx_k_order, sizeof(__pyx_k_order), 0, 0, 1, 1}, + {&__pyx_n_s_owndata, __pyx_k_owndata, sizeof(__pyx_k_owndata), 0, 0, 1, 1}, + {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, + {&__pyx_n_s_scipy_sparse_csc, __pyx_k_scipy_sparse_csc, sizeof(__pyx_k_scipy_sparse_csc), 0, 0, 1, 1}, + {&__pyx_n_s_shape, __pyx_k_shape, sizeof(__pyx_k_shape), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_s_uint64, __pyx_k_uint64, sizeof(__pyx_k_uint64), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(0, 88, __pyx_L1_error) + __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 90, __pyx_L1_error) + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 144, __pyx_L1_error) + __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 172, __pyx_L1_error) + __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 884, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":884 + * __pyx_import_array() + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_umath() except -1: + */ + __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 884, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple_); + __Pyx_GIVEREF(__pyx_tuple_); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":890 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_ufunc() except -1: + */ + __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 890, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ + +static int __Pyx_modinit_global_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); + /*--- Global init code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); + /*--- Variable export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_export_code(void) { + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); + /*--- Function export code ---*/ + if (__Pyx_ExportFunction("list_to_sp_dmat_field", (void (*)(void))__pyx_f_7l0learn_6cyarma_list_to_sp_dmat_field, "arma::field (PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("list_to_dvec_field", (void (*)(void))__pyx_f_7l0learn_6cyarma_list_to_dvec_field, "arma::field (PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("numpy_to_dmat", (void (*)(void))__pyx_f_7l0learn_6cyarma_numpy_to_dmat, "arma::dmat *(PyArrayObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("numpy_to_dmat_d", (void (*)(void))__pyx_f_7l0learn_6cyarma_numpy_to_dmat_d, "arma::dmat (PyArrayObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("numpy_to_dvec", (void (*)(void))__pyx_f_7l0learn_6cyarma_numpy_to_dvec, "arma::dvec *(PyArrayObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("numpy_to_dvec_d", (void (*)(void))__pyx_f_7l0learn_6cyarma_numpy_to_dvec_d, "arma::dvec (PyArrayObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("numpy_to_uvec", (void (*)(void))__pyx_f_7l0learn_6cyarma_numpy_to_uvec, "arma::uvec *(PyArrayObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("numpy_to_uvec_d", (void (*)(void))__pyx_f_7l0learn_6cyarma_numpy_to_uvec_d, "arma::uvec (PyArrayObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("numpy_to_sp_dmat", (void (*)(void))__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat, "arma::sp_dmat *(PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("numpy_to_sp_dmat_d", (void (*)(void))__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d, "arma::sp_dmat (PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("sp_dmat_field_to_list", (void (*)(void))__pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list, "PyObject *(arma::field )") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("dvec_field_to_list", (void (*)(void))__pyx_f_7l0learn_6cyarma_dvec_field_to_list, "PyObject *(arma::field )") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("dmat_to_numpy", (void (*)(void))__pyx_f_7l0learn_6cyarma_dmat_to_numpy, "PyArrayObject *(arma::dmat const &, PyArrayObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("dvec_to_numpy", (void (*)(void))__pyx_f_7l0learn_6cyarma_dvec_to_numpy, "PyArrayObject *(arma::dvec const &, PyArrayObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("uvec_to_numpy", (void (*)(void))__pyx_f_7l0learn_6cyarma_uvec_to_numpy, "PyArrayObject *(arma::uvec const &, PyArrayObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("sp_dmat_to_numpy", (void (*)(void))__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy, "PyObject *(arma::sp_dmat const &, PyArrayObject *, PyArrayObject *, PyArrayObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_type_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); + /*--- Type init code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_import_code(void) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); + /*--- Type import code ---*/ + __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyTypeObject), + #else + sizeof(PyHeapTypeObject), + #endif + __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(2, 9, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 199, __pyx_L1_error) + __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 222, __pyx_L1_error) + __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 226, __pyx_L1_error) + __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 238, __pyx_L1_error) + __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 764, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_variable_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); + /*--- Variable import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); + /*--- Function import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + + +#ifndef CYTHON_NO_PYINIT_EXPORT +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#elif PY_MAJOR_VERSION < 3 +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" void +#else +#define __Pyx_PyMODINIT_FUNC void +#endif +#else +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * +#else +#define __Pyx_PyMODINIT_FUNC PyObject * +#endif +#endif + + +#if PY_MAJOR_VERSION < 3 +__Pyx_PyMODINIT_FUNC initcyarma(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC initcyarma(void) +#else +__Pyx_PyMODINIT_FUNC PyInit_cyarma(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_cyarma(void) +#if CYTHON_PEP489_MULTI_PHASE_INIT +{ + return PyModuleDef_Init(&__pyx_moduledef); +} +static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { + #if PY_VERSION_HEX >= 0x030700A1 + static PY_INT64_T main_interpreter_id = -1; + PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); + if (main_interpreter_id == -1) { + main_interpreter_id = current_id; + return (unlikely(current_id == -1)) ? -1 : 0; + } else if (unlikely(main_interpreter_id != current_id)) + #else + static PyInterpreterState *main_interpreter = NULL; + PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; + if (!main_interpreter) { + main_interpreter = current_interpreter; + } else if (unlikely(main_interpreter != current_interpreter)) + #endif + { + PyErr_SetString( + PyExc_ImportError, + "Interpreter change detected - this module can only be loaded into one interpreter per process."); + return -1; + } + return 0; +} +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { + PyObject *value = PyObject_GetAttrString(spec, from_name); + int result = 0; + if (likely(value)) { + if (allow_none || value != Py_None) { + result = PyDict_SetItemString(moddict, to_name, value); + } + Py_DECREF(value); + } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + } else { + result = -1; + } + return result; +} +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { + PyObject *module = NULL, *moddict, *modname; + if (__Pyx_check_single_interpreter()) + return NULL; + if (__pyx_m) + return __Pyx_NewRef(__pyx_m); + modname = PyObject_GetAttrString(spec, "name"); + if (unlikely(!modname)) goto bad; + module = PyModule_NewObject(modname); + Py_DECREF(modname); + if (unlikely(!module)) goto bad; + moddict = PyModule_GetDict(module); + if (unlikely(!moddict)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; + return module; +bad: + Py_XDECREF(module); + return NULL; +} + + +static CYTHON_SMALL_CODE int __pyx_pymod_exec_cyarma(PyObject *__pyx_pyinit_module) +#endif +#endif +{ + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + #if CYTHON_PEP489_MULTI_PHASE_INIT + if (__pyx_m) { + if (__pyx_m == __pyx_pyinit_module) return 0; + PyErr_SetString(PyExc_RuntimeError, "Module 'cyarma' has already been imported. Re-initialisation is not supported."); + return -1; + } + #elif PY_MAJOR_VERSION >= 3 + if (__pyx_m) return __Pyx_NewRef(__pyx_m); + #endif + #if CYTHON_REFNANNY +__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); +if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); +} +#endif + __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_cyarma(void)", 0); + if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pxy_PyFrame_Initialize_Offsets + __Pxy_PyFrame_Initialize_Offsets(); + #endif + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + #ifdef WITH_THREAD /* Python build with threading support? */ + PyEval_InitThreads(); + #endif + #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_m = __pyx_pyinit_module; + Py_INCREF(__pyx_m); + #else + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("cyarma", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_b); + __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_cython_runtime); + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + if (__pyx_module_is_main_l0learn__cyarma) { + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "l0learn.cyarma")) { + if (unlikely(PyDict_SetItemString(modules, "l0learn.cyarma", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Global type/function init code ---*/ + (void)__Pyx_modinit_global_init_code(); + (void)__Pyx_modinit_variable_export_code(); + if (unlikely(__Pyx_modinit_function_export_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + (void)__Pyx_modinit_type_init_code(); + if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + (void)__Pyx_modinit_variable_import_code(); + (void)__Pyx_modinit_function_import_code(); + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + + /* "l0learn/cyarma.pyx":2 + * cimport cython + * import numpy as np # <<<<<<<<<<<<<< + * cimport numpy as np + * + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 2, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "l0learn/cyarma.pyx":5 + * cimport numpy as np + * + * from scipy.sparse.csc import csc_matrix # <<<<<<<<<<<<<< + * from cython.operator cimport dereference as deref, preincrement as inc + * + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_csc_matrix); + __Pyx_GIVEREF(__pyx_n_s_csc_matrix); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_csc_matrix); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_scipy_sparse_csc, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_csc_matrix, __pyx_t_1) < 0) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "l0learn/cyarma.pyx":1 + * cimport cython # <<<<<<<<<<<<<< + * import numpy as np + * cimport numpy as np + */ + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":892 + * raise ImportError("numpy.core.umath failed to import") + * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init l0learn.cyarma", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_CLEAR(__pyx_m); + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init l0learn.cyarma"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if CYTHON_PEP489_MULTI_PHASE_INIT + return (__pyx_m != NULL) ? 0 : -1; + #elif PY_MAJOR_VERSION >= 3 + return __pyx_m; + #else + return; + #endif +} + +/* --- Runtime support code --- */ +/* Refnanny */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule(modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, "RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +/* PyObjectGetAttrStr */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#endif + +/* GetBuiltinName */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +/* PyDictVersioning */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { + PyObject **dictptr = NULL; + Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; + if (offset) { +#if CYTHON_COMPILING_IN_CPYTHON + dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); +#else + dictptr = _PyObject_GetDictPtr(obj); +#endif + } + return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; +} +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) + return 0; + return obj_dict_version == __Pyx_get_object_dict_version(obj); +} +#endif + +/* GetModuleGlobalName */ +#if CYTHON_USE_DICT_VERSIONS +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) +#else +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) +#endif +{ + PyObject *result; +#if !CYTHON_AVOID_BORROWED_REFS +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 + result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } else if (unlikely(PyErr_Occurred())) { + return NULL; + } +#else + result = PyDict_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } +#endif +#else + result = PyObject_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } + PyErr_Clear(); +#endif + return __Pyx_GetBuiltinName(name); +} + +/* PyIntCompare */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_NeObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED long inplace) { + if (op1 == op2) { + Py_RETURN_FALSE; + } + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + const long b = intval; + long a = PyInt_AS_LONG(op1); + if (a != b) Py_RETURN_TRUE; else Py_RETURN_FALSE; + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op1))) { + int unequal; + unsigned long uintval; + Py_ssize_t size = Py_SIZE(op1); + const digit* digits = ((PyLongObject*)op1)->ob_digit; + if (intval == 0) { + if (size != 0) Py_RETURN_TRUE; else Py_RETURN_FALSE; + } else if (intval < 0) { + if (size >= 0) + Py_RETURN_TRUE; + intval = -intval; + size = -size; + } else { + if (size <= 0) + Py_RETURN_TRUE; + } + uintval = (unsigned long) intval; +#if PyLong_SHIFT * 4 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 4)) { + unequal = (size != 5) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[4] != ((uintval >> (4 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else +#endif +#if PyLong_SHIFT * 3 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 3)) { + unequal = (size != 4) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else +#endif +#if PyLong_SHIFT * 2 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 2)) { + unequal = (size != 3) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else +#endif +#if PyLong_SHIFT * 1 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 1)) { + unequal = (size != 2) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else +#endif + unequal = (size != 1) || (((unsigned long) digits[0]) != (uintval & (unsigned long) PyLong_MASK)); + if (unequal != 0) Py_RETURN_TRUE; else Py_RETURN_FALSE; + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + if ((double)a != (double)b) Py_RETURN_TRUE; else Py_RETURN_FALSE; + } + return ( + PyObject_RichCompare(op1, op2, Py_NE)); +} + +/* PyCFunctionFastCall */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { + PyCFunctionObject *func = (PyCFunctionObject*)func_obj; + PyCFunction meth = PyCFunction_GET_FUNCTION(func); + PyObject *self = PyCFunction_GET_SELF(func); + int flags = PyCFunction_GET_FLAGS(func); + assert(PyCFunction_Check(func)); + assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); + assert(nargs >= 0); + assert(nargs == 0 || args != NULL); + /* _PyCFunction_FastCallDict() must not be called with an exception set, + because it may clear it (directly or indirectly) and so the + caller loses its exception */ + assert(!PyErr_Occurred()); + if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { + return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); + } else { + return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); + } +} +#endif + +/* PyFunctionFastCall */ +#if CYTHON_FAST_PYCALL +static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, + PyObject *globals) { + PyFrameObject *f; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject **fastlocals; + Py_ssize_t i; + PyObject *result; + assert(globals != NULL); + /* XXX Perhaps we should create a specialized + PyFrame_New() that doesn't take locals, but does + take builtins without sanity checking them. + */ + assert(tstate != NULL); + f = PyFrame_New(tstate, co, globals, NULL); + if (f == NULL) { + return NULL; + } + fastlocals = __Pyx_PyFrame_GetLocalsplus(f); + for (i = 0; i < na; i++) { + Py_INCREF(*args); + fastlocals[i] = *args++; + } + result = PyEval_EvalFrameEx(f,0); + ++tstate->recursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + return result; +} +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { + PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); + PyObject *globals = PyFunction_GET_GLOBALS(func); + PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *closure; +#if PY_MAJOR_VERSION >= 3 + PyObject *kwdefs; +#endif + PyObject *kwtuple, **k; + PyObject **d; + Py_ssize_t nd; + Py_ssize_t nk; + PyObject *result; + assert(kwargs == NULL || PyDict_Check(kwargs)); + nk = kwargs ? PyDict_Size(kwargs) : 0; + if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { + return NULL; + } + if ( +#if PY_MAJOR_VERSION >= 3 + co->co_kwonlyargcount == 0 && +#endif + likely(kwargs == NULL || nk == 0) && + co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { + if (argdefs == NULL && co->co_argcount == nargs) { + result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); + goto done; + } + else if (nargs == 0 && argdefs != NULL + && co->co_argcount == Py_SIZE(argdefs)) { + /* function called with no arguments, but all parameters have + a default value: use default values as arguments .*/ + args = &PyTuple_GET_ITEM(argdefs, 0); + result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); + goto done; + } + } + if (kwargs != NULL) { + Py_ssize_t pos, i; + kwtuple = PyTuple_New(2 * nk); + if (kwtuple == NULL) { + result = NULL; + goto done; + } + k = &PyTuple_GET_ITEM(kwtuple, 0); + pos = i = 0; + while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { + Py_INCREF(k[i]); + Py_INCREF(k[i+1]); + i += 2; + } + nk = i / 2; + } + else { + kwtuple = NULL; + k = NULL; + } + closure = PyFunction_GET_CLOSURE(func); +#if PY_MAJOR_VERSION >= 3 + kwdefs = PyFunction_GET_KW_DEFAULTS(func); +#endif + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } +#if PY_MAJOR_VERSION >= 3 + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); +#else + result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, closure); +#endif + Py_XDECREF(kwtuple); +done: + Py_LeaveRecursiveCall(); + return result; +} +#endif +#endif + +/* PyObjectCall */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = func->ob_type->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCall2Args */ +static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { + PyObject *args, *result = NULL; + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(function)) { + PyObject *args[2] = {arg1, arg2}; + return __Pyx_PyFunction_FastCall(function, args, 2); + } + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(function)) { + PyObject *args[2] = {arg1, arg2}; + return __Pyx_PyCFunction_FastCall(function, args, 2); + } + #endif + args = PyTuple_New(2); + if (unlikely(!args)) goto done; + Py_INCREF(arg1); + PyTuple_SET_ITEM(args, 0, arg1); + Py_INCREF(arg2); + PyTuple_SET_ITEM(args, 1, arg2); + Py_INCREF(function); + result = __Pyx_PyObject_Call(function, args, NULL); + Py_DECREF(args); + Py_DECREF(function); +done: + return result; +} + +/* PyObjectCallMethO */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = PyCFunction_GET_FUNCTION(func); + self = PyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallOneArg */ +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, &arg, 1); + } +#endif + if (likely(PyCFunction_Check(func))) { + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { + return __Pyx_PyObject_CallMethO(func, arg); +#if CYTHON_FAST_PYCCALL + } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { + return __Pyx_PyCFunction_FastCall(func, &arg, 1); +#endif + } + } + return __Pyx__PyObject_CallOneArg(func, arg); +} +#else +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +#endif + +/* PyErrFetchRestore */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +} +#endif + +/* RaiseException */ +#if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + __Pyx_PyThreadState_declare + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_PyThreadState_assign + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } + if (cause) { + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_COMPILING_IN_PYPY + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#else + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} +#endif + +/* WriteUnraisableException */ +static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, + CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, + int full_traceback, CYTHON_UNUSED int nogil) { + PyObject *old_exc, *old_val, *old_tb; + PyObject *ctx; + __Pyx_PyThreadState_declare +#ifdef WITH_THREAD + PyGILState_STATE state; + if (nogil) + state = PyGILState_Ensure(); +#ifdef _MSC_VER + else state = (PyGILState_STATE)-1; +#endif +#endif + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); + if (full_traceback) { + Py_XINCREF(old_exc); + Py_XINCREF(old_val); + Py_XINCREF(old_tb); + __Pyx_ErrRestore(old_exc, old_val, old_tb); + PyErr_PrintEx(1); + } + #if PY_MAJOR_VERSION < 3 + ctx = PyString_FromString(name); + #else + ctx = PyUnicode_FromString(name); + #endif + __Pyx_ErrRestore(old_exc, old_val, old_tb); + if (!ctx) { + PyErr_WriteUnraisable(Py_None); + } else { + PyErr_WriteUnraisable(ctx); + Py_DECREF(ctx); + } +#ifdef WITH_THREAD + if (nogil) + PyGILState_Release(state); +#endif +} + +/* ExtTypeTest */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(__Pyx_TypeCheck(obj, type))) + return 1; + PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", + Py_TYPE(obj)->tp_name, type->tp_name); + return 0; +} + +/* IsLittleEndian */ +static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) +{ + union { + uint32_t u32; + uint8_t u8[4]; + } S; + S.u32 = 0x01020304; + return S.u8[0] == 4; +} + +/* BufferFormatCheck */ +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + __Pyx_TypeInfo* type) { + stack[0].field = &ctx->root; + stack[0].parent_offset = 0; + ctx->root.type = type; + ctx->root.name = "buffer dtype"; + ctx->root.offset = 0; + ctx->head = stack; + ctx->head->field = &ctx->root; + ctx->fmt_offset = 0; + ctx->head->parent_offset = 0; + ctx->new_packmode = '@'; + ctx->enc_packmode = '@'; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->is_complex = 0; + ctx->is_valid_array = 0; + ctx->struct_alignment = 0; + while (type->typegroup == 'S') { + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = 0; + type = type->fields->type; + } +} +static int __Pyx_BufFmt_ParseNumber(const char** ts) { + int count; + const char* t = *ts; + if (*t < '0' || *t > '9') { + return -1; + } else { + count = *t++ - '0'; + while (*t >= '0' && *t <= '9') { + count *= 10; + count += *t++ - '0'; + } + } + *ts = t; + return count; +} +static int __Pyx_BufFmt_ExpectNumber(const char **ts) { + int number = __Pyx_BufFmt_ParseNumber(ts); + if (number == -1) + PyErr_Format(PyExc_ValueError,\ + "Does not understand character buffer dtype format string ('%c')", **ts); + return number; +} +static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { + PyErr_Format(PyExc_ValueError, + "Unexpected format string character: '%c'", ch); +} +static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { + switch (ch) { + case '?': return "'bool'"; + case 'c': return "'char'"; + case 'b': return "'signed char'"; + case 'B': return "'unsigned char'"; + case 'h': return "'short'"; + case 'H': return "'unsigned short'"; + case 'i': return "'int'"; + case 'I': return "'unsigned int'"; + case 'l': return "'long'"; + case 'L': return "'unsigned long'"; + case 'q': return "'long long'"; + case 'Q': return "'unsigned long long'"; + case 'f': return (is_complex ? "'complex float'" : "'float'"); + case 'd': return (is_complex ? "'complex double'" : "'double'"); + case 'g': return (is_complex ? "'complex long double'" : "'long double'"); + case 'T': return "a struct"; + case 'O': return "Python object"; + case 'P': return "a pointer"; + case 's': case 'p': return "a string"; + case 0: return "end"; + default: return "unparseable format string"; + } +} +static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return 2; + case 'i': case 'I': case 'l': case 'L': return 4; + case 'q': case 'Q': return 8; + case 'f': return (is_complex ? 8 : 4); + case 'd': return (is_complex ? 16 : 8); + case 'g': { + PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); + return 0; + } + case 'O': case 'P': return sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(short); + case 'i': case 'I': return sizeof(int); + case 'l': case 'L': return sizeof(long); + #ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(PY_LONG_LONG); + #endif + case 'f': return sizeof(float) * (is_complex ? 2 : 1); + case 'd': return sizeof(double) * (is_complex ? 2 : 1); + case 'g': return sizeof(long double) * (is_complex ? 2 : 1); + case 'O': case 'P': return sizeof(void*); + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +typedef struct { char c; short x; } __Pyx_st_short; +typedef struct { char c; int x; } __Pyx_st_int; +typedef struct { char c; long x; } __Pyx_st_long; +typedef struct { char c; float x; } __Pyx_st_float; +typedef struct { char c; double x; } __Pyx_st_double; +typedef struct { char c; long double x; } __Pyx_st_longdouble; +typedef struct { char c; void *x; } __Pyx_st_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_st_float) - sizeof(float); + case 'd': return sizeof(__Pyx_st_double) - sizeof(double); + case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +/* These are for computing the padding at the end of the struct to align + on the first member of the struct. This will probably the same as above, + but we don't have any guarantees. + */ +typedef struct { short x; char c; } __Pyx_pad_short; +typedef struct { int x; char c; } __Pyx_pad_int; +typedef struct { long x; char c; } __Pyx_pad_long; +typedef struct { float x; char c; } __Pyx_pad_float; +typedef struct { double x; char c; } __Pyx_pad_double; +typedef struct { long double x; char c; } __Pyx_pad_longdouble; +typedef struct { void *x; char c; } __Pyx_pad_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); + case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); + case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { + switch (ch) { + case 'c': + return 'H'; + case 'b': case 'h': case 'i': + case 'l': case 'q': case 's': case 'p': + return 'I'; + case '?': case 'B': case 'H': case 'I': case 'L': case 'Q': + return 'U'; + case 'f': case 'd': case 'g': + return (is_complex ? 'C' : 'R'); + case 'O': + return 'O'; + case 'P': + return 'P'; + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { + if (ctx->head == NULL || ctx->head->field == &ctx->root) { + const char* expected; + const char* quote; + if (ctx->head == NULL) { + expected = "end"; + quote = ""; + } else { + expected = ctx->head->field->type->name; + quote = "'"; + } + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected %s%s%s but got %s", + quote, expected, quote, + __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); + } else { + __Pyx_StructField* field = ctx->head->field; + __Pyx_StructField* parent = (ctx->head - 1)->field; + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", + field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), + parent->type->name, field->name); + } +} +static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { + char group; + size_t size, offset, arraysize = 1; + if (ctx->enc_type == 0) return 0; + if (ctx->head->field->type->arraysize[0]) { + int i, ndim = 0; + if (ctx->enc_type == 's' || ctx->enc_type == 'p') { + ctx->is_valid_array = ctx->head->field->type->ndim == 1; + ndim = 1; + if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { + PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %zu", + ctx->head->field->type->arraysize[0], ctx->enc_count); + return -1; + } + } + if (!ctx->is_valid_array) { + PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", + ctx->head->field->type->ndim, ndim); + return -1; + } + for (i = 0; i < ctx->head->field->type->ndim; i++) { + arraysize *= ctx->head->field->type->arraysize[i]; + } + ctx->is_valid_array = 0; + ctx->enc_count = 1; + } + group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); + do { + __Pyx_StructField* field = ctx->head->field; + __Pyx_TypeInfo* type = field->type; + if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { + size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); + } else { + size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); + } + if (ctx->enc_packmode == '@') { + size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); + size_t align_mod_offset; + if (align_at == 0) return -1; + align_mod_offset = ctx->fmt_offset % align_at; + if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; + if (ctx->struct_alignment == 0) + ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, + ctx->is_complex); + } + if (type->size != size || type->typegroup != group) { + if (type->typegroup == 'C' && type->fields != NULL) { + size_t parent_offset = ctx->head->parent_offset + field->offset; + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = parent_offset; + continue; + } + if ((type->typegroup == 'H' || group == 'H') && type->size == size) { + } else { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + } + offset = ctx->head->parent_offset + field->offset; + if (ctx->fmt_offset != offset) { + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", + (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); + return -1; + } + ctx->fmt_offset += size; + if (arraysize) + ctx->fmt_offset += (arraysize - 1) * size; + --ctx->enc_count; + while (1) { + if (field == &ctx->root) { + ctx->head = NULL; + if (ctx->enc_count != 0) { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + break; + } + ctx->head->field = ++field; + if (field->type == NULL) { + --ctx->head; + field = ctx->head->field; + continue; + } else if (field->type->typegroup == 'S') { + size_t parent_offset = ctx->head->parent_offset + field->offset; + if (field->type->fields->type == NULL) continue; + field = field->type->fields; + ++ctx->head; + ctx->head->field = field; + ctx->head->parent_offset = parent_offset; + break; + } else { + break; + } + } + } while (ctx->enc_count); + ctx->enc_type = 0; + ctx->is_complex = 0; + return 0; +} +static PyObject * +__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) +{ + const char *ts = *tsp; + int i = 0, number, ndim; + ++ts; + if (ctx->new_count != 1) { + PyErr_SetString(PyExc_ValueError, + "Cannot handle repeated arrays in format string"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ndim = ctx->head->field->type->ndim; + while (*ts && *ts != ')') { + switch (*ts) { + case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; + default: break; + } + number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) + return PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %d", + ctx->head->field->type->arraysize[i], number); + if (*ts != ',' && *ts != ')') + return PyErr_Format(PyExc_ValueError, + "Expected a comma in format string, got '%c'", *ts); + if (*ts == ',') ts++; + i++; + } + if (i != ndim) + return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", + ctx->head->field->type->ndim, i); + if (!*ts) { + PyErr_SetString(PyExc_ValueError, + "Unexpected end of format string, expected ')'"); + return NULL; + } + ctx->is_valid_array = 1; + ctx->new_count = 1; + *tsp = ++ts; + return Py_None; +} +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { + int got_Z = 0; + while (1) { + switch(*ts) { + case 0: + if (ctx->enc_type != 0 && ctx->head == NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + if (ctx->head != NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + return ts; + case ' ': + case '\r': + case '\n': + ++ts; + break; + case '<': + if (!__Pyx_Is_Little_Endian()) { + PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '>': + case '!': + if (__Pyx_Is_Little_Endian()) { + PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '=': + case '@': + case '^': + ctx->new_packmode = *ts++; + break; + case 'T': + { + const char* ts_after_sub; + size_t i, struct_count = ctx->new_count; + size_t struct_alignment = ctx->struct_alignment; + ctx->new_count = 1; + ++ts; + if (*ts != '{') { + PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + ctx->enc_count = 0; + ctx->struct_alignment = 0; + ++ts; + ts_after_sub = ts; + for (i = 0; i != struct_count; ++i) { + ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); + if (!ts_after_sub) return NULL; + } + ts = ts_after_sub; + if (struct_alignment) ctx->struct_alignment = struct_alignment; + } + break; + case '}': + { + size_t alignment = ctx->struct_alignment; + ++ts; + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + if (alignment && ctx->fmt_offset % alignment) { + ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); + } + } + return ts; + case 'x': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->fmt_offset += ctx->new_count; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->enc_packmode = ctx->new_packmode; + ++ts; + break; + case 'Z': + got_Z = 1; + ++ts; + if (*ts != 'f' && *ts != 'd' && *ts != 'g') { + __Pyx_BufFmt_RaiseUnexpectedChar('Z'); + return NULL; + } + CYTHON_FALLTHROUGH; + case '?': case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': + case 'l': case 'L': case 'q': case 'Q': + case 'f': case 'd': case 'g': + case 'O': case 'p': + if ((ctx->enc_type == *ts) && (got_Z == ctx->is_complex) && + (ctx->enc_packmode == ctx->new_packmode) && (!ctx->is_valid_array)) { + ctx->enc_count += ctx->new_count; + ctx->new_count = 1; + got_Z = 0; + ++ts; + break; + } + CYTHON_FALLTHROUGH; + case 's': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_count = ctx->new_count; + ctx->enc_packmode = ctx->new_packmode; + ctx->enc_type = *ts; + ctx->is_complex = got_Z; + ++ts; + ctx->new_count = 1; + got_Z = 0; + break; + case ':': + ++ts; + while(*ts != ':') ++ts; + ++ts; + break; + case '(': + if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; + break; + default: + { + int number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + ctx->new_count = (size_t)number; + } + } + } +} + +/* BufferGetAndValidate */ + static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) { + if (unlikely(info->buf == NULL)) return; + if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL; + __Pyx_ReleaseBuffer(info); +} +static void __Pyx_ZeroBuffer(Py_buffer* buf) { + buf->buf = NULL; + buf->obj = NULL; + buf->strides = __Pyx_zeros; + buf->shape = __Pyx_zeros; + buf->suboffsets = __Pyx_minusones; +} +static int __Pyx__GetBufferAndValidate( + Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, + int nd, int cast, __Pyx_BufFmt_StackElem* stack) +{ + buf->buf = NULL; + if (unlikely(__Pyx_GetBuffer(obj, buf, flags) == -1)) { + __Pyx_ZeroBuffer(buf); + return -1; + } + if (unlikely(buf->ndim != nd)) { + PyErr_Format(PyExc_ValueError, + "Buffer has wrong number of dimensions (expected %d, got %d)", + nd, buf->ndim); + goto fail; + } + if (!cast) { + __Pyx_BufFmt_Context ctx; + __Pyx_BufFmt_Init(&ctx, stack, dtype); + if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail; + } + if (unlikely((size_t)buf->itemsize != dtype->size)) { + PyErr_Format(PyExc_ValueError, + "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)", + buf->itemsize, (buf->itemsize > 1) ? "s" : "", + dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : ""); + goto fail; + } + if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones; + return 0; +fail:; + __Pyx_SafeReleaseBuffer(buf); + return -1; +} + +/* BufferFallbackError */ + static void __Pyx_RaiseBufferFallbackError(void) { + PyErr_SetString(PyExc_ValueError, + "Buffer acquisition failed on assignment; and then reacquiring the old buffer failed too!"); +} + +/* PyObjectCallNoArg */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, NULL, 0); + } +#endif +#ifdef __Pyx_CyFunction_USED + if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func))) +#else + if (likely(PyCFunction_Check(func))) +#endif + { + if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { + return __Pyx_PyObject_CallMethO(func, NULL); + } + } + return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); +} +#endif + +/* JoinPyUnicode */ + static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, + CYTHON_UNUSED Py_UCS4 max_char) { +#if CYTHON_USE_UNICODE_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + PyObject *result_uval; + int result_ukind; + Py_ssize_t i, char_pos; + void *result_udata; +#if CYTHON_PEP393_ENABLED + result_uval = PyUnicode_New(result_ulength, max_char); + if (unlikely(!result_uval)) return NULL; + result_ukind = (max_char <= 255) ? PyUnicode_1BYTE_KIND : (max_char <= 65535) ? PyUnicode_2BYTE_KIND : PyUnicode_4BYTE_KIND; + result_udata = PyUnicode_DATA(result_uval); +#else + result_uval = PyUnicode_FromUnicode(NULL, result_ulength); + if (unlikely(!result_uval)) return NULL; + result_ukind = sizeof(Py_UNICODE); + result_udata = PyUnicode_AS_UNICODE(result_uval); +#endif + char_pos = 0; + for (i=0; i < value_count; i++) { + int ukind; + Py_ssize_t ulength; + void *udata; + PyObject *uval = PyTuple_GET_ITEM(value_tuple, i); + if (unlikely(__Pyx_PyUnicode_READY(uval))) + goto bad; + ulength = __Pyx_PyUnicode_GET_LENGTH(uval); + if (unlikely(!ulength)) + continue; + if (unlikely(char_pos + ulength < 0)) + goto overflow; + ukind = __Pyx_PyUnicode_KIND(uval); + udata = __Pyx_PyUnicode_DATA(uval); + if (!CYTHON_PEP393_ENABLED || ukind == result_ukind) { + memcpy((char *)result_udata + char_pos * result_ukind, udata, (size_t) (ulength * result_ukind)); + } else { + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030300F0 || defined(_PyUnicode_FastCopyCharacters) + _PyUnicode_FastCopyCharacters(result_uval, char_pos, uval, 0, ulength); + #else + Py_ssize_t j; + for (j=0; j < ulength; j++) { + Py_UCS4 uchar = __Pyx_PyUnicode_READ(ukind, udata, j); + __Pyx_PyUnicode_WRITE(result_ukind, result_udata, char_pos+j, uchar); + } + #endif + } + char_pos += ulength; + } + return result_uval; +overflow: + PyErr_SetString(PyExc_OverflowError, "join() result is too long for a Python string"); +bad: + Py_DECREF(result_uval); + return NULL; +#else + result_ulength++; + value_count++; + return PyUnicode_Join(__pyx_empty_unicode, value_tuple); +#endif +} + +/* GetItemInt */ + static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (!j) return NULL; + r = PyObject_GetItem(o, j); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyList_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { + PyObject *r = PyList_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyTuple_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); + if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { + PyObject *r = PyList_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } + else if (PyTuple_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return NULL; + PyErr_Clear(); + } + } + return m->sq_item(o, i); + } + } +#else + if (is_list || PySequence_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +} + +/* GetTopmostException */ + #if CYTHON_USE_EXC_INFO_STACK +static _PyErr_StackItem * +__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) +{ + _PyErr_StackItem *exc_info = tstate->exc_info; + while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && + exc_info->previous_item != NULL) + { + exc_info = exc_info->previous_item; + } + return exc_info; +} +#endif + +/* SaveResetException */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + *type = exc_info->exc_type; + *value = exc_info->exc_value; + *tb = exc_info->exc_traceback; + #else + *type = tstate->exc_type; + *value = tstate->exc_value; + *tb = tstate->exc_traceback; + #endif + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); +} +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = type; + exc_info->exc_value = value; + exc_info->exc_traceback = tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = type; + tstate->exc_value = value; + tstate->exc_traceback = tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +#endif + +/* PyErrExceptionMatches */ + #if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; icurexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; + if (unlikely(PyTuple_Check(err))) + return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); +} +#endif + +/* GetException */ + #if CYTHON_FAST_THREAD_STATE +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) +#endif +{ + PyObject *local_type, *local_value, *local_tb; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) +#else + if (unlikely(PyErr_Occurred())) +#endif + goto bad; + #if PY_MAJOR_VERSION >= 3 + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; + } + #endif + Py_XINCREF(local_tb); + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; +#if CYTHON_FAST_THREAD_STATE + #if CYTHON_USE_EXC_INFO_STACK + { + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = local_type; + exc_info->exc_value = local_value; + exc_info->exc_traceback = local_tb; + } + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = local_type; + tstate->exc_value = local_value; + tstate->exc_traceback = local_tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); +#endif + return 0; +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; +} + +/* TypeImport */ + #ifndef __PYX_HAVE_RT_ImportType +#define __PYX_HAVE_RT_ImportType +static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, + size_t size, enum __Pyx_ImportType_CheckSize check_size) +{ + PyObject *result = 0; + char warning[200]; + Py_ssize_t basicsize; +#ifdef Py_LIMITED_API + PyObject *py_basicsize; +#endif + result = PyObject_GetAttrString(module, class_name); + if (!result) + goto bad; + if (!PyType_Check(result)) { + PyErr_Format(PyExc_TypeError, + "%.200s.%.200s is not a type object", + module_name, class_name); + goto bad; + } +#ifndef Py_LIMITED_API + basicsize = ((PyTypeObject *)result)->tp_basicsize; +#else + py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); + if (!py_basicsize) + goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; +#endif + if ((size_t)basicsize < size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize); + goto bad; + } + if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize); + goto bad; + } + else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) { + PyOS_snprintf(warning, sizeof(warning), + "%s.%s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize); + if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; + } + return (PyTypeObject *)result; +bad: + Py_XDECREF(result); + return NULL; +} +#endif + +/* Import */ + static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_MAJOR_VERSION < 3 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) { + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + #endif + if (!module) { + #if PY_MAJOR_VERSION < 3 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } +bad: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + +/* ImportFrom */ + static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { + PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); + if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Format(PyExc_ImportError, + #if PY_MAJOR_VERSION < 3 + "cannot import name %.230s", PyString_AS_STRING(name)); + #else + "cannot import name %S", name); + #endif + } + return value; +} + +/* CLineInTraceback */ + #ifndef CYTHON_CLINE_IN_TRACEBACK +static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { + PyObject *use_cline; + PyObject *ptype, *pvalue, *ptraceback; +#if CYTHON_COMPILING_IN_CPYTHON + PyObject **cython_runtime_dict; +#endif + if (unlikely(!__pyx_cython_runtime)) { + return c_line; + } + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); +#if CYTHON_COMPILING_IN_CPYTHON + cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); + if (likely(cython_runtime_dict)) { + __PYX_PY_DICT_LOOKUP_IF_MODIFIED( + use_cline, *cython_runtime_dict, + __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) + } else +#endif + { + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + if (use_cline_obj) { + use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; + Py_DECREF(use_cline_obj); + } else { + PyErr_Clear(); + use_cline = NULL; + } + } + if (!use_cline) { + c_line = 0; + PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); + } + else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { + c_line = 0; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + return c_line; +} +#endif + +/* CodeObjectCache */ + static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +/* AddTraceback */ + #include "compile.h" +#include "frameobject.h" +#include "traceback.h" +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + #if PY_MAJOR_VERSION < 3 + py_srcfile = PyString_FromString(filename); + #else + py_srcfile = PyUnicode_FromString(filename); + #endif + if (!py_srcfile) goto bad; + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + #else + py_funcname = PyUnicode_FromString(funcname); + #endif + } + if (!py_funcname) goto bad; + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + Py_DECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + if (c_line) { + c_line = __Pyx_CLineForTraceback(tstate, c_line); + } + py_code = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!py_code) { + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) goto bad; + __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); + } + py_frame = PyFrame_New( + tstate, /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + __Pyx_PyFrame_SetLineNumber(py_frame, py_line); + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +#if PY_MAJOR_VERSION < 3 +static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { + if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); + PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); + return -1; +} +static void __Pyx_ReleaseBuffer(Py_buffer *view) { + PyObject *obj = view->obj; + if (!obj) return; + if (PyObject_CheckBuffer(obj)) { + PyBuffer_Release(view); + return; + } + if ((0)) {} + view->obj = NULL; + Py_DECREF(obj); +} +#endif + + + /* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { + const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + +/* CIntFromPyVerify */ + #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { + const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + +/* Declarations */ + #if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return ::std::complex< float >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return x + y*(__pyx_t_float_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + __pyx_t_float_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +/* Arithmetic */ + #if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + #if 1 + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + if (b.imag == 0) { + return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); + } else if (fabsf(b.real) >= fabsf(b.imag)) { + if (b.real == 0 && b.imag == 0) { + return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.imag); + } else { + float r = b.imag / b.real; + float s = (float)(1.0) / (b.real + b.imag * r); + return __pyx_t_float_complex_from_parts( + (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); + } + } else { + float r = b.real / b.imag; + float s = (float)(1.0) / (b.imag + b.real * r); + return __pyx_t_float_complex_from_parts( + (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); + } + } + #else + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + if (b.imag == 0) { + return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); + } else { + float denom = b.real * b.real + b.imag * b.imag; + return __pyx_t_float_complex_from_parts( + (a.real * b.real + a.imag * b.imag) / denom, + (a.imag * b.real - a.real * b.imag) / denom); + } + } + #endif + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrtf(z.real*z.real + z.imag*z.imag); + #else + return hypotf(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + float r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + float denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + return __Pyx_c_prod_float(a, a); + case 3: + z = __Pyx_c_prod_float(a, a); + return __Pyx_c_prod_float(z, a); + case 4: + z = __Pyx_c_prod_float(a, a); + return __Pyx_c_prod_float(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } else if (b.imag == 0) { + z.real = powf(a.real, b.real); + z.imag = 0; + return z; + } else if (a.real > 0) { + r = a.real; + theta = 0; + } else { + r = -a.real; + theta = atan2f(0.0, -1.0); + } + } else { + r = __Pyx_c_abs_float(a); + theta = atan2f(a.imag, a.real); + } + lnr = logf(r); + z_r = expf(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cosf(z_theta); + z.imag = z_r * sinf(z_theta); + return z; + } + #endif +#endif + +/* Declarations */ + #if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return ::std::complex< double >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return x + y*(__pyx_t_double_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + __pyx_t_double_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +/* Arithmetic */ + #if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + #if 1 + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + if (b.imag == 0) { + return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); + } else if (fabs(b.real) >= fabs(b.imag)) { + if (b.real == 0 && b.imag == 0) { + return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.imag); + } else { + double r = b.imag / b.real; + double s = (double)(1.0) / (b.real + b.imag * r); + return __pyx_t_double_complex_from_parts( + (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); + } + } else { + double r = b.real / b.imag; + double s = (double)(1.0) / (b.imag + b.real * r); + return __pyx_t_double_complex_from_parts( + (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); + } + } + #else + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + if (b.imag == 0) { + return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); + } else { + double denom = b.real * b.real + b.imag * b.imag; + return __pyx_t_double_complex_from_parts( + (a.real * b.real + a.imag * b.imag) / denom, + (a.imag * b.real - a.real * b.imag) / denom); + } + } + #endif + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrt(z.real*z.real + z.imag*z.imag); + #else + return hypot(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + double r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + double denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + return __Pyx_c_prod_double(a, a); + case 3: + z = __Pyx_c_prod_double(a, a); + return __Pyx_c_prod_double(z, a); + case 4: + z = __Pyx_c_prod_double(a, a); + return __Pyx_c_prod_double(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } else if (b.imag == 0) { + z.real = pow(a.real, b.real); + z.imag = 0; + return z; + } else if (a.real > 0) { + r = a.real; + theta = 0; + } else { + r = -a.real; + theta = atan2(0.0, -1.0); + } + } else { + r = __Pyx_c_abs_double(a); + theta = atan2(a.imag, a.real); + } + lnr = log(r); + z_r = exp(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cos(z_theta); + z.imag = z_r * sin(z_theta); + return z; + } + #endif +#endif + +/* CIntFromPy */ + static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { + const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +/* CIntFromPy */ + static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { + const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } +#endif + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + long val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +/* FastTypeChecks */ + #if CYTHON_COMPILING_IN_CPYTHON +static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { + while (a) { + a = a->tp_base; + if (a == b) + return 1; + } + return b == &PyBaseObject_Type; +} +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (a == b) return 1; + mro = a->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(a, b); +} +#if PY_MAJOR_VERSION == 2 +static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { + PyObject *exception, *value, *tb; + int res; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&exception, &value, &tb); + res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + if (!res) { + res = PyObject_IsSubclass(err, exc_type2); + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + } + __Pyx_ErrRestore(exception, value, tb); + return res; +} +#else +static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { + int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; + if (!res) { + res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + } + return res; +} +#endif +static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + assert(PyExceptionClass_Check(exc_type)); + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; i= 0x02070000 + cobj = PyCapsule_New(tmp.p, sig, 0); +#else + cobj = PyCObject_FromVoidPtrAndDesc(tmp.p, (void *)sig, 0); +#endif + if (!cobj) + goto bad; + if (PyDict_SetItemString(d, name, cobj) < 0) + goto bad; + Py_DECREF(cobj); + Py_DECREF(d); + return 0; +bad: + Py_XDECREF(cobj); + Py_XDECREF(d); + return -1; +} + +/* InitStrings */ + static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + if (PyObject_Hash(*t->p) == -1) + return -1; + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); +} +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +#if !CYTHON_PEP393_ENABLED +static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +} +#else +static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (likely(PyUnicode_IS_ASCII(o))) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +} +#endif +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { + return __Pyx_PyUnicode_AsStringAndSize(o, length); + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { + int retval; + if (unlikely(!x)) return -1; + retval = __Pyx_PyObject_IsTrue(x); + Py_DECREF(x); + return retval; +} +static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { +#if PY_MAJOR_VERSION >= 3 + if (PyLong_Check(result)) { + if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, + "__int__ returned non-int (type %.200s). " + "The ability to return an instance of a strict subclass of int " + "is deprecated, and may be removed in a future version of Python.", + Py_TYPE(result)->tp_name)) { + Py_DECREF(result); + return NULL; + } + return result; + } +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + type_name, type_name, Py_TYPE(result)->tp_name); + Py_DECREF(result); + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { +#if CYTHON_USE_TYPE_SLOTS + PyNumberMethods *m; +#endif + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x) || PyLong_Check(x))) +#else + if (likely(PyLong_Check(x))) +#endif + return __Pyx_NewRef(x); +#if CYTHON_USE_TYPE_SLOTS + m = Py_TYPE(x)->tp_as_number; + #if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = m->nb_int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = m->nb_long(x); + } + #else + if (likely(m && m->nb_int)) { + name = "int"; + res = m->nb_int(x); + } + #endif +#else + if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { + res = PyNumber_Int(x); + } +#endif + if (likely(res)) { +#if PY_MAJOR_VERSION < 3 + if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { +#else + if (unlikely(!PyLong_CheckExact(res))) { +#endif + return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(b); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { + return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +#endif /* Py_PYTHON_H */ diff --git a/python/l0learn/cyarma.pxd b/python/l0learn/cyarma.pxd new file mode 100644 index 0000000..d9809e5 --- /dev/null +++ b/python/l0learn/cyarma.pxd @@ -0,0 +1,112 @@ +# distutils: language = c++ + +from libcpp cimport bool +cimport numpy as np + +cdef extern from "armadillo" namespace "arma" nogil: + + # matrix class (double) + cdef cppclass dmat: + dmat(double * aux_mem, int n_rows, int n_cols, bool copy_aux_mem, bool strict) nogil + dmat(dmat x) + dmat() nogil + int n_rows + int n_cols + int n_elem + double * memptr() nogil + + # available for testing purposes + dmat operator*(const dmat) nogil + + # vector class (double) + cdef cppclass dvec: + dvec(double * aux_mem, int number_of_elements, bool copy_aux_mem, bool strict) nogil + dvec() nogil + int n_rows + int n_cols + int n_elem + int n_nonzero + double * memptr() nogil + + #vector class (int) + cdef cppclass uvec: + uvec(unsigned long long * aux_mem, int number_of_elements, bool copy_aux_mem, bool strict) nogil + uvec() nogil + int n_rows + int n_cols + int n_elem + int n_nonzero + unsigned long long * memptr() nogil + + # sparse matrix class (double) + cdef cppclass sp_dmat: + sp_dmat(uvec rowind, uvec colptr, dvec values, int n_rows, int n_cols) nogil + sp_dmat() nogil + int n_rows + int n_cols + int n_elem + int n_nonzero + double * memptr() nogil + uvec row_indices + uvec col_ptrs + dvec values + + # double& operator[](int) nogil + # double& operator[](int,int) nogil + # double& at(int,int) nogil + # double& at(int) nogil + + cppclass const_iterator: + const_iterator operator++() + # bint operator==(iterator) + # bint operator!=(iterator) + unsigned long long row() + unsigned long long col() + double& operator*() + + # iterators + const_iterator begin() + # const_iterator end() + + cdef cppclass field[T]: + field() nogil + field(int n_elem) + int n_rows + int n_cols + int n_elem + T& operator[](int) nogil + +cdef field[sp_dmat] list_to_sp_dmat_field(list values) + +cdef field[dvec] list_to_dvec_field(list values) + +cdef dmat * numpy_to_dmat(np.ndarray[np.double_t, ndim=2] X) + +cdef dmat numpy_to_dmat_d(np.ndarray[np.double_t, ndim=2] X) + +# cdef const dmat numpy_to_const_dmat_d(np.ndarray[np.double_t, ndim=2] X) + +cdef dvec * numpy_to_dvec(np.ndarray[np.double_t, ndim=1] x) + +cdef dvec numpy_to_dvec_d(np.ndarray[np.double_t, ndim=1] x) + +cdef uvec * numpy_to_uvec(np.ndarray[np.uint64_t, ndim=1] x) + +cdef uvec numpy_to_uvec_d(np.ndarray[np.uint64_t, ndim=1] x) + +cdef sp_dmat * numpy_to_sp_dmat(x) + +cdef sp_dmat numpy_to_sp_dmat_d(x) + +cdef list sp_dmat_field_to_list(field[sp_dmat] f) + +cdef list dvec_field_to_list(field[dvec] f) + +cdef np.ndarray[np.double_t, ndim=2] dmat_to_numpy(const dmat & X, np.ndarray[np.double_t, ndim=2] D) + +cdef np.ndarray[np.double_t, ndim=1] dvec_to_numpy(const dvec & X, np.ndarray[np.double_t, ndim=1] D) + +cdef np.ndarray[np.uint64_t, ndim=1] uvec_to_numpy(const uvec & X, np.ndarray[np.uint64_t, ndim=1] D) + +cdef sp_dmat_to_numpy(const sp_dmat & X, np.ndarray[np.uint64_t, ndim=1] rowind, + np.ndarray[np.uint64_t, ndim=1] colptr, np.ndarray[np.double_t, ndim=1] values) \ No newline at end of file diff --git a/python/l0learn/cyarma.pyx b/python/l0learn/cyarma.pyx new file mode 100644 index 0000000..f198f84 --- /dev/null +++ b/python/l0learn/cyarma.pyx @@ -0,0 +1,240 @@ +cimport cython +import numpy as np +cimport numpy as np + +from scipy.sparse.csc import csc_matrix +from cython.operator cimport dereference as deref, preincrement as inc + +from libcpp cimport bool + +cdef extern from "armadillo" namespace "arma" nogil: + # matrix class (double) + + cdef cppclass dmat: + dmat(double * aux_mem, int n_rows, int n_cols, bool copy_aux_mem, bool strict) nogil + dmat(dmat& x) + dmat() nogil + int n_rows + int n_cols + int n_elem + double * memptr() nogil + + # available for testing purposes + dmat operator*(const dmat) nogil + + # vector class (double) + cdef cppclass dvec: + dvec(double * aux_mem, int number_of_elements, bool copy_aux_mem, bool strict) nogil + dvec() nogil + int n_rows + int n_cols + int n_elem + double * memptr() nogil + + #vector class (int) + cdef cppclass uvec: + uvec(unsigned long long * aux_mem, int number_of_elements, bool copy_aux_mem, bool strict) nogil + uvec() nogil + int n_rows + int n_cols + int n_elem + int n_nonzero + unsigned long long * memptr() nogil + + # sparse matrix class (double) + cdef cppclass sp_dmat: + sp_dmat(uvec rowind, uvec colptr, dvec values, int n_rows, int n_cols) nogil + sp_dmat() nogil + int n_rows + int n_cols + int n_elem + int n_nonzero + double * memptr() nogil + uvec row_indices + uvec col_ptrs + dvec values + + # double& operator[](int) nogil + # double& operator[](int,int) nogil + # double& at(int,int) nogil + # double& at(int) nogil + + cppclass const_iterator: + const_iterator operator++() + # bint operator==(iterator) + # bint operator!=(iterator) + unsigned long long row() + unsigned long long col() + double& operator*() + + # iterators + const_iterator begin() + const_iterator end() + + cdef cppclass field[T]: + field() nogil + field(int n_elem) + int n_rows + int n_cols + int n_elem + T& operator[](int) nogil + + +## TODO: refactor to return pointer, but other function derefed. + +##### Tools to convert numpy arrays to armadillo arrays ###### +cdef field[sp_dmat] list_to_sp_dmat_field(list values): + cdef field[sp_dmat] f = field[sp_dmat](len(values)) + for i, value in enumerate(values): + if not isinstance(value, csc_matrix) or value.ndim != 2 or np.isreal(value): + raise TypeError(f"expected each value in values to be a 2D real csc_matrix, but got {value}") + f[i] = numpy_to_sp_dmat_d(value) + return f + +cdef field[dvec] list_to_dvec_field(list values): + cdef field[dvec] f = field[dvec](len(values)) + for i, value in enumerate(values): + if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isreal(value): + raise TypeError(f"expected each value in values to be a 1D real numpy matrix, but got {value}") + f[i] = numpy_to_dvec_d(value) + return f + +cdef dmat * numpy_to_dmat(np.ndarray[np.double_t, ndim=2] X): + # TODO: Add checks on X (Size, ...) + # TODO: Add flags for new dmat. See: Advanced constructors in http://arma.sourceforge.net/docs.html#Mat + # mat(ptr_aux_mem, n_rows, n_cols, copy_aux_mem = true, strict = false) + # TODO: raise Warning on copy or replication of data + if not (X.flags.f_contiguous or X.flags.owndata): + X = X.copy(order="F") + cdef dmat *aR_p = new dmat( X.data, X.shape[0], X.shape[1], False, True) + return aR_p + +cdef dmat numpy_to_dmat_d(np.ndarray[np.double_t, ndim=2] X): + cdef dmat * aR_p = numpy_to_dmat(X) + cdef dmat aR = deref(aR_p) + del aR_p + return aR + +cdef dvec * numpy_to_dvec(np.ndarray[np.double_t, ndim=1] x): + if not (x.flags.f_contiguous or x.flags.owndata): + x = x.copy() + cdef dvec *ar_p = new dvec( x.data, x.shape[0], False, True) + return ar_p + +cdef dvec numpy_to_dvec_d(np.ndarray[np.double_t, ndim=1] x): + cdef dvec *ar_p = numpy_to_dvec(x) + cdef dvec ar = deref(ar_p) + del ar_p + return ar + +cdef uvec * numpy_to_uvec(np.ndarray[np.uint64_t, ndim=1] x): + if not (x.flags.f_contiguous or x.flags.owndata): + x = x.copy() + cdef uvec *ar_p = new uvec( x.data, x.shape[0], False, True) + return ar_p + +cdef uvec numpy_to_uvec_d(np.ndarray[np.uint64_t, ndim=1] x): + cdef uvec *ar_p = numpy_to_uvec(x) + cdef uvec ar = deref(ar_p) + del ar_p + return ar + +cdef sp_dmat * numpy_to_sp_dmat(x): + if not isinstance(x, csc_matrix): + raise ValueError(f"expected x to be of type {csc_matrix}, but got {type(x)}") + + cdef np.ndarray[np.double_t, ndim=1] data = x.data + cdef dvec values = numpy_to_dvec_d(data) + + cdef np.ndarray[np.uint64_t, ndim=1] indptr = x.indptr.astype(np.uint64) + cdef uvec colptr = numpy_to_uvec_d(indptr) + + cdef np.ndarray[np.uint64_t, ndim=1] indices = x.indices.astype(np.uint64) + cdef uvec rowind = numpy_to_uvec_d(indices) + + cdef sp_dmat * ar = new sp_dmat(rowind, colptr, values, x.shape[0], x.shape[1]) + + return ar + +cdef sp_dmat numpy_to_sp_dmat_d(x): + cdef sp_dmat *ar_p = numpy_to_sp_dmat(x) + cdef sp_dmat ar = deref(ar_p) + del ar_p + return ar + +##### Converting back to l0learn arrays, must pass preallocated memory or None +# all data will be copied since numpy doesn't own the data and can't clean up +# otherwise. Maybe this can be improved. ####### + +@cython.boundscheck(False) +cdef list sp_dmat_field_to_list(field[sp_dmat] f): + cdef list lst = [] + for i in range(f.n_elem): + lst.append(sp_dmat_to_numpy(f[i], None, None, None)) + return lst + +@cython.boundscheck(False) +cdef list dvec_field_to_list(field[dvec] f): + cdef list lst = [] + for i in range(f.n_elem): + lst.append(dvec_to_numpy(f[i], None)) + return lst + +@cython.boundscheck(False) +cdef np.ndarray[np.double_t, ndim=2] dmat_to_numpy(const dmat & X, np.ndarray[np.double_t, ndim=2] D): + # TODO: Check order of X and D + cdef const double * Xptr = X.memptr() + + if D is None: + D = np.empty((X.n_rows, X.n_cols), dtype=np.double, order="F") + cdef double * Dptr = D.data + for i in range(X.n_rows*X.n_cols): + Dptr[i] = Xptr[i] + return D + +@cython.boundscheck(False) +cdef np.ndarray[np.double_t, ndim=1] dvec_to_numpy(const dvec & X, np.ndarray[np.double_t, ndim=1] D): + cdef const double * Xptr = X.memptr() + + if D is None: + D = np.empty(X.n_elem, dtype=np.double) + cdef double * Dptr = D.data + for i in range(X.n_elem): + Dptr[i] = Xptr[i] + return D + + +@cython.boundscheck(False) +cdef np.ndarray[np.uint64_t, ndim=1] uvec_to_numpy(const uvec & X, np.ndarray[np.uint64_t, ndim=1] D): + cdef const unsigned long long * Xptr = X.memptr() + + if D is None: + D = np.empty(X.n_elem, dtype=np.uint64) + cdef unsigned long long * Dptr = D.data + for i in range(X.n_elem): + Dptr[i] = Xptr[i] + return D + + +@cython.boundscheck(False) +cdef sp_dmat_to_numpy(const sp_dmat & X, np.ndarray[np.uint64_t, ndim=1] rowind, + np.ndarray[np.uint64_t, ndim=1] colind, np.ndarray[np.double_t, ndim=1] values): + # TODO: Check order of X and D + if rowind is None: + rowind = np.empty(X.n_nonzero, dtype=np.uint64) + if colind is None: + colind = np.empty(X.n_nonzero, dtype=np.uint64) + if values is None: + values = np.empty(X.n_nonzero, dtype=np.double) + + cdef sp_dmat.const_iterator it = X.begin() + + for i in range(X.n_nonzero): + # TODO: Double check the following comment... + # Arma is column major so rows are columns and columns are rows when converting back to l0learn (row major) + rowind[i] = it.col() + colind[i] = it.row() + values[i] = deref(it) + inc(it) + + return csc_matrix((values, (colind, rowind)), shape=(X.n_rows, X.n_cols)) diff --git a/python/l0learn/interface.cpp b/python/l0learn/interface.cpp new file mode 100644 index 0000000..a5dba29 --- /dev/null +++ b/python/l0learn/interface.cpp @@ -0,0 +1,17451 @@ +/* Generated by Cython 0.29.21 */ + +/* BEGIN: Cython Metadata +{ + "distutils": { + "depends": [ + "/Users/tnonet/opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/core/include/numpy/arrayobject.h", + "/Users/tnonet/opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/core/include/numpy/ufuncobject.h", + "l0learn/src/include/L0LearnCore.h" + ], + "extra_compile_args": [ + "-std=c++11" + ], + "extra_link_args": [ + "-std=c++11" + ], + "include_dirs": [ + "l0learn", + ".", + "/Users/tnonet/opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/core/include", + "l0learn/src/include" + ], + "language": "c++", + "libraries": [ + "armadillo", + "lapack", + "blas" + ], + "name": "l0learn.interface", + "sources": [ + "l0learn/interface.pyx", + "l0learn/src/CDL012LogisticSwaps.cpp", + "l0learn/src/Grid2D.cpp", + "l0learn/src/CDL012SquaredHingeSwaps.cpp", + "l0learn/src/Normalize.cpp", + "l0learn/src/CDL012Swaps.cpp", + "l0learn/src/Grid.cpp", + "l0learn/src/Grid1D.cpp" + ] + }, + "module_name": "l0learn.interface" +} +END: Cython Metadata */ + +#define PY_SSIZE_T_CLEAN +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.6+ or Python 3.3+. +#else +#define CYTHON_ABI "0_29_21" +#define CYTHON_HEX_VERSION 0x001D15F0 +#define CYTHON_FUTURE_DIVISION 1 +#include +#ifndef offsetof + #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#define __PYX_COMMA , +#ifndef HAVE_LONG_LONG + #if PY_VERSION_HEX >= 0x02070000 + #define HAVE_LONG_LONG + #endif +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION + #define CYTHON_COMPILING_IN_PYPY 1 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 +#elif defined(PYSTON_VERSION) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 1 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 +#else + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) + #define CYTHON_USE_PYTYPE_LOOKUP 1 + #endif + #if PY_MAJOR_VERSION < 3 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #define CYTHON_USE_PYLONG_INTERNALS 1 + #endif + #ifndef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 1 + #endif + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #if PY_VERSION_HEX < 0x030300F0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #elif !defined(CYTHON_USE_UNICODE_WRITER) + #define CYTHON_USE_UNICODE_WRITER 1 + #endif + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #ifndef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #ifndef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 1 + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) + #endif + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #endif + #ifndef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) + #endif + #ifndef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #endif +#endif +#if !defined(CYTHON_FAST_PYCCALL) +#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) +#endif +#if CYTHON_USE_PYLONG_INTERNALS + #include "longintrepr.h" + #undef SHIFT + #undef BASE + #undef MASK + #ifdef SIZEOF_VOID_P + enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; + #endif +#endif +#ifndef __has_attribute + #define __has_attribute(x) 0 +#endif +#ifndef __has_cpp_attribute + #define __has_cpp_attribute(x) 0 +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_MAYBE_UNUSED_VAR +# if defined(__cplusplus) + template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } +# else +# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# endif +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) +#ifdef _MSC_VER + #ifndef _MSC_STDINT_H_ + #if _MSC_VER < 1300 + typedef unsigned char uint8_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int32 uint32_t; + #endif + #endif +#else + #include +#endif +#ifndef CYTHON_FALLTHROUGH + #if defined(__cplusplus) && __cplusplus >= 201103L + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #elif __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_attribute(fallthrough) + #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) + #else + #define CYTHON_FALLTHROUGH + #endif + #endif + #if defined(__clang__ ) && defined(__apple_build_version__) + #if __apple_build_version__ < 7000000 + #undef CYTHON_FALLTHROUGH + #define CYTHON_FALLTHROUGH + #endif + #endif +#endif + +#ifndef __cplusplus + #error "Cython files generated with the C++ option must be compiled with a C++ compiler." +#endif +#ifndef CYTHON_INLINE + #if defined(__clang__) + #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) + #else + #define CYTHON_INLINE inline + #endif +#endif +template +void __Pyx_call_destructor(T& x) { + x.~T(); +} +template +class __Pyx_FakeReference { + public: + __Pyx_FakeReference() : ptr(NULL) { } + __Pyx_FakeReference(const T& ref) : ptr(const_cast(&ref)) { } + T *operator->() { return ptr; } + T *operator&() { return ptr; } + operator T&() { return *ptr; } + template bool operator ==(U other) { return *ptr == other; } + template bool operator !=(U other) { return *ptr != other; } + private: + T *ptr; +}; + +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) + #define Py_OptimizeFlag 0 +#endif +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyClass_Type +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" +#if PY_VERSION_HEX >= 0x030800A4 && PY_VERSION_HEX < 0x030800B2 + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, 0, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#else + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#endif + #define __Pyx_DefaultClassType PyType_Type +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#ifndef METH_STACKLESS + #define METH_STACKLESS 0 +#endif +#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) + #ifndef METH_FASTCALL + #define METH_FASTCALL 0x80 + #endif + typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); + typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, + Py_ssize_t nargs, PyObject *kwnames); +#else + #define __Pyx_PyCFunctionFast _PyCFunctionFast + #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords +#endif +#if CYTHON_FAST_PYCCALL +#define __Pyx_PyFastCFunction_Check(func)\ + ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) +#else +#define __Pyx_PyFastCFunction_Check(func) 0 +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) + #define PyObject_Malloc(s) PyMem_Malloc(s) + #define PyObject_Free(p) PyMem_Free(p) + #define PyObject_Realloc(p) PyMem_Realloc(p) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 + #define PyMem_RawMalloc(n) PyMem_Malloc(n) + #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) + #define PyMem_RawFree(p) PyMem_Free(p) +#endif +#if CYTHON_COMPILING_IN_PYSTON + #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) +#else + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) +#endif +#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x03060000 + #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() +#elif PY_VERSION_HEX >= 0x03000000 + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#else + #define __Pyx_PyThreadState_Current _PyThreadState_Current +#endif +#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) +#include "pythread.h" +#define Py_tss_NEEDS_INIT 0 +typedef int Py_tss_t; +static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { + *key = PyThread_create_key(); + return 0; +} +static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { + Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); + *key = Py_tss_NEEDS_INIT; + return key; +} +static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { + PyObject_Free(key); +} +static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { + return *key != Py_tss_NEEDS_INIT; +} +static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { + PyThread_delete_key(*key); + *key = Py_tss_NEEDS_INIT; +} +static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { + return PyThread_set_key_value(*key, value); +} +static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { + return PyThread_get_key_value(*key); +} +#endif +#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) +#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) +#else +#define __Pyx_PyDict_NewPresized(n) PyDict_New() +#endif +#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +#else +#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) + #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) + #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #endif +#else + #define CYTHON_PEP393_ENABLED 0 + #define PyUnicode_1BYTE_KIND 1 + #define PyUnicode_2BYTE_KIND 2 + #define PyUnicode_4BYTE_KIND 4 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) + #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#endif +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#else + #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#endif +#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) + #define PyObject_ASCII(o) PyObject_Repr(o) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBaseString_Type PyUnicode_Type + #define PyStringObject PyUnicodeObject + #define PyString_Type PyUnicode_Type + #define PyString_Check PyUnicode_Check + #define PyString_CheckExact PyUnicode_CheckExact +#ifndef PyObject_Unicode + #define PyObject_Unicode PyObject_Str +#endif +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#endif +#if PY_VERSION_HEX >= 0x030900A4 + #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) +#else + #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) +#endif +#if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) +#else + #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask + #define PyNumber_Int PyNumber_Long +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY + #ifndef PyUnicode_InternFromString + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) + #endif +#endif +#if PY_VERSION_HEX < 0x030200A4 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t PyInt_AsLong +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) +#else + #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) +#endif +#if CYTHON_USE_ASYNC_SLOTS + #if PY_VERSION_HEX >= 0x030500B1 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods + #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) + #else + #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) + #endif +#else + #define __Pyx_PyType_AsAsync(obj) NULL +#endif +#ifndef __Pyx_PyAsyncMethodsStruct + typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + } __Pyx_PyAsyncMethodsStruct; +#endif + +#if defined(WIN32) || defined(MS_WINDOWS) + #define _USE_MATH_DEFINES +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif +#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) +#define __Pyx_truncl trunc +#else +#define __Pyx_truncl truncl +#endif + +#define __PYX_MARK_ERR_POS(f_index, lineno) \ + { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } +#define __PYX_ERR(f_index, lineno, Ln_error) \ + { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__l0learn__interface +#define __PYX_HAVE_API__l0learn__interface +/* Early includes */ +#include "ios" +#include "new" +#include "stdexcept" +#include "typeinfo" +#include +#include +#include +#include +#include "numpy/arrayobject.h" +#include "numpy/ufuncobject.h" + + /* NumPy API declarations from "numpy/__init__.pxd" */ + +#include "armadillo" +#include "src/include/L0LearnCore.h" +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { + return (size_t) i < (size_t) limit; +} +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) + #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#else + #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize +#endif +#define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); +#define __Pyx_PySequence_Tuple(obj)\ + (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +#if CYTHON_ASSUME_SAFE_MACROS +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) +#else +#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) +#endif +#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + const char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + if (strcmp(default_encoding_c, "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (!ascii_chars_u) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { + PyErr_Format( + PyExc_ValueError, + "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + Py_DECREF(ascii_chars_u); + Py_DECREF(ascii_chars_b); + } + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); + if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ +static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } + +static PyObject *__pyx_m = NULL; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_cython_runtime = NULL; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static PyObject *__pyx_empty_unicode; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + +/* Header.proto */ +#if !defined(CYTHON_CCOMPLEX) + #if defined(__cplusplus) + #define CYTHON_CCOMPLEX 1 + #elif defined(_Complex_I) + #define CYTHON_CCOMPLEX 1 + #else + #define CYTHON_CCOMPLEX 0 + #endif +#endif +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #include + #else + #include + #endif +#endif +#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) + #undef _Complex_I + #define _Complex_I 1.0fj +#endif + + +static const char *__pyx_f[] = { + "l0learn/interface.pyx", + "__init__.pxd", + "stringsource", + "type.pxd", +}; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":689 + * # in Cython to enable them only on the right systems. + * + * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + */ +typedef npy_int8 __pyx_t_5numpy_int8_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":690 + * + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t + */ +typedef npy_int16 __pyx_t_5numpy_int16_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":691 + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< + * ctypedef npy_int64 int64_t + * #ctypedef npy_int96 int96_t + */ +typedef npy_int32 __pyx_t_5numpy_int32_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":692 + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< + * #ctypedef npy_int96 int96_t + * #ctypedef npy_int128 int128_t + */ +typedef npy_int64 __pyx_t_5numpy_int64_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":696 + * #ctypedef npy_int128 int128_t + * + * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + */ +typedef npy_uint8 __pyx_t_5numpy_uint8_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":697 + * + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t + */ +typedef npy_uint16 __pyx_t_5numpy_uint16_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":698 + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< + * ctypedef npy_uint64 uint64_t + * #ctypedef npy_uint96 uint96_t + */ +typedef npy_uint32 __pyx_t_5numpy_uint32_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":699 + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< + * #ctypedef npy_uint96 uint96_t + * #ctypedef npy_uint128 uint128_t + */ +typedef npy_uint64 __pyx_t_5numpy_uint64_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":703 + * #ctypedef npy_uint128 uint128_t + * + * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< + * ctypedef npy_float64 float64_t + * #ctypedef npy_float80 float80_t + */ +typedef npy_float32 __pyx_t_5numpy_float32_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":704 + * + * ctypedef npy_float32 float32_t + * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< + * #ctypedef npy_float80 float80_t + * #ctypedef npy_float128 float128_t + */ +typedef npy_float64 __pyx_t_5numpy_float64_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":713 + * # The int types are mapped a bit surprising -- + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t + */ +typedef npy_long __pyx_t_5numpy_int_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":714 + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong longlong_t + * + */ +typedef npy_longlong __pyx_t_5numpy_long_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":715 + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_ulong uint_t + */ +typedef npy_longlong __pyx_t_5numpy_longlong_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":717 + * ctypedef npy_longlong longlong_t + * + * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t + */ +typedef npy_ulong __pyx_t_5numpy_uint_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":718 + * + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulonglong_t + * + */ +typedef npy_ulonglong __pyx_t_5numpy_ulong_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":719 + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_intp intp_t + */ +typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":721 + * ctypedef npy_ulonglong ulonglong_t + * + * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< + * ctypedef npy_uintp uintp_t + * + */ +typedef npy_intp __pyx_t_5numpy_intp_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":722 + * + * ctypedef npy_intp intp_t + * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< + * + * ctypedef npy_double float_t + */ +typedef npy_uintp __pyx_t_5numpy_uintp_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":724 + * ctypedef npy_uintp uintp_t + * + * ctypedef npy_double float_t # <<<<<<<<<<<<<< + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t + */ +typedef npy_double __pyx_t_5numpy_float_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":725 + * + * ctypedef npy_double float_t + * ctypedef npy_double double_t # <<<<<<<<<<<<<< + * ctypedef npy_longdouble longdouble_t + * + */ +typedef npy_double __pyx_t_5numpy_double_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":726 + * ctypedef npy_double float_t + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cfloat cfloat_t + */ +typedef npy_longdouble __pyx_t_5numpy_longdouble_t; +/* Declarations.proto */ +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< float > __pyx_t_float_complex; + #else + typedef float _Complex __pyx_t_float_complex; + #endif +#else + typedef struct { float real, imag; } __pyx_t_float_complex; +#endif +static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); + +/* Declarations.proto */ +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< double > __pyx_t_double_complex; + #else + typedef double _Complex __pyx_t_double_complex; + #endif +#else + typedef struct { double real, imag; } __pyx_t_double_complex; +#endif +static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); + + +/*--- Type declarations ---*/ + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":728 + * ctypedef npy_longdouble longdouble_t + * + * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t + */ +typedef npy_cfloat __pyx_t_5numpy_cfloat_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":729 + * + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< + * ctypedef npy_clongdouble clongdouble_t + * + */ +typedef npy_cdouble __pyx_t_5numpy_cdouble_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":730 + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cdouble complex_t + */ +typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":732 + * ctypedef npy_clongdouble clongdouble_t + * + * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew1(a): + */ +typedef npy_cdouble __pyx_t_5numpy_complex_t; + +/* --- Runtime support code (head) --- */ +/* Refnanny.proto */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* DictGetItem.proto */ +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); +#define __Pyx_PyObject_Dict_GetItem(obj, name)\ + (likely(PyDict_CheckExact(obj)) ?\ + __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name)) +#else +#define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) +#define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) +#endif + +/* PyObjectCall.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() PyErr_Occurred() +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +#else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* PyDictVersioning.proto */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) +#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ + (version_var) = __PYX_GET_DICT_VERSION(dict);\ + (cache_var) = (value); +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ + (VAR) = __pyx_dict_cached_value;\ + } else {\ + (VAR) = __pyx_dict_cached_value = (LOOKUP);\ + __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ + }\ +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); +#else +#define __PYX_GET_DICT_VERSION(dict) (0) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); +#endif + +/* GetModuleGlobalName.proto */ +#if CYTHON_USE_DICT_VERSIONS +#define __Pyx_GetModuleGlobalName(var, name) {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ + (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ + __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} +#define __Pyx_GetModuleGlobalNameUncached(var, name) {\ + PY_UINT64_T __pyx_dict_version;\ + PyObject *__pyx_dict_cached_value;\ + (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); +#else +#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) +#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); +#endif + +/* PyObjectFormatSimple.proto */ +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + PyObject_Format(s, f)) +#elif PY_MAJOR_VERSION < 3 + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + likely(PyString_CheckExact(s)) ? PyUnicode_FromEncodedObject(s, NULL, "strict") :\ + PyObject_Format(s, f)) +#elif CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + likely(PyLong_CheckExact(s)) ? PyLong_Type.tp_str(s) :\ + likely(PyFloat_CheckExact(s)) ? PyFloat_Type.tp_str(s) :\ + PyObject_Format(s, f)) +#else + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + PyObject_Format(s, f)) +#endif + +/* IncludeStringH.proto */ +#include + +/* JoinPyUnicode.proto */ +static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, + Py_UCS4 max_char); + +/* PyCFunctionFastCall.proto */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); +#else +#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) +#endif + +/* PyFunctionFastCall.proto */ +#if CYTHON_FAST_PYCALL +#define __Pyx_PyFunction_FastCall(func, args, nargs)\ + __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); +#else +#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) +#endif +#define __Pyx_BUILD_ASSERT_EXPR(cond)\ + (sizeof(char [1 - 2*!(cond)]) - 1) +#ifndef Py_MEMBER_SIZE +#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) +#endif + static size_t __pyx_pyframe_localsplus_offset = 0; + #include "frameobject.h" + #define __Pxy_PyFrame_Initialize_Offsets()\ + ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ + (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) + #define __Pyx_PyFrame_GetLocalsplus(frame)\ + (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) +#endif + +/* PyObjectCallMethO.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* PyIntCompare.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, long intval, long inplace); + +/* PyObjectCall2Args.proto */ +static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); + +/* RaiseArgTupleInvalid.proto */ +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); + +/* RaiseDoubleKeywords.proto */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +/* ParseKeywords.proto */ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ + const char* function_name); + +/* ArgTypeTest.proto */ +#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ + ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ + __Pyx__ArgTypeTest(obj, type, name, exact)) +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); + +/* PyIntCompare.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_NeObjC(PyObject *op1, PyObject *op2, long intval, long inplace); + +/* RaiseTooManyValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); + +/* RaiseNeedMoreValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); + +/* IterFinish.proto */ +static CYTHON_INLINE int __Pyx_IterFinish(void); + +/* UnpackItemEndCheck.proto */ +static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); + +/* PySequenceContains.proto */ +static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) { + int result = PySequence_Contains(seq, item); + return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); +} + +/* PyUnicode_Unicode.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_Unicode(PyObject *obj); + +/* BytesEquals.proto */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); + +/* UnicodeEquals.proto */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); + +/* BuildPyUnicode.proto */ +static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, char* chars, int clength, + int prepend_sign, char padding_char); + +/* CIntToPyUnicode.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char, char format_char); + +/* PyIntBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); +#else +#define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace, zerodivision_check)\ + (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2)) +#endif + +/* pyobject_as_double.proto */ +static double __Pyx__PyObject_AsDouble(PyObject* obj); +#if CYTHON_COMPILING_IN_PYPY +#define __Pyx_PyObject_AsDouble(obj)\ +(likely(PyFloat_CheckExact(obj)) ? PyFloat_AS_DOUBLE(obj) :\ + likely(PyInt_CheckExact(obj)) ?\ + PyFloat_AsDouble(obj) : __Pyx__PyObject_AsDouble(obj)) +#else +#define __Pyx_PyObject_AsDouble(obj)\ +((likely(PyFloat_CheckExact(obj))) ?\ + PyFloat_AS_DOUBLE(obj) : __Pyx__PyObject_AsDouble(obj)) +#endif + +/* GetItemInt.proto */ +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ + __Pyx_GetItemInt_Generic(o, to_py_func(i)))) +#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, + int is_list, int wraparound, int boundscheck); + +/* GetTopmostException.proto */ +#if CYTHON_USE_EXC_INFO_STACK +static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); +#endif + +/* SaveResetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +#else +#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) +#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) +#endif + +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +#else +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +#endif + +/* GetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* ExtTypeTest.proto */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + +/* ListCompAppend.proto */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { + PyListObject* L = (PyListObject*) list; + Py_ssize_t len = Py_SIZE(list); + if (likely(L->allocated > len)) { + Py_INCREF(x); + PyList_SET_ITEM(list, len, x); + __Pyx_SET_SIZE(list, len + 1); + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x) +#endif + +/* TypeImport.proto */ +#ifndef __PYX_HAVE_RT_ImportType_proto +#define __PYX_HAVE_RT_ImportType_proto +enum __Pyx_ImportType_CheckSize { + __Pyx_ImportType_CheckSize_Error = 0, + __Pyx_ImportType_CheckSize_Warn = 1, + __Pyx_ImportType_CheckSize_Ignore = 2 +}; +static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size); +#endif + +/* Import.proto */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +/* ImportFrom.proto */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); + +/* CLineInTraceback.proto */ +#ifdef CYTHON_CLINE_IN_TRACEBACK +#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) +#else +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); +#endif + +/* CodeObjectCache.proto */ +typedef struct { + PyCodeObject* code_object; + int code_line; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; +}; +static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static PyCodeObject *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); + +/* AddTraceback.proto */ +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +/* RealImag.proto */ +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #define __Pyx_CREAL(z) ((z).real()) + #define __Pyx_CIMAG(z) ((z).imag()) + #else + #define __Pyx_CREAL(z) (__real__(z)) + #define __Pyx_CIMAG(z) (__imag__(z)) + #endif +#else + #define __Pyx_CREAL(z) ((z).real) + #define __Pyx_CIMAG(z) ((z).imag) +#endif +#if defined(__cplusplus) && CYTHON_CCOMPLEX\ + && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103) + #define __Pyx_SET_CREAL(z,x) ((z).real(x)) + #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) +#else + #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) + #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) +#endif + +/* Arithmetic.proto */ +#if CYTHON_CCOMPLEX + #define __Pyx_c_eq_float(a, b) ((a)==(b)) + #define __Pyx_c_sum_float(a, b) ((a)+(b)) + #define __Pyx_c_diff_float(a, b) ((a)-(b)) + #define __Pyx_c_prod_float(a, b) ((a)*(b)) + #define __Pyx_c_quot_float(a, b) ((a)/(b)) + #define __Pyx_c_neg_float(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero_float(z) ((z)==(float)0) + #define __Pyx_c_conj_float(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_abs_float(z) (::std::abs(z)) + #define __Pyx_c_pow_float(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero_float(z) ((z)==0) + #define __Pyx_c_conj_float(z) (conjf(z)) + #if 1 + #define __Pyx_c_abs_float(z) (cabsf(z)) + #define __Pyx_c_pow_float(a, b) (cpowf(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex); + static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex); + #if 1 + static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex, __pyx_t_float_complex); + #endif +#endif + +/* Arithmetic.proto */ +#if CYTHON_CCOMPLEX + #define __Pyx_c_eq_double(a, b) ((a)==(b)) + #define __Pyx_c_sum_double(a, b) ((a)+(b)) + #define __Pyx_c_diff_double(a, b) ((a)-(b)) + #define __Pyx_c_prod_double(a, b) ((a)*(b)) + #define __Pyx_c_quot_double(a, b) ((a)/(b)) + #define __Pyx_c_neg_double(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero_double(z) ((z)==(double)0) + #define __Pyx_c_conj_double(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_abs_double(z) (::std::abs(z)) + #define __Pyx_c_pow_double(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero_double(z) ((z)==0) + #define __Pyx_c_conj_double(z) (conj(z)) + #if 1 + #define __Pyx_c_abs_double(z) (cabs(z)) + #define __Pyx_c_pow_double(a, b) (cpow(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex); + static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex); + #if 1 + static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex, __pyx_t_double_complex); + #endif +#endif + +/* CIntFromPy.proto */ +static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +/* FastTypeChecks.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); +#else +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) +#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) +#endif +#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) + +/* CheckBinaryVersion.proto */ +static int __Pyx_check_binary_version(void); + +/* FunctionExport.proto */ +static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig); + +/* FunctionImport.proto */ +static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig); + +/* InitStrings.proto */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); + + +/* Module declarations from 'libcpp.vector' */ + +/* Module declarations from 'libc.string' */ + +/* Module declarations from 'libcpp.string' */ + +/* Module declarations from 'libcpp' */ + +/* Module declarations from 'cpython.buffer' */ + +/* Module declarations from 'libc.stdio' */ + +/* Module declarations from '__builtin__' */ + +/* Module declarations from 'cpython.type' */ +static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; + +/* Module declarations from 'cpython' */ + +/* Module declarations from 'cpython.object' */ + +/* Module declarations from 'cpython.ref' */ + +/* Module declarations from 'cpython.mem' */ + +/* Module declarations from 'numpy' */ + +/* Module declarations from 'numpy' */ +static PyTypeObject *__pyx_ptype_5numpy_dtype = 0; +static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; +static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; +static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; +static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; + +/* Module declarations from 'l0learn.cyarma' */ +static arma::dmat (*__pyx_f_7l0learn_6cyarma_numpy_to_dmat_d)(PyArrayObject *); /*proto*/ +static arma::dvec (*__pyx_f_7l0learn_6cyarma_numpy_to_dvec_d)(PyArrayObject *); /*proto*/ +static arma::sp_dmat (*__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d)(PyObject *); /*proto*/ +static PyObject *(*__pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list)(arma::field ); /*proto*/ +static PyObject *(*__pyx_f_7l0learn_6cyarma_dvec_field_to_list)(arma::field ); /*proto*/ + +/* Module declarations from 'l0learn.interface' */ +static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_dense(arma::dmat const &, arma::dvec const &, std::string const , std::string const , std::string const , size_t const , size_t const , size_t const , double const , double const , bool const , size_t const , double const , double const , bool const , size_t const , size_t const , double const , size_t const , bool const , std::vector > const &, size_t const , bool const , bool const , arma::dvec const &, arma::dvec const &); /*proto*/ +static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_sparse(arma::sp_dmat const &, arma::dvec const &, std::string const , std::string const , std::string const , size_t const , size_t const , size_t const , double const , double const , bool const , size_t const , double const , double const , bool const , size_t const , size_t const , double const , size_t const , bool const , std::vector > const &, size_t const , bool const , bool const , arma::dvec const &, arma::dvec const &); /*proto*/ +static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_dense(arma::dmat const &, arma::dvec const &, std::string const , std::string const , std::string const , size_t const , size_t const , size_t const , double const , double const , bool const , size_t const , double const , double const , bool const , size_t const , size_t const , double const , size_t const , bool const , std::vector > const &, unsigned int const , double const , size_t const , bool const , bool const , arma::dvec const &, arma::dvec const &); /*proto*/ +static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_sparse(arma::sp_dmat const &, arma::dvec const &, std::string const , std::string const , std::string const , size_t const , size_t const , size_t const , double const , double const , bool const , size_t const , double const , double const , bool const , size_t const , size_t const , double const , size_t const , bool const , std::vector > const &, unsigned int const , double const , size_t const , bool const , bool const , arma::dvec const &, arma::dvec const &); /*proto*/ +static std::vector __pyx_convert_vector_from_py_double(PyObject *); /*proto*/ +static std::vector > __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(PyObject *); /*proto*/ +static std::string __pyx_convert_string_from_py_std__in_string(PyObject *); /*proto*/ +static PyObject *__pyx_convert_vector_to_py_size_t(const std::vector &); /*proto*/ +static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(const std::vector > &); /*proto*/ +static PyObject *__pyx_convert_vector_to_py_double(const std::vector &); /*proto*/ +static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(const std::vector > &); /*proto*/ +static PyObject *__pyx_convert_vector_to_py_bool(const std::vector &); /*proto*/ +static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(const std::vector > &); /*proto*/ +#define __Pyx_MODULE_NAME "l0learn.interface" +extern int __pyx_module_is_main_l0learn__interface; +int __pyx_module_is_main_l0learn__interface = 0; + +/* Implementation of 'l0learn.interface' */ +static PyObject *__pyx_builtin_ValueError; +static PyObject *__pyx_builtin_NotImplementedError; +static PyObject *__pyx_builtin_enumerate; +static PyObject *__pyx_builtin_any; +static PyObject *__pyx_builtin_all; +static PyObject *__pyx_builtin_TypeError; +static PyObject *__pyx_builtin_ImportError; +static PyObject *__pyx_builtin_range; +static const char __pyx_k_X[] = "X"; +static const char __pyx_k_i[] = "i"; +static const char __pyx_k_n[] = "n"; +static const char __pyx_k_p[] = "p"; +static const char __pyx_k_y[] = "y"; +static const char __pyx_k_CD[] = "CD"; +static const char __pyx_k_L0[] = "L0"; +static const char __pyx_k__5[] = "."; +static const char __pyx_k_np[] = "np"; +static const char __pyx_k_or[] = " or "; +static const char __pyx_k_all[] = "all"; +static const char __pyx_k_any[] = "any"; +static const char __pyx_k_arr[] = "arr"; +static const char __pyx_k_fit[] = "fit"; +static const char __pyx_k_inf[] = "inf"; +static const char __pyx_k_Beta[] = "Beta"; +static const char __pyx_k_L0L1[] = "L0L1"; +static const char __pyx_k_L0L2[] = "L0L2"; +static const char __pyx_k_List[] = "List"; +static const char __pyx_k_None[] = "None"; +static const char __pyx_k_atol[] = "atol"; +static const char __pyx_k_data[] = "data"; +static const char __pyx_k_diff[] = "diff"; +static const char __pyx_k_loss[] = "loss"; +static const char __pyx_k_lows[] = "lows"; +static const char __pyx_k_main[] = "__main__"; +static const char __pyx_k_name[] = "__name__"; +static const char __pyx_k_ndim[] = "ndim"; +static const char __pyx_k_ones[] = "ones"; +static const char __pyx_k_rtol[] = "rtol"; +static const char __pyx_k_seed[] = "seed"; +static const char __pyx_k_test[] = "__test__"; +static const char __pyx_k_CDPSI[] = "CDPSI"; +static const char __pyx_k_CVSDs[] = "CVSDs"; +static const char __pyx_k_Union[] = "Union"; +static const char __pyx_k_array[] = "array"; +static const char __pyx_k_cvfit[] = "cvfit"; +static const char __pyx_k_dtype[] = "dtype"; +static const char __pyx_k_flags[] = "flags"; +static const char __pyx_k_highs[] = "highs"; +static const char __pyx_k_numpy[] = "numpy"; +static const char __pyx_k_range[] = "range"; +static const char __pyx_k_shape[] = "shape"; +static const char __pyx_k_c_loss[] = "c_loss"; +static const char __pyx_k_import[] = "__import__"; +static const char __pyx_k_indptr[] = "indptr"; +static const char __pyx_k_number[] = "number"; +static const char __pyx_k_typing[] = "typing"; +static const char __pyx_k_unique[] = "unique"; +static const char __pyx_k_CVMeans[] = "CVMeans"; +static const char __pyx_k_Lambda0[] = "Lambda0"; +static const char __pyx_k_but_got[] = ", but got "; +static const char __pyx_k_current[] = "current"; +static const char __pyx_k_indices[] = "indices"; +static const char __pyx_k_penalty[] = "penalty"; +static const char __pyx_k_product[] = "product"; +static const char __pyx_k_results[] = "results"; +static const char __pyx_k_Lambda12[] = "Lambda12"; +static const char __pyx_k_Logistic[] = "Logistic"; +static const char __pyx_k_NnzCount[] = "NnzCount"; +static const char __pyx_k_Optional[] = "Optional"; +static const char __pyx_k_argwhere[] = "argwhere"; +static const char __pyx_k_max_iter[] = "max_iter"; +static const char __pyx_k_Converged[] = "Converged"; +static const char __pyx_k_Intercept[] = "Intercept"; +static const char __pyx_k_TypeError[] = "TypeError"; +static const char __pyx_k_algorithm[] = "algorithm"; +static const char __pyx_k_c_penalty[] = "c_penalty"; +static const char __pyx_k_enumerate[] = "enumerate"; +static const char __pyx_k_gamma_max[] = "gamma_max"; +static const char __pyx_k_gamma_min[] = "gamma_min"; +static const char __pyx_k_intercept[] = "intercept"; +static const char __pyx_k_isrealobj[] = "isrealobj"; +static const char __pyx_k_max_swaps[] = "max_swaps"; +static const char __pyx_k_num_folds[] = "num_folds"; +static const char __pyx_k_num_gamma[] = "num_gamma"; +static const char __pyx_k_ValueError[] = "ValueError"; +static const char __pyx_k_active_set[] = "active_set"; +static const char __pyx_k_bad_bounds[] = "bad_bounds"; +static const char __pyx_k_csc_matrix[] = "csc_matrix"; +static const char __pyx_k_issubdtype[] = "issubdtype"; +static const char __pyx_k_num_lambda[] = "num_lambda"; +static const char __pyx_k_ImportError[] = "ImportError"; +static const char __pyx_k_auto_lambda[] = "auto_lambda"; +static const char __pyx_k_lambda_grid[] = "lambda_grid"; +static const char __pyx_k_screen_size[] = "screen_size"; +static const char __pyx_k_with_bounds[] = "with_bounds"; +static const char __pyx_k_F_CONTIGUOUS[] = "F_CONTIGUOUS"; +static const char __pyx_k_SquaredError[] = "SquaredError"; +static const char __pyx_k_SquaredHinge[] = "SquaredHinge"; +static const char __pyx_k_c_algorithim[] = "c_algorithim"; +static const char __pyx_k_partial_sort[] = "partial_sort"; +static const char __pyx_k_scipy_sparse[] = "scipy.sparse"; +static const char __pyx_k_Not_supported[] = ". Not supported"; +static const char __pyx_k_c_lambda_grid[] = "c_lambda_grid"; +static const char __pyx_k_SUPPORTED_LOSS[] = "SUPPORTED_LOSS"; +static const char __pyx_k_active_set_num[] = "active_set_num"; +static const char __pyx_k_bad_lambda_grid[] = "bad_lambda_grid"; +static const char __pyx_k_exclude_first_k[] = "exclude_first_k"; +static const char __pyx_k_sub_lambda_grid[] = "sub_lambda_grid"; +static const char __pyx_k_max_support_size[] = "max_support_size"; +static const char __pyx_k_np_to_arma_check[] = "np_to_arma_check"; +static const char __pyx_k_SUPPORTED_PENALTY[] = "SUPPORTED_PENALTY"; +static const char __pyx_k_l0learn_interface[] = "l0learn.interface"; +static const char __pyx_k_scale_down_factor[] = "scale_down_factor"; +static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; +static const char __pyx_k_CLASSIFICATION_LOSS[] = "CLASSIFICATION_LOSS"; +static const char __pyx_k_NotImplementedError[] = "NotImplementedError"; +static const char __pyx_k_SUPPORTED_ALGORITHM[] = "SUPPORTED_ALGORITHM"; +static const char __pyx_k_l0learn_interface_pyx[] = "l0learn/interface.pyx"; +static const char __pyx_k_expected_arr_to_be_of_type[] = "expected arr to be of type "; +static const char __pyx_k_where_that_is_not_the_case[] = " where that is not the case "; +static const char __pyx_k_containing_a_negative_value[] = "] containing a negative value"; +static const char __pyx_k_containing_an_increasing_value[] = "] containing an increasing value."; +static const char __pyx_k_of_non_negative_floats_but_got[] = " of non-negative floats, but got "; +static const char __pyx_k_Expected_each_element_of_lambda[] = "Expected each element of lambda_grid to be a list of decreasing value, but got lambda_grid["; +static const char __pyx_k_L0_Penalty_requires_lambda_grid[] = "L0 Penalty requires 'lambda_grid' to be a list of length 1, but got "; +static const char __pyx_k_expected_algorithm_parameter_to[] = "expected algorithm parameter to be on of "; +static const char __pyx_k_expected_arr_to_be_F_CONTIGUOUS[] = "expected arr to be F_CONTIGUOUS."; +static const char __pyx_k_expected_gamma_max_parameter_to[] = "expected gamma_max parameter to be a positive float, but got "; +static const char __pyx_k_expected_intercept_parameter_to[] = "expected intercept parameter to be a bool, but got "; +static const char __pyx_k_expected_max_swaps_parameter_to[] = "expected max_swaps parameter to be a positive integer, but got "; +static const char __pyx_k_expected_num_folds_parameter_to[] = "expected num_folds parameter to be a integer greater than 2, but got "; +static const char __pyx_k_expected_partial_sort_parameter[] = "expected partial_sort parameter to be a bool, but got "; +static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import"; +static const char __pyx_k_of_non_positives_floats_but_got[] = " of non-positives floats, but got "; +static const char __pyx_k_Expected_all_values_of_lambda_gr[] = "Expected all values of lambda_grid to be positive, but got lambda_grid["; +static const char __pyx_k_expected_X_to_be_a_2D_non_degene[] = "expected X to be a 2D non-degenerate real numpy or csc_matrix, but got "; +static const char __pyx_k_expected_active_set_num_paramete[] = "expected active_set_num parameter to be a positive integer, but got "; +static const char __pyx_k_expected_active_set_parameter_to[] = "expected active_set parameter to be a bool, but got "; +static const char __pyx_k_expected_arr_data_to_be_F_CONTIG[] = "expected arr.data to be F_CONTIGUOUS."; +static const char __pyx_k_expected_arr_indices_to_be_F_CON[] = "expected arr.indices to be F_CONTIGUOUS."; +static const char __pyx_k_expected_arr_indptr_to_be_F_CONT[] = "expected arr.indptr to be F_CONTIGUOUS."; +static const char __pyx_k_expected_arr_ndim_to_be_1_or_2_b[] = "expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar"; +static const char __pyx_k_expected_atol_parameter_to_exist[] = "expected atol parameter to exist in [0, INF), but got "; +static const char __pyx_k_expected_exclude_first_k_paramet[] = "expected exclude_first_k parameter to be a positive integer less than "; +static const char __pyx_k_expected_highs_to_be_a_non_negat[] = "expected highs to be a non-negative float, but got "; +static const char __pyx_k_expected_lambda_grid_to_be_a_lis[] = "expected lambda_grid to be a list of list of doubles, but got "; +static const char __pyx_k_expected_lambda_grid_to_of_lengt[] = "expected lambda_grid to of length 1 when penalty = 'L0', but got "; +static const char __pyx_k_expected_loss_parameter_to_be_on[] = "expected loss parameter to be on of "; +static const char __pyx_k_expected_lows_to_be_a_non_positi[] = "expected lows to be a non-positive float, but got "; +static const char __pyx_k_expected_max_iter_parameter_to_b[] = "expected max_iter parameter to be a positive integer, but got "; +static const char __pyx_k_expected_max_support_size_parame[] = "expected max_support_size parameter to be a positive integer less than "; +static const char __pyx_k_expected_non_complex_dtype_but_g[] = "expected non-complex dtype, but got "; +static const char __pyx_k_expected_non_degenerate_dimensio[] = "expected non-degenerate dimensions of arr, but got "; +static const char __pyx_k_expected_num_gamma_to_1_when_pen[] = "expected num_gamma to 1 when penalty = 'L0', but got "; +static const char __pyx_k_expected_num_gamma_to_a_positive[] = "expected num_gamma to a positive integer when lambda_grid is None, but got "; +static const char __pyx_k_expected_num_gamma_to_be_None_if[] = "expected num_gamma to be None if lambda_grid is specified by the user, but got "; +static const char __pyx_k_expected_num_lambda_to_a_positiv[] = "expected num_lambda to a positive integer when lambda_grid is None, but got "; +static const char __pyx_k_expected_num_lambda_to_be_None_i[] = "expected num_lambda to be None if lambda_grid is specified by the user, but got "; +static const char __pyx_k_expected_numerical_dtype_but_got[] = "expected numerical dtype, but got "; +static const char __pyx_k_expected_penalty_parameter_to_be[] = "expected penalty parameter to be on of "; +static const char __pyx_k_expected_rtol_parameter_to_exist[] = "expected rtol parameter to exist in [0, 1), but got "; +static const char __pyx_k_expected_scale_down_factor_param[] = "expected scale_down_factor parameter to exist in (0, 1), but got "; +static const char __pyx_k_expected_screen_size_parameter_t[] = "expected screen_size parameter to be a positive integer, but got "; +static const char __pyx_k_expected_seed_parameter_to_be_an[] = "expected seed parameter to be an integer, but got "; +static const char __pyx_k_expected_to_be_high_to_be_elemen[] = "expected to be high to be elementwise greater than lows, but got indices "; +static const char __pyx_k_expected_y_to_be_a_1D_real_numpy[] = "expected y to be a 1D real numpy, but got "; +static const char __pyx_k_expected_y_vector_to_only_have_t[] = "expected y vector to only have two unique values (-1 and 1) (Binary Classification), but got "; +static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import"; +static const char __pyx_k_expected_gamma_max_parameter_to_2[] = "expected gamma_max parameter to be a positive float less than gamma_max, but got "; +static const char __pyx_k_expected_arr_ndim_to_be_1_or_2_b_2[] = "expected 'arr.ndim' to be 1 or 2, but got "; +static const char __pyx_k_expected_highs_to_be_a_non_negat_2[] = "expected highs to be a non-negative float, or a 1D numpy array of length "; +static const char __pyx_k_expected_lows_to_be_a_non_positi_2[] = "expected lows to be a non-positive float, or a 1D numpy array of length "; +static PyObject *__pyx_n_u_Beta; +static PyObject *__pyx_n_u_CD; +static PyObject *__pyx_n_u_CDPSI; +static PyObject *__pyx_n_s_CLASSIFICATION_LOSS; +static PyObject *__pyx_n_u_CVMeans; +static PyObject *__pyx_n_u_CVSDs; +static PyObject *__pyx_n_u_Converged; +static PyObject *__pyx_kp_u_Expected_all_values_of_lambda_gr; +static PyObject *__pyx_kp_u_Expected_each_element_of_lambda; +static PyObject *__pyx_n_u_F_CONTIGUOUS; +static PyObject *__pyx_n_s_ImportError; +static PyObject *__pyx_n_u_Intercept; +static PyObject *__pyx_n_u_L0; +static PyObject *__pyx_n_u_L0L1; +static PyObject *__pyx_n_u_L0L2; +static PyObject *__pyx_kp_u_L0_Penalty_requires_lambda_grid; +static PyObject *__pyx_n_u_Lambda0; +static PyObject *__pyx_n_u_Lambda12; +static PyObject *__pyx_n_s_List; +static PyObject *__pyx_n_u_Logistic; +static PyObject *__pyx_n_u_NnzCount; +static PyObject *__pyx_kp_u_None; +static PyObject *__pyx_n_s_NotImplementedError; +static PyObject *__pyx_kp_u_Not_supported; +static PyObject *__pyx_n_s_Optional; +static PyObject *__pyx_n_s_SUPPORTED_ALGORITHM; +static PyObject *__pyx_n_s_SUPPORTED_LOSS; +static PyObject *__pyx_n_s_SUPPORTED_PENALTY; +static PyObject *__pyx_n_u_SquaredError; +static PyObject *__pyx_n_u_SquaredHinge; +static PyObject *__pyx_n_s_TypeError; +static PyObject *__pyx_n_s_Union; +static PyObject *__pyx_n_s_ValueError; +static PyObject *__pyx_n_s_X; +static PyObject *__pyx_kp_u__5; +static PyObject *__pyx_n_s_active_set; +static PyObject *__pyx_n_s_active_set_num; +static PyObject *__pyx_n_s_algorithm; +static PyObject *__pyx_n_s_all; +static PyObject *__pyx_n_s_any; +static PyObject *__pyx_n_s_argwhere; +static PyObject *__pyx_n_s_arr; +static PyObject *__pyx_n_s_array; +static PyObject *__pyx_n_s_atol; +static PyObject *__pyx_n_s_auto_lambda; +static PyObject *__pyx_n_s_bad_bounds; +static PyObject *__pyx_n_s_bad_lambda_grid; +static PyObject *__pyx_kp_u_but_got; +static PyObject *__pyx_n_s_c_algorithim; +static PyObject *__pyx_n_s_c_lambda_grid; +static PyObject *__pyx_n_s_c_loss; +static PyObject *__pyx_n_s_c_penalty; +static PyObject *__pyx_n_s_cline_in_traceback; +static PyObject *__pyx_kp_u_containing_a_negative_value; +static PyObject *__pyx_kp_u_containing_an_increasing_value; +static PyObject *__pyx_n_s_csc_matrix; +static PyObject *__pyx_n_s_current; +static PyObject *__pyx_n_s_cvfit; +static PyObject *__pyx_n_s_data; +static PyObject *__pyx_n_s_diff; +static PyObject *__pyx_n_s_dtype; +static PyObject *__pyx_n_s_enumerate; +static PyObject *__pyx_n_s_exclude_first_k; +static PyObject *__pyx_kp_u_expected_X_to_be_a_2D_non_degene; +static PyObject *__pyx_kp_u_expected_active_set_num_paramete; +static PyObject *__pyx_kp_u_expected_active_set_parameter_to; +static PyObject *__pyx_kp_u_expected_algorithm_parameter_to; +static PyObject *__pyx_kp_u_expected_arr_data_to_be_F_CONTIG; +static PyObject *__pyx_kp_u_expected_arr_indices_to_be_F_CON; +static PyObject *__pyx_kp_u_expected_arr_indptr_to_be_F_CONT; +static PyObject *__pyx_kp_u_expected_arr_ndim_to_be_1_or_2_b; +static PyObject *__pyx_kp_u_expected_arr_ndim_to_be_1_or_2_b_2; +static PyObject *__pyx_kp_u_expected_arr_to_be_F_CONTIGUOUS; +static PyObject *__pyx_kp_u_expected_arr_to_be_of_type; +static PyObject *__pyx_kp_u_expected_atol_parameter_to_exist; +static PyObject *__pyx_kp_u_expected_exclude_first_k_paramet; +static PyObject *__pyx_kp_u_expected_gamma_max_parameter_to; +static PyObject *__pyx_kp_u_expected_gamma_max_parameter_to_2; +static PyObject *__pyx_kp_u_expected_highs_to_be_a_non_negat; +static PyObject *__pyx_kp_u_expected_highs_to_be_a_non_negat_2; +static PyObject *__pyx_kp_u_expected_intercept_parameter_to; +static PyObject *__pyx_kp_u_expected_lambda_grid_to_be_a_lis; +static PyObject *__pyx_kp_u_expected_lambda_grid_to_of_lengt; +static PyObject *__pyx_kp_u_expected_loss_parameter_to_be_on; +static PyObject *__pyx_kp_u_expected_lows_to_be_a_non_positi; +static PyObject *__pyx_kp_u_expected_lows_to_be_a_non_positi_2; +static PyObject *__pyx_kp_u_expected_max_iter_parameter_to_b; +static PyObject *__pyx_kp_u_expected_max_support_size_parame; +static PyObject *__pyx_kp_u_expected_max_swaps_parameter_to; +static PyObject *__pyx_kp_u_expected_non_complex_dtype_but_g; +static PyObject *__pyx_kp_u_expected_non_degenerate_dimensio; +static PyObject *__pyx_kp_u_expected_num_folds_parameter_to; +static PyObject *__pyx_kp_u_expected_num_gamma_to_1_when_pen; +static PyObject *__pyx_kp_u_expected_num_gamma_to_a_positive; +static PyObject *__pyx_kp_u_expected_num_gamma_to_be_None_if; +static PyObject *__pyx_kp_u_expected_num_lambda_to_a_positiv; +static PyObject *__pyx_kp_u_expected_num_lambda_to_be_None_i; +static PyObject *__pyx_kp_u_expected_numerical_dtype_but_got; +static PyObject *__pyx_kp_u_expected_partial_sort_parameter; +static PyObject *__pyx_kp_u_expected_penalty_parameter_to_be; +static PyObject *__pyx_kp_u_expected_rtol_parameter_to_exist; +static PyObject *__pyx_kp_u_expected_scale_down_factor_param; +static PyObject *__pyx_kp_u_expected_screen_size_parameter_t; +static PyObject *__pyx_kp_u_expected_seed_parameter_to_be_an; +static PyObject *__pyx_kp_u_expected_to_be_high_to_be_elemen; +static PyObject *__pyx_kp_u_expected_y_to_be_a_1D_real_numpy; +static PyObject *__pyx_kp_u_expected_y_vector_to_only_have_t; +static PyObject *__pyx_n_s_fit; +static PyObject *__pyx_n_s_flags; +static PyObject *__pyx_n_s_gamma_max; +static PyObject *__pyx_n_s_gamma_min; +static PyObject *__pyx_n_s_highs; +static PyObject *__pyx_n_s_i; +static PyObject *__pyx_n_s_import; +static PyObject *__pyx_n_s_indices; +static PyObject *__pyx_n_s_indptr; +static PyObject *__pyx_n_u_inf; +static PyObject *__pyx_n_s_intercept; +static PyObject *__pyx_n_s_isrealobj; +static PyObject *__pyx_n_s_issubdtype; +static PyObject *__pyx_n_s_l0learn_interface; +static PyObject *__pyx_kp_s_l0learn_interface_pyx; +static PyObject *__pyx_n_s_lambda_grid; +static PyObject *__pyx_n_s_loss; +static PyObject *__pyx_n_s_lows; +static PyObject *__pyx_n_s_main; +static PyObject *__pyx_n_s_max_iter; +static PyObject *__pyx_n_s_max_support_size; +static PyObject *__pyx_n_s_max_swaps; +static PyObject *__pyx_n_s_n; +static PyObject *__pyx_n_s_name; +static PyObject *__pyx_n_s_ndim; +static PyObject *__pyx_n_s_np; +static PyObject *__pyx_n_s_np_to_arma_check; +static PyObject *__pyx_n_s_num_folds; +static PyObject *__pyx_n_s_num_gamma; +static PyObject *__pyx_n_s_num_lambda; +static PyObject *__pyx_n_s_number; +static PyObject *__pyx_n_s_numpy; +static PyObject *__pyx_kp_u_numpy_core_multiarray_failed_to; +static PyObject *__pyx_kp_u_numpy_core_umath_failed_to_impor; +static PyObject *__pyx_kp_u_of_non_negative_floats_but_got; +static PyObject *__pyx_kp_u_of_non_positives_floats_but_got; +static PyObject *__pyx_n_s_ones; +static PyObject *__pyx_kp_u_or; +static PyObject *__pyx_n_s_p; +static PyObject *__pyx_n_s_partial_sort; +static PyObject *__pyx_n_s_penalty; +static PyObject *__pyx_n_s_product; +static PyObject *__pyx_n_s_range; +static PyObject *__pyx_n_s_results; +static PyObject *__pyx_n_s_rtol; +static PyObject *__pyx_n_s_scale_down_factor; +static PyObject *__pyx_n_s_scipy_sparse; +static PyObject *__pyx_n_s_screen_size; +static PyObject *__pyx_n_s_seed; +static PyObject *__pyx_n_s_shape; +static PyObject *__pyx_n_s_sub_lambda_grid; +static PyObject *__pyx_n_s_test; +static PyObject *__pyx_n_s_typing; +static PyObject *__pyx_n_s_unique; +static PyObject *__pyx_kp_u_where_that_is_not_the_case; +static PyObject *__pyx_n_s_with_bounds; +static PyObject *__pyx_n_s_y; +static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_arr); /* proto */ +static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyArrayObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs); /* proto */ +static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyArrayObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_num_folds, PyObject *__pyx_v_seed, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs); /* proto */ +static PyObject *__pyx_float_0_; +static PyObject *__pyx_int_0; +static PyObject *__pyx_int_1; +static PyObject *__pyx_int_2; +static PyObject *__pyx_int_3; +static PyObject *__pyx_int_10; +static PyObject *__pyx_int_100; +static PyObject *__pyx_int_200; +static PyObject *__pyx_int_1000; +static PyObject *__pyx_int_neg_1; +static PyObject *__pyx_k__7; +static PyObject *__pyx_k__8; +static PyObject *__pyx_k__9; +static PyObject *__pyx_k__10; +static PyObject *__pyx_tuple_; +static PyObject *__pyx_tuple__2; +static PyObject *__pyx_tuple__3; +static PyObject *__pyx_tuple__4; +static PyObject *__pyx_tuple__6; +static PyObject *__pyx_tuple__11; +static PyObject *__pyx_tuple__12; +static PyObject *__pyx_tuple__13; +static PyObject *__pyx_tuple__15; +static PyObject *__pyx_tuple__16; +static PyObject *__pyx_tuple__17; +static PyObject *__pyx_tuple__18; +static PyObject *__pyx_tuple__20; +static PyObject *__pyx_codeobj__14; +static PyObject *__pyx_codeobj__19; +static PyObject *__pyx_codeobj__21; +/* Late includes */ + +/* "l0learn/interface.pyx":26 + * + * + * def np_to_arma_check(arr): # <<<<<<<<<<<<<< + * # TODO: Add checks for Behaved and OwnsData + * if isinstance(arr, np.ndarray): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7l0learn_9interface_1np_to_arma_check(PyObject *__pyx_self, PyObject *__pyx_v_arr); /*proto*/ +static char __pyx_doc_7l0learn_9interface_np_to_arma_check[] = "np_to_arma_check(arr)"; +static PyMethodDef __pyx_mdef_7l0learn_9interface_1np_to_arma_check = {"np_to_arma_check", (PyCFunction)__pyx_pw_7l0learn_9interface_1np_to_arma_check, METH_O, __pyx_doc_7l0learn_9interface_np_to_arma_check}; +static PyObject *__pyx_pw_7l0learn_9interface_1np_to_arma_check(PyObject *__pyx_self, PyObject *__pyx_v_arr) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("np_to_arma_check (wrapper)", 0); + __pyx_r = __pyx_pf_7l0learn_9interface_np_to_arma_check(__pyx_self, ((PyObject *)__pyx_v_arr)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_arr) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + Py_ssize_t __pyx_t_5; + Py_UCS4 __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + int __pyx_t_10; + PyObject *__pyx_t_11 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("np_to_arma_check", 0); + + /* "l0learn/interface.pyx":28 + * def np_to_arma_check(arr): + * # TODO: Add checks for Behaved and OwnsData + * if isinstance(arr, np.ndarray): # <<<<<<<<<<<<<< + * if not arr.flags['F_CONTIGUOUS']: + * raise ValueError("expected arr to be F_CONTIGUOUS.") + */ + __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_arr, __pyx_ptype_5numpy_ndarray); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "l0learn/interface.pyx":29 + * # TODO: Add checks for Behaved and OwnsData + * if isinstance(arr, np.ndarray): + * if not arr.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< + * raise ValueError("expected arr to be F_CONTIGUOUS.") + * elif isinstance(arr, csc_matrix): + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_n_u_F_CONTIGUOUS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 29, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_1 = ((!__pyx_t_2) != 0); + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":30 + * if isinstance(arr, np.ndarray): + * if not arr.flags['F_CONTIGUOUS']: + * raise ValueError("expected arr to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< + * elif isinstance(arr, csc_matrix): + * if not arr.data.flags['F_CONTIGUOUS']: + */ + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 30, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(0, 30, __pyx_L1_error) + + /* "l0learn/interface.pyx":29 + * # TODO: Add checks for Behaved and OwnsData + * if isinstance(arr, np.ndarray): + * if not arr.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< + * raise ValueError("expected arr to be F_CONTIGUOUS.") + * elif isinstance(arr, csc_matrix): + */ + } + + /* "l0learn/interface.pyx":28 + * def np_to_arma_check(arr): + * # TODO: Add checks for Behaved and OwnsData + * if isinstance(arr, np.ndarray): # <<<<<<<<<<<<<< + * if not arr.flags['F_CONTIGUOUS']: + * raise ValueError("expected arr to be F_CONTIGUOUS.") + */ + goto __pyx_L3; + } + + /* "l0learn/interface.pyx":31 + * if not arr.flags['F_CONTIGUOUS']: + * raise ValueError("expected arr to be F_CONTIGUOUS.") + * elif isinstance(arr, csc_matrix): # <<<<<<<<<<<<<< + * if not arr.data.flags['F_CONTIGUOUS']: + * raise ValueError("expected arr.data to be F_CONTIGUOUS.") + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 31, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyObject_IsInstance(__pyx_v_arr, __pyx_t_4); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 31, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_2 = (__pyx_t_1 != 0); + if (likely(__pyx_t_2)) { + + /* "l0learn/interface.pyx":32 + * raise ValueError("expected arr to be F_CONTIGUOUS.") + * elif isinstance(arr, csc_matrix): + * if not arr.data.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< + * raise ValueError("expected arr.data to be F_CONTIGUOUS.") + * if not arr.indices.flags['F_CONTIGUOUS']: + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_data); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_n_u_F_CONTIGUOUS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_1 = ((!__pyx_t_2) != 0); + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":33 + * elif isinstance(arr, csc_matrix): + * if not arr.data.flags['F_CONTIGUOUS']: + * raise ValueError("expected arr.data to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< + * if not arr.indices.flags['F_CONTIGUOUS']: + * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") + */ + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(0, 33, __pyx_L1_error) + + /* "l0learn/interface.pyx":32 + * raise ValueError("expected arr to be F_CONTIGUOUS.") + * elif isinstance(arr, csc_matrix): + * if not arr.data.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< + * raise ValueError("expected arr.data to be F_CONTIGUOUS.") + * if not arr.indices.flags['F_CONTIGUOUS']: + */ + } + + /* "l0learn/interface.pyx":34 + * if not arr.data.flags['F_CONTIGUOUS']: + * raise ValueError("expected arr.data to be F_CONTIGUOUS.") + * if not arr.indices.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< + * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") + * if not arr.indptr.flags['F_CONTIGUOUS']: + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_indices); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_n_u_F_CONTIGUOUS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 34, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_2 = ((!__pyx_t_1) != 0); + if (unlikely(__pyx_t_2)) { + + /* "l0learn/interface.pyx":35 + * raise ValueError("expected arr.data to be F_CONTIGUOUS.") + * if not arr.indices.flags['F_CONTIGUOUS']: + * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< + * if not arr.indptr.flags['F_CONTIGUOUS']: + * raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") + */ + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 35, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(0, 35, __pyx_L1_error) + + /* "l0learn/interface.pyx":34 + * if not arr.data.flags['F_CONTIGUOUS']: + * raise ValueError("expected arr.data to be F_CONTIGUOUS.") + * if not arr.indices.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< + * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") + * if not arr.indptr.flags['F_CONTIGUOUS']: + */ + } + + /* "l0learn/interface.pyx":36 + * if not arr.indices.flags['F_CONTIGUOUS']: + * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") + * if not arr.indptr.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< + * raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") + * else: + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_indptr); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_n_u_F_CONTIGUOUS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 36, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_1 = ((!__pyx_t_2) != 0); + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":37 + * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") + * if not arr.indptr.flags['F_CONTIGUOUS']: + * raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< + * else: + * raise NotImplementedError(f"expected arr to be of type {np.ndarray} or {csc_matrix}, but got {type(arr)}.") + */ + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(0, 37, __pyx_L1_error) + + /* "l0learn/interface.pyx":36 + * if not arr.indices.flags['F_CONTIGUOUS']: + * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") + * if not arr.indptr.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< + * raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") + * else: + */ + } + + /* "l0learn/interface.pyx":31 + * if not arr.flags['F_CONTIGUOUS']: + * raise ValueError("expected arr to be F_CONTIGUOUS.") + * elif isinstance(arr, csc_matrix): # <<<<<<<<<<<<<< + * if not arr.data.flags['F_CONTIGUOUS']: + * raise ValueError("expected arr.data to be F_CONTIGUOUS.") + */ + goto __pyx_L3; + } + + /* "l0learn/interface.pyx":39 + * raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") + * else: + * raise NotImplementedError(f"expected arr to be of type {np.ndarray} or {csc_matrix}, but got {type(arr)}.") # <<<<<<<<<<<<<< + * + * if arr.ndim == 0: + */ + /*else*/ { + __pyx_t_4 = PyTuple_New(7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = 0; + __pyx_t_6 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_arr_to_be_of_type); + __pyx_t_5 += 27; + __Pyx_GIVEREF(__pyx_kp_u_expected_arr_to_be_of_type); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_kp_u_expected_arr_to_be_of_type); + __pyx_t_3 = __Pyx_PyObject_FormatSimple(((PyObject *)__pyx_ptype_5numpy_ndarray), __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_6) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_6; + __pyx_t_5 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3); + __pyx_t_3 = 0; + __Pyx_INCREF(__pyx_kp_u_or); + __pyx_t_5 += 4; + __Pyx_GIVEREF(__pyx_kp_u_or); + PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_kp_u_or); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_6) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_6; + __pyx_t_5 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_t_7); + __pyx_t_7 = 0; + __Pyx_INCREF(__pyx_kp_u_but_got); + __pyx_t_5 += 10; + __Pyx_GIVEREF(__pyx_kp_u_but_got); + PyTuple_SET_ITEM(__pyx_t_4, 4, __pyx_kp_u_but_got); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(((PyObject *)Py_TYPE(__pyx_v_arr)), __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_6) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_6; + __pyx_t_5 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_4, 5, __pyx_t_7); + __pyx_t_7 = 0; + __Pyx_INCREF(__pyx_kp_u__5); + __pyx_t_5 += 1; + __Pyx_GIVEREF(__pyx_kp_u__5); + PyTuple_SET_ITEM(__pyx_t_4, 6, __pyx_kp_u__5); + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_4, 7, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_NotImplementedError, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(0, 39, __pyx_L1_error) + } + __pyx_L3:; + + /* "l0learn/interface.pyx":41 + * raise NotImplementedError(f"expected arr to be of type {np.ndarray} or {csc_matrix}, but got {type(arr)}.") + * + * if arr.ndim == 0: # <<<<<<<<<<<<<< + * raise ValueError("expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar") + * elif arr.ndim > 2: + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_ndim); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 41, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_PyInt_EqObjC(__pyx_t_4, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 41, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 41, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":42 + * + * if arr.ndim == 0: + * raise ValueError("expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar") # <<<<<<<<<<<<<< + * elif arr.ndim > 2: + * raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") + */ + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(0, 42, __pyx_L1_error) + + /* "l0learn/interface.pyx":41 + * raise NotImplementedError(f"expected arr to be of type {np.ndarray} or {csc_matrix}, but got {type(arr)}.") + * + * if arr.ndim == 0: # <<<<<<<<<<<<<< + * raise ValueError("expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar") + * elif arr.ndim > 2: + */ + } + + /* "l0learn/interface.pyx":43 + * if arr.ndim == 0: + * raise ValueError("expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar") + * elif arr.ndim > 2: # <<<<<<<<<<<<<< + * raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") + * + */ + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 43, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_7, __pyx_int_2, Py_GT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 43, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 43, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":44 + * raise ValueError("expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar") + * elif arr.ndim > 2: + * raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") # <<<<<<<<<<<<<< + * + * if np.product(arr.shape) == 0: + */ + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 44, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = 0; + __pyx_t_6 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_arr_ndim_to_be_1_or_2_b_2); + __pyx_t_5 += 42; + __Pyx_GIVEREF(__pyx_kp_u_expected_arr_ndim_to_be_1_or_2_b_2); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_kp_u_expected_arr_ndim_to_be_1_or_2_b_2); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 44, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 44, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_6 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_6) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_6; + __pyx_t_5 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3); + __pyx_t_3 = 0; + __Pyx_INCREF(__pyx_kp_u_Not_supported); + __pyx_t_5 += 15; + __Pyx_GIVEREF(__pyx_kp_u_Not_supported); + PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_kp_u_Not_supported); + __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_4, 3, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 44, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_NotImplementedError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 44, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(0, 44, __pyx_L1_error) + + /* "l0learn/interface.pyx":43 + * if arr.ndim == 0: + * raise ValueError("expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar") + * elif arr.ndim > 2: # <<<<<<<<<<<<<< + * raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") + * + */ + } + + /* "l0learn/interface.pyx":46 + * raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") + * + * if np.product(arr.shape) == 0: # <<<<<<<<<<<<<< + * raise ValueError(f"expected non-degenerate dimensions of arr, but got {arr.ndim}") + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_product); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + __pyx_t_4 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_3); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyInt_EqObjC(__pyx_t_4, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":47 + * + * if np.product(arr.shape) == 0: + * raise ValueError(f"expected non-degenerate dimensions of arr, but got {arr.ndim}") # <<<<<<<<<<<<<< + * + * if not np.issubdtype(arr.dtype, np.number): + */ + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_non_degenerate_dimensio, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(0, 47, __pyx_L1_error) + + /* "l0learn/interface.pyx":46 + * raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") + * + * if np.product(arr.shape) == 0: # <<<<<<<<<<<<<< + * raise ValueError(f"expected non-degenerate dimensions of arr, but got {arr.ndim}") + * + */ + } + + /* "l0learn/interface.pyx":49 + * raise ValueError(f"expected non-degenerate dimensions of arr, but got {arr.ndim}") + * + * if not np.issubdtype(arr.dtype, np.number): # <<<<<<<<<<<<<< + * raise ValueError(f"expected numerical dtype, but got {arr.dtype}") + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_issubdtype); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_dtype); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_number); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = NULL; + __pyx_t_10 = 0; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_10 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_7, __pyx_t_9}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_7, __pyx_t_9}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else + #endif + { + __pyx_t_11 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + if (__pyx_t_8) { + __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_8); __pyx_t_8 = NULL; + } + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_10, __pyx_t_7); + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_10, __pyx_t_9); + __pyx_t_7 = 0; + __pyx_t_9 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_11, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_2 = ((!__pyx_t_1) != 0); + if (unlikely(__pyx_t_2)) { + + /* "l0learn/interface.pyx":50 + * + * if not np.issubdtype(arr.dtype, np.number): + * raise ValueError(f"expected numerical dtype, but got {arr.dtype}") # <<<<<<<<<<<<<< + * + * if not np.isrealobj(arr): + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_dtype); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_t_4, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_numerical_dtype_but_got, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 50, __pyx_L1_error) + + /* "l0learn/interface.pyx":49 + * raise ValueError(f"expected non-degenerate dimensions of arr, but got {arr.ndim}") + * + * if not np.issubdtype(arr.dtype, np.number): # <<<<<<<<<<<<<< + * raise ValueError(f"expected numerical dtype, but got {arr.dtype}") + * + */ + } + + /* "l0learn/interface.pyx":52 + * raise ValueError(f"expected numerical dtype, but got {arr.dtype}") + * + * if not np.isrealobj(arr): # <<<<<<<<<<<<<< + * raise ValueError(f"expected non-complex dtype, but got {arr.dtype}") + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_11))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_11); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_11, function); + } + } + __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_4, __pyx_v_arr) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_v_arr); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = ((!__pyx_t_2) != 0); + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":53 + * + * if not np.isrealobj(arr): + * raise ValueError(f"expected non-complex dtype, but got {arr.dtype}") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_dtype); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_11 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_empty_unicode); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_non_complex_dtype_but_g, __pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_11 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_11, 0, 0, 0); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __PYX_ERR(0, 53, __pyx_L1_error) + + /* "l0learn/interface.pyx":52 + * raise ValueError(f"expected numerical dtype, but got {arr.dtype}") + * + * if not np.isrealobj(arr): # <<<<<<<<<<<<<< + * raise ValueError(f"expected non-complex dtype, but got {arr.dtype}") + * + */ + } + + /* "l0learn/interface.pyx":26 + * + * + * def np_to_arma_check(arr): # <<<<<<<<<<<<<< + * # TODO: Add checks for Behaved and OwnsData + * if isinstance(arr, np.ndarray): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_AddTraceback("l0learn.interface.np_to_arma_check", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/interface.pyx":62 + * + * + * def fit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< + * y: np.ndarray, + * loss: str = "SquaredHinge", + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7l0learn_9interface_3fit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_7l0learn_9interface_2fit[] = "fit(X: Union[np.ndarray, csc_matrix], ndarray y: np.ndarray, unicode loss: str = u'SquaredHinge', unicode penalty: str = u'L0', unicode algorithm: str = u'CD', max_support_size: int = 100, num_lambda: Optional[int] = 100, num_gamma: Optional[int] = 1, double gamma_max: float = 10., double gamma_min: float = .0001, partial_sort: bool = True, max_iter: int = 200, double rtol: float = 1e-6, double atol: float = 1e-9, active_set: bool = True, active_set_num: int = 3, max_swaps: int = 100, double scale_down_factor: float = 0.8, screen_size: int = 1000, lambda_grid: Optional[List[List[float]]] = None, exclude_first_k: int = 0, intercept: bool = True, lows: Union[np.ndarray, float] = -float(u'inf'), highs: Union[np.ndarray, float] = +float(u'inf'))\n\n Computes the regularization path for the specified loss function and penalty function.\n\n Parameters\n ----------\n X : np.ndarray or csc_matrix of shape (N, P)\n Data Matrix where rows of X are observations and columns of X are features\n y : np.ndarray of shape (P)\n The response vector where y[i] corresponds to X[i, :]\n For classification, a binary vector (-1, 1) is requried .\n loss : str\n The loss function. Currently supports the choices:\n \"SquaredError\" (for regression),\n \"Logistic\" (for logistic regression), and\n \"SquaredHinge\" (for smooth SVM).\n penalty : str\n The type of regularization.\n This can take either one of the following choices:\n \"L0\",\n \"L0L2\", and\n \"L0L1\"\n algorithm : str\n The type of algorithm used to minimize the objective function. Currently \"CD\" and \"CDPSI\" are are supported.\n \"CD\" is a variant of cyclic coordinate descent and runs very fast. \"CDPSI\" performs local combinatorial search\n on top of CD and typically achieves higher quality solutions (at the expense of increased running time).\n max_support_size\n ""num_lambda\n num_gamma\n gamma_max\n gamma_min\n partial_sort\n max_iter\n rtol\n atol\n active_set\n active_set_num\n max_swaps\n scale_down_factor\n screen_size\n lambda_grid\n exclude_first_k\n intercept\n lows\n highs\n\n Returns\n -------\n\n "; +static PyMethodDef __pyx_mdef_7l0learn_9interface_3fit = {"fit", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7l0learn_9interface_3fit, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7l0learn_9interface_2fit}; +static PyObject *__pyx_pw_7l0learn_9interface_3fit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_X = 0; + PyArrayObject *__pyx_v_y = 0; + PyObject *__pyx_v_loss = 0; + PyObject *__pyx_v_penalty = 0; + PyObject *__pyx_v_algorithm = 0; + PyObject *__pyx_v_max_support_size = 0; + PyObject *__pyx_v_num_lambda = 0; + PyObject *__pyx_v_num_gamma = 0; + double __pyx_v_gamma_max; + double __pyx_v_gamma_min; + PyObject *__pyx_v_partial_sort = 0; + PyObject *__pyx_v_max_iter = 0; + double __pyx_v_rtol; + double __pyx_v_atol; + PyObject *__pyx_v_active_set = 0; + PyObject *__pyx_v_active_set_num = 0; + PyObject *__pyx_v_max_swaps = 0; + double __pyx_v_scale_down_factor; + PyObject *__pyx_v_screen_size = 0; + PyObject *__pyx_v_lambda_grid = 0; + PyObject *__pyx_v_exclude_first_k = 0; + PyObject *__pyx_v_intercept = 0; + PyObject *__pyx_v_lows = 0; + PyObject *__pyx_v_highs = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("fit (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_X,&__pyx_n_s_y,&__pyx_n_s_loss,&__pyx_n_s_penalty,&__pyx_n_s_algorithm,&__pyx_n_s_max_support_size,&__pyx_n_s_num_lambda,&__pyx_n_s_num_gamma,&__pyx_n_s_gamma_max,&__pyx_n_s_gamma_min,&__pyx_n_s_partial_sort,&__pyx_n_s_max_iter,&__pyx_n_s_rtol,&__pyx_n_s_atol,&__pyx_n_s_active_set,&__pyx_n_s_active_set_num,&__pyx_n_s_max_swaps,&__pyx_n_s_scale_down_factor,&__pyx_n_s_screen_size,&__pyx_n_s_lambda_grid,&__pyx_n_s_exclude_first_k,&__pyx_n_s_intercept,&__pyx_n_s_lows,&__pyx_n_s_highs,0}; + PyObject* values[24] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + values[2] = ((PyObject*)__pyx_n_u_SquaredHinge); + values[3] = ((PyObject*)__pyx_n_u_L0); + values[4] = ((PyObject*)__pyx_n_u_CD); + values[5] = ((PyObject *)__pyx_int_100); + values[6] = ((PyObject *)__pyx_int_100); + values[7] = ((PyObject *)__pyx_int_1); + + /* "l0learn/interface.pyx":72 + * gamma_max: float = 10., + * gamma_min: float = .0001, + * partial_sort: bool = True, # <<<<<<<<<<<<<< + * max_iter: int = 200, + * rtol: float = 1e-6, + */ + values[10] = ((PyObject *)Py_True); + values[11] = ((PyObject *)__pyx_int_200); + + /* "l0learn/interface.pyx":76 + * rtol: float = 1e-6, + * atol: float = 1e-9, + * active_set: bool = True, # <<<<<<<<<<<<<< + * active_set_num: int = 3, + * max_swaps: int = 100, + */ + values[14] = ((PyObject *)Py_True); + values[15] = ((PyObject *)__pyx_int_3); + values[16] = ((PyObject *)__pyx_int_100); + values[18] = ((PyObject *)__pyx_int_1000); + + /* "l0learn/interface.pyx":81 + * scale_down_factor: float = 0.8, + * screen_size: int = 1000, + * lambda_grid: Optional[List[List[float]]] = None, # <<<<<<<<<<<<<< + * exclude_first_k: int = 0, + * intercept: bool = True, + */ + values[19] = ((PyObject *)Py_None); + values[20] = ((PyObject *)__pyx_int_0); + + /* "l0learn/interface.pyx":83 + * lambda_grid: Optional[List[List[float]]] = None, + * exclude_first_k: int = 0, + * intercept: bool = True, # <<<<<<<<<<<<<< + * lows: Union[np.ndarray, float] = -float('inf'), + * highs: Union[np.ndarray, float] = +float('inf'),): + */ + values[21] = ((PyObject *)Py_True); + values[22] = __pyx_k__7; + values[23] = __pyx_k__8; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 24: values[23] = PyTuple_GET_ITEM(__pyx_args, 23); + CYTHON_FALLTHROUGH; + case 23: values[22] = PyTuple_GET_ITEM(__pyx_args, 22); + CYTHON_FALLTHROUGH; + case 22: values[21] = PyTuple_GET_ITEM(__pyx_args, 21); + CYTHON_FALLTHROUGH; + case 21: values[20] = PyTuple_GET_ITEM(__pyx_args, 20); + CYTHON_FALLTHROUGH; + case 20: values[19] = PyTuple_GET_ITEM(__pyx_args, 19); + CYTHON_FALLTHROUGH; + case 19: values[18] = PyTuple_GET_ITEM(__pyx_args, 18); + CYTHON_FALLTHROUGH; + case 18: values[17] = PyTuple_GET_ITEM(__pyx_args, 17); + CYTHON_FALLTHROUGH; + case 17: values[16] = PyTuple_GET_ITEM(__pyx_args, 16); + CYTHON_FALLTHROUGH; + case 16: values[15] = PyTuple_GET_ITEM(__pyx_args, 15); + CYTHON_FALLTHROUGH; + case 15: values[14] = PyTuple_GET_ITEM(__pyx_args, 14); + CYTHON_FALLTHROUGH; + case 14: values[13] = PyTuple_GET_ITEM(__pyx_args, 13); + CYTHON_FALLTHROUGH; + case 13: values[12] = PyTuple_GET_ITEM(__pyx_args, 12); + CYTHON_FALLTHROUGH; + case 12: values[11] = PyTuple_GET_ITEM(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_X)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("fit", 0, 2, 24, 1); __PYX_ERR(0, 62, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_loss); + if (value) { values[2] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_penalty); + if (value) { values[3] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_algorithm); + if (value) { values[4] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_support_size); + if (value) { values[5] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_num_lambda); + if (value) { values[6] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 7: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_num_gamma); + if (value) { values[7] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 8: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_gamma_max); + if (value) { values[8] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 9: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_gamma_min); + if (value) { values[9] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 10: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_partial_sort); + if (value) { values[10] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 11: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_iter); + if (value) { values[11] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 12: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rtol); + if (value) { values[12] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 13: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_atol); + if (value) { values[13] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 14: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_active_set); + if (value) { values[14] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 15: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_active_set_num); + if (value) { values[15] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 16: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_swaps); + if (value) { values[16] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 17: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_scale_down_factor); + if (value) { values[17] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 18: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_screen_size); + if (value) { values[18] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 19: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_lambda_grid); + if (value) { values[19] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 20: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_exclude_first_k); + if (value) { values[20] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 21: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_intercept); + if (value) { values[21] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 22: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_lows); + if (value) { values[22] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 23: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_highs); + if (value) { values[23] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fit") < 0)) __PYX_ERR(0, 62, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 24: values[23] = PyTuple_GET_ITEM(__pyx_args, 23); + CYTHON_FALLTHROUGH; + case 23: values[22] = PyTuple_GET_ITEM(__pyx_args, 22); + CYTHON_FALLTHROUGH; + case 22: values[21] = PyTuple_GET_ITEM(__pyx_args, 21); + CYTHON_FALLTHROUGH; + case 21: values[20] = PyTuple_GET_ITEM(__pyx_args, 20); + CYTHON_FALLTHROUGH; + case 20: values[19] = PyTuple_GET_ITEM(__pyx_args, 19); + CYTHON_FALLTHROUGH; + case 19: values[18] = PyTuple_GET_ITEM(__pyx_args, 18); + CYTHON_FALLTHROUGH; + case 18: values[17] = PyTuple_GET_ITEM(__pyx_args, 17); + CYTHON_FALLTHROUGH; + case 17: values[16] = PyTuple_GET_ITEM(__pyx_args, 16); + CYTHON_FALLTHROUGH; + case 16: values[15] = PyTuple_GET_ITEM(__pyx_args, 15); + CYTHON_FALLTHROUGH; + case 15: values[14] = PyTuple_GET_ITEM(__pyx_args, 14); + CYTHON_FALLTHROUGH; + case 14: values[13] = PyTuple_GET_ITEM(__pyx_args, 13); + CYTHON_FALLTHROUGH; + case 13: values[12] = PyTuple_GET_ITEM(__pyx_args, 12); + CYTHON_FALLTHROUGH; + case 12: values[11] = PyTuple_GET_ITEM(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_X = values[0]; + __pyx_v_y = ((PyArrayObject *)values[1]); + __pyx_v_loss = ((PyObject*)values[2]); + __pyx_v_penalty = ((PyObject*)values[3]); + __pyx_v_algorithm = ((PyObject*)values[4]); + __pyx_v_max_support_size = values[5]; + __pyx_v_num_lambda = values[6]; + __pyx_v_num_gamma = values[7]; + if (values[8]) { + __pyx_v_gamma_max = __pyx_PyFloat_AsDouble(values[8]); if (unlikely((__pyx_v_gamma_max == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 70, __pyx_L3_error) + } else { + __pyx_v_gamma_max = ((double)10.); + } + if (values[9]) { + __pyx_v_gamma_min = __pyx_PyFloat_AsDouble(values[9]); if (unlikely((__pyx_v_gamma_min == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error) + } else { + __pyx_v_gamma_min = ((double).0001); + } + __pyx_v_partial_sort = values[10]; + __pyx_v_max_iter = values[11]; + if (values[12]) { + __pyx_v_rtol = __pyx_PyFloat_AsDouble(values[12]); if (unlikely((__pyx_v_rtol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 74, __pyx_L3_error) + } else { + __pyx_v_rtol = ((double)1e-6); + } + if (values[13]) { + __pyx_v_atol = __pyx_PyFloat_AsDouble(values[13]); if (unlikely((__pyx_v_atol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 75, __pyx_L3_error) + } else { + __pyx_v_atol = ((double)1e-9); + } + __pyx_v_active_set = values[14]; + __pyx_v_active_set_num = values[15]; + __pyx_v_max_swaps = values[16]; + if (values[17]) { + __pyx_v_scale_down_factor = __pyx_PyFloat_AsDouble(values[17]); if (unlikely((__pyx_v_scale_down_factor == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 79, __pyx_L3_error) + } else { + __pyx_v_scale_down_factor = ((double)0.8); + } + __pyx_v_screen_size = values[18]; + __pyx_v_lambda_grid = values[19]; + __pyx_v_exclude_first_k = values[20]; + __pyx_v_intercept = values[21]; + __pyx_v_lows = values[22]; + __pyx_v_highs = values[23]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("fit", 0, 2, 24, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 62, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("l0learn.interface.fit", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_y), __pyx_ptype_5numpy_ndarray, 1, "y", 0))) __PYX_ERR(0, 63, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loss), (&PyUnicode_Type), 1, "loss", 1))) __PYX_ERR(0, 64, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_penalty), (&PyUnicode_Type), 1, "penalty", 1))) __PYX_ERR(0, 65, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_algorithm), (&PyUnicode_Type), 1, "algorithm", 1))) __PYX_ERR(0, 66, __pyx_L1_error) + __pyx_r = __pyx_pf_7l0learn_9interface_2fit(__pyx_self, __pyx_v_X, __pyx_v_y, __pyx_v_loss, __pyx_v_penalty, __pyx_v_algorithm, __pyx_v_max_support_size, __pyx_v_num_lambda, __pyx_v_num_gamma, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_v_partial_sort, __pyx_v_max_iter, __pyx_v_rtol, __pyx_v_atol, __pyx_v_active_set, __pyx_v_active_set_num, __pyx_v_max_swaps, __pyx_v_scale_down_factor, __pyx_v_screen_size, __pyx_v_lambda_grid, __pyx_v_exclude_first_k, __pyx_v_intercept, __pyx_v_lows, __pyx_v_highs); + + /* "l0learn/interface.pyx":62 + * + * + * def fit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< + * y: np.ndarray, + * loss: str = "SquaredHinge", + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyArrayObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs) { + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_v_p = NULL; + int __pyx_v_auto_lambda; + CYTHON_UNUSED int __pyx_v_bad_lambda_grid; + PyObject *__pyx_v_i = NULL; + PyObject *__pyx_v_sub_lambda_grid = NULL; + CYTHON_UNUSED double __pyx_v_current; + int __pyx_v_with_bounds; + PyObject *__pyx_v_bad_bounds = NULL; + std::vector > __pyx_v_c_lambda_grid; + std::string __pyx_v_c_loss; + std::string __pyx_v_c_penalty; + std::string __pyx_v_c_algorithim; + fitmodel __pyx_v_results; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + Py_ssize_t __pyx_t_9; + Py_UCS4 __pyx_t_10; + PyObject *(*__pyx_t_11)(PyObject *); + int __pyx_t_12; + PyObject *(*__pyx_t_13)(PyObject *); + double __pyx_t_14; + Py_ssize_t __pyx_t_15; + PyObject *__pyx_t_16 = NULL; + PyObject *__pyx_t_17 = NULL; + PyObject *__pyx_t_18 = NULL; + PyObject *__pyx_t_19 = NULL; + std::vector > __pyx_t_20; + int __pyx_t_21; + std::string __pyx_t_22; + size_t __pyx_t_23; + size_t __pyx_t_24; + size_t __pyx_t_25; + bool __pyx_t_26; + size_t __pyx_t_27; + bool __pyx_t_28; + size_t __pyx_t_29; + size_t __pyx_t_30; + size_t __pyx_t_31; + size_t __pyx_t_32; + bool __pyx_t_33; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("fit", 0); + __Pyx_INCREF(__pyx_v_penalty); + __Pyx_INCREF(__pyx_v_num_lambda); + __Pyx_INCREF(__pyx_v_num_gamma); + __Pyx_INCREF(__pyx_v_lambda_grid); + __Pyx_INCREF(__pyx_v_lows); + __Pyx_INCREF(__pyx_v_highs); + + /* "l0learn/interface.pyx":136 + * """ + * + * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): # <<<<<<<<<<<<<< + * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_TypeCheck(__pyx_v_X, __pyx_ptype_5numpy_ndarray); + __pyx_t_5 = (__pyx_t_4 != 0); + if (!__pyx_t_5) { + } else { + __pyx_t_3 = __pyx_t_5; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_5 = PyObject_IsInstance(__pyx_v_X, __pyx_t_2); + __pyx_t_4 = (__pyx_t_5 != 0); + __pyx_t_3 = __pyx_t_4; + __pyx_L6_bool_binop_done:; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = ((!(__pyx_t_3 != 0)) != 0); + if (!__pyx_t_4) { + } else { + __pyx_t_1 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + __pyx_t_2 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_6, __pyx_v_X) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_X); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = ((!__pyx_t_4) != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyInt_NeObjC(__pyx_t_2, __pyx_int_2, 2, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_product); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + __pyx_t_7 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_8, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_2); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_4 = ((!__pyx_t_3) != 0); + __pyx_t_1 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":137 + * + * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): + * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") # <<<<<<<<<<<<<< + * + * n, p = X.shape + */ + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_X_to_be_a_2D_non_degene); + __pyx_t_9 += 71; + __Pyx_GIVEREF(__pyx_kp_u_expected_X_to_be_a_2D_non_degene); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_X_to_be_a_2D_non_degene); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_X, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_kp_u__5); + __pyx_t_9 += 1; + __Pyx_GIVEREF(__pyx_kp_u__5); + PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u__5); + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(0, 137, __pyx_L1_error) + + /* "l0learn/interface.pyx":136 + * """ + * + * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): # <<<<<<<<<<<<<< + * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") + * + */ + } + + /* "l0learn/interface.pyx":139 + * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") + * + * n, p = X.shape # <<<<<<<<<<<<<< + * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: + * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") + */ + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if ((likely(PyTuple_CheckExact(__pyx_t_7))) || (PyList_CheckExact(__pyx_t_7))) { + PyObject* sequence = __pyx_t_7; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 139, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_2 = PyTuple_GET_ITEM(sequence, 1); + } else { + __pyx_t_6 = PyList_GET_ITEM(sequence, 0); + __pyx_t_2 = PyList_GET_ITEM(sequence, 1); + } + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx_t_2); + #else + __pyx_t_6 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_8 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_11 = Py_TYPE(__pyx_t_8)->tp_iternext; + index = 0; __pyx_t_6 = __pyx_t_11(__pyx_t_8); if (unlikely(!__pyx_t_6)) goto __pyx_L10_unpacking_failed; + __Pyx_GOTREF(__pyx_t_6); + index = 1; __pyx_t_2 = __pyx_t_11(__pyx_t_8); if (unlikely(!__pyx_t_2)) goto __pyx_L10_unpacking_failed; + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_8), 2) < 0) __PYX_ERR(0, 139, __pyx_L1_error) + __pyx_t_11 = NULL; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + goto __pyx_L11_unpacking_done; + __pyx_L10_unpacking_failed:; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_11 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 139, __pyx_L1_error) + __pyx_L11_unpacking_done:; + } + __pyx_v_n = __pyx_t_6; + __pyx_t_6 = 0; + __pyx_v_p = __pyx_t_2; + __pyx_t_2 = 0; + + /* "l0learn/interface.pyx":140 + * + * n, p = X.shape + * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: # <<<<<<<<<<<<<< + * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") + * + */ + __pyx_t_4 = __Pyx_TypeCheck(((PyObject *)__pyx_v_y), __pyx_ptype_5numpy_ndarray); + __pyx_t_3 = ((!(__pyx_t_4 != 0)) != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L13_bool_binop_done; + } + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + __pyx_t_7 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_2, ((PyObject *)__pyx_v_y)) : __Pyx_PyObject_CallOneArg(__pyx_t_6, ((PyObject *)__pyx_v_y)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 140, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_4 = ((!__pyx_t_3) != 0); + if (!__pyx_t_4) { + } else { + __pyx_t_1 = __pyx_t_4; + goto __pyx_L13_bool_binop_done; + } + __pyx_t_4 = ((__pyx_v_y->nd != 1) != 0); + if (!__pyx_t_4) { + } else { + __pyx_t_1 = __pyx_t_4; + goto __pyx_L13_bool_binop_done; + } + __pyx_t_9 = PyObject_Length(((PyObject *)__pyx_v_y)); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 140, __pyx_L1_error) + __pyx_t_7 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = PyObject_RichCompare(__pyx_t_7, __pyx_v_n, Py_NE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 140, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 140, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_1 = __pyx_t_4; + __pyx_L13_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":141 + * n, p = X.shape + * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: + * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") # <<<<<<<<<<<<<< + * + * if loss not in SUPPORTED_LOSS: + */ + __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_y_to_be_a_1D_real_numpy); + __pyx_t_9 += 42; + __Pyx_GIVEREF(__pyx_kp_u_expected_y_to_be_a_1D_real_numpy); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_y_to_be_a_1D_real_numpy); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(((PyObject *)__pyx_v_y), __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_7); + __pyx_t_7 = 0; + __Pyx_INCREF(__pyx_kp_u__5); + __pyx_t_9 += 1; + __Pyx_GIVEREF(__pyx_kp_u__5); + PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u__5); + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_6, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 141, __pyx_L1_error) + + /* "l0learn/interface.pyx":140 + * + * n, p = X.shape + * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: # <<<<<<<<<<<<<< + * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") + * + */ + } + + /* "l0learn/interface.pyx":143 + * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") + * + * if loss not in SUPPORTED_LOSS: # <<<<<<<<<<<<<< + * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_loss, __pyx_t_6, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 143, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_4 = (__pyx_t_1 != 0); + if (unlikely(__pyx_t_4)) { + + /* "l0learn/interface.pyx":144 + * + * if loss not in SUPPORTED_LOSS: + * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") # <<<<<<<<<<<<<< + * + * if penalty not in SUPPORTED_PENALTY: + */ + __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_loss_parameter_to_be_on); + __pyx_t_9 += 36; + __Pyx_GIVEREF(__pyx_kp_u_expected_loss_parameter_to_be_on); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_loss_parameter_to_be_on); + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_kp_u_but_got); + __pyx_t_9 += 10; + __Pyx_GIVEREF(__pyx_kp_u_but_got); + PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u_but_got); + __pyx_t_2 = __Pyx_PyUnicode_Unicode(__pyx_v_loss); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_6, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 144, __pyx_L1_error) + + /* "l0learn/interface.pyx":143 + * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") + * + * if loss not in SUPPORTED_LOSS: # <<<<<<<<<<<<<< + * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") + * + */ + } + + /* "l0learn/interface.pyx":146 + * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") + * + * if penalty not in SUPPORTED_PENALTY: # <<<<<<<<<<<<<< + * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") + * if algorithm not in SUPPORTED_ALGORITHM: + */ + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_SUPPORTED_PENALTY); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_4 = (__Pyx_PySequence_ContainsTF(__pyx_v_penalty, __pyx_t_6, Py_NE)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 146, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_1 = (__pyx_t_4 != 0); + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":147 + * + * if penalty not in SUPPORTED_PENALTY: + * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") # <<<<<<<<<<<<<< + * if algorithm not in SUPPORTED_ALGORITHM: + * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") + */ + __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_penalty_parameter_to_be); + __pyx_t_9 += 39; + __Pyx_GIVEREF(__pyx_kp_u_expected_penalty_parameter_to_be); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_penalty_parameter_to_be); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SUPPORTED_PENALTY); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_7); + __pyx_t_7 = 0; + __Pyx_INCREF(__pyx_kp_u_but_got); + __pyx_t_9 += 10; + __Pyx_GIVEREF(__pyx_kp_u_but_got); + PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u_but_got); + __pyx_t_7 = __Pyx_PyUnicode_Unicode(__pyx_v_penalty); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_6, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 147, __pyx_L1_error) + + /* "l0learn/interface.pyx":146 + * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") + * + * if penalty not in SUPPORTED_PENALTY: # <<<<<<<<<<<<<< + * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") + * if algorithm not in SUPPORTED_ALGORITHM: + */ + } + + /* "l0learn/interface.pyx":148 + * if penalty not in SUPPORTED_PENALTY: + * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") + * if algorithm not in SUPPORTED_ALGORITHM: # <<<<<<<<<<<<<< + * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") + * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): + */ + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_SUPPORTED_ALGORITHM); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_algorithm, __pyx_t_6, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 148, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_4 = (__pyx_t_1 != 0); + if (unlikely(__pyx_t_4)) { + + /* "l0learn/interface.pyx":149 + * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") + * if algorithm not in SUPPORTED_ALGORITHM: + * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") # <<<<<<<<<<<<<< + * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): + * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," + */ + __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_algorithm_parameter_to); + __pyx_t_9 += 41; + __Pyx_GIVEREF(__pyx_kp_u_expected_algorithm_parameter_to); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_algorithm_parameter_to); + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_SUPPORTED_ALGORITHM); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_kp_u_but_got); + __pyx_t_9 += 10; + __Pyx_GIVEREF(__pyx_kp_u_but_got); + PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u_but_got); + __pyx_t_2 = __Pyx_PyUnicode_Unicode(__pyx_v_algorithm); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_6, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 149, __pyx_L1_error) + + /* "l0learn/interface.pyx":148 + * if penalty not in SUPPORTED_PENALTY: + * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") + * if algorithm not in SUPPORTED_ALGORITHM: # <<<<<<<<<<<<<< + * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") + * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): + */ + } + + /* "l0learn/interface.pyx":150 + * if algorithm not in SUPPORTED_ALGORITHM: + * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") + * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): # <<<<<<<<<<<<<< + * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," + * f" but got {max_support_size}") + */ + __pyx_t_1 = PyInt_Check(__pyx_v_max_support_size); + __pyx_t_3 = ((!(__pyx_t_1 != 0)) != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_4 = __pyx_t_3; + goto __pyx_L21_bool_binop_done; + } + __pyx_t_6 = PyObject_RichCompare(__pyx_int_0, __pyx_v_max_support_size, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 150, __pyx_L1_error) + if (__Pyx_PyObject_IsTrue(__pyx_t_6)) { + __Pyx_DECREF(__pyx_t_6); + __pyx_t_6 = PyObject_RichCompare(__pyx_v_max_support_size, __pyx_v_p, Py_LE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 150, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_1 = ((!__pyx_t_3) != 0); + __pyx_t_4 = __pyx_t_1; + __pyx_L21_bool_binop_done:; + if (unlikely(__pyx_t_4)) { + + /* "l0learn/interface.pyx":151 + * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") + * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): + * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," # <<<<<<<<<<<<<< + * f" but got {max_support_size}") + * if gamma_max < 0: + */ + __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_max_support_size_parame); + __pyx_t_9 += 71; + __Pyx_GIVEREF(__pyx_kp_u_expected_max_support_size_parame); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_max_support_size_parame); + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_kp_u_but_got); + __pyx_t_9 += 10; + __Pyx_GIVEREF(__pyx_kp_u_but_got); + PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u_but_got); + + /* "l0learn/interface.pyx":152 + * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): + * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," + * f" but got {max_support_size}") # <<<<<<<<<<<<<< + * if gamma_max < 0: + * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") + */ + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_max_support_size, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_2); + __pyx_t_2 = 0; + + /* "l0learn/interface.pyx":151 + * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") + * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): + * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," # <<<<<<<<<<<<<< + * f" but got {max_support_size}") + * if gamma_max < 0: + */ + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_6, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 151, __pyx_L1_error) + + /* "l0learn/interface.pyx":150 + * if algorithm not in SUPPORTED_ALGORITHM: + * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") + * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): # <<<<<<<<<<<<<< + * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," + * f" but got {max_support_size}") + */ + } + + /* "l0learn/interface.pyx":153 + * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," + * f" but got {max_support_size}") + * if gamma_max < 0: # <<<<<<<<<<<<<< + * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") + * if gamma_min < 0 or gamma_min > gamma_max: + */ + __pyx_t_4 = ((__pyx_v_gamma_max < 0.0) != 0); + if (unlikely(__pyx_t_4)) { + + /* "l0learn/interface.pyx":154 + * f" but got {max_support_size}") + * if gamma_max < 0: + * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") # <<<<<<<<<<<<<< + * if gamma_min < 0 or gamma_min > gamma_max: + * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," + */ + __pyx_t_6 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_6, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_gamma_max_parameter_to, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 154, __pyx_L1_error) + + /* "l0learn/interface.pyx":153 + * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," + * f" but got {max_support_size}") + * if gamma_max < 0: # <<<<<<<<<<<<<< + * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") + * if gamma_min < 0 or gamma_min > gamma_max: + */ + } + + /* "l0learn/interface.pyx":155 + * if gamma_max < 0: + * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") + * if gamma_min < 0 or gamma_min > gamma_max: # <<<<<<<<<<<<<< + * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," + * f" but got {gamma_min}") + */ + __pyx_t_1 = ((__pyx_v_gamma_min < 0.0) != 0); + if (!__pyx_t_1) { + } else { + __pyx_t_4 = __pyx_t_1; + goto __pyx_L25_bool_binop_done; + } + __pyx_t_1 = ((__pyx_v_gamma_min > __pyx_v_gamma_max) != 0); + __pyx_t_4 = __pyx_t_1; + __pyx_L25_bool_binop_done:; + if (unlikely(__pyx_t_4)) { + + /* "l0learn/interface.pyx":157 + * if gamma_min < 0 or gamma_min > gamma_max: + * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," + * f" but got {gamma_min}") # <<<<<<<<<<<<<< + * if not isinstance(partial_sort, bool): + * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") + */ + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "l0learn/interface.pyx":156 + * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") + * if gamma_min < 0 or gamma_min > gamma_max: + * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," # <<<<<<<<<<<<<< + * f" but got {gamma_min}") + * if not isinstance(partial_sort, bool): + */ + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_gamma_max_parameter_to_2, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 156, __pyx_L1_error) + + /* "l0learn/interface.pyx":155 + * if gamma_max < 0: + * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") + * if gamma_min < 0 or gamma_min > gamma_max: # <<<<<<<<<<<<<< + * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," + * f" but got {gamma_min}") + */ + } + + /* "l0learn/interface.pyx":158 + * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," + * f" but got {gamma_min}") + * if not isinstance(partial_sort, bool): # <<<<<<<<<<<<<< + * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") + * if not isinstance(max_iter, int) or max_iter < 1: + */ + __pyx_t_6 = ((PyObject*)&PyBool_Type); + __Pyx_INCREF(__pyx_t_6); + __pyx_t_4 = PyObject_IsInstance(__pyx_v_partial_sort, __pyx_t_6); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 158, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_1 = ((!(__pyx_t_4 != 0)) != 0); + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":159 + * f" but got {gamma_min}") + * if not isinstance(partial_sort, bool): + * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") # <<<<<<<<<<<<<< + * if not isinstance(max_iter, int) or max_iter < 1: + * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") + */ + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_partial_sort, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_partial_sort_parameter, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 159, __pyx_L1_error) + + /* "l0learn/interface.pyx":158 + * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," + * f" but got {gamma_min}") + * if not isinstance(partial_sort, bool): # <<<<<<<<<<<<<< + * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") + * if not isinstance(max_iter, int) or max_iter < 1: + */ + } + + /* "l0learn/interface.pyx":160 + * if not isinstance(partial_sort, bool): + * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") + * if not isinstance(max_iter, int) or max_iter < 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") + * if rtol < 0 or rtol >= 1: + */ + __pyx_t_4 = PyInt_Check(__pyx_v_max_iter); + __pyx_t_3 = ((!(__pyx_t_4 != 0)) != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L29_bool_binop_done; + } + __pyx_t_6 = PyObject_RichCompare(__pyx_v_max_iter, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 160, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 160, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_1 = __pyx_t_3; + __pyx_L29_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":161 + * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") + * if not isinstance(max_iter, int) or max_iter < 1: + * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") # <<<<<<<<<<<<<< + * if rtol < 0 or rtol >= 1: + * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") + */ + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_max_iter, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_iter_parameter_to_b, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 161, __pyx_L1_error) + + /* "l0learn/interface.pyx":160 + * if not isinstance(partial_sort, bool): + * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") + * if not isinstance(max_iter, int) or max_iter < 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") + * if rtol < 0 or rtol >= 1: + */ + } + + /* "l0learn/interface.pyx":162 + * if not isinstance(max_iter, int) or max_iter < 1: + * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") + * if rtol < 0 or rtol >= 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") + * if atol < 0: + */ + __pyx_t_3 = ((__pyx_v_rtol < 0.0) != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L32_bool_binop_done; + } + __pyx_t_3 = ((__pyx_v_rtol >= 1.0) != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L32_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":163 + * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") + * if rtol < 0 or rtol >= 1: + * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") # <<<<<<<<<<<<<< + * if atol < 0: + * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") + */ + __pyx_t_6 = PyFloat_FromDouble(__pyx_v_rtol); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 163, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_6, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 163, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_rtol_parameter_to_exist, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 163, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 163, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 163, __pyx_L1_error) + + /* "l0learn/interface.pyx":162 + * if not isinstance(max_iter, int) or max_iter < 1: + * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") + * if rtol < 0 or rtol >= 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") + * if atol < 0: + */ + } + + /* "l0learn/interface.pyx":164 + * if rtol < 0 or rtol >= 1: + * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") + * if atol < 0: # <<<<<<<<<<<<<< + * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") + * if not isinstance(active_set, bool): + */ + __pyx_t_1 = ((__pyx_v_atol < 0.0) != 0); + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":165 + * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") + * if atol < 0: + * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") # <<<<<<<<<<<<<< + * if not isinstance(active_set, bool): + * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") + */ + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_atol); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_atol_parameter_to_exist, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 165, __pyx_L1_error) + + /* "l0learn/interface.pyx":164 + * if rtol < 0 or rtol >= 1: + * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") + * if atol < 0: # <<<<<<<<<<<<<< + * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") + * if not isinstance(active_set, bool): + */ + } + + /* "l0learn/interface.pyx":166 + * if atol < 0: + * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") + * if not isinstance(active_set, bool): # <<<<<<<<<<<<<< + * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") + * if not isinstance(active_set_num, int) or active_set_num < 1: + */ + __pyx_t_6 = ((PyObject*)&PyBool_Type); + __Pyx_INCREF(__pyx_t_6); + __pyx_t_1 = PyObject_IsInstance(__pyx_v_active_set, __pyx_t_6); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 166, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_3 = ((!(__pyx_t_1 != 0)) != 0); + if (unlikely(__pyx_t_3)) { + + /* "l0learn/interface.pyx":167 + * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") + * if not isinstance(active_set, bool): + * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") # <<<<<<<<<<<<<< + * if not isinstance(active_set_num, int) or active_set_num < 1: + * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") + */ + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_active_set, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_active_set_parameter_to, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 167, __pyx_L1_error) + + /* "l0learn/interface.pyx":166 + * if atol < 0: + * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") + * if not isinstance(active_set, bool): # <<<<<<<<<<<<<< + * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") + * if not isinstance(active_set_num, int) or active_set_num < 1: + */ + } + + /* "l0learn/interface.pyx":168 + * if not isinstance(active_set, bool): + * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") + * if not isinstance(active_set_num, int) or active_set_num < 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") + * if not isinstance(max_swaps, int) or max_swaps < 1: + */ + __pyx_t_1 = PyInt_Check(__pyx_v_active_set_num); + __pyx_t_4 = ((!(__pyx_t_1 != 0)) != 0); + if (!__pyx_t_4) { + } else { + __pyx_t_3 = __pyx_t_4; + goto __pyx_L37_bool_binop_done; + } + __pyx_t_6 = PyObject_RichCompare(__pyx_v_active_set_num, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 168, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 168, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_3 = __pyx_t_4; + __pyx_L37_bool_binop_done:; + if (unlikely(__pyx_t_3)) { + + /* "l0learn/interface.pyx":169 + * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") + * if not isinstance(active_set_num, int) or active_set_num < 1: + * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") # <<<<<<<<<<<<<< + * if not isinstance(max_swaps, int) or max_swaps < 1: + * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") + */ + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_active_set_num, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 169, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_active_set_num_paramete, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 169, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 169, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 169, __pyx_L1_error) + + /* "l0learn/interface.pyx":168 + * if not isinstance(active_set, bool): + * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") + * if not isinstance(active_set_num, int) or active_set_num < 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") + * if not isinstance(max_swaps, int) or max_swaps < 1: + */ + } + + /* "l0learn/interface.pyx":170 + * if not isinstance(active_set_num, int) or active_set_num < 1: + * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") + * if not isinstance(max_swaps, int) or max_swaps < 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") + * if not (0 < scale_down_factor < 1): + */ + __pyx_t_4 = PyInt_Check(__pyx_v_max_swaps); + __pyx_t_1 = ((!(__pyx_t_4 != 0)) != 0); + if (!__pyx_t_1) { + } else { + __pyx_t_3 = __pyx_t_1; + goto __pyx_L40_bool_binop_done; + } + __pyx_t_6 = PyObject_RichCompare(__pyx_v_max_swaps, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 170, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 170, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_3 = __pyx_t_1; + __pyx_L40_bool_binop_done:; + if (unlikely(__pyx_t_3)) { + + /* "l0learn/interface.pyx":171 + * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") + * if not isinstance(max_swaps, int) or max_swaps < 1: + * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") # <<<<<<<<<<<<<< + * if not (0 < scale_down_factor < 1): + * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") + */ + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_max_swaps, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 171, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_swaps_parameter_to, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 171, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 171, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 171, __pyx_L1_error) + + /* "l0learn/interface.pyx":170 + * if not isinstance(active_set_num, int) or active_set_num < 1: + * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") + * if not isinstance(max_swaps, int) or max_swaps < 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") + * if not (0 < scale_down_factor < 1): + */ + } + + /* "l0learn/interface.pyx":172 + * if not isinstance(max_swaps, int) or max_swaps < 1: + * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") + * if not (0 < scale_down_factor < 1): # <<<<<<<<<<<<<< + * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") + * if not isinstance(screen_size, int) or screen_size < 1: + */ + __pyx_t_3 = (0.0 < __pyx_v_scale_down_factor); + if (__pyx_t_3) { + __pyx_t_3 = (__pyx_v_scale_down_factor < 1.0); + } + __pyx_t_1 = ((!(__pyx_t_3 != 0)) != 0); + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":173 + * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") + * if not (0 < scale_down_factor < 1): + * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") # <<<<<<<<<<<<<< + * if not isinstance(screen_size, int) or screen_size < 1: + * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") + */ + __pyx_t_6 = PyFloat_FromDouble(__pyx_v_scale_down_factor); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 173, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_6, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 173, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_scale_down_factor_param, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 173, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 173, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 173, __pyx_L1_error) + + /* "l0learn/interface.pyx":172 + * if not isinstance(max_swaps, int) or max_swaps < 1: + * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") + * if not (0 < scale_down_factor < 1): # <<<<<<<<<<<<<< + * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") + * if not isinstance(screen_size, int) or screen_size < 1: + */ + } + + /* "l0learn/interface.pyx":174 + * if not (0 < scale_down_factor < 1): + * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") + * if not isinstance(screen_size, int) or screen_size < 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") + * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): + */ + __pyx_t_3 = PyInt_Check(__pyx_v_screen_size); + __pyx_t_4 = ((!(__pyx_t_3 != 0)) != 0); + if (!__pyx_t_4) { + } else { + __pyx_t_1 = __pyx_t_4; + goto __pyx_L44_bool_binop_done; + } + __pyx_t_2 = PyObject_RichCompare(__pyx_v_screen_size, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 174, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 174, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_1 = __pyx_t_4; + __pyx_L44_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":175 + * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") + * if not isinstance(screen_size, int) or screen_size < 1: + * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") # <<<<<<<<<<<<<< + * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): + * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " + */ + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_screen_size, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 175, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_screen_size_parameter_t, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 175, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 175, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 175, __pyx_L1_error) + + /* "l0learn/interface.pyx":174 + * if not (0 < scale_down_factor < 1): + * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") + * if not isinstance(screen_size, int) or screen_size < 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") + * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): + */ + } + + /* "l0learn/interface.pyx":176 + * if not isinstance(screen_size, int) or screen_size < 1: + * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") + * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): # <<<<<<<<<<<<<< + * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " + * f"but got {exclude_first_k}") + */ + __pyx_t_4 = PyInt_Check(__pyx_v_exclude_first_k); + __pyx_t_3 = ((!(__pyx_t_4 != 0)) != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L47_bool_binop_done; + } + __pyx_t_2 = PyObject_RichCompare(__pyx_int_0, __pyx_v_exclude_first_k, Py_LE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 176, __pyx_L1_error) + if (__Pyx_PyObject_IsTrue(__pyx_t_2)) { + __Pyx_DECREF(__pyx_t_2); + __pyx_t_2 = PyObject_RichCompare(__pyx_v_exclude_first_k, __pyx_v_p, Py_LE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 176, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 176, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = ((!__pyx_t_3) != 0); + __pyx_t_1 = __pyx_t_4; + __pyx_L47_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":177 + * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") + * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): + * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " # <<<<<<<<<<<<<< + * f"but got {exclude_first_k}") + * if not isinstance(intercept, bool): + */ + __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_exclude_first_k_paramet); + __pyx_t_9 += 70; + __Pyx_GIVEREF(__pyx_kp_u_expected_exclude_first_k_paramet); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_u_expected_exclude_first_k_paramet); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_kp_u_but_got); + __pyx_t_9 += 10; + __Pyx_GIVEREF(__pyx_kp_u_but_got); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_kp_u_but_got); + + /* "l0learn/interface.pyx":178 + * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): + * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " + * f"but got {exclude_first_k}") # <<<<<<<<<<<<<< + * if not isinstance(intercept, bool): + * raise ValueError(f"expected intercept parameter to be a bool, " + */ + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_exclude_first_k, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_6); + __pyx_t_6 = 0; + + /* "l0learn/interface.pyx":177 + * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") + * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): + * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " # <<<<<<<<<<<<<< + * f"but got {exclude_first_k}") + * if not isinstance(intercept, bool): + */ + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_2, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 177, __pyx_L1_error) + + /* "l0learn/interface.pyx":176 + * if not isinstance(screen_size, int) or screen_size < 1: + * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") + * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): # <<<<<<<<<<<<<< + * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " + * f"but got {exclude_first_k}") + */ + } + + /* "l0learn/interface.pyx":179 + * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " + * f"but got {exclude_first_k}") + * if not isinstance(intercept, bool): # <<<<<<<<<<<<<< + * raise ValueError(f"expected intercept parameter to be a bool, " + * f"but got {intercept}") + */ + __pyx_t_2 = ((PyObject*)&PyBool_Type); + __Pyx_INCREF(__pyx_t_2); + __pyx_t_1 = PyObject_IsInstance(__pyx_v_intercept, __pyx_t_2); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 179, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = ((!(__pyx_t_1 != 0)) != 0); + if (unlikely(__pyx_t_4)) { + + /* "l0learn/interface.pyx":181 + * if not isinstance(intercept, bool): + * raise ValueError(f"expected intercept parameter to be a bool, " + * f"but got {intercept}") # <<<<<<<<<<<<<< + * + * if loss in CLASSIFICATION_LOSS: + */ + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_intercept, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "l0learn/interface.pyx":180 + * f"but got {exclude_first_k}") + * if not isinstance(intercept, bool): + * raise ValueError(f"expected intercept parameter to be a bool, " # <<<<<<<<<<<<<< + * f"but got {intercept}") + * + */ + __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_intercept_parameter_to, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 180, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 180, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 180, __pyx_L1_error) + + /* "l0learn/interface.pyx":179 + * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " + * f"but got {exclude_first_k}") + * if not isinstance(intercept, bool): # <<<<<<<<<<<<<< + * raise ValueError(f"expected intercept parameter to be a bool, " + * f"but got {intercept}") + */ + } + + /* "l0learn/interface.pyx":183 + * f"but got {intercept}") + * + * if loss in CLASSIFICATION_LOSS: # <<<<<<<<<<<<<< + * if sorted(np.unique(y)) != [-1, 1]: + * raise ValueError(f"expected y vector to only have two unique values (-1 and 1) (Binary Classification), " + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_CLASSIFICATION_LOSS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 183, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = (__Pyx_PySequence_ContainsTF(__pyx_v_loss, __pyx_t_2, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 183, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_1 = (__pyx_t_4 != 0); + if (__pyx_t_1) { + + /* "l0learn/interface.pyx":184 + * + * if loss in CLASSIFICATION_LOSS: + * if sorted(np.unique(y)) != [-1, 1]: # <<<<<<<<<<<<<< + * raise ValueError(f"expected y vector to only have two unique values (-1 and 1) (Binary Classification), " + * f"but got {np.unique(y)}") + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_unique); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + } + } + __pyx_t_6 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_7, ((PyObject *)__pyx_v_y)) : __Pyx_PyObject_CallOneArg(__pyx_t_8, ((PyObject *)__pyx_v_y)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PySequence_List(__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_2 = ((PyObject*)__pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_12 = PyList_Sort(__pyx_t_2); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 184, __pyx_L1_error) + __pyx_t_8 = PyList_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_INCREF(__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_int_neg_1); + PyList_SET_ITEM(__pyx_t_8, 0, __pyx_int_neg_1); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyList_SET_ITEM(__pyx_t_8, 1, __pyx_int_1); + __pyx_t_6 = PyObject_RichCompare(__pyx_t_2, __pyx_t_8, Py_NE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":186 + * if sorted(np.unique(y)) != [-1, 1]: + * raise ValueError(f"expected y vector to only have two unique values (-1 and 1) (Binary Classification), " + * f"but got {np.unique(y)}") # <<<<<<<<<<<<<< + * + * if penalty == "L0": + */ + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_unique); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + __pyx_t_6 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_8, ((PyObject *)__pyx_v_y)) : __Pyx_PyObject_CallOneArg(__pyx_t_2, ((PyObject *)__pyx_v_y)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_6, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "l0learn/interface.pyx":185 + * if loss in CLASSIFICATION_LOSS: + * if sorted(np.unique(y)) != [-1, 1]: + * raise ValueError(f"expected y vector to only have two unique values (-1 and 1) (Binary Classification), " # <<<<<<<<<<<<<< + * f"but got {np.unique(y)}") + * + */ + __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_y_vector_to_only_have_t, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 185, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 185, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 185, __pyx_L1_error) + + /* "l0learn/interface.pyx":184 + * + * if loss in CLASSIFICATION_LOSS: + * if sorted(np.unique(y)) != [-1, 1]: # <<<<<<<<<<<<<< + * raise ValueError(f"expected y vector to only have two unique values (-1 and 1) (Binary Classification), " + * f"but got {np.unique(y)}") + */ + } + + /* "l0learn/interface.pyx":188 + * f"but got {np.unique(y)}") + * + * if penalty == "L0": # <<<<<<<<<<<<<< + * # TODO: Must be corrected in R code: https://github.com/hazimehh/L0Learn/blob/7a65474dfdb01489a0c263d7b24fbafad56fba61/R/fit.R#L136 + * # Pure L0 is not supported for classification + */ + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 188, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_1 != 0); + if (__pyx_t_4) { + + /* "l0learn/interface.pyx":193 + * # Below we add a small L2 component. + * + * if len(lambda_grid) != 1: # <<<<<<<<<<<<<< + * # If this error checking was left to the lower section, it would confuse users as + * # we are converting L0 to L0L2 with small L2 penalty. + */ + __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 193, __pyx_L1_error) + __pyx_t_4 = ((__pyx_t_9 != 1) != 0); + if (unlikely(__pyx_t_4)) { + + /* "l0learn/interface.pyx":198 + * # Here we must check if lambdaGrid is supplied (And thus use 'autolambda') + * # If 'lambdaGrid' is supplied, we must only supply 1 list of lambda values + * raise ValueError(f"L0 Penalty requires 'lambda_grid' to be a list of length 1, but got {lambda_grid}.") # <<<<<<<<<<<<<< + * + * penalty = "L0L2" + */ + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_L0_Penalty_requires_lambda_grid); + __pyx_t_9 += 68; + __Pyx_GIVEREF(__pyx_kp_u_L0_Penalty_requires_lambda_grid); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_u_L0_Penalty_requires_lambda_grid); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_kp_u__5); + __pyx_t_9 += 1; + __Pyx_GIVEREF(__pyx_kp_u__5); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_kp_u__5); + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_2, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 198, __pyx_L1_error) + + /* "l0learn/interface.pyx":193 + * # Below we add a small L2 component. + * + * if len(lambda_grid) != 1: # <<<<<<<<<<<<<< + * # If this error checking was left to the lower section, it would confuse users as + * # we are converting L0 to L0L2 with small L2 penalty. + */ + } + + /* "l0learn/interface.pyx":188 + * f"but got {np.unique(y)}") + * + * if penalty == "L0": # <<<<<<<<<<<<<< + * # TODO: Must be corrected in R code: https://github.com/hazimehh/L0Learn/blob/7a65474dfdb01489a0c263d7b24fbafad56fba61/R/fit.R#L136 + * # Pure L0 is not supported for classification + */ + } + + /* "l0learn/interface.pyx":200 + * raise ValueError(f"L0 Penalty requires 'lambda_grid' to be a list of length 1, but got {lambda_grid}.") + * + * penalty = "L0L2" # <<<<<<<<<<<<<< + * gamma_max = 1e-7 + * gamma_min = 1e-7 + */ + __Pyx_INCREF(__pyx_n_u_L0L2); + __Pyx_DECREF_SET(__pyx_v_penalty, __pyx_n_u_L0L2); + + /* "l0learn/interface.pyx":201 + * + * penalty = "L0L2" + * gamma_max = 1e-7 # <<<<<<<<<<<<<< + * gamma_min = 1e-7 + * + */ + __pyx_v_gamma_max = 1e-7; + + /* "l0learn/interface.pyx":202 + * penalty = "L0L2" + * gamma_max = 1e-7 + * gamma_min = 1e-7 # <<<<<<<<<<<<<< + * + * if lambda_grid is None: + */ + __pyx_v_gamma_min = 1e-7; + + /* "l0learn/interface.pyx":183 + * f"but got {intercept}") + * + * if loss in CLASSIFICATION_LOSS: # <<<<<<<<<<<<<< + * if sorted(np.unique(y)) != [-1, 1]: + * raise ValueError(f"expected y vector to only have two unique values (-1 and 1) (Binary Classification), " + */ + } + + /* "l0learn/interface.pyx":204 + * gamma_min = 1e-7 + * + * if lambda_grid is None: # <<<<<<<<<<<<<< + * lambda_grid = [[0.]] + * auto_lambda = True + */ + __pyx_t_4 = (__pyx_v_lambda_grid == Py_None); + __pyx_t_1 = (__pyx_t_4 != 0); + if (__pyx_t_1) { + + /* "l0learn/interface.pyx":205 + * + * if lambda_grid is None: + * lambda_grid = [[0.]] # <<<<<<<<<<<<<< + * auto_lambda = True + * if not isinstance(num_lambda, int) or num_lambda < 1: + */ + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 205, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_float_0_); + __Pyx_GIVEREF(__pyx_float_0_); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_float_0_); + __pyx_t_6 = PyList_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 205, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_2); + PyList_SET_ITEM(__pyx_t_6, 0, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_lambda_grid, __pyx_t_6); + __pyx_t_6 = 0; + + /* "l0learn/interface.pyx":206 + * if lambda_grid is None: + * lambda_grid = [[0.]] + * auto_lambda = True # <<<<<<<<<<<<<< + * if not isinstance(num_lambda, int) or num_lambda < 1: + * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") + */ + __pyx_v_auto_lambda = 1; + + /* "l0learn/interface.pyx":207 + * lambda_grid = [[0.]] + * auto_lambda = True + * if not isinstance(num_lambda, int) or num_lambda < 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") + * if not isinstance(num_gamma, int) or num_gamma < 1: + */ + __pyx_t_4 = PyInt_Check(__pyx_v_num_lambda); + __pyx_t_3 = ((!(__pyx_t_4 != 0)) != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L56_bool_binop_done; + } + __pyx_t_6 = PyObject_RichCompare(__pyx_v_num_lambda, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 207, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 207, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_1 = __pyx_t_3; + __pyx_L56_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":208 + * auto_lambda = True + * if not isinstance(num_lambda, int) or num_lambda < 1: + * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") # <<<<<<<<<<<<<< + * if not isinstance(num_gamma, int) or num_gamma < 1: + * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") + */ + __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 208, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_num_lambda_to_a_positiv); + __pyx_t_9 += 76; + __Pyx_GIVEREF(__pyx_kp_u_expected_num_lambda_to_a_positiv); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_num_lambda_to_a_positiv); + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 208, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_kp_u__5); + __pyx_t_9 += 1; + __Pyx_GIVEREF(__pyx_kp_u__5); + PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u__5); + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_6, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 208, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 208, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 208, __pyx_L1_error) + + /* "l0learn/interface.pyx":207 + * lambda_grid = [[0.]] + * auto_lambda = True + * if not isinstance(num_lambda, int) or num_lambda < 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") + * if not isinstance(num_gamma, int) or num_gamma < 1: + */ + } + + /* "l0learn/interface.pyx":209 + * if not isinstance(num_lambda, int) or num_lambda < 1: + * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") + * if not isinstance(num_gamma, int) or num_gamma < 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") + * if penalty == "L0" and num_gamma != 1: + */ + __pyx_t_3 = PyInt_Check(__pyx_v_num_gamma); + __pyx_t_4 = ((!(__pyx_t_3 != 0)) != 0); + if (!__pyx_t_4) { + } else { + __pyx_t_1 = __pyx_t_4; + goto __pyx_L59_bool_binop_done; + } + __pyx_t_6 = PyObject_RichCompare(__pyx_v_num_gamma, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 209, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 209, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_1 = __pyx_t_4; + __pyx_L59_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":210 + * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") + * if not isinstance(num_gamma, int) or num_gamma < 1: + * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") # <<<<<<<<<<<<<< + * if penalty == "L0" and num_gamma != 1: + * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") + */ + __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_num_gamma_to_a_positive); + __pyx_t_9 += 75; + __Pyx_GIVEREF(__pyx_kp_u_expected_num_gamma_to_a_positive); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_num_gamma_to_a_positive); + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_kp_u__5); + __pyx_t_9 += 1; + __Pyx_GIVEREF(__pyx_kp_u__5); + PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u__5); + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_6, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 210, __pyx_L1_error) + + /* "l0learn/interface.pyx":209 + * if not isinstance(num_lambda, int) or num_lambda < 1: + * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") + * if not isinstance(num_gamma, int) or num_gamma < 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") + * if penalty == "L0" and num_gamma != 1: + */ + } + + /* "l0learn/interface.pyx":211 + * if not isinstance(num_gamma, int) or num_gamma < 1: + * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") + * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") + * else: # lambda_grid should be a List[List[float]] + */ + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 211, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_4 != 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L62_bool_binop_done; + } + __pyx_t_6 = __Pyx_PyInt_NeObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 211, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 211, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_1 = __pyx_t_3; + __pyx_L62_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":212 + * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") + * if penalty == "L0" and num_gamma != 1: + * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") # <<<<<<<<<<<<<< + * else: # lambda_grid should be a List[List[float]] + * if num_gamma is not None: + */ + __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_num_gamma_to_1_when_pen); + __pyx_t_9 += 53; + __Pyx_GIVEREF(__pyx_kp_u_expected_num_gamma_to_1_when_pen); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_num_gamma_to_1_when_pen); + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_kp_u__5); + __pyx_t_9 += 1; + __Pyx_GIVEREF(__pyx_kp_u__5); + PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u__5); + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_6, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 212, __pyx_L1_error) + + /* "l0learn/interface.pyx":211 + * if not isinstance(num_gamma, int) or num_gamma < 1: + * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") + * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") + * else: # lambda_grid should be a List[List[float]] + */ + } + + /* "l0learn/interface.pyx":204 + * gamma_min = 1e-7 + * + * if lambda_grid is None: # <<<<<<<<<<<<<< + * lambda_grid = [[0.]] + * auto_lambda = True + */ + goto __pyx_L54; + } + + /* "l0learn/interface.pyx":214 + * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") + * else: # lambda_grid should be a List[List[float]] + * if num_gamma is not None: # <<<<<<<<<<<<<< + * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " + * f"but got {num_gamma}") + */ + /*else*/ { + __pyx_t_1 = (__pyx_v_num_gamma != Py_None); + __pyx_t_3 = (__pyx_t_1 != 0); + if (unlikely(__pyx_t_3)) { + + /* "l0learn/interface.pyx":216 + * if num_gamma is not None: + * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " + * f"but got {num_gamma}") # <<<<<<<<<<<<<< + * num_gamma = len(lambda_grid) + * + */ + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + + /* "l0learn/interface.pyx":215 + * else: # lambda_grid should be a List[List[float]] + * if num_gamma is not None: + * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " # <<<<<<<<<<<<<< + * f"but got {num_gamma}") + * num_gamma = len(lambda_grid) + */ + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_gamma_to_be_None_if, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 215, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 215, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 215, __pyx_L1_error) + + /* "l0learn/interface.pyx":214 + * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") + * else: # lambda_grid should be a List[List[float]] + * if num_gamma is not None: # <<<<<<<<<<<<<< + * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " + * f"but got {num_gamma}") + */ + } + + /* "l0learn/interface.pyx":217 + * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " + * f"but got {num_gamma}") + * num_gamma = len(lambda_grid) # <<<<<<<<<<<<<< + * + * if num_lambda is not None: + */ + __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 217, __pyx_L1_error) + __pyx_t_6 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF_SET(__pyx_v_num_gamma, __pyx_t_6); + __pyx_t_6 = 0; + + /* "l0learn/interface.pyx":219 + * num_gamma = len(lambda_grid) + * + * if num_lambda is not None: # <<<<<<<<<<<<<< + * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " + * f"but got {num_lambda}") + */ + __pyx_t_3 = (__pyx_v_num_lambda != Py_None); + __pyx_t_1 = (__pyx_t_3 != 0); + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":221 + * if num_lambda is not None: + * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " + * f"but got {num_lambda}") # <<<<<<<<<<<<<< + * num_lambda = 0 # This value is ignored. + * auto_lambda = False + */ + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 221, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + + /* "l0learn/interface.pyx":220 + * + * if num_lambda is not None: + * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " # <<<<<<<<<<<<<< + * f"but got {num_lambda}") + * num_lambda = 0 # This value is ignored. + */ + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_lambda_to_be_None_i, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 220, __pyx_L1_error) + + /* "l0learn/interface.pyx":219 + * num_gamma = len(lambda_grid) + * + * if num_lambda is not None: # <<<<<<<<<<<<<< + * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " + * f"but got {num_lambda}") + */ + } + + /* "l0learn/interface.pyx":222 + * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " + * f"but got {num_lambda}") + * num_lambda = 0 # This value is ignored. # <<<<<<<<<<<<<< + * auto_lambda = False + * bad_lambda_grid = False + */ + __Pyx_INCREF(__pyx_int_0); + __Pyx_DECREF_SET(__pyx_v_num_lambda, __pyx_int_0); + + /* "l0learn/interface.pyx":223 + * f"but got {num_lambda}") + * num_lambda = 0 # This value is ignored. + * auto_lambda = False # <<<<<<<<<<<<<< + * bad_lambda_grid = False + * + */ + __pyx_v_auto_lambda = 0; + + /* "l0learn/interface.pyx":224 + * num_lambda = 0 # This value is ignored. + * auto_lambda = False + * bad_lambda_grid = False # <<<<<<<<<<<<<< + * + * if penalty == "L0" and num_gamma != 1: + */ + __pyx_v_bad_lambda_grid = 0; + + /* "l0learn/interface.pyx":226 + * bad_lambda_grid = False + * + * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") + * + */ + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 226, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 != 0); + if (__pyx_t_4) { + } else { + __pyx_t_1 = __pyx_t_4; + goto __pyx_L67_bool_binop_done; + } + __pyx_t_6 = __Pyx_PyInt_NeObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_1 = __pyx_t_4; + __pyx_L67_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":227 + * + * if penalty == "L0" and num_gamma != 1: + * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") # <<<<<<<<<<<<<< + * + * for i, sub_lambda_grid in enumerate(lambda_grid): + */ + __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 227, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_9, 0, ' ', 'd'); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 227, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_of_lengt, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 227, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 227, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 227, __pyx_L1_error) + + /* "l0learn/interface.pyx":226 + * bad_lambda_grid = False + * + * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") + * + */ + } + + /* "l0learn/interface.pyx":229 + * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") + * + * for i, sub_lambda_grid in enumerate(lambda_grid): # <<<<<<<<<<<<<< + * current = float("inf") + * if sub_lambda_grid[0] <= 0: + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_t_6 = __pyx_int_0; + if (likely(PyList_CheckExact(__pyx_v_lambda_grid)) || PyTuple_CheckExact(__pyx_v_lambda_grid)) { + __pyx_t_2 = __pyx_v_lambda_grid; __Pyx_INCREF(__pyx_t_2); __pyx_t_9 = 0; + __pyx_t_13 = NULL; + } else { + __pyx_t_9 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_lambda_grid); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_13 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 229, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_13)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_8 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_9); __Pyx_INCREF(__pyx_t_8); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 229, __pyx_L1_error) + #else + __pyx_t_8 = PySequence_ITEM(__pyx_t_2, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + #endif + } else { + if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_9); __Pyx_INCREF(__pyx_t_8); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 229, __pyx_L1_error) + #else + __pyx_t_8 = PySequence_ITEM(__pyx_t_2, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + #endif + } + } else { + __pyx_t_8 = __pyx_t_13(__pyx_t_2); + if (unlikely(!__pyx_t_8)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 229, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_8); + } + __Pyx_XDECREF_SET(__pyx_v_sub_lambda_grid, __pyx_t_8); + __pyx_t_8 = 0; + __Pyx_INCREF(__pyx_t_6); + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_6); + __pyx_t_8 = __Pyx_PyInt_AddObjC(__pyx_t_6, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_6); + __pyx_t_6 = __pyx_t_8; + __pyx_t_8 = 0; + + /* "l0learn/interface.pyx":230 + * + * for i, sub_lambda_grid in enumerate(lambda_grid): + * current = float("inf") # <<<<<<<<<<<<<< + * if sub_lambda_grid[0] <= 0: + * raise ValueError(f"Expected all values of lambda_grid to be positive, " + */ + __pyx_t_14 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 230, __pyx_L1_error) + __pyx_v_current = __pyx_t_14; + + /* "l0learn/interface.pyx":231 + * for i, sub_lambda_grid in enumerate(lambda_grid): + * current = float("inf") + * if sub_lambda_grid[0] <= 0: # <<<<<<<<<<<<<< + * raise ValueError(f"Expected all values of lambda_grid to be positive, " + * f"but got lambda_grid[{i}] containing a negative value") + */ + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_sub_lambda_grid, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 231, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = PyObject_RichCompare(__pyx_t_8, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 231, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 231, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":232 + * current = float("inf") + * if sub_lambda_grid[0] <= 0: + * raise ValueError(f"Expected all values of lambda_grid to be positive, " # <<<<<<<<<<<<<< + * f"but got lambda_grid[{i}] containing a negative value") + * if any(np.diff(sub_lambda_grid) >= 0): + */ + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_15 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_Expected_all_values_of_lambda_gr); + __pyx_t_15 += 71; + __Pyx_GIVEREF(__pyx_kp_u_Expected_all_values_of_lambda_gr); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_Expected_all_values_of_lambda_gr); + + /* "l0learn/interface.pyx":233 + * if sub_lambda_grid[0] <= 0: + * raise ValueError(f"Expected all values of lambda_grid to be positive, " + * f"but got lambda_grid[{i}] containing a negative value") # <<<<<<<<<<<<<< + * if any(np.diff(sub_lambda_grid) >= 0): + * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " + */ + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; + __pyx_t_15 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_8); + __pyx_t_8 = 0; + __Pyx_INCREF(__pyx_kp_u_containing_a_negative_value); + __pyx_t_15 += 29; + __Pyx_GIVEREF(__pyx_kp_u_containing_a_negative_value); + PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_containing_a_negative_value); + + /* "l0learn/interface.pyx":232 + * current = float("inf") + * if sub_lambda_grid[0] <= 0: + * raise ValueError(f"Expected all values of lambda_grid to be positive, " # <<<<<<<<<<<<<< + * f"but got lambda_grid[{i}] containing a negative value") + * if any(np.diff(sub_lambda_grid) >= 0): + */ + __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(0, 232, __pyx_L1_error) + + /* "l0learn/interface.pyx":231 + * for i, sub_lambda_grid in enumerate(lambda_grid): + * current = float("inf") + * if sub_lambda_grid[0] <= 0: # <<<<<<<<<<<<<< + * raise ValueError(f"Expected all values of lambda_grid to be positive, " + * f"but got lambda_grid[{i}] containing a negative value") + */ + } + + /* "l0learn/interface.pyx":234 + * raise ValueError(f"Expected all values of lambda_grid to be positive, " + * f"but got lambda_grid[{i}] containing a negative value") + * if any(np.diff(sub_lambda_grid) >= 0): # <<<<<<<<<<<<<< + * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " + * f"but got lambda_grid[{i}] containing an increasing value.") + */ + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_diff); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_16); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_16))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_16); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_16); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_16, function); + } + } + __pyx_t_7 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_16, __pyx_t_8, __pyx_v_sub_lambda_grid) : __Pyx_PyObject_CallOneArg(__pyx_t_16, __pyx_v_sub_lambda_grid); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_16 = PyObject_RichCompare(__pyx_t_7, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_16); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_16); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":235 + * f"but got lambda_grid[{i}] containing a negative value") + * if any(np.diff(sub_lambda_grid) >= 0): + * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " # <<<<<<<<<<<<<< + * f"but got lambda_grid[{i}] containing an increasing value.") + * + */ + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_15 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_Expected_each_element_of_lambda); + __pyx_t_15 += 91; + __Pyx_GIVEREF(__pyx_kp_u_Expected_each_element_of_lambda); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_Expected_each_element_of_lambda); + + /* "l0learn/interface.pyx":236 + * if any(np.diff(sub_lambda_grid) >= 0): + * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " + * f"but got lambda_grid[{i}] containing an increasing value.") # <<<<<<<<<<<<<< + * + * n, p = X.shape + */ + __pyx_t_16 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_16); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_16) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_16) : __pyx_t_10; + __pyx_t_15 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_16); + __Pyx_GIVEREF(__pyx_t_16); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_16); + __pyx_t_16 = 0; + __Pyx_INCREF(__pyx_kp_u_containing_an_increasing_value); + __pyx_t_15 += 33; + __Pyx_GIVEREF(__pyx_kp_u_containing_an_increasing_value); + PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_containing_an_increasing_value); + + /* "l0learn/interface.pyx":235 + * f"but got lambda_grid[{i}] containing a negative value") + * if any(np.diff(sub_lambda_grid) >= 0): + * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " # <<<<<<<<<<<<<< + * f"but got lambda_grid[{i}] containing an increasing value.") + * + */ + __pyx_t_16 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_16); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_16); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(0, 235, __pyx_L1_error) + + /* "l0learn/interface.pyx":234 + * raise ValueError(f"Expected all values of lambda_grid to be positive, " + * f"but got lambda_grid[{i}] containing a negative value") + * if any(np.diff(sub_lambda_grid) >= 0): # <<<<<<<<<<<<<< + * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " + * f"but got lambda_grid[{i}] containing an increasing value.") + */ + } + + /* "l0learn/interface.pyx":229 + * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") + * + * for i, sub_lambda_grid in enumerate(lambda_grid): # <<<<<<<<<<<<<< + * current = float("inf") + * if sub_lambda_grid[0] <= 0: + */ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __pyx_L54:; + + /* "l0learn/interface.pyx":238 + * f"but got lambda_grid[{i}] containing an increasing value.") + * + * n, p = X.shape # <<<<<<<<<<<<<< + * with_bounds = False + * + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if ((likely(PyTuple_CheckExact(__pyx_t_6))) || (PyList_CheckExact(__pyx_t_6))) { + PyObject* sequence = __pyx_t_6; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 238, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_7 = PyTuple_GET_ITEM(sequence, 1); + } else { + __pyx_t_2 = PyList_GET_ITEM(sequence, 0); + __pyx_t_7 = PyList_GET_ITEM(sequence, 1); + } + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + #else + __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_16 = PyObject_GetIter(__pyx_t_6); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_16); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_11 = Py_TYPE(__pyx_t_16)->tp_iternext; + index = 0; __pyx_t_2 = __pyx_t_11(__pyx_t_16); if (unlikely(!__pyx_t_2)) goto __pyx_L73_unpacking_failed; + __Pyx_GOTREF(__pyx_t_2); + index = 1; __pyx_t_7 = __pyx_t_11(__pyx_t_16); if (unlikely(!__pyx_t_7)) goto __pyx_L73_unpacking_failed; + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_16), 2) < 0) __PYX_ERR(0, 238, __pyx_L1_error) + __pyx_t_11 = NULL; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + goto __pyx_L74_unpacking_done; + __pyx_L73_unpacking_failed:; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_11 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 238, __pyx_L1_error) + __pyx_L74_unpacking_done:; + } + __Pyx_DECREF_SET(__pyx_v_n, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_p, __pyx_t_7); + __pyx_t_7 = 0; + + /* "l0learn/interface.pyx":239 + * + * n, p = X.shape + * with_bounds = False # <<<<<<<<<<<<<< + * + * if isinstance(lows, float): + */ + __pyx_v_with_bounds = 0; + + /* "l0learn/interface.pyx":241 + * with_bounds = False + * + * if isinstance(lows, float): # <<<<<<<<<<<<<< + * if lows > 0: + * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") + */ + __pyx_t_1 = PyFloat_Check(__pyx_v_lows); + __pyx_t_4 = (__pyx_t_1 != 0); + if (__pyx_t_4) { + + /* "l0learn/interface.pyx":242 + * + * if isinstance(lows, float): + * if lows > 0: # <<<<<<<<<<<<<< + * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") + * elif lows > -float('inf'): + */ + __pyx_t_6 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_GT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 242, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(__pyx_t_4)) { + + /* "l0learn/interface.pyx":243 + * if isinstance(lows, float): + * if lows > 0: + * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") # <<<<<<<<<<<<<< + * elif lows > -float('inf'): + * with_bounds = True + */ + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lows_to_be_a_non_positi, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 243, __pyx_L1_error) + + /* "l0learn/interface.pyx":242 + * + * if isinstance(lows, float): + * if lows > 0: # <<<<<<<<<<<<<< + * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") + * elif lows > -float('inf'): + */ + } + + /* "l0learn/interface.pyx":244 + * if lows > 0: + * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") + * elif lows > -float('inf'): # <<<<<<<<<<<<<< + * with_bounds = True + * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): + */ + __pyx_t_14 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 244, __pyx_L1_error) + __pyx_t_6 = PyFloat_FromDouble((-__pyx_t_14)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 244, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyObject_RichCompare(__pyx_v_lows, __pyx_t_6, Py_GT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 244, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 244, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (__pyx_t_4) { + + /* "l0learn/interface.pyx":245 + * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") + * elif lows > -float('inf'): + * with_bounds = True # <<<<<<<<<<<<<< + * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): + * with_bounds = True + */ + __pyx_v_with_bounds = 1; + + /* "l0learn/interface.pyx":244 + * if lows > 0: + * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") + * elif lows > -float('inf'): # <<<<<<<<<<<<<< + * with_bounds = True + * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): + */ + } + + /* "l0learn/interface.pyx":241 + * with_bounds = False + * + * if isinstance(lows, float): # <<<<<<<<<<<<<< + * if lows > 0: + * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") + */ + goto __pyx_L75; + } + + /* "l0learn/interface.pyx":246 + * elif lows > -float('inf'): + * with_bounds = True + * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): # <<<<<<<<<<<<<< + * with_bounds = True + * else: + */ + __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_lows, __pyx_ptype_5numpy_ndarray); + __pyx_t_3 = (__pyx_t_1 != 0); + if (__pyx_t_3) { + } else { + __pyx_t_4 = __pyx_t_3; + goto __pyx_L77_bool_binop_done; + } + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_lows, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyInt_EqObjC(__pyx_t_7, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (__pyx_t_3) { + } else { + __pyx_t_4 = __pyx_t_3; + goto __pyx_L77_bool_binop_done; + } + __pyx_t_9 = PyObject_Length(__pyx_v_lows); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 246, __pyx_L1_error) + __pyx_t_6 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyObject_RichCompare(__pyx_t_6, __pyx_v_p, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (__pyx_t_3) { + } else { + __pyx_t_4 = __pyx_t_3; + goto __pyx_L77_bool_binop_done; + } + __pyx_t_7 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 246, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_all, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_4 = __pyx_t_3; + __pyx_L77_bool_binop_done:; + if (likely(__pyx_t_4)) { + + /* "l0learn/interface.pyx":247 + * with_bounds = True + * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): + * with_bounds = True # <<<<<<<<<<<<<< + * else: + * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " + */ + __pyx_v_with_bounds = 1; + + /* "l0learn/interface.pyx":246 + * elif lows > -float('inf'): + * with_bounds = True + * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): # <<<<<<<<<<<<<< + * with_bounds = True + * else: + */ + goto __pyx_L75; + } + + /* "l0learn/interface.pyx":249 + * with_bounds = True + * else: + * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " # <<<<<<<<<<<<<< + * f"floats, but got {lows}") + * + */ + /*else*/ { + __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_lows_to_be_a_non_positi_2); + __pyx_t_9 += 72; + __Pyx_GIVEREF(__pyx_kp_u_expected_lows_to_be_a_non_positi_2); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_lows_to_be_a_non_positi_2); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_7); + __pyx_t_7 = 0; + __Pyx_INCREF(__pyx_kp_u_of_non_positives_floats_but_got); + __pyx_t_9 += 34; + __Pyx_GIVEREF(__pyx_kp_u_of_non_positives_floats_but_got); + PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u_of_non_positives_floats_but_got); + + /* "l0learn/interface.pyx":250 + * else: + * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " + * f"floats, but got {lows}") # <<<<<<<<<<<<<< + * + * if isinstance(highs, float): + */ + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_7); + __pyx_t_7 = 0; + + /* "l0learn/interface.pyx":249 + * with_bounds = True + * else: + * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " # <<<<<<<<<<<<<< + * f"floats, but got {lows}") + * + */ + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_6, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 249, __pyx_L1_error) + } + __pyx_L75:; + + /* "l0learn/interface.pyx":252 + * f"floats, but got {lows}") + * + * if isinstance(highs, float): # <<<<<<<<<<<<<< + * if highs < 0: + * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") + */ + __pyx_t_4 = PyFloat_Check(__pyx_v_highs); + __pyx_t_3 = (__pyx_t_4 != 0); + if (__pyx_t_3) { + + /* "l0learn/interface.pyx":253 + * + * if isinstance(highs, float): + * if highs < 0: # <<<<<<<<<<<<<< + * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") + * if highs < float('inf'): + */ + __pyx_t_6 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 253, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 253, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(__pyx_t_3)) { + + /* "l0learn/interface.pyx":254 + * if isinstance(highs, float): + * if highs < 0: + * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") # <<<<<<<<<<<<<< + * if highs < float('inf'): + * with_bounds = True + */ + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_highs_to_be_a_non_negat, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 254, __pyx_L1_error) + + /* "l0learn/interface.pyx":253 + * + * if isinstance(highs, float): + * if highs < 0: # <<<<<<<<<<<<<< + * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") + * if highs < float('inf'): + */ + } + + /* "l0learn/interface.pyx":255 + * if highs < 0: + * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") + * if highs < float('inf'): # <<<<<<<<<<<<<< + * with_bounds = True + * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): + */ + __pyx_t_6 = __Pyx_PyNumber_Float(__pyx_n_u_inf); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyObject_RichCompare(__pyx_v_highs, __pyx_t_6, Py_LT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 255, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 255, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (__pyx_t_3) { + + /* "l0learn/interface.pyx":256 + * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") + * if highs < float('inf'): + * with_bounds = True # <<<<<<<<<<<<<< + * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): + * with_bounds = True + */ + __pyx_v_with_bounds = 1; + + /* "l0learn/interface.pyx":255 + * if highs < 0: + * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") + * if highs < float('inf'): # <<<<<<<<<<<<<< + * with_bounds = True + * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): + */ + } + + /* "l0learn/interface.pyx":252 + * f"floats, but got {lows}") + * + * if isinstance(highs, float): # <<<<<<<<<<<<<< + * if highs < 0: + * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") + */ + goto __pyx_L81; + } + + /* "l0learn/interface.pyx":257 + * if highs < float('inf'): + * with_bounds = True + * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): # <<<<<<<<<<<<<< + * with_bounds = True + * else: + */ + __pyx_t_4 = __Pyx_TypeCheck(__pyx_v_highs, __pyx_ptype_5numpy_ndarray); + __pyx_t_1 = (__pyx_t_4 != 0); + if (__pyx_t_1) { + } else { + __pyx_t_3 = __pyx_t_1; + goto __pyx_L84_bool_binop_done; + } + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_highs, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 257, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyInt_EqObjC(__pyx_t_7, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 257, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 257, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (__pyx_t_1) { + } else { + __pyx_t_3 = __pyx_t_1; + goto __pyx_L84_bool_binop_done; + } + __pyx_t_9 = PyObject_Length(__pyx_v_highs); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 257, __pyx_L1_error) + __pyx_t_6 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 257, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyObject_RichCompare(__pyx_t_6, __pyx_v_p, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 257, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 257, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (__pyx_t_1) { + } else { + __pyx_t_3 = __pyx_t_1; + goto __pyx_L84_bool_binop_done; + } + __pyx_t_7 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 257, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 257, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_3 = __pyx_t_1; + __pyx_L84_bool_binop_done:; + if (likely(__pyx_t_3)) { + + /* "l0learn/interface.pyx":258 + * with_bounds = True + * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): + * with_bounds = True # <<<<<<<<<<<<<< + * else: + * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " + */ + __pyx_v_with_bounds = 1; + + /* "l0learn/interface.pyx":257 + * if highs < float('inf'): + * with_bounds = True + * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): # <<<<<<<<<<<<<< + * with_bounds = True + * else: + */ + goto __pyx_L81; + } + + /* "l0learn/interface.pyx":260 + * with_bounds = True + * else: + * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " # <<<<<<<<<<<<<< + * f"non-negative floats, but got {highs}") + * + */ + /*else*/ { + __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_highs_to_be_a_non_negat_2); + __pyx_t_9 += 73; + __Pyx_GIVEREF(__pyx_kp_u_expected_highs_to_be_a_non_negat_2); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_highs_to_be_a_non_negat_2); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_kp_u_of_non_negative_floats_but_got); + __pyx_t_9 += 33; + __Pyx_GIVEREF(__pyx_kp_u_of_non_negative_floats_but_got); + PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_of_non_negative_floats_but_got); + + /* "l0learn/interface.pyx":261 + * else: + * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " + * f"non-negative floats, but got {highs}") # <<<<<<<<<<<<<< + * + * if with_bounds: + */ + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_6); + __pyx_t_6 = 0; + + /* "l0learn/interface.pyx":260 + * with_bounds = True + * else: + * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " # <<<<<<<<<<<<<< + * f"non-negative floats, but got {highs}") + * + */ + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(0, 260, __pyx_L1_error) + } + __pyx_L81:; + + /* "l0learn/interface.pyx":263 + * f"non-negative floats, but got {highs}") + * + * if with_bounds: # <<<<<<<<<<<<<< + * if isinstance(lows, float): + * lows = np.ones(p) * lows + */ + __pyx_t_3 = (__pyx_v_with_bounds != 0); + if (__pyx_t_3) { + + /* "l0learn/interface.pyx":264 + * + * if with_bounds: + * if isinstance(lows, float): # <<<<<<<<<<<<<< + * lows = np.ones(p) * lows + * if isinstance(highs, float): + */ + __pyx_t_3 = PyFloat_Check(__pyx_v_lows); + __pyx_t_1 = (__pyx_t_3 != 0); + if (__pyx_t_1) { + + /* "l0learn/interface.pyx":265 + * if with_bounds: + * if isinstance(lows, float): + * lows = np.ones(p) * lows # <<<<<<<<<<<<<< + * if isinstance(highs, float): + * highs = np.ones(p) * highs + */ + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_ones); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + __pyx_t_7 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_6, __pyx_v_p) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_p); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyNumber_Multiply(__pyx_t_7, __pyx_v_lows); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_2); + __pyx_t_2 = 0; + + /* "l0learn/interface.pyx":264 + * + * if with_bounds: + * if isinstance(lows, float): # <<<<<<<<<<<<<< + * lows = np.ones(p) * lows + * if isinstance(highs, float): + */ + } + + /* "l0learn/interface.pyx":266 + * if isinstance(lows, float): + * lows = np.ones(p) * lows + * if isinstance(highs, float): # <<<<<<<<<<<<<< + * highs = np.ones(p) * highs + * + */ + __pyx_t_1 = PyFloat_Check(__pyx_v_highs); + __pyx_t_3 = (__pyx_t_1 != 0); + if (__pyx_t_3) { + + /* "l0learn/interface.pyx":267 + * lows = np.ones(p) * lows + * if isinstance(highs, float): + * highs = np.ones(p) * highs # <<<<<<<<<<<<<< + * + * if any(lows >= highs): + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ones); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + __pyx_t_2 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_v_p) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_p); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = PyNumber_Multiply(__pyx_t_2, __pyx_v_highs); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_6); + __pyx_t_6 = 0; + + /* "l0learn/interface.pyx":266 + * if isinstance(lows, float): + * lows = np.ones(p) * lows + * if isinstance(highs, float): # <<<<<<<<<<<<<< + * highs = np.ones(p) * highs + * + */ + } + + /* "l0learn/interface.pyx":269 + * highs = np.ones(p) * highs + * + * if any(lows >= highs): # <<<<<<<<<<<<<< + * bad_bounds = np.argwhere(lows >= highs) + * raise ValueError(f"expected to be high to be elementwise greater than lows, " + */ + __pyx_t_6 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 269, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 269, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 269, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(__pyx_t_3)) { + + /* "l0learn/interface.pyx":270 + * + * if any(lows >= highs): + * bad_bounds = np.argwhere(lows >= highs) # <<<<<<<<<<<<<< + * raise ValueError(f"expected to be high to be elementwise greater than lows, " + * f"but got indices {bad_bounds[0]} where that is not the case ") + */ + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 270, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_argwhere); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 270, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 270, __pyx_L1_error) + __pyx_t_16 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_16)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_16); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + __pyx_t_2 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_16, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); + __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 270, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_v_bad_bounds = __pyx_t_2; + __pyx_t_2 = 0; + + /* "l0learn/interface.pyx":271 + * if any(lows >= highs): + * bad_bounds = np.argwhere(lows >= highs) + * raise ValueError(f"expected to be high to be elementwise greater than lows, " # <<<<<<<<<<<<<< + * f"but got indices {bad_bounds[0]} where that is not the case ") + * else: + */ + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 271, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_to_be_high_to_be_elemen); + __pyx_t_9 += 73; + __Pyx_GIVEREF(__pyx_kp_u_expected_to_be_high_to_be_elemen); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_u_expected_to_be_high_to_be_elemen); + + /* "l0learn/interface.pyx":272 + * bad_bounds = np.argwhere(lows >= highs) + * raise ValueError(f"expected to be high to be elementwise greater than lows, " + * f"but got indices {bad_bounds[0]} where that is not the case ") # <<<<<<<<<<<<<< + * else: + * lows = np.array([0.]) + */ + __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_bad_bounds, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 272, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 272, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_kp_u_where_that_is_not_the_case); + __pyx_t_9 += 28; + __Pyx_GIVEREF(__pyx_kp_u_where_that_is_not_the_case); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_kp_u_where_that_is_not_the_case); + + /* "l0learn/interface.pyx":271 + * if any(lows >= highs): + * bad_bounds = np.argwhere(lows >= highs) + * raise ValueError(f"expected to be high to be elementwise greater than lows, " # <<<<<<<<<<<<<< + * f"but got indices {bad_bounds[0]} where that is not the case ") + * else: + */ + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_2, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 271, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 271, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 271, __pyx_L1_error) + + /* "l0learn/interface.pyx":269 + * highs = np.ones(p) * highs + * + * if any(lows >= highs): # <<<<<<<<<<<<<< + * bad_bounds = np.argwhere(lows >= highs) + * raise ValueError(f"expected to be high to be elementwise greater than lows, " + */ + } + + /* "l0learn/interface.pyx":263 + * f"non-negative floats, but got {highs}") + * + * if with_bounds: # <<<<<<<<<<<<<< + * if isinstance(lows, float): + * lows = np.ones(p) * lows + */ + goto __pyx_L88; + } + + /* "l0learn/interface.pyx":274 + * f"but got indices {bad_bounds[0]} where that is not the case ") + * else: + * lows = np.array([0.]) # <<<<<<<<<<<<<< + * highs = np.array(([0.])) + * + */ + /*else*/ { + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_array); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = PyList_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_INCREF(__pyx_float_0_); + __Pyx_GIVEREF(__pyx_float_0_); + PyList_SET_ITEM(__pyx_t_6, 0, __pyx_float_0_); + __pyx_t_16 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_16)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_16); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + __pyx_t_2 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_16, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); + __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_2); + __pyx_t_2 = 0; + + /* "l0learn/interface.pyx":275 + * else: + * lows = np.array([0.]) + * highs = np.array(([0.])) # <<<<<<<<<<<<<< + * + * cdef vector[vector[double]] c_lambda_grid + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 275, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_array); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 275, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyList_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 275, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_INCREF(__pyx_float_0_); + __Pyx_GIVEREF(__pyx_float_0_); + PyList_SET_ITEM(__pyx_t_7, 0, __pyx_float_0_); + __pyx_t_16 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_16)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_16); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + __pyx_t_2 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_16, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); + __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 275, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_2); + __pyx_t_2 = 0; + } + __pyx_L88:; + + /* "l0learn/interface.pyx":278 + * + * cdef vector[vector[double]] c_lambda_grid + * try: # <<<<<<<<<<<<<< + * c_lambda_grid = lambda_grid + * except TypeError: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19); + __Pyx_XGOTREF(__pyx_t_17); + __Pyx_XGOTREF(__pyx_t_18); + __Pyx_XGOTREF(__pyx_t_19); + /*try:*/ { + + /* "l0learn/interface.pyx":279 + * cdef vector[vector[double]] c_lambda_grid + * try: + * c_lambda_grid = lambda_grid # <<<<<<<<<<<<<< + * except TypeError: + * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") + */ + __pyx_t_20 = __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_lambda_grid); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 279, __pyx_L92_error) + __pyx_v_c_lambda_grid = __pyx_t_20; + + /* "l0learn/interface.pyx":278 + * + * cdef vector[vector[double]] c_lambda_grid + * try: # <<<<<<<<<<<<<< + * c_lambda_grid = lambda_grid + * except TypeError: + */ + } + __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; + __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; + goto __pyx_L97_try_end; + __pyx_L92_error:; + __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "l0learn/interface.pyx":280 + * try: + * c_lambda_grid = lambda_grid + * except TypeError: # <<<<<<<<<<<<<< + * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") + * + */ + __pyx_t_21 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); + if (__pyx_t_21) { + __Pyx_AddTraceback("l0learn.interface.fit", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(0, 280, __pyx_L94_except_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + + /* "l0learn/interface.pyx":281 + * c_lambda_grid = lambda_grid + * except TypeError: + * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") # <<<<<<<<<<<<<< + * + * cdef string c_loss = loss.encode('UTF-8') + */ + __pyx_t_16 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 281, __pyx_L94_except_error) + __Pyx_GOTREF(__pyx_t_16); + __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_be_a_lis, __pyx_t_16); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 281, __pyx_L94_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_16 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 281, __pyx_L94_except_error) + __Pyx_GOTREF(__pyx_t_16); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_Raise(__pyx_t_16, 0, 0, 0); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __PYX_ERR(0, 281, __pyx_L94_except_error) + } + goto __pyx_L94_except_error; + __pyx_L94_except_error:; + + /* "l0learn/interface.pyx":278 + * + * cdef vector[vector[double]] c_lambda_grid + * try: # <<<<<<<<<<<<<< + * c_lambda_grid = lambda_grid + * except TypeError: + */ + __Pyx_XGIVEREF(__pyx_t_17); + __Pyx_XGIVEREF(__pyx_t_18); + __Pyx_XGIVEREF(__pyx_t_19); + __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_18, __pyx_t_19); + goto __pyx_L1_error; + __pyx_L97_try_end:; + } + + /* "l0learn/interface.pyx":283 + * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") + * + * cdef string c_loss = loss.encode('UTF-8') # <<<<<<<<<<<<<< + * cdef string c_penalty = penalty.encode('UTF-8') + * cdef string c_algorithim = algorithm.encode('UTF-8') + */ + if (unlikely(__pyx_v_loss == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); + __PYX_ERR(0, 283, __pyx_L1_error) + } + __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_loss); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 283, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 283, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_v_c_loss = __pyx_t_22; + + /* "l0learn/interface.pyx":284 + * + * cdef string c_loss = loss.encode('UTF-8') + * cdef string c_penalty = penalty.encode('UTF-8') # <<<<<<<<<<<<<< + * cdef string c_algorithim = algorithm.encode('UTF-8') + * + */ + if (unlikely(__pyx_v_penalty == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); + __PYX_ERR(0, 284, __pyx_L1_error) + } + __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_penalty); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 284, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_v_c_penalty = __pyx_t_22; + + /* "l0learn/interface.pyx":285 + * cdef string c_loss = loss.encode('UTF-8') + * cdef string c_penalty = penalty.encode('UTF-8') + * cdef string c_algorithim = algorithm.encode('UTF-8') # <<<<<<<<<<<<<< + * + * cdef fitmodel results + */ + if (unlikely(__pyx_v_algorithm == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); + __PYX_ERR(0, 285, __pyx_L1_error) + } + __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_algorithm); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 285, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_v_c_algorithim = __pyx_t_22; + + /* "l0learn/interface.pyx":288 + * + * cdef fitmodel results + * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< + * results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), + * y=numpy_to_dvec_d(y), + */ + __pyx_t_3 = __Pyx_TypeCheck(__pyx_v_X, __pyx_ptype_5numpy_ndarray); + __pyx_t_1 = (__pyx_t_3 != 0); + if (__pyx_t_1) { + + /* "l0learn/interface.pyx":289 + * cdef fitmodel results + * if isinstance(X, np.ndarray): + * results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< + * y=numpy_to_dvec_d(y), + * Loss=c_loss, + */ + if (!(likely(((__pyx_v_X) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_X, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 289, __pyx_L1_error) + + /* "l0learn/interface.pyx":294 + * Penalty=c_penalty, + * Algorithm=c_algorithim, + * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< + * G_ncols=num_lambda, + * G_nrows=num_gamma, + */ + __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 294, __pyx_L1_error) + + /* "l0learn/interface.pyx":295 + * Algorithm=c_algorithim, + * NnzStopNum=max_support_size, + * G_ncols=num_lambda, # <<<<<<<<<<<<<< + * G_nrows=num_gamma, + * Lambda2Max=gamma_max, + */ + __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 295, __pyx_L1_error) + + /* "l0learn/interface.pyx":296 + * NnzStopNum=max_support_size, + * G_ncols=num_lambda, + * G_nrows=num_gamma, # <<<<<<<<<<<<<< + * Lambda2Max=gamma_max, + * Lambda2Min=gamma_min, + */ + __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 296, __pyx_L1_error) + + /* "l0learn/interface.pyx":299 + * Lambda2Max=gamma_max, + * Lambda2Min=gamma_min, + * PartialSort=partial_sort, # <<<<<<<<<<<<<< + * MaxIters=max_iter, + * rtol=rtol, + */ + __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 299, __pyx_L1_error) + + /* "l0learn/interface.pyx":300 + * Lambda2Min=gamma_min, + * PartialSort=partial_sort, + * MaxIters=max_iter, # <<<<<<<<<<<<<< + * rtol=rtol, + * atol=atol, + */ + __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 300, __pyx_L1_error) + + /* "l0learn/interface.pyx":303 + * rtol=rtol, + * atol=atol, + * ActiveSet=active_set, # <<<<<<<<<<<<<< + * ActiveSetNum=active_set_num, + * MaxNumSwaps=max_swaps, + */ + __pyx_t_28 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_28 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 303, __pyx_L1_error) + + /* "l0learn/interface.pyx":304 + * atol=atol, + * ActiveSet=active_set, + * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< + * MaxNumSwaps=max_swaps, + * ScaleDownFactor=scale_down_factor, + */ + __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 304, __pyx_L1_error) + + /* "l0learn/interface.pyx":305 + * ActiveSet=active_set, + * ActiveSetNum=active_set_num, + * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< + * ScaleDownFactor=scale_down_factor, + * ScreenSize=screen_size, + */ + __pyx_t_30 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_30 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 305, __pyx_L1_error) + + /* "l0learn/interface.pyx":307 + * MaxNumSwaps=max_swaps, + * ScaleDownFactor=scale_down_factor, + * ScreenSize=screen_size, # <<<<<<<<<<<<<< + * LambdaU=not auto_lambda, + * Lambdas=c_lambda_grid, + */ + __pyx_t_31 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_31 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 307, __pyx_L1_error) + + /* "l0learn/interface.pyx":310 + * LambdaU=not auto_lambda, + * Lambdas=c_lambda_grid, + * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< + * Intercept=intercept, + * withBounds=with_bounds, + */ + __pyx_t_32 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_32 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 310, __pyx_L1_error) + + /* "l0learn/interface.pyx":311 + * Lambdas=c_lambda_grid, + * ExcludeFirstK=exclude_first_k, + * Intercept=intercept, # <<<<<<<<<<<<<< + * withBounds=with_bounds, + * Lows=numpy_to_dvec_d(lows), + */ + __pyx_t_33 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_33 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 311, __pyx_L1_error) + + /* "l0learn/interface.pyx":313 + * Intercept=intercept, + * withBounds=with_bounds, + * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< + * Highs=numpy_to_dvec_d(highs)) + * else: # isinstance(X, csc_matrix) + */ + if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 313, __pyx_L1_error) + + /* "l0learn/interface.pyx":314 + * withBounds=with_bounds, + * Lows=numpy_to_dvec_d(lows), + * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< + * else: # isinstance(X, csc_matrix) + * results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), + */ + if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 314, __pyx_L1_error) + + /* "l0learn/interface.pyx":289 + * cdef fitmodel results + * if isinstance(X, np.ndarray): + * results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< + * y=numpy_to_dvec_d(y), + * Loss=c_loss, + */ + __pyx_v_results = __pyx_f_7l0learn_9interface__L0LearnFit_dense(__pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_X)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_23, __pyx_t_24, __pyx_t_25, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_26, __pyx_t_27, __pyx_v_rtol, __pyx_v_atol, __pyx_t_28, __pyx_t_29, __pyx_t_30, __pyx_v_scale_down_factor, __pyx_t_31, (!(__pyx_v_auto_lambda != 0)), __pyx_v_c_lambda_grid, __pyx_t_32, __pyx_t_33, __pyx_v_with_bounds, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); + + /* "l0learn/interface.pyx":288 + * + * cdef fitmodel results + * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< + * results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), + * y=numpy_to_dvec_d(y), + */ + goto __pyx_L100; + } + + /* "l0learn/interface.pyx":316 + * Highs=numpy_to_dvec_d(highs)) + * else: # isinstance(X, csc_matrix) + * results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< + * y=numpy_to_dvec_d(y), + * Loss=c_loss, + */ + /*else*/ { + + /* "l0learn/interface.pyx":321 + * Penalty=c_penalty, + * Algorithm=c_algorithim, + * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< + * G_ncols=num_lambda, + * G_nrows=num_gamma, + */ + __pyx_t_32 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_32 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 321, __pyx_L1_error) + + /* "l0learn/interface.pyx":322 + * Algorithm=c_algorithim, + * NnzStopNum=max_support_size, + * G_ncols=num_lambda, # <<<<<<<<<<<<<< + * G_nrows=num_gamma, + * Lambda2Max=gamma_max, + */ + __pyx_t_31 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_31 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 322, __pyx_L1_error) + + /* "l0learn/interface.pyx":323 + * NnzStopNum=max_support_size, + * G_ncols=num_lambda, + * G_nrows=num_gamma, # <<<<<<<<<<<<<< + * Lambda2Max=gamma_max, + * Lambda2Min=gamma_min, + */ + __pyx_t_30 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_30 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 323, __pyx_L1_error) + + /* "l0learn/interface.pyx":326 + * Lambda2Max=gamma_max, + * Lambda2Min=gamma_min, + * PartialSort=partial_sort, # <<<<<<<<<<<<<< + * MaxIters=max_iter, + * rtol=rtol, + */ + __pyx_t_33 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_33 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 326, __pyx_L1_error) + + /* "l0learn/interface.pyx":327 + * Lambda2Min=gamma_min, + * PartialSort=partial_sort, + * MaxIters=max_iter, # <<<<<<<<<<<<<< + * rtol=rtol, + * atol=atol, + */ + __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 327, __pyx_L1_error) + + /* "l0learn/interface.pyx":330 + * rtol=rtol, + * atol=atol, + * ActiveSet=active_set, # <<<<<<<<<<<<<< + * ActiveSetNum=active_set_num, + * MaxNumSwaps=max_swaps, + */ + __pyx_t_28 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_28 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 330, __pyx_L1_error) + + /* "l0learn/interface.pyx":331 + * atol=atol, + * ActiveSet=active_set, + * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< + * MaxNumSwaps=max_swaps, + * ScaleDownFactor=scale_down_factor, + */ + __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 331, __pyx_L1_error) + + /* "l0learn/interface.pyx":332 + * ActiveSet=active_set, + * ActiveSetNum=active_set_num, + * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< + * ScaleDownFactor=scale_down_factor, + * ScreenSize=screen_size, + */ + __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 332, __pyx_L1_error) + + /* "l0learn/interface.pyx":334 + * MaxNumSwaps=max_swaps, + * ScaleDownFactor=scale_down_factor, + * ScreenSize=screen_size, # <<<<<<<<<<<<<< + * LambdaU=not auto_lambda, + * Lambdas=c_lambda_grid, + */ + __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 334, __pyx_L1_error) + + /* "l0learn/interface.pyx":337 + * LambdaU=not auto_lambda, + * Lambdas=c_lambda_grid, + * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< + * Intercept=intercept, + * withBounds=with_bounds, + */ + __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 337, __pyx_L1_error) + + /* "l0learn/interface.pyx":338 + * Lambdas=c_lambda_grid, + * ExcludeFirstK=exclude_first_k, + * Intercept=intercept, # <<<<<<<<<<<<<< + * withBounds=with_bounds, + * Lows=numpy_to_dvec_d(lows), + */ + __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 338, __pyx_L1_error) + + /* "l0learn/interface.pyx":340 + * Intercept=intercept, + * withBounds=with_bounds, + * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< + * Highs=numpy_to_dvec_d(highs)) + * + */ + if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 340, __pyx_L1_error) + + /* "l0learn/interface.pyx":341 + * withBounds=with_bounds, + * Lows=numpy_to_dvec_d(lows), + * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< + * + * return {"NnzCount": results.NnzCount, + */ + if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 341, __pyx_L1_error) + + /* "l0learn/interface.pyx":316 + * Highs=numpy_to_dvec_d(highs)) + * else: # isinstance(X, csc_matrix) + * results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< + * y=numpy_to_dvec_d(y), + * Loss=c_loss, + */ + __pyx_v_results = __pyx_f_7l0learn_9interface__L0LearnFit_sparse(__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(__pyx_v_X), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_32, __pyx_t_31, __pyx_t_30, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_33, __pyx_t_29, __pyx_v_rtol, __pyx_v_atol, __pyx_t_28, __pyx_t_27, __pyx_t_25, __pyx_v_scale_down_factor, __pyx_t_24, (!(__pyx_v_auto_lambda != 0)), __pyx_v_c_lambda_grid, __pyx_t_23, __pyx_t_26, __pyx_v_with_bounds, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); + } + __pyx_L100:; + + /* "l0learn/interface.pyx":343 + * Highs=numpy_to_dvec_d(highs)) + * + * return {"NnzCount": results.NnzCount, # <<<<<<<<<<<<<< + * "Lambda0": results.Lambda0, + * "Lambda12": results.Lambda12, + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_7 = __Pyx_PyDict_NewPresized(6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 343, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(__pyx_v_results.NnzCount); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 343, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_NnzCount, __pyx_t_6) < 0) __PYX_ERR(0, 343, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "l0learn/interface.pyx":344 + * + * return {"NnzCount": results.NnzCount, + * "Lambda0": results.Lambda0, # <<<<<<<<<<<<<< + * "Lambda12": results.Lambda12, + * "Beta": sp_dmat_field_to_list(results.Beta), + */ + __pyx_t_6 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_results.Lambda0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 344, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_Lambda0, __pyx_t_6) < 0) __PYX_ERR(0, 343, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "l0learn/interface.pyx":345 + * return {"NnzCount": results.NnzCount, + * "Lambda0": results.Lambda0, + * "Lambda12": results.Lambda12, # <<<<<<<<<<<<<< + * "Beta": sp_dmat_field_to_list(results.Beta), + * "Intercept": results.Intercept, + */ + __pyx_t_6 = __pyx_convert_vector_to_py_double(__pyx_v_results.Lambda12); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 345, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_Lambda12, __pyx_t_6) < 0) __PYX_ERR(0, 343, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "l0learn/interface.pyx":346 + * "Lambda0": results.Lambda0, + * "Lambda12": results.Lambda12, + * "Beta": sp_dmat_field_to_list(results.Beta), # <<<<<<<<<<<<<< + * "Intercept": results.Intercept, + * "Converged": results.Converged} + */ + __pyx_t_6 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_results.Beta); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 346, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_Beta, __pyx_t_6) < 0) __PYX_ERR(0, 343, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "l0learn/interface.pyx":347 + * "Lambda12": results.Lambda12, + * "Beta": sp_dmat_field_to_list(results.Beta), + * "Intercept": results.Intercept, # <<<<<<<<<<<<<< + * "Converged": results.Converged} + * + */ + __pyx_t_6 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_results.Intercept); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_Intercept, __pyx_t_6) < 0) __PYX_ERR(0, 343, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "l0learn/interface.pyx":348 + * "Beta": sp_dmat_field_to_list(results.Beta), + * "Intercept": results.Intercept, + * "Converged": results.Converged} # <<<<<<<<<<<<<< + * + * def cvfit(X: Union[np.ndarray, csc_matrix], + */ + __pyx_t_6 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(__pyx_v_results.Converged); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 348, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_Converged, __pyx_t_6) < 0) __PYX_ERR(0, 343, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_r = __pyx_t_7; + __pyx_t_7 = 0; + goto __pyx_L0; + + /* "l0learn/interface.pyx":62 + * + * + * def fit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< + * y: np.ndarray, + * loss: str = "SquaredHinge", + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_16); + __Pyx_AddTraceback("l0learn.interface.fit", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XDECREF(__pyx_v_p); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XDECREF(__pyx_v_sub_lambda_grid); + __Pyx_XDECREF(__pyx_v_bad_bounds); + __Pyx_XDECREF(__pyx_v_penalty); + __Pyx_XDECREF(__pyx_v_num_lambda); + __Pyx_XDECREF(__pyx_v_num_gamma); + __Pyx_XDECREF(__pyx_v_lambda_grid); + __Pyx_XDECREF(__pyx_v_lows); + __Pyx_XDECREF(__pyx_v_highs); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/interface.pyx":350 + * "Converged": results.Converged} + * + * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< + * y: np.ndarray, + * loss: str = "SquaredHinge", + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_7l0learn_9interface_4cvfit[] = "cvfit(X: Union[np.ndarray, csc_matrix], ndarray y: np.ndarray, unicode loss: str = u'SquaredHinge', unicode penalty: str = u'L0', unicode algorithm: str = u'CD', num_folds: int = 10, seed: int = 1, max_support_size: int = 100, num_lambda: Optional[int] = 100, num_gamma: Optional[int] = 1, double gamma_max: float = 10., double gamma_min: float = .0001, partial_sort: bool = True, max_iter: int = 200, double rtol: float = 1e-6, double atol: float = 1e-9, active_set: bool = True, active_set_num: int = 3, max_swaps: int = 100, double scale_down_factor: float = 0.8, screen_size: int = 1000, lambda_grid: Optional[List[List[float]]] = None, exclude_first_k: int = 0, intercept: bool = True, lows: Union[np.ndarray, float] = -float(u'inf'), highs: Union[np.ndarray, float] = +float(u'inf'))"; +static PyMethodDef __pyx_mdef_7l0learn_9interface_5cvfit = {"cvfit", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7l0learn_9interface_5cvfit, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7l0learn_9interface_4cvfit}; +static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_X = 0; + PyArrayObject *__pyx_v_y = 0; + PyObject *__pyx_v_loss = 0; + PyObject *__pyx_v_penalty = 0; + PyObject *__pyx_v_algorithm = 0; + PyObject *__pyx_v_num_folds = 0; + PyObject *__pyx_v_seed = 0; + PyObject *__pyx_v_max_support_size = 0; + PyObject *__pyx_v_num_lambda = 0; + PyObject *__pyx_v_num_gamma = 0; + double __pyx_v_gamma_max; + double __pyx_v_gamma_min; + PyObject *__pyx_v_partial_sort = 0; + PyObject *__pyx_v_max_iter = 0; + double __pyx_v_rtol; + double __pyx_v_atol; + PyObject *__pyx_v_active_set = 0; + PyObject *__pyx_v_active_set_num = 0; + PyObject *__pyx_v_max_swaps = 0; + double __pyx_v_scale_down_factor; + PyObject *__pyx_v_screen_size = 0; + PyObject *__pyx_v_lambda_grid = 0; + PyObject *__pyx_v_exclude_first_k = 0; + PyObject *__pyx_v_intercept = 0; + PyObject *__pyx_v_lows = 0; + PyObject *__pyx_v_highs = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("cvfit (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_X,&__pyx_n_s_y,&__pyx_n_s_loss,&__pyx_n_s_penalty,&__pyx_n_s_algorithm,&__pyx_n_s_num_folds,&__pyx_n_s_seed,&__pyx_n_s_max_support_size,&__pyx_n_s_num_lambda,&__pyx_n_s_num_gamma,&__pyx_n_s_gamma_max,&__pyx_n_s_gamma_min,&__pyx_n_s_partial_sort,&__pyx_n_s_max_iter,&__pyx_n_s_rtol,&__pyx_n_s_atol,&__pyx_n_s_active_set,&__pyx_n_s_active_set_num,&__pyx_n_s_max_swaps,&__pyx_n_s_scale_down_factor,&__pyx_n_s_screen_size,&__pyx_n_s_lambda_grid,&__pyx_n_s_exclude_first_k,&__pyx_n_s_intercept,&__pyx_n_s_lows,&__pyx_n_s_highs,0}; + PyObject* values[26] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + values[2] = ((PyObject*)__pyx_n_u_SquaredHinge); + values[3] = ((PyObject*)__pyx_n_u_L0); + values[4] = ((PyObject*)__pyx_n_u_CD); + values[5] = ((PyObject *)__pyx_int_10); + values[6] = ((PyObject *)__pyx_int_1); + values[7] = ((PyObject *)__pyx_int_100); + values[8] = ((PyObject *)__pyx_int_100); + values[9] = ((PyObject *)__pyx_int_1); + + /* "l0learn/interface.pyx":362 + * gamma_max: float = 10., + * gamma_min: float = .0001, + * partial_sort: bool = True, # <<<<<<<<<<<<<< + * max_iter: int = 200, + * rtol: float = 1e-6, + */ + values[12] = ((PyObject *)Py_True); + values[13] = ((PyObject *)__pyx_int_200); + + /* "l0learn/interface.pyx":366 + * rtol: float = 1e-6, + * atol: float = 1e-9, + * active_set: bool = True, # <<<<<<<<<<<<<< + * active_set_num: int = 3, + * max_swaps: int = 100, + */ + values[16] = ((PyObject *)Py_True); + values[17] = ((PyObject *)__pyx_int_3); + values[18] = ((PyObject *)__pyx_int_100); + values[20] = ((PyObject *)__pyx_int_1000); + + /* "l0learn/interface.pyx":371 + * scale_down_factor: float = 0.8, + * screen_size: int = 1000, + * lambda_grid: Optional[List[List[float]]] = None, # <<<<<<<<<<<<<< + * exclude_first_k: int = 0, + * intercept: bool = True, + */ + values[21] = ((PyObject *)Py_None); + values[22] = ((PyObject *)__pyx_int_0); + + /* "l0learn/interface.pyx":373 + * lambda_grid: Optional[List[List[float]]] = None, + * exclude_first_k: int = 0, + * intercept: bool = True, # <<<<<<<<<<<<<< + * lows: Union[np.ndarray, float] = -float('inf'), + * highs: Union[np.ndarray, float] = +float('inf'),): + */ + values[23] = ((PyObject *)Py_True); + values[24] = __pyx_k__9; + values[25] = __pyx_k__10; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 26: values[25] = PyTuple_GET_ITEM(__pyx_args, 25); + CYTHON_FALLTHROUGH; + case 25: values[24] = PyTuple_GET_ITEM(__pyx_args, 24); + CYTHON_FALLTHROUGH; + case 24: values[23] = PyTuple_GET_ITEM(__pyx_args, 23); + CYTHON_FALLTHROUGH; + case 23: values[22] = PyTuple_GET_ITEM(__pyx_args, 22); + CYTHON_FALLTHROUGH; + case 22: values[21] = PyTuple_GET_ITEM(__pyx_args, 21); + CYTHON_FALLTHROUGH; + case 21: values[20] = PyTuple_GET_ITEM(__pyx_args, 20); + CYTHON_FALLTHROUGH; + case 20: values[19] = PyTuple_GET_ITEM(__pyx_args, 19); + CYTHON_FALLTHROUGH; + case 19: values[18] = PyTuple_GET_ITEM(__pyx_args, 18); + CYTHON_FALLTHROUGH; + case 18: values[17] = PyTuple_GET_ITEM(__pyx_args, 17); + CYTHON_FALLTHROUGH; + case 17: values[16] = PyTuple_GET_ITEM(__pyx_args, 16); + CYTHON_FALLTHROUGH; + case 16: values[15] = PyTuple_GET_ITEM(__pyx_args, 15); + CYTHON_FALLTHROUGH; + case 15: values[14] = PyTuple_GET_ITEM(__pyx_args, 14); + CYTHON_FALLTHROUGH; + case 14: values[13] = PyTuple_GET_ITEM(__pyx_args, 13); + CYTHON_FALLTHROUGH; + case 13: values[12] = PyTuple_GET_ITEM(__pyx_args, 12); + CYTHON_FALLTHROUGH; + case 12: values[11] = PyTuple_GET_ITEM(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_X)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("cvfit", 0, 2, 26, 1); __PYX_ERR(0, 350, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_loss); + if (value) { values[2] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_penalty); + if (value) { values[3] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_algorithm); + if (value) { values[4] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_num_folds); + if (value) { values[5] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_seed); + if (value) { values[6] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 7: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_support_size); + if (value) { values[7] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 8: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_num_lambda); + if (value) { values[8] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 9: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_num_gamma); + if (value) { values[9] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 10: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_gamma_max); + if (value) { values[10] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 11: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_gamma_min); + if (value) { values[11] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 12: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_partial_sort); + if (value) { values[12] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 13: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_iter); + if (value) { values[13] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 14: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rtol); + if (value) { values[14] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 15: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_atol); + if (value) { values[15] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 16: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_active_set); + if (value) { values[16] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 17: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_active_set_num); + if (value) { values[17] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 18: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_swaps); + if (value) { values[18] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 19: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_scale_down_factor); + if (value) { values[19] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 20: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_screen_size); + if (value) { values[20] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 21: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_lambda_grid); + if (value) { values[21] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 22: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_exclude_first_k); + if (value) { values[22] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 23: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_intercept); + if (value) { values[23] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 24: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_lows); + if (value) { values[24] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 25: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_highs); + if (value) { values[25] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "cvfit") < 0)) __PYX_ERR(0, 350, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 26: values[25] = PyTuple_GET_ITEM(__pyx_args, 25); + CYTHON_FALLTHROUGH; + case 25: values[24] = PyTuple_GET_ITEM(__pyx_args, 24); + CYTHON_FALLTHROUGH; + case 24: values[23] = PyTuple_GET_ITEM(__pyx_args, 23); + CYTHON_FALLTHROUGH; + case 23: values[22] = PyTuple_GET_ITEM(__pyx_args, 22); + CYTHON_FALLTHROUGH; + case 22: values[21] = PyTuple_GET_ITEM(__pyx_args, 21); + CYTHON_FALLTHROUGH; + case 21: values[20] = PyTuple_GET_ITEM(__pyx_args, 20); + CYTHON_FALLTHROUGH; + case 20: values[19] = PyTuple_GET_ITEM(__pyx_args, 19); + CYTHON_FALLTHROUGH; + case 19: values[18] = PyTuple_GET_ITEM(__pyx_args, 18); + CYTHON_FALLTHROUGH; + case 18: values[17] = PyTuple_GET_ITEM(__pyx_args, 17); + CYTHON_FALLTHROUGH; + case 17: values[16] = PyTuple_GET_ITEM(__pyx_args, 16); + CYTHON_FALLTHROUGH; + case 16: values[15] = PyTuple_GET_ITEM(__pyx_args, 15); + CYTHON_FALLTHROUGH; + case 15: values[14] = PyTuple_GET_ITEM(__pyx_args, 14); + CYTHON_FALLTHROUGH; + case 14: values[13] = PyTuple_GET_ITEM(__pyx_args, 13); + CYTHON_FALLTHROUGH; + case 13: values[12] = PyTuple_GET_ITEM(__pyx_args, 12); + CYTHON_FALLTHROUGH; + case 12: values[11] = PyTuple_GET_ITEM(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_X = values[0]; + __pyx_v_y = ((PyArrayObject *)values[1]); + __pyx_v_loss = ((PyObject*)values[2]); + __pyx_v_penalty = ((PyObject*)values[3]); + __pyx_v_algorithm = ((PyObject*)values[4]); + __pyx_v_num_folds = values[5]; + __pyx_v_seed = values[6]; + __pyx_v_max_support_size = values[7]; + __pyx_v_num_lambda = values[8]; + __pyx_v_num_gamma = values[9]; + if (values[10]) { + __pyx_v_gamma_max = __pyx_PyFloat_AsDouble(values[10]); if (unlikely((__pyx_v_gamma_max == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 360, __pyx_L3_error) + } else { + __pyx_v_gamma_max = ((double)10.); + } + if (values[11]) { + __pyx_v_gamma_min = __pyx_PyFloat_AsDouble(values[11]); if (unlikely((__pyx_v_gamma_min == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 361, __pyx_L3_error) + } else { + __pyx_v_gamma_min = ((double).0001); + } + __pyx_v_partial_sort = values[12]; + __pyx_v_max_iter = values[13]; + if (values[14]) { + __pyx_v_rtol = __pyx_PyFloat_AsDouble(values[14]); if (unlikely((__pyx_v_rtol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 364, __pyx_L3_error) + } else { + __pyx_v_rtol = ((double)1e-6); + } + if (values[15]) { + __pyx_v_atol = __pyx_PyFloat_AsDouble(values[15]); if (unlikely((__pyx_v_atol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 365, __pyx_L3_error) + } else { + __pyx_v_atol = ((double)1e-9); + } + __pyx_v_active_set = values[16]; + __pyx_v_active_set_num = values[17]; + __pyx_v_max_swaps = values[18]; + if (values[19]) { + __pyx_v_scale_down_factor = __pyx_PyFloat_AsDouble(values[19]); if (unlikely((__pyx_v_scale_down_factor == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 369, __pyx_L3_error) + } else { + __pyx_v_scale_down_factor = ((double)0.8); + } + __pyx_v_screen_size = values[20]; + __pyx_v_lambda_grid = values[21]; + __pyx_v_exclude_first_k = values[22]; + __pyx_v_intercept = values[23]; + __pyx_v_lows = values[24]; + __pyx_v_highs = values[25]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("cvfit", 0, 2, 26, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 350, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("l0learn.interface.cvfit", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_y), __pyx_ptype_5numpy_ndarray, 1, "y", 0))) __PYX_ERR(0, 351, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loss), (&PyUnicode_Type), 1, "loss", 1))) __PYX_ERR(0, 352, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_penalty), (&PyUnicode_Type), 1, "penalty", 1))) __PYX_ERR(0, 353, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_algorithm), (&PyUnicode_Type), 1, "algorithm", 1))) __PYX_ERR(0, 354, __pyx_L1_error) + __pyx_r = __pyx_pf_7l0learn_9interface_4cvfit(__pyx_self, __pyx_v_X, __pyx_v_y, __pyx_v_loss, __pyx_v_penalty, __pyx_v_algorithm, __pyx_v_num_folds, __pyx_v_seed, __pyx_v_max_support_size, __pyx_v_num_lambda, __pyx_v_num_gamma, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_v_partial_sort, __pyx_v_max_iter, __pyx_v_rtol, __pyx_v_atol, __pyx_v_active_set, __pyx_v_active_set_num, __pyx_v_max_swaps, __pyx_v_scale_down_factor, __pyx_v_screen_size, __pyx_v_lambda_grid, __pyx_v_exclude_first_k, __pyx_v_intercept, __pyx_v_lows, __pyx_v_highs); + + /* "l0learn/interface.pyx":350 + * "Converged": results.Converged} + * + * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< + * y: np.ndarray, + * loss: str = "SquaredHinge", + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyArrayObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_num_folds, PyObject *__pyx_v_seed, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs) { + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_v_p = NULL; + int __pyx_v_auto_lambda; + CYTHON_UNUSED int __pyx_v_bad_lambda_grid; + PyObject *__pyx_v_i = NULL; + PyObject *__pyx_v_sub_lambda_grid = NULL; + CYTHON_UNUSED double __pyx_v_current; + int __pyx_v_with_bounds; + PyObject *__pyx_v_bad_bounds = NULL; + std::vector > __pyx_v_c_lambda_grid; + std::string __pyx_v_c_loss; + std::string __pyx_v_c_penalty; + std::string __pyx_v_c_algorithim; + cvfitmodel __pyx_v_results; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + Py_ssize_t __pyx_t_9; + Py_UCS4 __pyx_t_10; + PyObject *(*__pyx_t_11)(PyObject *); + int __pyx_t_12; + PyObject *(*__pyx_t_13)(PyObject *); + double __pyx_t_14; + Py_ssize_t __pyx_t_15; + PyObject *__pyx_t_16 = NULL; + PyObject *__pyx_t_17 = NULL; + PyObject *__pyx_t_18 = NULL; + PyObject *__pyx_t_19 = NULL; + std::vector > __pyx_t_20; + int __pyx_t_21; + std::string __pyx_t_22; + size_t __pyx_t_23; + size_t __pyx_t_24; + size_t __pyx_t_25; + bool __pyx_t_26; + size_t __pyx_t_27; + bool __pyx_t_28; + size_t __pyx_t_29; + size_t __pyx_t_30; + size_t __pyx_t_31; + unsigned int __pyx_t_32; + size_t __pyx_t_33; + bool __pyx_t_34; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("cvfit", 0); + __Pyx_INCREF(__pyx_v_penalty); + __Pyx_INCREF(__pyx_v_num_lambda); + __Pyx_INCREF(__pyx_v_num_gamma); + __Pyx_INCREF(__pyx_v_lambda_grid); + __Pyx_INCREF(__pyx_v_lows); + __Pyx_INCREF(__pyx_v_highs); + + /* "l0learn/interface.pyx":376 + * lows: Union[np.ndarray, float] = -float('inf'), + * highs: Union[np.ndarray, float] = +float('inf'),): + * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): # <<<<<<<<<<<<<< + * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 376, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_TypeCheck(__pyx_v_X, __pyx_ptype_5numpy_ndarray); + __pyx_t_5 = (__pyx_t_4 != 0); + if (!__pyx_t_5) { + } else { + __pyx_t_3 = __pyx_t_5; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_5 = PyObject_IsInstance(__pyx_v_X, __pyx_t_2); + __pyx_t_4 = (__pyx_t_5 != 0); + __pyx_t_3 = __pyx_t_4; + __pyx_L6_bool_binop_done:; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = ((!(__pyx_t_3 != 0)) != 0); + if (!__pyx_t_4) { + } else { + __pyx_t_1 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 376, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 376, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + __pyx_t_2 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_6, __pyx_v_X) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_X); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 376, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 376, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = ((!__pyx_t_4) != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 376, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyInt_NeObjC(__pyx_t_2, __pyx_int_2, 2, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 376, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 376, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 376, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_product); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 376, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 376, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + __pyx_t_7 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_8, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_2); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 376, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 376, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_4 = ((!__pyx_t_3) != 0); + __pyx_t_1 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":377 + * highs: Union[np.ndarray, float] = +float('inf'),): + * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): + * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") # <<<<<<<<<<<<<< + * + * n, p = X.shape + */ + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 377, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_X_to_be_a_2D_non_degene); + __pyx_t_9 += 71; + __Pyx_GIVEREF(__pyx_kp_u_expected_X_to_be_a_2D_non_degene); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_X_to_be_a_2D_non_degene); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_X, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 377, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_kp_u__5); + __pyx_t_9 += 1; + __Pyx_GIVEREF(__pyx_kp_u__5); + PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u__5); + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 377, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 377, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(0, 377, __pyx_L1_error) + + /* "l0learn/interface.pyx":376 + * lows: Union[np.ndarray, float] = -float('inf'), + * highs: Union[np.ndarray, float] = +float('inf'),): + * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): # <<<<<<<<<<<<<< + * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") + * + */ + } + + /* "l0learn/interface.pyx":379 + * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") + * + * n, p = X.shape # <<<<<<<<<<<<<< + * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: + * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") + */ + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 379, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if ((likely(PyTuple_CheckExact(__pyx_t_7))) || (PyList_CheckExact(__pyx_t_7))) { + PyObject* sequence = __pyx_t_7; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 379, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_2 = PyTuple_GET_ITEM(sequence, 1); + } else { + __pyx_t_6 = PyList_GET_ITEM(sequence, 0); + __pyx_t_2 = PyList_GET_ITEM(sequence, 1); + } + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx_t_2); + #else + __pyx_t_6 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 379, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 379, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_8 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 379, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_11 = Py_TYPE(__pyx_t_8)->tp_iternext; + index = 0; __pyx_t_6 = __pyx_t_11(__pyx_t_8); if (unlikely(!__pyx_t_6)) goto __pyx_L10_unpacking_failed; + __Pyx_GOTREF(__pyx_t_6); + index = 1; __pyx_t_2 = __pyx_t_11(__pyx_t_8); if (unlikely(!__pyx_t_2)) goto __pyx_L10_unpacking_failed; + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_8), 2) < 0) __PYX_ERR(0, 379, __pyx_L1_error) + __pyx_t_11 = NULL; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + goto __pyx_L11_unpacking_done; + __pyx_L10_unpacking_failed:; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_11 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 379, __pyx_L1_error) + __pyx_L11_unpacking_done:; + } + __pyx_v_n = __pyx_t_6; + __pyx_t_6 = 0; + __pyx_v_p = __pyx_t_2; + __pyx_t_2 = 0; + + /* "l0learn/interface.pyx":380 + * + * n, p = X.shape + * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: # <<<<<<<<<<<<<< + * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") + * + */ + __pyx_t_4 = __Pyx_TypeCheck(((PyObject *)__pyx_v_y), __pyx_ptype_5numpy_ndarray); + __pyx_t_3 = ((!(__pyx_t_4 != 0)) != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L13_bool_binop_done; + } + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 380, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 380, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + __pyx_t_7 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_2, ((PyObject *)__pyx_v_y)) : __Pyx_PyObject_CallOneArg(__pyx_t_6, ((PyObject *)__pyx_v_y)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 380, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 380, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_4 = ((!__pyx_t_3) != 0); + if (!__pyx_t_4) { + } else { + __pyx_t_1 = __pyx_t_4; + goto __pyx_L13_bool_binop_done; + } + __pyx_t_4 = ((__pyx_v_y->nd != 1) != 0); + if (!__pyx_t_4) { + } else { + __pyx_t_1 = __pyx_t_4; + goto __pyx_L13_bool_binop_done; + } + __pyx_t_9 = PyObject_Length(((PyObject *)__pyx_v_y)); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 380, __pyx_L1_error) + __pyx_t_7 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 380, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = PyObject_RichCompare(__pyx_t_7, __pyx_v_n, Py_NE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 380, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 380, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_1 = __pyx_t_4; + __pyx_L13_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":381 + * n, p = X.shape + * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: + * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") # <<<<<<<<<<<<<< + * + * if loss not in SUPPORTED_LOSS: + */ + __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 381, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_y_to_be_a_1D_real_numpy); + __pyx_t_9 += 42; + __Pyx_GIVEREF(__pyx_kp_u_expected_y_to_be_a_1D_real_numpy); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_y_to_be_a_1D_real_numpy); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(((PyObject *)__pyx_v_y), __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 381, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_7); + __pyx_t_7 = 0; + __Pyx_INCREF(__pyx_kp_u__5); + __pyx_t_9 += 1; + __Pyx_GIVEREF(__pyx_kp_u__5); + PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u__5); + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_6, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 381, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 381, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 381, __pyx_L1_error) + + /* "l0learn/interface.pyx":380 + * + * n, p = X.shape + * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: # <<<<<<<<<<<<<< + * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") + * + */ + } + + /* "l0learn/interface.pyx":383 + * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") + * + * if loss not in SUPPORTED_LOSS: # <<<<<<<<<<<<<< + * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 383, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_loss, __pyx_t_6, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 383, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_4 = (__pyx_t_1 != 0); + if (unlikely(__pyx_t_4)) { + + /* "l0learn/interface.pyx":384 + * + * if loss not in SUPPORTED_LOSS: + * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") # <<<<<<<<<<<<<< + * + * if penalty not in SUPPORTED_PENALTY: + */ + __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 384, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_loss_parameter_to_be_on); + __pyx_t_9 += 36; + __Pyx_GIVEREF(__pyx_kp_u_expected_loss_parameter_to_be_on); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_loss_parameter_to_be_on); + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 384, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 384, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_kp_u_but_got); + __pyx_t_9 += 10; + __Pyx_GIVEREF(__pyx_kp_u_but_got); + PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u_but_got); + __pyx_t_2 = __Pyx_PyUnicode_Unicode(__pyx_v_loss); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 384, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_6, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 384, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 384, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 384, __pyx_L1_error) + + /* "l0learn/interface.pyx":383 + * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") + * + * if loss not in SUPPORTED_LOSS: # <<<<<<<<<<<<<< + * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") + * + */ + } + + /* "l0learn/interface.pyx":386 + * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") + * + * if penalty not in SUPPORTED_PENALTY: # <<<<<<<<<<<<<< + * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") + * if algorithm not in SUPPORTED_ALGORITHM: + */ + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_SUPPORTED_PENALTY); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 386, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_4 = (__Pyx_PySequence_ContainsTF(__pyx_v_penalty, __pyx_t_6, Py_NE)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 386, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_1 = (__pyx_t_4 != 0); + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":387 + * + * if penalty not in SUPPORTED_PENALTY: + * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") # <<<<<<<<<<<<<< + * if algorithm not in SUPPORTED_ALGORITHM: + * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") + */ + __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 387, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_penalty_parameter_to_be); + __pyx_t_9 += 39; + __Pyx_GIVEREF(__pyx_kp_u_expected_penalty_parameter_to_be); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_penalty_parameter_to_be); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SUPPORTED_PENALTY); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 387, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 387, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_7); + __pyx_t_7 = 0; + __Pyx_INCREF(__pyx_kp_u_but_got); + __pyx_t_9 += 10; + __Pyx_GIVEREF(__pyx_kp_u_but_got); + PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u_but_got); + __pyx_t_7 = __Pyx_PyUnicode_Unicode(__pyx_v_penalty); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 387, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_6, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 387, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 387, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 387, __pyx_L1_error) + + /* "l0learn/interface.pyx":386 + * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") + * + * if penalty not in SUPPORTED_PENALTY: # <<<<<<<<<<<<<< + * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") + * if algorithm not in SUPPORTED_ALGORITHM: + */ + } + + /* "l0learn/interface.pyx":388 + * if penalty not in SUPPORTED_PENALTY: + * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") + * if algorithm not in SUPPORTED_ALGORITHM: # <<<<<<<<<<<<<< + * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") + * if not isinstance(num_folds, int) or num_folds < 2: + */ + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_SUPPORTED_ALGORITHM); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_algorithm, __pyx_t_6, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 388, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_4 = (__pyx_t_1 != 0); + if (unlikely(__pyx_t_4)) { + + /* "l0learn/interface.pyx":389 + * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") + * if algorithm not in SUPPORTED_ALGORITHM: + * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") # <<<<<<<<<<<<<< + * if not isinstance(num_folds, int) or num_folds < 2: + * raise ValueError(f"expected num_folds parameter to be a integer greater than 2, but got {num_folds}") + */ + __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 389, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_algorithm_parameter_to); + __pyx_t_9 += 41; + __Pyx_GIVEREF(__pyx_kp_u_expected_algorithm_parameter_to); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_algorithm_parameter_to); + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_SUPPORTED_ALGORITHM); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 389, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 389, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_kp_u_but_got); + __pyx_t_9 += 10; + __Pyx_GIVEREF(__pyx_kp_u_but_got); + PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u_but_got); + __pyx_t_2 = __Pyx_PyUnicode_Unicode(__pyx_v_algorithm); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 389, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_6, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 389, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 389, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 389, __pyx_L1_error) + + /* "l0learn/interface.pyx":388 + * if penalty not in SUPPORTED_PENALTY: + * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") + * if algorithm not in SUPPORTED_ALGORITHM: # <<<<<<<<<<<<<< + * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") + * if not isinstance(num_folds, int) or num_folds < 2: + */ + } + + /* "l0learn/interface.pyx":390 + * if algorithm not in SUPPORTED_ALGORITHM: + * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") + * if not isinstance(num_folds, int) or num_folds < 2: # <<<<<<<<<<<<<< + * raise ValueError(f"expected num_folds parameter to be a integer greater than 2, but got {num_folds}") + * if not isinstance(seed, int): + */ + __pyx_t_1 = PyInt_Check(__pyx_v_num_folds); + __pyx_t_3 = ((!(__pyx_t_1 != 0)) != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_4 = __pyx_t_3; + goto __pyx_L21_bool_binop_done; + } + __pyx_t_6 = PyObject_RichCompare(__pyx_v_num_folds, __pyx_int_2, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 390, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 390, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_4 = __pyx_t_3; + __pyx_L21_bool_binop_done:; + if (unlikely(__pyx_t_4)) { + + /* "l0learn/interface.pyx":391 + * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") + * if not isinstance(num_folds, int) or num_folds < 2: + * raise ValueError(f"expected num_folds parameter to be a integer greater than 2, but got {num_folds}") # <<<<<<<<<<<<<< + * if not isinstance(seed, int): + * raise ValueError(f"expected seed parameter to be an integer, but got {seed}") + */ + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_num_folds, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 391, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_folds_parameter_to, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 391, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 391, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 391, __pyx_L1_error) + + /* "l0learn/interface.pyx":390 + * if algorithm not in SUPPORTED_ALGORITHM: + * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") + * if not isinstance(num_folds, int) or num_folds < 2: # <<<<<<<<<<<<<< + * raise ValueError(f"expected num_folds parameter to be a integer greater than 2, but got {num_folds}") + * if not isinstance(seed, int): + */ + } + + /* "l0learn/interface.pyx":392 + * if not isinstance(num_folds, int) or num_folds < 2: + * raise ValueError(f"expected num_folds parameter to be a integer greater than 2, but got {num_folds}") + * if not isinstance(seed, int): # <<<<<<<<<<<<<< + * raise ValueError(f"expected seed parameter to be an integer, but got {seed}") + * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): + */ + __pyx_t_4 = PyInt_Check(__pyx_v_seed); + __pyx_t_3 = ((!(__pyx_t_4 != 0)) != 0); + if (unlikely(__pyx_t_3)) { + + /* "l0learn/interface.pyx":393 + * raise ValueError(f"expected num_folds parameter to be a integer greater than 2, but got {num_folds}") + * if not isinstance(seed, int): + * raise ValueError(f"expected seed parameter to be an integer, but got {seed}") # <<<<<<<<<<<<<< + * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): + * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," + */ + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_seed, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 393, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_seed_parameter_to_be_an, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 393, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 393, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 393, __pyx_L1_error) + + /* "l0learn/interface.pyx":392 + * if not isinstance(num_folds, int) or num_folds < 2: + * raise ValueError(f"expected num_folds parameter to be a integer greater than 2, but got {num_folds}") + * if not isinstance(seed, int): # <<<<<<<<<<<<<< + * raise ValueError(f"expected seed parameter to be an integer, but got {seed}") + * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): + */ + } + + /* "l0learn/interface.pyx":394 + * if not isinstance(seed, int): + * raise ValueError(f"expected seed parameter to be an integer, but got {seed}") + * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): # <<<<<<<<<<<<<< + * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," + * f" but got {max_support_size}") + */ + __pyx_t_4 = PyInt_Check(__pyx_v_max_support_size); + __pyx_t_1 = ((!(__pyx_t_4 != 0)) != 0); + if (!__pyx_t_1) { + } else { + __pyx_t_3 = __pyx_t_1; + goto __pyx_L25_bool_binop_done; + } + __pyx_t_6 = PyObject_RichCompare(__pyx_int_0, __pyx_v_max_support_size, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 394, __pyx_L1_error) + if (__Pyx_PyObject_IsTrue(__pyx_t_6)) { + __Pyx_DECREF(__pyx_t_6); + __pyx_t_6 = PyObject_RichCompare(__pyx_v_max_support_size, __pyx_v_p, Py_LE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 394, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 394, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_4 = ((!__pyx_t_1) != 0); + __pyx_t_3 = __pyx_t_4; + __pyx_L25_bool_binop_done:; + if (unlikely(__pyx_t_3)) { + + /* "l0learn/interface.pyx":395 + * raise ValueError(f"expected seed parameter to be an integer, but got {seed}") + * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): + * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," # <<<<<<<<<<<<<< + * f" but got {max_support_size}") + * if gamma_max < 0: + */ + __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 395, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_max_support_size_parame); + __pyx_t_9 += 71; + __Pyx_GIVEREF(__pyx_kp_u_expected_max_support_size_parame); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_max_support_size_parame); + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 395, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_kp_u_but_got); + __pyx_t_9 += 10; + __Pyx_GIVEREF(__pyx_kp_u_but_got); + PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u_but_got); + + /* "l0learn/interface.pyx":396 + * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): + * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," + * f" but got {max_support_size}") # <<<<<<<<<<<<<< + * if gamma_max < 0: + * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") + */ + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_max_support_size, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 396, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_2); + __pyx_t_2 = 0; + + /* "l0learn/interface.pyx":395 + * raise ValueError(f"expected seed parameter to be an integer, but got {seed}") + * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): + * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," # <<<<<<<<<<<<<< + * f" but got {max_support_size}") + * if gamma_max < 0: + */ + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_6, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 395, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 395, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 395, __pyx_L1_error) + + /* "l0learn/interface.pyx":394 + * if not isinstance(seed, int): + * raise ValueError(f"expected seed parameter to be an integer, but got {seed}") + * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): # <<<<<<<<<<<<<< + * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," + * f" but got {max_support_size}") + */ + } + + /* "l0learn/interface.pyx":397 + * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," + * f" but got {max_support_size}") + * if gamma_max < 0: # <<<<<<<<<<<<<< + * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") + * if gamma_min < 0 or gamma_min > gamma_max: + */ + __pyx_t_3 = ((__pyx_v_gamma_max < 0.0) != 0); + if (unlikely(__pyx_t_3)) { + + /* "l0learn/interface.pyx":398 + * f" but got {max_support_size}") + * if gamma_max < 0: + * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") # <<<<<<<<<<<<<< + * if gamma_min < 0 or gamma_min > gamma_max: + * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," + */ + __pyx_t_6 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 398, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_6, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 398, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_gamma_max_parameter_to, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 398, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 398, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 398, __pyx_L1_error) + + /* "l0learn/interface.pyx":397 + * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," + * f" but got {max_support_size}") + * if gamma_max < 0: # <<<<<<<<<<<<<< + * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") + * if gamma_min < 0 or gamma_min > gamma_max: + */ + } + + /* "l0learn/interface.pyx":399 + * if gamma_max < 0: + * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") + * if gamma_min < 0 or gamma_min > gamma_max: # <<<<<<<<<<<<<< + * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," + * f" but got {gamma_min}") + */ + __pyx_t_4 = ((__pyx_v_gamma_min < 0.0) != 0); + if (!__pyx_t_4) { + } else { + __pyx_t_3 = __pyx_t_4; + goto __pyx_L29_bool_binop_done; + } + __pyx_t_4 = ((__pyx_v_gamma_min > __pyx_v_gamma_max) != 0); + __pyx_t_3 = __pyx_t_4; + __pyx_L29_bool_binop_done:; + if (unlikely(__pyx_t_3)) { + + /* "l0learn/interface.pyx":401 + * if gamma_min < 0 or gamma_min > gamma_max: + * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," + * f" but got {gamma_min}") # <<<<<<<<<<<<<< + * if not isinstance(partial_sort, bool): + * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") + */ + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 401, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 401, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "l0learn/interface.pyx":400 + * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") + * if gamma_min < 0 or gamma_min > gamma_max: + * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," # <<<<<<<<<<<<<< + * f" but got {gamma_min}") + * if not isinstance(partial_sort, bool): + */ + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_gamma_max_parameter_to_2, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 400, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 400, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 400, __pyx_L1_error) + + /* "l0learn/interface.pyx":399 + * if gamma_max < 0: + * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") + * if gamma_min < 0 or gamma_min > gamma_max: # <<<<<<<<<<<<<< + * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," + * f" but got {gamma_min}") + */ + } + + /* "l0learn/interface.pyx":402 + * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," + * f" but got {gamma_min}") + * if not isinstance(partial_sort, bool): # <<<<<<<<<<<<<< + * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") + * if not isinstance(max_iter, int) or max_iter < 1: + */ + __pyx_t_6 = ((PyObject*)&PyBool_Type); + __Pyx_INCREF(__pyx_t_6); + __pyx_t_3 = PyObject_IsInstance(__pyx_v_partial_sort, __pyx_t_6); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 402, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_4 = ((!(__pyx_t_3 != 0)) != 0); + if (unlikely(__pyx_t_4)) { + + /* "l0learn/interface.pyx":403 + * f" but got {gamma_min}") + * if not isinstance(partial_sort, bool): + * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") # <<<<<<<<<<<<<< + * if not isinstance(max_iter, int) or max_iter < 1: + * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") + */ + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_partial_sort, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 403, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_partial_sort_parameter, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 403, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 403, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 403, __pyx_L1_error) + + /* "l0learn/interface.pyx":402 + * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," + * f" but got {gamma_min}") + * if not isinstance(partial_sort, bool): # <<<<<<<<<<<<<< + * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") + * if not isinstance(max_iter, int) or max_iter < 1: + */ + } + + /* "l0learn/interface.pyx":404 + * if not isinstance(partial_sort, bool): + * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") + * if not isinstance(max_iter, int) or max_iter < 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") + * if rtol < 0 or rtol >= 1: + */ + __pyx_t_3 = PyInt_Check(__pyx_v_max_iter); + __pyx_t_1 = ((!(__pyx_t_3 != 0)) != 0); + if (!__pyx_t_1) { + } else { + __pyx_t_4 = __pyx_t_1; + goto __pyx_L33_bool_binop_done; + } + __pyx_t_6 = PyObject_RichCompare(__pyx_v_max_iter, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 404, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 404, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_4 = __pyx_t_1; + __pyx_L33_bool_binop_done:; + if (unlikely(__pyx_t_4)) { + + /* "l0learn/interface.pyx":405 + * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") + * if not isinstance(max_iter, int) or max_iter < 1: + * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") # <<<<<<<<<<<<<< + * if rtol < 0 or rtol >= 1: + * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") + */ + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_max_iter, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_iter_parameter_to_b, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 405, __pyx_L1_error) + + /* "l0learn/interface.pyx":404 + * if not isinstance(partial_sort, bool): + * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") + * if not isinstance(max_iter, int) or max_iter < 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") + * if rtol < 0 or rtol >= 1: + */ + } + + /* "l0learn/interface.pyx":406 + * if not isinstance(max_iter, int) or max_iter < 1: + * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") + * if rtol < 0 or rtol >= 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") + * if atol < 0: + */ + __pyx_t_1 = ((__pyx_v_rtol < 0.0) != 0); + if (!__pyx_t_1) { + } else { + __pyx_t_4 = __pyx_t_1; + goto __pyx_L36_bool_binop_done; + } + __pyx_t_1 = ((__pyx_v_rtol >= 1.0) != 0); + __pyx_t_4 = __pyx_t_1; + __pyx_L36_bool_binop_done:; + if (unlikely(__pyx_t_4)) { + + /* "l0learn/interface.pyx":407 + * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") + * if rtol < 0 or rtol >= 1: + * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") # <<<<<<<<<<<<<< + * if atol < 0: + * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") + */ + __pyx_t_6 = PyFloat_FromDouble(__pyx_v_rtol); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_6, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_rtol_parameter_to_exist, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 407, __pyx_L1_error) + + /* "l0learn/interface.pyx":406 + * if not isinstance(max_iter, int) or max_iter < 1: + * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") + * if rtol < 0 or rtol >= 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") + * if atol < 0: + */ + } + + /* "l0learn/interface.pyx":408 + * if rtol < 0 or rtol >= 1: + * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") + * if atol < 0: # <<<<<<<<<<<<<< + * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") + * if not isinstance(active_set, bool): + */ + __pyx_t_4 = ((__pyx_v_atol < 0.0) != 0); + if (unlikely(__pyx_t_4)) { + + /* "l0learn/interface.pyx":409 + * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") + * if atol < 0: + * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") # <<<<<<<<<<<<<< + * if not isinstance(active_set, bool): + * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") + */ + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_atol); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_atol_parameter_to_exist, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 409, __pyx_L1_error) + + /* "l0learn/interface.pyx":408 + * if rtol < 0 or rtol >= 1: + * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") + * if atol < 0: # <<<<<<<<<<<<<< + * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") + * if not isinstance(active_set, bool): + */ + } + + /* "l0learn/interface.pyx":410 + * if atol < 0: + * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") + * if not isinstance(active_set, bool): # <<<<<<<<<<<<<< + * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") + * if not isinstance(active_set_num, int) or active_set_num < 1: + */ + __pyx_t_6 = ((PyObject*)&PyBool_Type); + __Pyx_INCREF(__pyx_t_6); + __pyx_t_4 = PyObject_IsInstance(__pyx_v_active_set, __pyx_t_6); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 410, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_1 = ((!(__pyx_t_4 != 0)) != 0); + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":411 + * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") + * if not isinstance(active_set, bool): + * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") # <<<<<<<<<<<<<< + * if not isinstance(active_set_num, int) or active_set_num < 1: + * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") + */ + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_active_set, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_active_set_parameter_to, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 411, __pyx_L1_error) + + /* "l0learn/interface.pyx":410 + * if atol < 0: + * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") + * if not isinstance(active_set, bool): # <<<<<<<<<<<<<< + * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") + * if not isinstance(active_set_num, int) or active_set_num < 1: + */ + } + + /* "l0learn/interface.pyx":412 + * if not isinstance(active_set, bool): + * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") + * if not isinstance(active_set_num, int) or active_set_num < 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") + * if not isinstance(max_swaps, int) or max_swaps < 1: + */ + __pyx_t_4 = PyInt_Check(__pyx_v_active_set_num); + __pyx_t_3 = ((!(__pyx_t_4 != 0)) != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L41_bool_binop_done; + } + __pyx_t_6 = PyObject_RichCompare(__pyx_v_active_set_num, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 412, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 412, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_1 = __pyx_t_3; + __pyx_L41_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":413 + * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") + * if not isinstance(active_set_num, int) or active_set_num < 1: + * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") # <<<<<<<<<<<<<< + * if not isinstance(max_swaps, int) or max_swaps < 1: + * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") + */ + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_active_set_num, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_active_set_num_paramete, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 413, __pyx_L1_error) + + /* "l0learn/interface.pyx":412 + * if not isinstance(active_set, bool): + * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") + * if not isinstance(active_set_num, int) or active_set_num < 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") + * if not isinstance(max_swaps, int) or max_swaps < 1: + */ + } + + /* "l0learn/interface.pyx":414 + * if not isinstance(active_set_num, int) or active_set_num < 1: + * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") + * if not isinstance(max_swaps, int) or max_swaps < 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") + * if not (0 < scale_down_factor < 1): + */ + __pyx_t_3 = PyInt_Check(__pyx_v_max_swaps); + __pyx_t_4 = ((!(__pyx_t_3 != 0)) != 0); + if (!__pyx_t_4) { + } else { + __pyx_t_1 = __pyx_t_4; + goto __pyx_L44_bool_binop_done; + } + __pyx_t_6 = PyObject_RichCompare(__pyx_v_max_swaps, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 414, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 414, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_1 = __pyx_t_4; + __pyx_L44_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":415 + * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") + * if not isinstance(max_swaps, int) or max_swaps < 1: + * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") # <<<<<<<<<<<<<< + * if not (0 < scale_down_factor < 1): + * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") + */ + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_max_swaps, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 415, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_swaps_parameter_to, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 415, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 415, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 415, __pyx_L1_error) + + /* "l0learn/interface.pyx":414 + * if not isinstance(active_set_num, int) or active_set_num < 1: + * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") + * if not isinstance(max_swaps, int) or max_swaps < 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") + * if not (0 < scale_down_factor < 1): + */ + } + + /* "l0learn/interface.pyx":416 + * if not isinstance(max_swaps, int) or max_swaps < 1: + * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") + * if not (0 < scale_down_factor < 1): # <<<<<<<<<<<<<< + * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") + * if not isinstance(screen_size, int) or screen_size < 1: + */ + __pyx_t_1 = (0.0 < __pyx_v_scale_down_factor); + if (__pyx_t_1) { + __pyx_t_1 = (__pyx_v_scale_down_factor < 1.0); + } + __pyx_t_4 = ((!(__pyx_t_1 != 0)) != 0); + if (unlikely(__pyx_t_4)) { + + /* "l0learn/interface.pyx":417 + * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") + * if not (0 < scale_down_factor < 1): + * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") # <<<<<<<<<<<<<< + * if not isinstance(screen_size, int) or screen_size < 1: + * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") + */ + __pyx_t_6 = PyFloat_FromDouble(__pyx_v_scale_down_factor); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 417, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_6, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 417, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_scale_down_factor_param, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 417, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 417, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 417, __pyx_L1_error) + + /* "l0learn/interface.pyx":416 + * if not isinstance(max_swaps, int) or max_swaps < 1: + * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") + * if not (0 < scale_down_factor < 1): # <<<<<<<<<<<<<< + * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") + * if not isinstance(screen_size, int) or screen_size < 1: + */ + } + + /* "l0learn/interface.pyx":418 + * if not (0 < scale_down_factor < 1): + * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") + * if not isinstance(screen_size, int) or screen_size < 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") + * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): + */ + __pyx_t_1 = PyInt_Check(__pyx_v_screen_size); + __pyx_t_3 = ((!(__pyx_t_1 != 0)) != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_4 = __pyx_t_3; + goto __pyx_L48_bool_binop_done; + } + __pyx_t_2 = PyObject_RichCompare(__pyx_v_screen_size, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 418, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 418, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = __pyx_t_3; + __pyx_L48_bool_binop_done:; + if (unlikely(__pyx_t_4)) { + + /* "l0learn/interface.pyx":419 + * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") + * if not isinstance(screen_size, int) or screen_size < 1: + * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") # <<<<<<<<<<<<<< + * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): + * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " + */ + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_screen_size, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 419, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_screen_size_parameter_t, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 419, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 419, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 419, __pyx_L1_error) + + /* "l0learn/interface.pyx":418 + * if not (0 < scale_down_factor < 1): + * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") + * if not isinstance(screen_size, int) or screen_size < 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") + * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): + */ + } + + /* "l0learn/interface.pyx":420 + * if not isinstance(screen_size, int) or screen_size < 1: + * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") + * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): # <<<<<<<<<<<<<< + * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " + * f"but got {exclude_first_k}") + */ + __pyx_t_3 = PyInt_Check(__pyx_v_exclude_first_k); + __pyx_t_1 = ((!(__pyx_t_3 != 0)) != 0); + if (!__pyx_t_1) { + } else { + __pyx_t_4 = __pyx_t_1; + goto __pyx_L51_bool_binop_done; + } + __pyx_t_2 = PyObject_RichCompare(__pyx_int_0, __pyx_v_exclude_first_k, Py_LE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 420, __pyx_L1_error) + if (__Pyx_PyObject_IsTrue(__pyx_t_2)) { + __Pyx_DECREF(__pyx_t_2); + __pyx_t_2 = PyObject_RichCompare(__pyx_v_exclude_first_k, __pyx_v_p, Py_LE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 420, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 420, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = ((!__pyx_t_1) != 0); + __pyx_t_4 = __pyx_t_3; + __pyx_L51_bool_binop_done:; + if (unlikely(__pyx_t_4)) { + + /* "l0learn/interface.pyx":421 + * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") + * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): + * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " # <<<<<<<<<<<<<< + * f"but got {exclude_first_k}") + * if not isinstance(intercept, bool): + */ + __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 421, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_exclude_first_k_paramet); + __pyx_t_9 += 70; + __Pyx_GIVEREF(__pyx_kp_u_expected_exclude_first_k_paramet); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_u_expected_exclude_first_k_paramet); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 421, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_kp_u_but_got); + __pyx_t_9 += 10; + __Pyx_GIVEREF(__pyx_kp_u_but_got); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_kp_u_but_got); + + /* "l0learn/interface.pyx":422 + * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): + * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " + * f"but got {exclude_first_k}") # <<<<<<<<<<<<<< + * if not isinstance(intercept, bool): + * raise ValueError(f"expected intercept parameter to be a bool, " + */ + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_exclude_first_k, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 422, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_6); + __pyx_t_6 = 0; + + /* "l0learn/interface.pyx":421 + * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") + * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): + * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " # <<<<<<<<<<<<<< + * f"but got {exclude_first_k}") + * if not isinstance(intercept, bool): + */ + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_2, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 421, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 421, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 421, __pyx_L1_error) + + /* "l0learn/interface.pyx":420 + * if not isinstance(screen_size, int) or screen_size < 1: + * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") + * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): # <<<<<<<<<<<<<< + * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " + * f"but got {exclude_first_k}") + */ + } + + /* "l0learn/interface.pyx":423 + * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " + * f"but got {exclude_first_k}") + * if not isinstance(intercept, bool): # <<<<<<<<<<<<<< + * raise ValueError(f"expected intercept parameter to be a bool, " + * f"but got {intercept}") + */ + __pyx_t_2 = ((PyObject*)&PyBool_Type); + __Pyx_INCREF(__pyx_t_2); + __pyx_t_4 = PyObject_IsInstance(__pyx_v_intercept, __pyx_t_2); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 423, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = ((!(__pyx_t_4 != 0)) != 0); + if (unlikely(__pyx_t_3)) { + + /* "l0learn/interface.pyx":425 + * if not isinstance(intercept, bool): + * raise ValueError(f"expected intercept parameter to be a bool, " + * f"but got {intercept}") # <<<<<<<<<<<<<< + * + * if loss in CLASSIFICATION_LOSS: + */ + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_intercept, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 425, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "l0learn/interface.pyx":424 + * f"but got {exclude_first_k}") + * if not isinstance(intercept, bool): + * raise ValueError(f"expected intercept parameter to be a bool, " # <<<<<<<<<<<<<< + * f"but got {intercept}") + * + */ + __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_intercept_parameter_to, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 424, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 424, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 424, __pyx_L1_error) + + /* "l0learn/interface.pyx":423 + * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " + * f"but got {exclude_first_k}") + * if not isinstance(intercept, bool): # <<<<<<<<<<<<<< + * raise ValueError(f"expected intercept parameter to be a bool, " + * f"but got {intercept}") + */ + } + + /* "l0learn/interface.pyx":427 + * f"but got {intercept}") + * + * if loss in CLASSIFICATION_LOSS: # <<<<<<<<<<<<<< + * if sorted(np.unique(y)) != [-1, 1]: + * raise ValueError(f"expected y vector to only have two unique values (-1 and 1) (Binary Classification), " + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_CLASSIFICATION_LOSS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = (__Pyx_PySequence_ContainsTF(__pyx_v_loss, __pyx_t_2, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 427, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = (__pyx_t_3 != 0); + if (__pyx_t_4) { + + /* "l0learn/interface.pyx":428 + * + * if loss in CLASSIFICATION_LOSS: + * if sorted(np.unique(y)) != [-1, 1]: # <<<<<<<<<<<<<< + * raise ValueError(f"expected y vector to only have two unique values (-1 and 1) (Binary Classification), " + * f"but got {np.unique(y)}") + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 428, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_unique); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 428, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + } + } + __pyx_t_6 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_7, ((PyObject *)__pyx_v_y)) : __Pyx_PyObject_CallOneArg(__pyx_t_8, ((PyObject *)__pyx_v_y)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 428, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PySequence_List(__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 428, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_2 = ((PyObject*)__pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_12 = PyList_Sort(__pyx_t_2); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 428, __pyx_L1_error) + __pyx_t_8 = PyList_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 428, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_INCREF(__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_int_neg_1); + PyList_SET_ITEM(__pyx_t_8, 0, __pyx_int_neg_1); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + PyList_SET_ITEM(__pyx_t_8, 1, __pyx_int_1); + __pyx_t_6 = PyObject_RichCompare(__pyx_t_2, __pyx_t_8, Py_NE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 428, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 428, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(__pyx_t_4)) { + + /* "l0learn/interface.pyx":430 + * if sorted(np.unique(y)) != [-1, 1]: + * raise ValueError(f"expected y vector to only have two unique values (-1 and 1) (Binary Classification), " + * f"but got {np.unique(y)}") # <<<<<<<<<<<<<< + * + * if penalty == "L0": + */ + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 430, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_unique); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 430, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + __pyx_t_6 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_8, ((PyObject *)__pyx_v_y)) : __Pyx_PyObject_CallOneArg(__pyx_t_2, ((PyObject *)__pyx_v_y)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 430, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_6, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 430, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "l0learn/interface.pyx":429 + * if loss in CLASSIFICATION_LOSS: + * if sorted(np.unique(y)) != [-1, 1]: + * raise ValueError(f"expected y vector to only have two unique values (-1 and 1) (Binary Classification), " # <<<<<<<<<<<<<< + * f"but got {np.unique(y)}") + * + */ + __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_y_vector_to_only_have_t, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 429, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 429, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 429, __pyx_L1_error) + + /* "l0learn/interface.pyx":428 + * + * if loss in CLASSIFICATION_LOSS: + * if sorted(np.unique(y)) != [-1, 1]: # <<<<<<<<<<<<<< + * raise ValueError(f"expected y vector to only have two unique values (-1 and 1) (Binary Classification), " + * f"but got {np.unique(y)}") + */ + } + + /* "l0learn/interface.pyx":432 + * f"but got {np.unique(y)}") + * + * if penalty == "L0": # <<<<<<<<<<<<<< + * # TODO: Must be corrected in R code: https://github.com/hazimehh/L0Learn/blob/7a65474dfdb01489a0c263d7b24fbafad56fba61/R/fit.R#L136 + * # Pure L0 is not supported for classification + */ + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 432, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_4 != 0); + if (__pyx_t_3) { + + /* "l0learn/interface.pyx":437 + * # Below we add a small L2 component. + * + * if len(lambda_grid) != 1: # <<<<<<<<<<<<<< + * # If this error checking was left to the lower section, it would confuse users as + * # we are converting L0 to L0L2 with small L2 penalty. + */ + __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 437, __pyx_L1_error) + __pyx_t_3 = ((__pyx_t_9 != 1) != 0); + if (unlikely(__pyx_t_3)) { + + /* "l0learn/interface.pyx":442 + * # Here we must check if lambdaGrid is supplied (And thus use 'autolambda') + * # If 'lambdaGrid' is supplied, we must only supply 1 list of lambda values + * raise ValueError(f"L0 Penalty requires 'lambda_grid' to be a list of length 1, but got {lambda_grid}.") # <<<<<<<<<<<<<< + * + * penalty = "L0L2" + */ + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 442, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_L0_Penalty_requires_lambda_grid); + __pyx_t_9 += 68; + __Pyx_GIVEREF(__pyx_kp_u_L0_Penalty_requires_lambda_grid); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_u_L0_Penalty_requires_lambda_grid); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 442, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_kp_u__5); + __pyx_t_9 += 1; + __Pyx_GIVEREF(__pyx_kp_u__5); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_kp_u__5); + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_2, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 442, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 442, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 442, __pyx_L1_error) + + /* "l0learn/interface.pyx":437 + * # Below we add a small L2 component. + * + * if len(lambda_grid) != 1: # <<<<<<<<<<<<<< + * # If this error checking was left to the lower section, it would confuse users as + * # we are converting L0 to L0L2 with small L2 penalty. + */ + } + + /* "l0learn/interface.pyx":432 + * f"but got {np.unique(y)}") + * + * if penalty == "L0": # <<<<<<<<<<<<<< + * # TODO: Must be corrected in R code: https://github.com/hazimehh/L0Learn/blob/7a65474dfdb01489a0c263d7b24fbafad56fba61/R/fit.R#L136 + * # Pure L0 is not supported for classification + */ + } + + /* "l0learn/interface.pyx":444 + * raise ValueError(f"L0 Penalty requires 'lambda_grid' to be a list of length 1, but got {lambda_grid}.") + * + * penalty = "L0L2" # <<<<<<<<<<<<<< + * gamma_max = 1e-7 + * gamma_min = 1e-7 + */ + __Pyx_INCREF(__pyx_n_u_L0L2); + __Pyx_DECREF_SET(__pyx_v_penalty, __pyx_n_u_L0L2); + + /* "l0learn/interface.pyx":445 + * + * penalty = "L0L2" + * gamma_max = 1e-7 # <<<<<<<<<<<<<< + * gamma_min = 1e-7 + * + */ + __pyx_v_gamma_max = 1e-7; + + /* "l0learn/interface.pyx":446 + * penalty = "L0L2" + * gamma_max = 1e-7 + * gamma_min = 1e-7 # <<<<<<<<<<<<<< + * + * if lambda_grid is None: + */ + __pyx_v_gamma_min = 1e-7; + + /* "l0learn/interface.pyx":427 + * f"but got {intercept}") + * + * if loss in CLASSIFICATION_LOSS: # <<<<<<<<<<<<<< + * if sorted(np.unique(y)) != [-1, 1]: + * raise ValueError(f"expected y vector to only have two unique values (-1 and 1) (Binary Classification), " + */ + } + + /* "l0learn/interface.pyx":448 + * gamma_min = 1e-7 + * + * if lambda_grid is None: # <<<<<<<<<<<<<< + * lambda_grid = [[0.]] + * auto_lambda = True + */ + __pyx_t_3 = (__pyx_v_lambda_grid == Py_None); + __pyx_t_4 = (__pyx_t_3 != 0); + if (__pyx_t_4) { + + /* "l0learn/interface.pyx":449 + * + * if lambda_grid is None: + * lambda_grid = [[0.]] # <<<<<<<<<<<<<< + * auto_lambda = True + * if not isinstance(num_lambda, int) or num_lambda < 1: + */ + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_float_0_); + __Pyx_GIVEREF(__pyx_float_0_); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_float_0_); + __pyx_t_6 = PyList_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_2); + PyList_SET_ITEM(__pyx_t_6, 0, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_lambda_grid, __pyx_t_6); + __pyx_t_6 = 0; + + /* "l0learn/interface.pyx":450 + * if lambda_grid is None: + * lambda_grid = [[0.]] + * auto_lambda = True # <<<<<<<<<<<<<< + * if not isinstance(num_lambda, int) or num_lambda < 1: + * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") + */ + __pyx_v_auto_lambda = 1; + + /* "l0learn/interface.pyx":451 + * lambda_grid = [[0.]] + * auto_lambda = True + * if not isinstance(num_lambda, int) or num_lambda < 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") + * if not isinstance(num_gamma, int) or num_gamma < 1: + */ + __pyx_t_3 = PyInt_Check(__pyx_v_num_lambda); + __pyx_t_1 = ((!(__pyx_t_3 != 0)) != 0); + if (!__pyx_t_1) { + } else { + __pyx_t_4 = __pyx_t_1; + goto __pyx_L60_bool_binop_done; + } + __pyx_t_6 = PyObject_RichCompare(__pyx_v_num_lambda, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 451, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 451, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_4 = __pyx_t_1; + __pyx_L60_bool_binop_done:; + if (unlikely(__pyx_t_4)) { + + /* "l0learn/interface.pyx":452 + * auto_lambda = True + * if not isinstance(num_lambda, int) or num_lambda < 1: + * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") # <<<<<<<<<<<<<< + * if not isinstance(num_gamma, int) or num_gamma < 1: + * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") + */ + __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 452, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_num_lambda_to_a_positiv); + __pyx_t_9 += 76; + __Pyx_GIVEREF(__pyx_kp_u_expected_num_lambda_to_a_positiv); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_num_lambda_to_a_positiv); + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 452, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_kp_u__5); + __pyx_t_9 += 1; + __Pyx_GIVEREF(__pyx_kp_u__5); + PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u__5); + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_6, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 452, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 452, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 452, __pyx_L1_error) + + /* "l0learn/interface.pyx":451 + * lambda_grid = [[0.]] + * auto_lambda = True + * if not isinstance(num_lambda, int) or num_lambda < 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") + * if not isinstance(num_gamma, int) or num_gamma < 1: + */ + } + + /* "l0learn/interface.pyx":453 + * if not isinstance(num_lambda, int) or num_lambda < 1: + * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") + * if not isinstance(num_gamma, int) or num_gamma < 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") + * if penalty == "L0" and num_gamma != 1: + */ + __pyx_t_1 = PyInt_Check(__pyx_v_num_gamma); + __pyx_t_3 = ((!(__pyx_t_1 != 0)) != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_4 = __pyx_t_3; + goto __pyx_L63_bool_binop_done; + } + __pyx_t_6 = PyObject_RichCompare(__pyx_v_num_gamma, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 453, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 453, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_4 = __pyx_t_3; + __pyx_L63_bool_binop_done:; + if (unlikely(__pyx_t_4)) { + + /* "l0learn/interface.pyx":454 + * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") + * if not isinstance(num_gamma, int) or num_gamma < 1: + * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") # <<<<<<<<<<<<<< + * if penalty == "L0" and num_gamma != 1: + * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") + */ + __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 454, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_num_gamma_to_a_positive); + __pyx_t_9 += 75; + __Pyx_GIVEREF(__pyx_kp_u_expected_num_gamma_to_a_positive); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_num_gamma_to_a_positive); + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 454, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_kp_u__5); + __pyx_t_9 += 1; + __Pyx_GIVEREF(__pyx_kp_u__5); + PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u__5); + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_6, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 454, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 454, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 454, __pyx_L1_error) + + /* "l0learn/interface.pyx":453 + * if not isinstance(num_lambda, int) or num_lambda < 1: + * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") + * if not isinstance(num_gamma, int) or num_gamma < 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") + * if penalty == "L0" and num_gamma != 1: + */ + } + + /* "l0learn/interface.pyx":455 + * if not isinstance(num_gamma, int) or num_gamma < 1: + * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") + * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") + * else: # lambda_grid should be a List[List[float]] + */ + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 455, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_3 != 0); + if (__pyx_t_1) { + } else { + __pyx_t_4 = __pyx_t_1; + goto __pyx_L66_bool_binop_done; + } + __pyx_t_6 = __Pyx_PyInt_NeObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 455, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 455, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_4 = __pyx_t_1; + __pyx_L66_bool_binop_done:; + if (unlikely(__pyx_t_4)) { + + /* "l0learn/interface.pyx":456 + * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") + * if penalty == "L0" and num_gamma != 1: + * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") # <<<<<<<<<<<<<< + * else: # lambda_grid should be a List[List[float]] + * if num_gamma is not None: + */ + __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 456, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_num_gamma_to_1_when_pen); + __pyx_t_9 += 53; + __Pyx_GIVEREF(__pyx_kp_u_expected_num_gamma_to_1_when_pen); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_num_gamma_to_1_when_pen); + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 456, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_kp_u__5); + __pyx_t_9 += 1; + __Pyx_GIVEREF(__pyx_kp_u__5); + PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u__5); + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_6, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 456, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 456, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 456, __pyx_L1_error) + + /* "l0learn/interface.pyx":455 + * if not isinstance(num_gamma, int) or num_gamma < 1: + * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") + * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") + * else: # lambda_grid should be a List[List[float]] + */ + } + + /* "l0learn/interface.pyx":448 + * gamma_min = 1e-7 + * + * if lambda_grid is None: # <<<<<<<<<<<<<< + * lambda_grid = [[0.]] + * auto_lambda = True + */ + goto __pyx_L58; + } + + /* "l0learn/interface.pyx":458 + * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") + * else: # lambda_grid should be a List[List[float]] + * if num_gamma is not None: # <<<<<<<<<<<<<< + * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " + * f"but got {num_gamma}") + */ + /*else*/ { + __pyx_t_4 = (__pyx_v_num_gamma != Py_None); + __pyx_t_1 = (__pyx_t_4 != 0); + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":460 + * if num_gamma is not None: + * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " + * f"but got {num_gamma}") # <<<<<<<<<<<<<< + * num_gamma = len(lambda_grid) + * + */ + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 460, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + + /* "l0learn/interface.pyx":459 + * else: # lambda_grid should be a List[List[float]] + * if num_gamma is not None: + * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " # <<<<<<<<<<<<<< + * f"but got {num_gamma}") + * num_gamma = len(lambda_grid) + */ + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_gamma_to_be_None_if, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 459, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 459, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 459, __pyx_L1_error) + + /* "l0learn/interface.pyx":458 + * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") + * else: # lambda_grid should be a List[List[float]] + * if num_gamma is not None: # <<<<<<<<<<<<<< + * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " + * f"but got {num_gamma}") + */ + } + + /* "l0learn/interface.pyx":461 + * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " + * f"but got {num_gamma}") + * num_gamma = len(lambda_grid) # <<<<<<<<<<<<<< + * + * if num_lambda is not None: + */ + __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 461, __pyx_L1_error) + __pyx_t_6 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 461, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF_SET(__pyx_v_num_gamma, __pyx_t_6); + __pyx_t_6 = 0; + + /* "l0learn/interface.pyx":463 + * num_gamma = len(lambda_grid) + * + * if num_lambda is not None: # <<<<<<<<<<<<<< + * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " + * f"but got {num_lambda}") + */ + __pyx_t_1 = (__pyx_v_num_lambda != Py_None); + __pyx_t_4 = (__pyx_t_1 != 0); + if (unlikely(__pyx_t_4)) { + + /* "l0learn/interface.pyx":465 + * if num_lambda is not None: + * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " + * f"but got {num_lambda}") # <<<<<<<<<<<<<< + * num_lambda = 0 # This value is ignored. + * auto_lambda = False + */ + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 465, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + + /* "l0learn/interface.pyx":464 + * + * if num_lambda is not None: + * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " # <<<<<<<<<<<<<< + * f"but got {num_lambda}") + * num_lambda = 0 # This value is ignored. + */ + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_lambda_to_be_None_i, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 464, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 464, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 464, __pyx_L1_error) + + /* "l0learn/interface.pyx":463 + * num_gamma = len(lambda_grid) + * + * if num_lambda is not None: # <<<<<<<<<<<<<< + * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " + * f"but got {num_lambda}") + */ + } + + /* "l0learn/interface.pyx":466 + * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " + * f"but got {num_lambda}") + * num_lambda = 0 # This value is ignored. # <<<<<<<<<<<<<< + * auto_lambda = False + * bad_lambda_grid = False + */ + __Pyx_INCREF(__pyx_int_0); + __Pyx_DECREF_SET(__pyx_v_num_lambda, __pyx_int_0); + + /* "l0learn/interface.pyx":467 + * f"but got {num_lambda}") + * num_lambda = 0 # This value is ignored. + * auto_lambda = False # <<<<<<<<<<<<<< + * bad_lambda_grid = False + * + */ + __pyx_v_auto_lambda = 0; + + /* "l0learn/interface.pyx":468 + * num_lambda = 0 # This value is ignored. + * auto_lambda = False + * bad_lambda_grid = False # <<<<<<<<<<<<<< + * + * if penalty == "L0" and num_gamma != 1: + */ + __pyx_v_bad_lambda_grid = 0; + + /* "l0learn/interface.pyx":470 + * bad_lambda_grid = False + * + * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") + * + */ + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 470, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_1 != 0); + if (__pyx_t_3) { + } else { + __pyx_t_4 = __pyx_t_3; + goto __pyx_L71_bool_binop_done; + } + __pyx_t_6 = __Pyx_PyInt_NeObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 470, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 470, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_4 = __pyx_t_3; + __pyx_L71_bool_binop_done:; + if (unlikely(__pyx_t_4)) { + + /* "l0learn/interface.pyx":471 + * + * if penalty == "L0" and num_gamma != 1: + * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") # <<<<<<<<<<<<<< + * + * for i, sub_lambda_grid in enumerate(lambda_grid): + */ + __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 471, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_9, 0, ' ', 'd'); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 471, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_of_lengt, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 471, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 471, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 471, __pyx_L1_error) + + /* "l0learn/interface.pyx":470 + * bad_lambda_grid = False + * + * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") + * + */ + } + + /* "l0learn/interface.pyx":473 + * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") + * + * for i, sub_lambda_grid in enumerate(lambda_grid): # <<<<<<<<<<<<<< + * current = float("inf") + * if sub_lambda_grid[0] <= 0: + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_t_6 = __pyx_int_0; + if (likely(PyList_CheckExact(__pyx_v_lambda_grid)) || PyTuple_CheckExact(__pyx_v_lambda_grid)) { + __pyx_t_2 = __pyx_v_lambda_grid; __Pyx_INCREF(__pyx_t_2); __pyx_t_9 = 0; + __pyx_t_13 = NULL; + } else { + __pyx_t_9 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_lambda_grid); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 473, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_13 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 473, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_13)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_8 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_9); __Pyx_INCREF(__pyx_t_8); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 473, __pyx_L1_error) + #else + __pyx_t_8 = PySequence_ITEM(__pyx_t_2, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 473, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + #endif + } else { + if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_9); __Pyx_INCREF(__pyx_t_8); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 473, __pyx_L1_error) + #else + __pyx_t_8 = PySequence_ITEM(__pyx_t_2, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 473, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + #endif + } + } else { + __pyx_t_8 = __pyx_t_13(__pyx_t_2); + if (unlikely(!__pyx_t_8)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 473, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_8); + } + __Pyx_XDECREF_SET(__pyx_v_sub_lambda_grid, __pyx_t_8); + __pyx_t_8 = 0; + __Pyx_INCREF(__pyx_t_6); + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_6); + __pyx_t_8 = __Pyx_PyInt_AddObjC(__pyx_t_6, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 473, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_6); + __pyx_t_6 = __pyx_t_8; + __pyx_t_8 = 0; + + /* "l0learn/interface.pyx":474 + * + * for i, sub_lambda_grid in enumerate(lambda_grid): + * current = float("inf") # <<<<<<<<<<<<<< + * if sub_lambda_grid[0] <= 0: + * raise ValueError(f"Expected all values of lambda_grid to be positive, " + */ + __pyx_t_14 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 474, __pyx_L1_error) + __pyx_v_current = __pyx_t_14; + + /* "l0learn/interface.pyx":475 + * for i, sub_lambda_grid in enumerate(lambda_grid): + * current = float("inf") + * if sub_lambda_grid[0] <= 0: # <<<<<<<<<<<<<< + * raise ValueError(f"Expected all values of lambda_grid to be positive, " + * f"but got lambda_grid[{i}] containing a negative value") + */ + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_sub_lambda_grid, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 475, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = PyObject_RichCompare(__pyx_t_8, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 475, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 475, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(__pyx_t_4)) { + + /* "l0learn/interface.pyx":476 + * current = float("inf") + * if sub_lambda_grid[0] <= 0: + * raise ValueError(f"Expected all values of lambda_grid to be positive, " # <<<<<<<<<<<<<< + * f"but got lambda_grid[{i}] containing a negative value") + * if any(np.diff(sub_lambda_grid) >= 0): + */ + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 476, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_15 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_Expected_all_values_of_lambda_gr); + __pyx_t_15 += 71; + __Pyx_GIVEREF(__pyx_kp_u_Expected_all_values_of_lambda_gr); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_Expected_all_values_of_lambda_gr); + + /* "l0learn/interface.pyx":477 + * if sub_lambda_grid[0] <= 0: + * raise ValueError(f"Expected all values of lambda_grid to be positive, " + * f"but got lambda_grid[{i}] containing a negative value") # <<<<<<<<<<<<<< + * if any(np.diff(sub_lambda_grid) >= 0): + * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " + */ + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 477, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; + __pyx_t_15 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_8); + __pyx_t_8 = 0; + __Pyx_INCREF(__pyx_kp_u_containing_a_negative_value); + __pyx_t_15 += 29; + __Pyx_GIVEREF(__pyx_kp_u_containing_a_negative_value); + PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_containing_a_negative_value); + + /* "l0learn/interface.pyx":476 + * current = float("inf") + * if sub_lambda_grid[0] <= 0: + * raise ValueError(f"Expected all values of lambda_grid to be positive, " # <<<<<<<<<<<<<< + * f"but got lambda_grid[{i}] containing a negative value") + * if any(np.diff(sub_lambda_grid) >= 0): + */ + __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 476, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 476, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(0, 476, __pyx_L1_error) + + /* "l0learn/interface.pyx":475 + * for i, sub_lambda_grid in enumerate(lambda_grid): + * current = float("inf") + * if sub_lambda_grid[0] <= 0: # <<<<<<<<<<<<<< + * raise ValueError(f"Expected all values of lambda_grid to be positive, " + * f"but got lambda_grid[{i}] containing a negative value") + */ + } + + /* "l0learn/interface.pyx":478 + * raise ValueError(f"Expected all values of lambda_grid to be positive, " + * f"but got lambda_grid[{i}] containing a negative value") + * if any(np.diff(sub_lambda_grid) >= 0): # <<<<<<<<<<<<<< + * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " + * f"but got lambda_grid[{i}] containing an increasing value.") + */ + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 478, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_diff); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 478, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_16); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_16))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_16); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_16); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_16, function); + } + } + __pyx_t_7 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_16, __pyx_t_8, __pyx_v_sub_lambda_grid) : __Pyx_PyObject_CallOneArg(__pyx_t_16, __pyx_v_sub_lambda_grid); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 478, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_16 = PyObject_RichCompare(__pyx_t_7, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_16); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 478, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_16); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 478, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 478, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(__pyx_t_4)) { + + /* "l0learn/interface.pyx":479 + * f"but got lambda_grid[{i}] containing a negative value") + * if any(np.diff(sub_lambda_grid) >= 0): + * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " # <<<<<<<<<<<<<< + * f"but got lambda_grid[{i}] containing an increasing value.") + * + */ + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 479, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_15 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_Expected_each_element_of_lambda); + __pyx_t_15 += 91; + __Pyx_GIVEREF(__pyx_kp_u_Expected_each_element_of_lambda); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_Expected_each_element_of_lambda); + + /* "l0learn/interface.pyx":480 + * if any(np.diff(sub_lambda_grid) >= 0): + * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " + * f"but got lambda_grid[{i}] containing an increasing value.") # <<<<<<<<<<<<<< + * + * n, p = X.shape + */ + __pyx_t_16 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 480, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_16); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_16) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_16) : __pyx_t_10; + __pyx_t_15 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_16); + __Pyx_GIVEREF(__pyx_t_16); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_16); + __pyx_t_16 = 0; + __Pyx_INCREF(__pyx_kp_u_containing_an_increasing_value); + __pyx_t_15 += 33; + __Pyx_GIVEREF(__pyx_kp_u_containing_an_increasing_value); + PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_containing_an_increasing_value); + + /* "l0learn/interface.pyx":479 + * f"but got lambda_grid[{i}] containing a negative value") + * if any(np.diff(sub_lambda_grid) >= 0): + * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " # <<<<<<<<<<<<<< + * f"but got lambda_grid[{i}] containing an increasing value.") + * + */ + __pyx_t_16 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 479, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_16); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_16); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 479, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(0, 479, __pyx_L1_error) + + /* "l0learn/interface.pyx":478 + * raise ValueError(f"Expected all values of lambda_grid to be positive, " + * f"but got lambda_grid[{i}] containing a negative value") + * if any(np.diff(sub_lambda_grid) >= 0): # <<<<<<<<<<<<<< + * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " + * f"but got lambda_grid[{i}] containing an increasing value.") + */ + } + + /* "l0learn/interface.pyx":473 + * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") + * + * for i, sub_lambda_grid in enumerate(lambda_grid): # <<<<<<<<<<<<<< + * current = float("inf") + * if sub_lambda_grid[0] <= 0: + */ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __pyx_L58:; + + /* "l0learn/interface.pyx":482 + * f"but got lambda_grid[{i}] containing an increasing value.") + * + * n, p = X.shape # <<<<<<<<<<<<<< + * with_bounds = False + * + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 482, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if ((likely(PyTuple_CheckExact(__pyx_t_6))) || (PyList_CheckExact(__pyx_t_6))) { + PyObject* sequence = __pyx_t_6; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 482, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_7 = PyTuple_GET_ITEM(sequence, 1); + } else { + __pyx_t_2 = PyList_GET_ITEM(sequence, 0); + __pyx_t_7 = PyList_GET_ITEM(sequence, 1); + } + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + #else + __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 482, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 482, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_16 = PyObject_GetIter(__pyx_t_6); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 482, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_16); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_11 = Py_TYPE(__pyx_t_16)->tp_iternext; + index = 0; __pyx_t_2 = __pyx_t_11(__pyx_t_16); if (unlikely(!__pyx_t_2)) goto __pyx_L77_unpacking_failed; + __Pyx_GOTREF(__pyx_t_2); + index = 1; __pyx_t_7 = __pyx_t_11(__pyx_t_16); if (unlikely(!__pyx_t_7)) goto __pyx_L77_unpacking_failed; + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_16), 2) < 0) __PYX_ERR(0, 482, __pyx_L1_error) + __pyx_t_11 = NULL; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + goto __pyx_L78_unpacking_done; + __pyx_L77_unpacking_failed:; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_11 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 482, __pyx_L1_error) + __pyx_L78_unpacking_done:; + } + __Pyx_DECREF_SET(__pyx_v_n, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_p, __pyx_t_7); + __pyx_t_7 = 0; + + /* "l0learn/interface.pyx":483 + * + * n, p = X.shape + * with_bounds = False # <<<<<<<<<<<<<< + * + * if isinstance(lows, float): + */ + __pyx_v_with_bounds = 0; + + /* "l0learn/interface.pyx":485 + * with_bounds = False + * + * if isinstance(lows, float): # <<<<<<<<<<<<<< + * if lows > 0: + * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") + */ + __pyx_t_4 = PyFloat_Check(__pyx_v_lows); + __pyx_t_3 = (__pyx_t_4 != 0); + if (__pyx_t_3) { + + /* "l0learn/interface.pyx":486 + * + * if isinstance(lows, float): + * if lows > 0: # <<<<<<<<<<<<<< + * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") + * elif lows > -float('inf'): + */ + __pyx_t_6 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_GT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 486, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 486, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(__pyx_t_3)) { + + /* "l0learn/interface.pyx":487 + * if isinstance(lows, float): + * if lows > 0: + * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") # <<<<<<<<<<<<<< + * elif lows > -float('inf'): + * with_bounds = True + */ + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 487, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lows_to_be_a_non_positi, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 487, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 487, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 487, __pyx_L1_error) + + /* "l0learn/interface.pyx":486 + * + * if isinstance(lows, float): + * if lows > 0: # <<<<<<<<<<<<<< + * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") + * elif lows > -float('inf'): + */ + } + + /* "l0learn/interface.pyx":488 + * if lows > 0: + * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") + * elif lows > -float('inf'): # <<<<<<<<<<<<<< + * with_bounds = True + * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): + */ + __pyx_t_14 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 488, __pyx_L1_error) + __pyx_t_6 = PyFloat_FromDouble((-__pyx_t_14)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 488, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyObject_RichCompare(__pyx_v_lows, __pyx_t_6, Py_GT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 488, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 488, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (__pyx_t_3) { + + /* "l0learn/interface.pyx":489 + * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") + * elif lows > -float('inf'): + * with_bounds = True # <<<<<<<<<<<<<< + * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): + * with_bounds = True + */ + __pyx_v_with_bounds = 1; + + /* "l0learn/interface.pyx":488 + * if lows > 0: + * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") + * elif lows > -float('inf'): # <<<<<<<<<<<<<< + * with_bounds = True + * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): + */ + } + + /* "l0learn/interface.pyx":485 + * with_bounds = False + * + * if isinstance(lows, float): # <<<<<<<<<<<<<< + * if lows > 0: + * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") + */ + goto __pyx_L79; + } + + /* "l0learn/interface.pyx":490 + * elif lows > -float('inf'): + * with_bounds = True + * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): # <<<<<<<<<<<<<< + * with_bounds = True + * else: + */ + __pyx_t_4 = __Pyx_TypeCheck(__pyx_v_lows, __pyx_ptype_5numpy_ndarray); + __pyx_t_1 = (__pyx_t_4 != 0); + if (__pyx_t_1) { + } else { + __pyx_t_3 = __pyx_t_1; + goto __pyx_L81_bool_binop_done; + } + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_lows, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 490, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyInt_EqObjC(__pyx_t_7, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 490, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 490, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (__pyx_t_1) { + } else { + __pyx_t_3 = __pyx_t_1; + goto __pyx_L81_bool_binop_done; + } + __pyx_t_9 = PyObject_Length(__pyx_v_lows); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 490, __pyx_L1_error) + __pyx_t_6 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 490, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyObject_RichCompare(__pyx_t_6, __pyx_v_p, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 490, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 490, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (__pyx_t_1) { + } else { + __pyx_t_3 = __pyx_t_1; + goto __pyx_L81_bool_binop_done; + } + __pyx_t_7 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 490, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_all, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 490, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 490, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_3 = __pyx_t_1; + __pyx_L81_bool_binop_done:; + if (likely(__pyx_t_3)) { + + /* "l0learn/interface.pyx":491 + * with_bounds = True + * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): + * with_bounds = True # <<<<<<<<<<<<<< + * else: + * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " + */ + __pyx_v_with_bounds = 1; + + /* "l0learn/interface.pyx":490 + * elif lows > -float('inf'): + * with_bounds = True + * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): # <<<<<<<<<<<<<< + * with_bounds = True + * else: + */ + goto __pyx_L79; + } + + /* "l0learn/interface.pyx":493 + * with_bounds = True + * else: + * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " # <<<<<<<<<<<<<< + * f"floats, but got {lows}") + * + */ + /*else*/ { + __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_lows_to_be_a_non_positi_2); + __pyx_t_9 += 72; + __Pyx_GIVEREF(__pyx_kp_u_expected_lows_to_be_a_non_positi_2); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_lows_to_be_a_non_positi_2); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_7); + __pyx_t_7 = 0; + __Pyx_INCREF(__pyx_kp_u_of_non_positives_floats_but_got); + __pyx_t_9 += 34; + __Pyx_GIVEREF(__pyx_kp_u_of_non_positives_floats_but_got); + PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u_of_non_positives_floats_but_got); + + /* "l0learn/interface.pyx":494 + * else: + * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " + * f"floats, but got {lows}") # <<<<<<<<<<<<<< + * + * if isinstance(highs, float): + */ + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_7); + __pyx_t_7 = 0; + + /* "l0learn/interface.pyx":493 + * with_bounds = True + * else: + * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " # <<<<<<<<<<<<<< + * f"floats, but got {lows}") + * + */ + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_6, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 493, __pyx_L1_error) + } + __pyx_L79:; + + /* "l0learn/interface.pyx":496 + * f"floats, but got {lows}") + * + * if isinstance(highs, float): # <<<<<<<<<<<<<< + * if highs < 0: + * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") + */ + __pyx_t_3 = PyFloat_Check(__pyx_v_highs); + __pyx_t_1 = (__pyx_t_3 != 0); + if (__pyx_t_1) { + + /* "l0learn/interface.pyx":497 + * + * if isinstance(highs, float): + * if highs < 0: # <<<<<<<<<<<<<< + * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") + * if highs < float('inf'): + */ + __pyx_t_6 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 497, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 497, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":498 + * if isinstance(highs, float): + * if highs < 0: + * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") # <<<<<<<<<<<<<< + * if highs < float('inf'): + * with_bounds = True + */ + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 498, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_highs_to_be_a_non_negat, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 498, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 498, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 498, __pyx_L1_error) + + /* "l0learn/interface.pyx":497 + * + * if isinstance(highs, float): + * if highs < 0: # <<<<<<<<<<<<<< + * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") + * if highs < float('inf'): + */ + } + + /* "l0learn/interface.pyx":499 + * if highs < 0: + * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") + * if highs < float('inf'): # <<<<<<<<<<<<<< + * with_bounds = True + * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): + */ + __pyx_t_6 = __Pyx_PyNumber_Float(__pyx_n_u_inf); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 499, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyObject_RichCompare(__pyx_v_highs, __pyx_t_6, Py_LT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 499, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 499, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (__pyx_t_1) { + + /* "l0learn/interface.pyx":500 + * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") + * if highs < float('inf'): + * with_bounds = True # <<<<<<<<<<<<<< + * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): + * with_bounds = True + */ + __pyx_v_with_bounds = 1; + + /* "l0learn/interface.pyx":499 + * if highs < 0: + * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") + * if highs < float('inf'): # <<<<<<<<<<<<<< + * with_bounds = True + * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): + */ + } + + /* "l0learn/interface.pyx":496 + * f"floats, but got {lows}") + * + * if isinstance(highs, float): # <<<<<<<<<<<<<< + * if highs < 0: + * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") + */ + goto __pyx_L85; + } + + /* "l0learn/interface.pyx":501 + * if highs < float('inf'): + * with_bounds = True + * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): # <<<<<<<<<<<<<< + * with_bounds = True + * else: + */ + __pyx_t_3 = __Pyx_TypeCheck(__pyx_v_highs, __pyx_ptype_5numpy_ndarray); + __pyx_t_4 = (__pyx_t_3 != 0); + if (__pyx_t_4) { + } else { + __pyx_t_1 = __pyx_t_4; + goto __pyx_L88_bool_binop_done; + } + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_highs, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 501, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyInt_EqObjC(__pyx_t_7, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 501, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 501, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (__pyx_t_4) { + } else { + __pyx_t_1 = __pyx_t_4; + goto __pyx_L88_bool_binop_done; + } + __pyx_t_9 = PyObject_Length(__pyx_v_highs); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 501, __pyx_L1_error) + __pyx_t_6 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 501, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyObject_RichCompare(__pyx_t_6, __pyx_v_p, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 501, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 501, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (__pyx_t_4) { + } else { + __pyx_t_1 = __pyx_t_4; + goto __pyx_L88_bool_binop_done; + } + __pyx_t_7 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 501, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 501, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_1 = __pyx_t_4; + __pyx_L88_bool_binop_done:; + if (likely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":502 + * with_bounds = True + * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): + * with_bounds = True # <<<<<<<<<<<<<< + * else: + * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " + */ + __pyx_v_with_bounds = 1; + + /* "l0learn/interface.pyx":501 + * if highs < float('inf'): + * with_bounds = True + * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): # <<<<<<<<<<<<<< + * with_bounds = True + * else: + */ + goto __pyx_L85; + } + + /* "l0learn/interface.pyx":504 + * with_bounds = True + * else: + * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " # <<<<<<<<<<<<<< + * f"non-negative floats, but got {highs}") + * + */ + /*else*/ { + __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 504, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_highs_to_be_a_non_negat_2); + __pyx_t_9 += 73; + __Pyx_GIVEREF(__pyx_kp_u_expected_highs_to_be_a_non_negat_2); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_highs_to_be_a_non_negat_2); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 504, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_kp_u_of_non_negative_floats_but_got); + __pyx_t_9 += 33; + __Pyx_GIVEREF(__pyx_kp_u_of_non_negative_floats_but_got); + PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_of_non_negative_floats_but_got); + + /* "l0learn/interface.pyx":505 + * else: + * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " + * f"non-negative floats, but got {highs}") # <<<<<<<<<<<<<< + * + * if with_bounds: + */ + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 505, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_6); + __pyx_t_6 = 0; + + /* "l0learn/interface.pyx":504 + * with_bounds = True + * else: + * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " # <<<<<<<<<<<<<< + * f"non-negative floats, but got {highs}") + * + */ + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 504, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 504, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(0, 504, __pyx_L1_error) + } + __pyx_L85:; + + /* "l0learn/interface.pyx":507 + * f"non-negative floats, but got {highs}") + * + * if with_bounds: # <<<<<<<<<<<<<< + * if isinstance(lows, float): + * lows = np.ones(p) * lows + */ + __pyx_t_1 = (__pyx_v_with_bounds != 0); + if (__pyx_t_1) { + + /* "l0learn/interface.pyx":508 + * + * if with_bounds: + * if isinstance(lows, float): # <<<<<<<<<<<<<< + * lows = np.ones(p) * lows + * if isinstance(highs, float): + */ + __pyx_t_1 = PyFloat_Check(__pyx_v_lows); + __pyx_t_4 = (__pyx_t_1 != 0); + if (__pyx_t_4) { + + /* "l0learn/interface.pyx":509 + * if with_bounds: + * if isinstance(lows, float): + * lows = np.ones(p) * lows # <<<<<<<<<<<<<< + * if isinstance(highs, float): + * highs = np.ones(p) * highs + */ + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 509, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_ones); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 509, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + __pyx_t_7 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_6, __pyx_v_p) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_p); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 509, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyNumber_Multiply(__pyx_t_7, __pyx_v_lows); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 509, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_2); + __pyx_t_2 = 0; + + /* "l0learn/interface.pyx":508 + * + * if with_bounds: + * if isinstance(lows, float): # <<<<<<<<<<<<<< + * lows = np.ones(p) * lows + * if isinstance(highs, float): + */ + } + + /* "l0learn/interface.pyx":510 + * if isinstance(lows, float): + * lows = np.ones(p) * lows + * if isinstance(highs, float): # <<<<<<<<<<<<<< + * highs = np.ones(p) * highs + * + */ + __pyx_t_4 = PyFloat_Check(__pyx_v_highs); + __pyx_t_1 = (__pyx_t_4 != 0); + if (__pyx_t_1) { + + /* "l0learn/interface.pyx":511 + * lows = np.ones(p) * lows + * if isinstance(highs, float): + * highs = np.ones(p) * highs # <<<<<<<<<<<<<< + * + * if any(lows >= highs): + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 511, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ones); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 511, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + __pyx_t_2 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_v_p) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_p); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 511, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = PyNumber_Multiply(__pyx_t_2, __pyx_v_highs); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 511, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_6); + __pyx_t_6 = 0; + + /* "l0learn/interface.pyx":510 + * if isinstance(lows, float): + * lows = np.ones(p) * lows + * if isinstance(highs, float): # <<<<<<<<<<<<<< + * highs = np.ones(p) * highs + * + */ + } + + /* "l0learn/interface.pyx":513 + * highs = np.ones(p) * highs + * + * if any(lows >= highs): # <<<<<<<<<<<<<< + * bad_bounds = np.argwhere(lows >= highs) + * raise ValueError(f"expected to be high to be elementwise greater than lows, " + */ + __pyx_t_6 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 513, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 513, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 513, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(__pyx_t_1)) { + + /* "l0learn/interface.pyx":514 + * + * if any(lows >= highs): + * bad_bounds = np.argwhere(lows >= highs) # <<<<<<<<<<<<<< + * raise ValueError(f"expected to be high to be elementwise greater than lows, " + * f"but got indices {bad_bounds[0]} where that is not the case ") + */ + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_argwhere); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 514, __pyx_L1_error) + __pyx_t_16 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_16)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_16); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + __pyx_t_2 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_16, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); + __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_v_bad_bounds = __pyx_t_2; + __pyx_t_2 = 0; + + /* "l0learn/interface.pyx":515 + * if any(lows >= highs): + * bad_bounds = np.argwhere(lows >= highs) + * raise ValueError(f"expected to be high to be elementwise greater than lows, " # <<<<<<<<<<<<<< + * f"but got indices {bad_bounds[0]} where that is not the case ") + * else: + */ + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 515, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_to_be_high_to_be_elemen); + __pyx_t_9 += 73; + __Pyx_GIVEREF(__pyx_kp_u_expected_to_be_high_to_be_elemen); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_u_expected_to_be_high_to_be_elemen); + + /* "l0learn/interface.pyx":516 + * bad_bounds = np.argwhere(lows >= highs) + * raise ValueError(f"expected to be high to be elementwise greater than lows, " + * f"but got indices {bad_bounds[0]} where that is not the case ") # <<<<<<<<<<<<<< + * else: + * lows = np.array([0.]) + */ + __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_bad_bounds, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 516, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 516, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_kp_u_where_that_is_not_the_case); + __pyx_t_9 += 28; + __Pyx_GIVEREF(__pyx_kp_u_where_that_is_not_the_case); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_kp_u_where_that_is_not_the_case); + + /* "l0learn/interface.pyx":515 + * if any(lows >= highs): + * bad_bounds = np.argwhere(lows >= highs) + * raise ValueError(f"expected to be high to be elementwise greater than lows, " # <<<<<<<<<<<<<< + * f"but got indices {bad_bounds[0]} where that is not the case ") + * else: + */ + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_2, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 515, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 515, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 515, __pyx_L1_error) + + /* "l0learn/interface.pyx":513 + * highs = np.ones(p) * highs + * + * if any(lows >= highs): # <<<<<<<<<<<<<< + * bad_bounds = np.argwhere(lows >= highs) + * raise ValueError(f"expected to be high to be elementwise greater than lows, " + */ + } + + /* "l0learn/interface.pyx":507 + * f"non-negative floats, but got {highs}") + * + * if with_bounds: # <<<<<<<<<<<<<< + * if isinstance(lows, float): + * lows = np.ones(p) * lows + */ + goto __pyx_L92; + } + + /* "l0learn/interface.pyx":518 + * f"but got indices {bad_bounds[0]} where that is not the case ") + * else: + * lows = np.array([0.]) # <<<<<<<<<<<<<< + * highs = np.array(([0.])) + * + */ + /*else*/ { + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 518, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_array); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 518, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = PyList_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 518, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_INCREF(__pyx_float_0_); + __Pyx_GIVEREF(__pyx_float_0_); + PyList_SET_ITEM(__pyx_t_6, 0, __pyx_float_0_); + __pyx_t_16 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_16)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_16); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + __pyx_t_2 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_16, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); + __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 518, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_2); + __pyx_t_2 = 0; + + /* "l0learn/interface.pyx":519 + * else: + * lows = np.array([0.]) + * highs = np.array(([0.])) # <<<<<<<<<<<<<< + * + * cdef vector[vector[double]] c_lambda_grid + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 519, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_array); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 519, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyList_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 519, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_INCREF(__pyx_float_0_); + __Pyx_GIVEREF(__pyx_float_0_); + PyList_SET_ITEM(__pyx_t_7, 0, __pyx_float_0_); + __pyx_t_16 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_16)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_16); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + __pyx_t_2 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_16, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); + __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 519, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_2); + __pyx_t_2 = 0; + } + __pyx_L92:; + + /* "l0learn/interface.pyx":522 + * + * cdef vector[vector[double]] c_lambda_grid + * try: # <<<<<<<<<<<<<< + * c_lambda_grid = lambda_grid + * except TypeError: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19); + __Pyx_XGOTREF(__pyx_t_17); + __Pyx_XGOTREF(__pyx_t_18); + __Pyx_XGOTREF(__pyx_t_19); + /*try:*/ { + + /* "l0learn/interface.pyx":523 + * cdef vector[vector[double]] c_lambda_grid + * try: + * c_lambda_grid = lambda_grid # <<<<<<<<<<<<<< + * except TypeError: + * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") + */ + __pyx_t_20 = __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_lambda_grid); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 523, __pyx_L96_error) + __pyx_v_c_lambda_grid = __pyx_t_20; + + /* "l0learn/interface.pyx":522 + * + * cdef vector[vector[double]] c_lambda_grid + * try: # <<<<<<<<<<<<<< + * c_lambda_grid = lambda_grid + * except TypeError: + */ + } + __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; + __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; + goto __pyx_L101_try_end; + __pyx_L96_error:; + __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "l0learn/interface.pyx":524 + * try: + * c_lambda_grid = lambda_grid + * except TypeError: # <<<<<<<<<<<<<< + * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") + * + */ + __pyx_t_21 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); + if (__pyx_t_21) { + __Pyx_AddTraceback("l0learn.interface.cvfit", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(0, 524, __pyx_L98_except_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + + /* "l0learn/interface.pyx":525 + * c_lambda_grid = lambda_grid + * except TypeError: + * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") # <<<<<<<<<<<<<< + * + * cdef string c_loss = loss.encode('UTF-8') + */ + __pyx_t_16 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 525, __pyx_L98_except_error) + __Pyx_GOTREF(__pyx_t_16); + __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_be_a_lis, __pyx_t_16); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 525, __pyx_L98_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __pyx_t_16 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 525, __pyx_L98_except_error) + __Pyx_GOTREF(__pyx_t_16); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_Raise(__pyx_t_16, 0, 0, 0); + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __PYX_ERR(0, 525, __pyx_L98_except_error) + } + goto __pyx_L98_except_error; + __pyx_L98_except_error:; + + /* "l0learn/interface.pyx":522 + * + * cdef vector[vector[double]] c_lambda_grid + * try: # <<<<<<<<<<<<<< + * c_lambda_grid = lambda_grid + * except TypeError: + */ + __Pyx_XGIVEREF(__pyx_t_17); + __Pyx_XGIVEREF(__pyx_t_18); + __Pyx_XGIVEREF(__pyx_t_19); + __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_18, __pyx_t_19); + goto __pyx_L1_error; + __pyx_L101_try_end:; + } + + /* "l0learn/interface.pyx":527 + * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") + * + * cdef string c_loss = loss.encode('UTF-8') # <<<<<<<<<<<<<< + * cdef string c_penalty = penalty.encode('UTF-8') + * cdef string c_algorithim = algorithm.encode('UTF-8') + */ + if (unlikely(__pyx_v_loss == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); + __PYX_ERR(0, 527, __pyx_L1_error) + } + __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_loss); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 527, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 527, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_v_c_loss = __pyx_t_22; + + /* "l0learn/interface.pyx":528 + * + * cdef string c_loss = loss.encode('UTF-8') + * cdef string c_penalty = penalty.encode('UTF-8') # <<<<<<<<<<<<<< + * cdef string c_algorithim = algorithm.encode('UTF-8') + * + */ + if (unlikely(__pyx_v_penalty == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); + __PYX_ERR(0, 528, __pyx_L1_error) + } + __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_penalty); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 528, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 528, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_v_c_penalty = __pyx_t_22; + + /* "l0learn/interface.pyx":529 + * cdef string c_loss = loss.encode('UTF-8') + * cdef string c_penalty = penalty.encode('UTF-8') + * cdef string c_algorithim = algorithm.encode('UTF-8') # <<<<<<<<<<<<<< + * + * cdef cvfitmodel results + */ + if (unlikely(__pyx_v_algorithm == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); + __PYX_ERR(0, 529, __pyx_L1_error) + } + __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_algorithm); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 529, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 529, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_v_c_algorithim = __pyx_t_22; + + /* "l0learn/interface.pyx":532 + * + * cdef cvfitmodel results + * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< + * results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), + * y=numpy_to_dvec_d(y), + */ + __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_X, __pyx_ptype_5numpy_ndarray); + __pyx_t_4 = (__pyx_t_1 != 0); + if (__pyx_t_4) { + + /* "l0learn/interface.pyx":533 + * cdef cvfitmodel results + * if isinstance(X, np.ndarray): + * results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< + * y=numpy_to_dvec_d(y), + * Loss=c_loss, + */ + if (!(likely(((__pyx_v_X) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_X, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 533, __pyx_L1_error) + + /* "l0learn/interface.pyx":538 + * Penalty=c_penalty, + * Algorithm=c_algorithim, + * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< + * G_ncols=num_lambda, + * G_nrows=num_gamma, + */ + __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 538, __pyx_L1_error) + + /* "l0learn/interface.pyx":539 + * Algorithm=c_algorithim, + * NnzStopNum=max_support_size, + * G_ncols=num_lambda, # <<<<<<<<<<<<<< + * G_nrows=num_gamma, + * Lambda2Max=gamma_max, + */ + __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 539, __pyx_L1_error) + + /* "l0learn/interface.pyx":540 + * NnzStopNum=max_support_size, + * G_ncols=num_lambda, + * G_nrows=num_gamma, # <<<<<<<<<<<<<< + * Lambda2Max=gamma_max, + * Lambda2Min=gamma_min, + */ + __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 540, __pyx_L1_error) + + /* "l0learn/interface.pyx":543 + * Lambda2Max=gamma_max, + * Lambda2Min=gamma_min, + * PartialSort=partial_sort, # <<<<<<<<<<<<<< + * MaxIters=max_iter, + * rtol=rtol, + */ + __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 543, __pyx_L1_error) + + /* "l0learn/interface.pyx":544 + * Lambda2Min=gamma_min, + * PartialSort=partial_sort, + * MaxIters=max_iter, # <<<<<<<<<<<<<< + * rtol=rtol, + * atol=atol, + */ + __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 544, __pyx_L1_error) + + /* "l0learn/interface.pyx":547 + * rtol=rtol, + * atol=atol, + * ActiveSet=active_set, # <<<<<<<<<<<<<< + * ActiveSetNum=active_set_num, + * MaxNumSwaps=max_swaps, + */ + __pyx_t_28 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_28 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 547, __pyx_L1_error) + + /* "l0learn/interface.pyx":548 + * atol=atol, + * ActiveSet=active_set, + * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< + * MaxNumSwaps=max_swaps, + * ScaleDownFactor=scale_down_factor, + */ + __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 548, __pyx_L1_error) + + /* "l0learn/interface.pyx":549 + * ActiveSet=active_set, + * ActiveSetNum=active_set_num, + * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< + * ScaleDownFactor=scale_down_factor, + * ScreenSize=screen_size, + */ + __pyx_t_30 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_30 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 549, __pyx_L1_error) + + /* "l0learn/interface.pyx":551 + * MaxNumSwaps=max_swaps, + * ScaleDownFactor=scale_down_factor, + * ScreenSize=screen_size, # <<<<<<<<<<<<<< + * LambdaU=not auto_lambda, + * Lambdas=c_lambda_grid, + */ + __pyx_t_31 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_31 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 551, __pyx_L1_error) + + /* "l0learn/interface.pyx":554 + * LambdaU=not auto_lambda, + * Lambdas=c_lambda_grid, + * nfolds=num_folds, # <<<<<<<<<<<<<< + * seed=seed, + * ExcludeFirstK=exclude_first_k, + */ + __pyx_t_32 = __Pyx_PyInt_As_unsigned_int(__pyx_v_num_folds); if (unlikely((__pyx_t_32 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 554, __pyx_L1_error) + + /* "l0learn/interface.pyx":555 + * Lambdas=c_lambda_grid, + * nfolds=num_folds, + * seed=seed, # <<<<<<<<<<<<<< + * ExcludeFirstK=exclude_first_k, + * Intercept=intercept, + */ + __pyx_t_14 = __pyx_PyFloat_AsDouble(__pyx_v_seed); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 555, __pyx_L1_error) + + /* "l0learn/interface.pyx":556 + * nfolds=num_folds, + * seed=seed, + * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< + * Intercept=intercept, + * withBounds=with_bounds, + */ + __pyx_t_33 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_33 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 556, __pyx_L1_error) + + /* "l0learn/interface.pyx":557 + * seed=seed, + * ExcludeFirstK=exclude_first_k, + * Intercept=intercept, # <<<<<<<<<<<<<< + * withBounds=with_bounds, + * Lows=numpy_to_dvec_d(lows), + */ + __pyx_t_34 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_34 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 557, __pyx_L1_error) + + /* "l0learn/interface.pyx":559 + * Intercept=intercept, + * withBounds=with_bounds, + * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< + * Highs=numpy_to_dvec_d(highs)) + * else: # isinstance(X, csc_matrix) + */ + if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 559, __pyx_L1_error) + + /* "l0learn/interface.pyx":560 + * withBounds=with_bounds, + * Lows=numpy_to_dvec_d(lows), + * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< + * else: # isinstance(X, csc_matrix) + * results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), + */ + if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 560, __pyx_L1_error) + + /* "l0learn/interface.pyx":533 + * cdef cvfitmodel results + * if isinstance(X, np.ndarray): + * results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< + * y=numpy_to_dvec_d(y), + * Loss=c_loss, + */ + __pyx_v_results = __pyx_f_7l0learn_9interface__L0LearnCV_dense(__pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_X)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_23, __pyx_t_24, __pyx_t_25, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_26, __pyx_t_27, __pyx_v_rtol, __pyx_v_atol, __pyx_t_28, __pyx_t_29, __pyx_t_30, __pyx_v_scale_down_factor, __pyx_t_31, (!(__pyx_v_auto_lambda != 0)), __pyx_v_c_lambda_grid, __pyx_t_32, __pyx_t_14, __pyx_t_33, __pyx_t_34, __pyx_v_with_bounds, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); + + /* "l0learn/interface.pyx":532 + * + * cdef cvfitmodel results + * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< + * results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), + * y=numpy_to_dvec_d(y), + */ + goto __pyx_L104; + } + + /* "l0learn/interface.pyx":562 + * Highs=numpy_to_dvec_d(highs)) + * else: # isinstance(X, csc_matrix) + * results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< + * y=numpy_to_dvec_d(y), + * Loss=c_loss, + */ + /*else*/ { + + /* "l0learn/interface.pyx":567 + * Penalty=c_penalty, + * Algorithm=c_algorithim, + * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< + * G_ncols=num_lambda, + * G_nrows=num_gamma, + */ + __pyx_t_33 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_33 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 567, __pyx_L1_error) + + /* "l0learn/interface.pyx":568 + * Algorithm=c_algorithim, + * NnzStopNum=max_support_size, + * G_ncols=num_lambda, # <<<<<<<<<<<<<< + * G_nrows=num_gamma, + * Lambda2Max=gamma_max, + */ + __pyx_t_31 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_31 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 568, __pyx_L1_error) + + /* "l0learn/interface.pyx":569 + * NnzStopNum=max_support_size, + * G_ncols=num_lambda, + * G_nrows=num_gamma, # <<<<<<<<<<<<<< + * Lambda2Max=gamma_max, + * Lambda2Min=gamma_min, + */ + __pyx_t_30 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_30 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 569, __pyx_L1_error) + + /* "l0learn/interface.pyx":572 + * Lambda2Max=gamma_max, + * Lambda2Min=gamma_min, + * PartialSort=partial_sort, # <<<<<<<<<<<<<< + * MaxIters=max_iter, + * rtol=rtol, + */ + __pyx_t_34 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_34 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 572, __pyx_L1_error) + + /* "l0learn/interface.pyx":573 + * Lambda2Min=gamma_min, + * PartialSort=partial_sort, + * MaxIters=max_iter, # <<<<<<<<<<<<<< + * rtol=rtol, + * atol=atol, + */ + __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 573, __pyx_L1_error) + + /* "l0learn/interface.pyx":576 + * rtol=rtol, + * atol=atol, + * ActiveSet=active_set, # <<<<<<<<<<<<<< + * ActiveSetNum=active_set_num, + * MaxNumSwaps=max_swaps, + */ + __pyx_t_28 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_28 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 576, __pyx_L1_error) + + /* "l0learn/interface.pyx":577 + * atol=atol, + * ActiveSet=active_set, + * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< + * MaxNumSwaps=max_swaps, + * ScaleDownFactor=scale_down_factor, + */ + __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 577, __pyx_L1_error) + + /* "l0learn/interface.pyx":578 + * ActiveSet=active_set, + * ActiveSetNum=active_set_num, + * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< + * ScaleDownFactor=scale_down_factor, + * ScreenSize=screen_size, + */ + __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 578, __pyx_L1_error) + + /* "l0learn/interface.pyx":580 + * MaxNumSwaps=max_swaps, + * ScaleDownFactor=scale_down_factor, + * ScreenSize=screen_size, # <<<<<<<<<<<<<< + * LambdaU=not auto_lambda, + * Lambdas=c_lambda_grid, + */ + __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 580, __pyx_L1_error) + + /* "l0learn/interface.pyx":583 + * LambdaU=not auto_lambda, + * Lambdas=c_lambda_grid, + * nfolds=num_folds, # <<<<<<<<<<<<<< + * seed=seed, + * ExcludeFirstK=exclude_first_k, + */ + __pyx_t_32 = __Pyx_PyInt_As_unsigned_int(__pyx_v_num_folds); if (unlikely((__pyx_t_32 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 583, __pyx_L1_error) + + /* "l0learn/interface.pyx":584 + * Lambdas=c_lambda_grid, + * nfolds=num_folds, + * seed=seed, # <<<<<<<<<<<<<< + * ExcludeFirstK=exclude_first_k, + * Intercept=intercept, + */ + __pyx_t_14 = __pyx_PyFloat_AsDouble(__pyx_v_seed); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 584, __pyx_L1_error) + + /* "l0learn/interface.pyx":585 + * nfolds=num_folds, + * seed=seed, + * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< + * Intercept=intercept, + * withBounds=with_bounds, + */ + __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 585, __pyx_L1_error) + + /* "l0learn/interface.pyx":586 + * seed=seed, + * ExcludeFirstK=exclude_first_k, + * Intercept=intercept, # <<<<<<<<<<<<<< + * withBounds=with_bounds, + * Lows=numpy_to_dvec_d(lows), + */ + __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 586, __pyx_L1_error) + + /* "l0learn/interface.pyx":588 + * Intercept=intercept, + * withBounds=with_bounds, + * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< + * Highs=numpy_to_dvec_d(highs)) + * + */ + if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 588, __pyx_L1_error) + + /* "l0learn/interface.pyx":589 + * withBounds=with_bounds, + * Lows=numpy_to_dvec_d(lows), + * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< + * + * return {"NnzCount": results.NnzCount, + */ + if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 589, __pyx_L1_error) + + /* "l0learn/interface.pyx":562 + * Highs=numpy_to_dvec_d(highs)) + * else: # isinstance(X, csc_matrix) + * results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< + * y=numpy_to_dvec_d(y), + * Loss=c_loss, + */ + __pyx_v_results = __pyx_f_7l0learn_9interface__L0LearnCV_sparse(__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(__pyx_v_X), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_33, __pyx_t_31, __pyx_t_30, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_34, __pyx_t_29, __pyx_v_rtol, __pyx_v_atol, __pyx_t_28, __pyx_t_27, __pyx_t_25, __pyx_v_scale_down_factor, __pyx_t_24, (!(__pyx_v_auto_lambda != 0)), __pyx_v_c_lambda_grid, __pyx_t_32, __pyx_t_14, __pyx_t_23, __pyx_t_26, __pyx_v_with_bounds, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); + } + __pyx_L104:; + + /* "l0learn/interface.pyx":591 + * Highs=numpy_to_dvec_d(highs)) + * + * return {"NnzCount": results.NnzCount, # <<<<<<<<<<<<<< + * "Lambda0": results.Lambda0, + * "Lambda12": results.Lambda12, + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_7 = __Pyx_PyDict_NewPresized(8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 591, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(__pyx_v_results.NnzCount); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 591, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_NnzCount, __pyx_t_6) < 0) __PYX_ERR(0, 591, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "l0learn/interface.pyx":592 + * + * return {"NnzCount": results.NnzCount, + * "Lambda0": results.Lambda0, # <<<<<<<<<<<<<< + * "Lambda12": results.Lambda12, + * "Beta": sp_dmat_field_to_list(results.Beta), + */ + __pyx_t_6 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_results.Lambda0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 592, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_Lambda0, __pyx_t_6) < 0) __PYX_ERR(0, 591, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "l0learn/interface.pyx":593 + * return {"NnzCount": results.NnzCount, + * "Lambda0": results.Lambda0, + * "Lambda12": results.Lambda12, # <<<<<<<<<<<<<< + * "Beta": sp_dmat_field_to_list(results.Beta), + * "Intercept": results.Intercept, + */ + __pyx_t_6 = __pyx_convert_vector_to_py_double(__pyx_v_results.Lambda12); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 593, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_Lambda12, __pyx_t_6) < 0) __PYX_ERR(0, 591, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "l0learn/interface.pyx":594 + * "Lambda0": results.Lambda0, + * "Lambda12": results.Lambda12, + * "Beta": sp_dmat_field_to_list(results.Beta), # <<<<<<<<<<<<<< + * "Intercept": results.Intercept, + * "Converged": results.Converged, + */ + __pyx_t_6 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_results.Beta); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 594, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_Beta, __pyx_t_6) < 0) __PYX_ERR(0, 591, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "l0learn/interface.pyx":595 + * "Lambda12": results.Lambda12, + * "Beta": sp_dmat_field_to_list(results.Beta), + * "Intercept": results.Intercept, # <<<<<<<<<<<<<< + * "Converged": results.Converged, + * "CVMeans": dvec_field_to_list(results.CVMeans)[0], + */ + __pyx_t_6 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_results.Intercept); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 595, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_Intercept, __pyx_t_6) < 0) __PYX_ERR(0, 591, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "l0learn/interface.pyx":596 + * "Beta": sp_dmat_field_to_list(results.Beta), + * "Intercept": results.Intercept, + * "Converged": results.Converged, # <<<<<<<<<<<<<< + * "CVMeans": dvec_field_to_list(results.CVMeans)[0], + * "CVSDs": dvec_field_to_list(results.CVSDs)[0]} + */ + __pyx_t_6 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(__pyx_v_results.Converged); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 596, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_Converged, __pyx_t_6) < 0) __PYX_ERR(0, 591, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "l0learn/interface.pyx":597 + * "Intercept": results.Intercept, + * "Converged": results.Converged, + * "CVMeans": dvec_field_to_list(results.CVMeans)[0], # <<<<<<<<<<<<<< + * "CVSDs": dvec_field_to_list(results.CVSDs)[0]} + * + */ + __pyx_t_6 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_results.CVMeans); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 597, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (unlikely(__pyx_t_6 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 597, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_GetItemInt_List(__pyx_t_6, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 597, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_CVMeans, __pyx_t_2) < 0) __PYX_ERR(0, 591, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "l0learn/interface.pyx":598 + * "Converged": results.Converged, + * "CVMeans": dvec_field_to_list(results.CVMeans)[0], + * "CVSDs": dvec_field_to_list(results.CVSDs)[0]} # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_results.CVSDs); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 598, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(__pyx_t_2 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 598, __pyx_L1_error) + } + __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_t_2, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 598, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_CVSDs, __pyx_t_6) < 0) __PYX_ERR(0, 591, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_r = __pyx_t_7; + __pyx_t_7 = 0; + goto __pyx_L0; + + /* "l0learn/interface.pyx":350 + * "Converged": results.Converged} + * + * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< + * y: np.ndarray, + * loss: str = "SquaredHinge", + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_16); + __Pyx_AddTraceback("l0learn.interface.cvfit", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XDECREF(__pyx_v_p); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XDECREF(__pyx_v_sub_lambda_grid); + __Pyx_XDECREF(__pyx_v_bad_bounds); + __Pyx_XDECREF(__pyx_v_penalty); + __Pyx_XDECREF(__pyx_v_num_lambda); + __Pyx_XDECREF(__pyx_v_num_gamma); + __Pyx_XDECREF(__pyx_v_lambda_grid); + __Pyx_XDECREF(__pyx_v_lows); + __Pyx_XDECREF(__pyx_v_highs); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/interface.pyx":601 + * + * + * cdef fitmodel _L0LearnFit_dense(const dmat& X, # <<<<<<<<<<<<<< + * const dvec& y, + * const string Loss, + */ + +static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_dense(arma::dmat const &__pyx_v_X, arma::dvec const &__pyx_v_y, std::string const __pyx_v_Loss, std::string const __pyx_v_Penalty, std::string const __pyx_v_Algorithm, size_t const __pyx_v_NnzStopNum, size_t const __pyx_v_G_ncols, size_t const __pyx_v_G_nrows, double const __pyx_v_Lambda2Max, double const __pyx_v_Lambda2Min, bool const __pyx_v_PartialSort, size_t const __pyx_v_MaxIters, double const __pyx_v_rtol, double const __pyx_v_atol, bool const __pyx_v_ActiveSet, size_t const __pyx_v_ActiveSetNum, size_t const __pyx_v_MaxNumSwaps, double const __pyx_v_ScaleDownFactor, size_t const __pyx_v_ScreenSize, bool const __pyx_v_LambdaU, std::vector > const &__pyx_v_Lambdas, size_t const __pyx_v_ExcludeFirstK, bool const __pyx_v_Intercept, bool const __pyx_v_withBounds, arma::dvec const &__pyx_v_Lows, arma::dvec const &__pyx_v_Highs) { + fitmodel __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_L0LearnFit_dense", 0); + + /* "l0learn/interface.pyx":627 + * const dvec &Lows, + * const dvec &Highs): + * return L0LearnFit[dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< + * MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, + * Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs) + */ + __pyx_r = L0LearnFit(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); + goto __pyx_L0; + + /* "l0learn/interface.pyx":601 + * + * + * cdef fitmodel _L0LearnFit_dense(const dmat& X, # <<<<<<<<<<<<<< + * const dvec& y, + * const string Loss, + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/interface.pyx":632 + * + * + * cdef fitmodel _L0LearnFit_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< + * const dvec& y, + * const string Loss, + */ + +static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_sparse(arma::sp_dmat const &__pyx_v_X, arma::dvec const &__pyx_v_y, std::string const __pyx_v_Loss, std::string const __pyx_v_Penalty, std::string const __pyx_v_Algorithm, size_t const __pyx_v_NnzStopNum, size_t const __pyx_v_G_ncols, size_t const __pyx_v_G_nrows, double const __pyx_v_Lambda2Max, double const __pyx_v_Lambda2Min, bool const __pyx_v_PartialSort, size_t const __pyx_v_MaxIters, double const __pyx_v_rtol, double const __pyx_v_atol, bool const __pyx_v_ActiveSet, size_t const __pyx_v_ActiveSetNum, size_t const __pyx_v_MaxNumSwaps, double const __pyx_v_ScaleDownFactor, size_t const __pyx_v_ScreenSize, bool const __pyx_v_LambdaU, std::vector > const &__pyx_v_Lambdas, size_t const __pyx_v_ExcludeFirstK, bool const __pyx_v_Intercept, bool const __pyx_v_withBounds, arma::dvec const &__pyx_v_Lows, arma::dvec const &__pyx_v_Highs) { + fitmodel __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_L0LearnFit_sparse", 0); + + /* "l0learn/interface.pyx":658 + * const dvec &Lows, + * const dvec &Highs): + * return L0LearnFit[sp_dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< + * MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, + * Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs) + */ + __pyx_r = L0LearnFit(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); + goto __pyx_L0; + + /* "l0learn/interface.pyx":632 + * + * + * cdef fitmodel _L0LearnFit_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< + * const dvec& y, + * const string Loss, + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/interface.pyx":663 + * + * + * cdef cvfitmodel _L0LearnCV_dense(const dmat& X, # <<<<<<<<<<<<<< + * const dvec& y, + * const string Loss, + */ + +static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_dense(arma::dmat const &__pyx_v_X, arma::dvec const &__pyx_v_y, std::string const __pyx_v_Loss, std::string const __pyx_v_Penalty, std::string const __pyx_v_Algorithm, size_t const __pyx_v_NnzStopNum, size_t const __pyx_v_G_ncols, size_t const __pyx_v_G_nrows, double const __pyx_v_Lambda2Max, double const __pyx_v_Lambda2Min, bool const __pyx_v_PartialSort, size_t const __pyx_v_MaxIters, double const __pyx_v_rtol, double const __pyx_v_atol, bool const __pyx_v_ActiveSet, size_t const __pyx_v_ActiveSetNum, size_t const __pyx_v_MaxNumSwaps, double const __pyx_v_ScaleDownFactor, size_t const __pyx_v_ScreenSize, bool const __pyx_v_LambdaU, std::vector > const &__pyx_v_Lambdas, unsigned int const __pyx_v_nfolds, double const __pyx_v_seed, size_t const __pyx_v_ExcludeFirstK, bool const __pyx_v_Intercept, bool const __pyx_v_withBounds, arma::dvec const &__pyx_v_Lows, arma::dvec const &__pyx_v_Highs) { + cvfitmodel __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_L0LearnCV_dense", 0); + + /* "l0learn/interface.pyx":691 + * const dvec &Lows, + * const dvec &Highs): + * return L0LearnCV[dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< + * MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, + * Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs) + */ + __pyx_r = L0LearnCV(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_nfolds, __pyx_v_seed, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); + goto __pyx_L0; + + /* "l0learn/interface.pyx":663 + * + * + * cdef cvfitmodel _L0LearnCV_dense(const dmat& X, # <<<<<<<<<<<<<< + * const dvec& y, + * const string Loss, + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/interface.pyx":696 + * + * + * cdef cvfitmodel _L0LearnCV_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< + * const dvec& y, + * const string Loss, + */ + +static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_sparse(arma::sp_dmat const &__pyx_v_X, arma::dvec const &__pyx_v_y, std::string const __pyx_v_Loss, std::string const __pyx_v_Penalty, std::string const __pyx_v_Algorithm, size_t const __pyx_v_NnzStopNum, size_t const __pyx_v_G_ncols, size_t const __pyx_v_G_nrows, double const __pyx_v_Lambda2Max, double const __pyx_v_Lambda2Min, bool const __pyx_v_PartialSort, size_t const __pyx_v_MaxIters, double const __pyx_v_rtol, double const __pyx_v_atol, bool const __pyx_v_ActiveSet, size_t const __pyx_v_ActiveSetNum, size_t const __pyx_v_MaxNumSwaps, double const __pyx_v_ScaleDownFactor, size_t const __pyx_v_ScreenSize, bool const __pyx_v_LambdaU, std::vector > const &__pyx_v_Lambdas, unsigned int const __pyx_v_nfolds, double const __pyx_v_seed, size_t const __pyx_v_ExcludeFirstK, bool const __pyx_v_Intercept, bool const __pyx_v_withBounds, arma::dvec const &__pyx_v_Lows, arma::dvec const &__pyx_v_Highs) { + cvfitmodel __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_L0LearnCV_sparse", 0); + + /* "l0learn/interface.pyx":724 + * const dvec &Lows, + * const dvec &Highs): + * return L0LearnCV[sp_dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< + * MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, + * Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs) + */ + __pyx_r = L0LearnCV(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_nfolds, __pyx_v_seed, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); + goto __pyx_L0; + + /* "l0learn/interface.pyx":696 + * + * + * cdef cvfitmodel _L0LearnCV_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< + * const dvec& y, + * const string Loss, + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":734 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":735 + * + * cdef inline object PyArray_MultiIterNew1(a): + * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew2(a, b): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 735, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":734 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":737 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":738 + * + * cdef inline object PyArray_MultiIterNew2(a, b): + * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 738, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":737 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":740 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":741 + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 741, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":740 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":743 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":744 + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 744, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":743 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":746 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":747 + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< + * + * cdef inline tuple PyDataType_SHAPE(dtype d): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 747, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":746 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":749 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":750 + * + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< + * return d.subarray.shape + * else: + */ + __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); + if (__pyx_t_1) { + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":751 + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape # <<<<<<<<<<<<<< + * else: + * return () + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); + __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":750 + * + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< + * return d.subarray.shape + * else: + */ + } + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":753 + * return d.subarray.shape + * else: + * return () # <<<<<<<<<<<<<< + * + * + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_empty_tuple); + __pyx_r = __pyx_empty_tuple; + goto __pyx_L0; + } + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":749 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":868 + * int _import_umath() except -1 + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) + */ + +static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_array_base", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":869 + * + * cdef inline void set_array_base(ndarray arr, object base): + * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< + * PyArray_SetBaseObject(arr, base) + * + */ + Py_INCREF(__pyx_v_base); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":870 + * cdef inline void set_array_base(ndarray arr, object base): + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< + * + * cdef inline object get_array_base(ndarray arr): + */ + (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":868 + * int _import_umath() except -1 + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":872 + * PyArray_SetBaseObject(arr, base) + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) + * if base is NULL: + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { + PyObject *__pyx_v_base; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("get_array_base", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":873 + * + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< + * if base is NULL: + * return None + */ + __pyx_v_base = PyArray_BASE(__pyx_v_arr); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":874 + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) + * if base is NULL: # <<<<<<<<<<<<<< + * return None + * return base + */ + __pyx_t_1 = ((__pyx_v_base == NULL) != 0); + if (__pyx_t_1) { + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":875 + * base = PyArray_BASE(arr) + * if base is NULL: + * return None # <<<<<<<<<<<<<< + * return base + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":874 + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) + * if base is NULL: # <<<<<<<<<<<<<< + * return None + * return base + */ + } + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":876 + * if base is NULL: + * return None + * return base # <<<<<<<<<<<<<< + * + * # Versions of the import_* functions which are more suitable for + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_base)); + __pyx_r = ((PyObject *)__pyx_v_base); + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":872 + * PyArray_SetBaseObject(arr, base) + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) + * if base is NULL: + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":880 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * __pyx_import_array() + */ + +static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("import_array", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":881 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * __pyx_import_array() + * except Exception: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":882 + * cdef inline int import_array() except -1: + * try: + * __pyx_import_array() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") + */ + __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 882, __pyx_L3_error) + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":881 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * __pyx_import_array() + * except Exception: + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":883 + * try: + * __pyx_import_array() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.multiarray failed to import") + * + */ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 883, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":884 + * __pyx_import_array() + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_umath() except -1: + */ + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 884, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 884, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":881 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * __pyx_import_array() + * except Exception: + */ + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":880 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * __pyx_import_array() + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":886 + * raise ImportError("numpy.core.multiarray failed to import") + * + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + +static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("import_umath", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":887 + * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":888 + * cdef inline int import_umath() except -1: + * try: + * _import_umath() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.umath failed to import") + */ + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 888, __pyx_L3_error) + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":887 + * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":889 + * try: + * _import_umath() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.umath failed to import") + * + */ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 889, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":890 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_ufunc() except -1: + */ + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 890, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 890, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":887 + * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":886 + * raise ImportError("numpy.core.multiarray failed to import") + * + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":892 + * raise ImportError("numpy.core.umath failed to import") + * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + +static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("import_ufunc", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":893 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":894 + * cdef inline int import_ufunc() except -1: + * try: + * _import_umath() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.umath failed to import") + */ + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 894, __pyx_L3_error) + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":893 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":895 + * try: + * _import_umath() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.umath failed to import") + * + */ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 895, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":896 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< + * + * cdef extern from *: + */ + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 896, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 896, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":893 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":892 + * raise ImportError("numpy.core.umath failed to import") + * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "vector.from_py":45 + * + * @cname("__pyx_convert_vector_from_py_double") + * cdef vector[X] __pyx_convert_vector_from_py_double(object o) except *: # <<<<<<<<<<<<<< + * cdef vector[X] v + * for item in o: + */ + +static std::vector __pyx_convert_vector_from_py_double(PyObject *__pyx_v_o) { + std::vector __pyx_v_v; + PyObject *__pyx_v_item = NULL; + std::vector __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *(*__pyx_t_3)(PyObject *); + PyObject *__pyx_t_4 = NULL; + double __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_convert_vector_from_py_double", 0); + + /* "vector.from_py":47 + * cdef vector[X] __pyx_convert_vector_from_py_double(object o) except *: + * cdef vector[X] v + * for item in o: # <<<<<<<<<<<<<< + * v.push_back(item) + * return v + */ + if (likely(PyList_CheckExact(__pyx_v_o)) || PyTuple_CheckExact(__pyx_v_o)) { + __pyx_t_1 = __pyx_v_o; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + __pyx_t_3 = NULL; + } else { + __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_o); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 47, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_3)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(2, 47, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(2, 47, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } + } else { + __pyx_t_4 = __pyx_t_3(__pyx_t_1); + if (unlikely(!__pyx_t_4)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(2, 47, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_4); + __pyx_t_4 = 0; + + /* "vector.from_py":48 + * cdef vector[X] v + * for item in o: + * v.push_back(item) # <<<<<<<<<<<<<< + * return v + * + */ + __pyx_t_5 = __pyx_PyFloat_AsDouble(__pyx_v_item); if (unlikely((__pyx_t_5 == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 48, __pyx_L1_error) + __pyx_v_v.push_back(((double)__pyx_t_5)); + + /* "vector.from_py":47 + * cdef vector[X] __pyx_convert_vector_from_py_double(object o) except *: + * cdef vector[X] v + * for item in o: # <<<<<<<<<<<<<< + * v.push_back(item) + * return v + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "vector.from_py":49 + * for item in o: + * v.push_back(item) + * return v # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_v; + goto __pyx_L0; + + /* "vector.from_py":45 + * + * @cname("__pyx_convert_vector_from_py_double") + * cdef vector[X] __pyx_convert_vector_from_py_double(object o) except *: # <<<<<<<<<<<<<< + * cdef vector[X] v + * for item in o: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("vector.from_py.__pyx_convert_vector_from_py_double", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_item); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static std::vector > __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(PyObject *__pyx_v_o) { + std::vector > __pyx_v_v; + PyObject *__pyx_v_item = NULL; + std::vector > __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *(*__pyx_t_3)(PyObject *); + PyObject *__pyx_t_4 = NULL; + std::vector __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___", 0); + + /* "vector.from_py":47 + * cdef vector[X] __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(object o) except *: + * cdef vector[X] v + * for item in o: # <<<<<<<<<<<<<< + * v.push_back(item) + * return v + */ + if (likely(PyList_CheckExact(__pyx_v_o)) || PyTuple_CheckExact(__pyx_v_o)) { + __pyx_t_1 = __pyx_v_o; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + __pyx_t_3 = NULL; + } else { + __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_o); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 47, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_3)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(2, 47, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(2, 47, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } + } else { + __pyx_t_4 = __pyx_t_3(__pyx_t_1); + if (unlikely(!__pyx_t_4)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(2, 47, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_4); + __pyx_t_4 = 0; + + /* "vector.from_py":48 + * cdef vector[X] v + * for item in o: + * v.push_back(item) # <<<<<<<<<<<<<< + * return v + * + */ + __pyx_t_5 = __pyx_convert_vector_from_py_double(__pyx_v_item); if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 48, __pyx_L1_error) + __pyx_v_v.push_back(((std::vector )__pyx_t_5)); + + /* "vector.from_py":47 + * cdef vector[X] __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(object o) except *: + * cdef vector[X] v + * for item in o: # <<<<<<<<<<<<<< + * v.push_back(item) + * return v + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "vector.from_py":49 + * for item in o: + * v.push_back(item) + * return v # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_v; + goto __pyx_L0; + + /* "vector.from_py":45 + * + * @cname("__pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___") + * cdef vector[X] __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(object o) except *: # <<<<<<<<<<<<<< + * cdef vector[X] v + * for item in o: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("vector.from_py.__pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_item); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "string.from_py":13 + * + * @cname("__pyx_convert_string_from_py_std__in_string") + * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: # <<<<<<<<<<<<<< + * cdef Py_ssize_t length = 0 + * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) + */ + +static std::string __pyx_convert_string_from_py_std__in_string(PyObject *__pyx_v_o) { + Py_ssize_t __pyx_v_length; + char const *__pyx_v_data; + std::string __pyx_r; + __Pyx_RefNannyDeclarations + char const *__pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_convert_string_from_py_std__in_string", 0); + + /* "string.from_py":14 + * @cname("__pyx_convert_string_from_py_std__in_string") + * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: + * cdef Py_ssize_t length = 0 # <<<<<<<<<<<<<< + * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) + * return string(data, length) + */ + __pyx_v_length = 0; + + /* "string.from_py":15 + * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: + * cdef Py_ssize_t length = 0 + * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) # <<<<<<<<<<<<<< + * return string(data, length) + * + */ + __pyx_t_1 = __Pyx_PyObject_AsStringAndSize(__pyx_v_o, (&__pyx_v_length)); if (unlikely(__pyx_t_1 == ((char const *)NULL))) __PYX_ERR(2, 15, __pyx_L1_error) + __pyx_v_data = __pyx_t_1; + + /* "string.from_py":16 + * cdef Py_ssize_t length = 0 + * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) + * return string(data, length) # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = std::string(__pyx_v_data, __pyx_v_length); + goto __pyx_L0; + + /* "string.from_py":13 + * + * @cname("__pyx_convert_string_from_py_std__in_string") + * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: # <<<<<<<<<<<<<< + * cdef Py_ssize_t length = 0 + * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("string.from_py.__pyx_convert_string_from_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "vector.to_py":60 + * + * @cname("__pyx_convert_vector_to_py_size_t") + * cdef object __pyx_convert_vector_to_py_size_t(vector[X]& v): # <<<<<<<<<<<<<< + * return [v[i] for i in range(v.size())] + * + */ + +static PyObject *__pyx_convert_vector_to_py_size_t(const std::vector &__pyx_v_v) { + size_t __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + size_t __pyx_t_2; + size_t __pyx_t_3; + size_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_size_t", 0); + + /* "vector.to_py":61 + * @cname("__pyx_convert_vector_to_py_size_t") + * cdef object __pyx_convert_vector_to_py_size_t(vector[X]& v): + * return [v[i] for i in range(v.size())] # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_v_v.size(); + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + __pyx_t_5 = __Pyx_PyInt_FromSize_t((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "vector.to_py":60 + * + * @cname("__pyx_convert_vector_to_py_size_t") + * cdef object __pyx_convert_vector_to_py_size_t(vector[X]& v): # <<<<<<<<<<<<<< + * return [v[i] for i in range(v.size())] + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_size_t", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(const std::vector > &__pyx_v_v) { + size_t __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + size_t __pyx_t_2; + size_t __pyx_t_3; + size_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___", 0); + + /* "vector.to_py":61 + * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___") + * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(vector[X]& v): + * return [v[i] for i in range(v.size())] # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_v_v.size(); + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + __pyx_t_5 = __pyx_convert_vector_to_py_size_t((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "vector.to_py":60 + * + * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___") + * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(vector[X]& v): # <<<<<<<<<<<<<< + * return [v[i] for i in range(v.size())] + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_convert_vector_to_py_double(const std::vector &__pyx_v_v) { + size_t __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + size_t __pyx_t_2; + size_t __pyx_t_3; + size_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_double", 0); + + /* "vector.to_py":61 + * @cname("__pyx_convert_vector_to_py_double") + * cdef object __pyx_convert_vector_to_py_double(vector[X]& v): + * return [v[i] for i in range(v.size())] # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_v_v.size(); + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + __pyx_t_5 = PyFloat_FromDouble((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "vector.to_py":60 + * + * @cname("__pyx_convert_vector_to_py_double") + * cdef object __pyx_convert_vector_to_py_double(vector[X]& v): # <<<<<<<<<<<<<< + * return [v[i] for i in range(v.size())] + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_double", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(const std::vector > &__pyx_v_v) { + size_t __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + size_t __pyx_t_2; + size_t __pyx_t_3; + size_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___", 0); + + /* "vector.to_py":61 + * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___") + * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(vector[X]& v): + * return [v[i] for i in range(v.size())] # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_v_v.size(); + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + __pyx_t_5 = __pyx_convert_vector_to_py_double((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "vector.to_py":60 + * + * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___") + * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(vector[X]& v): # <<<<<<<<<<<<<< + * return [v[i] for i in range(v.size())] + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_convert_vector_to_py_bool(const std::vector &__pyx_v_v) { + size_t __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + size_t __pyx_t_2; + size_t __pyx_t_3; + size_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_bool", 0); + + /* "vector.to_py":61 + * @cname("__pyx_convert_vector_to_py_bool") + * cdef object __pyx_convert_vector_to_py_bool(vector[X]& v): + * return [v[i] for i in range(v.size())] # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_v_v.size(); + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + __pyx_t_5 = __Pyx_PyBool_FromLong((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "vector.to_py":60 + * + * @cname("__pyx_convert_vector_to_py_bool") + * cdef object __pyx_convert_vector_to_py_bool(vector[X]& v): # <<<<<<<<<<<<<< + * return [v[i] for i in range(v.size())] + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_bool", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(const std::vector > &__pyx_v_v) { + size_t __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + size_t __pyx_t_2; + size_t __pyx_t_3; + size_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___", 0); + + /* "vector.to_py":61 + * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___") + * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(vector[X]& v): + * return [v[i] for i in range(v.size())] # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_v_v.size(); + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + __pyx_t_5 = __pyx_convert_vector_to_py_bool((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "vector.to_py":60 + * + * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___") + * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(vector[X]& v): # <<<<<<<<<<<<<< + * return [v[i] for i in range(v.size())] + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; + +#if PY_MAJOR_VERSION >= 3 +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_interface(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_interface}, + {0, NULL} +}; +#endif + +static struct PyModuleDef __pyx_moduledef = { + PyModuleDef_HEAD_INIT, + "interface", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif +#ifndef CYTHON_SMALL_CODE +#if defined(__clang__) + #define CYTHON_SMALL_CODE +#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) + #define CYTHON_SMALL_CODE __attribute__((cold)) +#else + #define CYTHON_SMALL_CODE +#endif +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_u_Beta, __pyx_k_Beta, sizeof(__pyx_k_Beta), 0, 1, 0, 1}, + {&__pyx_n_u_CD, __pyx_k_CD, sizeof(__pyx_k_CD), 0, 1, 0, 1}, + {&__pyx_n_u_CDPSI, __pyx_k_CDPSI, sizeof(__pyx_k_CDPSI), 0, 1, 0, 1}, + {&__pyx_n_s_CLASSIFICATION_LOSS, __pyx_k_CLASSIFICATION_LOSS, sizeof(__pyx_k_CLASSIFICATION_LOSS), 0, 0, 1, 1}, + {&__pyx_n_u_CVMeans, __pyx_k_CVMeans, sizeof(__pyx_k_CVMeans), 0, 1, 0, 1}, + {&__pyx_n_u_CVSDs, __pyx_k_CVSDs, sizeof(__pyx_k_CVSDs), 0, 1, 0, 1}, + {&__pyx_n_u_Converged, __pyx_k_Converged, sizeof(__pyx_k_Converged), 0, 1, 0, 1}, + {&__pyx_kp_u_Expected_all_values_of_lambda_gr, __pyx_k_Expected_all_values_of_lambda_gr, sizeof(__pyx_k_Expected_all_values_of_lambda_gr), 0, 1, 0, 0}, + {&__pyx_kp_u_Expected_each_element_of_lambda, __pyx_k_Expected_each_element_of_lambda, sizeof(__pyx_k_Expected_each_element_of_lambda), 0, 1, 0, 0}, + {&__pyx_n_u_F_CONTIGUOUS, __pyx_k_F_CONTIGUOUS, sizeof(__pyx_k_F_CONTIGUOUS), 0, 1, 0, 1}, + {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1}, + {&__pyx_n_u_Intercept, __pyx_k_Intercept, sizeof(__pyx_k_Intercept), 0, 1, 0, 1}, + {&__pyx_n_u_L0, __pyx_k_L0, sizeof(__pyx_k_L0), 0, 1, 0, 1}, + {&__pyx_n_u_L0L1, __pyx_k_L0L1, sizeof(__pyx_k_L0L1), 0, 1, 0, 1}, + {&__pyx_n_u_L0L2, __pyx_k_L0L2, sizeof(__pyx_k_L0L2), 0, 1, 0, 1}, + {&__pyx_kp_u_L0_Penalty_requires_lambda_grid, __pyx_k_L0_Penalty_requires_lambda_grid, sizeof(__pyx_k_L0_Penalty_requires_lambda_grid), 0, 1, 0, 0}, + {&__pyx_n_u_Lambda0, __pyx_k_Lambda0, sizeof(__pyx_k_Lambda0), 0, 1, 0, 1}, + {&__pyx_n_u_Lambda12, __pyx_k_Lambda12, sizeof(__pyx_k_Lambda12), 0, 1, 0, 1}, + {&__pyx_n_s_List, __pyx_k_List, sizeof(__pyx_k_List), 0, 0, 1, 1}, + {&__pyx_n_u_Logistic, __pyx_k_Logistic, sizeof(__pyx_k_Logistic), 0, 1, 0, 1}, + {&__pyx_n_u_NnzCount, __pyx_k_NnzCount, sizeof(__pyx_k_NnzCount), 0, 1, 0, 1}, + {&__pyx_kp_u_None, __pyx_k_None, sizeof(__pyx_k_None), 0, 1, 0, 0}, + {&__pyx_n_s_NotImplementedError, __pyx_k_NotImplementedError, sizeof(__pyx_k_NotImplementedError), 0, 0, 1, 1}, + {&__pyx_kp_u_Not_supported, __pyx_k_Not_supported, sizeof(__pyx_k_Not_supported), 0, 1, 0, 0}, + {&__pyx_n_s_Optional, __pyx_k_Optional, sizeof(__pyx_k_Optional), 0, 0, 1, 1}, + {&__pyx_n_s_SUPPORTED_ALGORITHM, __pyx_k_SUPPORTED_ALGORITHM, sizeof(__pyx_k_SUPPORTED_ALGORITHM), 0, 0, 1, 1}, + {&__pyx_n_s_SUPPORTED_LOSS, __pyx_k_SUPPORTED_LOSS, sizeof(__pyx_k_SUPPORTED_LOSS), 0, 0, 1, 1}, + {&__pyx_n_s_SUPPORTED_PENALTY, __pyx_k_SUPPORTED_PENALTY, sizeof(__pyx_k_SUPPORTED_PENALTY), 0, 0, 1, 1}, + {&__pyx_n_u_SquaredError, __pyx_k_SquaredError, sizeof(__pyx_k_SquaredError), 0, 1, 0, 1}, + {&__pyx_n_u_SquaredHinge, __pyx_k_SquaredHinge, sizeof(__pyx_k_SquaredHinge), 0, 1, 0, 1}, + {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, + {&__pyx_n_s_Union, __pyx_k_Union, sizeof(__pyx_k_Union), 0, 0, 1, 1}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s_X, __pyx_k_X, sizeof(__pyx_k_X), 0, 0, 1, 1}, + {&__pyx_kp_u__5, __pyx_k__5, sizeof(__pyx_k__5), 0, 1, 0, 0}, + {&__pyx_n_s_active_set, __pyx_k_active_set, sizeof(__pyx_k_active_set), 0, 0, 1, 1}, + {&__pyx_n_s_active_set_num, __pyx_k_active_set_num, sizeof(__pyx_k_active_set_num), 0, 0, 1, 1}, + {&__pyx_n_s_algorithm, __pyx_k_algorithm, sizeof(__pyx_k_algorithm), 0, 0, 1, 1}, + {&__pyx_n_s_all, __pyx_k_all, sizeof(__pyx_k_all), 0, 0, 1, 1}, + {&__pyx_n_s_any, __pyx_k_any, sizeof(__pyx_k_any), 0, 0, 1, 1}, + {&__pyx_n_s_argwhere, __pyx_k_argwhere, sizeof(__pyx_k_argwhere), 0, 0, 1, 1}, + {&__pyx_n_s_arr, __pyx_k_arr, sizeof(__pyx_k_arr), 0, 0, 1, 1}, + {&__pyx_n_s_array, __pyx_k_array, sizeof(__pyx_k_array), 0, 0, 1, 1}, + {&__pyx_n_s_atol, __pyx_k_atol, sizeof(__pyx_k_atol), 0, 0, 1, 1}, + {&__pyx_n_s_auto_lambda, __pyx_k_auto_lambda, sizeof(__pyx_k_auto_lambda), 0, 0, 1, 1}, + {&__pyx_n_s_bad_bounds, __pyx_k_bad_bounds, sizeof(__pyx_k_bad_bounds), 0, 0, 1, 1}, + {&__pyx_n_s_bad_lambda_grid, __pyx_k_bad_lambda_grid, sizeof(__pyx_k_bad_lambda_grid), 0, 0, 1, 1}, + {&__pyx_kp_u_but_got, __pyx_k_but_got, sizeof(__pyx_k_but_got), 0, 1, 0, 0}, + {&__pyx_n_s_c_algorithim, __pyx_k_c_algorithim, sizeof(__pyx_k_c_algorithim), 0, 0, 1, 1}, + {&__pyx_n_s_c_lambda_grid, __pyx_k_c_lambda_grid, sizeof(__pyx_k_c_lambda_grid), 0, 0, 1, 1}, + {&__pyx_n_s_c_loss, __pyx_k_c_loss, sizeof(__pyx_k_c_loss), 0, 0, 1, 1}, + {&__pyx_n_s_c_penalty, __pyx_k_c_penalty, sizeof(__pyx_k_c_penalty), 0, 0, 1, 1}, + {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_kp_u_containing_a_negative_value, __pyx_k_containing_a_negative_value, sizeof(__pyx_k_containing_a_negative_value), 0, 1, 0, 0}, + {&__pyx_kp_u_containing_an_increasing_value, __pyx_k_containing_an_increasing_value, sizeof(__pyx_k_containing_an_increasing_value), 0, 1, 0, 0}, + {&__pyx_n_s_csc_matrix, __pyx_k_csc_matrix, sizeof(__pyx_k_csc_matrix), 0, 0, 1, 1}, + {&__pyx_n_s_current, __pyx_k_current, sizeof(__pyx_k_current), 0, 0, 1, 1}, + {&__pyx_n_s_cvfit, __pyx_k_cvfit, sizeof(__pyx_k_cvfit), 0, 0, 1, 1}, + {&__pyx_n_s_data, __pyx_k_data, sizeof(__pyx_k_data), 0, 0, 1, 1}, + {&__pyx_n_s_diff, __pyx_k_diff, sizeof(__pyx_k_diff), 0, 0, 1, 1}, + {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1}, + {&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1}, + {&__pyx_n_s_exclude_first_k, __pyx_k_exclude_first_k, sizeof(__pyx_k_exclude_first_k), 0, 0, 1, 1}, + {&__pyx_kp_u_expected_X_to_be_a_2D_non_degene, __pyx_k_expected_X_to_be_a_2D_non_degene, sizeof(__pyx_k_expected_X_to_be_a_2D_non_degene), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_active_set_num_paramete, __pyx_k_expected_active_set_num_paramete, sizeof(__pyx_k_expected_active_set_num_paramete), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_active_set_parameter_to, __pyx_k_expected_active_set_parameter_to, sizeof(__pyx_k_expected_active_set_parameter_to), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_algorithm_parameter_to, __pyx_k_expected_algorithm_parameter_to, sizeof(__pyx_k_expected_algorithm_parameter_to), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_arr_data_to_be_F_CONTIG, __pyx_k_expected_arr_data_to_be_F_CONTIG, sizeof(__pyx_k_expected_arr_data_to_be_F_CONTIG), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_arr_indices_to_be_F_CON, __pyx_k_expected_arr_indices_to_be_F_CON, sizeof(__pyx_k_expected_arr_indices_to_be_F_CON), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_arr_indptr_to_be_F_CONT, __pyx_k_expected_arr_indptr_to_be_F_CONT, sizeof(__pyx_k_expected_arr_indptr_to_be_F_CONT), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_arr_ndim_to_be_1_or_2_b, __pyx_k_expected_arr_ndim_to_be_1_or_2_b, sizeof(__pyx_k_expected_arr_ndim_to_be_1_or_2_b), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_arr_ndim_to_be_1_or_2_b_2, __pyx_k_expected_arr_ndim_to_be_1_or_2_b_2, sizeof(__pyx_k_expected_arr_ndim_to_be_1_or_2_b_2), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_arr_to_be_F_CONTIGUOUS, __pyx_k_expected_arr_to_be_F_CONTIGUOUS, sizeof(__pyx_k_expected_arr_to_be_F_CONTIGUOUS), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_arr_to_be_of_type, __pyx_k_expected_arr_to_be_of_type, sizeof(__pyx_k_expected_arr_to_be_of_type), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_atol_parameter_to_exist, __pyx_k_expected_atol_parameter_to_exist, sizeof(__pyx_k_expected_atol_parameter_to_exist), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_exclude_first_k_paramet, __pyx_k_expected_exclude_first_k_paramet, sizeof(__pyx_k_expected_exclude_first_k_paramet), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_gamma_max_parameter_to, __pyx_k_expected_gamma_max_parameter_to, sizeof(__pyx_k_expected_gamma_max_parameter_to), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_gamma_max_parameter_to_2, __pyx_k_expected_gamma_max_parameter_to_2, sizeof(__pyx_k_expected_gamma_max_parameter_to_2), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_highs_to_be_a_non_negat, __pyx_k_expected_highs_to_be_a_non_negat, sizeof(__pyx_k_expected_highs_to_be_a_non_negat), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_highs_to_be_a_non_negat_2, __pyx_k_expected_highs_to_be_a_non_negat_2, sizeof(__pyx_k_expected_highs_to_be_a_non_negat_2), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_intercept_parameter_to, __pyx_k_expected_intercept_parameter_to, sizeof(__pyx_k_expected_intercept_parameter_to), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_lambda_grid_to_be_a_lis, __pyx_k_expected_lambda_grid_to_be_a_lis, sizeof(__pyx_k_expected_lambda_grid_to_be_a_lis), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_lambda_grid_to_of_lengt, __pyx_k_expected_lambda_grid_to_of_lengt, sizeof(__pyx_k_expected_lambda_grid_to_of_lengt), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_loss_parameter_to_be_on, __pyx_k_expected_loss_parameter_to_be_on, sizeof(__pyx_k_expected_loss_parameter_to_be_on), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_lows_to_be_a_non_positi, __pyx_k_expected_lows_to_be_a_non_positi, sizeof(__pyx_k_expected_lows_to_be_a_non_positi), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_lows_to_be_a_non_positi_2, __pyx_k_expected_lows_to_be_a_non_positi_2, sizeof(__pyx_k_expected_lows_to_be_a_non_positi_2), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_max_iter_parameter_to_b, __pyx_k_expected_max_iter_parameter_to_b, sizeof(__pyx_k_expected_max_iter_parameter_to_b), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_max_support_size_parame, __pyx_k_expected_max_support_size_parame, sizeof(__pyx_k_expected_max_support_size_parame), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_max_swaps_parameter_to, __pyx_k_expected_max_swaps_parameter_to, sizeof(__pyx_k_expected_max_swaps_parameter_to), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_non_complex_dtype_but_g, __pyx_k_expected_non_complex_dtype_but_g, sizeof(__pyx_k_expected_non_complex_dtype_but_g), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_non_degenerate_dimensio, __pyx_k_expected_non_degenerate_dimensio, sizeof(__pyx_k_expected_non_degenerate_dimensio), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_num_folds_parameter_to, __pyx_k_expected_num_folds_parameter_to, sizeof(__pyx_k_expected_num_folds_parameter_to), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_num_gamma_to_1_when_pen, __pyx_k_expected_num_gamma_to_1_when_pen, sizeof(__pyx_k_expected_num_gamma_to_1_when_pen), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_num_gamma_to_a_positive, __pyx_k_expected_num_gamma_to_a_positive, sizeof(__pyx_k_expected_num_gamma_to_a_positive), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_num_gamma_to_be_None_if, __pyx_k_expected_num_gamma_to_be_None_if, sizeof(__pyx_k_expected_num_gamma_to_be_None_if), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_num_lambda_to_a_positiv, __pyx_k_expected_num_lambda_to_a_positiv, sizeof(__pyx_k_expected_num_lambda_to_a_positiv), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_num_lambda_to_be_None_i, __pyx_k_expected_num_lambda_to_be_None_i, sizeof(__pyx_k_expected_num_lambda_to_be_None_i), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_numerical_dtype_but_got, __pyx_k_expected_numerical_dtype_but_got, sizeof(__pyx_k_expected_numerical_dtype_but_got), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_partial_sort_parameter, __pyx_k_expected_partial_sort_parameter, sizeof(__pyx_k_expected_partial_sort_parameter), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_penalty_parameter_to_be, __pyx_k_expected_penalty_parameter_to_be, sizeof(__pyx_k_expected_penalty_parameter_to_be), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_rtol_parameter_to_exist, __pyx_k_expected_rtol_parameter_to_exist, sizeof(__pyx_k_expected_rtol_parameter_to_exist), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_scale_down_factor_param, __pyx_k_expected_scale_down_factor_param, sizeof(__pyx_k_expected_scale_down_factor_param), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_screen_size_parameter_t, __pyx_k_expected_screen_size_parameter_t, sizeof(__pyx_k_expected_screen_size_parameter_t), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_seed_parameter_to_be_an, __pyx_k_expected_seed_parameter_to_be_an, sizeof(__pyx_k_expected_seed_parameter_to_be_an), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_to_be_high_to_be_elemen, __pyx_k_expected_to_be_high_to_be_elemen, sizeof(__pyx_k_expected_to_be_high_to_be_elemen), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_y_to_be_a_1D_real_numpy, __pyx_k_expected_y_to_be_a_1D_real_numpy, sizeof(__pyx_k_expected_y_to_be_a_1D_real_numpy), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_y_vector_to_only_have_t, __pyx_k_expected_y_vector_to_only_have_t, sizeof(__pyx_k_expected_y_vector_to_only_have_t), 0, 1, 0, 0}, + {&__pyx_n_s_fit, __pyx_k_fit, sizeof(__pyx_k_fit), 0, 0, 1, 1}, + {&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 1}, + {&__pyx_n_s_gamma_max, __pyx_k_gamma_max, sizeof(__pyx_k_gamma_max), 0, 0, 1, 1}, + {&__pyx_n_s_gamma_min, __pyx_k_gamma_min, sizeof(__pyx_k_gamma_min), 0, 0, 1, 1}, + {&__pyx_n_s_highs, __pyx_k_highs, sizeof(__pyx_k_highs), 0, 0, 1, 1}, + {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_indices, __pyx_k_indices, sizeof(__pyx_k_indices), 0, 0, 1, 1}, + {&__pyx_n_s_indptr, __pyx_k_indptr, sizeof(__pyx_k_indptr), 0, 0, 1, 1}, + {&__pyx_n_u_inf, __pyx_k_inf, sizeof(__pyx_k_inf), 0, 1, 0, 1}, + {&__pyx_n_s_intercept, __pyx_k_intercept, sizeof(__pyx_k_intercept), 0, 0, 1, 1}, + {&__pyx_n_s_isrealobj, __pyx_k_isrealobj, sizeof(__pyx_k_isrealobj), 0, 0, 1, 1}, + {&__pyx_n_s_issubdtype, __pyx_k_issubdtype, sizeof(__pyx_k_issubdtype), 0, 0, 1, 1}, + {&__pyx_n_s_l0learn_interface, __pyx_k_l0learn_interface, sizeof(__pyx_k_l0learn_interface), 0, 0, 1, 1}, + {&__pyx_kp_s_l0learn_interface_pyx, __pyx_k_l0learn_interface_pyx, sizeof(__pyx_k_l0learn_interface_pyx), 0, 0, 1, 0}, + {&__pyx_n_s_lambda_grid, __pyx_k_lambda_grid, sizeof(__pyx_k_lambda_grid), 0, 0, 1, 1}, + {&__pyx_n_s_loss, __pyx_k_loss, sizeof(__pyx_k_loss), 0, 0, 1, 1}, + {&__pyx_n_s_lows, __pyx_k_lows, sizeof(__pyx_k_lows), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_max_iter, __pyx_k_max_iter, sizeof(__pyx_k_max_iter), 0, 0, 1, 1}, + {&__pyx_n_s_max_support_size, __pyx_k_max_support_size, sizeof(__pyx_k_max_support_size), 0, 0, 1, 1}, + {&__pyx_n_s_max_swaps, __pyx_k_max_swaps, sizeof(__pyx_k_max_swaps), 0, 0, 1, 1}, + {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_n_s_ndim, __pyx_k_ndim, sizeof(__pyx_k_ndim), 0, 0, 1, 1}, + {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, + {&__pyx_n_s_np_to_arma_check, __pyx_k_np_to_arma_check, sizeof(__pyx_k_np_to_arma_check), 0, 0, 1, 1}, + {&__pyx_n_s_num_folds, __pyx_k_num_folds, sizeof(__pyx_k_num_folds), 0, 0, 1, 1}, + {&__pyx_n_s_num_gamma, __pyx_k_num_gamma, sizeof(__pyx_k_num_gamma), 0, 0, 1, 1}, + {&__pyx_n_s_num_lambda, __pyx_k_num_lambda, sizeof(__pyx_k_num_lambda), 0, 0, 1, 1}, + {&__pyx_n_s_number, __pyx_k_number, sizeof(__pyx_k_number), 0, 0, 1, 1}, + {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, + {&__pyx_kp_u_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 1, 0, 0}, + {&__pyx_kp_u_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 1, 0, 0}, + {&__pyx_kp_u_of_non_negative_floats_but_got, __pyx_k_of_non_negative_floats_but_got, sizeof(__pyx_k_of_non_negative_floats_but_got), 0, 1, 0, 0}, + {&__pyx_kp_u_of_non_positives_floats_but_got, __pyx_k_of_non_positives_floats_but_got, sizeof(__pyx_k_of_non_positives_floats_but_got), 0, 1, 0, 0}, + {&__pyx_n_s_ones, __pyx_k_ones, sizeof(__pyx_k_ones), 0, 0, 1, 1}, + {&__pyx_kp_u_or, __pyx_k_or, sizeof(__pyx_k_or), 0, 1, 0, 0}, + {&__pyx_n_s_p, __pyx_k_p, sizeof(__pyx_k_p), 0, 0, 1, 1}, + {&__pyx_n_s_partial_sort, __pyx_k_partial_sort, sizeof(__pyx_k_partial_sort), 0, 0, 1, 1}, + {&__pyx_n_s_penalty, __pyx_k_penalty, sizeof(__pyx_k_penalty), 0, 0, 1, 1}, + {&__pyx_n_s_product, __pyx_k_product, sizeof(__pyx_k_product), 0, 0, 1, 1}, + {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, + {&__pyx_n_s_results, __pyx_k_results, sizeof(__pyx_k_results), 0, 0, 1, 1}, + {&__pyx_n_s_rtol, __pyx_k_rtol, sizeof(__pyx_k_rtol), 0, 0, 1, 1}, + {&__pyx_n_s_scale_down_factor, __pyx_k_scale_down_factor, sizeof(__pyx_k_scale_down_factor), 0, 0, 1, 1}, + {&__pyx_n_s_scipy_sparse, __pyx_k_scipy_sparse, sizeof(__pyx_k_scipy_sparse), 0, 0, 1, 1}, + {&__pyx_n_s_screen_size, __pyx_k_screen_size, sizeof(__pyx_k_screen_size), 0, 0, 1, 1}, + {&__pyx_n_s_seed, __pyx_k_seed, sizeof(__pyx_k_seed), 0, 0, 1, 1}, + {&__pyx_n_s_shape, __pyx_k_shape, sizeof(__pyx_k_shape), 0, 0, 1, 1}, + {&__pyx_n_s_sub_lambda_grid, __pyx_k_sub_lambda_grid, sizeof(__pyx_k_sub_lambda_grid), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_s_typing, __pyx_k_typing, sizeof(__pyx_k_typing), 0, 0, 1, 1}, + {&__pyx_n_s_unique, __pyx_k_unique, sizeof(__pyx_k_unique), 0, 0, 1, 1}, + {&__pyx_kp_u_where_that_is_not_the_case, __pyx_k_where_that_is_not_the_case, sizeof(__pyx_k_where_that_is_not_the_case), 0, 1, 0, 0}, + {&__pyx_n_s_with_bounds, __pyx_k_with_bounds, sizeof(__pyx_k_with_bounds), 0, 0, 1, 1}, + {&__pyx_n_s_y, __pyx_k_y, sizeof(__pyx_k_y), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 30, __pyx_L1_error) + __pyx_builtin_NotImplementedError = __Pyx_GetBuiltinName(__pyx_n_s_NotImplementedError); if (!__pyx_builtin_NotImplementedError) __PYX_ERR(0, 39, __pyx_L1_error) + __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(0, 229, __pyx_L1_error) + __pyx_builtin_any = __Pyx_GetBuiltinName(__pyx_n_s_any); if (!__pyx_builtin_any) __PYX_ERR(0, 234, __pyx_L1_error) + __pyx_builtin_all = __Pyx_GetBuiltinName(__pyx_n_s_all); if (!__pyx_builtin_all) __PYX_ERR(0, 246, __pyx_L1_error) + __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 280, __pyx_L1_error) + __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 884, __pyx_L1_error) + __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(2, 61, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "l0learn/interface.pyx":30 + * if isinstance(arr, np.ndarray): + * if not arr.flags['F_CONTIGUOUS']: + * raise ValueError("expected arr to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< + * elif isinstance(arr, csc_matrix): + * if not arr.data.flags['F_CONTIGUOUS']: + */ + __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_expected_arr_to_be_F_CONTIGUOUS); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 30, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple_); + __Pyx_GIVEREF(__pyx_tuple_); + + /* "l0learn/interface.pyx":33 + * elif isinstance(arr, csc_matrix): + * if not arr.data.flags['F_CONTIGUOUS']: + * raise ValueError("expected arr.data to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< + * if not arr.indices.flags['F_CONTIGUOUS']: + * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") + */ + __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_data_to_be_F_CONTIG); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); + + /* "l0learn/interface.pyx":35 + * raise ValueError("expected arr.data to be F_CONTIGUOUS.") + * if not arr.indices.flags['F_CONTIGUOUS']: + * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< + * if not arr.indptr.flags['F_CONTIGUOUS']: + * raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") + */ + __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_indices_to_be_F_CON); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 35, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + + /* "l0learn/interface.pyx":37 + * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") + * if not arr.indptr.flags['F_CONTIGUOUS']: + * raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< + * else: + * raise NotImplementedError(f"expected arr to be of type {np.ndarray} or {csc_matrix}, but got {type(arr)}.") + */ + __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_indptr_to_be_F_CONT); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + + /* "l0learn/interface.pyx":42 + * + * if arr.ndim == 0: + * raise ValueError("expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar") # <<<<<<<<<<<<<< + * elif arr.ndim > 2: + * raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") + */ + __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_ndim_to_be_1_or_2_b); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":884 + * __pyx_import_array() + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_umath() except -1: + */ + __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 884, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__11); + __Pyx_GIVEREF(__pyx_tuple__11); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":890 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_ufunc() except -1: + */ + __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 890, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__12); + __Pyx_GIVEREF(__pyx_tuple__12); + + /* "l0learn/interface.pyx":26 + * + * + * def np_to_arma_check(arr): # <<<<<<<<<<<<<< + * # TODO: Add checks for Behaved and OwnsData + * if isinstance(arr, np.ndarray): + */ + __pyx_tuple__13 = PyTuple_Pack(1, __pyx_n_s_arr); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__13); + __Pyx_GIVEREF(__pyx_tuple__13); + __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_np_to_arma_check, 26, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(0, 26, __pyx_L1_error) + + /* "l0learn/interface.pyx":56 + * + * + * SUPPORTED_LOSS = ("SquaredError", "Logistic", "SquaredHinge") # <<<<<<<<<<<<<< + * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] + * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") + */ + __pyx_tuple__15 = PyTuple_Pack(3, __pyx_n_u_SquaredError, __pyx_n_u_Logistic, __pyx_n_u_SquaredHinge); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__15); + __Pyx_GIVEREF(__pyx_tuple__15); + + /* "l0learn/interface.pyx":58 + * SUPPORTED_LOSS = ("SquaredError", "Logistic", "SquaredHinge") + * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] + * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") # <<<<<<<<<<<<<< + * SUPPORTED_ALGORITHM = ("CD", "CDPSI") + * + */ + __pyx_tuple__16 = PyTuple_Pack(3, __pyx_n_u_L0, __pyx_n_u_L0L1, __pyx_n_u_L0L2); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__16); + __Pyx_GIVEREF(__pyx_tuple__16); + + /* "l0learn/interface.pyx":59 + * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] + * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") + * SUPPORTED_ALGORITHM = ("CD", "CDPSI") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__17 = PyTuple_Pack(2, __pyx_n_u_CD, __pyx_n_u_CDPSI); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(0, 59, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__17); + __Pyx_GIVEREF(__pyx_tuple__17); + + /* "l0learn/interface.pyx":62 + * + * + * def fit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< + * y: np.ndarray, + * loss: str = "SquaredHinge", + */ + __pyx_tuple__18 = PyTuple_Pack(38, __pyx_n_s_X, __pyx_n_s_y, __pyx_n_s_loss, __pyx_n_s_penalty, __pyx_n_s_algorithm, __pyx_n_s_max_support_size, __pyx_n_s_num_lambda, __pyx_n_s_num_gamma, __pyx_n_s_gamma_max, __pyx_n_s_gamma_min, __pyx_n_s_partial_sort, __pyx_n_s_max_iter, __pyx_n_s_rtol, __pyx_n_s_atol, __pyx_n_s_active_set, __pyx_n_s_active_set_num, __pyx_n_s_max_swaps, __pyx_n_s_scale_down_factor, __pyx_n_s_screen_size, __pyx_n_s_lambda_grid, __pyx_n_s_exclude_first_k, __pyx_n_s_intercept, __pyx_n_s_lows, __pyx_n_s_highs, __pyx_n_s_n, __pyx_n_s_p, __pyx_n_s_auto_lambda, __pyx_n_s_bad_lambda_grid, __pyx_n_s_i, __pyx_n_s_sub_lambda_grid, __pyx_n_s_current, __pyx_n_s_with_bounds, __pyx_n_s_bad_bounds, __pyx_n_s_c_lambda_grid, __pyx_n_s_c_loss, __pyx_n_s_c_penalty, __pyx_n_s_c_algorithim, __pyx_n_s_results); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(0, 62, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__18); + __Pyx_GIVEREF(__pyx_tuple__18); + __pyx_codeobj__19 = (PyObject*)__Pyx_PyCode_New(24, 0, 38, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_fit, 62, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__19)) __PYX_ERR(0, 62, __pyx_L1_error) + + /* "l0learn/interface.pyx":350 + * "Converged": results.Converged} + * + * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< + * y: np.ndarray, + * loss: str = "SquaredHinge", + */ + __pyx_tuple__20 = PyTuple_Pack(40, __pyx_n_s_X, __pyx_n_s_y, __pyx_n_s_loss, __pyx_n_s_penalty, __pyx_n_s_algorithm, __pyx_n_s_num_folds, __pyx_n_s_seed, __pyx_n_s_max_support_size, __pyx_n_s_num_lambda, __pyx_n_s_num_gamma, __pyx_n_s_gamma_max, __pyx_n_s_gamma_min, __pyx_n_s_partial_sort, __pyx_n_s_max_iter, __pyx_n_s_rtol, __pyx_n_s_atol, __pyx_n_s_active_set, __pyx_n_s_active_set_num, __pyx_n_s_max_swaps, __pyx_n_s_scale_down_factor, __pyx_n_s_screen_size, __pyx_n_s_lambda_grid, __pyx_n_s_exclude_first_k, __pyx_n_s_intercept, __pyx_n_s_lows, __pyx_n_s_highs, __pyx_n_s_n, __pyx_n_s_p, __pyx_n_s_auto_lambda, __pyx_n_s_bad_lambda_grid, __pyx_n_s_i, __pyx_n_s_sub_lambda_grid, __pyx_n_s_current, __pyx_n_s_with_bounds, __pyx_n_s_bad_bounds, __pyx_n_s_c_lambda_grid, __pyx_n_s_c_loss, __pyx_n_s_c_penalty, __pyx_n_s_c_algorithim, __pyx_n_s_results); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(0, 350, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__20); + __Pyx_GIVEREF(__pyx_tuple__20); + __pyx_codeobj__21 = (PyObject*)__Pyx_PyCode_New(26, 0, 40, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__20, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_cvfit, 350, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__21)) __PYX_ERR(0, 350, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + __pyx_float_0_ = PyFloat_FromDouble(0.); if (unlikely(!__pyx_float_0_)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_10 = PyInt_FromLong(10); if (unlikely(!__pyx_int_10)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_100 = PyInt_FromLong(100); if (unlikely(!__pyx_int_100)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_200 = PyInt_FromLong(200); if (unlikely(!__pyx_int_200)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_1000 = PyInt_FromLong(1000); if (unlikely(!__pyx_int_1000)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ + +static int __Pyx_modinit_global_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); + /*--- Global init code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); + /*--- Variable export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_export_code(void) { + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); + /*--- Function export code ---*/ + if (__Pyx_ExportFunction("_L0LearnFit_dense", (void (*)(void))__pyx_f_7l0learn_9interface__L0LearnFit_dense, "fitmodel (arma::dmat const &, arma::dvec const &, std::string const , std::string const , std::string const , size_t const , size_t const , size_t const , double const , double const , bool const , size_t const , double const , double const , bool const , size_t const , size_t const , double const , size_t const , bool const , std::vector > const &, size_t const , bool const , bool const , arma::dvec const &, arma::dvec const &)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_L0LearnFit_sparse", (void (*)(void))__pyx_f_7l0learn_9interface__L0LearnFit_sparse, "fitmodel (arma::sp_dmat const &, arma::dvec const &, std::string const , std::string const , std::string const , size_t const , size_t const , size_t const , double const , double const , bool const , size_t const , double const , double const , bool const , size_t const , size_t const , double const , size_t const , bool const , std::vector > const &, size_t const , bool const , bool const , arma::dvec const &, arma::dvec const &)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_L0LearnCV_dense", (void (*)(void))__pyx_f_7l0learn_9interface__L0LearnCV_dense, "cvfitmodel (arma::dmat const &, arma::dvec const &, std::string const , std::string const , std::string const , size_t const , size_t const , size_t const , double const , double const , bool const , size_t const , double const , double const , bool const , size_t const , size_t const , double const , size_t const , bool const , std::vector > const &, unsigned int const , double const , size_t const , bool const , bool const , arma::dvec const &, arma::dvec const &)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_L0LearnCV_sparse", (void (*)(void))__pyx_f_7l0learn_9interface__L0LearnCV_sparse, "cvfitmodel (arma::sp_dmat const &, arma::dvec const &, std::string const , std::string const , std::string const , size_t const , size_t const , size_t const , double const , double const , bool const , size_t const , double const , double const , bool const , size_t const , size_t const , double const , size_t const , bool const , std::vector > const &, unsigned int const , double const , size_t const , bool const , bool const , arma::dvec const &, arma::dvec const &)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_type_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); + /*--- Type init code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_import_code(void) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); + /*--- Type import code ---*/ + __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyTypeObject), + #else + sizeof(PyHeapTypeObject), + #endif + __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(3, 9, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 199, __pyx_L1_error) + __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 222, __pyx_L1_error) + __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 226, __pyx_L1_error) + __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 238, __pyx_L1_error) + __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 764, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_variable_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); + /*--- Variable import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_import_code(void) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); + /*--- Function import code ---*/ + __pyx_t_1 = PyImport_ImportModule("l0learn.cyarma"); if (!__pyx_t_1) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_ImportFunction(__pyx_t_1, "numpy_to_dmat_d", (void (**)(void))&__pyx_f_7l0learn_6cyarma_numpy_to_dmat_d, "arma::dmat (PyArrayObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ImportFunction(__pyx_t_1, "numpy_to_dvec_d", (void (**)(void))&__pyx_f_7l0learn_6cyarma_numpy_to_dvec_d, "arma::dvec (PyArrayObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ImportFunction(__pyx_t_1, "numpy_to_sp_dmat_d", (void (**)(void))&__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d, "arma::sp_dmat (PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ImportFunction(__pyx_t_1, "sp_dmat_field_to_list", (void (**)(void))&__pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list, "PyObject *(arma::field )") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ImportFunction(__pyx_t_1, "dvec_field_to_list", (void (**)(void))&__pyx_f_7l0learn_6cyarma_dvec_field_to_list, "PyObject *(arma::field )") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_RefNannyFinishContext(); + return -1; +} + + +#ifndef CYTHON_NO_PYINIT_EXPORT +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#elif PY_MAJOR_VERSION < 3 +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" void +#else +#define __Pyx_PyMODINIT_FUNC void +#endif +#else +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * +#else +#define __Pyx_PyMODINIT_FUNC PyObject * +#endif +#endif + + +#if PY_MAJOR_VERSION < 3 +__Pyx_PyMODINIT_FUNC initinterface(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC initinterface(void) +#else +__Pyx_PyMODINIT_FUNC PyInit_interface(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_interface(void) +#if CYTHON_PEP489_MULTI_PHASE_INIT +{ + return PyModuleDef_Init(&__pyx_moduledef); +} +static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { + #if PY_VERSION_HEX >= 0x030700A1 + static PY_INT64_T main_interpreter_id = -1; + PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); + if (main_interpreter_id == -1) { + main_interpreter_id = current_id; + return (unlikely(current_id == -1)) ? -1 : 0; + } else if (unlikely(main_interpreter_id != current_id)) + #else + static PyInterpreterState *main_interpreter = NULL; + PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; + if (!main_interpreter) { + main_interpreter = current_interpreter; + } else if (unlikely(main_interpreter != current_interpreter)) + #endif + { + PyErr_SetString( + PyExc_ImportError, + "Interpreter change detected - this module can only be loaded into one interpreter per process."); + return -1; + } + return 0; +} +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { + PyObject *value = PyObject_GetAttrString(spec, from_name); + int result = 0; + if (likely(value)) { + if (allow_none || value != Py_None) { + result = PyDict_SetItemString(moddict, to_name, value); + } + Py_DECREF(value); + } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + } else { + result = -1; + } + return result; +} +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { + PyObject *module = NULL, *moddict, *modname; + if (__Pyx_check_single_interpreter()) + return NULL; + if (__pyx_m) + return __Pyx_NewRef(__pyx_m); + modname = PyObject_GetAttrString(spec, "name"); + if (unlikely(!modname)) goto bad; + module = PyModule_NewObject(modname); + Py_DECREF(modname); + if (unlikely(!module)) goto bad; + moddict = PyModule_GetDict(module); + if (unlikely(!moddict)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; + return module; +bad: + Py_XDECREF(module); + return NULL; +} + + +static CYTHON_SMALL_CODE int __pyx_pymod_exec_interface(PyObject *__pyx_pyinit_module) +#endif +#endif +{ + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + double __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + #if CYTHON_PEP489_MULTI_PHASE_INIT + if (__pyx_m) { + if (__pyx_m == __pyx_pyinit_module) return 0; + PyErr_SetString(PyExc_RuntimeError, "Module 'interface' has already been imported. Re-initialisation is not supported."); + return -1; + } + #elif PY_MAJOR_VERSION >= 3 + if (__pyx_m) return __Pyx_NewRef(__pyx_m); + #endif + #if CYTHON_REFNANNY +__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); +if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); +} +#endif + __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_interface(void)", 0); + if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pxy_PyFrame_Initialize_Offsets + __Pxy_PyFrame_Initialize_Offsets(); + #endif + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + #ifdef WITH_THREAD /* Python build with threading support? */ + PyEval_InitThreads(); + #endif + #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_m = __pyx_pyinit_module; + Py_INCREF(__pyx_m); + #else + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("interface", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_b); + __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_cython_runtime); + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + if (__pyx_module_is_main_l0learn__interface) { + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "l0learn.interface")) { + if (unlikely(PyDict_SetItemString(modules, "l0learn.interface", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Global type/function init code ---*/ + (void)__Pyx_modinit_global_init_code(); + (void)__Pyx_modinit_variable_export_code(); + if (unlikely(__Pyx_modinit_function_export_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + (void)__Pyx_modinit_type_init_code(); + if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + (void)__Pyx_modinit_variable_import_code(); + if (unlikely(__Pyx_modinit_function_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + + /* "l0learn/interface.pyx":6 + * from libcpp.string cimport string + * from libcpp cimport bool as cppbool + * import numpy as np # <<<<<<<<<<<<<< + * from scipy.sparse import csc_matrix + * + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "l0learn/interface.pyx":7 + * from libcpp cimport bool as cppbool + * import numpy as np + * from scipy.sparse import csc_matrix # <<<<<<<<<<<<<< + * + * from typing import Union, Optional, List + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_csc_matrix); + __Pyx_GIVEREF(__pyx_n_s_csc_matrix); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_csc_matrix); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_scipy_sparse, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_csc_matrix, __pyx_t_1) < 0) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "l0learn/interface.pyx":9 + * from scipy.sparse import csc_matrix + * + * from typing import Union, Optional, List # <<<<<<<<<<<<<< + * + * from l0learn.cyarma cimport dmat, sp_dmat, numpy_to_sp_dmat_d, numpy_to_dmat_d, dvec, numpy_to_dvec_d, \ + */ + __pyx_t_2 = PyList_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_Union); + __Pyx_GIVEREF(__pyx_n_s_Union); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_Union); + __Pyx_INCREF(__pyx_n_s_Optional); + __Pyx_GIVEREF(__pyx_n_s_Optional); + PyList_SET_ITEM(__pyx_t_2, 1, __pyx_n_s_Optional); + __Pyx_INCREF(__pyx_n_s_List); + __Pyx_GIVEREF(__pyx_n_s_List); + PyList_SET_ITEM(__pyx_t_2, 2, __pyx_n_s_List); + __pyx_t_1 = __Pyx_Import(__pyx_n_s_typing, __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_Union); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Union, __pyx_t_2) < 0) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_Optional); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Optional, __pyx_t_2) < 0) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_List); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_List, __pyx_t_2) < 0) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "l0learn/interface.pyx":26 + * + * + * def np_to_arma_check(arr): # <<<<<<<<<<<<<< + * # TODO: Add checks for Behaved and OwnsData + * if isinstance(arr, np.ndarray): + */ + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_1np_to_arma_check, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_np_to_arma_check, __pyx_t_1) < 0) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "l0learn/interface.pyx":56 + * + * + * SUPPORTED_LOSS = ("SquaredError", "Logistic", "SquaredHinge") # <<<<<<<<<<<<<< + * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] + * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SUPPORTED_LOSS, __pyx_tuple__15) < 0) __PYX_ERR(0, 56, __pyx_L1_error) + + /* "l0learn/interface.pyx":57 + * + * SUPPORTED_LOSS = ("SquaredError", "Logistic", "SquaredHinge") + * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] # <<<<<<<<<<<<<< + * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") + * SUPPORTED_ALGORITHM = ("CD", "CDPSI") + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3); + __pyx_t_2 = 0; + __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_CLASSIFICATION_LOSS, __pyx_t_1) < 0) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "l0learn/interface.pyx":58 + * SUPPORTED_LOSS = ("SquaredError", "Logistic", "SquaredHinge") + * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] + * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") # <<<<<<<<<<<<<< + * SUPPORTED_ALGORITHM = ("CD", "CDPSI") + * + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SUPPORTED_PENALTY, __pyx_tuple__16) < 0) __PYX_ERR(0, 58, __pyx_L1_error) + + /* "l0learn/interface.pyx":59 + * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] + * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") + * SUPPORTED_ALGORITHM = ("CD", "CDPSI") # <<<<<<<<<<<<<< + * + * + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SUPPORTED_ALGORITHM, __pyx_tuple__17) < 0) __PYX_ERR(0, 59, __pyx_L1_error) + + /* "l0learn/interface.pyx":84 + * exclude_first_k: int = 0, + * intercept: bool = True, + * lows: Union[np.ndarray, float] = -float('inf'), # <<<<<<<<<<<<<< + * highs: Union[np.ndarray, float] = +float('inf'),): + * """ + */ + __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 84, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble((-__pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 84, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_k__7 = __pyx_t_1; + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "l0learn/interface.pyx":85 + * intercept: bool = True, + * lows: Union[np.ndarray, float] = -float('inf'), + * highs: Union[np.ndarray, float] = +float('inf'),): # <<<<<<<<<<<<<< + * """ + * Computes the regularization path for the specified loss function and penalty function. + */ + __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 85, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_k__8 = __pyx_t_1; + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "l0learn/interface.pyx":62 + * + * + * def fit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< + * y: np.ndarray, + * loss: str = "SquaredHinge", + */ + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_3fit, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 62, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_fit, __pyx_t_1) < 0) __PYX_ERR(0, 62, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "l0learn/interface.pyx":374 + * exclude_first_k: int = 0, + * intercept: bool = True, + * lows: Union[np.ndarray, float] = -float('inf'), # <<<<<<<<<<<<<< + * highs: Union[np.ndarray, float] = +float('inf'),): + * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): + */ + __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 374, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble((-__pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 374, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_k__9 = __pyx_t_1; + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "l0learn/interface.pyx":375 + * intercept: bool = True, + * lows: Union[np.ndarray, float] = -float('inf'), + * highs: Union[np.ndarray, float] = +float('inf'),): # <<<<<<<<<<<<<< + * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): + * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") + */ + __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 375, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 375, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_k__10 = __pyx_t_1; + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "l0learn/interface.pyx":350 + * "Converged": results.Converged} + * + * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< + * y: np.ndarray, + * loss: str = "SquaredHinge", + */ + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_5cvfit, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 350, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_cvfit, __pyx_t_1) < 0) __PYX_ERR(0, 350, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "l0learn/interface.pyx":1 + * cimport numpy # <<<<<<<<<<<<<< + * cimport numpy as np + * from libcpp.vector cimport vector + */ + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "vector.to_py":60 + * + * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___") + * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(vector[X]& v): # <<<<<<<<<<<<<< + * return [v[i] for i in range(v.size())] + * + */ + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init l0learn.interface", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_CLEAR(__pyx_m); + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init l0learn.interface"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if CYTHON_PEP489_MULTI_PHASE_INIT + return (__pyx_m != NULL) ? 0 : -1; + #elif PY_MAJOR_VERSION >= 3 + return __pyx_m; + #else + return; + #endif +} + +/* --- Runtime support code --- */ +/* Refnanny */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule(modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, "RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +/* PyObjectGetAttrStr */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#endif + +/* GetBuiltinName */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +/* DictGetItem */ +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { + PyObject *value; + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (!PyErr_Occurred()) { + if (unlikely(PyTuple_Check(key))) { + PyObject* args = PyTuple_Pack(1, key); + if (likely(args)) { + PyErr_SetObject(PyExc_KeyError, args); + Py_DECREF(args); + } + } else { + PyErr_SetObject(PyExc_KeyError, key); + } + } + return NULL; + } + Py_INCREF(value); + return value; +} +#endif + +/* PyObjectCall */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = func->ob_type->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyErrFetchRestore */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +} +#endif + +/* RaiseException */ +#if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + __Pyx_PyThreadState_declare + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_PyThreadState_assign + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } + if (cause) { + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_COMPILING_IN_PYPY + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#else + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} +#endif + +/* PyDictVersioning */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { + PyObject **dictptr = NULL; + Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; + if (offset) { +#if CYTHON_COMPILING_IN_CPYTHON + dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); +#else + dictptr = _PyObject_GetDictPtr(obj); +#endif + } + return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; +} +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) + return 0; + return obj_dict_version == __Pyx_get_object_dict_version(obj); +} +#endif + +/* GetModuleGlobalName */ +#if CYTHON_USE_DICT_VERSIONS +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) +#else +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) +#endif +{ + PyObject *result; +#if !CYTHON_AVOID_BORROWED_REFS +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 + result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } else if (unlikely(PyErr_Occurred())) { + return NULL; + } +#else + result = PyDict_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } +#endif +#else + result = PyObject_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } + PyErr_Clear(); +#endif + return __Pyx_GetBuiltinName(name); +} + +/* JoinPyUnicode */ +static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, + CYTHON_UNUSED Py_UCS4 max_char) { +#if CYTHON_USE_UNICODE_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + PyObject *result_uval; + int result_ukind; + Py_ssize_t i, char_pos; + void *result_udata; +#if CYTHON_PEP393_ENABLED + result_uval = PyUnicode_New(result_ulength, max_char); + if (unlikely(!result_uval)) return NULL; + result_ukind = (max_char <= 255) ? PyUnicode_1BYTE_KIND : (max_char <= 65535) ? PyUnicode_2BYTE_KIND : PyUnicode_4BYTE_KIND; + result_udata = PyUnicode_DATA(result_uval); +#else + result_uval = PyUnicode_FromUnicode(NULL, result_ulength); + if (unlikely(!result_uval)) return NULL; + result_ukind = sizeof(Py_UNICODE); + result_udata = PyUnicode_AS_UNICODE(result_uval); +#endif + char_pos = 0; + for (i=0; i < value_count; i++) { + int ukind; + Py_ssize_t ulength; + void *udata; + PyObject *uval = PyTuple_GET_ITEM(value_tuple, i); + if (unlikely(__Pyx_PyUnicode_READY(uval))) + goto bad; + ulength = __Pyx_PyUnicode_GET_LENGTH(uval); + if (unlikely(!ulength)) + continue; + if (unlikely(char_pos + ulength < 0)) + goto overflow; + ukind = __Pyx_PyUnicode_KIND(uval); + udata = __Pyx_PyUnicode_DATA(uval); + if (!CYTHON_PEP393_ENABLED || ukind == result_ukind) { + memcpy((char *)result_udata + char_pos * result_ukind, udata, (size_t) (ulength * result_ukind)); + } else { + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030300F0 || defined(_PyUnicode_FastCopyCharacters) + _PyUnicode_FastCopyCharacters(result_uval, char_pos, uval, 0, ulength); + #else + Py_ssize_t j; + for (j=0; j < ulength; j++) { + Py_UCS4 uchar = __Pyx_PyUnicode_READ(ukind, udata, j); + __Pyx_PyUnicode_WRITE(result_ukind, result_udata, char_pos+j, uchar); + } + #endif + } + char_pos += ulength; + } + return result_uval; +overflow: + PyErr_SetString(PyExc_OverflowError, "join() result is too long for a Python string"); +bad: + Py_DECREF(result_uval); + return NULL; +#else + result_ulength++; + value_count++; + return PyUnicode_Join(__pyx_empty_unicode, value_tuple); +#endif +} + +/* PyCFunctionFastCall */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { + PyCFunctionObject *func = (PyCFunctionObject*)func_obj; + PyCFunction meth = PyCFunction_GET_FUNCTION(func); + PyObject *self = PyCFunction_GET_SELF(func); + int flags = PyCFunction_GET_FLAGS(func); + assert(PyCFunction_Check(func)); + assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); + assert(nargs >= 0); + assert(nargs == 0 || args != NULL); + /* _PyCFunction_FastCallDict() must not be called with an exception set, + because it may clear it (directly or indirectly) and so the + caller loses its exception */ + assert(!PyErr_Occurred()); + if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { + return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); + } else { + return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); + } +} +#endif + +/* PyFunctionFastCall */ +#if CYTHON_FAST_PYCALL +static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, + PyObject *globals) { + PyFrameObject *f; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject **fastlocals; + Py_ssize_t i; + PyObject *result; + assert(globals != NULL); + /* XXX Perhaps we should create a specialized + PyFrame_New() that doesn't take locals, but does + take builtins without sanity checking them. + */ + assert(tstate != NULL); + f = PyFrame_New(tstate, co, globals, NULL); + if (f == NULL) { + return NULL; + } + fastlocals = __Pyx_PyFrame_GetLocalsplus(f); + for (i = 0; i < na; i++) { + Py_INCREF(*args); + fastlocals[i] = *args++; + } + result = PyEval_EvalFrameEx(f,0); + ++tstate->recursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + return result; +} +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { + PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); + PyObject *globals = PyFunction_GET_GLOBALS(func); + PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *closure; +#if PY_MAJOR_VERSION >= 3 + PyObject *kwdefs; +#endif + PyObject *kwtuple, **k; + PyObject **d; + Py_ssize_t nd; + Py_ssize_t nk; + PyObject *result; + assert(kwargs == NULL || PyDict_Check(kwargs)); + nk = kwargs ? PyDict_Size(kwargs) : 0; + if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { + return NULL; + } + if ( +#if PY_MAJOR_VERSION >= 3 + co->co_kwonlyargcount == 0 && +#endif + likely(kwargs == NULL || nk == 0) && + co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { + if (argdefs == NULL && co->co_argcount == nargs) { + result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); + goto done; + } + else if (nargs == 0 && argdefs != NULL + && co->co_argcount == Py_SIZE(argdefs)) { + /* function called with no arguments, but all parameters have + a default value: use default values as arguments .*/ + args = &PyTuple_GET_ITEM(argdefs, 0); + result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); + goto done; + } + } + if (kwargs != NULL) { + Py_ssize_t pos, i; + kwtuple = PyTuple_New(2 * nk); + if (kwtuple == NULL) { + result = NULL; + goto done; + } + k = &PyTuple_GET_ITEM(kwtuple, 0); + pos = i = 0; + while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { + Py_INCREF(k[i]); + Py_INCREF(k[i+1]); + i += 2; + } + nk = i / 2; + } + else { + kwtuple = NULL; + k = NULL; + } + closure = PyFunction_GET_CLOSURE(func); +#if PY_MAJOR_VERSION >= 3 + kwdefs = PyFunction_GET_KW_DEFAULTS(func); +#endif + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } +#if PY_MAJOR_VERSION >= 3 + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); +#else + result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, closure); +#endif + Py_XDECREF(kwtuple); +done: + Py_LeaveRecursiveCall(); + return result; +} +#endif +#endif + +/* PyObjectCallMethO */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = PyCFunction_GET_FUNCTION(func); + self = PyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallOneArg */ +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, &arg, 1); + } +#endif + if (likely(PyCFunction_Check(func))) { + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { + return __Pyx_PyObject_CallMethO(func, arg); +#if CYTHON_FAST_PYCCALL + } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { + return __Pyx_PyCFunction_FastCall(func, &arg, 1); +#endif + } + } + return __Pyx__PyObject_CallOneArg(func, arg); +} +#else +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +#endif + +/* PyIntCompare */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED long inplace) { + if (op1 == op2) { + Py_RETURN_TRUE; + } + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + const long b = intval; + long a = PyInt_AS_LONG(op1); + if (a == b) Py_RETURN_TRUE; else Py_RETURN_FALSE; + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op1))) { + int unequal; + unsigned long uintval; + Py_ssize_t size = Py_SIZE(op1); + const digit* digits = ((PyLongObject*)op1)->ob_digit; + if (intval == 0) { + if (size == 0) Py_RETURN_TRUE; else Py_RETURN_FALSE; + } else if (intval < 0) { + if (size >= 0) + Py_RETURN_FALSE; + intval = -intval; + size = -size; + } else { + if (size <= 0) + Py_RETURN_FALSE; + } + uintval = (unsigned long) intval; +#if PyLong_SHIFT * 4 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 4)) { + unequal = (size != 5) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[4] != ((uintval >> (4 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else +#endif +#if PyLong_SHIFT * 3 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 3)) { + unequal = (size != 4) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else +#endif +#if PyLong_SHIFT * 2 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 2)) { + unequal = (size != 3) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else +#endif +#if PyLong_SHIFT * 1 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 1)) { + unequal = (size != 2) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else +#endif + unequal = (size != 1) || (((unsigned long) digits[0]) != (uintval & (unsigned long) PyLong_MASK)); + if (unequal == 0) Py_RETURN_TRUE; else Py_RETURN_FALSE; + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + if ((double)a == (double)b) Py_RETURN_TRUE; else Py_RETURN_FALSE; + } + return ( + PyObject_RichCompare(op1, op2, Py_EQ)); +} + +/* PyObjectCall2Args */ +static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { + PyObject *args, *result = NULL; + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(function)) { + PyObject *args[2] = {arg1, arg2}; + return __Pyx_PyFunction_FastCall(function, args, 2); + } + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(function)) { + PyObject *args[2] = {arg1, arg2}; + return __Pyx_PyCFunction_FastCall(function, args, 2); + } + #endif + args = PyTuple_New(2); + if (unlikely(!args)) goto done; + Py_INCREF(arg1); + PyTuple_SET_ITEM(args, 0, arg1); + Py_INCREF(arg2); + PyTuple_SET_ITEM(args, 1, arg2); + Py_INCREF(function); + result = __Pyx_PyObject_Call(function, args, NULL); + Py_DECREF(args); + Py_DECREF(function); +done: + return result; +} + +/* RaiseArgTupleInvalid */ +static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +/* RaiseDoubleKeywords */ +static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION >= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +/* ParseKeywords */ +static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + while (PyDict_Next(kwds, &pos, &key, &value)) { + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; + continue; + } + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = (**name == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + return -1; +} + +/* ArgTypeTest */ +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + else if (exact) { + #if PY_MAJOR_VERSION == 2 + if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; + #endif + } + else { + if (likely(__Pyx_TypeCheck(obj, type))) return 1; + } + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", + name, type->tp_name, Py_TYPE(obj)->tp_name); + return 0; +} + +/* PyIntCompare */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_NeObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED long inplace) { + if (op1 == op2) { + Py_RETURN_FALSE; + } + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + const long b = intval; + long a = PyInt_AS_LONG(op1); + if (a != b) Py_RETURN_TRUE; else Py_RETURN_FALSE; + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op1))) { + int unequal; + unsigned long uintval; + Py_ssize_t size = Py_SIZE(op1); + const digit* digits = ((PyLongObject*)op1)->ob_digit; + if (intval == 0) { + if (size != 0) Py_RETURN_TRUE; else Py_RETURN_FALSE; + } else if (intval < 0) { + if (size >= 0) + Py_RETURN_TRUE; + intval = -intval; + size = -size; + } else { + if (size <= 0) + Py_RETURN_TRUE; + } + uintval = (unsigned long) intval; +#if PyLong_SHIFT * 4 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 4)) { + unequal = (size != 5) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[4] != ((uintval >> (4 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else +#endif +#if PyLong_SHIFT * 3 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 3)) { + unequal = (size != 4) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else +#endif +#if PyLong_SHIFT * 2 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 2)) { + unequal = (size != 3) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else +#endif +#if PyLong_SHIFT * 1 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 1)) { + unequal = (size != 2) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else +#endif + unequal = (size != 1) || (((unsigned long) digits[0]) != (uintval & (unsigned long) PyLong_MASK)); + if (unequal != 0) Py_RETURN_TRUE; else Py_RETURN_FALSE; + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + if ((double)a != (double)b) Py_RETURN_TRUE; else Py_RETURN_FALSE; + } + return ( + PyObject_RichCompare(op1, op2, Py_NE)); +} + +/* RaiseTooManyValuesToUnpack */ +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); +} + +/* RaiseNeedMoreValuesToUnpack */ +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { + PyErr_Format(PyExc_ValueError, + "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", + index, (index == 1) ? "" : "s"); +} + +/* IterFinish */ +static CYTHON_INLINE int __Pyx_IterFinish(void) { +#if CYTHON_FAST_THREAD_STATE + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject* exc_type = tstate->curexc_type; + if (unlikely(exc_type)) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) { + PyObject *exc_value, *exc_tb; + exc_value = tstate->curexc_value; + exc_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; + Py_DECREF(exc_type); + Py_XDECREF(exc_value); + Py_XDECREF(exc_tb); + return 0; + } else { + return -1; + } + } + return 0; +#else + if (unlikely(PyErr_Occurred())) { + if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { + PyErr_Clear(); + return 0; + } else { + return -1; + } + } + return 0; +#endif +} + +/* UnpackItemEndCheck */ +static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { + if (unlikely(retval)) { + Py_DECREF(retval); + __Pyx_RaiseTooManyValuesError(expected); + return -1; + } else { + return __Pyx_IterFinish(); + } + return 0; +} + +/* PyUnicode_Unicode */ +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_Unicode(PyObject *obj) { + if (unlikely(obj == Py_None)) + obj = __pyx_kp_u_None; + return __Pyx_NewRef(obj); +} + +/* BytesEquals */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY + return PyObject_RichCompareBool(s1, s2, equals); +#else + if (s1 == s2) { + return (equals == Py_EQ); + } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { + const char *ps1, *ps2; + Py_ssize_t length = PyBytes_GET_SIZE(s1); + if (length != PyBytes_GET_SIZE(s2)) + return (equals == Py_NE); + ps1 = PyBytes_AS_STRING(s1); + ps2 = PyBytes_AS_STRING(s2); + if (ps1[0] != ps2[0]) { + return (equals == Py_NE); + } else if (length == 1) { + return (equals == Py_EQ); + } else { + int result; +#if CYTHON_USE_UNICODE_INTERNALS + Py_hash_t hash1, hash2; + hash1 = ((PyBytesObject*)s1)->ob_shash; + hash2 = ((PyBytesObject*)s2)->ob_shash; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + return (equals == Py_NE); + } +#endif + result = memcmp(ps1, ps2, (size_t)length); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { + return (equals == Py_NE); + } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { + return (equals == Py_NE); + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +#endif +} + +/* UnicodeEquals */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY + return PyObject_RichCompareBool(s1, s2, equals); +#else +#if PY_MAJOR_VERSION < 3 + PyObject* owned_ref = NULL; +#endif + int s1_is_unicode, s2_is_unicode; + if (s1 == s2) { + goto return_eq; + } + s1_is_unicode = PyUnicode_CheckExact(s1); + s2_is_unicode = PyUnicode_CheckExact(s2); +#if PY_MAJOR_VERSION < 3 + if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { + owned_ref = PyUnicode_FromObject(s2); + if (unlikely(!owned_ref)) + return -1; + s2 = owned_ref; + s2_is_unicode = 1; + } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { + owned_ref = PyUnicode_FromObject(s1); + if (unlikely(!owned_ref)) + return -1; + s1 = owned_ref; + s1_is_unicode = 1; + } else if (((!s2_is_unicode) & (!s1_is_unicode))) { + return __Pyx_PyBytes_Equals(s1, s2, equals); + } +#endif + if (s1_is_unicode & s2_is_unicode) { + Py_ssize_t length; + int kind; + void *data1, *data2; + if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) + return -1; + length = __Pyx_PyUnicode_GET_LENGTH(s1); + if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { + goto return_ne; + } +#if CYTHON_USE_UNICODE_INTERNALS + { + Py_hash_t hash1, hash2; + #if CYTHON_PEP393_ENABLED + hash1 = ((PyASCIIObject*)s1)->hash; + hash2 = ((PyASCIIObject*)s2)->hash; + #else + hash1 = ((PyUnicodeObject*)s1)->hash; + hash2 = ((PyUnicodeObject*)s2)->hash; + #endif + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + goto return_ne; + } + } +#endif + kind = __Pyx_PyUnicode_KIND(s1); + if (kind != __Pyx_PyUnicode_KIND(s2)) { + goto return_ne; + } + data1 = __Pyx_PyUnicode_DATA(s1); + data2 = __Pyx_PyUnicode_DATA(s2); + if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { + goto return_ne; + } else if (length == 1) { + goto return_eq; + } else { + int result = memcmp(data1, data2, (size_t)(length * kind)); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & s2_is_unicode) { + goto return_ne; + } else if ((s2 == Py_None) & s1_is_unicode) { + goto return_ne; + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +return_eq: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ); +return_ne: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_NE); +#endif +} + +/* CIntToDigits */ +static const char DIGIT_PAIRS_10[2*10*10+1] = { + "00010203040506070809" + "10111213141516171819" + "20212223242526272829" + "30313233343536373839" + "40414243444546474849" + "50515253545556575859" + "60616263646566676869" + "70717273747576777879" + "80818283848586878889" + "90919293949596979899" +}; +static const char DIGIT_PAIRS_8[2*8*8+1] = { + "0001020304050607" + "1011121314151617" + "2021222324252627" + "3031323334353637" + "4041424344454647" + "5051525354555657" + "6061626364656667" + "7071727374757677" +}; +static const char DIGITS_HEX[2*16+1] = { + "0123456789abcdef" + "0123456789ABCDEF" +}; + +/* BuildPyUnicode */ +static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, char* chars, int clength, + int prepend_sign, char padding_char) { + PyObject *uval; + Py_ssize_t uoffset = ulength - clength; +#if CYTHON_USE_UNICODE_INTERNALS + Py_ssize_t i; +#if CYTHON_PEP393_ENABLED + void *udata; + uval = PyUnicode_New(ulength, 127); + if (unlikely(!uval)) return NULL; + udata = PyUnicode_DATA(uval); +#else + Py_UNICODE *udata; + uval = PyUnicode_FromUnicode(NULL, ulength); + if (unlikely(!uval)) return NULL; + udata = PyUnicode_AS_UNICODE(uval); +#endif + if (uoffset > 0) { + i = 0; + if (prepend_sign) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, 0, '-'); + i++; + } + for (; i < uoffset; i++) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, i, padding_char); + } + } + for (i=0; i < clength; i++) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, uoffset+i, chars[i]); + } +#else + { + PyObject *sign = NULL, *padding = NULL; + uval = NULL; + if (uoffset > 0) { + prepend_sign = !!prepend_sign; + if (uoffset > prepend_sign) { + padding = PyUnicode_FromOrdinal(padding_char); + if (likely(padding) && uoffset > prepend_sign + 1) { + PyObject *tmp; + PyObject *repeat = PyInt_FromSize_t(uoffset - prepend_sign); + if (unlikely(!repeat)) goto done_or_error; + tmp = PyNumber_Multiply(padding, repeat); + Py_DECREF(repeat); + Py_DECREF(padding); + padding = tmp; + } + if (unlikely(!padding)) goto done_or_error; + } + if (prepend_sign) { + sign = PyUnicode_FromOrdinal('-'); + if (unlikely(!sign)) goto done_or_error; + } + } + uval = PyUnicode_DecodeASCII(chars, clength, NULL); + if (likely(uval) && padding) { + PyObject *tmp = PyNumber_Add(padding, uval); + Py_DECREF(uval); + uval = tmp; + } + if (likely(uval) && sign) { + PyObject *tmp = PyNumber_Add(sign, uval); + Py_DECREF(uval); + uval = tmp; + } +done_or_error: + Py_XDECREF(padding); + Py_XDECREF(sign); + } +#endif + return uval; +} + +/* CIntToPyUnicode */ +#ifdef _MSC_VER + #ifndef _MSC_STDINT_H_ + #if _MSC_VER < 1300 + typedef unsigned short uint16_t; + #else + typedef unsigned __int16 uint16_t; + #endif + #endif +#else + #include +#endif +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#define GCC_DIAGNOSTIC +#endif +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char, char format_char) { + char digits[sizeof(Py_ssize_t)*3+2]; + char *dpos, *end = digits + sizeof(Py_ssize_t)*3+2; + const char *hex_digits = DIGITS_HEX; + Py_ssize_t length, ulength; + int prepend_sign, last_one_off; + Py_ssize_t remaining; +#ifdef GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const Py_ssize_t neg_one = (Py_ssize_t) -1, const_zero = (Py_ssize_t) 0; +#ifdef GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (format_char == 'X') { + hex_digits += 16; + format_char = 'x'; + } + remaining = value; + last_one_off = 0; + dpos = end; + do { + int digit_pos; + switch (format_char) { + case 'o': + digit_pos = abs((int)(remaining % (8*8))); + remaining = (Py_ssize_t) (remaining / (8*8)); + dpos -= 2; + *(uint16_t*)dpos = ((const uint16_t*)DIGIT_PAIRS_8)[digit_pos]; + last_one_off = (digit_pos < 8); + break; + case 'd': + digit_pos = abs((int)(remaining % (10*10))); + remaining = (Py_ssize_t) (remaining / (10*10)); + dpos -= 2; + *(uint16_t*)dpos = ((const uint16_t*)DIGIT_PAIRS_10)[digit_pos]; + last_one_off = (digit_pos < 10); + break; + case 'x': + *(--dpos) = hex_digits[abs((int)(remaining % 16))]; + remaining = (Py_ssize_t) (remaining / 16); + break; + default: + assert(0); + break; + } + } while (unlikely(remaining != 0)); + if (last_one_off) { + assert(*dpos == '0'); + dpos++; + } + length = end - dpos; + ulength = length; + prepend_sign = 0; + if (!is_unsigned && value <= neg_one) { + if (padding_char == ' ' || width <= length + 1) { + *(--dpos) = '-'; + ++length; + } else { + prepend_sign = 1; + } + ++ulength; + } + if (width > ulength) { + ulength = width; + } + if (ulength == 1) { + return PyUnicode_FromOrdinal(*dpos); + } + return __Pyx_PyUnicode_BuildFromAscii(ulength, dpos, (int) length, prepend_sign, padding_char); +} + +/* PyIntBinop */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, int inplace, int zerodivision_check) { + (void)inplace; + (void)zerodivision_check; + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + const long b = intval; + long x; + long a = PyInt_AS_LONG(op1); + x = (long)((unsigned long)a + b); + if (likely((x^a) >= 0 || (x^b) >= 0)) + return PyInt_FromLong(x); + return PyLong_Type.tp_as_number->nb_add(op1, op2); + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op1))) { + const long b = intval; + long a, x; +#ifdef HAVE_LONG_LONG + const PY_LONG_LONG llb = intval; + PY_LONG_LONG lla, llx; +#endif + const digit* digits = ((PyLongObject*)op1)->ob_digit; + const Py_ssize_t size = Py_SIZE(op1); + if (likely(__Pyx_sst_abs(size) <= 1)) { + a = likely(size) ? digits[0] : 0; + if (size == -1) a = -a; + } else { + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + default: return PyLong_Type.tp_as_number->nb_add(op1, op2); + } + } + x = a + b; + return PyLong_FromLong(x); +#ifdef HAVE_LONG_LONG + long_long: + llx = lla + llb; + return PyLong_FromLongLong(llx); +#endif + + + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + double result; + PyFPE_START_PROTECT("add", return NULL) + result = ((double)a) + (double)b; + PyFPE_END_PROTECT(result) + return PyFloat_FromDouble(result); + } + return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2); +} +#endif + +/* pyobject_as_double */ +static double __Pyx__PyObject_AsDouble(PyObject* obj) { + PyObject* float_value; +#if !CYTHON_USE_TYPE_SLOTS + float_value = PyNumber_Float(obj); if ((0)) goto bad; +#else + PyNumberMethods *nb = Py_TYPE(obj)->tp_as_number; + if (likely(nb) && likely(nb->nb_float)) { + float_value = nb->nb_float(obj); + if (likely(float_value) && unlikely(!PyFloat_Check(float_value))) { + PyErr_Format(PyExc_TypeError, + "__float__ returned non-float (type %.200s)", + Py_TYPE(float_value)->tp_name); + Py_DECREF(float_value); + goto bad; + } + } else if (PyUnicode_CheckExact(obj) || PyBytes_CheckExact(obj)) { +#if PY_MAJOR_VERSION >= 3 + float_value = PyFloat_FromString(obj); +#else + float_value = PyFloat_FromString(obj, 0); +#endif + } else { + PyObject* args = PyTuple_New(1); + if (unlikely(!args)) goto bad; + PyTuple_SET_ITEM(args, 0, obj); + float_value = PyObject_Call((PyObject*)&PyFloat_Type, args, 0); + PyTuple_SET_ITEM(args, 0, 0); + Py_DECREF(args); + } +#endif + if (likely(float_value)) { + double value = PyFloat_AS_DOUBLE(float_value); + Py_DECREF(float_value); + return value; + } +bad: + return (double)-1; +} + +/* GetItemInt */ +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (!j) return NULL; + r = PyObject_GetItem(o, j); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyList_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { + PyObject *r = PyList_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyTuple_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); + if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { + PyObject *r = PyList_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } + else if (PyTuple_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return NULL; + PyErr_Clear(); + } + } + return m->sq_item(o, i); + } + } +#else + if (is_list || PySequence_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +} + +/* GetTopmostException */ +#if CYTHON_USE_EXC_INFO_STACK +static _PyErr_StackItem * +__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) +{ + _PyErr_StackItem *exc_info = tstate->exc_info; + while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && + exc_info->previous_item != NULL) + { + exc_info = exc_info->previous_item; + } + return exc_info; +} +#endif + +/* SaveResetException */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + *type = exc_info->exc_type; + *value = exc_info->exc_value; + *tb = exc_info->exc_traceback; + #else + *type = tstate->exc_type; + *value = tstate->exc_value; + *tb = tstate->exc_traceback; + #endif + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); +} +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = type; + exc_info->exc_value = value; + exc_info->exc_traceback = tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = type; + tstate->exc_value = value; + tstate->exc_traceback = tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +#endif + +/* PyErrExceptionMatches */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; icurexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; + if (unlikely(PyTuple_Check(err))) + return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); +} +#endif + +/* GetException */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) +#endif +{ + PyObject *local_type, *local_value, *local_tb; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) +#else + if (unlikely(PyErr_Occurred())) +#endif + goto bad; + #if PY_MAJOR_VERSION >= 3 + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; + } + #endif + Py_XINCREF(local_tb); + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; +#if CYTHON_FAST_THREAD_STATE + #if CYTHON_USE_EXC_INFO_STACK + { + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = local_type; + exc_info->exc_value = local_value; + exc_info->exc_traceback = local_tb; + } + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = local_type; + tstate->exc_value = local_value; + tstate->exc_traceback = local_tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); +#endif + return 0; +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; +} + +/* ExtTypeTest */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(__Pyx_TypeCheck(obj, type))) + return 1; + PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", + Py_TYPE(obj)->tp_name, type->tp_name); + return 0; +} + +/* TypeImport */ +#ifndef __PYX_HAVE_RT_ImportType +#define __PYX_HAVE_RT_ImportType +static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, + size_t size, enum __Pyx_ImportType_CheckSize check_size) +{ + PyObject *result = 0; + char warning[200]; + Py_ssize_t basicsize; +#ifdef Py_LIMITED_API + PyObject *py_basicsize; +#endif + result = PyObject_GetAttrString(module, class_name); + if (!result) + goto bad; + if (!PyType_Check(result)) { + PyErr_Format(PyExc_TypeError, + "%.200s.%.200s is not a type object", + module_name, class_name); + goto bad; + } +#ifndef Py_LIMITED_API + basicsize = ((PyTypeObject *)result)->tp_basicsize; +#else + py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); + if (!py_basicsize) + goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; +#endif + if ((size_t)basicsize < size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize); + goto bad; + } + if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize); + goto bad; + } + else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) { + PyOS_snprintf(warning, sizeof(warning), + "%s.%s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize); + if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; + } + return (PyTypeObject *)result; +bad: + Py_XDECREF(result); + return NULL; +} +#endif + +/* Import */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_MAJOR_VERSION < 3 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) { + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + #endif + if (!module) { + #if PY_MAJOR_VERSION < 3 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } +bad: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + +/* ImportFrom */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { + PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); + if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Format(PyExc_ImportError, + #if PY_MAJOR_VERSION < 3 + "cannot import name %.230s", PyString_AS_STRING(name)); + #else + "cannot import name %S", name); + #endif + } + return value; +} + +/* CLineInTraceback */ +#ifndef CYTHON_CLINE_IN_TRACEBACK +static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { + PyObject *use_cline; + PyObject *ptype, *pvalue, *ptraceback; +#if CYTHON_COMPILING_IN_CPYTHON + PyObject **cython_runtime_dict; +#endif + if (unlikely(!__pyx_cython_runtime)) { + return c_line; + } + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); +#if CYTHON_COMPILING_IN_CPYTHON + cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); + if (likely(cython_runtime_dict)) { + __PYX_PY_DICT_LOOKUP_IF_MODIFIED( + use_cline, *cython_runtime_dict, + __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) + } else +#endif + { + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + if (use_cline_obj) { + use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; + Py_DECREF(use_cline_obj); + } else { + PyErr_Clear(); + use_cline = NULL; + } + } + if (!use_cline) { + c_line = 0; + PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); + } + else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { + c_line = 0; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + return c_line; +} +#endif + +/* CodeObjectCache */ +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +/* AddTraceback */ +#include "compile.h" +#include "frameobject.h" +#include "traceback.h" +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + #if PY_MAJOR_VERSION < 3 + py_srcfile = PyString_FromString(filename); + #else + py_srcfile = PyUnicode_FromString(filename); + #endif + if (!py_srcfile) goto bad; + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + #else + py_funcname = PyUnicode_FromString(funcname); + #endif + } + if (!py_funcname) goto bad; + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + Py_DECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + if (c_line) { + c_line = __Pyx_CLineForTraceback(tstate, c_line); + } + py_code = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!py_code) { + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) goto bad; + __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); + } + py_frame = PyFrame_New( + tstate, /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + __Pyx_PyFrame_SetLineNumber(py_frame, py_line); + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +/* CIntToPy */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { + const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + +/* CIntFromPyVerify */ +#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +/* Declarations */ +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return ::std::complex< float >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return x + y*(__pyx_t_float_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + __pyx_t_float_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +/* Arithmetic */ +#if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + #if 1 + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + if (b.imag == 0) { + return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); + } else if (fabsf(b.real) >= fabsf(b.imag)) { + if (b.real == 0 && b.imag == 0) { + return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.imag); + } else { + float r = b.imag / b.real; + float s = (float)(1.0) / (b.real + b.imag * r); + return __pyx_t_float_complex_from_parts( + (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); + } + } else { + float r = b.real / b.imag; + float s = (float)(1.0) / (b.imag + b.real * r); + return __pyx_t_float_complex_from_parts( + (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); + } + } + #else + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + if (b.imag == 0) { + return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); + } else { + float denom = b.real * b.real + b.imag * b.imag; + return __pyx_t_float_complex_from_parts( + (a.real * b.real + a.imag * b.imag) / denom, + (a.imag * b.real - a.real * b.imag) / denom); + } + } + #endif + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrtf(z.real*z.real + z.imag*z.imag); + #else + return hypotf(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + float r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + float denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + return __Pyx_c_prod_float(a, a); + case 3: + z = __Pyx_c_prod_float(a, a); + return __Pyx_c_prod_float(z, a); + case 4: + z = __Pyx_c_prod_float(a, a); + return __Pyx_c_prod_float(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } else if (b.imag == 0) { + z.real = powf(a.real, b.real); + z.imag = 0; + return z; + } else if (a.real > 0) { + r = a.real; + theta = 0; + } else { + r = -a.real; + theta = atan2f(0.0, -1.0); + } + } else { + r = __Pyx_c_abs_float(a); + theta = atan2f(a.imag, a.real); + } + lnr = logf(r); + z_r = expf(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cosf(z_theta); + z.imag = z_r * sinf(z_theta); + return z; + } + #endif +#endif + +/* Declarations */ +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return ::std::complex< double >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return x + y*(__pyx_t_double_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + __pyx_t_double_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +/* Arithmetic */ +#if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + #if 1 + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + if (b.imag == 0) { + return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); + } else if (fabs(b.real) >= fabs(b.imag)) { + if (b.real == 0 && b.imag == 0) { + return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.imag); + } else { + double r = b.imag / b.real; + double s = (double)(1.0) / (b.real + b.imag * r); + return __pyx_t_double_complex_from_parts( + (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); + } + } else { + double r = b.real / b.imag; + double s = (double)(1.0) / (b.imag + b.real * r); + return __pyx_t_double_complex_from_parts( + (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); + } + } + #else + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + if (b.imag == 0) { + return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); + } else { + double denom = b.real * b.real + b.imag * b.imag; + return __pyx_t_double_complex_from_parts( + (a.real * b.real + a.imag * b.imag) / denom, + (a.imag * b.real - a.real * b.imag) / denom); + } + } + #endif + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrt(z.real*z.real + z.imag*z.imag); + #else + return hypot(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + double r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + double denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + return __Pyx_c_prod_double(a, a); + case 3: + z = __Pyx_c_prod_double(a, a); + return __Pyx_c_prod_double(z, a); + case 4: + z = __Pyx_c_prod_double(a, a); + return __Pyx_c_prod_double(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } else if (b.imag == 0) { + z.real = pow(a.real, b.real); + z.imag = 0; + return z; + } else if (a.real > 0) { + r = a.real; + theta = 0; + } else { + r = -a.real; + theta = atan2(0.0, -1.0); + } + } else { + r = __Pyx_c_abs_double(a); + theta = atan2(a.imag, a.real); + } + lnr = log(r); + z_r = exp(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cos(z_theta); + z.imag = z_r * sin(z_theta); + return z; + } + #endif +#endif + +/* CIntFromPy */ +static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) { + const size_t neg_one = (size_t) ((size_t) 0 - (size_t) 1), const_zero = (size_t) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(size_t) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(size_t, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (size_t) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (size_t) 0; + case 1: __PYX_VERIFY_RETURN_INT(size_t, digit, digits[0]) + case 2: + if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(size_t) >= 2 * PyLong_SHIFT) { + return (size_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(size_t) >= 3 * PyLong_SHIFT) { + return (size_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(size_t) >= 4 * PyLong_SHIFT) { + return (size_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (size_t) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(size_t) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(size_t) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (size_t) 0; + case -1: __PYX_VERIFY_RETURN_INT(size_t, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(size_t, digit, +digits[0]) + case -2: + if (8 * sizeof(size_t) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) { + return (size_t) (((size_t)-1)*(((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) { + return (size_t) ((((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) { + return (size_t) (((size_t)-1)*(((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) { + return (size_t) ((((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) { + return (size_t) (((size_t)-1)*(((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) { + return (size_t) ((((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); + } + } + break; + } +#endif + if (sizeof(size_t) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(size_t, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(size_t) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(size_t, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + size_t val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (size_t) -1; + } + } else { + size_t val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (size_t) -1; + val = __Pyx_PyInt_As_size_t(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to size_t"); + return (size_t) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to size_t"); + return (size_t) -1; +} + +/* CIntFromPy */ +static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) { + const unsigned int neg_one = (unsigned int) ((unsigned int) 0 - (unsigned int) 1), const_zero = (unsigned int) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(unsigned int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(unsigned int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (unsigned int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (unsigned int) 0; + case 1: __PYX_VERIFY_RETURN_INT(unsigned int, digit, digits[0]) + case 2: + if (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned int) >= 2 * PyLong_SHIFT) { + return (unsigned int) (((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned int) >= 3 * PyLong_SHIFT) { + return (unsigned int) (((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned int) >= 4 * PyLong_SHIFT) { + return (unsigned int) (((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (unsigned int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(unsigned int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (unsigned int) 0; + case -1: __PYX_VERIFY_RETURN_INT(unsigned int, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(unsigned int, digit, +digits[0]) + case -2: + if (8 * sizeof(unsigned int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) { + return (unsigned int) (((unsigned int)-1)*(((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) { + return (unsigned int) ((((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) { + return (unsigned int) (((unsigned int)-1)*(((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) { + return (unsigned int) ((((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT) { + return (unsigned int) (((unsigned int)-1)*(((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT) { + return (unsigned int) ((((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(unsigned int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned int, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(unsigned int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned int, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + unsigned int val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (unsigned int) -1; + } + } else { + unsigned int val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (unsigned int) -1; + val = __Pyx_PyInt_As_unsigned_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to unsigned int"); + return (unsigned int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to unsigned int"); + return (unsigned int) -1; +} + +/* CIntFromPy */ +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { + const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } +#endif + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + long val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +/* CIntFromPy */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { + const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +/* FastTypeChecks */ +#if CYTHON_COMPILING_IN_CPYTHON +static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { + while (a) { + a = a->tp_base; + if (a == b) + return 1; + } + return b == &PyBaseObject_Type; +} +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (a == b) return 1; + mro = a->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(a, b); +} +#if PY_MAJOR_VERSION == 2 +static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { + PyObject *exception, *value, *tb; + int res; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&exception, &value, &tb); + res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + if (!res) { + res = PyObject_IsSubclass(err, exc_type2); + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + } + __Pyx_ErrRestore(exception, value, tb); + return res; +} +#else +static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { + int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; + if (!res) { + res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + } + return res; +} +#endif +static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + assert(PyExceptionClass_Check(exc_type)); + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; i= 0x02070000 + cobj = PyCapsule_New(tmp.p, sig, 0); +#else + cobj = PyCObject_FromVoidPtrAndDesc(tmp.p, (void *)sig, 0); +#endif + if (!cobj) + goto bad; + if (PyDict_SetItemString(d, name, cobj) < 0) + goto bad; + Py_DECREF(cobj); + Py_DECREF(d); + return 0; +bad: + Py_XDECREF(cobj); + Py_XDECREF(d); + return -1; +} + +/* FunctionImport */ +#ifndef __PYX_HAVE_RT_ImportFunction +#define __PYX_HAVE_RT_ImportFunction +static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) { + PyObject *d = 0; + PyObject *cobj = 0; + union { + void (*fp)(void); + void *p; + } tmp; + d = PyObject_GetAttrString(module, (char *)"__pyx_capi__"); + if (!d) + goto bad; + cobj = PyDict_GetItemString(d, funcname); + if (!cobj) { + PyErr_Format(PyExc_ImportError, + "%.200s does not export expected C function %.200s", + PyModule_GetName(module), funcname); + goto bad; + } +#if PY_VERSION_HEX >= 0x02070000 + if (!PyCapsule_IsValid(cobj, sig)) { + PyErr_Format(PyExc_TypeError, + "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", + PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj)); + goto bad; + } + tmp.p = PyCapsule_GetPointer(cobj, sig); +#else + {const char *desc, *s1, *s2; + desc = (const char *)PyCObject_GetDesc(cobj); + if (!desc) + goto bad; + s1 = desc; s2 = sig; + while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; } + if (*s1 != *s2) { + PyErr_Format(PyExc_TypeError, + "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", + PyModule_GetName(module), funcname, sig, desc); + goto bad; + } + tmp.p = PyCObject_AsVoidPtr(cobj);} +#endif + *f = tmp.fp; + if (!(*f)) + goto bad; + Py_DECREF(d); + return 0; +bad: + Py_XDECREF(d); + return -1; +} +#endif + +/* InitStrings */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + if (PyObject_Hash(*t->p) == -1) + return -1; + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); +} +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +#if !CYTHON_PEP393_ENABLED +static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +} +#else +static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (likely(PyUnicode_IS_ASCII(o))) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +} +#endif +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { + return __Pyx_PyUnicode_AsStringAndSize(o, length); + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { + int retval; + if (unlikely(!x)) return -1; + retval = __Pyx_PyObject_IsTrue(x); + Py_DECREF(x); + return retval; +} +static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { +#if PY_MAJOR_VERSION >= 3 + if (PyLong_Check(result)) { + if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, + "__int__ returned non-int (type %.200s). " + "The ability to return an instance of a strict subclass of int " + "is deprecated, and may be removed in a future version of Python.", + Py_TYPE(result)->tp_name)) { + Py_DECREF(result); + return NULL; + } + return result; + } +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + type_name, type_name, Py_TYPE(result)->tp_name); + Py_DECREF(result); + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { +#if CYTHON_USE_TYPE_SLOTS + PyNumberMethods *m; +#endif + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x) || PyLong_Check(x))) +#else + if (likely(PyLong_Check(x))) +#endif + return __Pyx_NewRef(x); +#if CYTHON_USE_TYPE_SLOTS + m = Py_TYPE(x)->tp_as_number; + #if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = m->nb_int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = m->nb_long(x); + } + #else + if (likely(m && m->nb_int)) { + name = "int"; + res = m->nb_int(x); + } + #endif +#else + if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { + res = PyNumber_Int(x); + } +#endif + if (likely(res)) { +#if PY_MAJOR_VERSION < 3 + if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { +#else + if (unlikely(!PyLong_CheckExact(res))) { +#endif + return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(b); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { + return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +#endif /* Py_PYTHON_H */ diff --git a/python/l0learn/interface.pxd b/python/l0learn/interface.pxd new file mode 100644 index 0000000..648a0c7 --- /dev/null +++ b/python/l0learn/interface.pxd @@ -0,0 +1,199 @@ +# distutils: language = c++ + +from libcpp.vector cimport vector +from libcpp.string cimport string +from libcpp cimport bool as cppbool +from l0learn.cyarma cimport field, dmat, sp_dmat, dvec + +TEST_INTERFACE = "INSTALLED" + +cdef extern from "src/include/L0LearnCore.h": + + cdef cppclass fitmodel: + vector[vector[double]] Lambda0; + vector[double] Lambda12; + vector[vector[size_t]] NnzCount; + field[sp_dmat] Beta; + vector[vector[double]] Intercept; + vector[vector[cppbool]] Converged; + + fitmodel() except + + fitmodel(const fitmodel &) except + + + cdef cppclass cvfitmodel(fitmodel): + field[dvec] CVMeans; + field[dvec] CVSDs; + + cvfitmodel() except + + cvfitmodel(const cvfitmodel &) except + + + cdef fitmodel L0LearnFit[T](const T& X, + const dvec& y, + const string Loss, + const string Penalty, + const string Algorithm, + const size_t NnzStopNum, + const size_t G_ncols, + const size_t G_nrows, + const double Lambda2Max, + const double Lambda2Min, + const cppbool PartialSort, + const size_t MaxIters, + const double rtol, + const double atol, + const cppbool ActiveSet, + const size_t ActiveSetNum, + const size_t MaxNumSwaps, + const double ScaleDownFactor, + const size_t ScreenSize, + const cppbool LambdaU, + const vector[vector[double]]& Lambdas, + const size_t ExcludeFirstK, + const cppbool Intercept, + const cppbool withBounds, + const dvec &Lows, + const dvec &Highs); + + cdef cvfitmodel L0LearnCV[T](const T& X, + const dvec& y, + const string Loss, + const string Penalty, + const string Algorithm, + const size_t NnzStopNum, + const size_t G_ncols, + const size_t G_nrows, + const double Lambda2Max, + const double Lambda2Min, + const cppbool PartialSort, + const size_t MaxIters, + const double rtol, + const double atol, + const cppbool ActiveSet, + const size_t ActiveSetNum, + const size_t MaxNumSwaps, + const double ScaleDownFactor, + const size_t ScreenSize, + const cppbool LambdaU, + const vector[vector[double]]& Lambdas, + const unsigned int nfolds, + const double seed, + const size_t ExcludeFirstK, + const cppbool Intercept, + const cppbool withBounds, + const dvec &Lows, + const dvec &Highs) + +cdef fitmodel _L0LearnFit_dense(const dmat& X, + const dvec& y, + const string Loss, + const string Penalty, + const string Algorithm, + const size_t NnzStopNum, + const size_t G_ncols, + const size_t G_nrows, + const double Lambda2Max, + const double Lambda2Min, + const cppbool PartialSort, + const size_t MaxIters, + const double rtol, + const double atol, + const cppbool ActiveSet, + const size_t ActiveSetNum, + const size_t MaxNumSwaps, + const double ScaleDownFactor, + const size_t ScreenSize, + const cppbool LambdaU, + const vector[vector[double]]& Lambdas, + const size_t ExcludeFirstK, + const cppbool Intercept, + const cppbool withBounds, + const dvec &Lows, + const dvec &Highs); + + +cdef fitmodel _L0LearnFit_sparse(const sp_dmat& X, + const dvec& y, + const string Loss, + const string Penalty, + const string Algorithm, + const size_t NnzStopNum, + const size_t G_ncols, + const size_t G_nrows, + const double Lambda2Max, + const double Lambda2Min, + const cppbool PartialSort, + const size_t MaxIters, + const double rtol, + const double atol, + const cppbool ActiveSet, + const size_t ActiveSetNum, + const size_t MaxNumSwaps, + const double ScaleDownFactor, + const size_t ScreenSize, + const cppbool LambdaU, + const vector[vector[double]]& Lambdas, + const size_t ExcludeFirstK, + const cppbool Intercept, + const cppbool withBounds, + const dvec &Lows, + const dvec &Highs); + + +cdef cvfitmodel _L0LearnCV_dense(const dmat& X, + const dvec& y, + const string Loss, + const string Penalty, + const string Algorithm, + const size_t NnzStopNum, + const size_t G_ncols, + const size_t G_nrows, + const double Lambda2Max, + const double Lambda2Min, + const cppbool PartialSort, + const size_t MaxIters, + const double rtol, + const double atol, + const cppbool ActiveSet, + const size_t ActiveSetNum, + const size_t MaxNumSwaps, + const double ScaleDownFactor, + const size_t ScreenSize, + const cppbool LambdaU, + const vector[vector[double]]& Lambdas, + const unsigned int nfolds, + const double seed, + const size_t ExcludeFirstK, + const cppbool Intercept, + const cppbool withBounds, + const dvec &Lows, + const dvec &Highs); + + +cdef cvfitmodel _L0LearnCV_sparse(const sp_dmat& X, + const dvec& y, + const string Loss, + const string Penalty, + const string Algorithm, + const size_t NnzStopNum, + const size_t G_ncols, + const size_t G_nrows, + const double Lambda2Max, + const double Lambda2Min, + const cppbool PartialSort, + const size_t MaxIters, + const double rtol, + const double atol, + const cppbool ActiveSet, + const size_t ActiveSetNum, + const size_t MaxNumSwaps, + const double ScaleDownFactor, + const size_t ScreenSize, + const cppbool LambdaU, + const vector[vector[double]]& Lambdas, + const unsigned int nfolds, + const double seed, + const size_t ExcludeFirstK, + const cppbool Intercept, + const cppbool withBounds, + const dvec &Lows, + const dvec &Highs); diff --git a/python/l0learn/interface.pyx b/python/l0learn/interface.pyx new file mode 100644 index 0000000..364398c --- /dev/null +++ b/python/l0learn/interface.pyx @@ -0,0 +1,726 @@ +cimport numpy +cimport numpy as np +from libcpp.vector cimport vector +from libcpp.string cimport string +from libcpp cimport bool as cppbool +import numpy as np +from scipy.sparse import csc_matrix + +from typing import Union, Optional, List + +from l0learn.cyarma cimport dmat, sp_dmat, numpy_to_sp_dmat_d, numpy_to_dmat_d, dvec, numpy_to_dvec_d, \ + sp_dmat_field_to_list, dvec_field_to_list + +# def gen_synthetic(): +# raise NotImplementedError +# +# +# def gen_synthetic_high_corr(): +# raise NotImplementedError +# +# +# def gen_synthetic_logistic(): +# raise NotImplementedError + + +def np_to_arma_check(arr): + # TODO: Add checks for Behaved and OwnsData + if isinstance(arr, np.ndarray): + if not arr.flags['F_CONTIGUOUS']: + raise ValueError("expected arr to be F_CONTIGUOUS.") + elif isinstance(arr, csc_matrix): + if not arr.data.flags['F_CONTIGUOUS']: + raise ValueError("expected arr.data to be F_CONTIGUOUS.") + if not arr.indices.flags['F_CONTIGUOUS']: + raise ValueError("expected arr.indices to be F_CONTIGUOUS.") + if not arr.indptr.flags['F_CONTIGUOUS']: + raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") + else: + raise NotImplementedError(f"expected arr to be of type {np.ndarray} or {csc_matrix}, but got {type(arr)}.") + + if arr.ndim == 0: + raise ValueError("expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar") + elif arr.ndim > 2: + raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") + + if np.product(arr.shape) == 0: + raise ValueError(f"expected non-degenerate dimensions of arr, but got {arr.ndim}") + + if not np.issubdtype(arr.dtype, np.number): + raise ValueError(f"expected numerical dtype, but got {arr.dtype}") + + if not np.isrealobj(arr): + raise ValueError(f"expected non-complex dtype, but got {arr.dtype}") + + +SUPPORTED_LOSS = ("SquaredError", "Logistic", "SquaredHinge") +CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] +SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") +SUPPORTED_ALGORITHM = ("CD", "CDPSI") + + +def fit(X: Union[np.ndarray, csc_matrix], + y: np.ndarray, + loss: str = "SquaredHinge", + penalty: str = "L0", + algorithm: str = "CD", + max_support_size: int = 100, + num_lambda: Optional[int] = 100, + num_gamma: Optional[int] = 1, + gamma_max: float = 10., + gamma_min: float = .0001, + partial_sort: bool = True, + max_iter: int = 200, + rtol: float = 1e-6, + atol: float = 1e-9, + active_set: bool = True, + active_set_num: int = 3, + max_swaps: int = 100, + scale_down_factor: float = 0.8, + screen_size: int = 1000, + lambda_grid: Optional[List[List[float]]] = None, + exclude_first_k: int = 0, + intercept: bool = True, + lows: Union[np.ndarray, float] = -float('inf'), + highs: Union[np.ndarray, float] = +float('inf'),): + """ + Computes the regularization path for the specified loss function and penalty function. + + Parameters + ---------- + X : np.ndarray or csc_matrix of shape (N, P) + Data Matrix where rows of X are observations and columns of X are features + y : np.ndarray of shape (P) + The response vector where y[i] corresponds to X[i, :] + For classification, a binary vector (-1, 1) is requried . + loss : str + The loss function. Currently supports the choices: + "SquaredError" (for regression), + "Logistic" (for logistic regression), and + "SquaredHinge" (for smooth SVM). + penalty : str + The type of regularization. + This can take either one of the following choices: + "L0", + "L0L2", and + "L0L1" + algorithm : str + The type of algorithm used to minimize the objective function. Currently "CD" and "CDPSI" are are supported. + "CD" is a variant of cyclic coordinate descent and runs very fast. "CDPSI" performs local combinatorial search + on top of CD and typically achieves higher quality solutions (at the expense of increased running time). + max_support_size + num_lambda + num_gamma + gamma_max + gamma_min + partial_sort + max_iter + rtol + atol + active_set + active_set_num + max_swaps + scale_down_factor + screen_size + lambda_grid + exclude_first_k + intercept + lows + highs + + Returns + ------- + + """ + + if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): + raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") + + n, p = X.shape + if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: + raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") + + if loss not in SUPPORTED_LOSS: + raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") + + if penalty not in SUPPORTED_PENALTY: + raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") + if algorithm not in SUPPORTED_ALGORITHM: + raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") + if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): + raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," + f" but got {max_support_size}") + if gamma_max < 0: + raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") + if gamma_min < 0 or gamma_min > gamma_max: + raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," + f" but got {gamma_min}") + if not isinstance(partial_sort, bool): + raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") + if not isinstance(max_iter, int) or max_iter < 1: + raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") + if rtol < 0 or rtol >= 1: + raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") + if atol < 0: + raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") + if not isinstance(active_set, bool): + raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") + if not isinstance(active_set_num, int) or active_set_num < 1: + raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") + if not isinstance(max_swaps, int) or max_swaps < 1: + raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") + if not (0 < scale_down_factor < 1): + raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") + if not isinstance(screen_size, int) or screen_size < 1: + raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") + if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): + raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " + f"but got {exclude_first_k}") + if not isinstance(intercept, bool): + raise ValueError(f"expected intercept parameter to be a bool, " + f"but got {intercept}") + + if loss in CLASSIFICATION_LOSS: + if sorted(np.unique(y)) != [-1, 1]: + raise ValueError(f"expected y vector to only have two unique values (-1 and 1) (Binary Classification), " + f"but got {np.unique(y)}") + + if penalty == "L0": + # TODO: Must be corrected in R code: https://github.com/hazimehh/L0Learn/blob/7a65474dfdb01489a0c263d7b24fbafad56fba61/R/fit.R#L136 + # Pure L0 is not supported for classification + # Below we add a small L2 component. + + if len(lambda_grid) != 1: + # If this error checking was left to the lower section, it would confuse users as + # we are converting L0 to L0L2 with small L2 penalty. + # Here we must check if lambdaGrid is supplied (And thus use 'autolambda') + # If 'lambdaGrid' is supplied, we must only supply 1 list of lambda values + raise ValueError(f"L0 Penalty requires 'lambda_grid' to be a list of length 1, but got {lambda_grid}.") + + penalty = "L0L2" + gamma_max = 1e-7 + gamma_min = 1e-7 + + if lambda_grid is None: + lambda_grid = [[0.]] + auto_lambda = True + if not isinstance(num_lambda, int) or num_lambda < 1: + raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") + if not isinstance(num_gamma, int) or num_gamma < 1: + raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") + if penalty == "L0" and num_gamma != 1: + raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") + else: # lambda_grid should be a List[List[float]] + if num_gamma is not None: + raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " + f"but got {num_gamma}") + num_gamma = len(lambda_grid) + + if num_lambda is not None: + raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " + f"but got {num_lambda}") + num_lambda = 0 # This value is ignored. + auto_lambda = False + bad_lambda_grid = False + + if penalty == "L0" and num_gamma != 1: + raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") + + for i, sub_lambda_grid in enumerate(lambda_grid): + current = float("inf") + if sub_lambda_grid[0] <= 0: + raise ValueError(f"Expected all values of lambda_grid to be positive, " + f"but got lambda_grid[{i}] containing a negative value") + if any(np.diff(sub_lambda_grid) >= 0): + raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " + f"but got lambda_grid[{i}] containing an increasing value.") + + n, p = X.shape + with_bounds = False + + if isinstance(lows, float): + if lows > 0: + raise ValueError(f"expected lows to be a non-positive float, but got {lows}") + elif lows > -float('inf'): + with_bounds = True + elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): + with_bounds = True + else: + raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " + f"floats, but got {lows}") + + if isinstance(highs, float): + if highs < 0: + raise ValueError(f"expected highs to be a non-negative float, but got {highs}") + if highs < float('inf'): + with_bounds = True + elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): + with_bounds = True + else: + raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " + f"non-negative floats, but got {highs}") + + if with_bounds: + if isinstance(lows, float): + lows = np.ones(p) * lows + if isinstance(highs, float): + highs = np.ones(p) * highs + + if any(lows >= highs): + bad_bounds = np.argwhere(lows >= highs) + raise ValueError(f"expected to be high to be elementwise greater than lows, " + f"but got indices {bad_bounds[0]} where that is not the case ") + else: + lows = np.array([0.]) + highs = np.array(([0.])) + + cdef vector[vector[double]] c_lambda_grid + try: + c_lambda_grid = lambda_grid + except TypeError: + raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") + + cdef string c_loss = loss.encode('UTF-8') + cdef string c_penalty = penalty.encode('UTF-8') + cdef string c_algorithim = algorithm.encode('UTF-8') + + cdef fitmodel results + if isinstance(X, np.ndarray): + results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), + y=numpy_to_dvec_d(y), + Loss=c_loss, + Penalty=c_penalty, + Algorithm=c_algorithim, + NnzStopNum=max_support_size, + G_ncols=num_lambda, + G_nrows=num_gamma, + Lambda2Max=gamma_max, + Lambda2Min=gamma_min, + PartialSort=partial_sort, + MaxIters=max_iter, + rtol=rtol, + atol=atol, + ActiveSet=active_set, + ActiveSetNum=active_set_num, + MaxNumSwaps=max_swaps, + ScaleDownFactor=scale_down_factor, + ScreenSize=screen_size, + LambdaU=not auto_lambda, + Lambdas=c_lambda_grid, + ExcludeFirstK=exclude_first_k, + Intercept=intercept, + withBounds=with_bounds, + Lows=numpy_to_dvec_d(lows), + Highs=numpy_to_dvec_d(highs)) + else: # isinstance(X, csc_matrix) + results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), + y=numpy_to_dvec_d(y), + Loss=c_loss, + Penalty=c_penalty, + Algorithm=c_algorithim, + NnzStopNum=max_support_size, + G_ncols=num_lambda, + G_nrows=num_gamma, + Lambda2Max=gamma_max, + Lambda2Min=gamma_min, + PartialSort=partial_sort, + MaxIters=max_iter, + rtol=rtol, + atol=atol, + ActiveSet=active_set, + ActiveSetNum=active_set_num, + MaxNumSwaps=max_swaps, + ScaleDownFactor=scale_down_factor, + ScreenSize=screen_size, + LambdaU=not auto_lambda, + Lambdas=c_lambda_grid, + ExcludeFirstK=exclude_first_k, + Intercept=intercept, + withBounds=with_bounds, + Lows=numpy_to_dvec_d(lows), + Highs=numpy_to_dvec_d(highs)) + + return {"NnzCount": results.NnzCount, + "Lambda0": results.Lambda0, + "Lambda12": results.Lambda12, + "Beta": sp_dmat_field_to_list(results.Beta), + "Intercept": results.Intercept, + "Converged": results.Converged} + +def cvfit(X: Union[np.ndarray, csc_matrix], + y: np.ndarray, + loss: str = "SquaredHinge", + penalty: str = "L0", + algorithm: str = "CD", + num_folds: int = 10, + seed: int = 1, + max_support_size: int = 100, + num_lambda: Optional[int] = 100, + num_gamma: Optional[int] = 1, + gamma_max: float = 10., + gamma_min: float = .0001, + partial_sort: bool = True, + max_iter: int = 200, + rtol: float = 1e-6, + atol: float = 1e-9, + active_set: bool = True, + active_set_num: int = 3, + max_swaps: int = 100, + scale_down_factor: float = 0.8, + screen_size: int = 1000, + lambda_grid: Optional[List[List[float]]] = None, + exclude_first_k: int = 0, + intercept: bool = True, + lows: Union[np.ndarray, float] = -float('inf'), + highs: Union[np.ndarray, float] = +float('inf'),): + if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): + raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") + + n, p = X.shape + if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: + raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") + + if loss not in SUPPORTED_LOSS: + raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") + + if penalty not in SUPPORTED_PENALTY: + raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") + if algorithm not in SUPPORTED_ALGORITHM: + raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") + if not isinstance(num_folds, int) or num_folds < 2: + raise ValueError(f"expected num_folds parameter to be a integer greater than 2, but got {num_folds}") + if not isinstance(seed, int): + raise ValueError(f"expected seed parameter to be an integer, but got {seed}") + if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): + raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," + f" but got {max_support_size}") + if gamma_max < 0: + raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") + if gamma_min < 0 or gamma_min > gamma_max: + raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," + f" but got {gamma_min}") + if not isinstance(partial_sort, bool): + raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") + if not isinstance(max_iter, int) or max_iter < 1: + raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") + if rtol < 0 or rtol >= 1: + raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") + if atol < 0: + raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") + if not isinstance(active_set, bool): + raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") + if not isinstance(active_set_num, int) or active_set_num < 1: + raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") + if not isinstance(max_swaps, int) or max_swaps < 1: + raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") + if not (0 < scale_down_factor < 1): + raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") + if not isinstance(screen_size, int) or screen_size < 1: + raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") + if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): + raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " + f"but got {exclude_first_k}") + if not isinstance(intercept, bool): + raise ValueError(f"expected intercept parameter to be a bool, " + f"but got {intercept}") + + if loss in CLASSIFICATION_LOSS: + if sorted(np.unique(y)) != [-1, 1]: + raise ValueError(f"expected y vector to only have two unique values (-1 and 1) (Binary Classification), " + f"but got {np.unique(y)}") + + if penalty == "L0": + # TODO: Must be corrected in R code: https://github.com/hazimehh/L0Learn/blob/7a65474dfdb01489a0c263d7b24fbafad56fba61/R/fit.R#L136 + # Pure L0 is not supported for classification + # Below we add a small L2 component. + + if len(lambda_grid) != 1: + # If this error checking was left to the lower section, it would confuse users as + # we are converting L0 to L0L2 with small L2 penalty. + # Here we must check if lambdaGrid is supplied (And thus use 'autolambda') + # If 'lambdaGrid' is supplied, we must only supply 1 list of lambda values + raise ValueError(f"L0 Penalty requires 'lambda_grid' to be a list of length 1, but got {lambda_grid}.") + + penalty = "L0L2" + gamma_max = 1e-7 + gamma_min = 1e-7 + + if lambda_grid is None: + lambda_grid = [[0.]] + auto_lambda = True + if not isinstance(num_lambda, int) or num_lambda < 1: + raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") + if not isinstance(num_gamma, int) or num_gamma < 1: + raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") + if penalty == "L0" and num_gamma != 1: + raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") + else: # lambda_grid should be a List[List[float]] + if num_gamma is not None: + raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " + f"but got {num_gamma}") + num_gamma = len(lambda_grid) + + if num_lambda is not None: + raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " + f"but got {num_lambda}") + num_lambda = 0 # This value is ignored. + auto_lambda = False + bad_lambda_grid = False + + if penalty == "L0" and num_gamma != 1: + raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") + + for i, sub_lambda_grid in enumerate(lambda_grid): + current = float("inf") + if sub_lambda_grid[0] <= 0: + raise ValueError(f"Expected all values of lambda_grid to be positive, " + f"but got lambda_grid[{i}] containing a negative value") + if any(np.diff(sub_lambda_grid) >= 0): + raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " + f"but got lambda_grid[{i}] containing an increasing value.") + + n, p = X.shape + with_bounds = False + + if isinstance(lows, float): + if lows > 0: + raise ValueError(f"expected lows to be a non-positive float, but got {lows}") + elif lows > -float('inf'): + with_bounds = True + elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): + with_bounds = True + else: + raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " + f"floats, but got {lows}") + + if isinstance(highs, float): + if highs < 0: + raise ValueError(f"expected highs to be a non-negative float, but got {highs}") + if highs < float('inf'): + with_bounds = True + elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): + with_bounds = True + else: + raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " + f"non-negative floats, but got {highs}") + + if with_bounds: + if isinstance(lows, float): + lows = np.ones(p) * lows + if isinstance(highs, float): + highs = np.ones(p) * highs + + if any(lows >= highs): + bad_bounds = np.argwhere(lows >= highs) + raise ValueError(f"expected to be high to be elementwise greater than lows, " + f"but got indices {bad_bounds[0]} where that is not the case ") + else: + lows = np.array([0.]) + highs = np.array(([0.])) + + cdef vector[vector[double]] c_lambda_grid + try: + c_lambda_grid = lambda_grid + except TypeError: + raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") + + cdef string c_loss = loss.encode('UTF-8') + cdef string c_penalty = penalty.encode('UTF-8') + cdef string c_algorithim = algorithm.encode('UTF-8') + + cdef cvfitmodel results + if isinstance(X, np.ndarray): + results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), + y=numpy_to_dvec_d(y), + Loss=c_loss, + Penalty=c_penalty, + Algorithm=c_algorithim, + NnzStopNum=max_support_size, + G_ncols=num_lambda, + G_nrows=num_gamma, + Lambda2Max=gamma_max, + Lambda2Min=gamma_min, + PartialSort=partial_sort, + MaxIters=max_iter, + rtol=rtol, + atol=atol, + ActiveSet=active_set, + ActiveSetNum=active_set_num, + MaxNumSwaps=max_swaps, + ScaleDownFactor=scale_down_factor, + ScreenSize=screen_size, + LambdaU=not auto_lambda, + Lambdas=c_lambda_grid, + nfolds=num_folds, + seed=seed, + ExcludeFirstK=exclude_first_k, + Intercept=intercept, + withBounds=with_bounds, + Lows=numpy_to_dvec_d(lows), + Highs=numpy_to_dvec_d(highs)) + else: # isinstance(X, csc_matrix) + results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), + y=numpy_to_dvec_d(y), + Loss=c_loss, + Penalty=c_penalty, + Algorithm=c_algorithim, + NnzStopNum=max_support_size, + G_ncols=num_lambda, + G_nrows=num_gamma, + Lambda2Max=gamma_max, + Lambda2Min=gamma_min, + PartialSort=partial_sort, + MaxIters=max_iter, + rtol=rtol, + atol=atol, + ActiveSet=active_set, + ActiveSetNum=active_set_num, + MaxNumSwaps=max_swaps, + ScaleDownFactor=scale_down_factor, + ScreenSize=screen_size, + LambdaU=not auto_lambda, + Lambdas=c_lambda_grid, + nfolds=num_folds, + seed=seed, + ExcludeFirstK=exclude_first_k, + Intercept=intercept, + withBounds=with_bounds, + Lows=numpy_to_dvec_d(lows), + Highs=numpy_to_dvec_d(highs)) + + return {"NnzCount": results.NnzCount, + "Lambda0": results.Lambda0, + "Lambda12": results.Lambda12, + "Beta": sp_dmat_field_to_list(results.Beta), + "Intercept": results.Intercept, + "Converged": results.Converged, + "CVMeans": dvec_field_to_list(results.CVMeans)[0], + "CVSDs": dvec_field_to_list(results.CVSDs)[0]} + + +cdef fitmodel _L0LearnFit_dense(const dmat& X, + const dvec& y, + const string Loss, + const string Penalty, + const string Algorithm, + const size_t NnzStopNum, + const size_t G_ncols, + const size_t G_nrows, + const double Lambda2Max, + const double Lambda2Min, + const cppbool PartialSort, + const size_t MaxIters, + const double rtol, + const double atol, + const cppbool ActiveSet, + const size_t ActiveSetNum, + const size_t MaxNumSwaps, + const double ScaleDownFactor, + const size_t ScreenSize, + const cppbool LambdaU, + const vector[vector[double]]& Lambdas, + const size_t ExcludeFirstK, + const cppbool Intercept, + const cppbool withBounds, + const dvec &Lows, + const dvec &Highs): + return L0LearnFit[dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, + MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, + Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs) + + +cdef fitmodel _L0LearnFit_sparse(const sp_dmat& X, + const dvec& y, + const string Loss, + const string Penalty, + const string Algorithm, + const size_t NnzStopNum, + const size_t G_ncols, + const size_t G_nrows, + const double Lambda2Max, + const double Lambda2Min, + const cppbool PartialSort, + const size_t MaxIters, + const double rtol, + const double atol, + const cppbool ActiveSet, + const size_t ActiveSetNum, + const size_t MaxNumSwaps, + const double ScaleDownFactor, + const size_t ScreenSize, + const cppbool LambdaU, + const vector[vector[double]]& Lambdas, + const size_t ExcludeFirstK, + const cppbool Intercept, + const cppbool withBounds, + const dvec &Lows, + const dvec &Highs): + return L0LearnFit[sp_dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, + MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, + Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs) + + +cdef cvfitmodel _L0LearnCV_dense(const dmat& X, + const dvec& y, + const string Loss, + const string Penalty, + const string Algorithm, + const size_t NnzStopNum, + const size_t G_ncols, + const size_t G_nrows, + const double Lambda2Max, + const double Lambda2Min, + const cppbool PartialSort, + const size_t MaxIters, + const double rtol, + const double atol, + const cppbool ActiveSet, + const size_t ActiveSetNum, + const size_t MaxNumSwaps, + const double ScaleDownFactor, + const size_t ScreenSize, + const cppbool LambdaU, + const vector[vector[double]]& Lambdas, + const unsigned int nfolds, + const double seed, + const size_t ExcludeFirstK, + const cppbool Intercept, + const cppbool withBounds, + const dvec &Lows, + const dvec &Highs): + return L0LearnCV[dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, + MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, + Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs) + + +cdef cvfitmodel _L0LearnCV_sparse(const sp_dmat& X, + const dvec& y, + const string Loss, + const string Penalty, + const string Algorithm, + const size_t NnzStopNum, + const size_t G_ncols, + const size_t G_nrows, + const double Lambda2Max, + const double Lambda2Min, + const cppbool PartialSort, + const size_t MaxIters, + const double rtol, + const double atol, + const cppbool ActiveSet, + const size_t ActiveSetNum, + const size_t MaxNumSwaps, + const double ScaleDownFactor, + const size_t ScreenSize, + const cppbool LambdaU, + const vector[vector[double]]& Lambdas, + const unsigned int nfolds, + const double seed, + const size_t ExcludeFirstK, + const cppbool Intercept, + const cppbool withBounds, + const dvec &Lows, + const dvec &Highs): + return L0LearnCV[sp_dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, + MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, + Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs) diff --git a/python/l0learn/src/CDL012LogisticSwaps.cpp b/python/l0learn/src/CDL012LogisticSwaps.cpp new file mode 100644 index 0000000..75de90f --- /dev/null +++ b/python/l0learn/src/CDL012LogisticSwaps.cpp @@ -0,0 +1,168 @@ +#include "CDL012LogisticSwaps.h" + +template +CDL012LogisticSwaps::CDL012LogisticSwaps(const T& Xi, const arma::vec& yi, const Params& Pi) : CDSwaps(Xi, yi, Pi) { + twolambda2 = 2 * this->lambda2; + qp2lamda2 = (LipschitzConst + twolambda2); // this is the univariate lipschitz const of the differentiable objective + this->thr2 = (2 * this->lambda0) / qp2lamda2; + this->thr = std::sqrt(this->thr2); + stl0Lc = std::sqrt((2 * this->lambda0) * qp2lamda2); + lambda1ol = this->lambda1 / qp2lamda2; + Xy = Pi.Xy; +} + +template +FitResult CDL012LogisticSwaps::_FitWithBounds() { + throw "This Error should not happen. Please report it as an issue to https://github.com/hazimehh/L0Learn "; +} + +template +FitResult CDL012LogisticSwaps::_Fit() { + auto result = CDL012Logistic(*(this->X), this->y, this->P).Fit(); // result will be maintained till the end + this->b0 = result.b0; // Initialize from previous later....! + this->B = result.B; + ExpyXB = result.ExpyXB; // Maintained throughout the algorithm + + double objective = result.Objective; + double Fmin = objective; + std::size_t maxindex; + double Bmaxindex; + + this->P.Init = 'u'; + + bool foundbetter = false; + bool foundbetter_i = false; + + for (std::size_t t = 0; t < this->MaxNumSwaps; ++t) { + + std::vector NnzIndices = nnzIndicies(this->B, this->NoSelectK); + + // TODO: Add shuffle of Order + //std::shuffle(std::begin(Order), std::end(Order), engine); + + foundbetter = false; + + // TODO: Check if this should be Templated Operation + arma::mat ExpyXBnojs = arma::zeros(this->n, NnzIndices.size()); + + int j_index = -1; + for (auto& j : NnzIndices) + { + // Remove NnzIndices[j] + ++j_index; + ExpyXBnojs.col(j_index) = ExpyXB % arma::exp( - this->B.at(j) * matrix_column_get(*(this->Xy), j)); + + } + arma::mat gradients = - 1/(1 + ExpyXBnojs).t() * *Xy; + arma::mat abs_gradients = arma::abs(gradients); + + + j_index = -1; + for (auto& j : NnzIndices) { + // Set B[j] = 0 + ++j_index; + arma::vec ExpyXBnoj = ExpyXBnojs.col(j_index); + arma::rowvec gradient = gradients.row(j_index); + arma::rowvec abs_gradient = abs_gradients.row(j_index); + + arma::uvec indices = arma::sort_index(arma::abs(gradient), "descend"); + foundbetter_i = false; + + // TODO: make sure this scans at least 100 coordinates from outside supp (now it does not) + for(std::size_t ll = 0; ll < std::min(50, (int) this->p); ++ll) { + std::size_t i = indices(ll); + + if(this->B[i] == 0 && i >= this->NoSelectK) { + // Do not swap B[i] if i between 0 and NoSelectK; + + arma::vec ExpyXBnoji = ExpyXBnoj; + + double Biold = 0; + double partial_i = gradient[i]; + bool converged = false; + + beta_vector Btemp = this->B; + Btemp[j] = 0; + double ObjTemp = Objective(ExpyXBnoji, Btemp); + std::size_t innerindex = 0; + + double x = Biold - partial_i/qp2lamda2; + double z = std::abs(x) - lambda1ol; + double Binew = std::copysign(z, x); + // double Binew = clamp(std::copysign(z, x), this->Lows[i], this->Highs[i]); // no need to check if >= sqrt(2lambda_0/Lc) + + while(!converged && innerindex < 10 && ObjTemp >= Fmin) { // ObjTemp >= Fmin + ExpyXBnoji %= arma::exp( (Binew - Biold) * matrix_column_get(*Xy, i)); + //partial_i = - arma::sum( matrix_column_get(*Xy, i) / (1 + ExpyXBnoji) ) + twolambda2 * Binew; + partial_i = - arma::dot( matrix_column_get(*Xy, i), 1/(1 + ExpyXBnoji) ) + twolambda2 * Binew; + + if (std::abs((Binew - Biold)/Biold) < 0.0001) { + converged = true; + //std::cout<<"swaps converged!!!"<Lows[i], this->Highs[i]); // no need to check if >= sqrt(2lambda_0/Lc) + innerindex += 1; + } + + + Btemp[i] = Binew; + ObjTemp = Objective(ExpyXBnoji, Btemp); + + if (ObjTemp < Fmin) { + Fmin = ObjTemp; + maxindex = i; + Bmaxindex = Binew; + foundbetter_i = true; + } + + // Can be made much faster (later) + Btemp[i] = Binew; + + } + + if (foundbetter_i) { + this->B[j] = 0; + this->B[maxindex] = Bmaxindex; + this->P.InitialSol = &(this->B); + + // TODO: Check if this line is necessary. P should already have b0. + this->P.b0 = this->b0; + + result = CDL012Logistic(*(this->X), this->y, this->P).Fit(); + + ExpyXB = result.ExpyXB; + this->B = result.B; + this->b0 = result.b0; + objective = result.Objective; + Fmin = objective; + foundbetter = true; + break; + } + } + + //auto end2 = std::chrono::high_resolution_clock::now(); + //std::cout<<"restricted: "<(end2-start2).count() << " ms " << std::endl; + + if (foundbetter){ + break; + } + + } + + if(!foundbetter) { + // Early exit to prevent looping + return result; + } + } + + //result.Model = this; + return result; +} + +template class CDL012LogisticSwaps; +template class CDL012LogisticSwaps; diff --git a/python/l0learn/src/CDL012SquaredHingeSwaps.cpp b/python/l0learn/src/CDL012SquaredHingeSwaps.cpp new file mode 100644 index 0000000..c24ba82 --- /dev/null +++ b/python/l0learn/src/CDL012SquaredHingeSwaps.cpp @@ -0,0 +1,135 @@ +#include "CDL012SquaredHingeSwaps.h" + +template +CDL012SquaredHingeSwaps::CDL012SquaredHingeSwaps(const T& Xi, const arma::vec& yi, const Params& Pi) : CDSwaps(Xi, yi, Pi) { + twolambda2 = 2 * this->lambda2; + qp2lamda2 = (LipschitzConst + twolambda2); // this is the univariate lipschitz constant of the differentiable objective + this->thr2 = (2 * this->lambda0) / qp2lamda2; + this->thr = std::sqrt(this->thr2); + stl0Lc = std::sqrt((2 * this->lambda0) * qp2lamda2); + lambda1ol = this->lambda1 / qp2lamda2; +} + +template +FitResult CDL012SquaredHingeSwaps::_FitWithBounds() { + throw "This Error should not happen. Please report it as an issue to https://github.com/hazimehh/L0Learn "; +} + +template +FitResult CDL012SquaredHingeSwaps::_Fit() { + auto result = CDL012SquaredHinge(*(this->X), this->y, this->P).Fit(); // result will be maintained till the end + this->b0 = result.b0; // Initialize from previous later....! + this->B = result.B; + + arma::vec onemyxb = result.onemyxb; + + this->objective = result.Objective; + double Fmin = this->objective; + std::size_t maxindex; + double Bmaxindex; + + this->P.Init = 'u'; + + bool foundbetter = false; + + for (std::size_t t = 0; t < this->MaxNumSwaps; ++t) { + // Rcpp::Rcout << "Swap Number: " << t << "|mean(onemyxb): " << arma::mean(onemyxb) << "\n"; + + std::vector NnzIndices = nnzIndicies(this->B, this->NoSelectK); + + // TODO: Implement shuffle of NnzIndices Indicies + + foundbetter = false; + + for (auto& j : NnzIndices) { + + arma::vec onemyxbnoj = onemyxb + this->B[j] * this->y % matrix_column_get(*(this->X), j); + arma::uvec indices = arma::find(onemyxbnoj > 0); + + + for(std::size_t i = 0; i < this->p; ++i) { + if(this->B[i] == 0 && i>=this->NoSelectK) { + + double Biold = 0; + double Binew; + + + double partial_i = arma::sum(2 * onemyxbnoj.elem(indices) % (- (this->y.elem(indices) % matrix_column_get(*(this->X), i).elem(indices)))); + + bool converged = false; + if (std::abs(partial_i) >= this->lambda1 + stl0Lc){ + + //std::cout<<"Adding: "<B; + Btemp[j] = 0; + //double ObjTemp = Objective(onemyxbnoj,Btemp); + //double Biolddescent = 0; + while(!converged) { + + double x = Biold - partial_i / qp2lamda2; + double z = std::abs(x) - lambda1ol; + Binew = std::copysign(z, x); + + // Binew = clamp(std::copysign(z, x), this->Lows[i], this->Highs[i]); // no need to check if >= sqrt(2lambda_0/Lc) + onemyxbnoji += (Biold - Binew) * this->y % matrix_column_get(*(this->X), i); + + arma::uvec indicesi = arma::find(onemyxbnoji > 0); + partial_i = arma::sum(2 * onemyxbnoji.elem(indicesi) % (- this->y.elem(indicesi) % matrix_column_get(*(this->X), i).elem(indicesi))); + + if (std::abs((Binew - Biold) / Biold) < 0.0001){ + converged = true; + } + + Biold = Binew; + l += 1; + + } + + Btemp[i] = Binew; + double Fnew = Objective(onemyxbnoji, Btemp); + + if (Fnew < Fmin) { + Fmin = Fnew; + maxindex = i; + Bmaxindex = Binew; + } + } + } + } + + if (Fmin < this->objective) { + this->B[j] = 0; + this->B[maxindex] = Bmaxindex; + + this->P.InitialSol = &(this->B); + + // TODO: Check if this line is needed. P should already have b0. + this->P.b0 = this->b0; + + result = CDL012SquaredHinge(*(this->X), this->y, this->P).Fit(); + + this->B = result.B; + this->b0 = result.b0; + + onemyxb = result.onemyxb; + this->objective = result.Objective; + Fmin = this->objective; + foundbetter = true; + break; + } + if (foundbetter){break;} + } + + if(!foundbetter) { + return result; + } + } + + return result; +} + +template class CDL012SquaredHingeSwaps; +template class CDL012SquaredHingeSwaps; diff --git a/python/l0learn/src/CDL012Swaps.cpp b/python/l0learn/src/CDL012Swaps.cpp new file mode 100644 index 0000000..0438e6c --- /dev/null +++ b/python/l0learn/src/CDL012Swaps.cpp @@ -0,0 +1,99 @@ +#include "CDL012Swaps.h" + +template +CDL012Swaps::CDL012Swaps(const T& Xi, const arma::vec& yi, const Params& Pi) : CDSwaps(Xi, yi, Pi) {} + + +template +FitResult CDL012Swaps::_FitWithBounds() { + throw "This Error should not happen. Please report it as an issue to https://github.com/hazimehh/L0Learn "; +} + +template +FitResult CDL012Swaps::_Fit() { + auto result = CDL012(*(this->X), this->y, this->P).Fit(); // result will be maintained till the end + this->B = result.B; + this->b0 = result.b0; + double objective = result.Objective; + this->P.Init = 'u'; + + bool foundbetter = false; + + for (std::size_t t = 0; t < this->MaxNumSwaps; ++t) { + + std::vector NnzIndices = nnzIndicies(this->B, this->NoSelectK); + + foundbetter = false; + + // TODO: shuffle NNz Indices to prevent bias. + //std::shuffle(std::begin(Order), std::end(Order), engine); + + // TODO: This calculation is already preformed in a previous step + // Can be pulled/stored + arma::vec r = this->y - *(this->X) * this->B - this->b0; + + for (auto& i : NnzIndices) { + arma::rowvec riX = (r + this->B[i] * matrix_column_get(*(this->X), i)).t() * *(this->X); + + double maxcorr = -1; + std::size_t maxindex = -1; + + for(std::size_t j = this->NoSelectK; j < this->p; ++j) { + // TODO: Account for bounds when determining best swap + // Loops through each column and finds the column with the highest correlation to residuals + // In non-constrained cases, the highest correlation will always be the best option + // However, if bounds restrict the value of B[j], it is possible that swapping column 'i' + // and column 'j' might be rejected as B[j], when constrained, is not able to take a value + // with sufficient magnitude to utilize the correlation. + // Therefore, we must ensure that 'j' was not already rejected. + if (std::fabs(riX[j]) > maxcorr && this->B[j] == 0) { + maxcorr = std::fabs(riX[j]); + maxindex = j; + } + } + + // Check if the correlation is sufficiently large to make up for regularization + if(maxcorr > (1 + 2 * this->ModelParams[2])*std::fabs(this->B[i]) + this->ModelParams[1]) { + // Rcpp::Rcout << t << ": Proposing Swap " << i << " => NNZ and " << maxindex << " => 0 \n"; + // Proposed new Swap + // Value (without considering bounds are solvable in closed form) + // Must be clamped to bounds + + this->B[i] = 0; + + // Bi with No Bounds (nb); + double Bi_nb = (riX[maxindex] - std::copysign(this->ModelParams[1],riX[maxindex])) / (1 + 2 * this->ModelParams[2]); + //double Bi_wb = clamp(Bi_nb, this->Lows[maxindex], this->Highs[maxindex]); // Bi With Bounds (wb) + this->B[maxindex] = Bi_nb; + + // Change initial solution to Swapped value to seed standard CD algorithm. + this->P.InitialSol = &(this->B); + *this->P.r = this->y - *(this->X) * (this->B) - this->b0; + // this->P already has access to b0. + + // proposed_result object. + // Keep tack of previous_best result object + // Only override previous_best if proposed_result has a better objective. + result = CDL012(*(this->X), this->y, this->P).Fit(); + + // Rcpp::Rcout << "Swap Objective " << result.Objective << " \n"; + // Rcpp::Rcout << "Old Objective " << objective << " \n"; + this->B = result.B; + objective = result.Objective; + foundbetter = true; + break; + } + } + + if(!foundbetter) { + // Early exit to prevent looping + return result; + } + } + + return result; +} + +template class CDL012Swaps; +template class CDL012Swaps; + diff --git a/python/l0learn/src/Grid.cpp b/python/l0learn/src/Grid.cpp new file mode 100644 index 0000000..8c40653 --- /dev/null +++ b/python/l0learn/src/Grid.cpp @@ -0,0 +1,69 @@ +#include "Grid.h" + +// Assumes PG.P.Specs have been already set +template +Grid::Grid(const T& X, const arma::vec& y, const GridParams& PGi) { + PG = PGi; + + std::tie(BetaMultiplier, meanX, meany, scaley) = Normalize(X, + y, Xscaled, yscaled, !PG.P.Specs.Classification, PG.intercept); + + // Must rescale bounds by BetaMultiplier in order for final result to conform to bounds + if (PG.P.withBounds){ + PG.P.Lows /= BetaMultiplier; + PG.P.Highs /= BetaMultiplier; + } +} + +template +void Grid::Fit() { + // // arma::cout << "Grid::Fit() Entered \n"; + std::vector>>> G; + + if (PG.P.Specs.L0) { + // arma::cout << "Grid1D(Xscaled, yscaled, PG) Created \n"; + G.push_back(std::move(Grid1D(Xscaled, yscaled, PG).Fit())); + Lambda12.push_back(0); + } else { + G = std::move(Grid2D(Xscaled, yscaled, PG).Fit()); + } + + // arma::cout << "Grid Unpacking Beginning \n"; + Lambda0 = std::vector< std::vector >(G.size()); + NnzCount = std::vector< std::vector >(G.size()); + Solutions = std::vector< std::vector >(G.size()); + Intercepts = std::vector< std::vector >(G.size()); + Converged = std::vector< std::vector >(G.size()); + + for (std::size_t i=0; iModelParams[1]); + } else if (PG.P.Specs.L0L2) { + Lambda12.push_back(G[i][0]->ModelParams[2]); + } + + for (auto &g : G[i]) { + Lambda0[i].push_back(g->ModelParams[0]); + + NnzCount[i].push_back(n_nonzero(g->B)); + + Converged[i].push_back(g->IterNum != PG.P.MaxIters); + + beta_vector B_unscaled; + double b0; + + std::tie(B_unscaled, b0) = DeNormalize(g->B, BetaMultiplier, meanX, meany); + Solutions[i].push_back(arma::sp_mat(B_unscaled)); + /* scaley is 1 for classification problems. + * g->intercept is 0 unless specifically optimized for in: + * classification + * sparse regression and intercept = true + */ + Intercepts[i].push_back(scaley*g->b0 + b0); + } + } + // arma::cout << "Grid Unpacking Ended \n"; +} + +template class Grid; +template class Grid; diff --git a/python/l0learn/src/Grid1D.cpp b/python/l0learn/src/Grid1D.cpp new file mode 100644 index 0000000..5308323 --- /dev/null +++ b/python/l0learn/src/Grid1D.cpp @@ -0,0 +1,248 @@ +#include "Grid1D.h" + +template +Grid1D::Grid1D(const T& Xi, const arma::vec& yi, const GridParams& PG) { + // automatically selects lambda_0 (but assumes other lambdas are given in PG.P.ModelParams) + // arma::cout << "Grid1D(Xscaled, yscaled, PG) Entered \n"; + X = Ξ + y = &yi; + p = Xi.n_cols; + LambdaMinFactor = PG.LambdaMinFactor; + ScaleDownFactor = PG.ScaleDownFactor; + P = PG.P; + P.Xtr = new std::vector(X->n_cols); // needed! careful + P.ytX = new arma::rowvec(X->n_cols); + P.D = new std::map(); + P.r = new arma::vec(Xi.n_rows); + Xtr = P.Xtr; + ytX = P.ytX; + NoSelectK = P.NoSelectK; + + LambdaU = PG.LambdaU; + + if (!LambdaU) { + G_ncols = PG.G_ncols; + } else { + G_ncols = PG.Lambdas.n_rows; // override the user's ncols if LambdaU = 1 + } + + G.reserve(G_ncols); + if (LambdaU) { + Lambdas = PG.Lambdas; + } // user-defined lambda0 grid + /* + else { + Lambdas.reserve(G_ncols); + Lambdas.push_back((0.5*arma::square(y->t() * *X)).max()); + } + */ + NnzStopNum = PG.NnzStopNum; + PartialSort = PG.PartialSort; + XtrAvailable = PG.XtrAvailable; + if (XtrAvailable) { + ytXmax2d = PG.ytXmax; + Xtr = PG.Xtr; + } + // arma::cout << "Grid1D(Xscaled, yscaled, PG) Finished \n"; +} + +template +Grid1D::~Grid1D() { + // delete all dynamically allocated memory + delete P.Xtr; + delete P.ytX; + delete P.D; + delete P.r; +} + + +template +std::vector>> Grid1D::Fit() { + // arma::cout << "Grid1D Fit Enetered \n"; + if (P.Specs.L0 || P.Specs.L0L2 || P.Specs.L0L1) { + bool scaledown = false; + + double Lipconst; + arma::vec Xtrarma; + if (P.Specs.Logistic) { + if (!XtrAvailable) { + Xtrarma = 0.5 * arma::abs(y->t() * *X).t(); + } // = gradient of logistic loss at zero} + Lipconst = 0.25 + 2 * P.ModelParams[2]; + } else if (P.Specs.SquaredHinge) { + if (!XtrAvailable) { + // gradient of loss function at zero + Xtrarma = 2 * arma::abs(y->t() * *X).t(); + } + Lipconst = 2 + 2 * P.ModelParams[2]; + } else { + if (!XtrAvailable) { + *ytX = y->t() * *X; + Xtrarma = arma::abs(*ytX).t(); // Least squares + } + Lipconst = 1 + 2 * P.ModelParams[2]; + *P.r = *y - P.b0; // B = 0 initially + } + + double ytXmax; + if (!XtrAvailable) { + *Xtr = arma::conv_to< std::vector >::from(Xtrarma); + ytXmax = arma::max(Xtrarma); + } else { + ytXmax = ytXmax2d; + } + + double lambdamax = ((ytXmax - P.ModelParams[1]) * (ytXmax - P.ModelParams[1])) / (2 * (Lipconst)); + + // arma::cout << "Grid1D Fit Point1 \n"; + + if (!LambdaU) { + P.ModelParams[0] = lambdamax; + } else { + // arma::cout << "Grid1D Fit Point2 \n"; + P.ModelParams[0] = Lambdas[0]; + } + + // Rcpp::Rcout << "P ModelParams: {" << P.ModelParams[0] << ", " << P.ModelParams[1] << ", " << P.ModelParams[2] << ", " << P.ModelParams[3] << "}\n"; + // arma::cout << "Grid1D Fit Point3 \n"; + P.Init = 'z'; + + + //std::cout<< "Lambda max: "<< lambdamax << std::endl; + //double lambdamin = lambdamax*LambdaMinFactor; + //Lambdas = arma::logspace(std::log10(lambdamin), std::log10(lambdamax), G_ncols); + //Lambdas = arma::flipud(Lambdas); + + + //std::size_t StopNum = (X->n_rows < NnzStopNum) ? X->n_rows : NnzStopNum; + std::size_t StopNum = NnzStopNum; + //std::vector* Xtr = P.Xtr; + std::vector idx(p); + double Xrmax; + bool prevskip = false; //previous grid point was skipped + bool currentskip = false; // current grid point should be skipped + // arma::cout << "Grid1D Fit Loop Beginning \n"; + for (std::size_t i = 0; i < G_ncols; ++i) { + // arma::cout << "Grid1D Fit Loop: " << i << " \n"; + // Rcpp::checkUserInterrupt(); + // Rcpp::Rcout << "Grid1D: " << i << "\n"; + FitResult * prevresult = new FitResult; // prevresult is ptr to the prev result object + //std::unique_ptr prevresult; + if (i > 0) { + //prevresult = std::move(G.back()); + *prevresult = *(G.back()); + + } + + currentskip = false; + + if (!prevskip) { + // arma::cout << "Grid1D Fit Loop: Here 1\n"; + + std::iota(idx.begin(), idx.end(), 0); // make global class var later + // Exclude the first NoSelectK features from sorting. + if (PartialSort && p > 5000 + NoSelectK) + std::partial_sort(idx.begin() + NoSelectK, idx.begin() + 5000 + NoSelectK, idx.end(), [this](std::size_t i1, std::size_t i2) {return (*Xtr)[i1] > (*Xtr)[i2] ;}); + else + std::sort(idx.begin() + NoSelectK, idx.end(), [this](std::size_t i1, std::size_t i2) {return (*Xtr)[i1] > (*Xtr)[i2] ;}); + P.CyclingOrder = 'u'; + P.Uorder = idx; // can be made faster + + // + Xrmax = (*Xtr)[idx[NoSelectK]]; + + if (i > 0) { + // arma::cout << "Grid1D Fit Loop: Here 2\n"; + std::vector Sp = nnzIndicies(prevresult->B); + + for(std::size_t l = NoSelectK; l < p; ++l) { + if ( std::binary_search(Sp.begin(), Sp.end(), idx[l]) == false ) { + Xrmax = (*Xtr)[idx[l]]; + //std::cout<<"Grid Iteration: "< Fit Loop New Params 1 \n"; + P.ModelParams[0] = (((Xrmax - P.ModelParams[1]) * (Xrmax - P.ModelParams[1])) / (2 * (Lipconst))) * 0.99; // for numerical stability issues. + + if (P.ModelParams[0] >= prevresult->ModelParams[0]) { + P.ModelParams[0] = prevresult->ModelParams[0] * 0.97; + } // handles numerical instability. + } else if (i >= 1 && !LambdaU) { + // arma::cout << "Grid1D Fit Loop New Params 2 \n"; + P.ModelParams[0] = std::min(P.ModelParams[0] * ScaleDownFactor, (((Xrmax - P.ModelParams[1]) * (Xrmax - P.ModelParams[1])) / (2 * (Lipconst))) * 0.97 ); + // add 0.9 as an R param + } else if (i >= 1 && LambdaU) { + // arma::cout << "Grid1D Fit Loop New Params 3 \n"; + P.ModelParams[0] = Lambdas[i]; + } + + // Rcpp::Rcout << "P.ModelParams[0]: " << P.ModelParams[0] << "\n"; + + if (!currentskip) { + // arma::cout << "Grid1D Fit Loop: Here 3\n"; + + auto Model = make_CD(*X, *y, P); + // arma::cout << "Grid1D Fit Loop: Here 4\n"; + std::unique_ptr> result(new FitResult); + // arma::cout << "Grid1D Fit Loop: Here 4.5\n"; + *result = Model->Fit(); + // arma::cout << "Grid1D Fit Loop: Here 5\n"; + delete Model; + + scaledown = false; + if (i >= 1) { + std::vector Spold = nnzIndicies(prevresult->B); + + std::vector Spnew = nnzIndicies(result->B); + + bool samesupp = false; + + if (Spold == Spnew) { + samesupp = true; + scaledown = true; + } + + // // + // + // if (samesupp) { + // scaledown = true; + // } // got same solution + } + + //else {scaledown = false;} + // arma::cout << "Grid1D Fit Loop: Here 6\n"; + G.push_back(std::move(result)); + + // arma::cout << "Grid1D Fit Loop: Here 7\n"; + if(n_nonzero(G.back()->B) >= StopNum) { + break; + } + // arma::cout << "Grid1D Fit Loop: Here 8\n"; + //result->B.t().print(); + P.InitialSol = &(G.back()->B); + P.b0 = G.back()->b0; + // Udate: After 1.1.0, P.r is automatically updated by the previous call to CD + //*P.r = G.back()->r; + + } + + delete prevresult; + + + P.Init = 'u'; + P.Iter += 1; + prevskip = currentskip; + } + } + // arma::cout << "Grid1D Fit Finished \n"; + return std::move(G); +} + + +template class Grid1D; +template class Grid1D; diff --git a/python/l0learn/src/Grid2D.cpp b/python/l0learn/src/Grid2D.cpp new file mode 100644 index 0000000..ec2c55e --- /dev/null +++ b/python/l0learn/src/Grid2D.cpp @@ -0,0 +1,126 @@ +#include "Grid2D.h" + +template +Grid2D::Grid2D(const T& Xi, const arma::vec& yi, const GridParams& PGi) +{ + // automatically selects lambda_0 (but assumes other lambdas are given in PG.P.ModelParams) + X = Ξ + y = &yi; + p = Xi.n_cols; + PG = PGi; + G_nrows = PG.G_nrows; + G_ncols = PG.G_ncols; + G.reserve(G_nrows); + Lambda2Max = PG.Lambda2Max; + Lambda2Min = PG.Lambda2Min; + LambdaMinFactor = PG.LambdaMinFactor; + + P = PG.P; +} + +template +Grid2D::~Grid2D(){ + delete Xtr; + if (PG.P.Specs.Logistic) + delete PG.P.Xy; + if (PG.P.Specs.SquaredHinge) + delete PG.P.Xy; +} + +template +std::vector< std::vector> > > Grid2D::Fit() { + arma::vec Xtrarma; + + if (PG.P.Specs.Logistic) { + auto n = X->n_rows; + double b0 = 0; + arma::vec ExpyXB = arma::ones(n); + if (PG.intercept) { + for (std::size_t t = 0; t < 50; ++t) { + double partial_b0 = - arma::sum( *y / (1 + ExpyXB) ); + b0 -= partial_b0 / (n * 0.25); // intercept is not regularized + ExpyXB = arma::exp(b0 * *y); + } + } + PG.P.b0 = b0; + Xtrarma = arma::abs(- arma::trans(*y /(1+ExpyXB)) * *X).t(); // = gradient of logistic loss at zero + //Xtrarma = 0.5 * arma::abs(y->t() * *X).t(); // = gradient of logistic loss at zero + + T Xy = matrix_vector_schur_product(*X, y); // X->each_col() % *y; + + PG.P.Xy = new T; + *PG.P.Xy = Xy; + } + + else if (PG.P.Specs.SquaredHinge) { + auto n = X->n_rows; + double b0 = 0; + arma::vec onemyxb = arma::ones(n); + arma::uvec indices = arma::find(onemyxb > 0); + if (PG.intercept){ + for (std::size_t t = 0; t < 50; ++t){ + double partial_b0 = arma::sum(2 * onemyxb.elem(indices) % (- y->elem(indices) ) ); + b0 -= partial_b0 / (n * 2); // intercept is not regularized + onemyxb = 1 - (*y * b0); + indices = arma::find(onemyxb > 0); + } + } + PG.P.b0 = b0; + T indices_rows = matrix_rows_get(*X, indices); + Xtrarma = 2 * arma::abs(arma::trans(y->elem(indices) % onemyxb.elem(indices))* indices_rows).t(); // = gradient of loss function at zero + //Xtrarma = 2 * arma::abs(y->t() * *X).t(); // = gradient of loss function at zero + T Xy = matrix_vector_schur_product(*X, y); // X->each_col() % *y; + PG.P.Xy = new T; + *PG.P.Xy = Xy; + } else { + Xtrarma = arma::abs(y->t() * *X).t(); + } + + + double ytXmax = arma::max(Xtrarma); + + std::size_t index; + if (PG.P.Specs.L0L1) { + index = 1; + if(G_nrows != 1) { + Lambda2Max = ytXmax; + Lambda2Min = Lambda2Max * LambdaMinFactor; + } + } else if (PG.P.Specs.L0L2) { + index = 2; + } + + arma::vec Lambdas2 = arma::logspace(std::log10(Lambda2Min), std::log10(Lambda2Max), G_nrows); + Lambdas2 = arma::flipud(Lambdas2); + + std::vector Xtrvec = arma::conv_to< std::vector >::from(Xtrarma); + + Xtr = new std::vector(X->n_cols); // needed! careful + + + PG.XtrAvailable = true; + // Rcpp::Rcout << "Grid2D Start\n"; + for(std::size_t i=0; i> Gl(); + //auto Gl = Grid1D(*X, *y, PG).Fit(); + // Rcpp::Rcout << "Grid1D Start: " << i << "\n"; + G.push_back(std::move(Grid1D(*X, *y, PG).Fit())); + } + + return std::move(G); + +} + +template class Grid2D; +template class Grid2D; diff --git a/python/l0learn/src/Normalize.cpp b/python/l0learn/src/Normalize.cpp new file mode 100644 index 0000000..ac9a055 --- /dev/null +++ b/python/l0learn/src/Normalize.cpp @@ -0,0 +1,14 @@ +#include "Normalize.h" + +std::tuple DeNormalize(beta_vector & B_scaled, + arma::vec & BetaMultiplier, + arma::vec & meanX, double meany) { + beta_vector B_unscaled = B_scaled % BetaMultiplier; + double intercept = meany - arma::dot(B_unscaled, meanX); + // Matrix Type, Intercept + // Dense, True -> meanX = colMeans(X) + // Dense, False -> meanX = 0 Vector (meany = 0) + // Sparse, True -> meanX = 0 Vector + // Sparse, False -> meanX = 0 Vector + return std::make_tuple(B_unscaled, intercept); +} diff --git a/python/l0learn/src/include/BetaVector.h b/python/l0learn/src/include/BetaVector.h new file mode 100644 index 0000000..a2afcac --- /dev/null +++ b/python/l0learn/src/include/BetaVector.h @@ -0,0 +1,103 @@ +#ifndef BETA_VECTOR_H +#define BETA_VECTOR_H +#include +#include + +/* + * arma::vec implementation + */ + + +using beta_vector = arma::vec; +//using beta_vector = arma::sp_mat; + +inline std::vector nnzIndicies(const arma::vec& B){ + // Returns a vector of the Non Zero Indicies of B + const arma::ucolvec nnzs_indicies = arma::find(B); + return arma::conv_to>::from(nnzs_indicies); +} + +// std::vector nnzIndicies(const arma::sp_mat& B){ +// // Returns a vector of the Non Zero Indicies of B +// std::vector S; +// arma::sp_mat::const_iterator it; +// const arma::sp_mat::const_iterator it_end = B.end(); +// for(it = B.begin(); it != it_end; ++it) +// { +// S.push_back(it.row()); +// } +// return S; +// } + +inline std::vector nnzIndicies(const arma::vec& B, const std::size_t low){ + // Returns a vector of the Non Zero Indicies of a slice of B starting at low + // This is for NoSelectK situations + const arma::vec B_slice = B.subvec(low, B.n_rows-1); + const arma::ucolvec nnzs_indicies = arma::find(B_slice); + return arma::conv_to>::from(nnzs_indicies); +} + +// std::vector nnzIndicies(const arma::sp_mat& B, const std::size_t low){ +// // Returns a vector of the Non Zero Indicies of B +// std::vector S; +// +// +// arma::sp_mat::const_iterator it; +// const arma::sp_mat::const_iterator it_end = B.end(); +// +// +// for(it = B.begin(); it != it_end; ++it) +// { +// if (it.row() >= low){ +// S.push_back(it.row()); +// } +// } +// return S; +// } + + +inline std::size_t n_nonzero(const arma::vec& B){ + const arma::vec nnzs = arma::nonzeros(B); + return nnzs.n_rows; + +} + +// std::size_t n_nonzero(const arma::sp_mat& B){ +// return B.n_nonzero; +// +// } + +inline bool has_same_support(const arma::vec& B1, const arma::vec& B2){ + if (B1.size() != B2.size()){ + return false; + } + std::size_t n = B1.n_rows; + + bool same_support = true; + for (std::size_t i = 0; i < n; i++){ + same_support = same_support && ((B1.at(i) != 0) == (B2.at(i) != 0)); + } + return same_support; +} + +// bool has_same_support(const arma::sp_mat& B1, const arma::sp_mat& B2){ +// +// if (B1.n_nonzero != B2.n_nonzero) { +// return false; +// } else { // same number of nnz and Supp is sorted +// arma::sp_mat::const_iterator i1, i2; +// const arma::sp_mat::const_iterator i1_end = B1.end(); +// +// +// for(i1 = B1.begin(), i2 = B2.begin(); i1 != i1_end; ++i1, ++i2) +// { +// if(i1.row() != i2.row()) +// { +// return false; +// } +// } +// return true; +// } +// } + +#endif // BETA_VECTOR_H diff --git a/python/l0learn/src/include/CD.h b/python/l0learn/src/include/CD.h new file mode 100644 index 0000000..012629c --- /dev/null +++ b/python/l0learn/src/include/CD.h @@ -0,0 +1,529 @@ +#ifndef CD_H +#define CD_H +#include +#include +#include +#include "BetaVector.h" +#include "FitResult.h" +#include "Params.h" +#include "Model.h" +#include "utils.h" + +constexpr double lambda1_fudge_factor = 1e-15; + + +template +class CDBase { + protected: + std::size_t NoSelectK; + std::vector * Xtr; + std::size_t n, p; + std::size_t Iter; + + beta_vector B; + beta_vector Bprev; + + std::size_t SameSuppCounter = 0; + double objective; + std::vector Order; // Cycling order + std::vector OldOrder; // Cycling order to be used after support stabilization + convergence. + FitResult result; + + /* Intercept and b0 are used for: + * 1. Classification as b0 is updated iteratively in the CD algorithm + * 2. Regression on Sparse Matrices as we cannot adjust the support of + * the columns of X and thus b0 must be updated iteraveily from the + * residuals + */ + double b0 = 0; + const double lambda0; + const double lambda1; + const double lambda2; + double thr; + double thr2; // threshold squared; + + bool isSparse; + const bool intercept; + const bool withBounds; + + public: + const T * X; + const arma::vec y; + std::vector ModelParams; + + char CyclingOrder; + std::size_t MaxIters; + std::size_t CurrentIters; // current number of iterations - maintained by Converged() + const double rtol; + const double atol; + arma::vec Lows; + arma::vec Highs; + bool ActiveSet; + std::size_t ActiveSetNum; + bool Stabilized = false; + + + CDBase(const T& Xi, const arma::vec& yi, const Params& P); + + FitResult Fit(); + + virtual ~CDBase(){} + + virtual inline double Objective(const arma::vec &, const beta_vector &)=0; + + virtual inline double Objective()=0; + + virtual FitResult _FitWithBounds() = 0; + + virtual FitResult _Fit() = 0; + + static CDBase * make_CD(const T& Xi, const arma::vec& yi, const Params& P); + +}; + +template +class CDSwaps : public CDBase { + +protected: + std::size_t MaxNumSwaps; + Params P; + +public: + + CDSwaps(const T& Xi, const arma::vec& yi, const Params& P); + + virtual ~CDSwaps(){}; + +}; + +class NotImplemented : public std::logic_error{ + public: + NotImplemented() : std::logic_error("Function not yet implemented") { }; +}; + +template +class CD : public CDBase{ + protected: + std::size_t ScreenSize; + std::vector Range1p; + + public: + CD(const T& Xi, const arma::vec& yi, const Params& P); + + virtual ~CD(){}; + + inline double GetBiGrad(const std::size_t i){ + // Must be implemented in Child Classes + throw NotImplemented(); + }; + + inline double GetBiValue(const double old_Bi, const double grd_Bi){ + // Must be implemented in Child Classes + throw NotImplemented(); + }; + + inline double GetBiReg(const double nrb_Bi){ + // Must be implemented in Child Classes + throw NotImplemented(); + }; + + inline void ApplyNewBi(const std::size_t i, const double old_Bi, const double new_Bi){ + // Must be implemented in Child Classes + throw NotImplemented(); + }; + + inline void ApplyNewBiCWMinCheck(const std::size_t i, const double old_Bi, const double new_Bi){ + // Must be implemented in Child Classes + throw NotImplemented(); + }; + + void UpdateBi(const std::size_t i); + + void UpdateBiWithBounds(const std::size_t i); + + bool UpdateBiCWMinCheck(const std::size_t i, const bool Cwmin); + + bool UpdateBiCWMinCheckWithBounds(const std::size_t i, const bool Cwmin); + + void RestrictSupport(); + + void UpdateSparse_b0(arma::vec &r); + + bool isConverged(); + + bool CWMinCheck(); + + bool CWMinCheckWithBounds(); + +}; + + +template +void CD::UpdateBiWithBounds(const std::size_t i){ + // Update a single coefficient of B for various CD Settings + // The following functions are virtual and must be defined for any CD implementation. + // GetBiValue + // GetBiValue + // GetBiReg + // ApplyNewBi + // ApplyNewBiCWMinCheck (found in UpdateBiCWMinCheck) + + + const double grd_Bi = static_cast(this)->GetBiGrad(i); // Gradient of Loss wrt to Bi + + (*this->Xtr)[i] = std::abs(grd_Bi); // Store absolute value of gradient for later steps + + const double old_Bi = this->B[i]; // copy of old Bi to adjust residuals if Bi updates + + const double nrb_Bi = static_cast(this)->GetBiValue(old_Bi, grd_Bi); + // Update Step for New No regularization No Bounds Bi: + // n r b _Bi => nrb_Bi + // Example + // For CDL0: the update step is nrb_Bi = old_Bi + grd_Bi + + const double reg_Bi = static_cast(this)->GetBiReg(nrb_Bi); + // Ideal Bi with L1 and L2 regularization (no bounds) + // Does not account for L0 regularziaton + // Example + // For CDL0: reg_Bi = nrb_Bi as there is no L1, L2 parameters + + const double bnd_Bi = clamp(std::copysign(reg_Bi, nrb_Bi), + this->Lows[i], this->Highs[i]); + // Ideal Bi with regularization and bounds + + // Rcpp::Rcout << "reg_Bi: " << reg_Bi << "\n"; + // Rcpp::Rcout << "new_Bi: " << bnd_Bi << "\n"; + // Rcpp::Rcout << "this->thr: " << this->thr << "\n"; + + if (i < this->NoSelectK){ + // L0 penalty is not applied for NoSelectK Variables. + // Only L1 and L2 (if either are used) + if (std::abs(nrb_Bi) > this->lambda1){ + static_cast(this)->ApplyNewBi(i, old_Bi, bnd_Bi); + // Rcpp::Rcout << "No Select k, Old: " << old_Bi << ", New: " << bnd_Bi << "\n"; + } else if (old_Bi != 0) { + static_cast(this)->ApplyNewBi(i, old_Bi, 0); + // Rcpp::Rcout << "No Select k, Old: " << old_Bi << ", New: " << 0 << "\n"; + } + } else if (reg_Bi < this->thr){ + // If ideal non-bounded reg_Bi is less than threshold, coefficient is not worth setting. + if (old_Bi != 0){ + static_cast(this)->ApplyNewBi(i, old_Bi, 0); + // Rcpp::Rcout << "Below Thresh, Old: " << old_Bi << ", New: " << 0 << "\n"; + } + } else { + // Thus reg_Bi >= this->thr + + const double delta_tmp = std::sqrt(reg_Bi*reg_Bi - this->thr2); + // Due to numerical precision delta_tmp might be nan + // Turns nans to 0. + const double delta = (delta_tmp == delta_tmp) ? delta_tmp : 0; + + const double range_Bi = std::copysign(reg_Bi, nrb_Bi); + + + if ((range_Bi - delta < bnd_Bi) && (bnd_Bi < range_Bi + delta)){ + // bnd_Bi exists in [bnd_Bi - delta, bnd_Bi + delta] + // Therefore accept bnd_Bi + static_cast(this)->ApplyNewBi(i, old_Bi, bnd_Bi); + // Rcpp::Rcout << "Old: " << old_Bi << ", New: " << bnd_Bi << "\n"; + } else if (old_Bi != 0) { + // Otherwise, reject bnd_Bi + static_cast(this)->ApplyNewBi(i, old_Bi, 0); + // Rcpp::Rcout << "Old: " << old_Bi << ", New: " << 0 << "\n"; + } + } +} + +template +void CD::UpdateBi(const std::size_t i){ + // Update a single coefficient of B for various CD Settings + // The following functions are virtual and must be defined for any CD implementation. + // GetBiValue + // GetBiValue + // GetBiReg + // ApplyNewBi + // ApplyNewBiCWMinCheck (found in UpdateBiCWMinCheck) + + + const double grd_Bi = static_cast(this)->GetBiGrad(i); // Gradient of Loss wrt to Bi + + (*this->Xtr)[i] = std::abs(grd_Bi); // Store absolute value of gradient for later steps + + const double old_Bi = this->B[i]; // copy of old Bi to adjust residuals if Bi updates + + const double nrb_Bi = static_cast(this)->GetBiValue(old_Bi, grd_Bi); + // Update Step for New No regularization No Bounds Bi: + // n r b _Bi => nrb_Bi + // Example + // For CDL0: the update step is nrb_Bi = old_Bi + grd_Bi + + const double reg_Bi = static_cast(this)->GetBiReg(nrb_Bi); + // Ideal Bi with L1 and L2 regularization (no bounds) + // Does not account for L0 regularization + // Example + // For CDL0: reg_Bi = nrb_Bi as there is no L1, L2 parameters + + const double new_Bi = std::copysign(reg_Bi, nrb_Bi); + + if (i < this->NoSelectK){ + // L0 penalty is not applied for NoSelectK Variables. + // Only L1 and L2 (if either are used) + if (std::abs(nrb_Bi) > this->lambda1){ + static_cast(this)->ApplyNewBi(i, old_Bi, new_Bi); + } else if (old_Bi != 0) { + static_cast(this)->ApplyNewBi(i, old_Bi, 0); + } + } else if (reg_Bi < this->thr + lambda1_fudge_factor){ + // If ideal non-bounded reg_Bi is less than threshold, coefficient is not worth setting. + if (old_Bi != 0){ + static_cast(this)->ApplyNewBi(i, old_Bi, 0); + // Rcpp::Rcout << "Z" << i <<" "; + } + } else { + static_cast(this)->ApplyNewBi(i, old_Bi, new_Bi); + // Rcpp::Rcout << "NZ" << i <<" "; + } +} + +template +bool CD::UpdateBiCWMinCheck(const std::size_t i, const bool Cwmin){ + // See CD::UpdateBi for documentation + const double grd_Bi = static_cast(this)->GetBiGrad(i); + const double old_Bi = 0; + + (*this->Xtr)[i] = std::abs(grd_Bi); + + const double nrb_Bi = static_cast(this)->GetBiValue(old_Bi, grd_Bi); + const double reg_Bi = static_cast(this)->GetBiReg(nrb_Bi); + const double new_Bi = std::copysign(reg_Bi, nrb_Bi); + + if (reg_Bi < this->thr + lambda1_fudge_factor){ + return Cwmin; + } else { + // Rcpp::Rcout << "Old B[" << i << "] = " << old_Bi << ", New B[" << i << "] = " << new_Bi << "\n"; + static_cast(this)->ApplyNewBiCWMinCheck(i, old_Bi, new_Bi); + return false; + } +} + +template +bool CD::UpdateBiCWMinCheckWithBounds(const std::size_t i, const bool Cwmin){ + // See CD::UpdateBi for documentation + const double grd_Bi = static_cast(this)->GetBiGrad(i); + const double old_Bi = 0; + + (*this->Xtr)[i] = std::abs(grd_Bi); + + const double nrb_Bi = static_cast(this)->GetBiValue(old_Bi, grd_Bi); + const double reg_Bi = static_cast(this)->GetBiReg(nrb_Bi); + const double bnd_Bi = clamp(std::copysign(reg_Bi, nrb_Bi), + this->Lows[i], this->Highs[i]); + + if (reg_Bi < this->thr){ + return Cwmin; + } else { + + const double delta_tmp = std::sqrt(reg_Bi*reg_Bi - this->thr2); + const double delta = (delta_tmp == delta_tmp) ? delta_tmp : 0; + + const double range_Bi = std::copysign(reg_Bi, nrb_Bi); + if ((range_Bi - delta < bnd_Bi) && (bnd_Bi < range_Bi + delta)){ + static_cast(this)->ApplyNewBiCWMinCheck(i, old_Bi, bnd_Bi); + return false; + } else { + return Cwmin; + } + } +} + +/* + * + * CDBase + * + */ + +template +CDBase::CDBase(const T& Xi, const arma::vec& yi, const Params& P) : + lambda0{P.ModelParams[0]}, lambda1{P.ModelParams[1]}, + lambda2{P.ModelParams[2]}, intercept{P.intercept}, withBounds{P.withBounds}, y{yi}, + ModelParams{P.ModelParams}, CyclingOrder{P.CyclingOrder}, MaxIters{P.MaxIters}, + rtol{P.rtol}, atol{P.atol}, Lows{P.Lows}, Highs{P.Highs}, ActiveSet{P.ActiveSet}, + ActiveSetNum{P.ActiveSetNum} + { + this->result.ModelParams = P.ModelParams; + this->NoSelectK = P.NoSelectK; + + this->Xtr = P.Xtr; + this->Iter = P.Iter; + + this->isSparse = std::is_same::value; + + this->b0 = P.b0; + + this->X = Ξ + + this->n = X->n_rows; + this->p = X->n_cols; + + if (P.Init == 'u') { + this->B = *(P.InitialSol); + } else { + //this->B = arma::zeros(p); + this->B = this->B.zeros(p); + } + + if (CyclingOrder == 'u') { + this->Order = P.Uorder; + } else if (CyclingOrder == 'c') { + std::vector cyclic(p); + std::iota(std::begin(cyclic), std::end(cyclic), 0); + this->Order = cyclic; + } + + this->CurrentIters = 0; + } + +template +FitResult CDBase::Fit(){ + // arma::cout << "CDBase::Fit() Start\n"; + // std::this_thread::sleep_for(std::chrono::milliseconds(10)); + if (this->withBounds){ + return this->_FitWithBounds(); + } else{ + // arma::cout << "CDBase::Fit No Bounds() Start\n"; + // std::this_thread::sleep_for(std::chrono::milliseconds(10)); + return this->_Fit(); + } +} + +template class CDBase; +template class CDBase; + +/* + * + * CD + * + */ + +template +void CD::UpdateSparse_b0(arma::vec& r){ + // Only run for regression when T is arma::sp_mat and intercept is True. + // r is this->r on outer scope; + const double new_b0 = arma::mean(r); + r -= new_b0; + this->b0 += new_b0; +} + + +template +bool CD::isConverged() { + this->CurrentIters += 1; // keeps track of the number of calls to Converged + const double objectiveold = this->objective; + this->objective = this->Objective(); + + // Rcpp::Rcout << "Old: "<< objectiveold << ", New: " << this->objective << "\n"; + // Rcpp::Rcout << "Exit 1: " << (std::abs(objectiveold - this->objective) <= this->rtol*objectiveold) << ", Exit 2: " << (this->objective <= 1e-12) << "\n"; + return std::abs(objectiveold - this->objective) <= this->rtol*objectiveold || this->objective <= this->atol; +} + +template +void CD::RestrictSupport() { + + if (has_same_support(this->B, this->Bprev)) { + this->SameSuppCounter += 1; + + if (this->SameSuppCounter == this->ActiveSetNum - 1) { + std::vector NewOrder = nnzIndicies(this->B); + + /// Map m of {Order[i] -> i}: + std::unordered_map m; + + std::size_t index = 0; + for (const auto &i : this->Order){ + m.insert(std::make_pair(i, index)); + index++; + } + + std::sort(NewOrder.begin(), NewOrder.end(), + [&m](std::size_t i, std::size_t j) {return m[i] < m[j] ;}); + + this->OldOrder = this->Order; + this->Order = NewOrder; + this->ActiveSet = false; + this->Stabilized = true; + + } + + } else { + this->SameSuppCounter = 0; + } + +} + +template +bool CD::CWMinCheckWithBounds() { + std::vector S = nnzIndicies(this->B); + + std::vector Sc; + set_difference( + this->Range1p.begin(), + this->Range1p.end(), + S.begin(), + S.end(), + back_inserter(Sc)); + + bool Cwmin = true; + for (auto& i : Sc) { + Cwmin = this->UpdateBiCWMinCheckWithBounds(i, Cwmin); + } + return Cwmin; +} + +template +bool CD::CWMinCheck() { + std::vector S = nnzIndicies(this->B); + + std::vector Sc; + set_difference( + this->Range1p.begin(), + this->Range1p.end(), + S.begin(), + S.end(), + back_inserter(Sc)); + + bool Cwmin = true; + for (auto& i : Sc) { + Cwmin = this->UpdateBiCWMinCheck(i, Cwmin); + } + + return Cwmin; +} + + +template +CD::CD(const T& Xi, const arma::vec& yi, const Params& P) : CDBase(Xi, yi, P){ + Range1p.resize(this->p); + std::iota(std::begin(Range1p), std::end(Range1p), 0); + ScreenSize = P.ScreenSize; +} + +// template class CD; +// template class CD; + +/* + * + * CDSwaps + * + */ + +template +CDSwaps::CDSwaps(const T& Xi, const arma::vec& yi, const Params& Pi) : CDBase(Xi, yi, Pi){ + MaxNumSwaps = Pi.MaxNumSwaps; + P = Pi; +} + +template class CDSwaps; +template class CDSwaps; + +#endif diff --git a/python/l0learn/src/include/CDL0.h b/python/l0learn/src/include/CDL0.h new file mode 100644 index 0000000..b5b4cc8 --- /dev/null +++ b/python/l0learn/src/include/CDL0.h @@ -0,0 +1,182 @@ +#ifndef CDL0_H +#define CDL0_H +#include +#include +#include "CD.h" +#include "Params.h" +#include "FitResult.h" +#include "utils.h" +#include "BetaVector.h" + + +template +class CDL0: public CD>{ + private: + + arma::vec r; //vector of residuals + + public: + CDL0(const T& Xi, const arma::vec& yi, const Params& P); + //~CDL0(){} + + FitResult _FitWithBounds() final; + + FitResult _Fit() final; + + inline double Objective(const arma::vec &, const beta_vector &) final; + + inline double Objective() final; + + inline double GetBiGrad(const std::size_t i); + + inline double GetBiValue(const double old_Bi, const double grd_Bi); + + inline double GetBiReg(const double nrb_Bi); + + inline void ApplyNewBi(const std::size_t i, const double old_Bi, const double new_Bi); + + inline void ApplyNewBiCWMinCheck(const std::size_t i, const double old_Bi, const double new_Bi); +}; + +template +inline double CDL0::GetBiGrad(const std::size_t i){ + return matrix_column_dot(*(this->X), i, this->r); +} + +template +inline double CDL0::GetBiValue(const double old_Bi, const double grd_Bi){ + return grd_Bi + old_Bi; +} + +template +inline double CDL0::GetBiReg(const double nrb_Bi){ + return std::abs(nrb_Bi); +} + +template +inline void CDL0::ApplyNewBi(const std::size_t i, const double old_Bi, const double new_Bi){ + this->r += matrix_column_mult(*(this->X), i, old_Bi - new_Bi); + this->B[i] = new_Bi; +} + +template +inline void CDL0::ApplyNewBiCWMinCheck(const std::size_t i, const double old_Bi, const double new_Bi){ + this->r += matrix_column_mult(*(this->X), i, old_Bi - new_Bi); + this->B[i] = new_Bi; + this->Order.push_back(i); +} + +template +inline double CDL0::Objective(const arma::vec & r, const beta_vector & B) { + return 0.5 * arma::dot(r, r) + this->lambda0 * n_nonzero(B); +} + +template +inline double CDL0::Objective() { + return 0.5 * arma::dot(this->r, this->r) + this->lambda0 * n_nonzero(this->B); +} + +template +CDL0::CDL0(const T& Xi, const arma::vec& yi, const Params& P) : CD>(Xi, yi, P){ + this->thr2 = 2 * this->lambda0; + this->thr = sqrt(this->thr2); + this->r = *P.r; + this->result.r = P.r; +} + +template +FitResult CDL0::_Fit() { + this->objective = Objective(this->r, this->B); + + std::vector FullOrder = this->Order; + + if (this->ActiveSet) { + this->Order.resize(std::min((int) (n_nonzero(this->B) + this->ScreenSize + this->NoSelectK), (int)(this->p))); // std::min(1000,Order.size()) + } + + for (std::size_t t = 0; t < this->MaxIters; ++t) { + this->Bprev = this->B; + + if (this->isSparse && this->intercept){ + this->UpdateSparse_b0(this->r); + } + + //Rcpp::Rcout << "{" << this->Order.size() << "}"; + for (auto& i : this->Order) { + this->UpdateBi(i); + } + + this->RestrictSupport(); + + if (this->isConverged() && this->CWMinCheck()) { + //Rcpp::Rcout << " |Converged on iter:" << t << "CWMinCheck \n"; + break; + } + } + + // arma::cout << "CDL0::_Fit() Loop End\n"; + // std::this_thread::sleep_for(std::chrono::milliseconds(10)); + // Re-optimize b0 after convergence. + if (this->isSparse && this->intercept){ + this->UpdateSparse_b0(this->r); + } + + this->result.Objective = this->objective; + this->result.B = this->B; + *(this->result.r) = this->r; // change to pointer later + this->result.IterNum = this->CurrentIters; + this->result.b0 = this->b0; + + return this->result; +} + +template +FitResult CDL0::_FitWithBounds() { + // Rcpp::Rcout << "CDL0 Fit: "; + clamp_by_vector(this->B, this->Lows, this->Highs); + + this->objective = Objective(this->r, this->B); + + std::vector FullOrder = this->Order; + + if (this->ActiveSet) { + this->Order.resize(std::min((int) (n_nonzero(this->B) + this->ScreenSize + this->NoSelectK), (int)(this->p))); // std::min(1000,Order.size()) + } + + for (std::size_t t = 0; t < this->MaxIters; ++t) { + this->Bprev = this->B; + + if (this->isSparse && this->intercept){ + this->UpdateSparse_b0(this->r); + } + + for (auto& i : this->Order) { + this->UpdateBiWithBounds(i); + } + + this->RestrictSupport(); + + if (this->isConverged() && this->CWMinCheckWithBounds()) { + // Rcpp::Rcout << "Converged on iter:" << t << "\n"; + break; + } + } + + // Re-optimize b0 after convergence. + if (this->isSparse && this->intercept){ + this->UpdateSparse_b0(this->r); + } + + this->result.Objective = this->objective; + this->result.B = this->B; + *(this->result.r) = this->r; // change to pointer later + this->result.IterNum = this->CurrentIters; + this->result.b0 = this->b0; + + return this->result; +} + +template class CDL0; +template class CDL0; + +#endif diff --git a/python/l0learn/src/include/CDL012.h b/python/l0learn/src/include/CDL012.h new file mode 100644 index 0000000..7015470 --- /dev/null +++ b/python/l0learn/src/include/CDL012.h @@ -0,0 +1,180 @@ +#ifndef CDL012_H +#define CDL012_H +#include +#include "CD.h" +#include "FitResult.h" +#include "utils.h" +#include "BetaVector.h" + +template +class CDL012 : public CD>{ + private: + double Onep2lamda2; + arma::vec r; //vector of residuals + + public: + CDL012(const T& Xi, const arma::vec& yi, const Params& P); + //~CDL012(){} + + FitResult _FitWithBounds() final; + + FitResult _Fit() final; + + inline double Objective(const arma::vec & r, const beta_vector & B) final; + + inline double Objective() final; + + inline double GetBiGrad(const std::size_t i); + + inline double GetBiValue(const double old_Bi, const double grd_Bi); + + inline double GetBiReg(const double nrb_Bi); + + inline void ApplyNewBi(const std::size_t i, const double old_Bi, const double new_Bi); + + inline void ApplyNewBiCWMinCheck(const std::size_t i, const double old_Bi, const double new_Bi); + +}; + + +template +inline double CDL012::GetBiGrad(const std::size_t i){ + return matrix_column_dot(*(this->X), i, this->r); +} + +template +inline double CDL012::GetBiValue(const double old_Bi, const double grd_Bi){ + return grd_Bi + old_Bi; +} + +template +inline double CDL012::GetBiReg(const double nrb_Bi){ + // sign(nrb_Bi)*(|nrb_Bi| - lambda1)/(1 + 2*lambda2) + return (std::abs(nrb_Bi) - this->lambda1) / Onep2lamda2; +} + +template +inline void CDL012::ApplyNewBi(const std::size_t i, const double Bi_old, const double Bi_new){ + this->r += matrix_column_mult(*(this->X), i, Bi_old - Bi_new); + this->B[i] = Bi_new; +} + +template +inline void CDL012::ApplyNewBiCWMinCheck(const std::size_t i, const double Bi_old, const double Bi_new){ + this->r += matrix_column_mult(*(this->X), i, Bi_old - Bi_new); + this->B[i] = Bi_new; + this->Order.push_back(i); +} + +template +inline double CDL012::Objective(const arma::vec & r, const beta_vector & B) { + auto l2norm = arma::norm(B, 2); + return 0.5 * arma::dot(r, r) + this->lambda0 * n_nonzero(this->B) + this->lambda1 * arma::norm(B, 1) + this->lambda2 * l2norm * l2norm; +} + +template +inline double CDL012::Objective() { + auto l2norm = arma::norm(this->B, 2); + return 0.5 * arma::dot(this->r, this->r) + this->lambda0 * n_nonzero(this->B) + this->lambda1 * arma::norm(this->B, 1) + this->lambda2 * l2norm * l2norm; +} + +template +CDL012::CDL012(const T& Xi, const arma::vec& yi, const Params& P) : CD>(Xi, yi, P) { + Onep2lamda2 = 1 + 2 * this->lambda2; + + this->thr2 = 2 * this->lambda0 / Onep2lamda2; + this->thr = std::sqrt(this->thr2); + this->r = *P.r; + this->result.r = P.r; +} + +template +FitResult CDL012::_Fit() { + + this->objective = Objective(this->r, this->B); + + std::vector FullOrder = this->Order; + + if (this->ActiveSet) { + this->Order.resize(std::min((int) (n_nonzero(this->B) + this->ScreenSize + this->NoSelectK), (int)(this->p))); + } + + for (std::size_t t = 0; t < this->MaxIters; ++t) { + this->Bprev = this->B; + + if (this->isSparse && this->intercept){ + this->UpdateSparse_b0(this->r); + } + + for (auto& i : this->Order) { + this->UpdateBi(i); + } + + this->RestrictSupport(); + + if (this->isConverged() && this->CWMinCheck()) { + break; + } + } + + if (this->isSparse && this->intercept){ + this->UpdateSparse_b0(this->r); + } + + this->result.Objective = this->objective; + this->result.B = this->B; + *(this->result.r) = this->r; // change to pointer later + this->result.IterNum = this->CurrentIters; + this->result.b0 = this->b0; + return this->result; +} + +template +FitResult CDL012::_FitWithBounds() { + + clamp_by_vector(this->B, this->Lows, this->Highs); + + this->objective = Objective(this->r, this->B); + + std::vector FullOrder = this->Order; + + if (this->ActiveSet) { + this->Order.resize(std::min((int) (n_nonzero(this->B) + this->ScreenSize + this->NoSelectK), (int)(this->p))); + } + + for (std::size_t t = 0; t < this->MaxIters; ++t) { + this->Bprev = this->B; + + if (this->isSparse && this->intercept){ + this->UpdateSparse_b0(this->r); + } + + for (auto& i : this->Order) { + this->UpdateBiWithBounds(i); + } + + this->RestrictSupport(); + + //B.print(); + if (this->isConverged() && this->CWMinCheckWithBounds()) { + break; + } + + } + + if (this->isSparse && this->intercept){ + this->UpdateSparse_b0(this->r); + } + + this->result.Objective = this->objective; + this->result.B = this->B; + *(this->result.r) = this->r; // change to pointer later + this->result.IterNum = this->CurrentIters; + this->result.b0 = this->b0; + return this->result; +} + +template class CDL012; +template class CDL012; + +#endif diff --git a/python/l0learn/src/include/CDL012Logistic.h b/python/l0learn/src/include/CDL012Logistic.h new file mode 100644 index 0000000..b714035 --- /dev/null +++ b/python/l0learn/src/include/CDL012Logistic.h @@ -0,0 +1,194 @@ +#ifndef CDL012Logistic_H +#define CDL012Logistic_H +#include +#include "CD.h" +#include "FitResult.h" +#include "Params.h" +#include "utils.h" +#include "BetaVector.h" + +template +class CDL012Logistic : public CD> { + private: + const double LipschitzConst = 0.25; + double twolambda2; + double qp2lamda2; + double lambda1ol; + arma::vec ExpyXB; + // std::vector * Xtr; + T * Xy; + + public: + CDL012Logistic(const T& Xi, const arma::vec& yi, const Params& P); + //~CDL012Logistic(){} + + FitResult _FitWithBounds() final; + + FitResult _Fit() final; + + inline double Objective(const arma::vec & r, const beta_vector & B) final; + + inline double Objective() final; + + inline double GetBiGrad(const std::size_t i); + + inline double GetBiValue(const double old_Bi, const double grd_Bi); + + inline double GetBiReg(const double Bi_step); + + inline void ApplyNewBi(const std::size_t i, const double Bi_old, const double Bi_new); + + inline void ApplyNewBiCWMinCheck(const std::size_t i, const double old_Bi, const double new_Bi); + +}; + +template +inline double CDL012Logistic::GetBiGrad(const std::size_t i){ + /* + * Notes: + * When called in CWMinCheck, we know that this->B[i] is 0. + */ + return -arma::dot(matrix_column_get(*(this->Xy), i), 1 / (1 + ExpyXB) ) + twolambda2 * this->B[i]; + //return -arma::sum( matrix_column_get(*(this->Xy), i) / (1 + ExpyXB) ) + twolambda2 * this->B[i]; +} + +template +inline double CDL012Logistic::GetBiValue(const double old_Bi, const double grd_Bi){ + return old_Bi - grd_Bi/qp2lamda2; +} + +template +inline double CDL012Logistic::GetBiReg(const double Bi_step){ + return std::abs(Bi_step) - lambda1ol; +} + +template +inline void CDL012Logistic::ApplyNewBi(const std::size_t i, const double old_Bi, const double new_Bi){ + ExpyXB %= arma::exp( (new_Bi - old_Bi) * matrix_column_get(*(this->Xy), i)); + this->B[i] = new_Bi; +} + +template +inline void CDL012Logistic::ApplyNewBiCWMinCheck(const std::size_t i, + const double old_Bi, + const double new_Bi){ + ExpyXB %= arma::exp( (new_Bi - old_Bi) * matrix_column_get(*(this->Xy), i)); + this->B[i] = new_Bi; + this->Order.push_back(i); +} + +template +inline double CDL012Logistic::Objective(const arma::vec & expyXB, const beta_vector & B) { // hint inline + const auto l2norm = arma::norm(B, 2); + // arma::sum(arma::log(1 + 1 / expyXB)) is the negative log-likelihood + return arma::sum(arma::log(1 + 1 / expyXB)) + this->lambda0 * n_nonzero(B) + this->lambda1 * arma::norm(B, 1) + this->lambda2 * l2norm * l2norm; +} + +template +inline double CDL012Logistic::Objective() { + return this->Objective(ExpyXB, this->B); +} + +template +CDL012Logistic::CDL012Logistic(const T& Xi, const arma::vec& yi, const Params& P) : CD>(Xi, yi, P) { + twolambda2 = 2 * this->lambda2; + qp2lamda2 = (LipschitzConst + twolambda2); // this is the univariate lipschitz const of the differentiable objective + this->thr2 = (2 * this->lambda0) / qp2lamda2; + this->thr = std::sqrt(this->thr2); + lambda1ol = this->lambda1 / qp2lamda2; + + ExpyXB = arma::exp(this->y % (*(this->X) * this->B + this->b0)); // Maintained throughout the algorithm + Xy = P.Xy; +} + +template +FitResult CDL012Logistic::_Fit() { + this->objective = Objective(); // Implicitly used ExpyXB + + std::vector FullOrder = this->Order; // never used in LR + this->Order.resize(std::min((int) (n_nonzero(this->B) + this->ScreenSize + this->NoSelectK), (int)(this->p))); + + for (std::size_t t = 0; t < this->MaxIters; ++t) { + this->Bprev = this->B; + + // Update the intercept + if (this->intercept){ + const double b0old = this->b0; + // const double partial_b0 = - arma::sum( *(this->y) / (1 + ExpyXB) ); + const double partial_b0 = - arma::dot( (this->y) , 1/(1 + ExpyXB) ); + this->b0 -= partial_b0 / (this->n * LipschitzConst); // intercept is not regularized + ExpyXB %= arma::exp( (this->b0 - b0old) * (this->y)); + } + + for (auto& i : this->Order) { + this->UpdateBi(i); + } + + this->RestrictSupport(); + + // only way to terminate is by (i) converging on active set and (ii) CWMinCheck + if (this->isConverged() && this->CWMinCheck()) { + break; + } + } + + this->result.Objective = this->objective; + this->result.B = this->B; + this->result.Model = this; + this->result.b0 = this->b0; + this->result.ExpyXB = ExpyXB; + this->result.IterNum = this->CurrentIters; + + return this->result; +} + +template +FitResult CDL012Logistic::_FitWithBounds() { // always uses active sets + + //arma::sp_mat B2 = this->B; + clamp_by_vector(this->B, this->Lows, this->Highs); + + this->objective = Objective(); // Implicitly used ExpyXB + + std::vector FullOrder = this->Order; // never used in LR + this->Order.resize(std::min((int) (n_nonzero(this->B) + this->ScreenSize + this->NoSelectK), (int)(this->p))); + + for (std::size_t t = 0; t < this->MaxIters; ++t) { + this->Bprev = this->B; + + // Update the intercept + if (this->intercept){ + const double b0old = this->b0; + // const double partial_b0 = - arma::sum( *(this->y) / (1 + ExpyXB) ); + const double partial_b0 = - arma::dot( (this->y) , 1/(1 + ExpyXB) ); + this->b0 -= partial_b0 / (this->n * LipschitzConst); // intercept is not regularized + ExpyXB %= arma::exp( (this->b0 - b0old) * (this->y)); + } + + for (auto& i : this->Order) { + this->UpdateBiWithBounds(i); + } + + this->RestrictSupport(); + + // only way to terminate is by (i) converging on active set and (ii) CWMinCheck + if (this->isConverged() && this->CWMinCheckWithBounds()) { + break; + } + } + + this->result.Objective = this->objective; + this->result.B = this->B; + this->result.Model = this; + this->result.b0 = this->b0; + this->result.ExpyXB = ExpyXB; + this->result.IterNum = this->CurrentIters; + + return this->result; +} + +template class CDL012Logistic; +template class CDL012Logistic; + + +#endif diff --git a/python/l0learn/src/include/CDL012LogisticSwaps.h b/python/l0learn/src/include/CDL012LogisticSwaps.h new file mode 100644 index 0000000..8dc3ee2 --- /dev/null +++ b/python/l0learn/src/include/CDL012LogisticSwaps.h @@ -0,0 +1,49 @@ +#ifndef CDL012LogisticSwaps_H +#define CDL012LogisticSwaps_H +#include +#include "CD.h" +#include "CDSwaps.h" +#include "CDL012Logistic.h" +#include "FitResult.h" +#include "Params.h" +#include "utils.h" +#include "BetaVector.h" + +template +class CDL012LogisticSwaps : public CDSwaps { + private: + const double LipschitzConst = 0.25; + double twolambda2; + double qp2lamda2; + double lambda1ol; + double stl0Lc; + arma::vec ExpyXB; + // std::vector * Xtr; + T * Xy; + + public: + CDL012LogisticSwaps(const T& Xi, const arma::vec& yi, const Params& P); + + FitResult _FitWithBounds() final; + + FitResult _Fit() final; + + inline double Objective(const arma::vec & r, const beta_vector & B) final; + + inline double Objective() final; + +}; + + +template +inline double CDL012LogisticSwaps::Objective(const arma::vec & r, const beta_vector & B) { + auto l2norm = arma::norm(B, 2); + return arma::sum(arma::log(1 + 1 / r)) + this->lambda0 * n_nonzero(B) + this->lambda1 * arma::norm(B, 1) + this->lambda2 * l2norm * l2norm; +} + +template +inline double CDL012LogisticSwaps::Objective() { + return this->Objective(ExpyXB, this->B); +} + +#endif diff --git a/python/l0learn/src/include/CDL012SquaredHinge.h b/python/l0learn/src/include/CDL012SquaredHinge.h new file mode 100644 index 0000000..193ded3 --- /dev/null +++ b/python/l0learn/src/include/CDL012SquaredHinge.h @@ -0,0 +1,208 @@ +#ifndef CDL012SquaredHinge_H +#define CDL012SquaredHinge_H +#include +#include "CD.h" +#include "FitResult.h" +#include "Params.h" +#include "utils.h" +#include "BetaVector.h" + +template +class CDL012SquaredHinge : public CD> { + private: + const double LipschitzConst = 2; // for f (without regularization) + double twolambda2; + double qp2lamda2; + double lambda1ol; + // std::vector * Xtr; + arma::vec onemyxb; + arma::uvec indices; + T * Xy; + + + public: + CDL012SquaredHinge(const T& Xi, const arma::vec& yi, const Params& P); + + //~CDL012SquaredHinge(){} + + FitResult _FitWithBounds() final; + + FitResult _Fit() final; + + inline double Objective(const arma::vec & r, const beta_vector & B) final; + + inline double Objective() final; + + inline double GetBiGrad(const std::size_t i); + + inline double GetBiValue(const double old_Bi, const double grd_Bi); + + inline double GetBiReg(const double Bi_step); + + inline void ApplyNewBi(const std::size_t i, const double Bi_old, const double Bi_new); + + inline void ApplyNewBiCWMinCheck(const std::size_t i, const double old_Bi, const double new_Bi); + +}; + +template +inline double CDL012SquaredHinge::GetBiGrad(const std::size_t i){ + // Rcpp::Rcout << "Grad stuff: " << arma::sum(2 * onemyxb.elem(indices) % (- matrix_column_get(*Xy, i).elem(indices)) ) << "\n"; + return arma::sum(2 * onemyxb.elem(indices) % (- matrix_column_get(*Xy, i).elem(indices)) ) + twolambda2 * this->B[i]; +} + +template +inline double CDL012SquaredHinge::GetBiValue(const double old_Bi, const double grd_Bi){ + return old_Bi - grd_Bi / qp2lamda2; +} + +template +inline double CDL012SquaredHinge::GetBiReg(const double Bi_step){ + return std::abs(Bi_step) - lambda1ol; +} + +template +inline void CDL012SquaredHinge::ApplyNewBi(const std::size_t i, const double Bi_old, const double Bi_new){ + onemyxb += (Bi_old - Bi_new) * matrix_column_get(*(this->Xy), i); + this->B[i] = Bi_new; + indices = arma::find(onemyxb > 0); +} + +template +inline void CDL012SquaredHinge::ApplyNewBiCWMinCheck(const std::size_t i, const double Bi_old, const double Bi_new){ + onemyxb += (Bi_old - Bi_new) * matrix_column_get(*(this->Xy), i); + this->B[i] = Bi_new; + indices = arma::find(onemyxb > 0); + this->Order.push_back(i); +} + +template +inline double CDL012SquaredHinge::Objective(const arma::vec & onemyxb, const beta_vector & B) { + + auto l2norm = arma::norm(B, 2); + arma::uvec indices = arma::find(onemyxb > 0); + + return arma::sum(onemyxb.elem(indices) % onemyxb.elem(indices)) + this->lambda0 * n_nonzero(B) + this->lambda1 * arma::norm(B, 1) + this->lambda2 * l2norm * l2norm; +} + + +template +inline double CDL012SquaredHinge::Objective() { + + auto l2norm = arma::norm(this->B, 2); + return arma::sum(onemyxb.elem(indices) % onemyxb.elem(indices)) + this->lambda0 * n_nonzero(this->B) + this->lambda1 * arma::norm(this->B, 1) + this->lambda2 * l2norm * l2norm; +} + +template +CDL012SquaredHinge::CDL012SquaredHinge(const T& Xi, const arma::vec& yi, const Params& P) : CD>(Xi, yi, P) { + twolambda2 = 2 * this->lambda2; + qp2lamda2 = (LipschitzConst + twolambda2); // this is the univariate lipschitz const of the differentiable objective + this->thr2 = (2 * this->lambda0) / qp2lamda2; + this->thr = std::sqrt(this->thr2); + lambda1ol = this->lambda1 / qp2lamda2; + + // TODO: Review this line + // TODO: Pass work from previous solution. + onemyxb = 1 - this->y % (*(this->X) * this->B + this->b0); + + // TODO: Add comment for purpose of 'indices' + indices = arma::find(onemyxb > 0); + Xy = P.Xy; +} + +template +FitResult CDL012SquaredHinge::_Fit() { + + this->objective = Objective(); // Implicitly uses onemyx + + + std::vector FullOrder = this->Order; // never used in LR + this->Order.resize(std::min((int) (n_nonzero(this->B) + this->ScreenSize + this->NoSelectK), (int)(this->p))); + + + for (auto t = 0; t < this->MaxIters; ++t) { + + this->Bprev = this->B; + + // Update the intercept + if (this->intercept) { + const double b0old = this->b0; + const double partial_b0 = arma::sum(2 * onemyxb.elem(indices) % -this->y.elem(indices)); + this->b0 -= partial_b0 / (this->n * LipschitzConst); // intercept is not regularized + onemyxb += this->y * (b0old - this->b0); + indices = arma::find(onemyxb > 0); + } + + for (auto& i : this->Order) { + this->UpdateBi(i); + } + + this->RestrictSupport(); + + // only way to terminate is by (i) converging on active set and (ii) CWMinCheck + if ((this->isConverged()) && this->CWMinCheck()) { + break; + } + } + + this->result.Objective = this->objective; + this->result.B = this->B; + this->result.Model = this; + this->result.b0 = this->b0; + this->result.IterNum = this->CurrentIters; + this->result.onemyxb = this->onemyxb; + return this->result; +} + + +template +FitResult CDL012SquaredHinge::_FitWithBounds() { + + clamp_by_vector(this->B, this->Lows, this->Highs); + + this->objective = Objective(); // Implicitly uses onemyx + + std::vector FullOrder = this->Order; // never used in LR + this->Order.resize(std::min((int) (n_nonzero(this->B) + this->ScreenSize + this->NoSelectK), (int)(this->p))); + + + for (auto t = 0; t < this->MaxIters; ++t) { + + this->Bprev = this->B; + + // Update the intercept + if (this->intercept) { + const double b0old = this->b0; + const double partial_b0 = arma::sum(2 * onemyxb.elem(indices) % -this->y.elem(indices)); + this->b0 -= partial_b0 / (this->n * LipschitzConst); // intercept is not regularized + onemyxb += this->y * (b0old - this->b0); + indices = arma::find(onemyxb > 0); + } + + for (auto& i : this->Order) { + this->UpdateBiWithBounds(i); + } + + this->RestrictSupport(); + + // only way to terminate is by (i) converging on active set and (ii) CWMinCheck + if (this->isConverged()) { + if (this->CWMinCheckWithBounds()) { + break; + } + } + } + + this->result.Objective = this->objective; + this->result.B = this->B; + this->result.Model = this; + this->result.b0 = this->b0; + this->result.IterNum = this->CurrentIters; + this->result.onemyxb = this->onemyxb; + return this->result; +} + +template class CDL012SquaredHinge; +template class CDL012SquaredHinge; + +#endif diff --git a/python/l0learn/src/include/CDL012SquaredHingeSwaps.h b/python/l0learn/src/include/CDL012SquaredHingeSwaps.h new file mode 100644 index 0000000..bf6a608 --- /dev/null +++ b/python/l0learn/src/include/CDL012SquaredHingeSwaps.h @@ -0,0 +1,49 @@ +#ifndef CDL012SquredHingeSwaps_H +#define CDL012SquredHingeSwaps_H +#include +#include "CD.h" +#include "CDSwaps.h" +#include "CDL012SquaredHinge.h" +#include "Params.h" +#include "FitResult.h" +#include "utils.h" +#include "BetaVector.h" + +template +class CDL012SquaredHingeSwaps : public CDSwaps { + private: + const double LipschitzConst = 2; + double twolambda2; + double qp2lamda2; + double lambda1ol; + double stl0Lc; + // std::vector * Xtr; + + public: + CDL012SquaredHingeSwaps(const T& Xi, const arma::vec& yi, const Params& P); + + FitResult _FitWithBounds() final; + + FitResult _Fit() final; + + inline double Objective(const arma::vec & r, const beta_vector & B) final; + + inline double Objective() final; + + +}; + +template +inline double CDL012SquaredHingeSwaps::Objective(const arma::vec & onemyxb, const beta_vector & B) { + auto l2norm = arma::norm(B, 2); + arma::uvec indices = arma::find(onemyxb > 0); + return arma::sum(onemyxb.elem(indices) % onemyxb.elem(indices)) + this->lambda0 * n_nonzero(B) + this->lambda1 * arma::norm(B, 1) + this->lambda2 * l2norm * l2norm; +} + +template +inline double CDL012SquaredHingeSwaps::Objective() { + throw std::runtime_error("CDL012SquaredHingeSwaps does not have this->onemyxb"); +} + + +#endif diff --git a/python/l0learn/src/include/CDL012Swaps.h b/python/l0learn/src/include/CDL012Swaps.h new file mode 100644 index 0000000..0703ac6 --- /dev/null +++ b/python/l0learn/src/include/CDL012Swaps.h @@ -0,0 +1,39 @@ +#ifndef CDL012SWAPS_H +#define CDL012SWAPS_H +#include +#include +#include "CD.h" +#include "CDSwaps.h" +#include "CDL012.h" +#include "FitResult.h" +#include "Params.h" +#include "utils.h" +#include "BetaVector.h" + +template +class CDL012Swaps : public CDSwaps { + public: + CDL012Swaps(const T& Xi, const arma::vec& yi, const Params& Pi); + + FitResult _FitWithBounds() final; + + FitResult _Fit() final; + + double Objective(const arma::vec & r, const beta_vector & B) final; + + double Objective() final; + +}; + +template +inline double CDL012Swaps::Objective(const arma::vec & r, const beta_vector & B) { + auto l2norm = arma::norm(B, 2); + return 0.5 * arma::dot(r, r) + this->lambda0 * n_nonzero(B) + this->lambda1 * arma::norm(B, 1) + this->lambda2 * l2norm * l2norm; +} + +template +inline double CDL012Swaps::Objective() { + throw std::runtime_error("CDL012Swaps does not have this->r."); +} + +#endif diff --git a/python/l0learn/src/include/CDSwaps.h b/python/l0learn/src/include/CDSwaps.h new file mode 100644 index 0000000..752d0a1 --- /dev/null +++ b/python/l0learn/src/include/CDSwaps.h @@ -0,0 +1,5 @@ +#ifndef CDSWAPS_H +#define CDSWAPS_H +#include "CD.h" + +#endif diff --git a/python/l0learn/src/include/FitResult.h b/python/l0learn/src/include/FitResult.h new file mode 100644 index 0000000..9b1f1f2 --- /dev/null +++ b/python/l0learn/src/include/FitResult.h @@ -0,0 +1,22 @@ +#ifndef FITRESULT_H +#define FITRESULT_H +#include +#include "BetaVector.h" + +template // Forward Reference to prevent circular dependencies +class CDBase; + +template +struct FitResult { + double Objective; + beta_vector B; + CDBase * Model; + std::size_t IterNum; + arma::vec * r; + std::vector ModelParams; + double b0 = 0; // used by classification models and sparse regression models + arma::vec ExpyXB; // Used by Logistic regression + arma::vec onemyxb; // Used by SquaredHinge regression +}; + +#endif diff --git a/python/l0learn/src/include/Grid.h b/python/l0learn/src/include/Grid.h new file mode 100644 index 0000000..9c79892 --- /dev/null +++ b/python/l0learn/src/include/Grid.h @@ -0,0 +1,41 @@ +#ifndef GRID_H +#define GRID_H +#include +#include +#include +#include +#include "GridParams.h" +#include "FitResult.h" +#include "Grid1D.h" +#include "Grid2D.h" +#include "Normalize.h" + +template +class Grid { + private: + T Xscaled; + arma::vec yscaled; + arma::vec BetaMultiplier; + arma::vec meanX; + double meany; + double scaley; + + public: + + GridParams PG; + + std::vector< std::vector > Lambda0; + std::vector Lambda12; + std::vector< std::vector > NnzCount; + std::vector< std::vector > Solutions; + std::vector< std::vector >Intercepts; + std::vector< std::vector > Converged; + + Grid(const T& X, const arma::vec& y, const GridParams& PG); + //~Grid(); + + void Fit(); + +}; + +#endif diff --git a/python/l0learn/src/include/Grid1D.h b/python/l0learn/src/include/Grid1D.h new file mode 100644 index 0000000..7985916 --- /dev/null +++ b/python/l0learn/src/include/Grid1D.h @@ -0,0 +1,39 @@ +#ifndef GRID1D_H +#define GRID1D_H +#include +#include +#include +#include +#include "Params.h" +#include "GridParams.h" +#include "FitResult.h" +#include "MakeCD.h" + +template +class Grid1D { + private: + std::size_t G_ncols; + Params P; + const T * X; + const arma::vec * y; + std::size_t p; + std::vector>> G; + arma::vec Lambdas; + bool LambdaU; + std::size_t NnzStopNum; + std::vector * Xtr; + arma::rowvec * ytX; + double LambdaMinFactor; + bool PartialSort; + bool XtrAvailable; + double ytXmax2d; + double ScaleDownFactor; + std::size_t NoSelectK; + + public: + Grid1D(const T& Xi, const arma::vec& yi, const GridParams& PG); + ~Grid1D(); + std::vector>> Fit(); +}; + +#endif diff --git a/python/l0learn/src/include/Grid2D.h b/python/l0learn/src/include/Grid2D.h new file mode 100644 index 0000000..e1d9a7e --- /dev/null +++ b/python/l0learn/src/include/Grid2D.h @@ -0,0 +1,39 @@ +#ifndef GRID2D_H +#define GRID2D_H +#include +#include +#include "GridParams.h" +#include "Params.h" +#include "FitResult.h" +#include "Grid1D.h" +#include "utils.h" + +template +class Grid2D +{ + private: + std::size_t G_nrows; + std::size_t G_ncols; + GridParams PG; + const T * X; + const arma::vec * y; + std::size_t p; + std::vector>>> G; + // each inner vector corresponds to a single lambda_1/lambda_2 + + double Lambda2Max; + double Lambda2Min; + double LambdaMinFactor; + std::vector * Xtr; + Params P; + + + public: + Grid2D(const T& Xi, const arma::vec& yi, const GridParams& PGi); + ~Grid2D(); + std::vector>>> Fit(); + +}; + + +#endif diff --git a/python/l0learn/src/include/GridParams.h b/python/l0learn/src/include/GridParams.h new file mode 100644 index 0000000..0c8244e --- /dev/null +++ b/python/l0learn/src/include/GridParams.h @@ -0,0 +1,28 @@ +#ifndef GRIDPARAMS_H +#define GRIDPARAMS_H +#include +#include "Params.h" + +template +struct GridParams +{ + Params P; + std::size_t G_ncols = 100; + std::size_t G_nrows = 10; + bool LambdaU = false; + std::size_t NnzStopNum = 200; + double LambdaMinFactor = 0.01; + arma::vec Lambdas; + std::vector< std::vector > LambdasGrid; + double Lambda2Max = 0.1; + double Lambda2Min = 0.001; + std::string Type = "L0"; + bool PartialSort = true; + bool XtrAvailable = false; + double ytXmax; + std::vector * Xtr; + double ScaleDownFactor = 0.8; + bool intercept; +}; + +#endif diff --git a/python/l0learn/src/include/L0LearnCore.h b/python/l0learn/src/include/L0LearnCore.h new file mode 100644 index 0000000..ffa896f --- /dev/null +++ b/python/l0learn/src/include/L0LearnCore.h @@ -0,0 +1,341 @@ +#ifndef INTERFACE_H +#define INTERFACE_H + +#include +#include +#include +#include +#include +#include "FitResult.h" +#include "Grid.h" +#include "GridParams.h" + +// Make an external struct + +struct fitmodel +{ + std::vector> Lambda0; + std::vector Lambda12; + std::vector> NnzCount; + arma::field Beta; + std::vector> Intercept; + std::vector> Converged; + + fitmodel() = default; + fitmodel(const fitmodel &) = default; + fitmodel(std::vector> lambda0, + std::vector lambda12, + std::vector> nnzCount, + arma::field beta, + std::vector> intercept, + std::vector> converged): + Lambda0(std::move(lambda0)), + Lambda12(std::move(lambda12)), + NnzCount(std::move(nnzCount)), + Beta(std::move(beta)), + Intercept(std::move(intercept)), + Converged(std::move(converged)){} +}; + +struct cvfitmodel : fitmodel +{ + arma::field CVMeans; + arma::field CVSDs; + + cvfitmodel() = default; + cvfitmodel ( const cvfitmodel & ) = default; + + cvfitmodel(std::vector> lambda0, + std::vector lambda12, + std::vector> nnzCount, + arma::field beta, + std::vector> intercept, + std::vector> converged, + arma::field cVMeans, + arma::field cVSDs) : + fitmodel(std::move(lambda0), + std::move(lambda12), + std::move(nnzCount), + std::move(beta), + std::move(intercept), + std::move(converged)), + CVMeans(std::move(cVMeans)), + CVSDs(std::move(cVSDs)){} +}; + + + +template +GridParams makeGridParams(const std::string Loss, const std::string Penalty, + const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, + const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, + const bool PartialSort, const std::size_t MaxIters, const double rtol, + const double atol, const bool ActiveSet, const std::size_t ActiveSetNum, + const std::size_t MaxNumSwaps, const double ScaleDownFactor, + const std::size_t ScreenSize, const bool LambdaU, + const std::vector< std::vector > Lambdas, + const std::size_t ExcludeFirstK, const bool Intercept, + const bool withBounds, const arma::vec &Lows, const arma::vec &Highs){ + GridParams PG; + PG.NnzStopNum = NnzStopNum; + PG.G_ncols = G_ncols; + PG.G_nrows = G_nrows; + PG.Lambda2Max = Lambda2Max; + PG.Lambda2Min = Lambda2Min; + PG.LambdaMinFactor = Lambda2Min; // + PG.PartialSort = PartialSort; + PG.ScaleDownFactor = ScaleDownFactor; + PG.LambdaU = LambdaU; + PG.LambdasGrid = Lambdas; + PG.Lambdas = Lambdas[0]; // to handle the case of L0 (i.e., Grid1D) + PG.intercept = Intercept; + + Params P; + PG.P = P; + PG.P.MaxIters = MaxIters; + PG.P.rtol = rtol; + PG.P.atol = atol; + PG.P.ActiveSet = ActiveSet; + PG.P.ActiveSetNum = ActiveSetNum; + PG.P.MaxNumSwaps = MaxNumSwaps; + PG.P.ScreenSize = ScreenSize; + PG.P.NoSelectK = ExcludeFirstK; + PG.P.intercept = Intercept; + PG.P.withBounds = withBounds; + PG.P.Lows = Lows; + PG.P.Highs = Highs; + + if (Loss == "SquaredError") { + PG.P.Specs.SquaredError = true; + } else if (Loss == "Logistic") { + PG.P.Specs.Logistic = true; + PG.P.Specs.Classification = true; + } else if (Loss == "SquaredHinge") { + PG.P.Specs.SquaredHinge = true; + PG.P.Specs.Classification = true; + } + + if (Algorithm == "CD") { + PG.P.Specs.CD = true; + } else if (Algorithm == "CDPSI") { + PG.P.Specs.PSI = true; + } + + if (Penalty == "L0") { + PG.P.Specs.L0 = true; + } else if (Penalty == "L0L2") { + PG.P.Specs.L0L2 = true; + } else if (Penalty == "L0L1") { + PG.P.Specs.L0L1 = true; + } + return PG; +} + + +template +fitmodel L0LearnFit(const T& X, const arma::vec& y, const std::string Loss, const std::string Penalty, + const std::string Algorithm, const std::size_t NnzStopNum, const std::size_t G_ncols, + const std::size_t G_nrows, const double Lambda2Max, const double Lambda2Min, + const bool PartialSort, const std::size_t MaxIters, const double rtol, const double atol, + const bool ActiveSet, const std::size_t ActiveSetNum, const std::size_t MaxNumSwaps, + const double ScaleDownFactor, const std::size_t ScreenSize, const bool LambdaU, + const std::vector< std::vector >& Lambdas, const std::size_t ExcludeFirstK, + const bool Intercept, const bool withBounds, const arma::vec &Lows, + const arma::vec &Highs){ + + // arma::cout << "L0LearnCore.h L0LearnFit Entered."; + // arma::cout << "L0LearnCore.h X shape = " << X.n_rows << ", " << X.n_cols << "\n"; + // arma::cout << "L0LearnCore.h y shape = " << y.n_rows << ", " << y.n_cols << "\n"; + // arma::cout << "L0LearnCore.h Lows shape = " << Lows.n_rows << ", " << Lows.n_cols << "\n"; + // arma::cout << "L0LearnCore.h Highs shape = " << Highs.n_rows << ", " << Highs.n_cols << "\n"; + + // arma::cout << "makeGridParams Entering"; + GridParams PG = makeGridParams(Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, + Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, ActiveSet, + ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, + LambdaU, Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs); + + // arma::cout << "PG.P.Specs.L0 " << PG.P.Specs.L0; + // arma::cout << "PG.P.Specs.CD " << PG.P.Specs.CD; + // arma::cout << "PG.P.Specs.CD " << PG.P.Specs.CD; + // arma::cout << "Grid G Entering"; + Grid G(X, y, PG); + // arma::cout << "Grid G.Fit Entering"; + G.Fit(); + + // Next Construct the list of Sparse Beta Matrices. + + auto p = X.n_cols; + arma::field Bs(G.Lambda12.size()); + + for (std::size_t i=0; i +cvfitmodel L0LearnCV(const T& X, const arma::vec& y, const std::string Loss, + const std::string Penalty, const std::string Algorithm, + const unsigned int NnzStopNum, const unsigned int G_ncols, + const unsigned int G_nrows, const double Lambda2Max, + const double Lambda2Min, const bool PartialSort, + const unsigned int MaxIters, const double rtol, + const double atol, const bool ActiveSet, + const unsigned int ActiveSetNum, + const unsigned int MaxNumSwaps, const double ScaleDownFactor, + const unsigned int ScreenSize, const bool LambdaU, + const std::vector< std::vector > Lambdas, + const unsigned int nfolds, const double seed, + const unsigned int ExcludeFirstK, const bool Intercept, + const bool withBounds, const arma::vec &Lows, + const arma::vec &Highs){ + + GridParams PG = makeGridParams(Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, + Lambda2Max, Lambda2Min, PartialSort, MaxIters, rtol, atol, + ActiveSet,ActiveSetNum, MaxNumSwaps, ScaleDownFactor, + ScreenSize,LambdaU, Lambdas, ExcludeFirstK, Intercept, + withBounds, Lows, Highs); + + Grid G(X, y, PG); + G.Fit(); + + // Next Construct the list of Sparse Beta Matrices. + + auto p = X.n_cols; + auto n = X.n_rows; + arma::field Bs(G.Lambda12.size()); + + for (std::size_t i=0; i >(G.size()); + //Intercepts = std::vector< std::vector >(G.size()); + + std::size_t Ngamma = G.Lambda12.size(); + + //std::vector< arma::mat > CVError (G.Solutions.size()); + arma::field< arma::mat > CVError (G.Solutions.size()); + + for (std::size_t i=0; i(0, X.n_rows-1, X.n_rows); + + arma::uvec indices = arma::shuffle(a); + + int samplesperfold = std::ceil(n/double(nfolds)); + int samplesinlastfold = samplesperfold - (samplesperfold*nfolds - n); + + std::vector fullindices(X.n_rows); + std::iota(fullindices.begin(), fullindices.end(), 0); + + + for (std::size_t j=0; j validationindices; + if (j < nfolds-1) + validationindices.resize(samplesperfold); + else + validationindices.resize(samplesinlastfold); + + std::iota(validationindices.begin(), validationindices.end(), samplesperfold*j); + + std::vector trainingindices; + + std::set_difference(fullindices.begin(), fullindices.end(), validationindices.begin(), validationindices.end(), + std::inserter(trainingindices, trainingindices.begin())); + + + // validationindicesarma contains the randomly permuted validation indices as a uvec + arma::uvec validationindicesarma; + arma::uvec validationindicestemp = arma::conv_to< arma::uvec >::from(validationindices); + validationindicesarma = indices.elem(validationindicestemp); + + // trainingindicesarma is similar to validationindicesarma but for training + arma::uvec trainingindicesarma; + + arma::uvec trainingindicestemp = arma::conv_to< arma::uvec >::from(trainingindices); + + + trainingindicesarma = indices.elem(trainingindicestemp); + + + T Xtraining = matrix_rows_get(X, trainingindicesarma); + + arma::mat ytraining = y.elem(trainingindicesarma); + + T Xvalidation = matrix_rows_get(X, validationindicesarma); + + arma::mat yvalidation = y.elem(validationindicesarma); + + PG.LambdaU = true; + PG.XtrAvailable = false; // reset XtrAvailable since its changed upon every call + PG.LambdasGrid = G.Lambda0; + PG.NnzStopNum = p+1; // remove any constraints on the supp size when fitting over the cv folds // +1 is imp to avoid =p edge case + if (PG.P.Specs.L0 == true){ + PG.Lambdas = PG.LambdasGrid[0]; + } + Grid Gtraining(Xtraining, ytraining, PG); + Gtraining.Fit(); + + for (std::size_t i=0; i 0); + CVError[i](k,j) = arma::sum(onemyxb.elem(indices) % onemyxb.elem(indices)) / yvalidation.n_rows; + } + } + } + } + + arma::field CVMeans(Ngamma); + arma::field CVSDs(Ngamma); + + for (std::size_t i=0; i +#include "Params.h" +#include "CD.h" +#include "CDL0.h" +#include "CDL012.h" +#include "CDL012Swaps.h" +#include "CDL012Logistic.h" +#include "CDL012SquaredHinge.h" +#include "CDL012LogisticSwaps.h" +#include "CDL012SquaredHingeSwaps.h" + + +template +CDBase * make_CD(const T& Xi, const arma::vec& yi, const Params& P) { + if (P.Specs.SquaredError) { + if (P.Specs.CD) { + if (P.Specs.L0) { + return new CDL0(Xi, yi, P); + } else { + return new CDL012(Xi, yi, P); + } + } else if (P.Specs.PSI) { + return new CDL012Swaps(Xi, yi, P); + } + } else if (P.Specs.Logistic) { + if (P.Specs.CD) { + return new CDL012Logistic(Xi, yi, P); + } else if (P.Specs.PSI) { + return new CDL012LogisticSwaps(Xi, yi, P); + } + } else if (P.Specs.SquaredHinge) { + if (P.Specs.CD) { + return new CDL012SquaredHinge(Xi, yi, P); + } else if (P.Specs.PSI) { + return new CDL012SquaredHingeSwaps(Xi, yi, P); + } + } + return new CDL0(Xi, yi, P); // handle later +} + + +#endif diff --git a/python/l0learn/src/include/Model.h b/python/l0learn/src/include/Model.h new file mode 100644 index 0000000..a1be074 --- /dev/null +++ b/python/l0learn/src/include/Model.h @@ -0,0 +1,22 @@ +#ifndef MODEL_H +#define MODEL_H + +struct Model { + + bool SquaredError = false; + bool Logistic = false; + bool SquaredHinge = false; + bool Classification = false; + + bool CD = false; + bool PSI = false; + + bool L0 = false; + bool L0L1 = false; + bool L0L2 = false; + bool L1 = false; + bool L1Relaxed = false; + +}; + +#endif diff --git a/python/l0learn/src/include/Normalize.h b/python/l0learn/src/include/Normalize.h new file mode 100644 index 0000000..5fbf684 --- /dev/null +++ b/python/l0learn/src/include/Normalize.h @@ -0,0 +1,52 @@ +#ifndef NORMALIZE_H +#define NORMALIZE_H + +#include +#include +#include "utils.h" +#include "BetaVector.h" + +std::tuple DeNormalize(beta_vector & B_scaled, + arma::vec & BetaMultiplier, + arma::vec & meanX, double meany); + +template +std::tuple Normalize(const T& X, + const arma::vec& y, + T& X_normalized, + arma::vec & y_normalized, + bool Normalizey, + bool intercept) { + + arma::rowvec meanX = matrix_center(X, X_normalized, intercept); + arma::rowvec scaleX = matrix_normalize(X_normalized); + + arma::vec BetaMultiplier; + double meany = 0; + double scaley; + if (Normalizey) { + if (intercept){ + meany = arma::mean(y); + } + y_normalized = y - meany; + + // TODO: Use l2_norm + scaley = arma::norm(y_normalized, 2); + + // properly handle cases where y is constant + if (scaley == 0){ + scaley = 1; + } + + y_normalized = y_normalized / scaley; + BetaMultiplier = scaley / (scaleX.t()); // transpose scale to get a col vec + // Multiplying the learned Beta by BetaMultiplier gives the optimal Beta on the original scale + } else { + y_normalized = y; + BetaMultiplier = 1 / (scaleX.t()); // transpose scale to get a col vec + scaley = 1; + } + return std::make_tuple(BetaMultiplier, meanX.t(), meany, scaley); +} + +#endif // NORMALIZE_H diff --git a/python/l0learn/src/include/Params.h b/python/l0learn/src/include/Params.h new file mode 100644 index 0000000..0ef7167 --- /dev/null +++ b/python/l0learn/src/include/Params.h @@ -0,0 +1,40 @@ +#ifndef PARAMS_H +#define PARAMS_H +#include +#include +#include "Model.h" +#include "BetaVector.h" + +template +struct Params { + + Model Specs; + std::vector ModelParams {0, 0, 0, 2}; + std::size_t MaxIters = 500; + double rtol = 1e-8; + double atol = 1e-12; + char Init = 'z'; // 'z' => zeros + std::size_t RandomStartSize = 10; + beta_vector * InitialSol; + double b0 = 0; // intercept + char CyclingOrder = 'c'; + std::vector Uorder; + bool ActiveSet = true; + std::size_t ActiveSetNum = 6; + std::size_t MaxNumSwaps = 200; // Used by CDSwaps + std::vector * Xtr; + arma::rowvec * ytX; + std::map * D; + std::size_t Iter = 0; // Current iteration number in the grid + std::size_t ScreenSize = 1000; + arma::vec * r; + T * Xy; // used for classification. + std::size_t NoSelectK = 0; + bool intercept = false; + bool withBounds = false; + arma::vec Lows; + arma::vec Highs; + +}; + +#endif diff --git a/python/l0learn/src/include/utils.h b/python/l0learn/src/include/utils.h new file mode 100644 index 0000000..53898ca --- /dev/null +++ b/python/l0learn/src/include/utils.h @@ -0,0 +1,216 @@ +#ifndef L0LEARN_UTILS_HPP +#define L0LEARN_UTILS_HPP +#include +#include +#include "BetaVector.h" + + +template +inline T clamp(T x, T low, T high) { + // -O3 Compiler should remove branches + if (x < low) + x = low; + if (x > high) + x = high; + return x; +} + +template +arma::vec inline matrix_column_get(const arma::mat &mat, T1 col){ + return mat.unsafe_col(col); +} + +template +arma::vec inline matrix_column_get(const arma::sp_mat &mat, T1 col){ + return arma::vec(mat.col(col)); +} + +template +arma::mat inline matrix_rows_get(const arma::mat &mat, const T1 vector_of_row_indices){ + return mat.rows(vector_of_row_indices); +} + +template +arma::sp_mat inline matrix_rows_get(const arma::sp_mat &mat, const T1 vector_of_row_indices){ + // Option for CV for random splitting or contiguous splitting. + // 1 - N without permutations splitting at floor(N/n_folds) + arma::sp_mat row_mat = arma::sp_mat(vector_of_row_indices.n_elem, mat.n_cols); + + for (auto i = 0; i < vector_of_row_indices.n_elem; i++){ + auto row_index = vector_of_row_indices(i); + arma::sp_mat::const_row_iterator begin = mat.begin_row(row_index); + arma::sp_mat::const_row_iterator end = mat.end_row(row_index); + + for (; begin != end; ++begin){ + row_mat(i, begin.col()) = *begin; + } + } + return row_mat; +} + +template +arma::mat inline matrix_vector_schur_product(const arma::mat &mat, const T1 &y){ + // return mat[i, j] * y[i] for each j + return mat.each_col() % *y; +} + +template +arma::sp_mat inline matrix_vector_schur_product(const arma::sp_mat &mat, const T1 &y){ + + arma::sp_mat Xy = arma::sp_mat(mat); + arma::sp_mat::iterator begin = Xy.begin(); + arma::sp_mat::iterator end = Xy.end(); + + auto yp = (*y); + for (; begin != end; ++begin){ + auto row = begin.row(); + *begin = (*begin) * yp(row); + } + return Xy; +} + +template +arma::sp_mat inline matrix_vector_divide(const arma::sp_mat& mat, const T1 &u){ + arma::sp_mat divided_mat = arma::sp_mat(mat); + + //auto up = (*u); + arma::sp_mat::iterator begin = divided_mat.begin(); + arma::sp_mat::iterator end = divided_mat.end(); + for ( ; begin != end; ++begin){ + *begin = (*begin) / u(begin.row()); + } + return divided_mat; +} + +template +arma::mat inline matrix_vector_divide(const arma::mat& mat, const T1 &u){ + return mat.each_col() / u; +} + +arma::rowvec inline matrix_column_sums(const arma::mat& mat){ + return arma::sum(mat, 0); +} + +arma::rowvec inline matrix_column_sums(const arma::sp_mat& mat){ + return arma::rowvec(arma::sum(mat, 0)); +} + +template +double inline matrix_column_dot(const arma::mat &mat, T1 col, const T2 &u){ + return arma::dot(matrix_column_get(mat, col), u); +} + +template +double inline matrix_column_dot(const arma::sp_mat &mat, T1 col, const T2 &u){ + return arma::dot(matrix_column_get(mat, col), u); +} + +template +arma::vec inline matrix_column_mult(const arma::mat &mat, T1 col, const T2 &u){ + return matrix_column_get(mat, col)*u; +} + +template +arma::vec inline matrix_column_mult(const arma::sp_mat &mat, T1 col, const T2 &u){ + return matrix_column_get(mat, col)*u; +} + +void inline clamp_by_vector(arma::vec &B, const arma::vec& lows, const arma::vec& highs){ + const std::size_t n = B.n_rows; + for (std::size_t i = 0; i < n; i++){ + B.at(i) = clamp(B.at(i), lows.at(i), highs.at(i)); + } +} + +// void clamp_by_vector(arma::sp_mat &B, const arma::vec& lows, const arma::vec& highs){ +// // See above implementation without filter for error. +// auto begin = B.begin(); +// auto end = B.end(); +// +// std::vector inds; +// for (; begin != end; ++begin) +// inds.push_back(begin.row()); +// +// auto n = B.size(); +// inds.erase(std::remove_if(inds.begin(), +// inds.end(), +// [n](size_t x){return (x > n) && (x < 0);}), +// inds.end()); +// for (auto& it : inds) { +// double B_item = B(it, 0); +// const double low = lows(it); +// const double high = highs(it); +// B(it, 0) = clamp(B_item, low, high); +// } +// } + +arma::rowvec inline matrix_normalize(arma::sp_mat &mat_norm){ + auto p = mat_norm.n_cols; + arma::rowvec scaleX = arma::zeros(p); // will contain the l2norm of every col + + for (auto col = 0; col < p; col++){ + double l2norm = arma::norm(matrix_column_get(mat_norm, col), 2); + scaleX(col) = l2norm; + } + + scaleX.replace(0, -1); + + for (auto col = 0; col < p; col++){ + arma::sp_mat::col_iterator begin = mat_norm.begin_col(col); + arma::sp_mat::col_iterator end = mat_norm.end_col(col); + for (; begin != end; ++begin) + (*begin) = (*begin)/scaleX(col); + } + + if (mat_norm.has_nan()) + mat_norm.replace(arma::datum::nan, 0); // can handle numerical instabilities. + + return scaleX; +} + +arma::rowvec inline matrix_normalize(arma::mat& mat_norm){ + + auto p = mat_norm.n_cols; + arma::rowvec scaleX = arma::zeros(p); // will contain the l2norm of every col + + for (auto col = 0; col < p; col++) { + double l2norm = arma::norm(matrix_column_get(mat_norm, col), 2); + scaleX(col) = l2norm; + } + + scaleX.replace(0, -1); + mat_norm.each_row() /= scaleX; + + if (mat_norm.has_nan()){ + mat_norm.replace(arma::datum::nan, 0); // can handle numerical instabilities. + } + + return scaleX; +} + +arma::rowvec inline matrix_center(const arma::mat& X, arma::mat& X_normalized, + bool intercept){ + auto p = X.n_cols; + arma::rowvec meanX; + + if (intercept){ + meanX = arma::mean(X, 0); + X_normalized = X.each_row() - meanX; + } else { + meanX = arma::zeros(p); + X_normalized = arma::mat(X); + } + + return meanX; +} + +arma::rowvec inline matrix_center(const arma::sp_mat& X, arma::sp_mat& X_normalized, + bool intercept){ + auto p = X.n_cols; + arma::rowvec meanX = arma::zeros(p); + X_normalized = arma::sp_mat(X); + return meanX; +} + + +#endif //L0LEARN_UTILS_HPP diff --git a/python/l0learn/testing_utils.cpp b/python/l0learn/testing_utils.cpp new file mode 100644 index 0000000..e787bbf --- /dev/null +++ b/python/l0learn/testing_utils.cpp @@ -0,0 +1,7268 @@ +/* Generated by Cython 0.29.21 */ + +/* BEGIN: Cython Metadata +{ + "distutils": { + "depends": [ + "/Users/tnonet/opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/core/include/numpy/arrayobject.h", + "/Users/tnonet/opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/core/include/numpy/ufuncobject.h" + ], + "extra_compile_args": [ + "-std=c++11" + ], + "extra_link_args": [ + "-std=c++11" + ], + "include_dirs": [ + ".", + "/Users/tnonet/opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/core/include" + ], + "language": "c++", + "libraries": [ + "armadillo", + "lapack", + "blas" + ], + "name": "l0learn.testing_utils", + "sources": [ + "l0learn/testing_utils.pyx" + ] + }, + "module_name": "l0learn.testing_utils" +} +END: Cython Metadata */ + +#define PY_SSIZE_T_CLEAN +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.6+ or Python 3.3+. +#else +#define CYTHON_ABI "0_29_21" +#define CYTHON_HEX_VERSION 0x001D15F0 +#define CYTHON_FUTURE_DIVISION 1 +#include +#ifndef offsetof + #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#define __PYX_COMMA , +#ifndef HAVE_LONG_LONG + #if PY_VERSION_HEX >= 0x02070000 + #define HAVE_LONG_LONG + #endif +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION + #define CYTHON_COMPILING_IN_PYPY 1 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 +#elif defined(PYSTON_VERSION) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 1 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 +#else + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) + #define CYTHON_USE_PYTYPE_LOOKUP 1 + #endif + #if PY_MAJOR_VERSION < 3 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #define CYTHON_USE_PYLONG_INTERNALS 1 + #endif + #ifndef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 1 + #endif + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #if PY_VERSION_HEX < 0x030300F0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #elif !defined(CYTHON_USE_UNICODE_WRITER) + #define CYTHON_USE_UNICODE_WRITER 1 + #endif + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #ifndef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #ifndef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 1 + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) + #endif + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #endif + #ifndef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) + #endif + #ifndef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #endif +#endif +#if !defined(CYTHON_FAST_PYCCALL) +#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) +#endif +#if CYTHON_USE_PYLONG_INTERNALS + #include "longintrepr.h" + #undef SHIFT + #undef BASE + #undef MASK + #ifdef SIZEOF_VOID_P + enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; + #endif +#endif +#ifndef __has_attribute + #define __has_attribute(x) 0 +#endif +#ifndef __has_cpp_attribute + #define __has_cpp_attribute(x) 0 +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_MAYBE_UNUSED_VAR +# if defined(__cplusplus) + template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } +# else +# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# endif +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) +#ifdef _MSC_VER + #ifndef _MSC_STDINT_H_ + #if _MSC_VER < 1300 + typedef unsigned char uint8_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int32 uint32_t; + #endif + #endif +#else + #include +#endif +#ifndef CYTHON_FALLTHROUGH + #if defined(__cplusplus) && __cplusplus >= 201103L + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #elif __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_attribute(fallthrough) + #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) + #else + #define CYTHON_FALLTHROUGH + #endif + #endif + #if defined(__clang__ ) && defined(__apple_build_version__) + #if __apple_build_version__ < 7000000 + #undef CYTHON_FALLTHROUGH + #define CYTHON_FALLTHROUGH + #endif + #endif +#endif + +#ifndef __cplusplus + #error "Cython files generated with the C++ option must be compiled with a C++ compiler." +#endif +#ifndef CYTHON_INLINE + #if defined(__clang__) + #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) + #else + #define CYTHON_INLINE inline + #endif +#endif +template +void __Pyx_call_destructor(T& x) { + x.~T(); +} +template +class __Pyx_FakeReference { + public: + __Pyx_FakeReference() : ptr(NULL) { } + __Pyx_FakeReference(const T& ref) : ptr(const_cast(&ref)) { } + T *operator->() { return ptr; } + T *operator&() { return ptr; } + operator T&() { return *ptr; } + template bool operator ==(U other) { return *ptr == other; } + template bool operator !=(U other) { return *ptr != other; } + private: + T *ptr; +}; + +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) + #define Py_OptimizeFlag 0 +#endif +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyClass_Type +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" +#if PY_VERSION_HEX >= 0x030800A4 && PY_VERSION_HEX < 0x030800B2 + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, 0, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#else + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#endif + #define __Pyx_DefaultClassType PyType_Type +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#ifndef METH_STACKLESS + #define METH_STACKLESS 0 +#endif +#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) + #ifndef METH_FASTCALL + #define METH_FASTCALL 0x80 + #endif + typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); + typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, + Py_ssize_t nargs, PyObject *kwnames); +#else + #define __Pyx_PyCFunctionFast _PyCFunctionFast + #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords +#endif +#if CYTHON_FAST_PYCCALL +#define __Pyx_PyFastCFunction_Check(func)\ + ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) +#else +#define __Pyx_PyFastCFunction_Check(func) 0 +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) + #define PyObject_Malloc(s) PyMem_Malloc(s) + #define PyObject_Free(p) PyMem_Free(p) + #define PyObject_Realloc(p) PyMem_Realloc(p) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 + #define PyMem_RawMalloc(n) PyMem_Malloc(n) + #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) + #define PyMem_RawFree(p) PyMem_Free(p) +#endif +#if CYTHON_COMPILING_IN_PYSTON + #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) +#else + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) +#endif +#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x03060000 + #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() +#elif PY_VERSION_HEX >= 0x03000000 + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#else + #define __Pyx_PyThreadState_Current _PyThreadState_Current +#endif +#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) +#include "pythread.h" +#define Py_tss_NEEDS_INIT 0 +typedef int Py_tss_t; +static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { + *key = PyThread_create_key(); + return 0; +} +static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { + Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); + *key = Py_tss_NEEDS_INIT; + return key; +} +static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { + PyObject_Free(key); +} +static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { + return *key != Py_tss_NEEDS_INIT; +} +static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { + PyThread_delete_key(*key); + *key = Py_tss_NEEDS_INIT; +} +static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { + return PyThread_set_key_value(*key, value); +} +static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { + return PyThread_get_key_value(*key); +} +#endif +#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) +#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) +#else +#define __Pyx_PyDict_NewPresized(n) PyDict_New() +#endif +#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +#else +#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) + #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) + #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #endif +#else + #define CYTHON_PEP393_ENABLED 0 + #define PyUnicode_1BYTE_KIND 1 + #define PyUnicode_2BYTE_KIND 2 + #define PyUnicode_4BYTE_KIND 4 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) + #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#endif +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#else + #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#endif +#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) + #define PyObject_ASCII(o) PyObject_Repr(o) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBaseString_Type PyUnicode_Type + #define PyStringObject PyUnicodeObject + #define PyString_Type PyUnicode_Type + #define PyString_Check PyUnicode_Check + #define PyString_CheckExact PyUnicode_CheckExact +#ifndef PyObject_Unicode + #define PyObject_Unicode PyObject_Str +#endif +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#endif +#if PY_VERSION_HEX >= 0x030900A4 + #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) +#else + #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) +#endif +#if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) +#else + #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask + #define PyNumber_Int PyNumber_Long +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY + #ifndef PyUnicode_InternFromString + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) + #endif +#endif +#if PY_VERSION_HEX < 0x030200A4 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t PyInt_AsLong +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) +#else + #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) +#endif +#if CYTHON_USE_ASYNC_SLOTS + #if PY_VERSION_HEX >= 0x030500B1 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods + #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) + #else + #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) + #endif +#else + #define __Pyx_PyType_AsAsync(obj) NULL +#endif +#ifndef __Pyx_PyAsyncMethodsStruct + typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + } __Pyx_PyAsyncMethodsStruct; +#endif + +#if defined(WIN32) || defined(MS_WINDOWS) + #define _USE_MATH_DEFINES +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif +#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) +#define __Pyx_truncl trunc +#else +#define __Pyx_truncl truncl +#endif + +#define __PYX_MARK_ERR_POS(f_index, lineno) \ + { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } +#define __PYX_ERR(f_index, lineno, Ln_error) \ + { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__l0learn__testing_utils +#define __PYX_HAVE_API__l0learn__testing_utils +/* Early includes */ +#include +#include +#include "numpy/arrayobject.h" +#include "numpy/ufuncobject.h" + + /* NumPy API declarations from "numpy/__init__.pxd" */ + +#include "armadillo" +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { + return (size_t) i < (size_t) limit; +} +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) + #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#else + #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize +#endif +#define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); +#define __Pyx_PySequence_Tuple(obj)\ + (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +#if CYTHON_ASSUME_SAFE_MACROS +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) +#else +#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) +#endif +#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + const char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + if (strcmp(default_encoding_c, "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (!ascii_chars_u) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { + PyErr_Format( + PyExc_ValueError, + "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + Py_DECREF(ascii_chars_u); + Py_DECREF(ascii_chars_b); + } + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); + if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ +static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } + +static PyObject *__pyx_m = NULL; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_cython_runtime = NULL; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static PyObject *__pyx_empty_unicode; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + +/* Header.proto */ +#if !defined(CYTHON_CCOMPLEX) + #if defined(__cplusplus) + #define CYTHON_CCOMPLEX 1 + #elif defined(_Complex_I) + #define CYTHON_CCOMPLEX 1 + #else + #define CYTHON_CCOMPLEX 0 + #endif +#endif +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #include + #else + #include + #endif +#endif +#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) + #undef _Complex_I + #define _Complex_I 1.0fj +#endif + + +static const char *__pyx_f[] = { + "l0learn/testing_utils.pyx", + "__init__.pxd", + "type.pxd", +}; +/* BufferFormatStructs.proto */ +#define IS_UNSIGNED(type) (((type) -1) > 0) +struct __Pyx_StructField_; +#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0) +typedef struct { + const char* name; + struct __Pyx_StructField_* fields; + size_t size; + size_t arraysize[8]; + int ndim; + char typegroup; + char is_unsigned; + int flags; +} __Pyx_TypeInfo; +typedef struct __Pyx_StructField_ { + __Pyx_TypeInfo* type; + const char* name; + size_t offset; +} __Pyx_StructField; +typedef struct { + __Pyx_StructField* field; + size_t parent_offset; +} __Pyx_BufFmt_StackElem; +typedef struct { + __Pyx_StructField root; + __Pyx_BufFmt_StackElem* head; + size_t fmt_offset; + size_t new_count, enc_count; + size_t struct_alignment; + int is_complex; + char enc_type; + char new_packmode; + char enc_packmode; + char is_valid_array; +} __Pyx_BufFmt_Context; + + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":689 + * # in Cython to enable them only on the right systems. + * + * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + */ +typedef npy_int8 __pyx_t_5numpy_int8_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":690 + * + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t + */ +typedef npy_int16 __pyx_t_5numpy_int16_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":691 + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< + * ctypedef npy_int64 int64_t + * #ctypedef npy_int96 int96_t + */ +typedef npy_int32 __pyx_t_5numpy_int32_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":692 + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< + * #ctypedef npy_int96 int96_t + * #ctypedef npy_int128 int128_t + */ +typedef npy_int64 __pyx_t_5numpy_int64_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":696 + * #ctypedef npy_int128 int128_t + * + * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + */ +typedef npy_uint8 __pyx_t_5numpy_uint8_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":697 + * + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t + */ +typedef npy_uint16 __pyx_t_5numpy_uint16_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":698 + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< + * ctypedef npy_uint64 uint64_t + * #ctypedef npy_uint96 uint96_t + */ +typedef npy_uint32 __pyx_t_5numpy_uint32_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":699 + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< + * #ctypedef npy_uint96 uint96_t + * #ctypedef npy_uint128 uint128_t + */ +typedef npy_uint64 __pyx_t_5numpy_uint64_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":703 + * #ctypedef npy_uint128 uint128_t + * + * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< + * ctypedef npy_float64 float64_t + * #ctypedef npy_float80 float80_t + */ +typedef npy_float32 __pyx_t_5numpy_float32_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":704 + * + * ctypedef npy_float32 float32_t + * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< + * #ctypedef npy_float80 float80_t + * #ctypedef npy_float128 float128_t + */ +typedef npy_float64 __pyx_t_5numpy_float64_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":713 + * # The int types are mapped a bit surprising -- + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t + */ +typedef npy_long __pyx_t_5numpy_int_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":714 + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong longlong_t + * + */ +typedef npy_longlong __pyx_t_5numpy_long_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":715 + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_ulong uint_t + */ +typedef npy_longlong __pyx_t_5numpy_longlong_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":717 + * ctypedef npy_longlong longlong_t + * + * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t + */ +typedef npy_ulong __pyx_t_5numpy_uint_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":718 + * + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulonglong_t + * + */ +typedef npy_ulonglong __pyx_t_5numpy_ulong_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":719 + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_intp intp_t + */ +typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":721 + * ctypedef npy_ulonglong ulonglong_t + * + * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< + * ctypedef npy_uintp uintp_t + * + */ +typedef npy_intp __pyx_t_5numpy_intp_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":722 + * + * ctypedef npy_intp intp_t + * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< + * + * ctypedef npy_double float_t + */ +typedef npy_uintp __pyx_t_5numpy_uintp_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":724 + * ctypedef npy_uintp uintp_t + * + * ctypedef npy_double float_t # <<<<<<<<<<<<<< + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t + */ +typedef npy_double __pyx_t_5numpy_float_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":725 + * + * ctypedef npy_double float_t + * ctypedef npy_double double_t # <<<<<<<<<<<<<< + * ctypedef npy_longdouble longdouble_t + * + */ +typedef npy_double __pyx_t_5numpy_double_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":726 + * ctypedef npy_double float_t + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cfloat cfloat_t + */ +typedef npy_longdouble __pyx_t_5numpy_longdouble_t; +/* Declarations.proto */ +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< float > __pyx_t_float_complex; + #else + typedef float _Complex __pyx_t_float_complex; + #endif +#else + typedef struct { float real, imag; } __pyx_t_float_complex; +#endif +static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); + +/* Declarations.proto */ +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< double > __pyx_t_double_complex; + #else + typedef double _Complex __pyx_t_double_complex; + #endif +#else + typedef struct { double real, imag; } __pyx_t_double_complex; +#endif +static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); + + +/*--- Type declarations ---*/ + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":728 + * ctypedef npy_longdouble longdouble_t + * + * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t + */ +typedef npy_cfloat __pyx_t_5numpy_cfloat_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":729 + * + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< + * ctypedef npy_clongdouble clongdouble_t + * + */ +typedef npy_cdouble __pyx_t_5numpy_cdouble_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":730 + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cdouble complex_t + */ +typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":732 + * ctypedef npy_clongdouble clongdouble_t + * + * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew1(a): + */ +typedef npy_cdouble __pyx_t_5numpy_complex_t; + +/* --- Runtime support code (head) --- */ +/* Refnanny.proto */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +/* ExtTypeTest.proto */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + +/* IsLittleEndian.proto */ +static CYTHON_INLINE int __Pyx_Is_Little_Endian(void); + +/* BufferFormatCheck.proto */ +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts); +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + __Pyx_TypeInfo* type); + +/* BufferGetAndValidate.proto */ +#define __Pyx_GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)\ + ((obj == Py_None || obj == NULL) ?\ + (__Pyx_ZeroBuffer(buf), 0) :\ + __Pyx__GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)) +static int __Pyx__GetBufferAndValidate(Py_buffer* buf, PyObject* obj, + __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack); +static void __Pyx_ZeroBuffer(Py_buffer* buf); +static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info); +static Py_ssize_t __Pyx_minusones[] = { -1, -1, -1, -1, -1, -1, -1, -1 }; +static Py_ssize_t __Pyx_zeros[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; + +/* BufferFallbackError.proto */ +static void __Pyx_RaiseBufferFallbackError(void); + +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() PyErr_Occurred() +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +#else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + +/* RaiseArgTupleInvalid.proto */ +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); + +/* RaiseDoubleKeywords.proto */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +/* ParseKeywords.proto */ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ + const char* function_name); + +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* GetTopmostException.proto */ +#if CYTHON_USE_EXC_INFO_STACK +static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); +#endif + +/* SaveResetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +#else +#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) +#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) +#endif + +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +#else +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +#endif + +/* GetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* PyObjectCall.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* TypeImport.proto */ +#ifndef __PYX_HAVE_RT_ImportType_proto +#define __PYX_HAVE_RT_ImportType_proto +enum __Pyx_ImportType_CheckSize { + __Pyx_ImportType_CheckSize_Error = 0, + __Pyx_ImportType_CheckSize_Warn = 1, + __Pyx_ImportType_CheckSize_Ignore = 2 +}; +static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size); +#endif + +/* Import.proto */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +/* PyDictVersioning.proto */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) +#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ + (version_var) = __PYX_GET_DICT_VERSION(dict);\ + (cache_var) = (value); +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ + (VAR) = __pyx_dict_cached_value;\ + } else {\ + (VAR) = __pyx_dict_cached_value = (LOOKUP);\ + __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ + }\ +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); +#else +#define __PYX_GET_DICT_VERSION(dict) (0) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); +#endif + +/* CLineInTraceback.proto */ +#ifdef CYTHON_CLINE_IN_TRACEBACK +#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) +#else +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); +#endif + +/* CodeObjectCache.proto */ +typedef struct { + PyCodeObject* code_object; + int code_line; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; +}; +static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static PyCodeObject *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); + +/* AddTraceback.proto */ +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +/* BufferStructDeclare.proto */ +typedef struct { + Py_ssize_t shape, strides, suboffsets; +} __Pyx_Buf_DimInfo; +typedef struct { + size_t refcount; + Py_buffer pybuffer; +} __Pyx_Buffer; +typedef struct { + __Pyx_Buffer *rcbuffer; + char *data; + __Pyx_Buf_DimInfo diminfo[8]; +} __Pyx_LocalBuf_ND; + +#if PY_MAJOR_VERSION < 3 + static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags); + static void __Pyx_ReleaseBuffer(Py_buffer *view); +#else + #define __Pyx_GetBuffer PyObject_GetBuffer + #define __Pyx_ReleaseBuffer PyBuffer_Release +#endif + + +/* RealImag.proto */ +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #define __Pyx_CREAL(z) ((z).real()) + #define __Pyx_CIMAG(z) ((z).imag()) + #else + #define __Pyx_CREAL(z) (__real__(z)) + #define __Pyx_CIMAG(z) (__imag__(z)) + #endif +#else + #define __Pyx_CREAL(z) ((z).real) + #define __Pyx_CIMAG(z) ((z).imag) +#endif +#if defined(__cplusplus) && CYTHON_CCOMPLEX\ + && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103) + #define __Pyx_SET_CREAL(z,x) ((z).real(x)) + #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) +#else + #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) + #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) +#endif + +/* Arithmetic.proto */ +#if CYTHON_CCOMPLEX + #define __Pyx_c_eq_float(a, b) ((a)==(b)) + #define __Pyx_c_sum_float(a, b) ((a)+(b)) + #define __Pyx_c_diff_float(a, b) ((a)-(b)) + #define __Pyx_c_prod_float(a, b) ((a)*(b)) + #define __Pyx_c_quot_float(a, b) ((a)/(b)) + #define __Pyx_c_neg_float(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero_float(z) ((z)==(float)0) + #define __Pyx_c_conj_float(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_abs_float(z) (::std::abs(z)) + #define __Pyx_c_pow_float(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero_float(z) ((z)==0) + #define __Pyx_c_conj_float(z) (conjf(z)) + #if 1 + #define __Pyx_c_abs_float(z) (cabsf(z)) + #define __Pyx_c_pow_float(a, b) (cpowf(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex); + static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex); + #if 1 + static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex, __pyx_t_float_complex); + #endif +#endif + +/* Arithmetic.proto */ +#if CYTHON_CCOMPLEX + #define __Pyx_c_eq_double(a, b) ((a)==(b)) + #define __Pyx_c_sum_double(a, b) ((a)+(b)) + #define __Pyx_c_diff_double(a, b) ((a)-(b)) + #define __Pyx_c_prod_double(a, b) ((a)*(b)) + #define __Pyx_c_quot_double(a, b) ((a)/(b)) + #define __Pyx_c_neg_double(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero_double(z) ((z)==(double)0) + #define __Pyx_c_conj_double(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_abs_double(z) (::std::abs(z)) + #define __Pyx_c_pow_double(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero_double(z) ((z)==0) + #define __Pyx_c_conj_double(z) (conj(z)) + #if 1 + #define __Pyx_c_abs_double(z) (cabs(z)) + #define __Pyx_c_pow_double(a, b) (cpow(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex); + static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex); + #if 1 + static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex, __pyx_t_double_complex); + #endif +#endif + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +/* FastTypeChecks.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); +#else +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) +#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) +#endif +#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) + +/* CheckBinaryVersion.proto */ +static int __Pyx_check_binary_version(void); + +/* FunctionExport.proto */ +static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig); + +/* FunctionImport.proto */ +static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig); + +/* InitStrings.proto */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); + + +/* Module declarations from 'cpython.buffer' */ + +/* Module declarations from 'libc.string' */ + +/* Module declarations from 'libc.stdio' */ + +/* Module declarations from '__builtin__' */ + +/* Module declarations from 'cpython.type' */ +static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; + +/* Module declarations from 'cpython' */ + +/* Module declarations from 'cpython.object' */ + +/* Module declarations from 'cpython.ref' */ + +/* Module declarations from 'cpython.mem' */ + +/* Module declarations from 'numpy' */ + +/* Module declarations from 'numpy' */ +static PyTypeObject *__pyx_ptype_5numpy_dtype = 0; +static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; +static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; +static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; +static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; + +/* Module declarations from 'libcpp' */ + +/* Module declarations from 'l0learn.cyarma' */ +static arma::field (*__pyx_f_7l0learn_6cyarma_list_to_sp_dmat_field)(PyObject *); /*proto*/ +static arma::field (*__pyx_f_7l0learn_6cyarma_list_to_dvec_field)(PyObject *); /*proto*/ +static arma::dmat (*__pyx_f_7l0learn_6cyarma_numpy_to_dmat_d)(PyArrayObject *); /*proto*/ +static arma::dvec (*__pyx_f_7l0learn_6cyarma_numpy_to_dvec_d)(PyArrayObject *); /*proto*/ +static arma::uvec (*__pyx_f_7l0learn_6cyarma_numpy_to_uvec_d)(PyArrayObject *); /*proto*/ +static arma::sp_dmat (*__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d)(PyObject *); /*proto*/ +static PyObject *(*__pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list)(arma::field ); /*proto*/ +static PyObject *(*__pyx_f_7l0learn_6cyarma_dvec_field_to_list)(arma::field ); /*proto*/ +static PyArrayObject *(*__pyx_f_7l0learn_6cyarma_dmat_to_numpy)(arma::dmat const &, PyArrayObject *); /*proto*/ +static PyArrayObject *(*__pyx_f_7l0learn_6cyarma_dvec_to_numpy)(arma::dvec const &, PyArrayObject *); /*proto*/ +static PyArrayObject *(*__pyx_f_7l0learn_6cyarma_uvec_to_numpy)(arma::uvec const &, PyArrayObject *); /*proto*/ +static PyObject *(*__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy)(arma::sp_dmat const &, PyArrayObject *, PyArrayObject *, PyArrayObject *); /*proto*/ + +/* Module declarations from 'cython' */ + +/* Module declarations from 'l0learn.testing_utils' */ +static PyObject *__pyx_f_7l0learn_13testing_utils_c_list_csc_to_arma_csc_to_list(PyObject *); /*proto*/ +static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_dmat_np_to_arma_to_np(PyArrayObject *); /*proto*/ +static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_uvec_np_to_arma_to_np(PyArrayObject *); /*proto*/ +static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_dvec_np_to_arma_to_np(PyArrayObject *); /*proto*/ +static PyObject *__pyx_f_7l0learn_13testing_utils_c_sp_dmat_np_to_arma_to_np(PyObject *); /*proto*/ +static arma::dmat __pyx_f_7l0learn_13testing_utils_c_dmat_dot_dmat(arma::dmat, arma::dmat); /*proto*/ +static PyObject *__pyx_f_7l0learn_13testing_utils_c_list_dvec_to_arma_dvec_to_list(PyObject *); /*proto*/ +static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_double_t = { "double_t", NULL, sizeof(__pyx_t_5numpy_double_t), { 0 }, 0, 'R', 0, 0 }; +static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t = { "uint64_t", NULL, sizeof(__pyx_t_5numpy_uint64_t), { 0 }, 0, IS_UNSIGNED(__pyx_t_5numpy_uint64_t) ? 'U' : 'I', IS_UNSIGNED(__pyx_t_5numpy_uint64_t), 0 }; +#define __Pyx_MODULE_NAME "l0learn.testing_utils" +extern int __pyx_module_is_main_l0learn__testing_utils; +int __pyx_module_is_main_l0learn__testing_utils = 0; + +/* Implementation of 'l0learn.testing_utils' */ +static PyObject *__pyx_builtin_ImportError; +static const char __pyx_k_x[] = "x"; +static const char __pyx_k_y[] = "y"; +static const char __pyx_k_np[] = "np"; +static const char __pyx_k_main[] = "__main__"; +static const char __pyx_k_name[] = "__name__"; +static const char __pyx_k_test[] = "__test__"; +static const char __pyx_k_np_xy[] = "np_xy"; +static const char __pyx_k_numpy[] = "numpy"; +static const char __pyx_k_arma_x[] = "arma_x"; +static const char __pyx_k_arma_y[] = "arma_y"; +static const char __pyx_k_import[] = "__import__"; +static const char __pyx_k_x_pass[] = "x_pass"; +static const char __pyx_k_arma_xy[] = "arma_xy"; +static const char __pyx_k_ImportError[] = "ImportError"; +static const char __pyx_k_dmat_dot_dmat[] = "dmat_dot_dmat"; +static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; +static const char __pyx_k_dmat_np_to_arma_to_np[] = "dmat_np_to_arma_to_np"; +static const char __pyx_k_dvec_np_to_arma_to_np[] = "dvec_np_to_arma_to_np"; +static const char __pyx_k_l0learn_testing_utils[] = "l0learn.testing_utils"; +static const char __pyx_k_uvec_np_to_arma_to_np[] = "uvec_np_to_arma_to_np"; +static const char __pyx_k_sp_dmat_np_to_arma_to_np[] = "sp_dmat_np_to_arma_to_np"; +static const char __pyx_k_l0learn_testing_utils_pyx[] = "l0learn/testing_utils.pyx"; +static const char __pyx_k_list_csc_to_arma_csc_to_list[] = "list_csc_to_arma_csc_to_list"; +static const char __pyx_k_list_dvec_to_arma_dvec_to_list[] = "list_dvec_to_arma_dvec_to_list"; +static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import"; +static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import"; +static PyObject *__pyx_n_s_ImportError; +static PyObject *__pyx_n_s_arma_x; +static PyObject *__pyx_n_s_arma_xy; +static PyObject *__pyx_n_s_arma_y; +static PyObject *__pyx_n_s_cline_in_traceback; +static PyObject *__pyx_n_s_dmat_dot_dmat; +static PyObject *__pyx_n_s_dmat_np_to_arma_to_np; +static PyObject *__pyx_n_s_dvec_np_to_arma_to_np; +static PyObject *__pyx_n_s_import; +static PyObject *__pyx_n_s_l0learn_testing_utils; +static PyObject *__pyx_kp_s_l0learn_testing_utils_pyx; +static PyObject *__pyx_n_s_list_csc_to_arma_csc_to_list; +static PyObject *__pyx_n_s_list_dvec_to_arma_dvec_to_list; +static PyObject *__pyx_n_s_main; +static PyObject *__pyx_n_s_name; +static PyObject *__pyx_n_s_np; +static PyObject *__pyx_n_s_np_xy; +static PyObject *__pyx_n_s_numpy; +static PyObject *__pyx_kp_u_numpy_core_multiarray_failed_to; +static PyObject *__pyx_kp_u_numpy_core_umath_failed_to_impor; +static PyObject *__pyx_n_s_sp_dmat_np_to_arma_to_np; +static PyObject *__pyx_n_s_test; +static PyObject *__pyx_n_s_uvec_np_to_arma_to_np; +static PyObject *__pyx_n_s_x; +static PyObject *__pyx_n_s_x_pass; +static PyObject *__pyx_n_s_y; +static PyObject *__pyx_pf_7l0learn_13testing_utils_list_csc_to_arma_csc_to_list(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x); /* proto */ +static PyObject *__pyx_pf_7l0learn_13testing_utils_2list_dvec_to_arma_dvec_to_list(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x); /* proto */ +static PyObject *__pyx_pf_7l0learn_13testing_utils_4dmat_np_to_arma_to_np(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x); /* proto */ +static PyObject *__pyx_pf_7l0learn_13testing_utils_6uvec_np_to_arma_to_np(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x); /* proto */ +static PyObject *__pyx_pf_7l0learn_13testing_utils_8dvec_np_to_arma_to_np(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x); /* proto */ +static PyObject *__pyx_pf_7l0learn_13testing_utils_10sp_dmat_np_to_arma_to_np(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x); /* proto */ +static PyObject *__pyx_pf_7l0learn_13testing_utils_12dmat_dot_dmat(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x, PyObject *__pyx_v_y); /* proto */ +static PyObject *__pyx_tuple_; +static PyObject *__pyx_tuple__2; +static PyObject *__pyx_tuple__3; +static PyObject *__pyx_tuple__5; +static PyObject *__pyx_tuple__7; +static PyObject *__pyx_tuple__9; +static PyObject *__pyx_tuple__11; +static PyObject *__pyx_tuple__13; +static PyObject *__pyx_tuple__15; +static PyObject *__pyx_codeobj__4; +static PyObject *__pyx_codeobj__6; +static PyObject *__pyx_codeobj__8; +static PyObject *__pyx_codeobj__10; +static PyObject *__pyx_codeobj__12; +static PyObject *__pyx_codeobj__14; +static PyObject *__pyx_codeobj__16; +/* Late includes */ + +/* "l0learn/testing_utils.pyx":10 + * sp_dmat_to_numpy) + * + * def list_csc_to_arma_csc_to_list(x): # <<<<<<<<<<<<<< + * return c_list_csc_to_arma_csc_to_list(x) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7l0learn_13testing_utils_1list_csc_to_arma_csc_to_list(PyObject *__pyx_self, PyObject *__pyx_v_x); /*proto*/ +static char __pyx_doc_7l0learn_13testing_utils_list_csc_to_arma_csc_to_list[] = "list_csc_to_arma_csc_to_list(x)"; +static PyMethodDef __pyx_mdef_7l0learn_13testing_utils_1list_csc_to_arma_csc_to_list = {"list_csc_to_arma_csc_to_list", (PyCFunction)__pyx_pw_7l0learn_13testing_utils_1list_csc_to_arma_csc_to_list, METH_O, __pyx_doc_7l0learn_13testing_utils_list_csc_to_arma_csc_to_list}; +static PyObject *__pyx_pw_7l0learn_13testing_utils_1list_csc_to_arma_csc_to_list(PyObject *__pyx_self, PyObject *__pyx_v_x) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("list_csc_to_arma_csc_to_list (wrapper)", 0); + __pyx_r = __pyx_pf_7l0learn_13testing_utils_list_csc_to_arma_csc_to_list(__pyx_self, ((PyObject *)__pyx_v_x)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7l0learn_13testing_utils_list_csc_to_arma_csc_to_list(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("list_csc_to_arma_csc_to_list", 0); + + /* "l0learn/testing_utils.pyx":11 + * + * def list_csc_to_arma_csc_to_list(x): + * return c_list_csc_to_arma_csc_to_list(x) # <<<<<<<<<<<<<< + * + * cdef list c_list_csc_to_arma_csc_to_list(list x): + */ + __Pyx_XDECREF(__pyx_r); + if (!(likely(PyList_CheckExact(__pyx_v_x))||((__pyx_v_x) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_x)->tp_name), 0))) __PYX_ERR(0, 11, __pyx_L1_error) + __pyx_t_1 = __pyx_f_7l0learn_13testing_utils_c_list_csc_to_arma_csc_to_list(((PyObject*)__pyx_v_x)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 11, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "l0learn/testing_utils.pyx":10 + * sp_dmat_to_numpy) + * + * def list_csc_to_arma_csc_to_list(x): # <<<<<<<<<<<<<< + * return c_list_csc_to_arma_csc_to_list(x) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("l0learn.testing_utils.list_csc_to_arma_csc_to_list", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/testing_utils.pyx":13 + * return c_list_csc_to_arma_csc_to_list(x) + * + * cdef list c_list_csc_to_arma_csc_to_list(list x): # <<<<<<<<<<<<<< + * cdef field[sp_dmat] f = list_to_sp_dmat_field(x) + * cdef lst = sp_dmat_field_to_list(f) + */ + +static PyObject *__pyx_f_7l0learn_13testing_utils_c_list_csc_to_arma_csc_to_list(PyObject *__pyx_v_x) { + arma::field __pyx_v_f; + PyObject *__pyx_v_lst = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("c_list_csc_to_arma_csc_to_list", 0); + + /* "l0learn/testing_utils.pyx":14 + * + * cdef list c_list_csc_to_arma_csc_to_list(list x): + * cdef field[sp_dmat] f = list_to_sp_dmat_field(x) # <<<<<<<<<<<<<< + * cdef lst = sp_dmat_field_to_list(f) + * return lst + */ + __pyx_v_f = __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_field(__pyx_v_x); + + /* "l0learn/testing_utils.pyx":15 + * cdef list c_list_csc_to_arma_csc_to_list(list x): + * cdef field[sp_dmat] f = list_to_sp_dmat_field(x) + * cdef lst = sp_dmat_field_to_list(f) # <<<<<<<<<<<<<< + * return lst + * + */ + __pyx_t_1 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_f); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_lst = __pyx_t_1; + __pyx_t_1 = 0; + + /* "l0learn/testing_utils.pyx":16 + * cdef field[sp_dmat] f = list_to_sp_dmat_field(x) + * cdef lst = sp_dmat_field_to_list(f) + * return lst # <<<<<<<<<<<<<< + * + * def list_dvec_to_arma_dvec_to_list(x): + */ + __Pyx_XDECREF(__pyx_r); + if (!(likely(PyList_CheckExact(__pyx_v_lst))||((__pyx_v_lst) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_lst)->tp_name), 0))) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_INCREF(__pyx_v_lst); + __pyx_r = ((PyObject*)__pyx_v_lst); + goto __pyx_L0; + + /* "l0learn/testing_utils.pyx":13 + * return c_list_csc_to_arma_csc_to_list(x) + * + * cdef list c_list_csc_to_arma_csc_to_list(list x): # <<<<<<<<<<<<<< + * cdef field[sp_dmat] f = list_to_sp_dmat_field(x) + * cdef lst = sp_dmat_field_to_list(f) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("l0learn.testing_utils.c_list_csc_to_arma_csc_to_list", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_lst); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/testing_utils.pyx":18 + * return lst + * + * def list_dvec_to_arma_dvec_to_list(x): # <<<<<<<<<<<<<< + * return c_list_dvec_to_arma_dvec_to_list(x) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7l0learn_13testing_utils_3list_dvec_to_arma_dvec_to_list(PyObject *__pyx_self, PyObject *__pyx_v_x); /*proto*/ +static char __pyx_doc_7l0learn_13testing_utils_2list_dvec_to_arma_dvec_to_list[] = "list_dvec_to_arma_dvec_to_list(x)"; +static PyMethodDef __pyx_mdef_7l0learn_13testing_utils_3list_dvec_to_arma_dvec_to_list = {"list_dvec_to_arma_dvec_to_list", (PyCFunction)__pyx_pw_7l0learn_13testing_utils_3list_dvec_to_arma_dvec_to_list, METH_O, __pyx_doc_7l0learn_13testing_utils_2list_dvec_to_arma_dvec_to_list}; +static PyObject *__pyx_pw_7l0learn_13testing_utils_3list_dvec_to_arma_dvec_to_list(PyObject *__pyx_self, PyObject *__pyx_v_x) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("list_dvec_to_arma_dvec_to_list (wrapper)", 0); + __pyx_r = __pyx_pf_7l0learn_13testing_utils_2list_dvec_to_arma_dvec_to_list(__pyx_self, ((PyObject *)__pyx_v_x)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7l0learn_13testing_utils_2list_dvec_to_arma_dvec_to_list(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("list_dvec_to_arma_dvec_to_list", 0); + + /* "l0learn/testing_utils.pyx":19 + * + * def list_dvec_to_arma_dvec_to_list(x): + * return c_list_dvec_to_arma_dvec_to_list(x) # <<<<<<<<<<<<<< + * + * cdef list c_list_dvec_to_arma_dvec_to_list(list x): + */ + __Pyx_XDECREF(__pyx_r); + if (!(likely(PyList_CheckExact(__pyx_v_x))||((__pyx_v_x) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_x)->tp_name), 0))) __PYX_ERR(0, 19, __pyx_L1_error) + __pyx_t_1 = __pyx_f_7l0learn_13testing_utils_c_list_dvec_to_arma_dvec_to_list(((PyObject*)__pyx_v_x)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "l0learn/testing_utils.pyx":18 + * return lst + * + * def list_dvec_to_arma_dvec_to_list(x): # <<<<<<<<<<<<<< + * return c_list_dvec_to_arma_dvec_to_list(x) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("l0learn.testing_utils.list_dvec_to_arma_dvec_to_list", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/testing_utils.pyx":21 + * return c_list_dvec_to_arma_dvec_to_list(x) + * + * cdef list c_list_dvec_to_arma_dvec_to_list(list x): # <<<<<<<<<<<<<< + * cdef field[dvec] f = list_to_dvec_field(x) + * cdef lst = dvec_field_to_list(f) + */ + +static PyObject *__pyx_f_7l0learn_13testing_utils_c_list_dvec_to_arma_dvec_to_list(PyObject *__pyx_v_x) { + arma::field __pyx_v_f; + PyObject *__pyx_v_lst = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("c_list_dvec_to_arma_dvec_to_list", 0); + + /* "l0learn/testing_utils.pyx":22 + * + * cdef list c_list_dvec_to_arma_dvec_to_list(list x): + * cdef field[dvec] f = list_to_dvec_field(x) # <<<<<<<<<<<<<< + * cdef lst = dvec_field_to_list(f) + * return lst + */ + __pyx_v_f = __pyx_f_7l0learn_6cyarma_list_to_dvec_field(__pyx_v_x); + + /* "l0learn/testing_utils.pyx":23 + * cdef list c_list_dvec_to_arma_dvec_to_list(list x): + * cdef field[dvec] f = list_to_dvec_field(x) + * cdef lst = dvec_field_to_list(f) # <<<<<<<<<<<<<< + * return lst + * + */ + __pyx_t_1 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_f); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_lst = __pyx_t_1; + __pyx_t_1 = 0; + + /* "l0learn/testing_utils.pyx":24 + * cdef field[dvec] f = list_to_dvec_field(x) + * cdef lst = dvec_field_to_list(f) + * return lst # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + if (!(likely(PyList_CheckExact(__pyx_v_lst))||((__pyx_v_lst) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_lst)->tp_name), 0))) __PYX_ERR(0, 24, __pyx_L1_error) + __Pyx_INCREF(__pyx_v_lst); + __pyx_r = ((PyObject*)__pyx_v_lst); + goto __pyx_L0; + + /* "l0learn/testing_utils.pyx":21 + * return c_list_dvec_to_arma_dvec_to_list(x) + * + * cdef list c_list_dvec_to_arma_dvec_to_list(list x): # <<<<<<<<<<<<<< + * cdef field[dvec] f = list_to_dvec_field(x) + * cdef lst = dvec_field_to_list(f) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("l0learn.testing_utils.c_list_dvec_to_arma_dvec_to_list", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_lst); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/testing_utils.pyx":27 + * + * + * def dmat_np_to_arma_to_np(x): # <<<<<<<<<<<<<< + * cdef np.ndarray[np.double_t, ndim=2] x_pass + * x_pass = c_dmat_np_to_arma_to_np(x) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7l0learn_13testing_utils_5dmat_np_to_arma_to_np(PyObject *__pyx_self, PyObject *__pyx_v_x); /*proto*/ +static char __pyx_doc_7l0learn_13testing_utils_4dmat_np_to_arma_to_np[] = "dmat_np_to_arma_to_np(x)"; +static PyMethodDef __pyx_mdef_7l0learn_13testing_utils_5dmat_np_to_arma_to_np = {"dmat_np_to_arma_to_np", (PyCFunction)__pyx_pw_7l0learn_13testing_utils_5dmat_np_to_arma_to_np, METH_O, __pyx_doc_7l0learn_13testing_utils_4dmat_np_to_arma_to_np}; +static PyObject *__pyx_pw_7l0learn_13testing_utils_5dmat_np_to_arma_to_np(PyObject *__pyx_self, PyObject *__pyx_v_x) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("dmat_np_to_arma_to_np (wrapper)", 0); + __pyx_r = __pyx_pf_7l0learn_13testing_utils_4dmat_np_to_arma_to_np(__pyx_self, ((PyObject *)__pyx_v_x)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7l0learn_13testing_utils_4dmat_np_to_arma_to_np(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x) { + PyArrayObject *__pyx_v_x_pass = 0; + __Pyx_LocalBuf_ND __pyx_pybuffernd_x_pass; + __Pyx_Buffer __pyx_pybuffer_x_pass; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("dmat_np_to_arma_to_np", 0); + __pyx_pybuffer_x_pass.pybuffer.buf = NULL; + __pyx_pybuffer_x_pass.refcount = 0; + __pyx_pybuffernd_x_pass.data = NULL; + __pyx_pybuffernd_x_pass.rcbuffer = &__pyx_pybuffer_x_pass; + + /* "l0learn/testing_utils.pyx":29 + * def dmat_np_to_arma_to_np(x): + * cdef np.ndarray[np.double_t, ndim=2] x_pass + * x_pass = c_dmat_np_to_arma_to_np(x) # <<<<<<<<<<<<<< + * + * return x_pass + */ + if (!(likely(((__pyx_v_x) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_x, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 29, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_7l0learn_13testing_utils_c_dmat_np_to_arma_to_np(((PyArrayObject *)__pyx_v_x))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x_pass.rcbuffer->pybuffer); + __pyx_t_2 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x_pass.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_1), &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack); + if (unlikely(__pyx_t_2 < 0)) { + PyErr_Fetch(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5); + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x_pass.rcbuffer->pybuffer, (PyObject*)__pyx_v_x_pass, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) { + Py_XDECREF(__pyx_t_3); Py_XDECREF(__pyx_t_4); Py_XDECREF(__pyx_t_5); + __Pyx_RaiseBufferFallbackError(); + } else { + PyErr_Restore(__pyx_t_3, __pyx_t_4, __pyx_t_5); + } + __pyx_t_3 = __pyx_t_4 = __pyx_t_5 = 0; + } + __pyx_pybuffernd_x_pass.diminfo[0].strides = __pyx_pybuffernd_x_pass.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x_pass.diminfo[0].shape = __pyx_pybuffernd_x_pass.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_x_pass.diminfo[1].strides = __pyx_pybuffernd_x_pass.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_x_pass.diminfo[1].shape = __pyx_pybuffernd_x_pass.rcbuffer->pybuffer.shape[1]; + if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 29, __pyx_L1_error) + } + __pyx_v_x_pass = ((PyArrayObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "l0learn/testing_utils.pyx":31 + * x_pass = c_dmat_np_to_arma_to_np(x) + * + * return x_pass # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_x_pass)); + __pyx_r = ((PyObject *)__pyx_v_x_pass); + goto __pyx_L0; + + /* "l0learn/testing_utils.pyx":27 + * + * + * def dmat_np_to_arma_to_np(x): # <<<<<<<<<<<<<< + * cdef np.ndarray[np.double_t, ndim=2] x_pass + * x_pass = c_dmat_np_to_arma_to_np(x) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x_pass.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("l0learn.testing_utils.dmat_np_to_arma_to_np", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x_pass.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_x_pass); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/testing_utils.pyx":34 + * + * + * cdef np.ndarray[np.double_t, ndim=2] c_dmat_np_to_arma_to_np(np.ndarray[np.double_t, ndim=2] x): # <<<<<<<<<<<<<< + * cdef dmat arma_x = numpy_to_dmat_d(x) + * + */ + +static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_dmat_np_to_arma_to_np(PyArrayObject *__pyx_v_x) { + arma::dmat __pyx_v_arma_x; + PyArrayObject *__pyx_v_np_x = 0; + __Pyx_LocalBuf_ND __pyx_pybuffernd_np_x; + __Pyx_Buffer __pyx_pybuffer_np_x; + __Pyx_LocalBuf_ND __pyx_pybuffernd_x; + __Pyx_Buffer __pyx_pybuffer_x; + PyArrayObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("c_dmat_np_to_arma_to_np", 0); + __pyx_pybuffer_np_x.pybuffer.buf = NULL; + __pyx_pybuffer_np_x.refcount = 0; + __pyx_pybuffernd_np_x.data = NULL; + __pyx_pybuffernd_np_x.rcbuffer = &__pyx_pybuffer_np_x; + __pyx_pybuffer_x.pybuffer.buf = NULL; + __pyx_pybuffer_x.refcount = 0; + __pyx_pybuffernd_x.data = NULL; + __pyx_pybuffernd_x.rcbuffer = &__pyx_pybuffer_x; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_v_x, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 34, __pyx_L1_error) + } + __pyx_pybuffernd_x.diminfo[0].strides = __pyx_pybuffernd_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x.diminfo[0].shape = __pyx_pybuffernd_x.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_x.diminfo[1].strides = __pyx_pybuffernd_x.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_x.diminfo[1].shape = __pyx_pybuffernd_x.rcbuffer->pybuffer.shape[1]; + + /* "l0learn/testing_utils.pyx":35 + * + * cdef np.ndarray[np.double_t, ndim=2] c_dmat_np_to_arma_to_np(np.ndarray[np.double_t, ndim=2] x): + * cdef dmat arma_x = numpy_to_dmat_d(x) # <<<<<<<<<<<<<< + * + * cdef np.ndarray[np.double_t, ndim=2] np_x = dmat_to_numpy(arma_x, None) + */ + __pyx_v_arma_x = __pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_x)); + + /* "l0learn/testing_utils.pyx":37 + * cdef dmat arma_x = numpy_to_dmat_d(x) + * + * cdef np.ndarray[np.double_t, ndim=2] np_x = dmat_to_numpy(arma_x, None) # <<<<<<<<<<<<<< + * + * return np_x + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7l0learn_6cyarma_dmat_to_numpy(__pyx_v_arma_x, ((PyArrayObject *)Py_None))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_np_x.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_1), &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) { + __pyx_v_np_x = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_np_x.rcbuffer->pybuffer.buf = NULL; + __PYX_ERR(0, 37, __pyx_L1_error) + } else {__pyx_pybuffernd_np_x.diminfo[0].strides = __pyx_pybuffernd_np_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_np_x.diminfo[0].shape = __pyx_pybuffernd_np_x.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_np_x.diminfo[1].strides = __pyx_pybuffernd_np_x.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_np_x.diminfo[1].shape = __pyx_pybuffernd_np_x.rcbuffer->pybuffer.shape[1]; + } + } + __pyx_v_np_x = ((PyArrayObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "l0learn/testing_utils.pyx":39 + * cdef np.ndarray[np.double_t, ndim=2] np_x = dmat_to_numpy(arma_x, None) + * + * return np_x # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_np_x)); + __pyx_r = ((PyArrayObject *)__pyx_v_np_x); + goto __pyx_L0; + + /* "l0learn/testing_utils.pyx":34 + * + * + * cdef np.ndarray[np.double_t, ndim=2] c_dmat_np_to_arma_to_np(np.ndarray[np.double_t, ndim=2] x): # <<<<<<<<<<<<<< + * cdef dmat arma_x = numpy_to_dmat_d(x) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_np_x.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("l0learn.testing_utils.c_dmat_np_to_arma_to_np", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_np_x.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_np_x); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/testing_utils.pyx":42 + * + * + * def uvec_np_to_arma_to_np(x): # <<<<<<<<<<<<<< + * cdef np.ndarray[np.uint64_t, ndim=1] x_pass + * x_pass = c_uvec_np_to_arma_to_np(x) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7l0learn_13testing_utils_7uvec_np_to_arma_to_np(PyObject *__pyx_self, PyObject *__pyx_v_x); /*proto*/ +static char __pyx_doc_7l0learn_13testing_utils_6uvec_np_to_arma_to_np[] = "uvec_np_to_arma_to_np(x)"; +static PyMethodDef __pyx_mdef_7l0learn_13testing_utils_7uvec_np_to_arma_to_np = {"uvec_np_to_arma_to_np", (PyCFunction)__pyx_pw_7l0learn_13testing_utils_7uvec_np_to_arma_to_np, METH_O, __pyx_doc_7l0learn_13testing_utils_6uvec_np_to_arma_to_np}; +static PyObject *__pyx_pw_7l0learn_13testing_utils_7uvec_np_to_arma_to_np(PyObject *__pyx_self, PyObject *__pyx_v_x) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("uvec_np_to_arma_to_np (wrapper)", 0); + __pyx_r = __pyx_pf_7l0learn_13testing_utils_6uvec_np_to_arma_to_np(__pyx_self, ((PyObject *)__pyx_v_x)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7l0learn_13testing_utils_6uvec_np_to_arma_to_np(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x) { + PyArrayObject *__pyx_v_x_pass = 0; + __Pyx_LocalBuf_ND __pyx_pybuffernd_x_pass; + __Pyx_Buffer __pyx_pybuffer_x_pass; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("uvec_np_to_arma_to_np", 0); + __pyx_pybuffer_x_pass.pybuffer.buf = NULL; + __pyx_pybuffer_x_pass.refcount = 0; + __pyx_pybuffernd_x_pass.data = NULL; + __pyx_pybuffernd_x_pass.rcbuffer = &__pyx_pybuffer_x_pass; + + /* "l0learn/testing_utils.pyx":44 + * def uvec_np_to_arma_to_np(x): + * cdef np.ndarray[np.uint64_t, ndim=1] x_pass + * x_pass = c_uvec_np_to_arma_to_np(x) # <<<<<<<<<<<<<< + * + * return x_pass + */ + if (!(likely(((__pyx_v_x) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_x, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 44, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_7l0learn_13testing_utils_c_uvec_np_to_arma_to_np(((PyArrayObject *)__pyx_v_x))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 44, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x_pass.rcbuffer->pybuffer); + __pyx_t_2 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x_pass.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_1), &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack); + if (unlikely(__pyx_t_2 < 0)) { + PyErr_Fetch(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5); + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x_pass.rcbuffer->pybuffer, (PyObject*)__pyx_v_x_pass, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + Py_XDECREF(__pyx_t_3); Py_XDECREF(__pyx_t_4); Py_XDECREF(__pyx_t_5); + __Pyx_RaiseBufferFallbackError(); + } else { + PyErr_Restore(__pyx_t_3, __pyx_t_4, __pyx_t_5); + } + __pyx_t_3 = __pyx_t_4 = __pyx_t_5 = 0; + } + __pyx_pybuffernd_x_pass.diminfo[0].strides = __pyx_pybuffernd_x_pass.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x_pass.diminfo[0].shape = __pyx_pybuffernd_x_pass.rcbuffer->pybuffer.shape[0]; + if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 44, __pyx_L1_error) + } + __pyx_v_x_pass = ((PyArrayObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "l0learn/testing_utils.pyx":46 + * x_pass = c_uvec_np_to_arma_to_np(x) + * + * return x_pass # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_x_pass)); + __pyx_r = ((PyObject *)__pyx_v_x_pass); + goto __pyx_L0; + + /* "l0learn/testing_utils.pyx":42 + * + * + * def uvec_np_to_arma_to_np(x): # <<<<<<<<<<<<<< + * cdef np.ndarray[np.uint64_t, ndim=1] x_pass + * x_pass = c_uvec_np_to_arma_to_np(x) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x_pass.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("l0learn.testing_utils.uvec_np_to_arma_to_np", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x_pass.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_x_pass); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/testing_utils.pyx":49 + * + * + * cdef np.ndarray[np.uint64_t, ndim=1] c_uvec_np_to_arma_to_np(np.ndarray[np.uint64_t, ndim=1] x): # <<<<<<<<<<<<<< + * cdef uvec arma_x = numpy_to_uvec_d(x) + * + */ + +static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_uvec_np_to_arma_to_np(PyArrayObject *__pyx_v_x) { + arma::uvec __pyx_v_arma_x; + PyArrayObject *__pyx_v_np_x = 0; + __Pyx_LocalBuf_ND __pyx_pybuffernd_np_x; + __Pyx_Buffer __pyx_pybuffer_np_x; + __Pyx_LocalBuf_ND __pyx_pybuffernd_x; + __Pyx_Buffer __pyx_pybuffer_x; + PyArrayObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("c_uvec_np_to_arma_to_np", 0); + __pyx_pybuffer_np_x.pybuffer.buf = NULL; + __pyx_pybuffer_np_x.refcount = 0; + __pyx_pybuffernd_np_x.data = NULL; + __pyx_pybuffernd_np_x.rcbuffer = &__pyx_pybuffer_np_x; + __pyx_pybuffer_x.pybuffer.buf = NULL; + __pyx_pybuffer_x.refcount = 0; + __pyx_pybuffernd_x.data = NULL; + __pyx_pybuffernd_x.rcbuffer = &__pyx_pybuffer_x; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_v_x, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 49, __pyx_L1_error) + } + __pyx_pybuffernd_x.diminfo[0].strides = __pyx_pybuffernd_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x.diminfo[0].shape = __pyx_pybuffernd_x.rcbuffer->pybuffer.shape[0]; + + /* "l0learn/testing_utils.pyx":50 + * + * cdef np.ndarray[np.uint64_t, ndim=1] c_uvec_np_to_arma_to_np(np.ndarray[np.uint64_t, ndim=1] x): + * cdef uvec arma_x = numpy_to_uvec_d(x) # <<<<<<<<<<<<<< + * + * cdef np.ndarray[np.uint64_t, ndim=1] np_x = uvec_to_numpy(arma_x, None) + */ + __pyx_v_arma_x = __pyx_f_7l0learn_6cyarma_numpy_to_uvec_d(((PyArrayObject *)__pyx_v_x)); + + /* "l0learn/testing_utils.pyx":52 + * cdef uvec arma_x = numpy_to_uvec_d(x) + * + * cdef np.ndarray[np.uint64_t, ndim=1] np_x = uvec_to_numpy(arma_x, None) # <<<<<<<<<<<<<< + * + * return np_x + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7l0learn_6cyarma_uvec_to_numpy(__pyx_v_arma_x, ((PyArrayObject *)Py_None))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_np_x.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_1), &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + __pyx_v_np_x = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_np_x.rcbuffer->pybuffer.buf = NULL; + __PYX_ERR(0, 52, __pyx_L1_error) + } else {__pyx_pybuffernd_np_x.diminfo[0].strides = __pyx_pybuffernd_np_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_np_x.diminfo[0].shape = __pyx_pybuffernd_np_x.rcbuffer->pybuffer.shape[0]; + } + } + __pyx_v_np_x = ((PyArrayObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "l0learn/testing_utils.pyx":54 + * cdef np.ndarray[np.uint64_t, ndim=1] np_x = uvec_to_numpy(arma_x, None) + * + * return np_x # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_np_x)); + __pyx_r = ((PyArrayObject *)__pyx_v_np_x); + goto __pyx_L0; + + /* "l0learn/testing_utils.pyx":49 + * + * + * cdef np.ndarray[np.uint64_t, ndim=1] c_uvec_np_to_arma_to_np(np.ndarray[np.uint64_t, ndim=1] x): # <<<<<<<<<<<<<< + * cdef uvec arma_x = numpy_to_uvec_d(x) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_np_x.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("l0learn.testing_utils.c_uvec_np_to_arma_to_np", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_np_x.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_np_x); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/testing_utils.pyx":57 + * + * + * def dvec_np_to_arma_to_np(x): # <<<<<<<<<<<<<< + * cdef np.ndarray[np.double_t, ndim=1] x_pass + * x_pass = c_dvec_np_to_arma_to_np(x) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7l0learn_13testing_utils_9dvec_np_to_arma_to_np(PyObject *__pyx_self, PyObject *__pyx_v_x); /*proto*/ +static char __pyx_doc_7l0learn_13testing_utils_8dvec_np_to_arma_to_np[] = "dvec_np_to_arma_to_np(x)"; +static PyMethodDef __pyx_mdef_7l0learn_13testing_utils_9dvec_np_to_arma_to_np = {"dvec_np_to_arma_to_np", (PyCFunction)__pyx_pw_7l0learn_13testing_utils_9dvec_np_to_arma_to_np, METH_O, __pyx_doc_7l0learn_13testing_utils_8dvec_np_to_arma_to_np}; +static PyObject *__pyx_pw_7l0learn_13testing_utils_9dvec_np_to_arma_to_np(PyObject *__pyx_self, PyObject *__pyx_v_x) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("dvec_np_to_arma_to_np (wrapper)", 0); + __pyx_r = __pyx_pf_7l0learn_13testing_utils_8dvec_np_to_arma_to_np(__pyx_self, ((PyObject *)__pyx_v_x)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7l0learn_13testing_utils_8dvec_np_to_arma_to_np(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x) { + PyArrayObject *__pyx_v_x_pass = 0; + __Pyx_LocalBuf_ND __pyx_pybuffernd_x_pass; + __Pyx_Buffer __pyx_pybuffer_x_pass; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("dvec_np_to_arma_to_np", 0); + __pyx_pybuffer_x_pass.pybuffer.buf = NULL; + __pyx_pybuffer_x_pass.refcount = 0; + __pyx_pybuffernd_x_pass.data = NULL; + __pyx_pybuffernd_x_pass.rcbuffer = &__pyx_pybuffer_x_pass; + + /* "l0learn/testing_utils.pyx":59 + * def dvec_np_to_arma_to_np(x): + * cdef np.ndarray[np.double_t, ndim=1] x_pass + * x_pass = c_dvec_np_to_arma_to_np(x) # <<<<<<<<<<<<<< + * + * return x_pass + */ + if (!(likely(((__pyx_v_x) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_x, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 59, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_7l0learn_13testing_utils_c_dvec_np_to_arma_to_np(((PyArrayObject *)__pyx_v_x))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 59, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x_pass.rcbuffer->pybuffer); + __pyx_t_2 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x_pass.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_1), &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack); + if (unlikely(__pyx_t_2 < 0)) { + PyErr_Fetch(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5); + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x_pass.rcbuffer->pybuffer, (PyObject*)__pyx_v_x_pass, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + Py_XDECREF(__pyx_t_3); Py_XDECREF(__pyx_t_4); Py_XDECREF(__pyx_t_5); + __Pyx_RaiseBufferFallbackError(); + } else { + PyErr_Restore(__pyx_t_3, __pyx_t_4, __pyx_t_5); + } + __pyx_t_3 = __pyx_t_4 = __pyx_t_5 = 0; + } + __pyx_pybuffernd_x_pass.diminfo[0].strides = __pyx_pybuffernd_x_pass.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x_pass.diminfo[0].shape = __pyx_pybuffernd_x_pass.rcbuffer->pybuffer.shape[0]; + if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 59, __pyx_L1_error) + } + __pyx_v_x_pass = ((PyArrayObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "l0learn/testing_utils.pyx":61 + * x_pass = c_dvec_np_to_arma_to_np(x) + * + * return x_pass # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_x_pass)); + __pyx_r = ((PyObject *)__pyx_v_x_pass); + goto __pyx_L0; + + /* "l0learn/testing_utils.pyx":57 + * + * + * def dvec_np_to_arma_to_np(x): # <<<<<<<<<<<<<< + * cdef np.ndarray[np.double_t, ndim=1] x_pass + * x_pass = c_dvec_np_to_arma_to_np(x) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x_pass.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("l0learn.testing_utils.dvec_np_to_arma_to_np", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x_pass.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_x_pass); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/testing_utils.pyx":64 + * + * + * cdef np.ndarray[np.uint64_t, ndim=1] c_dvec_np_to_arma_to_np(np.ndarray[np.double_t, ndim=1] x): # <<<<<<<<<<<<<< + * cdef dvec arma_x = numpy_to_dvec_d(x) + * + */ + +static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_dvec_np_to_arma_to_np(PyArrayObject *__pyx_v_x) { + arma::dvec __pyx_v_arma_x; + PyArrayObject *__pyx_v_np_x = 0; + __Pyx_LocalBuf_ND __pyx_pybuffernd_np_x; + __Pyx_Buffer __pyx_pybuffer_np_x; + __Pyx_LocalBuf_ND __pyx_pybuffernd_x; + __Pyx_Buffer __pyx_pybuffer_x; + PyArrayObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("c_dvec_np_to_arma_to_np", 0); + __pyx_pybuffer_np_x.pybuffer.buf = NULL; + __pyx_pybuffer_np_x.refcount = 0; + __pyx_pybuffernd_np_x.data = NULL; + __pyx_pybuffernd_np_x.rcbuffer = &__pyx_pybuffer_np_x; + __pyx_pybuffer_x.pybuffer.buf = NULL; + __pyx_pybuffer_x.refcount = 0; + __pyx_pybuffernd_x.data = NULL; + __pyx_pybuffernd_x.rcbuffer = &__pyx_pybuffer_x; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_v_x, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 64, __pyx_L1_error) + } + __pyx_pybuffernd_x.diminfo[0].strides = __pyx_pybuffernd_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x.diminfo[0].shape = __pyx_pybuffernd_x.rcbuffer->pybuffer.shape[0]; + + /* "l0learn/testing_utils.pyx":65 + * + * cdef np.ndarray[np.uint64_t, ndim=1] c_dvec_np_to_arma_to_np(np.ndarray[np.double_t, ndim=1] x): + * cdef dvec arma_x = numpy_to_dvec_d(x) # <<<<<<<<<<<<<< + * + * cdef np.ndarray[np.double_t, ndim=1] np_x = dvec_to_numpy(arma_x, None) + */ + __pyx_v_arma_x = __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_x)); + + /* "l0learn/testing_utils.pyx":67 + * cdef dvec arma_x = numpy_to_dvec_d(x) + * + * cdef np.ndarray[np.double_t, ndim=1] np_x = dvec_to_numpy(arma_x, None) # <<<<<<<<<<<<<< + * + * return np_x + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7l0learn_6cyarma_dvec_to_numpy(__pyx_v_arma_x, ((PyArrayObject *)Py_None))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 67, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_np_x.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_1), &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + __pyx_v_np_x = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_np_x.rcbuffer->pybuffer.buf = NULL; + __PYX_ERR(0, 67, __pyx_L1_error) + } else {__pyx_pybuffernd_np_x.diminfo[0].strides = __pyx_pybuffernd_np_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_np_x.diminfo[0].shape = __pyx_pybuffernd_np_x.rcbuffer->pybuffer.shape[0]; + } + } + __pyx_v_np_x = ((PyArrayObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "l0learn/testing_utils.pyx":69 + * cdef np.ndarray[np.double_t, ndim=1] np_x = dvec_to_numpy(arma_x, None) + * + * return np_x # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_np_x)); + __pyx_r = ((PyArrayObject *)__pyx_v_np_x); + goto __pyx_L0; + + /* "l0learn/testing_utils.pyx":64 + * + * + * cdef np.ndarray[np.uint64_t, ndim=1] c_dvec_np_to_arma_to_np(np.ndarray[np.double_t, ndim=1] x): # <<<<<<<<<<<<<< + * cdef dvec arma_x = numpy_to_dvec_d(x) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_np_x.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("l0learn.testing_utils.c_dvec_np_to_arma_to_np", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_np_x.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_np_x); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/testing_utils.pyx":72 + * + * + * def sp_dmat_np_to_arma_to_np(x): # <<<<<<<<<<<<<< + * return c_sp_dmat_np_to_arma_to_np(x) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7l0learn_13testing_utils_11sp_dmat_np_to_arma_to_np(PyObject *__pyx_self, PyObject *__pyx_v_x); /*proto*/ +static char __pyx_doc_7l0learn_13testing_utils_10sp_dmat_np_to_arma_to_np[] = "sp_dmat_np_to_arma_to_np(x)"; +static PyMethodDef __pyx_mdef_7l0learn_13testing_utils_11sp_dmat_np_to_arma_to_np = {"sp_dmat_np_to_arma_to_np", (PyCFunction)__pyx_pw_7l0learn_13testing_utils_11sp_dmat_np_to_arma_to_np, METH_O, __pyx_doc_7l0learn_13testing_utils_10sp_dmat_np_to_arma_to_np}; +static PyObject *__pyx_pw_7l0learn_13testing_utils_11sp_dmat_np_to_arma_to_np(PyObject *__pyx_self, PyObject *__pyx_v_x) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("sp_dmat_np_to_arma_to_np (wrapper)", 0); + __pyx_r = __pyx_pf_7l0learn_13testing_utils_10sp_dmat_np_to_arma_to_np(__pyx_self, ((PyObject *)__pyx_v_x)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7l0learn_13testing_utils_10sp_dmat_np_to_arma_to_np(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("sp_dmat_np_to_arma_to_np", 0); + + /* "l0learn/testing_utils.pyx":73 + * + * def sp_dmat_np_to_arma_to_np(x): + * return c_sp_dmat_np_to_arma_to_np(x) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_7l0learn_13testing_utils_c_sp_dmat_np_to_arma_to_np(__pyx_v_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 73, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "l0learn/testing_utils.pyx":72 + * + * + * def sp_dmat_np_to_arma_to_np(x): # <<<<<<<<<<<<<< + * return c_sp_dmat_np_to_arma_to_np(x) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("l0learn.testing_utils.sp_dmat_np_to_arma_to_np", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/testing_utils.pyx":76 + * + * + * cdef c_sp_dmat_np_to_arma_to_np(x): # <<<<<<<<<<<<<< + * cdef sp_dmat arma_x = numpy_to_sp_dmat_d(x) + * + */ + +static PyObject *__pyx_f_7l0learn_13testing_utils_c_sp_dmat_np_to_arma_to_np(PyObject *__pyx_v_x) { + arma::sp_dmat __pyx_v_arma_x; + PyObject *__pyx_v_np_x = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("c_sp_dmat_np_to_arma_to_np", 0); + + /* "l0learn/testing_utils.pyx":77 + * + * cdef c_sp_dmat_np_to_arma_to_np(x): + * cdef sp_dmat arma_x = numpy_to_sp_dmat_d(x) # <<<<<<<<<<<<<< + * + * np_x = sp_dmat_to_numpy(arma_x, None, None, None) + */ + __pyx_v_arma_x = __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(__pyx_v_x); + + /* "l0learn/testing_utils.pyx":79 + * cdef sp_dmat arma_x = numpy_to_sp_dmat_d(x) + * + * np_x = sp_dmat_to_numpy(arma_x, None, None, None) # <<<<<<<<<<<<<< + * return np_x + * + */ + __pyx_t_1 = __pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(__pyx_v_arma_x, ((PyArrayObject *)Py_None), ((PyArrayObject *)Py_None), ((PyArrayObject *)Py_None)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_np_x = __pyx_t_1; + __pyx_t_1 = 0; + + /* "l0learn/testing_utils.pyx":80 + * + * np_x = sp_dmat_to_numpy(arma_x, None, None, None) + * return np_x # <<<<<<<<<<<<<< + * + * def dmat_dot_dmat(x, y): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_np_x); + __pyx_r = __pyx_v_np_x; + goto __pyx_L0; + + /* "l0learn/testing_utils.pyx":76 + * + * + * cdef c_sp_dmat_np_to_arma_to_np(x): # <<<<<<<<<<<<<< + * cdef sp_dmat arma_x = numpy_to_sp_dmat_d(x) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("l0learn.testing_utils.c_sp_dmat_np_to_arma_to_np", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_np_x); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/testing_utils.pyx":82 + * return np_x + * + * def dmat_dot_dmat(x, y): # <<<<<<<<<<<<<< + * cdef dmat arma_x = numpy_to_dmat_d(x) + * cdef dmat arma_y = numpy_to_dmat_d(y) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_7l0learn_13testing_utils_13dmat_dot_dmat(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_7l0learn_13testing_utils_12dmat_dot_dmat[] = "dmat_dot_dmat(x, y)"; +static PyMethodDef __pyx_mdef_7l0learn_13testing_utils_13dmat_dot_dmat = {"dmat_dot_dmat", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7l0learn_13testing_utils_13dmat_dot_dmat, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7l0learn_13testing_utils_12dmat_dot_dmat}; +static PyObject *__pyx_pw_7l0learn_13testing_utils_13dmat_dot_dmat(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_x = 0; + PyObject *__pyx_v_y = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("dmat_dot_dmat (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x,&__pyx_n_s_y,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_x)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("dmat_dot_dmat", 1, 2, 2, 1); __PYX_ERR(0, 82, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "dmat_dot_dmat") < 0)) __PYX_ERR(0, 82, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_x = values[0]; + __pyx_v_y = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("dmat_dot_dmat", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 82, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("l0learn.testing_utils.dmat_dot_dmat", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_7l0learn_13testing_utils_12dmat_dot_dmat(__pyx_self, __pyx_v_x, __pyx_v_y); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_7l0learn_13testing_utils_12dmat_dot_dmat(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x, PyObject *__pyx_v_y) { + arma::dmat __pyx_v_arma_x; + arma::dmat __pyx_v_arma_y; + arma::dmat __pyx_v_arma_xy; + PyArrayObject *__pyx_v_np_xy = 0; + __Pyx_LocalBuf_ND __pyx_pybuffernd_np_xy; + __Pyx_Buffer __pyx_pybuffer_np_xy; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("dmat_dot_dmat", 0); + __pyx_pybuffer_np_xy.pybuffer.buf = NULL; + __pyx_pybuffer_np_xy.refcount = 0; + __pyx_pybuffernd_np_xy.data = NULL; + __pyx_pybuffernd_np_xy.rcbuffer = &__pyx_pybuffer_np_xy; + + /* "l0learn/testing_utils.pyx":83 + * + * def dmat_dot_dmat(x, y): + * cdef dmat arma_x = numpy_to_dmat_d(x) # <<<<<<<<<<<<<< + * cdef dmat arma_y = numpy_to_dmat_d(y) + * + */ + if (!(likely(((__pyx_v_x) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_x, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 83, __pyx_L1_error) + __pyx_v_arma_x = __pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_x)); + + /* "l0learn/testing_utils.pyx":84 + * def dmat_dot_dmat(x, y): + * cdef dmat arma_x = numpy_to_dmat_d(x) + * cdef dmat arma_y = numpy_to_dmat_d(y) # <<<<<<<<<<<<<< + * + * cdef dmat arma_xy = c_dmat_dot_dmat(arma_x, arma_y) + */ + if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 84, __pyx_L1_error) + __pyx_v_arma_y = __pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_y)); + + /* "l0learn/testing_utils.pyx":86 + * cdef dmat arma_y = numpy_to_dmat_d(y) + * + * cdef dmat arma_xy = c_dmat_dot_dmat(arma_x, arma_y) # <<<<<<<<<<<<<< + * + * cdef np.ndarray[np.double_t, ndim=2] np_xy = dmat_to_numpy(arma_xy, None) + */ + __pyx_v_arma_xy = __pyx_f_7l0learn_13testing_utils_c_dmat_dot_dmat(__pyx_v_arma_x, __pyx_v_arma_y); + + /* "l0learn/testing_utils.pyx":88 + * cdef dmat arma_xy = c_dmat_dot_dmat(arma_x, arma_y) + * + * cdef np.ndarray[np.double_t, ndim=2] np_xy = dmat_to_numpy(arma_xy, None) # <<<<<<<<<<<<<< + * + * return np_xy + */ + __pyx_t_1 = ((PyObject *)__pyx_f_7l0learn_6cyarma_dmat_to_numpy(__pyx_v_arma_xy, ((PyArrayObject *)Py_None))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_np_xy.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_1), &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) { + __pyx_v_np_xy = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_np_xy.rcbuffer->pybuffer.buf = NULL; + __PYX_ERR(0, 88, __pyx_L1_error) + } else {__pyx_pybuffernd_np_xy.diminfo[0].strides = __pyx_pybuffernd_np_xy.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_np_xy.diminfo[0].shape = __pyx_pybuffernd_np_xy.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_np_xy.diminfo[1].strides = __pyx_pybuffernd_np_xy.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_np_xy.diminfo[1].shape = __pyx_pybuffernd_np_xy.rcbuffer->pybuffer.shape[1]; + } + } + __pyx_v_np_xy = ((PyArrayObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "l0learn/testing_utils.pyx":90 + * cdef np.ndarray[np.double_t, ndim=2] np_xy = dmat_to_numpy(arma_xy, None) + * + * return np_xy # <<<<<<<<<<<<<< + * + * cdef dmat c_dmat_dot_dmat(dmat arma_x, dmat arma_y): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_np_xy)); + __pyx_r = ((PyObject *)__pyx_v_np_xy); + goto __pyx_L0; + + /* "l0learn/testing_utils.pyx":82 + * return np_x + * + * def dmat_dot_dmat(x, y): # <<<<<<<<<<<<<< + * cdef dmat arma_x = numpy_to_dmat_d(x) + * cdef dmat arma_y = numpy_to_dmat_d(y) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_np_xy.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("l0learn.testing_utils.dmat_dot_dmat", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_np_xy.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_np_xy); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/testing_utils.pyx":92 + * return np_xy + * + * cdef dmat c_dmat_dot_dmat(dmat arma_x, dmat arma_y): # <<<<<<<<<<<<<< + * cdef dmat arma_xy = arma_x*arma_y + * + */ + +static arma::dmat __pyx_f_7l0learn_13testing_utils_c_dmat_dot_dmat(arma::dmat __pyx_v_arma_x, arma::dmat __pyx_v_arma_y) { + arma::dmat __pyx_v_arma_xy; + arma::dmat __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("c_dmat_dot_dmat", 0); + + /* "l0learn/testing_utils.pyx":93 + * + * cdef dmat c_dmat_dot_dmat(dmat arma_x, dmat arma_y): + * cdef dmat arma_xy = arma_x*arma_y # <<<<<<<<<<<<<< + * + * return arma_xy + */ + __pyx_v_arma_xy = (__pyx_v_arma_x * __pyx_v_arma_y); + + /* "l0learn/testing_utils.pyx":95 + * cdef dmat arma_xy = arma_x*arma_y + * + * return arma_xy # <<<<<<<<<<<<<< + */ + __pyx_r = __pyx_v_arma_xy; + goto __pyx_L0; + + /* "l0learn/testing_utils.pyx":92 + * return np_xy + * + * cdef dmat c_dmat_dot_dmat(dmat arma_x, dmat arma_y): # <<<<<<<<<<<<<< + * cdef dmat arma_xy = arma_x*arma_y + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":734 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":735 + * + * cdef inline object PyArray_MultiIterNew1(a): + * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew2(a, b): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 735, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":734 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":737 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":738 + * + * cdef inline object PyArray_MultiIterNew2(a, b): + * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 738, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":737 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":740 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":741 + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 741, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":740 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":743 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":744 + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 744, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":743 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":746 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":747 + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< + * + * cdef inline tuple PyDataType_SHAPE(dtype d): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 747, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":746 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":749 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":750 + * + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< + * return d.subarray.shape + * else: + */ + __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); + if (__pyx_t_1) { + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":751 + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape # <<<<<<<<<<<<<< + * else: + * return () + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); + __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":750 + * + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< + * return d.subarray.shape + * else: + */ + } + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":753 + * return d.subarray.shape + * else: + * return () # <<<<<<<<<<<<<< + * + * + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_empty_tuple); + __pyx_r = __pyx_empty_tuple; + goto __pyx_L0; + } + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":749 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":868 + * int _import_umath() except -1 + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) + */ + +static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_array_base", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":869 + * + * cdef inline void set_array_base(ndarray arr, object base): + * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< + * PyArray_SetBaseObject(arr, base) + * + */ + Py_INCREF(__pyx_v_base); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":870 + * cdef inline void set_array_base(ndarray arr, object base): + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< + * + * cdef inline object get_array_base(ndarray arr): + */ + (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":868 + * int _import_umath() except -1 + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":872 + * PyArray_SetBaseObject(arr, base) + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) + * if base is NULL: + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { + PyObject *__pyx_v_base; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("get_array_base", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":873 + * + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< + * if base is NULL: + * return None + */ + __pyx_v_base = PyArray_BASE(__pyx_v_arr); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":874 + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) + * if base is NULL: # <<<<<<<<<<<<<< + * return None + * return base + */ + __pyx_t_1 = ((__pyx_v_base == NULL) != 0); + if (__pyx_t_1) { + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":875 + * base = PyArray_BASE(arr) + * if base is NULL: + * return None # <<<<<<<<<<<<<< + * return base + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":874 + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) + * if base is NULL: # <<<<<<<<<<<<<< + * return None + * return base + */ + } + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":876 + * if base is NULL: + * return None + * return base # <<<<<<<<<<<<<< + * + * # Versions of the import_* functions which are more suitable for + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_base)); + __pyx_r = ((PyObject *)__pyx_v_base); + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":872 + * PyArray_SetBaseObject(arr, base) + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) + * if base is NULL: + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":880 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * __pyx_import_array() + */ + +static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("import_array", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":881 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * __pyx_import_array() + * except Exception: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":882 + * cdef inline int import_array() except -1: + * try: + * __pyx_import_array() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") + */ + __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 882, __pyx_L3_error) + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":881 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * __pyx_import_array() + * except Exception: + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":883 + * try: + * __pyx_import_array() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.multiarray failed to import") + * + */ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 883, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":884 + * __pyx_import_array() + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_umath() except -1: + */ + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 884, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 884, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":881 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * __pyx_import_array() + * except Exception: + */ + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":880 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * __pyx_import_array() + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":886 + * raise ImportError("numpy.core.multiarray failed to import") + * + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + +static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("import_umath", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":887 + * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":888 + * cdef inline int import_umath() except -1: + * try: + * _import_umath() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.umath failed to import") + */ + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 888, __pyx_L3_error) + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":887 + * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":889 + * try: + * _import_umath() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.umath failed to import") + * + */ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 889, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":890 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_ufunc() except -1: + */ + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 890, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 890, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":887 + * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":886 + * raise ImportError("numpy.core.multiarray failed to import") + * + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":892 + * raise ImportError("numpy.core.umath failed to import") + * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + +static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("import_ufunc", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":893 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":894 + * cdef inline int import_ufunc() except -1: + * try: + * _import_umath() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.umath failed to import") + */ + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 894, __pyx_L3_error) + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":893 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":895 + * try: + * _import_umath() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.umath failed to import") + * + */ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 895, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":896 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< + * + * cdef extern from *: + */ + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 896, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 896, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":893 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":892 + * raise ImportError("numpy.core.umath failed to import") + * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; + +#if PY_MAJOR_VERSION >= 3 +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_testing_utils(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_testing_utils}, + {0, NULL} +}; +#endif + +static struct PyModuleDef __pyx_moduledef = { + PyModuleDef_HEAD_INIT, + "testing_utils", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif +#ifndef CYTHON_SMALL_CODE +#if defined(__clang__) + #define CYTHON_SMALL_CODE +#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) + #define CYTHON_SMALL_CODE __attribute__((cold)) +#else + #define CYTHON_SMALL_CODE +#endif +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1}, + {&__pyx_n_s_arma_x, __pyx_k_arma_x, sizeof(__pyx_k_arma_x), 0, 0, 1, 1}, + {&__pyx_n_s_arma_xy, __pyx_k_arma_xy, sizeof(__pyx_k_arma_xy), 0, 0, 1, 1}, + {&__pyx_n_s_arma_y, __pyx_k_arma_y, sizeof(__pyx_k_arma_y), 0, 0, 1, 1}, + {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_n_s_dmat_dot_dmat, __pyx_k_dmat_dot_dmat, sizeof(__pyx_k_dmat_dot_dmat), 0, 0, 1, 1}, + {&__pyx_n_s_dmat_np_to_arma_to_np, __pyx_k_dmat_np_to_arma_to_np, sizeof(__pyx_k_dmat_np_to_arma_to_np), 0, 0, 1, 1}, + {&__pyx_n_s_dvec_np_to_arma_to_np, __pyx_k_dvec_np_to_arma_to_np, sizeof(__pyx_k_dvec_np_to_arma_to_np), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_l0learn_testing_utils, __pyx_k_l0learn_testing_utils, sizeof(__pyx_k_l0learn_testing_utils), 0, 0, 1, 1}, + {&__pyx_kp_s_l0learn_testing_utils_pyx, __pyx_k_l0learn_testing_utils_pyx, sizeof(__pyx_k_l0learn_testing_utils_pyx), 0, 0, 1, 0}, + {&__pyx_n_s_list_csc_to_arma_csc_to_list, __pyx_k_list_csc_to_arma_csc_to_list, sizeof(__pyx_k_list_csc_to_arma_csc_to_list), 0, 0, 1, 1}, + {&__pyx_n_s_list_dvec_to_arma_dvec_to_list, __pyx_k_list_dvec_to_arma_dvec_to_list, sizeof(__pyx_k_list_dvec_to_arma_dvec_to_list), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, + {&__pyx_n_s_np_xy, __pyx_k_np_xy, sizeof(__pyx_k_np_xy), 0, 0, 1, 1}, + {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, + {&__pyx_kp_u_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 1, 0, 0}, + {&__pyx_kp_u_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 1, 0, 0}, + {&__pyx_n_s_sp_dmat_np_to_arma_to_np, __pyx_k_sp_dmat_np_to_arma_to_np, sizeof(__pyx_k_sp_dmat_np_to_arma_to_np), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_s_uvec_np_to_arma_to_np, __pyx_k_uvec_np_to_arma_to_np, sizeof(__pyx_k_uvec_np_to_arma_to_np), 0, 0, 1, 1}, + {&__pyx_n_s_x, __pyx_k_x, sizeof(__pyx_k_x), 0, 0, 1, 1}, + {&__pyx_n_s_x_pass, __pyx_k_x_pass, sizeof(__pyx_k_x_pass), 0, 0, 1, 1}, + {&__pyx_n_s_y, __pyx_k_y, sizeof(__pyx_k_y), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 884, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":884 + * __pyx_import_array() + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_umath() except -1: + */ + __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 884, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple_); + __Pyx_GIVEREF(__pyx_tuple_); + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":890 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_ufunc() except -1: + */ + __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 890, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); + + /* "l0learn/testing_utils.pyx":10 + * sp_dmat_to_numpy) + * + * def list_csc_to_arma_csc_to_list(x): # <<<<<<<<<<<<<< + * return c_list_csc_to_arma_csc_to_list(x) + * + */ + __pyx_tuple__3 = PyTuple_Pack(1, __pyx_n_s_x); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + __pyx_codeobj__4 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_list_csc_to_arma_csc_to_list, 10, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__4)) __PYX_ERR(0, 10, __pyx_L1_error) + + /* "l0learn/testing_utils.pyx":18 + * return lst + * + * def list_dvec_to_arma_dvec_to_list(x): # <<<<<<<<<<<<<< + * return c_list_dvec_to_arma_dvec_to_list(x) + * + */ + __pyx_tuple__5 = PyTuple_Pack(1, __pyx_n_s_x); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + __pyx_codeobj__6 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__5, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_list_dvec_to_arma_dvec_to_list, 18, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__6)) __PYX_ERR(0, 18, __pyx_L1_error) + + /* "l0learn/testing_utils.pyx":27 + * + * + * def dmat_np_to_arma_to_np(x): # <<<<<<<<<<<<<< + * cdef np.ndarray[np.double_t, ndim=2] x_pass + * x_pass = c_dmat_np_to_arma_to_np(x) + */ + __pyx_tuple__7 = PyTuple_Pack(2, __pyx_n_s_x, __pyx_n_s_x_pass); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 27, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__7); + __Pyx_GIVEREF(__pyx_tuple__7); + __pyx_codeobj__8 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__7, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_dmat_np_to_arma_to_np, 27, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__8)) __PYX_ERR(0, 27, __pyx_L1_error) + + /* "l0learn/testing_utils.pyx":42 + * + * + * def uvec_np_to_arma_to_np(x): # <<<<<<<<<<<<<< + * cdef np.ndarray[np.uint64_t, ndim=1] x_pass + * x_pass = c_uvec_np_to_arma_to_np(x) + */ + __pyx_tuple__9 = PyTuple_Pack(2, __pyx_n_s_x, __pyx_n_s_x_pass); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__9); + __Pyx_GIVEREF(__pyx_tuple__9); + __pyx_codeobj__10 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__9, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_uvec_np_to_arma_to_np, 42, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__10)) __PYX_ERR(0, 42, __pyx_L1_error) + + /* "l0learn/testing_utils.pyx":57 + * + * + * def dvec_np_to_arma_to_np(x): # <<<<<<<<<<<<<< + * cdef np.ndarray[np.double_t, ndim=1] x_pass + * x_pass = c_dvec_np_to_arma_to_np(x) + */ + __pyx_tuple__11 = PyTuple_Pack(2, __pyx_n_s_x, __pyx_n_s_x_pass); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__11); + __Pyx_GIVEREF(__pyx_tuple__11); + __pyx_codeobj__12 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__11, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_dvec_np_to_arma_to_np, 57, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__12)) __PYX_ERR(0, 57, __pyx_L1_error) + + /* "l0learn/testing_utils.pyx":72 + * + * + * def sp_dmat_np_to_arma_to_np(x): # <<<<<<<<<<<<<< + * return c_sp_dmat_np_to_arma_to_np(x) + * + */ + __pyx_tuple__13 = PyTuple_Pack(1, __pyx_n_s_x); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 72, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__13); + __Pyx_GIVEREF(__pyx_tuple__13); + __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_sp_dmat_np_to_arma_to_np, 72, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(0, 72, __pyx_L1_error) + + /* "l0learn/testing_utils.pyx":82 + * return np_x + * + * def dmat_dot_dmat(x, y): # <<<<<<<<<<<<<< + * cdef dmat arma_x = numpy_to_dmat_d(x) + * cdef dmat arma_y = numpy_to_dmat_d(y) + */ + __pyx_tuple__15 = PyTuple_Pack(6, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_arma_x, __pyx_n_s_arma_y, __pyx_n_s_arma_xy, __pyx_n_s_np_xy); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__15); + __Pyx_GIVEREF(__pyx_tuple__15); + __pyx_codeobj__16 = (PyObject*)__Pyx_PyCode_New(2, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__15, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_dmat_dot_dmat, 82, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__16)) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + return 0; + __pyx_L1_error:; + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ + +static int __Pyx_modinit_global_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); + /*--- Global init code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); + /*--- Variable export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_export_code(void) { + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); + /*--- Function export code ---*/ + if (__Pyx_ExportFunction("c_list_csc_to_arma_csc_to_list", (void (*)(void))__pyx_f_7l0learn_13testing_utils_c_list_csc_to_arma_csc_to_list, "PyObject *(PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("c_dmat_np_to_arma_to_np", (void (*)(void))__pyx_f_7l0learn_13testing_utils_c_dmat_np_to_arma_to_np, "PyArrayObject *(PyArrayObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("c_uvec_np_to_arma_to_np", (void (*)(void))__pyx_f_7l0learn_13testing_utils_c_uvec_np_to_arma_to_np, "PyArrayObject *(PyArrayObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("c_dvec_np_to_arma_to_np", (void (*)(void))__pyx_f_7l0learn_13testing_utils_c_dvec_np_to_arma_to_np, "PyArrayObject *(PyArrayObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("c_sp_dmat_np_to_arma_to_np", (void (*)(void))__pyx_f_7l0learn_13testing_utils_c_sp_dmat_np_to_arma_to_np, "PyObject *(PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("c_dmat_dot_dmat", (void (*)(void))__pyx_f_7l0learn_13testing_utils_c_dmat_dot_dmat, "arma::dmat (arma::dmat, arma::dmat)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_type_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); + /*--- Type init code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_import_code(void) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); + /*--- Type import code ---*/ + __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyTypeObject), + #else + sizeof(PyHeapTypeObject), + #endif + __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(2, 9, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 199, __pyx_L1_error) + __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 222, __pyx_L1_error) + __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 226, __pyx_L1_error) + __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 238, __pyx_L1_error) + __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 764, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_variable_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); + /*--- Variable import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_import_code(void) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); + /*--- Function import code ---*/ + __pyx_t_1 = PyImport_ImportModule("l0learn.cyarma"); if (!__pyx_t_1) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_ImportFunction(__pyx_t_1, "list_to_sp_dmat_field", (void (**)(void))&__pyx_f_7l0learn_6cyarma_list_to_sp_dmat_field, "arma::field (PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ImportFunction(__pyx_t_1, "list_to_dvec_field", (void (**)(void))&__pyx_f_7l0learn_6cyarma_list_to_dvec_field, "arma::field (PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ImportFunction(__pyx_t_1, "numpy_to_dmat_d", (void (**)(void))&__pyx_f_7l0learn_6cyarma_numpy_to_dmat_d, "arma::dmat (PyArrayObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ImportFunction(__pyx_t_1, "numpy_to_dvec_d", (void (**)(void))&__pyx_f_7l0learn_6cyarma_numpy_to_dvec_d, "arma::dvec (PyArrayObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ImportFunction(__pyx_t_1, "numpy_to_uvec_d", (void (**)(void))&__pyx_f_7l0learn_6cyarma_numpy_to_uvec_d, "arma::uvec (PyArrayObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ImportFunction(__pyx_t_1, "numpy_to_sp_dmat_d", (void (**)(void))&__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d, "arma::sp_dmat (PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ImportFunction(__pyx_t_1, "sp_dmat_field_to_list", (void (**)(void))&__pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list, "PyObject *(arma::field )") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ImportFunction(__pyx_t_1, "dvec_field_to_list", (void (**)(void))&__pyx_f_7l0learn_6cyarma_dvec_field_to_list, "PyObject *(arma::field )") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ImportFunction(__pyx_t_1, "dmat_to_numpy", (void (**)(void))&__pyx_f_7l0learn_6cyarma_dmat_to_numpy, "PyArrayObject *(arma::dmat const &, PyArrayObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ImportFunction(__pyx_t_1, "dvec_to_numpy", (void (**)(void))&__pyx_f_7l0learn_6cyarma_dvec_to_numpy, "PyArrayObject *(arma::dvec const &, PyArrayObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ImportFunction(__pyx_t_1, "uvec_to_numpy", (void (**)(void))&__pyx_f_7l0learn_6cyarma_uvec_to_numpy, "PyArrayObject *(arma::uvec const &, PyArrayObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ImportFunction(__pyx_t_1, "sp_dmat_to_numpy", (void (**)(void))&__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy, "PyObject *(arma::sp_dmat const &, PyArrayObject *, PyArrayObject *, PyArrayObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_RefNannyFinishContext(); + return -1; +} + + +#ifndef CYTHON_NO_PYINIT_EXPORT +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#elif PY_MAJOR_VERSION < 3 +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" void +#else +#define __Pyx_PyMODINIT_FUNC void +#endif +#else +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * +#else +#define __Pyx_PyMODINIT_FUNC PyObject * +#endif +#endif + + +#if PY_MAJOR_VERSION < 3 +__Pyx_PyMODINIT_FUNC inittesting_utils(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC inittesting_utils(void) +#else +__Pyx_PyMODINIT_FUNC PyInit_testing_utils(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_testing_utils(void) +#if CYTHON_PEP489_MULTI_PHASE_INIT +{ + return PyModuleDef_Init(&__pyx_moduledef); +} +static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { + #if PY_VERSION_HEX >= 0x030700A1 + static PY_INT64_T main_interpreter_id = -1; + PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); + if (main_interpreter_id == -1) { + main_interpreter_id = current_id; + return (unlikely(current_id == -1)) ? -1 : 0; + } else if (unlikely(main_interpreter_id != current_id)) + #else + static PyInterpreterState *main_interpreter = NULL; + PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; + if (!main_interpreter) { + main_interpreter = current_interpreter; + } else if (unlikely(main_interpreter != current_interpreter)) + #endif + { + PyErr_SetString( + PyExc_ImportError, + "Interpreter change detected - this module can only be loaded into one interpreter per process."); + return -1; + } + return 0; +} +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { + PyObject *value = PyObject_GetAttrString(spec, from_name); + int result = 0; + if (likely(value)) { + if (allow_none || value != Py_None) { + result = PyDict_SetItemString(moddict, to_name, value); + } + Py_DECREF(value); + } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + } else { + result = -1; + } + return result; +} +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { + PyObject *module = NULL, *moddict, *modname; + if (__Pyx_check_single_interpreter()) + return NULL; + if (__pyx_m) + return __Pyx_NewRef(__pyx_m); + modname = PyObject_GetAttrString(spec, "name"); + if (unlikely(!modname)) goto bad; + module = PyModule_NewObject(modname); + Py_DECREF(modname); + if (unlikely(!module)) goto bad; + moddict = PyModule_GetDict(module); + if (unlikely(!moddict)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; + return module; +bad: + Py_XDECREF(module); + return NULL; +} + + +static CYTHON_SMALL_CODE int __pyx_pymod_exec_testing_utils(PyObject *__pyx_pyinit_module) +#endif +#endif +{ + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + #if CYTHON_PEP489_MULTI_PHASE_INIT + if (__pyx_m) { + if (__pyx_m == __pyx_pyinit_module) return 0; + PyErr_SetString(PyExc_RuntimeError, "Module 'testing_utils' has already been imported. Re-initialisation is not supported."); + return -1; + } + #elif PY_MAJOR_VERSION >= 3 + if (__pyx_m) return __Pyx_NewRef(__pyx_m); + #endif + #if CYTHON_REFNANNY +__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); +if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); +} +#endif + __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_testing_utils(void)", 0); + if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pxy_PyFrame_Initialize_Offsets + __Pxy_PyFrame_Initialize_Offsets(); + #endif + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + #ifdef WITH_THREAD /* Python build with threading support? */ + PyEval_InitThreads(); + #endif + #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_m = __pyx_pyinit_module; + Py_INCREF(__pyx_m); + #else + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("testing_utils", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_b); + __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_cython_runtime); + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + if (__pyx_module_is_main_l0learn__testing_utils) { + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "l0learn.testing_utils")) { + if (unlikely(PyDict_SetItemString(modules, "l0learn.testing_utils", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Global type/function init code ---*/ + (void)__Pyx_modinit_global_init_code(); + (void)__Pyx_modinit_variable_export_code(); + if (unlikely(__Pyx_modinit_function_export_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + (void)__Pyx_modinit_type_init_code(); + if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + (void)__Pyx_modinit_variable_import_code(); + if (unlikely(__Pyx_modinit_function_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + + /* "l0learn/testing_utils.pyx":2 + * cimport cython + * import numpy as np # <<<<<<<<<<<<<< + * cimport numpy as np + * + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 2, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "l0learn/testing_utils.pyx":10 + * sp_dmat_to_numpy) + * + * def list_csc_to_arma_csc_to_list(x): # <<<<<<<<<<<<<< + * return c_list_csc_to_arma_csc_to_list(x) + * + */ + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_13testing_utils_1list_csc_to_arma_csc_to_list, NULL, __pyx_n_s_l0learn_testing_utils); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_list_csc_to_arma_csc_to_list, __pyx_t_1) < 0) __PYX_ERR(0, 10, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "l0learn/testing_utils.pyx":18 + * return lst + * + * def list_dvec_to_arma_dvec_to_list(x): # <<<<<<<<<<<<<< + * return c_list_dvec_to_arma_dvec_to_list(x) + * + */ + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_13testing_utils_3list_dvec_to_arma_dvec_to_list, NULL, __pyx_n_s_l0learn_testing_utils); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_list_dvec_to_arma_dvec_to_list, __pyx_t_1) < 0) __PYX_ERR(0, 18, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "l0learn/testing_utils.pyx":27 + * + * + * def dmat_np_to_arma_to_np(x): # <<<<<<<<<<<<<< + * cdef np.ndarray[np.double_t, ndim=2] x_pass + * x_pass = c_dmat_np_to_arma_to_np(x) + */ + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_13testing_utils_5dmat_np_to_arma_to_np, NULL, __pyx_n_s_l0learn_testing_utils); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 27, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_dmat_np_to_arma_to_np, __pyx_t_1) < 0) __PYX_ERR(0, 27, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "l0learn/testing_utils.pyx":42 + * + * + * def uvec_np_to_arma_to_np(x): # <<<<<<<<<<<<<< + * cdef np.ndarray[np.uint64_t, ndim=1] x_pass + * x_pass = c_uvec_np_to_arma_to_np(x) + */ + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_13testing_utils_7uvec_np_to_arma_to_np, NULL, __pyx_n_s_l0learn_testing_utils); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_uvec_np_to_arma_to_np, __pyx_t_1) < 0) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "l0learn/testing_utils.pyx":57 + * + * + * def dvec_np_to_arma_to_np(x): # <<<<<<<<<<<<<< + * cdef np.ndarray[np.double_t, ndim=1] x_pass + * x_pass = c_dvec_np_to_arma_to_np(x) + */ + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_13testing_utils_9dvec_np_to_arma_to_np, NULL, __pyx_n_s_l0learn_testing_utils); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_dvec_np_to_arma_to_np, __pyx_t_1) < 0) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "l0learn/testing_utils.pyx":72 + * + * + * def sp_dmat_np_to_arma_to_np(x): # <<<<<<<<<<<<<< + * return c_sp_dmat_np_to_arma_to_np(x) + * + */ + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_13testing_utils_11sp_dmat_np_to_arma_to_np, NULL, __pyx_n_s_l0learn_testing_utils); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 72, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_sp_dmat_np_to_arma_to_np, __pyx_t_1) < 0) __PYX_ERR(0, 72, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "l0learn/testing_utils.pyx":82 + * return np_x + * + * def dmat_dot_dmat(x, y): # <<<<<<<<<<<<<< + * cdef dmat arma_x = numpy_to_dmat_d(x) + * cdef dmat arma_y = numpy_to_dmat_d(y) + */ + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_13testing_utils_13dmat_dot_dmat, NULL, __pyx_n_s_l0learn_testing_utils); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_dmat_dot_dmat, __pyx_t_1) < 0) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "l0learn/testing_utils.pyx":1 + * cimport cython # <<<<<<<<<<<<<< + * import numpy as np + * cimport numpy as np + */ + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":892 + * raise ImportError("numpy.core.umath failed to import") + * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init l0learn.testing_utils", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_CLEAR(__pyx_m); + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init l0learn.testing_utils"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if CYTHON_PEP489_MULTI_PHASE_INIT + return (__pyx_m != NULL) ? 0 : -1; + #elif PY_MAJOR_VERSION >= 3 + return __pyx_m; + #else + return; + #endif +} + +/* --- Runtime support code --- */ +/* Refnanny */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule(modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, "RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +/* ExtTypeTest */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(__Pyx_TypeCheck(obj, type))) + return 1; + PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", + Py_TYPE(obj)->tp_name, type->tp_name); + return 0; +} + +/* IsLittleEndian */ +static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) +{ + union { + uint32_t u32; + uint8_t u8[4]; + } S; + S.u32 = 0x01020304; + return S.u8[0] == 4; +} + +/* BufferFormatCheck */ +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + __Pyx_TypeInfo* type) { + stack[0].field = &ctx->root; + stack[0].parent_offset = 0; + ctx->root.type = type; + ctx->root.name = "buffer dtype"; + ctx->root.offset = 0; + ctx->head = stack; + ctx->head->field = &ctx->root; + ctx->fmt_offset = 0; + ctx->head->parent_offset = 0; + ctx->new_packmode = '@'; + ctx->enc_packmode = '@'; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->is_complex = 0; + ctx->is_valid_array = 0; + ctx->struct_alignment = 0; + while (type->typegroup == 'S') { + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = 0; + type = type->fields->type; + } +} +static int __Pyx_BufFmt_ParseNumber(const char** ts) { + int count; + const char* t = *ts; + if (*t < '0' || *t > '9') { + return -1; + } else { + count = *t++ - '0'; + while (*t >= '0' && *t <= '9') { + count *= 10; + count += *t++ - '0'; + } + } + *ts = t; + return count; +} +static int __Pyx_BufFmt_ExpectNumber(const char **ts) { + int number = __Pyx_BufFmt_ParseNumber(ts); + if (number == -1) + PyErr_Format(PyExc_ValueError,\ + "Does not understand character buffer dtype format string ('%c')", **ts); + return number; +} +static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { + PyErr_Format(PyExc_ValueError, + "Unexpected format string character: '%c'", ch); +} +static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { + switch (ch) { + case '?': return "'bool'"; + case 'c': return "'char'"; + case 'b': return "'signed char'"; + case 'B': return "'unsigned char'"; + case 'h': return "'short'"; + case 'H': return "'unsigned short'"; + case 'i': return "'int'"; + case 'I': return "'unsigned int'"; + case 'l': return "'long'"; + case 'L': return "'unsigned long'"; + case 'q': return "'long long'"; + case 'Q': return "'unsigned long long'"; + case 'f': return (is_complex ? "'complex float'" : "'float'"); + case 'd': return (is_complex ? "'complex double'" : "'double'"); + case 'g': return (is_complex ? "'complex long double'" : "'long double'"); + case 'T': return "a struct"; + case 'O': return "Python object"; + case 'P': return "a pointer"; + case 's': case 'p': return "a string"; + case 0: return "end"; + default: return "unparseable format string"; + } +} +static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return 2; + case 'i': case 'I': case 'l': case 'L': return 4; + case 'q': case 'Q': return 8; + case 'f': return (is_complex ? 8 : 4); + case 'd': return (is_complex ? 16 : 8); + case 'g': { + PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); + return 0; + } + case 'O': case 'P': return sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(short); + case 'i': case 'I': return sizeof(int); + case 'l': case 'L': return sizeof(long); + #ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(PY_LONG_LONG); + #endif + case 'f': return sizeof(float) * (is_complex ? 2 : 1); + case 'd': return sizeof(double) * (is_complex ? 2 : 1); + case 'g': return sizeof(long double) * (is_complex ? 2 : 1); + case 'O': case 'P': return sizeof(void*); + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +typedef struct { char c; short x; } __Pyx_st_short; +typedef struct { char c; int x; } __Pyx_st_int; +typedef struct { char c; long x; } __Pyx_st_long; +typedef struct { char c; float x; } __Pyx_st_float; +typedef struct { char c; double x; } __Pyx_st_double; +typedef struct { char c; long double x; } __Pyx_st_longdouble; +typedef struct { char c; void *x; } __Pyx_st_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_st_float) - sizeof(float); + case 'd': return sizeof(__Pyx_st_double) - sizeof(double); + case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +/* These are for computing the padding at the end of the struct to align + on the first member of the struct. This will probably the same as above, + but we don't have any guarantees. + */ +typedef struct { short x; char c; } __Pyx_pad_short; +typedef struct { int x; char c; } __Pyx_pad_int; +typedef struct { long x; char c; } __Pyx_pad_long; +typedef struct { float x; char c; } __Pyx_pad_float; +typedef struct { double x; char c; } __Pyx_pad_double; +typedef struct { long double x; char c; } __Pyx_pad_longdouble; +typedef struct { void *x; char c; } __Pyx_pad_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); + case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); + case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { + switch (ch) { + case 'c': + return 'H'; + case 'b': case 'h': case 'i': + case 'l': case 'q': case 's': case 'p': + return 'I'; + case '?': case 'B': case 'H': case 'I': case 'L': case 'Q': + return 'U'; + case 'f': case 'd': case 'g': + return (is_complex ? 'C' : 'R'); + case 'O': + return 'O'; + case 'P': + return 'P'; + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { + if (ctx->head == NULL || ctx->head->field == &ctx->root) { + const char* expected; + const char* quote; + if (ctx->head == NULL) { + expected = "end"; + quote = ""; + } else { + expected = ctx->head->field->type->name; + quote = "'"; + } + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected %s%s%s but got %s", + quote, expected, quote, + __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); + } else { + __Pyx_StructField* field = ctx->head->field; + __Pyx_StructField* parent = (ctx->head - 1)->field; + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", + field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), + parent->type->name, field->name); + } +} +static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { + char group; + size_t size, offset, arraysize = 1; + if (ctx->enc_type == 0) return 0; + if (ctx->head->field->type->arraysize[0]) { + int i, ndim = 0; + if (ctx->enc_type == 's' || ctx->enc_type == 'p') { + ctx->is_valid_array = ctx->head->field->type->ndim == 1; + ndim = 1; + if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { + PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %zu", + ctx->head->field->type->arraysize[0], ctx->enc_count); + return -1; + } + } + if (!ctx->is_valid_array) { + PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", + ctx->head->field->type->ndim, ndim); + return -1; + } + for (i = 0; i < ctx->head->field->type->ndim; i++) { + arraysize *= ctx->head->field->type->arraysize[i]; + } + ctx->is_valid_array = 0; + ctx->enc_count = 1; + } + group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); + do { + __Pyx_StructField* field = ctx->head->field; + __Pyx_TypeInfo* type = field->type; + if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { + size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); + } else { + size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); + } + if (ctx->enc_packmode == '@') { + size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); + size_t align_mod_offset; + if (align_at == 0) return -1; + align_mod_offset = ctx->fmt_offset % align_at; + if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; + if (ctx->struct_alignment == 0) + ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, + ctx->is_complex); + } + if (type->size != size || type->typegroup != group) { + if (type->typegroup == 'C' && type->fields != NULL) { + size_t parent_offset = ctx->head->parent_offset + field->offset; + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = parent_offset; + continue; + } + if ((type->typegroup == 'H' || group == 'H') && type->size == size) { + } else { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + } + offset = ctx->head->parent_offset + field->offset; + if (ctx->fmt_offset != offset) { + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", + (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); + return -1; + } + ctx->fmt_offset += size; + if (arraysize) + ctx->fmt_offset += (arraysize - 1) * size; + --ctx->enc_count; + while (1) { + if (field == &ctx->root) { + ctx->head = NULL; + if (ctx->enc_count != 0) { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + break; + } + ctx->head->field = ++field; + if (field->type == NULL) { + --ctx->head; + field = ctx->head->field; + continue; + } else if (field->type->typegroup == 'S') { + size_t parent_offset = ctx->head->parent_offset + field->offset; + if (field->type->fields->type == NULL) continue; + field = field->type->fields; + ++ctx->head; + ctx->head->field = field; + ctx->head->parent_offset = parent_offset; + break; + } else { + break; + } + } + } while (ctx->enc_count); + ctx->enc_type = 0; + ctx->is_complex = 0; + return 0; +} +static PyObject * +__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) +{ + const char *ts = *tsp; + int i = 0, number, ndim; + ++ts; + if (ctx->new_count != 1) { + PyErr_SetString(PyExc_ValueError, + "Cannot handle repeated arrays in format string"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ndim = ctx->head->field->type->ndim; + while (*ts && *ts != ')') { + switch (*ts) { + case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; + default: break; + } + number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) + return PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %d", + ctx->head->field->type->arraysize[i], number); + if (*ts != ',' && *ts != ')') + return PyErr_Format(PyExc_ValueError, + "Expected a comma in format string, got '%c'", *ts); + if (*ts == ',') ts++; + i++; + } + if (i != ndim) + return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", + ctx->head->field->type->ndim, i); + if (!*ts) { + PyErr_SetString(PyExc_ValueError, + "Unexpected end of format string, expected ')'"); + return NULL; + } + ctx->is_valid_array = 1; + ctx->new_count = 1; + *tsp = ++ts; + return Py_None; +} +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { + int got_Z = 0; + while (1) { + switch(*ts) { + case 0: + if (ctx->enc_type != 0 && ctx->head == NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + if (ctx->head != NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + return ts; + case ' ': + case '\r': + case '\n': + ++ts; + break; + case '<': + if (!__Pyx_Is_Little_Endian()) { + PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '>': + case '!': + if (__Pyx_Is_Little_Endian()) { + PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '=': + case '@': + case '^': + ctx->new_packmode = *ts++; + break; + case 'T': + { + const char* ts_after_sub; + size_t i, struct_count = ctx->new_count; + size_t struct_alignment = ctx->struct_alignment; + ctx->new_count = 1; + ++ts; + if (*ts != '{') { + PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + ctx->enc_count = 0; + ctx->struct_alignment = 0; + ++ts; + ts_after_sub = ts; + for (i = 0; i != struct_count; ++i) { + ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); + if (!ts_after_sub) return NULL; + } + ts = ts_after_sub; + if (struct_alignment) ctx->struct_alignment = struct_alignment; + } + break; + case '}': + { + size_t alignment = ctx->struct_alignment; + ++ts; + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + if (alignment && ctx->fmt_offset % alignment) { + ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); + } + } + return ts; + case 'x': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->fmt_offset += ctx->new_count; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->enc_packmode = ctx->new_packmode; + ++ts; + break; + case 'Z': + got_Z = 1; + ++ts; + if (*ts != 'f' && *ts != 'd' && *ts != 'g') { + __Pyx_BufFmt_RaiseUnexpectedChar('Z'); + return NULL; + } + CYTHON_FALLTHROUGH; + case '?': case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': + case 'l': case 'L': case 'q': case 'Q': + case 'f': case 'd': case 'g': + case 'O': case 'p': + if ((ctx->enc_type == *ts) && (got_Z == ctx->is_complex) && + (ctx->enc_packmode == ctx->new_packmode) && (!ctx->is_valid_array)) { + ctx->enc_count += ctx->new_count; + ctx->new_count = 1; + got_Z = 0; + ++ts; + break; + } + CYTHON_FALLTHROUGH; + case 's': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_count = ctx->new_count; + ctx->enc_packmode = ctx->new_packmode; + ctx->enc_type = *ts; + ctx->is_complex = got_Z; + ++ts; + ctx->new_count = 1; + got_Z = 0; + break; + case ':': + ++ts; + while(*ts != ':') ++ts; + ++ts; + break; + case '(': + if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; + break; + default: + { + int number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + ctx->new_count = (size_t)number; + } + } + } +} + +/* BufferGetAndValidate */ + static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) { + if (unlikely(info->buf == NULL)) return; + if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL; + __Pyx_ReleaseBuffer(info); +} +static void __Pyx_ZeroBuffer(Py_buffer* buf) { + buf->buf = NULL; + buf->obj = NULL; + buf->strides = __Pyx_zeros; + buf->shape = __Pyx_zeros; + buf->suboffsets = __Pyx_minusones; +} +static int __Pyx__GetBufferAndValidate( + Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, + int nd, int cast, __Pyx_BufFmt_StackElem* stack) +{ + buf->buf = NULL; + if (unlikely(__Pyx_GetBuffer(obj, buf, flags) == -1)) { + __Pyx_ZeroBuffer(buf); + return -1; + } + if (unlikely(buf->ndim != nd)) { + PyErr_Format(PyExc_ValueError, + "Buffer has wrong number of dimensions (expected %d, got %d)", + nd, buf->ndim); + goto fail; + } + if (!cast) { + __Pyx_BufFmt_Context ctx; + __Pyx_BufFmt_Init(&ctx, stack, dtype); + if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail; + } + if (unlikely((size_t)buf->itemsize != dtype->size)) { + PyErr_Format(PyExc_ValueError, + "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)", + buf->itemsize, (buf->itemsize > 1) ? "s" : "", + dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : ""); + goto fail; + } + if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones; + return 0; +fail:; + __Pyx_SafeReleaseBuffer(buf); + return -1; +} + +/* BufferFallbackError */ + static void __Pyx_RaiseBufferFallbackError(void) { + PyErr_SetString(PyExc_ValueError, + "Buffer acquisition failed on assignment; and then reacquiring the old buffer failed too!"); +} + +/* PyErrFetchRestore */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +} +#endif + +/* RaiseArgTupleInvalid */ + static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +/* RaiseDoubleKeywords */ + static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION >= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +/* ParseKeywords */ + static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + while (PyDict_Next(kwds, &pos, &key, &value)) { + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; + continue; + } + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = (**name == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + return -1; +} + +/* PyObjectGetAttrStr */ + #if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#endif + +/* GetBuiltinName */ + static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +/* GetTopmostException */ + #if CYTHON_USE_EXC_INFO_STACK +static _PyErr_StackItem * +__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) +{ + _PyErr_StackItem *exc_info = tstate->exc_info; + while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && + exc_info->previous_item != NULL) + { + exc_info = exc_info->previous_item; + } + return exc_info; +} +#endif + +/* SaveResetException */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + *type = exc_info->exc_type; + *value = exc_info->exc_value; + *tb = exc_info->exc_traceback; + #else + *type = tstate->exc_type; + *value = tstate->exc_value; + *tb = tstate->exc_traceback; + #endif + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); +} +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = type; + exc_info->exc_value = value; + exc_info->exc_traceback = tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = type; + tstate->exc_value = value; + tstate->exc_traceback = tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +#endif + +/* PyErrExceptionMatches */ + #if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; icurexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; + if (unlikely(PyTuple_Check(err))) + return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); +} +#endif + +/* GetException */ + #if CYTHON_FAST_THREAD_STATE +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) +#endif +{ + PyObject *local_type, *local_value, *local_tb; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) +#else + if (unlikely(PyErr_Occurred())) +#endif + goto bad; + #if PY_MAJOR_VERSION >= 3 + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; + } + #endif + Py_XINCREF(local_tb); + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; +#if CYTHON_FAST_THREAD_STATE + #if CYTHON_USE_EXC_INFO_STACK + { + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = local_type; + exc_info->exc_value = local_value; + exc_info->exc_traceback = local_tb; + } + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = local_type; + tstate->exc_value = local_value; + tstate->exc_traceback = local_tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); +#endif + return 0; +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; +} + +/* PyObjectCall */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = func->ob_type->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* RaiseException */ + #if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + __Pyx_PyThreadState_declare + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_PyThreadState_assign + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } + if (cause) { + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_COMPILING_IN_PYPY + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#else + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} +#endif + +/* TypeImport */ + #ifndef __PYX_HAVE_RT_ImportType +#define __PYX_HAVE_RT_ImportType +static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, + size_t size, enum __Pyx_ImportType_CheckSize check_size) +{ + PyObject *result = 0; + char warning[200]; + Py_ssize_t basicsize; +#ifdef Py_LIMITED_API + PyObject *py_basicsize; +#endif + result = PyObject_GetAttrString(module, class_name); + if (!result) + goto bad; + if (!PyType_Check(result)) { + PyErr_Format(PyExc_TypeError, + "%.200s.%.200s is not a type object", + module_name, class_name); + goto bad; + } +#ifndef Py_LIMITED_API + basicsize = ((PyTypeObject *)result)->tp_basicsize; +#else + py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); + if (!py_basicsize) + goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; +#endif + if ((size_t)basicsize < size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize); + goto bad; + } + if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize); + goto bad; + } + else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) { + PyOS_snprintf(warning, sizeof(warning), + "%s.%s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize); + if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; + } + return (PyTypeObject *)result; +bad: + Py_XDECREF(result); + return NULL; +} +#endif + +/* Import */ + static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_MAJOR_VERSION < 3 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) { + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + #endif + if (!module) { + #if PY_MAJOR_VERSION < 3 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } +bad: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + +/* PyDictVersioning */ + #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { + PyObject **dictptr = NULL; + Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; + if (offset) { +#if CYTHON_COMPILING_IN_CPYTHON + dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); +#else + dictptr = _PyObject_GetDictPtr(obj); +#endif + } + return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; +} +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) + return 0; + return obj_dict_version == __Pyx_get_object_dict_version(obj); +} +#endif + +/* CLineInTraceback */ + #ifndef CYTHON_CLINE_IN_TRACEBACK +static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { + PyObject *use_cline; + PyObject *ptype, *pvalue, *ptraceback; +#if CYTHON_COMPILING_IN_CPYTHON + PyObject **cython_runtime_dict; +#endif + if (unlikely(!__pyx_cython_runtime)) { + return c_line; + } + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); +#if CYTHON_COMPILING_IN_CPYTHON + cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); + if (likely(cython_runtime_dict)) { + __PYX_PY_DICT_LOOKUP_IF_MODIFIED( + use_cline, *cython_runtime_dict, + __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) + } else +#endif + { + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + if (use_cline_obj) { + use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; + Py_DECREF(use_cline_obj); + } else { + PyErr_Clear(); + use_cline = NULL; + } + } + if (!use_cline) { + c_line = 0; + PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); + } + else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { + c_line = 0; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + return c_line; +} +#endif + +/* CodeObjectCache */ + static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +/* AddTraceback */ + #include "compile.h" +#include "frameobject.h" +#include "traceback.h" +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + #if PY_MAJOR_VERSION < 3 + py_srcfile = PyString_FromString(filename); + #else + py_srcfile = PyUnicode_FromString(filename); + #endif + if (!py_srcfile) goto bad; + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + #else + py_funcname = PyUnicode_FromString(funcname); + #endif + } + if (!py_funcname) goto bad; + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + Py_DECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + if (c_line) { + c_line = __Pyx_CLineForTraceback(tstate, c_line); + } + py_code = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!py_code) { + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) goto bad; + __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); + } + py_frame = PyFrame_New( + tstate, /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + __Pyx_PyFrame_SetLineNumber(py_frame, py_line); + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +#if PY_MAJOR_VERSION < 3 +static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { + if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); + PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); + return -1; +} +static void __Pyx_ReleaseBuffer(Py_buffer *view) { + PyObject *obj = view->obj; + if (!obj) return; + if (PyObject_CheckBuffer(obj)) { + PyBuffer_Release(view); + return; + } + if ((0)) {} + view->obj = NULL; + Py_DECREF(obj); +} +#endif + + + /* Declarations */ + #if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return ::std::complex< float >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return x + y*(__pyx_t_float_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + __pyx_t_float_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +/* Arithmetic */ + #if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + #if 1 + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + if (b.imag == 0) { + return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); + } else if (fabsf(b.real) >= fabsf(b.imag)) { + if (b.real == 0 && b.imag == 0) { + return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.imag); + } else { + float r = b.imag / b.real; + float s = (float)(1.0) / (b.real + b.imag * r); + return __pyx_t_float_complex_from_parts( + (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); + } + } else { + float r = b.real / b.imag; + float s = (float)(1.0) / (b.imag + b.real * r); + return __pyx_t_float_complex_from_parts( + (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); + } + } + #else + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + if (b.imag == 0) { + return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); + } else { + float denom = b.real * b.real + b.imag * b.imag; + return __pyx_t_float_complex_from_parts( + (a.real * b.real + a.imag * b.imag) / denom, + (a.imag * b.real - a.real * b.imag) / denom); + } + } + #endif + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrtf(z.real*z.real + z.imag*z.imag); + #else + return hypotf(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + float r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + float denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + return __Pyx_c_prod_float(a, a); + case 3: + z = __Pyx_c_prod_float(a, a); + return __Pyx_c_prod_float(z, a); + case 4: + z = __Pyx_c_prod_float(a, a); + return __Pyx_c_prod_float(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } else if (b.imag == 0) { + z.real = powf(a.real, b.real); + z.imag = 0; + return z; + } else if (a.real > 0) { + r = a.real; + theta = 0; + } else { + r = -a.real; + theta = atan2f(0.0, -1.0); + } + } else { + r = __Pyx_c_abs_float(a); + theta = atan2f(a.imag, a.real); + } + lnr = logf(r); + z_r = expf(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cosf(z_theta); + z.imag = z_r * sinf(z_theta); + return z; + } + #endif +#endif + +/* Declarations */ + #if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return ::std::complex< double >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return x + y*(__pyx_t_double_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + __pyx_t_double_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +/* Arithmetic */ + #if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + #if 1 + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + if (b.imag == 0) { + return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); + } else if (fabs(b.real) >= fabs(b.imag)) { + if (b.real == 0 && b.imag == 0) { + return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.imag); + } else { + double r = b.imag / b.real; + double s = (double)(1.0) / (b.real + b.imag * r); + return __pyx_t_double_complex_from_parts( + (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); + } + } else { + double r = b.real / b.imag; + double s = (double)(1.0) / (b.imag + b.real * r); + return __pyx_t_double_complex_from_parts( + (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); + } + } + #else + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + if (b.imag == 0) { + return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); + } else { + double denom = b.real * b.real + b.imag * b.imag; + return __pyx_t_double_complex_from_parts( + (a.real * b.real + a.imag * b.imag) / denom, + (a.imag * b.real - a.real * b.imag) / denom); + } + } + #endif + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrt(z.real*z.real + z.imag*z.imag); + #else + return hypot(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + double r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + double denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + return __Pyx_c_prod_double(a, a); + case 3: + z = __Pyx_c_prod_double(a, a); + return __Pyx_c_prod_double(z, a); + case 4: + z = __Pyx_c_prod_double(a, a); + return __Pyx_c_prod_double(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } else if (b.imag == 0) { + z.real = pow(a.real, b.real); + z.imag = 0; + return z; + } else if (a.real > 0) { + r = a.real; + theta = 0; + } else { + r = -a.real; + theta = atan2(0.0, -1.0); + } + } else { + r = __Pyx_c_abs_double(a); + theta = atan2(a.imag, a.real); + } + lnr = log(r); + z_r = exp(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cos(z_theta); + z.imag = z_r * sin(z_theta); + return z; + } + #endif +#endif + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { + const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + +/* CIntFromPyVerify */ + #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +/* CIntFromPy */ + static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { + const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } +#endif + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + long val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +/* CIntFromPy */ + static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { + const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +/* FastTypeChecks */ + #if CYTHON_COMPILING_IN_CPYTHON +static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { + while (a) { + a = a->tp_base; + if (a == b) + return 1; + } + return b == &PyBaseObject_Type; +} +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (a == b) return 1; + mro = a->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(a, b); +} +#if PY_MAJOR_VERSION == 2 +static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { + PyObject *exception, *value, *tb; + int res; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&exception, &value, &tb); + res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + if (!res) { + res = PyObject_IsSubclass(err, exc_type2); + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + } + __Pyx_ErrRestore(exception, value, tb); + return res; +} +#else +static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { + int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; + if (!res) { + res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + } + return res; +} +#endif +static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + assert(PyExceptionClass_Check(exc_type)); + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; i= 0x02070000 + cobj = PyCapsule_New(tmp.p, sig, 0); +#else + cobj = PyCObject_FromVoidPtrAndDesc(tmp.p, (void *)sig, 0); +#endif + if (!cobj) + goto bad; + if (PyDict_SetItemString(d, name, cobj) < 0) + goto bad; + Py_DECREF(cobj); + Py_DECREF(d); + return 0; +bad: + Py_XDECREF(cobj); + Py_XDECREF(d); + return -1; +} + +/* FunctionImport */ + #ifndef __PYX_HAVE_RT_ImportFunction +#define __PYX_HAVE_RT_ImportFunction +static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) { + PyObject *d = 0; + PyObject *cobj = 0; + union { + void (*fp)(void); + void *p; + } tmp; + d = PyObject_GetAttrString(module, (char *)"__pyx_capi__"); + if (!d) + goto bad; + cobj = PyDict_GetItemString(d, funcname); + if (!cobj) { + PyErr_Format(PyExc_ImportError, + "%.200s does not export expected C function %.200s", + PyModule_GetName(module), funcname); + goto bad; + } +#if PY_VERSION_HEX >= 0x02070000 + if (!PyCapsule_IsValid(cobj, sig)) { + PyErr_Format(PyExc_TypeError, + "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", + PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj)); + goto bad; + } + tmp.p = PyCapsule_GetPointer(cobj, sig); +#else + {const char *desc, *s1, *s2; + desc = (const char *)PyCObject_GetDesc(cobj); + if (!desc) + goto bad; + s1 = desc; s2 = sig; + while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; } + if (*s1 != *s2) { + PyErr_Format(PyExc_TypeError, + "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", + PyModule_GetName(module), funcname, sig, desc); + goto bad; + } + tmp.p = PyCObject_AsVoidPtr(cobj);} +#endif + *f = tmp.fp; + if (!(*f)) + goto bad; + Py_DECREF(d); + return 0; +bad: + Py_XDECREF(d); + return -1; +} +#endif + +/* InitStrings */ + static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + if (PyObject_Hash(*t->p) == -1) + return -1; + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); +} +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +#if !CYTHON_PEP393_ENABLED +static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +} +#else +static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (likely(PyUnicode_IS_ASCII(o))) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +} +#endif +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { + return __Pyx_PyUnicode_AsStringAndSize(o, length); + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { + int retval; + if (unlikely(!x)) return -1; + retval = __Pyx_PyObject_IsTrue(x); + Py_DECREF(x); + return retval; +} +static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { +#if PY_MAJOR_VERSION >= 3 + if (PyLong_Check(result)) { + if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, + "__int__ returned non-int (type %.200s). " + "The ability to return an instance of a strict subclass of int " + "is deprecated, and may be removed in a future version of Python.", + Py_TYPE(result)->tp_name)) { + Py_DECREF(result); + return NULL; + } + return result; + } +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + type_name, type_name, Py_TYPE(result)->tp_name); + Py_DECREF(result); + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { +#if CYTHON_USE_TYPE_SLOTS + PyNumberMethods *m; +#endif + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x) || PyLong_Check(x))) +#else + if (likely(PyLong_Check(x))) +#endif + return __Pyx_NewRef(x); +#if CYTHON_USE_TYPE_SLOTS + m = Py_TYPE(x)->tp_as_number; + #if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = m->nb_int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = m->nb_long(x); + } + #else + if (likely(m && m->nb_int)) { + name = "int"; + res = m->nb_int(x); + } + #endif +#else + if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { + res = PyNumber_Int(x); + } +#endif + if (likely(res)) { +#if PY_MAJOR_VERSION < 3 + if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { +#else + if (unlikely(!PyLong_CheckExact(res))) { +#endif + return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(b); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { + return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +#endif /* Py_PYTHON_H */ diff --git a/python/l0learn/testing_utils.pxd b/python/l0learn/testing_utils.pxd new file mode 100644 index 0000000..7f887e3 --- /dev/null +++ b/python/l0learn/testing_utils.pxd @@ -0,0 +1,17 @@ +# distutils: language = c++ + +cimport numpy as np + +from l0learn.cyarma cimport dmat, dvec, sp_dmat, uvec + +cdef list c_list_csc_to_arma_csc_to_list(list x) + +cdef np.ndarray[np.double_t, ndim=2] c_dmat_np_to_arma_to_np(np.ndarray[np.double_t, ndim=2] x) + +cdef np.ndarray[np.uint64_t, ndim=1] c_uvec_np_to_arma_to_np(np.ndarray[np.uint64_t, ndim=1] x) + +cdef np.ndarray[np.uint64_t, ndim=1] c_dvec_np_to_arma_to_np(np.ndarray[np.double_t, ndim=1] x) + +cdef c_sp_dmat_np_to_arma_to_np(x) + +cdef dmat c_dmat_dot_dmat(dmat arma_x, dmat arma_y) diff --git a/python/l0learn/testing_utils.pyx b/python/l0learn/testing_utils.pyx new file mode 100644 index 0000000..090653a --- /dev/null +++ b/python/l0learn/testing_utils.pyx @@ -0,0 +1,95 @@ +cimport cython +import numpy as np +cimport numpy as np + +from l0learn.cyarma cimport (sp_dmat_field_to_list, dvec_field_to_list, list_to_sp_dmat_field, list_to_dvec_field, +field, dmat, dvec, sp_dmat, uvec,numpy_to_dmat_d, dmat_to_numpy, numpy_to_uvec_d, + uvec_to_numpy, numpy_to_dvec_d, dvec_to_numpy, numpy_to_sp_dmat_d, + sp_dmat_to_numpy) + +def list_csc_to_arma_csc_to_list(x): + return c_list_csc_to_arma_csc_to_list(x) + +cdef list c_list_csc_to_arma_csc_to_list(list x): + cdef field[sp_dmat] f = list_to_sp_dmat_field(x) + cdef lst = sp_dmat_field_to_list(f) + return lst + +def list_dvec_to_arma_dvec_to_list(x): + return c_list_dvec_to_arma_dvec_to_list(x) + +cdef list c_list_dvec_to_arma_dvec_to_list(list x): + cdef field[dvec] f = list_to_dvec_field(x) + cdef lst = dvec_field_to_list(f) + return lst + + +def dmat_np_to_arma_to_np(x): + cdef np.ndarray[np.double_t, ndim=2] x_pass + x_pass = c_dmat_np_to_arma_to_np(x) + + return x_pass + + +cdef np.ndarray[np.double_t, ndim=2] c_dmat_np_to_arma_to_np(np.ndarray[np.double_t, ndim=2] x): + cdef dmat arma_x = numpy_to_dmat_d(x) + + cdef np.ndarray[np.double_t, ndim=2] np_x = dmat_to_numpy(arma_x, None) + + return np_x + + +def uvec_np_to_arma_to_np(x): + cdef np.ndarray[np.uint64_t, ndim=1] x_pass + x_pass = c_uvec_np_to_arma_to_np(x) + + return x_pass + + +cdef np.ndarray[np.uint64_t, ndim=1] c_uvec_np_to_arma_to_np(np.ndarray[np.uint64_t, ndim=1] x): + cdef uvec arma_x = numpy_to_uvec_d(x) + + cdef np.ndarray[np.uint64_t, ndim=1] np_x = uvec_to_numpy(arma_x, None) + + return np_x + + +def dvec_np_to_arma_to_np(x): + cdef np.ndarray[np.double_t, ndim=1] x_pass + x_pass = c_dvec_np_to_arma_to_np(x) + + return x_pass + + +cdef np.ndarray[np.uint64_t, ndim=1] c_dvec_np_to_arma_to_np(np.ndarray[np.double_t, ndim=1] x): + cdef dvec arma_x = numpy_to_dvec_d(x) + + cdef np.ndarray[np.double_t, ndim=1] np_x = dvec_to_numpy(arma_x, None) + + return np_x + + +def sp_dmat_np_to_arma_to_np(x): + return c_sp_dmat_np_to_arma_to_np(x) + + +cdef c_sp_dmat_np_to_arma_to_np(x): + cdef sp_dmat arma_x = numpy_to_sp_dmat_d(x) + + np_x = sp_dmat_to_numpy(arma_x, None, None, None) + return np_x + +def dmat_dot_dmat(x, y): + cdef dmat arma_x = numpy_to_dmat_d(x) + cdef dmat arma_y = numpy_to_dmat_d(y) + + cdef dmat arma_xy = c_dmat_dot_dmat(arma_x, arma_y) + + cdef np.ndarray[np.double_t, ndim=2] np_xy = dmat_to_numpy(arma_xy, None) + + return np_xy + +cdef dmat c_dmat_dot_dmat(dmat arma_x, dmat arma_y): + cdef dmat arma_xy = arma_x*arma_y + + return arma_xy \ No newline at end of file diff --git a/python/setup.py b/python/setup.py new file mode 100644 index 0000000..a146083 --- /dev/null +++ b/python/setup.py @@ -0,0 +1,181 @@ +#!/usr/bin/python3 + +# from distutils.core import setup +# from distutils.extension import Extension +# from Cython.Distutils import build_ext +# from Cython.Build import cythonize +# +# import numpy as np +# +# cyarma_extension = Extension( +# name='l0learn.l0learn.cyarma', +# sources=["l0learn/l0learn/cyarma.pyx"], +# include_dirs=['.', np.get_include()], +# language="c++", +# extra_compile_args=["-std=c++11"], +# extra_link_args=["-std=c++11"], +# ) +# +# utils_cyarma_extension = Extension( +# name='l0learn.tests.utils_cyarma', +# sources=["l0learn/tests/testing_utils.pyx"], +# include_dirs=['.', np.get_include()], +# language="c++", +# extra_compile_args=["-std=c++11"], +# extra_link_args=["-std=c++11"], +# ) +# +# bindings_extension = Extension( +# name="l0learn.l0learn.interface", +# sources=["l0learn/l0learn/interface.pyx"], +# include_dirs=['.', np.get_include()], +# language="c++", +# extra_compile_args=["-std=c++11"], +# extra_link_args=["-std=c++11"], +# ) +# +# ext_modules = [cyarma_extension, utils_cyarma_extension, bindings_extension] +# +# # setup( +# # name='py_bindings', +# # ext_modules=cythonize(ext_modules) +# # ) +# +# setup( +# name='l0learn', +# packages=['l0learn'], +# description='Python Wrapper for l0learn', +# maintainer='Tim Nonet', +# package_data={'l0learn': ['l0learn/l0learn/*.pyx', 'l0learn/l0learn/*.pxd']}, +# cmdclass={'build_ext': build_ext}, +# language_level=3, +# ext_modules=cythonize(ext_modules), +# ) + +import os +from setuptools import setup, find_packages, Extension +import numpy as np + +try: + from Cython.Build import cythonize +except ImportError: + cythonize = None + +try: + from psutil import cpu_count + + psutil_found = True +except ImportError: + psutil_found = False + +from Cython.Distutils import build_ext + + +# https://cython.readthedocs.io/en/latest/src/userguide/source_files_and_compilation.html#distributing-cython-modules +def no_cythonize(extensions, **_ignore): + for extension in extensions: + sources = [] + for sfile in extension.sources: + path, ext = os.path.splitext(sfile) + if ext in (".pyx", ".py"): + if extension.language == "c++": + ext = ".cpp" + else: + ext = ".c" + sfile = path + ext + sources.append(sfile) + extension.sources[:] = sources + return extensions + + +if psutil_found: + os.environ["CMAKE_BUILD_PARALLEL_LEVEL"] = str(cpu_count(logical=False)) + +extensions = [ + Extension(name='l0learn.cyarma', + sources=["l0learn/cyarma.pyx"], + include_dirs=['.', np.get_include()], # "usr/local/Cellar/armadillo/10.1.1/include" + language="c++", + libraries=["armadillo", "lapack", "blas"], + extra_compile_args=["-std=c++11"], + extra_link_args=["-std=c++11"], + # define_macros=[("NPY_NO_DEPRECATED_API", "NPY_1_7_API_VERSION")], + ), + Extension(name='l0learn.testing_utils', + sources=["l0learn/testing_utils.pyx"], + include_dirs=['.', np.get_include()], + language="c++", + libraries=["armadillo", "lapack", "blas"], + extra_compile_args=["-std=c++11"], + extra_link_args=["-std=c++11"], + # define_macros=[("NPY_NO_DEPRECATED_API", "NPY_1_7_API_VERSION")], + ), + Extension(name="l0learn.interface", + sources=["l0learn/interface.pyx", + "l0learn/src/CDL012LogisticSwaps.cpp", + "l0learn/src/Grid2D.cpp", + "l0learn/src/CDL012SquaredHingeSwaps.cpp", + "l0learn/src/Normalize.cpp", + "l0learn/src/CDL012Swaps.cpp", + "l0learn/src/Grid.cpp", + "l0learn/src/Grid1D.cpp" + ], + include_dirs=['.', np.get_include(), "l0learn/src/include"], + language="c++", + libraries=["armadillo", "lapack", "blas"], + extra_compile_args=["-std=c++11"], + extra_link_args=["-std=c++11"]), + # Extension("l0learn_src", + # sources=[ + # "l0learn/src/CDL012LogisticSwaps.cpp", + # "l0learn/src/Grid2D.cpp", + # "l0learn/src/CDL012SquaredHingeSwaps.cpp", + # "l0learn/src/Normalize.cpp", + # "l0learn/src/CDL012Swaps.cpp", + # "l0learn/src/Grid.cpp", + # "l0learn/src/Grid1D.cpp" + # ], + # include_dirs=["l0learn/src/include"], + # extra_compile_args=["-std=c++11"], + # extra_link_args=["-std=c++11"], + # ) +] + +CYTHONIZE = bool(int(os.getenv("CYTHONIZE", 0))) and cythonize is not None +if True: + compiler_directives = {"language_level": 3, "embedsignature": True} + extensions = cythonize(extensions, compiler_directives=compiler_directives) +else: + extensions = no_cythonize(extensions) + +# with open("requirements.txt") as fp: +# install_requires = fp.read().strip().split("\n") +# +# with open("requirements-dev.txt") as fp: +# dev_requires = fp.read().strip().split("\n") + +""" +Installation Notes; +How to ensure proper underlying armadillo is installed? + MacOsX: brew install armadillo --with-hdf5 +""" + +install_requires = ['numpy', 'h5py'] + +setup( + ext_modules=extensions, + name='l0learn', + description='Python Wrapper for L0Learn', + maintainer='Tim Nonet', + install_requires=['cython'], + cmdclass={'build_ext': build_ext} +) + +# setup( +# ext_modules=extensions, +# install_requires=install_requires, +# extras_require={ +# "dev": dev_requires, +# "docs": ["sphinx", "sphinx-rtd-theme"] +# }, +# ) diff --git a/python/tests/test_cyarma.py b/python/tests/test_cyarma.py new file mode 100644 index 0000000..4889338 --- /dev/null +++ b/python/tests/test_cyarma.py @@ -0,0 +1,87 @@ +import numpy as np +from scipy.sparse import csc_matrix +from hypothesis import given, assume +from hypothesis.extra import numpy as npst +from hypothesis.strategies import floats, integers, lists + +from l0learn.testing_utils import (list_dvec_to_arma_dvec_to_list, + list_csc_to_arma_csc_to_list, + dmat_np_to_arma_to_np, + dvec_np_to_arma_to_np, + uvec_np_to_arma_to_np, + sp_dmat_np_to_arma_to_np, + dmat_dot_dmat) + + +@given(npst.arrays(np.float64, shape=npst.array_shapes(min_dims=2, max_dims=2, max_side=100))) +def test_dmat_np_to_arma_to_np(arr): + arr = np.asfortranarray(arr) + arr2 = dmat_np_to_arma_to_np(arr) + np.testing.assert_array_equal(arr2, arr) + + +@given(npst.arrays(np.float64, shape=npst.array_shapes(min_dims=1, max_dims=1, max_side=100))) +def test_dvec_np_to_arma_to_np(arr): + arr = np.asfortranarray(arr) + arr2 = dvec_np_to_arma_to_np(arr) + np.testing.assert_array_equal(arr2, arr) + + +@given(npst.arrays(np.uint64, shape=npst.array_shapes(min_dims=1, max_dims=1, max_side=100), + elements=integers(0, 1000))) +def test_uvec_np_to_arma_to_np(arr): + arr = np.asfortranarray(arr) + arr = arr.astype(np.uint64) + arr2 = uvec_np_to_arma_to_np(arr) + np.testing.assert_array_equal(arr2, arr) + + +@given(npst.arrays(np.float64, + shape=npst.array_shapes(min_dims=2, max_dims=2, min_side=1, max_side=100), + elements=floats()), + floats(0, 1)) +def test_sp_dmat_np_to_arma_to_np(arr, thr): + arr[abs(arr) >= thr] = 0.0 + assume(np.sum(arr != 0) > 1) + arr = csc_matrix(arr) + arr2 = sp_dmat_np_to_arma_to_np(arr) + np.testing.assert_array_equal(arr2.toarray(), arr.toarray()) + + +@given(lists(elements=npst.arrays(np.float64, + shape=npst.array_shapes(min_dims=2, max_dims=2, min_side=1, max_side=100), + elements=floats()), + min_size=1), + floats(0, 1)) +def test_sp_dmat_field_np_to_arma_to_np(lst, thr): + for i, arr in enumerate(lst): + arr[abs(arr) >= thr] = 0.0 + assume(np.sum(arr != 0) > 1) + lst[i] = csc_matrix(arr) + + lst2 = list_csc_to_arma_csc_to_list(lst) + for arr, arr2 in zip(lst, lst2): + np.testing.assert_array_equal(arr.toarray(), arr2.toarray()) + +@given(lists(elements=npst.arrays(np.float64, + shape=npst.array_shapes(min_dims=1, max_dims=1, min_side=1, max_side=100), + elements=floats()), + min_size=1)) +def test_dvec_field_np_to_arma_to_np(lst): + lst2 = list_dvec_to_arma_dvec_to_list(lst) + for arr, arr2 in zip(lst, lst2): + np.testing.assert_array_equal(arr, arr2) + + +@given(n=integers(min_value=1, max_value=100), + p=integers(min_value=1, max_value=100), + k=integers(min_value=1, max_value=100)) +def test_dmat_dot_dmat(n, p, k): + arr = np.random.random((n, p)) + arr = np.asfortranarray(arr) + + x = np.random.random((p, k)) + x = np.asfortranarray(x) + + arr2 = dmat_dot_dmat(arr, x) + np.testing.assert_array_almost_equal(arr2, arr.dot(x)) From 7c0374c2e775350a8efdfd1bb62a7343482a55ea Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Sat, 18 Sep 2021 08:50:35 -0500 Subject: [PATCH 004/125] Fixed error handling infinite snr parameter in GenSynthetic --- R/R/gensynthetic.R | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/R/R/gensynthetic.R b/R/R/gensynthetic.R index f5ecd04..f779901 100644 --- a/R/R/gensynthetic.R +++ b/R/R/gensynthetic.R @@ -1,9 +1,11 @@ #' @importFrom stats rnorm var #' @title Generate Synthetic Data #' -#' @description Generates a synthetic dataset as follows: 1) Sample every element in data matrix X from N(0,1). -#' 2) Generate a vector B with the first k entries set to 1 and the rest are zeros. 3) Sample every element in the noise -#' vector e from N(0,1). 4) Set y = XB + b0 + e. +#' @description Generates a synthetic dataset as follows: +#' 1) Sample every element in data matrix X from N(0,1). +#' 2) Generate a vector B with the first k entries set to 1 and the rest are zeros. +#' 3) Sample every element in the noise vector e from N(0,A) where A is selected so y, X, B have snr as specified. +#' 4) Set y = XB + b0 + e. #' @param n Number of samples #' @param p Number of features #' @param k Number of non-zeros in true vector of coefficients @@ -30,11 +32,13 @@ GenSynthetic <- function(n, p, k, seed, rho=0, b0=0, snr=1) X[abs(X) < rho] <- 0. B = c(rep(1,k),rep(0,p-k)) sd_e = NULL + if (snr == +Inf){ - sd_e = sqrt(var(X %*% B)/snr) - } else { sd_e = 0 + } else { + sd_e = sqrt(var(X %*% B)/snr) } + e = rnorm(n, sd = sd_e) y = X%*%B + e + b0 list(X=X, y=y, B=B, e=e, b0=b0) From f834644a0de9b9d6cc076cac2a5837592d2f18b1 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Sat, 18 Sep 2021 08:50:58 -0500 Subject: [PATCH 005/125] Fixed error in documentation of genlogistic --- R/R/genlogistic.R | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/R/R/genlogistic.R b/R/R/genlogistic.R index b8607b8..570d31b 100644 --- a/R/R/genlogistic.R +++ b/R/R/genlogistic.R @@ -5,7 +5,7 @@ #' @description Generates a synthetic dataset as follows: 1) Generate a data matrix, #' X, drawn from a multivariate Gaussian distribution with mean = 0, sigma = Sigma #' 2) Generate a vector B with k entries set to 1 and the rest are zeros. -#' 3) Every coordinate yi of the outcome vector y exists in {-1, 1}^n is sampled +#' 3) Every coordinate yi of the outcome vector y exists in {0, 1}^n is sampled #' independently from a Bernoulli distribution with success probability: #' P(yi = 1|xi) = 1/(1 + exp(-s)) #' Source https://arxiv.org/pdf/2001.06471.pdf Section 5.1 Data Generation From 2bd2b68df599cbfc0688456f5780c1349fc750fa Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Sat, 18 Sep 2021 08:57:58 -0500 Subject: [PATCH 006/125] updating python API to use FitModel and CVFitModel --- python/l0learn/__init__.py | 1 + python/l0learn/cyarma.pxd | 3 +- python/l0learn/interface.cpp | 8578 ++++++++++++++++++---------------- python/l0learn/interface.pyx | 339 +- python/l0learn/utils.py | 654 +++ python/tests/test_utils.py | 58 + 6 files changed, 5587 insertions(+), 4046 deletions(-) create mode 100644 python/l0learn/__init__.py create mode 100644 python/l0learn/utils.py create mode 100644 python/tests/test_utils.py diff --git a/python/l0learn/__init__.py b/python/l0learn/__init__.py new file mode 100644 index 0000000..d0d796c --- /dev/null +++ b/python/l0learn/__init__.py @@ -0,0 +1 @@ +from l0learn.interface import fit, cvfit diff --git a/python/l0learn/cyarma.pxd b/python/l0learn/cyarma.pxd index d9809e5..a1c695c 100644 --- a/python/l0learn/cyarma.pxd +++ b/python/l0learn/cyarma.pxd @@ -1,4 +1,5 @@ # distutils: language = c++ +from dataclasses import dataclass from libcpp cimport bool cimport numpy as np @@ -109,4 +110,4 @@ cdef np.ndarray[np.double_t, ndim=1] dvec_to_numpy(const dvec & X, np.ndarray[np cdef np.ndarray[np.uint64_t, ndim=1] uvec_to_numpy(const uvec & X, np.ndarray[np.uint64_t, ndim=1] D) cdef sp_dmat_to_numpy(const sp_dmat & X, np.ndarray[np.uint64_t, ndim=1] rowind, - np.ndarray[np.uint64_t, ndim=1] colptr, np.ndarray[np.double_t, ndim=1] values) \ No newline at end of file + np.ndarray[np.uint64_t, ndim=1] colptr, np.ndarray[np.double_t, ndim=1] values) diff --git a/python/l0learn/interface.cpp b/python/l0learn/interface.cpp index a5dba29..c465e5e 100644 --- a/python/l0learn/interface.cpp +++ b/python/l0learn/interface.cpp @@ -1237,6 +1237,53 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); +/* PyDictVersioning.proto */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) +#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ + (version_var) = __PYX_GET_DICT_VERSION(dict);\ + (cache_var) = (value); +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ + (VAR) = __pyx_dict_cached_value;\ + } else {\ + (VAR) = __pyx_dict_cached_value = (LOOKUP);\ + __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ + }\ +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); +#else +#define __PYX_GET_DICT_VERSION(dict) (0) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); +#endif + +/* GetModuleGlobalName.proto */ +#if CYTHON_USE_DICT_VERSIONS +#define __Pyx_GetModuleGlobalName(var, name) {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ + (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ + __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} +#define __Pyx_GetModuleGlobalNameUncached(var, name) {\ + PY_UINT64_T __pyx_dict_version;\ + PyObject *__pyx_dict_cached_value;\ + (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); +#else +#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) +#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); +#endif + /* DictGetItem.proto */ #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); @@ -1294,53 +1341,6 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); -/* PyDictVersioning.proto */ -#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS -#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) -#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) -#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ - (version_var) = __PYX_GET_DICT_VERSION(dict);\ - (cache_var) = (value); -#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ - static PY_UINT64_T __pyx_dict_version = 0;\ - static PyObject *__pyx_dict_cached_value = NULL;\ - if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ - (VAR) = __pyx_dict_cached_value;\ - } else {\ - (VAR) = __pyx_dict_cached_value = (LOOKUP);\ - __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ - }\ -} -static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); -static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); -static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); -#else -#define __PYX_GET_DICT_VERSION(dict) (0) -#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) -#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); -#endif - -/* GetModuleGlobalName.proto */ -#if CYTHON_USE_DICT_VERSIONS -#define __Pyx_GetModuleGlobalName(var, name) {\ - static PY_UINT64_T __pyx_dict_version = 0;\ - static PyObject *__pyx_dict_cached_value = NULL;\ - (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ - (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ - __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ -} -#define __Pyx_GetModuleGlobalNameUncached(var, name) {\ - PY_UINT64_T __pyx_dict_version;\ - PyObject *__pyx_dict_cached_value;\ - (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ -} -static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); -#else -#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) -#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) -static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); -#endif - /* PyObjectFormatSimple.proto */ #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyObject_FormatSimple(s, f) (\ @@ -1462,6 +1462,10 @@ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int eq /* UnicodeEquals.proto */ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); +/* PyUnicode_Substring.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_Substring( + PyObject* text, Py_ssize_t start, Py_ssize_t stop); + /* BuildPyUnicode.proto */ static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, char* chars, int clength, int prepend_sign, char padding_char); @@ -1795,10 +1799,10 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_sparse(arma::sp_dmat co static std::vector __pyx_convert_vector_from_py_double(PyObject *); /*proto*/ static std::vector > __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(PyObject *); /*proto*/ static std::string __pyx_convert_string_from_py_std__in_string(PyObject *); /*proto*/ -static PyObject *__pyx_convert_vector_to_py_size_t(const std::vector &); /*proto*/ -static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(const std::vector > &); /*proto*/ static PyObject *__pyx_convert_vector_to_py_double(const std::vector &); /*proto*/ static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(const std::vector > &); /*proto*/ +static PyObject *__pyx_convert_vector_to_py_size_t(const std::vector &); /*proto*/ +static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(const std::vector > &); /*proto*/ static PyObject *__pyx_convert_vector_to_py_bool(const std::vector &); /*proto*/ static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(const std::vector > &); /*proto*/ #define __Pyx_MODULE_NAME "l0learn.interface" @@ -1815,6 +1819,7 @@ static PyObject *__pyx_builtin_TypeError; static PyObject *__pyx_builtin_ImportError; static PyObject *__pyx_builtin_range; static const char __pyx_k_X[] = "X"; +static const char __pyx_k_a[] = "a"; static const char __pyx_k_i[] = "i"; static const char __pyx_k_n[] = "n"; static const char __pyx_k_p[] = "p"; @@ -1824,17 +1829,18 @@ static const char __pyx_k_L0[] = "L0"; static const char __pyx_k__5[] = "."; static const char __pyx_k_np[] = "np"; static const char __pyx_k_or[] = " or "; +static const char __pyx_k__18[] = "_"; static const char __pyx_k_all[] = "all"; static const char __pyx_k_any[] = "any"; static const char __pyx_k_arr[] = "arr"; static const char __pyx_k_fit[] = "fit"; static const char __pyx_k_inf[] = "inf"; -static const char __pyx_k_Beta[] = "Beta"; static const char __pyx_k_L0L1[] = "L0L1"; static const char __pyx_k_L0L2[] = "L0L2"; static const char __pyx_k_List[] = "List"; static const char __pyx_k_None[] = "None"; static const char __pyx_k_atol[] = "atol"; +static const char __pyx_k_copy[] = "copy"; static const char __pyx_k_data[] = "data"; static const char __pyx_k_diff[] = "diff"; static const char __pyx_k_loss[] = "loss"; @@ -1846,42 +1852,47 @@ static const char __pyx_k_ones[] = "ones"; static const char __pyx_k_rtol[] = "rtol"; static const char __pyx_k_seed[] = "seed"; static const char __pyx_k_test[] = "__test__"; +static const char __pyx_k_warn[] = "warn"; static const char __pyx_k_CDPSI[] = "CDPSI"; -static const char __pyx_k_CVSDs[] = "CVSDs"; static const char __pyx_k_Union[] = "Union"; static const char __pyx_k_array[] = "array"; static const char __pyx_k_cvfit[] = "cvfit"; static const char __pyx_k_dtype[] = "dtype"; static const char __pyx_k_flags[] = "flags"; +static const char __pyx_k_gamma[] = "gamma"; static const char __pyx_k_highs[] = "highs"; static const char __pyx_k_numpy[] = "numpy"; static const char __pyx_k_range[] = "range"; static const char __pyx_k_shape[] = "shape"; static const char __pyx_k_c_loss[] = "c_loss"; +static const char __pyx_k_coeffs[] = "coeffs"; +static const char __pyx_k_cv_sds[] = "cv_sds"; static const char __pyx_k_import[] = "__import__"; static const char __pyx_k_indptr[] = "indptr"; static const char __pyx_k_number[] = "number"; static const char __pyx_k_typing[] = "typing"; static const char __pyx_k_unique[] = "unique"; -static const char __pyx_k_CVMeans[] = "CVMeans"; -static const char __pyx_k_Lambda0[] = "Lambda0"; static const char __pyx_k_but_got[] = ", but got "; static const char __pyx_k_current[] = "current"; static const char __pyx_k_indices[] = "indices"; +static const char __pyx_k_ndarray[] = "ndarray"; static const char __pyx_k_penalty[] = "penalty"; static const char __pyx_k_product[] = "product"; static const char __pyx_k_results[] = "results"; -static const char __pyx_k_Lambda12[] = "Lambda12"; +static const char __pyx_k_FitModel[] = "FitModel"; static const char __pyx_k_Logistic[] = "Logistic"; -static const char __pyx_k_NnzCount[] = "NnzCount"; static const char __pyx_k_Optional[] = "Optional"; static const char __pyx_k_argwhere[] = "argwhere"; +static const char __pyx_k_cv_means[] = "cv_means"; +static const char __pyx_k_lambda_0[] = "lambda_0"; static const char __pyx_k_max_iter[] = "max_iter"; -static const char __pyx_k_Converged[] = "Converged"; -static const char __pyx_k_Intercept[] = "Intercept"; +static const char __pyx_k_settings[] = "settings"; +static const char __pyx_k_warnings[] = "warnings"; static const char __pyx_k_TypeError[] = "TypeError"; static const char __pyx_k_algorithm[] = "algorithm"; static const char __pyx_k_c_penalty[] = "c_penalty"; +static const char __pyx_k_c_results[] = "c_results"; +static const char __pyx_k_converged[] = "converged"; static const char __pyx_k_enumerate[] = "enumerate"; static const char __pyx_k_gamma_max[] = "gamma_max"; static const char __pyx_k_gamma_min[] = "gamma_min"; @@ -1890,10 +1901,12 @@ static const char __pyx_k_isrealobj[] = "isrealobj"; static const char __pyx_k_max_swaps[] = "max_swaps"; static const char __pyx_k_num_folds[] = "num_folds"; static const char __pyx_k_num_gamma[] = "num_gamma"; +static const char __pyx_k_CVFitModel[] = "CVFitModel"; static const char __pyx_k_ValueError[] = "ValueError"; static const char __pyx_k_active_set[] = "active_set"; static const char __pyx_k_bad_bounds[] = "bad_bounds"; static const char __pyx_k_csc_matrix[] = "csc_matrix"; +static const char __pyx_k_intercepts[] = "intercepts"; static const char __pyx_k_issubdtype[] = "issubdtype"; static const char __pyx_k_num_lambda[] = "num_lambda"; static const char __pyx_k_ImportError[] = "ImportError"; @@ -1907,8 +1920,11 @@ static const char __pyx_k_SquaredHinge[] = "SquaredHinge"; static const char __pyx_k_c_algorithim[] = "c_algorithim"; static const char __pyx_k_partial_sort[] = "partial_sort"; static const char __pyx_k_scipy_sparse[] = "scipy.sparse"; +static const char __pyx_k_support_size[] = "support_size"; +static const char __pyx_k_unique_items[] = "unique_items"; static const char __pyx_k_Not_supported[] = ". Not supported"; static const char __pyx_k_c_lambda_grid[] = "c_lambda_grid"; +static const char __pyx_k_l0learn_utils[] = "l0learn.utils"; static const char __pyx_k_SUPPORTED_LOSS[] = "SUPPORTED_LOSS"; static const char __pyx_k_active_set_num[] = "active_set_num"; static const char __pyx_k_bad_lambda_grid[] = "bad_lambda_grid"; @@ -1916,6 +1932,7 @@ static const char __pyx_k_exclude_first_k[] = "exclude_first_k"; static const char __pyx_k_sub_lambda_grid[] = "sub_lambda_grid"; static const char __pyx_k_max_support_size[] = "max_support_size"; static const char __pyx_k_np_to_arma_check[] = "np_to_arma_check"; +static const char __pyx_k_penalty_Only_one[] = " penalty. Only one "; static const char __pyx_k_SUPPORTED_PENALTY[] = "SUPPORTED_PENALTY"; static const char __pyx_k_l0learn_interface[] = "l0learn.interface"; static const char __pyx_k_scale_down_factor[] = "scale_down_factor"; @@ -1924,6 +1941,8 @@ static const char __pyx_k_CLASSIFICATION_LOSS[] = "CLASSIFICATION_LOSS"; static const char __pyx_k_NotImplementedError[] = "NotImplementedError"; static const char __pyx_k_SUPPORTED_ALGORITHM[] = "SUPPORTED_ALGORITHM"; static const char __pyx_k_l0learn_interface_pyx[] = "l0learn/interface.pyx"; +static const char __pyx_k_num_gamma_set_to_1_with[] = "num_gamma set to 1 with "; +static const char __pyx_k_penalty_value_will_be_fit[] = " penalty value will be fit."; static const char __pyx_k_expected_arr_to_be_of_type[] = "expected arr to be of type "; static const char __pyx_k_where_that_is_not_the_case[] = " where that is not the case "; static const char __pyx_k_containing_a_negative_value[] = "] containing a negative value"; @@ -1968,37 +1987,32 @@ static const char __pyx_k_expected_numerical_dtype_but_got[] = "expected numeric static const char __pyx_k_expected_penalty_parameter_to_be[] = "expected penalty parameter to be on of "; static const char __pyx_k_expected_rtol_parameter_to_exist[] = "expected rtol parameter to exist in [0, 1), but got "; static const char __pyx_k_expected_scale_down_factor_param[] = "expected scale_down_factor parameter to exist in (0, 1), but got "; -static const char __pyx_k_expected_screen_size_parameter_t[] = "expected screen_size parameter to be a positive integer, but got "; +static const char __pyx_k_expected_screen_size_parameter_t[] = "expected screen_size parameter to be a positive integer less than "; static const char __pyx_k_expected_seed_parameter_to_be_an[] = "expected seed parameter to be an integer, but got "; static const char __pyx_k_expected_to_be_high_to_be_elemen[] = "expected to be high to be elementwise greater than lows, but got indices "; static const char __pyx_k_expected_y_to_be_a_1D_real_numpy[] = "expected y to be a 1D real numpy, but got "; -static const char __pyx_k_expected_y_vector_to_only_have_t[] = "expected y vector to only have two unique values (-1 and 1) (Binary Classification), but got "; +static const char __pyx_k_expected_y_vector_to_only_have_t[] = "expected y vector to only have two unique values (Binary Classification), but got "; static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import"; static const char __pyx_k_expected_gamma_max_parameter_to_2[] = "expected gamma_max parameter to be a positive float less than gamma_max, but got "; static const char __pyx_k_expected_arr_ndim_to_be_1_or_2_b_2[] = "expected 'arr.ndim' to be 1 or 2, but got "; static const char __pyx_k_expected_highs_to_be_a_non_negat_2[] = "expected highs to be a non-negative float, or a 1D numpy array of length "; static const char __pyx_k_expected_lows_to_be_a_non_positi_2[] = "expected lows to be a non-positive float, or a 1D numpy array of length "; -static PyObject *__pyx_n_u_Beta; +static const char __pyx_k_expected_screen_size_parameter_t_2[] = "expected screen_size parameter to be a positive integer, but got "; static PyObject *__pyx_n_u_CD; static PyObject *__pyx_n_u_CDPSI; static PyObject *__pyx_n_s_CLASSIFICATION_LOSS; -static PyObject *__pyx_n_u_CVMeans; -static PyObject *__pyx_n_u_CVSDs; -static PyObject *__pyx_n_u_Converged; +static PyObject *__pyx_n_s_CVFitModel; static PyObject *__pyx_kp_u_Expected_all_values_of_lambda_gr; static PyObject *__pyx_kp_u_Expected_each_element_of_lambda; static PyObject *__pyx_n_u_F_CONTIGUOUS; +static PyObject *__pyx_n_s_FitModel; static PyObject *__pyx_n_s_ImportError; -static PyObject *__pyx_n_u_Intercept; static PyObject *__pyx_n_u_L0; static PyObject *__pyx_n_u_L0L1; static PyObject *__pyx_n_u_L0L2; static PyObject *__pyx_kp_u_L0_Penalty_requires_lambda_grid; -static PyObject *__pyx_n_u_Lambda0; -static PyObject *__pyx_n_u_Lambda12; static PyObject *__pyx_n_s_List; static PyObject *__pyx_n_u_Logistic; -static PyObject *__pyx_n_u_NnzCount; static PyObject *__pyx_kp_u_None; static PyObject *__pyx_n_s_NotImplementedError; static PyObject *__pyx_kp_u_Not_supported; @@ -2012,7 +2026,9 @@ static PyObject *__pyx_n_s_TypeError; static PyObject *__pyx_n_s_Union; static PyObject *__pyx_n_s_ValueError; static PyObject *__pyx_n_s_X; +static PyObject *__pyx_n_s__18; static PyObject *__pyx_kp_u__5; +static PyObject *__pyx_n_s_a; static PyObject *__pyx_n_s_active_set; static PyObject *__pyx_n_s_active_set_num; static PyObject *__pyx_n_s_algorithm; @@ -2030,11 +2046,17 @@ static PyObject *__pyx_n_s_c_algorithim; static PyObject *__pyx_n_s_c_lambda_grid; static PyObject *__pyx_n_s_c_loss; static PyObject *__pyx_n_s_c_penalty; +static PyObject *__pyx_n_s_c_results; static PyObject *__pyx_n_s_cline_in_traceback; +static PyObject *__pyx_n_s_coeffs; static PyObject *__pyx_kp_u_containing_a_negative_value; static PyObject *__pyx_kp_u_containing_an_increasing_value; +static PyObject *__pyx_n_s_converged; +static PyObject *__pyx_n_s_copy; static PyObject *__pyx_n_s_csc_matrix; static PyObject *__pyx_n_s_current; +static PyObject *__pyx_n_s_cv_means; +static PyObject *__pyx_n_s_cv_sds; static PyObject *__pyx_n_s_cvfit; static PyObject *__pyx_n_s_data; static PyObject *__pyx_n_s_diff; @@ -2081,12 +2103,14 @@ static PyObject *__pyx_kp_u_expected_penalty_parameter_to_be; static PyObject *__pyx_kp_u_expected_rtol_parameter_to_exist; static PyObject *__pyx_kp_u_expected_scale_down_factor_param; static PyObject *__pyx_kp_u_expected_screen_size_parameter_t; +static PyObject *__pyx_kp_u_expected_screen_size_parameter_t_2; static PyObject *__pyx_kp_u_expected_seed_parameter_to_be_an; static PyObject *__pyx_kp_u_expected_to_be_high_to_be_elemen; static PyObject *__pyx_kp_u_expected_y_to_be_a_1D_real_numpy; static PyObject *__pyx_kp_u_expected_y_vector_to_only_have_t; static PyObject *__pyx_n_s_fit; static PyObject *__pyx_n_s_flags; +static PyObject *__pyx_n_s_gamma; static PyObject *__pyx_n_s_gamma_max; static PyObject *__pyx_n_s_gamma_min; static PyObject *__pyx_n_s_highs; @@ -2096,12 +2120,17 @@ static PyObject *__pyx_n_s_indices; static PyObject *__pyx_n_s_indptr; static PyObject *__pyx_n_u_inf; static PyObject *__pyx_n_s_intercept; +static PyObject *__pyx_n_u_intercept; +static PyObject *__pyx_n_s_intercepts; static PyObject *__pyx_n_s_isrealobj; static PyObject *__pyx_n_s_issubdtype; static PyObject *__pyx_n_s_l0learn_interface; static PyObject *__pyx_kp_s_l0learn_interface_pyx; +static PyObject *__pyx_n_s_l0learn_utils; +static PyObject *__pyx_n_s_lambda_0; static PyObject *__pyx_n_s_lambda_grid; static PyObject *__pyx_n_s_loss; +static PyObject *__pyx_n_u_loss; static PyObject *__pyx_n_s_lows; static PyObject *__pyx_n_s_main; static PyObject *__pyx_n_s_max_iter; @@ -2109,11 +2138,13 @@ static PyObject *__pyx_n_s_max_support_size; static PyObject *__pyx_n_s_max_swaps; static PyObject *__pyx_n_s_n; static PyObject *__pyx_n_s_name; +static PyObject *__pyx_n_s_ndarray; static PyObject *__pyx_n_s_ndim; static PyObject *__pyx_n_s_np; static PyObject *__pyx_n_s_np_to_arma_check; static PyObject *__pyx_n_s_num_folds; static PyObject *__pyx_n_s_num_gamma; +static PyObject *__pyx_kp_u_num_gamma_set_to_1_with; static PyObject *__pyx_n_s_num_lambda; static PyObject *__pyx_n_s_number; static PyObject *__pyx_n_s_numpy; @@ -2126,6 +2157,9 @@ static PyObject *__pyx_kp_u_or; static PyObject *__pyx_n_s_p; static PyObject *__pyx_n_s_partial_sort; static PyObject *__pyx_n_s_penalty; +static PyObject *__pyx_n_u_penalty; +static PyObject *__pyx_kp_u_penalty_Only_one; +static PyObject *__pyx_kp_u_penalty_value_will_be_fit; static PyObject *__pyx_n_s_product; static PyObject *__pyx_n_s_range; static PyObject *__pyx_n_s_results; @@ -2134,17 +2168,22 @@ static PyObject *__pyx_n_s_scale_down_factor; static PyObject *__pyx_n_s_scipy_sparse; static PyObject *__pyx_n_s_screen_size; static PyObject *__pyx_n_s_seed; +static PyObject *__pyx_n_s_settings; static PyObject *__pyx_n_s_shape; static PyObject *__pyx_n_s_sub_lambda_grid; +static PyObject *__pyx_n_s_support_size; static PyObject *__pyx_n_s_test; static PyObject *__pyx_n_s_typing; static PyObject *__pyx_n_s_unique; +static PyObject *__pyx_n_s_unique_items; +static PyObject *__pyx_n_s_warn; +static PyObject *__pyx_n_s_warnings; static PyObject *__pyx_kp_u_where_that_is_not_the_case; static PyObject *__pyx_n_s_with_bounds; static PyObject *__pyx_n_s_y; static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_arr); /* proto */ -static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyArrayObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs); /* proto */ -static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyArrayObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_num_folds, PyObject *__pyx_v_seed, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs); /* proto */ +static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs); /* proto */ +static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_num_folds, PyObject *__pyx_v_seed, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs); /* proto */ static PyObject *__pyx_float_0_; static PyObject *__pyx_int_0; static PyObject *__pyx_int_1; @@ -2170,15 +2209,15 @@ static PyObject *__pyx_tuple__13; static PyObject *__pyx_tuple__15; static PyObject *__pyx_tuple__16; static PyObject *__pyx_tuple__17; -static PyObject *__pyx_tuple__18; -static PyObject *__pyx_tuple__20; +static PyObject *__pyx_tuple__19; +static PyObject *__pyx_tuple__21; static PyObject *__pyx_codeobj__14; -static PyObject *__pyx_codeobj__19; -static PyObject *__pyx_codeobj__21; +static PyObject *__pyx_codeobj__20; +static PyObject *__pyx_codeobj__22; /* Late includes */ -/* "l0learn/interface.pyx":26 - * +/* "l0learn/interface.pyx":15 + * from l0learn.utils import FitModel, CVFitModel * * def np_to_arma_check(arr): # <<<<<<<<<<<<<< * # TODO: Add checks for Behaved and OwnsData @@ -2203,10 +2242,10 @@ static PyObject *__pyx_pw_7l0learn_9interface_1np_to_arma_check(PyObject *__pyx_ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_arr) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_t_2; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_t_4; Py_ssize_t __pyx_t_5; Py_UCS4 __pyx_t_6; PyObject *__pyx_t_7 = NULL; @@ -2219,48 +2258,54 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO int __pyx_clineno = 0; __Pyx_RefNannySetupContext("np_to_arma_check", 0); - /* "l0learn/interface.pyx":28 + /* "l0learn/interface.pyx":17 * def np_to_arma_check(arr): * # TODO: Add checks for Behaved and OwnsData * if isinstance(arr, np.ndarray): # <<<<<<<<<<<<<< * if not arr.flags['F_CONTIGUOUS']: * raise ValueError("expected arr to be F_CONTIGUOUS.") */ - __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_arr, __pyx_ptype_5numpy_ndarray); - __pyx_t_2 = (__pyx_t_1 != 0); - if (__pyx_t_2) { + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = PyObject_IsInstance(__pyx_v_arr, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 17, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = (__pyx_t_3 != 0); + if (__pyx_t_4) { - /* "l0learn/interface.pyx":29 + /* "l0learn/interface.pyx":18 * # TODO: Add checks for Behaved and OwnsData * if isinstance(arr, np.ndarray): * if not arr.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< * raise ValueError("expected arr to be F_CONTIGUOUS.") * elif isinstance(arr, csc_matrix): */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 29, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_n_u_F_CONTIGUOUS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 29, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 29, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_1 = ((!__pyx_t_2) != 0); - if (unlikely(__pyx_t_1)) { + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_n_u_F_CONTIGUOUS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 18, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = ((!__pyx_t_4) != 0); + if (unlikely(__pyx_t_3)) { - /* "l0learn/interface.pyx":30 + /* "l0learn/interface.pyx":19 * if isinstance(arr, np.ndarray): * if not arr.flags['F_CONTIGUOUS']: * raise ValueError("expected arr to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< * elif isinstance(arr, csc_matrix): * if not arr.data.flags['F_CONTIGUOUS']: */ - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 30, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_Raise(__pyx_t_4, 0, 0, 0); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(0, 30, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 19, __pyx_L1_error) - /* "l0learn/interface.pyx":29 + /* "l0learn/interface.pyx":18 * # TODO: Add checks for Behaved and OwnsData * if isinstance(arr, np.ndarray): * if not arr.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< @@ -2269,7 +2314,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO */ } - /* "l0learn/interface.pyx":28 + /* "l0learn/interface.pyx":17 * def np_to_arma_check(arr): * # TODO: Add checks for Behaved and OwnsData * if isinstance(arr, np.ndarray): # <<<<<<<<<<<<<< @@ -2279,54 +2324,54 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO goto __pyx_L3; } - /* "l0learn/interface.pyx":31 + /* "l0learn/interface.pyx":20 * if not arr.flags['F_CONTIGUOUS']: * raise ValueError("expected arr to be F_CONTIGUOUS.") * elif isinstance(arr, csc_matrix): # <<<<<<<<<<<<<< * if not arr.data.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.data to be F_CONTIGUOUS.") */ - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 31, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_1 = PyObject_IsInstance(__pyx_v_arr, __pyx_t_4); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 31, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_2 = (__pyx_t_1 != 0); - if (likely(__pyx_t_2)) { + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PyObject_IsInstance(__pyx_v_arr, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_4 = (__pyx_t_3 != 0); + if (likely(__pyx_t_4)) { - /* "l0learn/interface.pyx":32 + /* "l0learn/interface.pyx":21 * raise ValueError("expected arr to be F_CONTIGUOUS.") * elif isinstance(arr, csc_matrix): * if not arr.data.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< * raise ValueError("expected arr.data to be F_CONTIGUOUS.") * if not arr.indices.flags['F_CONTIGUOUS']: */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_data); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 32, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 32, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_n_u_F_CONTIGUOUS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 32, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 32, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_1 = ((!__pyx_t_2) != 0); - if (unlikely(__pyx_t_1)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 21, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_n_u_F_CONTIGUOUS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 21, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = ((!__pyx_t_4) != 0); + if (unlikely(__pyx_t_3)) { - /* "l0learn/interface.pyx":33 + /* "l0learn/interface.pyx":22 * elif isinstance(arr, csc_matrix): * if not arr.data.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.data to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< * if not arr.indices.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") */ - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 33, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_Raise(__pyx_t_4, 0, 0, 0); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(0, 33, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 22, __pyx_L1_error) - /* "l0learn/interface.pyx":32 + /* "l0learn/interface.pyx":21 * raise ValueError("expected arr to be F_CONTIGUOUS.") * elif isinstance(arr, csc_matrix): * if not arr.data.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< @@ -2335,40 +2380,40 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO */ } - /* "l0learn/interface.pyx":34 + /* "l0learn/interface.pyx":23 * if not arr.data.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.data to be F_CONTIGUOUS.") * if not arr.indices.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") * if not arr.indptr.flags['F_CONTIGUOUS']: */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_indices); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 34, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 34, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_n_u_F_CONTIGUOUS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 34, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 34, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_2 = ((!__pyx_t_1) != 0); - if (unlikely(__pyx_t_2)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_indices); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_n_u_F_CONTIGUOUS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_4 = ((!__pyx_t_3) != 0); + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":35 + /* "l0learn/interface.pyx":24 * raise ValueError("expected arr.data to be F_CONTIGUOUS.") * if not arr.indices.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< * if not arr.indptr.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") */ - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 35, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_Raise(__pyx_t_4, 0, 0, 0); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(0, 35, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 24, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 24, __pyx_L1_error) - /* "l0learn/interface.pyx":34 + /* "l0learn/interface.pyx":23 * if not arr.data.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.data to be F_CONTIGUOUS.") * if not arr.indices.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< @@ -2377,40 +2422,40 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO */ } - /* "l0learn/interface.pyx":36 + /* "l0learn/interface.pyx":25 * if not arr.indices.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") * if not arr.indptr.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< * raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") * else: */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_indptr); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 36, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 36, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_Dict_GetItem(__pyx_t_3, __pyx_n_u_F_CONTIGUOUS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 36, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 36, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_1 = ((!__pyx_t_2) != 0); - if (unlikely(__pyx_t_1)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_indptr); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 25, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 25, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_n_u_F_CONTIGUOUS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 25, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 25, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = ((!__pyx_t_4) != 0); + if (unlikely(__pyx_t_3)) { - /* "l0learn/interface.pyx":37 + /* "l0learn/interface.pyx":26 * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") * if not arr.indptr.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< * else: * raise NotImplementedError(f"expected arr to be of type {np.ndarray} or {csc_matrix}, but got {type(arr)}.") */ - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 37, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_Raise(__pyx_t_4, 0, 0, 0); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(0, 37, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 26, __pyx_L1_error) - /* "l0learn/interface.pyx":36 + /* "l0learn/interface.pyx":25 * if not arr.indices.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") * if not arr.indptr.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< @@ -2419,7 +2464,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO */ } - /* "l0learn/interface.pyx":31 + /* "l0learn/interface.pyx":20 * if not arr.flags['F_CONTIGUOUS']: * raise ValueError("expected arr to be F_CONTIGUOUS.") * elif isinstance(arr, csc_matrix): # <<<<<<<<<<<<<< @@ -2429,7 +2474,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO goto __pyx_L3; } - /* "l0learn/interface.pyx":39 + /* "l0learn/interface.pyx":28 * raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") * else: * raise NotImplementedError(f"expected arr to be of type {np.ndarray} or {csc_matrix}, but got {type(arr)}.") # <<<<<<<<<<<<<< @@ -2437,92 +2482,98 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO * if arr.ndim == 0: */ /*else*/ { - __pyx_t_4 = PyTuple_New(7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 39, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = 0; __pyx_t_6 = 127; __Pyx_INCREF(__pyx_kp_u_expected_arr_to_be_of_type); __pyx_t_5 += 27; __Pyx_GIVEREF(__pyx_kp_u_expected_arr_to_be_of_type); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_kp_u_expected_arr_to_be_of_type); - __pyx_t_3 = __Pyx_PyObject_FormatSimple(((PyObject *)__pyx_ptype_5numpy_ndarray), __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 39, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_6 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_6) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_6; - __pyx_t_5 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3); - __pyx_t_3 = 0; + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_expected_arr_to_be_of_type); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_6 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_6) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_6; + __pyx_t_5 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_2); + __pyx_t_2 = 0; __Pyx_INCREF(__pyx_kp_u_or); __pyx_t_5 += 4; __Pyx_GIVEREF(__pyx_kp_u_or); - PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_kp_u_or); - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 39, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 39, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_or); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 28, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_6 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_6) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_6; __pyx_t_5 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_t_7); __pyx_t_7 = 0; __Pyx_INCREF(__pyx_kp_u_but_got); __pyx_t_5 += 10; __Pyx_GIVEREF(__pyx_kp_u_but_got); - PyTuple_SET_ITEM(__pyx_t_4, 4, __pyx_kp_u_but_got); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(((PyObject *)Py_TYPE(__pyx_v_arr)), __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 39, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_1, 4, __pyx_kp_u_but_got); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(((PyObject *)Py_TYPE(__pyx_v_arr)), __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 28, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_6 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_6) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_6; __pyx_t_5 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_4, 5, __pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_1, 5, __pyx_t_7); __pyx_t_7 = 0; __Pyx_INCREF(__pyx_kp_u__5); __pyx_t_5 += 1; __Pyx_GIVEREF(__pyx_kp_u__5); - PyTuple_SET_ITEM(__pyx_t_4, 6, __pyx_kp_u__5); - __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_4, 7, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 39, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_1, 6, __pyx_kp_u__5); + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_1, 7, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 28, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_NotImplementedError, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 39, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_NotImplementedError, __pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_4, 0, 0, 0); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(0, 39, __pyx_L1_error) + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 28, __pyx_L1_error) } __pyx_L3:; - /* "l0learn/interface.pyx":41 + /* "l0learn/interface.pyx":30 * raise NotImplementedError(f"expected arr to be of type {np.ndarray} or {csc_matrix}, but got {type(arr)}.") * * if arr.ndim == 0: # <<<<<<<<<<<<<< * raise ValueError("expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar") * elif arr.ndim > 2: */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_ndim); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 41, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_7 = __Pyx_PyInt_EqObjC(__pyx_t_4, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 41, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 30, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = __Pyx_PyInt_EqObjC(__pyx_t_1, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 30, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 41, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 30, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(__pyx_t_1)) { + if (unlikely(__pyx_t_3)) { - /* "l0learn/interface.pyx":42 + /* "l0learn/interface.pyx":31 * * if arr.ndim == 0: * raise ValueError("expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar") # <<<<<<<<<<<<<< * elif arr.ndim > 2: * raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") */ - __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 42, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 31, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 42, __pyx_L1_error) + __PYX_ERR(0, 31, __pyx_L1_error) - /* "l0learn/interface.pyx":41 + /* "l0learn/interface.pyx":30 * raise NotImplementedError(f"expected arr to be of type {np.ndarray} or {csc_matrix}, but got {type(arr)}.") * * if arr.ndim == 0: # <<<<<<<<<<<<<< @@ -2531,61 +2582,61 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO */ } - /* "l0learn/interface.pyx":43 + /* "l0learn/interface.pyx":32 * if arr.ndim == 0: * raise ValueError("expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar") * elif arr.ndim > 2: # <<<<<<<<<<<<<< * raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") * */ - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 43, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 32, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_4 = PyObject_RichCompare(__pyx_t_7, __pyx_int_2, Py_GT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 43, __pyx_L1_error) + __pyx_t_1 = PyObject_RichCompare(__pyx_t_7, __pyx_int_2, Py_GT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 32, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 43, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(__pyx_t_1)) { + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(__pyx_t_3)) { - /* "l0learn/interface.pyx":44 + /* "l0learn/interface.pyx":33 * raise ValueError("expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar") * elif arr.ndim > 2: * raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") # <<<<<<<<<<<<<< * * if np.product(arr.shape) == 0: */ - __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 44, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = 0; __pyx_t_6 = 127; __Pyx_INCREF(__pyx_kp_u_expected_arr_ndim_to_be_1_or_2_b_2); __pyx_t_5 += 42; __Pyx_GIVEREF(__pyx_kp_u_expected_arr_ndim_to_be_1_or_2_b_2); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_kp_u_expected_arr_ndim_to_be_1_or_2_b_2); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 44, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_expected_arr_ndim_to_be_1_or_2_b_2); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 33, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 44, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_6 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_6) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_6; - __pyx_t_5 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3); - __pyx_t_3 = 0; + __pyx_t_6 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_6) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_6; + __pyx_t_5 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_2); + __pyx_t_2 = 0; __Pyx_INCREF(__pyx_kp_u_Not_supported); __pyx_t_5 += 15; __Pyx_GIVEREF(__pyx_kp_u_Not_supported); - PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_kp_u_Not_supported); - __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_4, 3, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 44, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_NotImplementedError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 44, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_t_4, 0, 0, 0); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(0, 44, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_Not_supported); + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_1, 3, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_NotImplementedError, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 33, __pyx_L1_error) - /* "l0learn/interface.pyx":43 + /* "l0learn/interface.pyx":32 * if arr.ndim == 0: * raise ValueError("expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar") * elif arr.ndim > 2: # <<<<<<<<<<<<<< @@ -2594,20 +2645,20 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO */ } - /* "l0learn/interface.pyx":46 + /* "l0learn/interface.pyx":35 * raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") * * if np.product(arr.shape) == 0: # <<<<<<<<<<<<<< * raise ValueError(f"expected non-degenerate dimensions of arr, but got {arr.ndim}") * */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 46, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_product); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 35, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_product); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 35, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 46, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 35, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __pyx_t_8 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); @@ -2618,42 +2669,42 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO __Pyx_DECREF_SET(__pyx_t_7, function); } } - __pyx_t_4 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_3); + __pyx_t_1 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_2); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 46, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 35, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyInt_EqObjC(__pyx_t_4, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 46, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_EqObjC(__pyx_t_1, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 35, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 35, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(__pyx_t_1)) { + if (unlikely(__pyx_t_3)) { - /* "l0learn/interface.pyx":47 + /* "l0learn/interface.pyx":36 * * if np.product(arr.shape) == 0: * raise ValueError(f"expected non-degenerate dimensions of arr, but got {arr.ndim}") # <<<<<<<<<<<<<< * * if not np.issubdtype(arr.dtype, np.number): */ - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 47, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 36, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 47, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_non_degenerate_dimensio, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 47, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_non_degenerate_dimensio, __pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 36, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 47, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_4, 0, 0, 0); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(0, 47, __pyx_L1_error) + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 36, __pyx_L1_error) - /* "l0learn/interface.pyx":46 + /* "l0learn/interface.pyx":35 * raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") * * if np.product(arr.shape) == 0: # <<<<<<<<<<<<<< @@ -2662,59 +2713,59 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO */ } - /* "l0learn/interface.pyx":49 + /* "l0learn/interface.pyx":38 * raise ValueError(f"expected non-degenerate dimensions of arr, but got {arr.ndim}") * * if not np.issubdtype(arr.dtype, np.number): # <<<<<<<<<<<<<< * raise ValueError(f"expected numerical dtype, but got {arr.dtype}") * */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 38, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_issubdtype); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 49, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_issubdtype); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_dtype); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 49, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_dtype); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 38, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 38, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_number); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 49, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_number); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 38, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_10 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3); + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); + __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_10 = 1; } } #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_3)) { + if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_7, __pyx_t_9}; - __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 49, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 38, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_GOTREF(__pyx_t_4); + __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } else #endif #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_7, __pyx_t_9}; - __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 49, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 38, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_GOTREF(__pyx_t_4); + __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } else #endif { - __pyx_t_11 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 49, __pyx_L1_error) + __pyx_t_11 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 38, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_8); __pyx_t_8 = NULL; @@ -2725,39 +2776,39 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_10, __pyx_t_9); __pyx_t_7 = 0; __pyx_t_9 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_11, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 49, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 49, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_2 = ((!__pyx_t_1) != 0); - if (unlikely(__pyx_t_2)) { + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 38, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_4 = ((!__pyx_t_3) != 0); + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":50 + /* "l0learn/interface.pyx":39 * * if not np.issubdtype(arr.dtype, np.number): * raise ValueError(f"expected numerical dtype, but got {arr.dtype}") # <<<<<<<<<<<<<< * * if not np.isrealobj(arr): */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_dtype); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 50, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_t_4, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 50, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_numerical_dtype_but_got, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 50, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 50, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 50, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_1, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_numerical_dtype_but_got, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 39, __pyx_L1_error) - /* "l0learn/interface.pyx":49 + /* "l0learn/interface.pyx":38 * raise ValueError(f"expected non-degenerate dimensions of arr, but got {arr.ndim}") * * if not np.issubdtype(arr.dtype, np.number): # <<<<<<<<<<<<<< @@ -2766,61 +2817,61 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO */ } - /* "l0learn/interface.pyx":52 + /* "l0learn/interface.pyx":41 * raise ValueError(f"expected numerical dtype, but got {arr.dtype}") * * if not np.isrealobj(arr): # <<<<<<<<<<<<<< * raise ValueError(f"expected non-complex dtype, but got {arr.dtype}") * */ - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 52, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 41, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 41, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = NULL; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_11))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_11); - if (likely(__pyx_t_4)) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_11); + if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11); - __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_11, function); } } - __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_4, __pyx_v_arr) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_v_arr); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 52, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_1, __pyx_v_arr) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_v_arr); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 41, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 52, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_1 = ((!__pyx_t_2) != 0); - if (unlikely(__pyx_t_1)) { + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 41, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = ((!__pyx_t_4) != 0); + if (unlikely(__pyx_t_3)) { - /* "l0learn/interface.pyx":53 + /* "l0learn/interface.pyx":42 * * if not np.isrealobj(arr): * raise ValueError(f"expected non-complex dtype, but got {arr.dtype}") # <<<<<<<<<<<<<< * * */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_dtype); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 53, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_11 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_empty_unicode); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 53, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_dtype); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_11 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 42, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_non_complex_dtype_but_g, __pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 53, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __pyx_t_11 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 53, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_non_complex_dtype_but_g, __pyx_t_11); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_11 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 42, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_11, 0, 0, 0); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __PYX_ERR(0, 53, __pyx_L1_error) + __PYX_ERR(0, 42, __pyx_L1_error) - /* "l0learn/interface.pyx":52 + /* "l0learn/interface.pyx":41 * raise ValueError(f"expected numerical dtype, but got {arr.dtype}") * * if not np.isrealobj(arr): # <<<<<<<<<<<<<< @@ -2829,8 +2880,8 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO */ } - /* "l0learn/interface.pyx":26 - * + /* "l0learn/interface.pyx":15 + * from l0learn.utils import FitModel, CVFitModel * * def np_to_arma_check(arr): # <<<<<<<<<<<<<< * # TODO: Add checks for Behaved and OwnsData @@ -2841,8 +2892,8 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); @@ -2855,8 +2906,8 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO return __pyx_r; } -/* "l0learn/interface.pyx":62 - * +/* "l0learn/interface.pyx":50 + * SUPPORTED_ALGORITHM = ("CD", "CDPSI") * * def fit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< * y: np.ndarray, @@ -2865,11 +2916,11 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO /* Python wrapper */ static PyObject *__pyx_pw_7l0learn_9interface_3fit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_7l0learn_9interface_2fit[] = "fit(X: Union[np.ndarray, csc_matrix], ndarray y: np.ndarray, unicode loss: str = u'SquaredHinge', unicode penalty: str = u'L0', unicode algorithm: str = u'CD', max_support_size: int = 100, num_lambda: Optional[int] = 100, num_gamma: Optional[int] = 1, double gamma_max: float = 10., double gamma_min: float = .0001, partial_sort: bool = True, max_iter: int = 200, double rtol: float = 1e-6, double atol: float = 1e-9, active_set: bool = True, active_set_num: int = 3, max_swaps: int = 100, double scale_down_factor: float = 0.8, screen_size: int = 1000, lambda_grid: Optional[List[List[float]]] = None, exclude_first_k: int = 0, intercept: bool = True, lows: Union[np.ndarray, float] = -float(u'inf'), highs: Union[np.ndarray, float] = +float(u'inf'))\n\n Computes the regularization path for the specified loss function and penalty function.\n\n Parameters\n ----------\n X : np.ndarray or csc_matrix of shape (N, P)\n Data Matrix where rows of X are observations and columns of X are features\n y : np.ndarray of shape (P)\n The response vector where y[i] corresponds to X[i, :]\n For classification, a binary vector (-1, 1) is requried .\n loss : str\n The loss function. Currently supports the choices:\n \"SquaredError\" (for regression),\n \"Logistic\" (for logistic regression), and\n \"SquaredHinge\" (for smooth SVM).\n penalty : str\n The type of regularization.\n This can take either one of the following choices:\n \"L0\",\n \"L0L2\", and\n \"L0L1\"\n algorithm : str\n The type of algorithm used to minimize the objective function. Currently \"CD\" and \"CDPSI\" are are supported.\n \"CD\" is a variant of cyclic coordinate descent and runs very fast. \"CDPSI\" performs local combinatorial search\n on top of CD and typically achieves higher quality solutions (at the expense of increased running time).\n max_support_size\n ""num_lambda\n num_gamma\n gamma_max\n gamma_min\n partial_sort\n max_iter\n rtol\n atol\n active_set\n active_set_num\n max_swaps\n scale_down_factor\n screen_size\n lambda_grid\n exclude_first_k\n intercept\n lows\n highs\n\n Returns\n -------\n\n "; +static char __pyx_doc_7l0learn_9interface_2fit[] = "fit(X: Union[np.ndarray, csc_matrix], y: np.ndarray, unicode loss: str = u'SquaredHinge', unicode penalty: str = u'L0', unicode algorithm: str = u'CD', max_support_size: int = 100, num_lambda: Optional[int] = 100, num_gamma: Optional[int] = 1, double gamma_max: float = 10., double gamma_min: float = .0001, partial_sort: bool = True, max_iter: int = 200, double rtol: float = 1e-6, double atol: float = 1e-9, active_set: bool = True, active_set_num: int = 3, max_swaps: int = 100, double scale_down_factor: float = 0.8, screen_size: int = 1000, lambda_grid: Optional[List[List[float]]] = None, exclude_first_k: int = 0, intercept: bool = True, lows: Union[np.ndarray, float] = -float(u'inf'), highs: Union[np.ndarray, float] = +float(u'inf'))\n\n Computes the regularization path for the specified loss function and penalty function.\n\n Parameters\n ----------\n X : np.ndarray or csc_matrix of shape (N, P)\n Data Matrix where rows of X are observations and columns of X are features\n\n y : np.ndarray of shape (P)\n The response vector where y[i] corresponds to X[i, :]\n For classification, a binary vector (-1, 1) is requried .\n\n loss : str\n The loss function. Currently supports the choices:\n \"SquaredError\" (for regression),\n \"Logistic\" (for logistic regression), and\n \"SquaredHinge\" (for smooth SVM).\n\n penalty : str\n The type of regularization.\n This can take either one of the following choices:\n \"L0\",\n \"L0L2\", and\n \"L0L1\"\n\n algorithm : str\n The type of algorithm used to minimize the objective function. Currently \"CD\" and \"CDPSI\" are are supported.\n \"CD\" is a variant of cyclic coordinate descent and runs very fast. \"CDPSI\" performs local combinatorial search\n on top of CD and typically achieves higher quality solutions (at the expense of increased running time).\n\n max_support_size : i""nt\n Must be greater than 0.\n The maximum support size at which to terminate the regularization path. We recommend setting this to a small\n fraction of min(n,p) (e.g. 0.05 * min(n,p)) as L0 regularization typically selects a small portion of non-zeros.\n\n num_lambda : int, optional\n The number of lambda values to select in the regularization path.\n This value must be None if lambda_grid is supplied.When supplied, must be greater than 0.\n Note: lambda is the regularization parameter corresponding to the L0 norm.\n\n num_gamma: int, optional\n The number of gamma values to select in the regularization path.\n This value must be None if lambda_grid is supplied. When supplied, must be greater than 0.\n Note: gamma is the regularization parameter corresponding to L1 or L2, depending on the chosen penalty).\n\n gamma_max : float\n The maximum value of gamma when using the L0L2 penalty.\n This value must be greater than 0.\n\n Note: For the L0L1 penalty this is automatically selected.\n\n gamma_min : float\n The minimum value of Gamma when using the L0L2 penalty.\n This value must be greater than 0 but less than gamma_max.\n Note: For the L0L1 penalty, the minimum value of gamma in the grid is set to gammaMin * gammaMax.\n\n partial_sort : bool\n If TRUE partial sorting will be used for sorting the coordinates to do greedy cycling (see our paper for\n for details). Otherwise, full sorting is used. #TODO: Add link for paper\n\n max_iter : int\n The maximum number of iterations (full cycles) for CD per grid point. The algorithm may not use the full number\n of iteration per grid point if convergence is found (defined by rtol and atol parameter)\n Must be greater than 0\n\n rtol : float\n The relative tolerance which decides when to terminate optimization as based on the relative change in the\n o""bjective between iterations.\n Must be greater than 0 and less than 1.\n\n atol : float\n The absolute tolerance which decides when to terminate optimization as based on the absolute L2 norm of the\n residuals\n Must be greater than 0\n\n active_set : bool\n If TRUE, performs active set updates. (see our paper for for details). #TODO: Add link for paper\n\n active_set_num : int\n The number of consecutive times a support should appear before declaring support stabilization.\n (see our paper for for details). #TODO: Add link for paper\n\n Must be greater than 0.\n\n max_swaps : int\n The maximum number of swaps used by CDPSI for each grid point.\n Must be greater than 0. Ignored by CD algorithims.\n\n scale_down_factor : float\n Roughly amount each lambda value is scaled by between grid points. Larger values lead to closer lambdas and\n typically to smaller gaps between the support sizes.\n\n For details, see our paper - Section 5 on Adaptive Selection of Tuning Parameters). #TODO: Add link for paper\n\n Must be greater than 0 and less than 1 (strictly for both.)\n\n screen_size : int\n The number of coordinates to cycle over when performing initial correlation screening. #TODO: Add link for paper\n\n Must be greater than 0 and less than number of columns of X.\n\n lambda_grid : list of list of floats\n A grid of lambda values to use in computing the regularization path. This is by default an empty list\n and is ignored. When specified, lambda_grid should be a list of list of floats, where the ith element\n (corresponding to the ith gamma) should be a decreasing sequence of lambda values. The length of this sequence\n is directly the number of lambdas to be tried for that gamma.\n\n In the the \"L0\" penalty case, lambda_grid should be a list of 1.\n In the \"L0LX\" penalty cases, lambda_grid ""can be a list of any length. The length of lambda_grid will be the\n number of gamma values tried.\n\n See the example notebook for more details.\n\n Note: When lambda_grid is supplied, num_gamma and num_lambda must be None.\n\n exclude_first_k : int\n The first exclude_first_k features in X will be excluded from variable selection. In other words, the first\n exclude_first_k variables will not be included in the L0-norm penalty however they will be included in the\n L1 or L2 norm penalties, if they are specified.\n\n Must be a positive integer less than the columns of X.\n\n intercept : bool\n If False, no intercept term is included or fit in the regularization path\n Intercept terms are not regularized by L0 or L1/L2.\n\n lows : np array or float\n Lower bounds for coefficients. Either a scalar for all coefficients to have the same bound or a vector of\n size p (number of columns of X) where lows[i] is the lower bound for coefficient i.\n\n Lower bounds can not be above 0 (i.e. we can not specify that all coefficients must be larger than a > 0).\n Lower bounds can be set to 0 iff the corresponding upper bound for that coefficient is also not 0.\n\n highs : np array or float\n Upper bounds for coefficients. Either a scalar for all coefficients to have the same bound or a vector of\n size p (number of columns of X) where highs[i] is the upper bound for coefficient i.\n\n Upper bounds can not be below 0 (i.e. we can not specify that all coefficients must be smaller than a < 0).\n Upper bounds can be set to 0 iff the corresponding looer bound for that coefficient is also not 0.\n\n Returns\n -------\n\n\n Examples\n --------\n "; static PyMethodDef __pyx_mdef_7l0learn_9interface_3fit = {"fit", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7l0learn_9interface_3fit, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7l0learn_9interface_2fit}; static PyObject *__pyx_pw_7l0learn_9interface_3fit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_X = 0; - PyArrayObject *__pyx_v_y = 0; + PyObject *__pyx_v_y = 0; PyObject *__pyx_v_loss = 0; PyObject *__pyx_v_penalty = 0; PyObject *__pyx_v_algorithm = 0; @@ -2908,7 +2959,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_3fit(PyObject *__pyx_self, PyObjec values[6] = ((PyObject *)__pyx_int_100); values[7] = ((PyObject *)__pyx_int_1); - /* "l0learn/interface.pyx":72 + /* "l0learn/interface.pyx":60 * gamma_max: float = 10., * gamma_min: float = .0001, * partial_sort: bool = True, # <<<<<<<<<<<<<< @@ -2918,7 +2969,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_3fit(PyObject *__pyx_self, PyObjec values[10] = ((PyObject *)Py_True); values[11] = ((PyObject *)__pyx_int_200); - /* "l0learn/interface.pyx":76 + /* "l0learn/interface.pyx":64 * rtol: float = 1e-6, * atol: float = 1e-9, * active_set: bool = True, # <<<<<<<<<<<<<< @@ -2930,7 +2981,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_3fit(PyObject *__pyx_self, PyObjec values[16] = ((PyObject *)__pyx_int_100); values[18] = ((PyObject *)__pyx_int_1000); - /* "l0learn/interface.pyx":81 + /* "l0learn/interface.pyx":69 * scale_down_factor: float = 0.8, * screen_size: int = 1000, * lambda_grid: Optional[List[List[float]]] = None, # <<<<<<<<<<<<<< @@ -2940,7 +2991,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_3fit(PyObject *__pyx_self, PyObjec values[19] = ((PyObject *)Py_None); values[20] = ((PyObject *)__pyx_int_0); - /* "l0learn/interface.pyx":83 + /* "l0learn/interface.pyx":71 * lambda_grid: Optional[List[List[float]]] = None, * exclude_first_k: int = 0, * intercept: bool = True, # <<<<<<<<<<<<<< @@ -3014,7 +3065,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_3fit(PyObject *__pyx_self, PyObjec case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("fit", 0, 2, 24, 1); __PYX_ERR(0, 62, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("fit", 0, 2, 24, 1); __PYX_ERR(0, 50, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: @@ -3150,7 +3201,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_3fit(PyObject *__pyx_self, PyObjec } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fit") < 0)) __PYX_ERR(0, 62, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fit") < 0)) __PYX_ERR(0, 50, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -3205,7 +3256,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_3fit(PyObject *__pyx_self, PyObjec } } __pyx_v_X = values[0]; - __pyx_v_y = ((PyArrayObject *)values[1]); + __pyx_v_y = values[1]; __pyx_v_loss = ((PyObject*)values[2]); __pyx_v_penalty = ((PyObject*)values[3]); __pyx_v_algorithm = ((PyObject*)values[4]); @@ -3213,24 +3264,24 @@ static PyObject *__pyx_pw_7l0learn_9interface_3fit(PyObject *__pyx_self, PyObjec __pyx_v_num_lambda = values[6]; __pyx_v_num_gamma = values[7]; if (values[8]) { - __pyx_v_gamma_max = __pyx_PyFloat_AsDouble(values[8]); if (unlikely((__pyx_v_gamma_max == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 70, __pyx_L3_error) + __pyx_v_gamma_max = __pyx_PyFloat_AsDouble(values[8]); if (unlikely((__pyx_v_gamma_max == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 58, __pyx_L3_error) } else { __pyx_v_gamma_max = ((double)10.); } if (values[9]) { - __pyx_v_gamma_min = __pyx_PyFloat_AsDouble(values[9]); if (unlikely((__pyx_v_gamma_min == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 71, __pyx_L3_error) + __pyx_v_gamma_min = __pyx_PyFloat_AsDouble(values[9]); if (unlikely((__pyx_v_gamma_min == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 59, __pyx_L3_error) } else { __pyx_v_gamma_min = ((double).0001); } __pyx_v_partial_sort = values[10]; __pyx_v_max_iter = values[11]; if (values[12]) { - __pyx_v_rtol = __pyx_PyFloat_AsDouble(values[12]); if (unlikely((__pyx_v_rtol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 74, __pyx_L3_error) + __pyx_v_rtol = __pyx_PyFloat_AsDouble(values[12]); if (unlikely((__pyx_v_rtol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 62, __pyx_L3_error) } else { __pyx_v_rtol = ((double)1e-6); } if (values[13]) { - __pyx_v_atol = __pyx_PyFloat_AsDouble(values[13]); if (unlikely((__pyx_v_atol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 75, __pyx_L3_error) + __pyx_v_atol = __pyx_PyFloat_AsDouble(values[13]); if (unlikely((__pyx_v_atol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 63, __pyx_L3_error) } else { __pyx_v_atol = ((double)1e-9); } @@ -3238,7 +3289,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_3fit(PyObject *__pyx_self, PyObjec __pyx_v_active_set_num = values[15]; __pyx_v_max_swaps = values[16]; if (values[17]) { - __pyx_v_scale_down_factor = __pyx_PyFloat_AsDouble(values[17]); if (unlikely((__pyx_v_scale_down_factor == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 79, __pyx_L3_error) + __pyx_v_scale_down_factor = __pyx_PyFloat_AsDouble(values[17]); if (unlikely((__pyx_v_scale_down_factor == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 67, __pyx_L3_error) } else { __pyx_v_scale_down_factor = ((double)0.8); } @@ -3251,20 +3302,19 @@ static PyObject *__pyx_pw_7l0learn_9interface_3fit(PyObject *__pyx_self, PyObjec } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("fit", 0, 2, 24, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 62, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("fit", 0, 2, 24, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 50, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("l0learn.interface.fit", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_y), __pyx_ptype_5numpy_ndarray, 1, "y", 0))) __PYX_ERR(0, 63, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loss), (&PyUnicode_Type), 1, "loss", 1))) __PYX_ERR(0, 64, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_penalty), (&PyUnicode_Type), 1, "penalty", 1))) __PYX_ERR(0, 65, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_algorithm), (&PyUnicode_Type), 1, "algorithm", 1))) __PYX_ERR(0, 66, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loss), (&PyUnicode_Type), 1, "loss", 1))) __PYX_ERR(0, 52, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_penalty), (&PyUnicode_Type), 1, "penalty", 1))) __PYX_ERR(0, 53, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_algorithm), (&PyUnicode_Type), 1, "algorithm", 1))) __PYX_ERR(0, 54, __pyx_L1_error) __pyx_r = __pyx_pf_7l0learn_9interface_2fit(__pyx_self, __pyx_v_X, __pyx_v_y, __pyx_v_loss, __pyx_v_penalty, __pyx_v_algorithm, __pyx_v_max_support_size, __pyx_v_num_lambda, __pyx_v_num_gamma, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_v_partial_sort, __pyx_v_max_iter, __pyx_v_rtol, __pyx_v_atol, __pyx_v_active_set, __pyx_v_active_set_num, __pyx_v_max_swaps, __pyx_v_scale_down_factor, __pyx_v_screen_size, __pyx_v_lambda_grid, __pyx_v_exclude_first_k, __pyx_v_intercept, __pyx_v_lows, __pyx_v_highs); - /* "l0learn/interface.pyx":62 - * + /* "l0learn/interface.pyx":50 + * SUPPORTED_ALGORITHM = ("CD", "CDPSI") * * def fit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< * y: np.ndarray, @@ -3280,9 +3330,12 @@ static PyObject *__pyx_pw_7l0learn_9interface_3fit(PyObject *__pyx_self, PyObjec return __pyx_r; } -static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyArrayObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs) { +static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs) { PyObject *__pyx_v_n = NULL; PyObject *__pyx_v_p = NULL; + PyObject *__pyx_v_unique_items = NULL; + PyObject *__pyx_v_a = NULL; + CYTHON_UNUSED PyObject *__pyx_v__ = NULL; int __pyx_v_auto_lambda; CYTHON_UNUSED int __pyx_v_bad_lambda_grid; PyObject *__pyx_v_i = NULL; @@ -3294,15 +3347,16 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx std::string __pyx_v_c_loss; std::string __pyx_v_c_penalty; std::string __pyx_v_c_algorithim; - fitmodel __pyx_v_results; + fitmodel __pyx_v_c_results; + PyObject *__pyx_v_results = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; - int __pyx_t_3; + PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; - PyObject *__pyx_t_6 = NULL; + int __pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; Py_ssize_t __pyx_t_9; @@ -3334,6 +3388,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fit", 0); + __Pyx_INCREF(__pyx_v_y); __Pyx_INCREF(__pyx_v_penalty); __Pyx_INCREF(__pyx_v_num_lambda); __Pyx_INCREF(__pyx_v_num_gamma); @@ -3341,111 +3396,117 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_INCREF(__pyx_v_lows); __Pyx_INCREF(__pyx_v_highs); - /* "l0learn/interface.pyx":136 + /* "l0learn/interface.pyx":222 * """ * * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): # <<<<<<<<<<<<<< * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") - * + * n, p = X.shape */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 222, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __Pyx_TypeCheck(__pyx_v_X, __pyx_ptype_5numpy_ndarray); - __pyx_t_5 = (__pyx_t_4 != 0); - if (!__pyx_t_5) { + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = PyObject_IsInstance(__pyx_v_X, __pyx_t_3); + __pyx_t_6 = (__pyx_t_5 != 0); + if (!__pyx_t_6) { } else { - __pyx_t_3 = __pyx_t_5; + __pyx_t_4 = __pyx_t_6; goto __pyx_L6_bool_binop_done; } - __pyx_t_5 = PyObject_IsInstance(__pyx_v_X, __pyx_t_2); - __pyx_t_4 = (__pyx_t_5 != 0); - __pyx_t_3 = __pyx_t_4; + __pyx_t_6 = PyObject_IsInstance(__pyx_v_X, __pyx_t_2); + __pyx_t_5 = (__pyx_t_6 != 0); + __pyx_t_4 = __pyx_t_5; __pyx_L6_bool_binop_done:; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = ((!(__pyx_t_3 != 0)) != 0); - if (!__pyx_t_4) { + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); + if (!__pyx_t_5) { } else { - __pyx_t_1 = __pyx_t_4; + __pyx_t_1 = __pyx_t_5; goto __pyx_L4_bool_binop_done; } - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 136, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 222, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = NULL; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { - __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7); - if (likely(__pyx_t_6)) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); - __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } - __pyx_t_2 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_6, __pyx_v_X) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_X); - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_2, __pyx_v_X) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_X); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 136, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = ((!__pyx_t_4) != 0); - if (!__pyx_t_3) { + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 222, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = ((!__pyx_t_5) != 0); + if (!__pyx_t_4) { } else { - __pyx_t_1 = __pyx_t_3; + __pyx_t_1 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyInt_NeObjC(__pyx_t_2, __pyx_int_2, 2, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 136, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyInt_NeObjC(__pyx_t_3, __pyx_int_2, 2, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 222, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 222, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (!__pyx_t_3) { + if (!__pyx_t_4) { } else { - __pyx_t_1 = __pyx_t_3; + __pyx_t_1 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_product); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 136, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_product); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 222, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __pyx_t_8 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_6, function); + __Pyx_DECREF_SET(__pyx_t_2, function); } } - __pyx_t_7 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_8, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_2); + __pyx_t_7 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_8, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 222, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 222, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = ((!__pyx_t_3) != 0); - __pyx_t_1 = __pyx_t_4; + __pyx_t_5 = ((!__pyx_t_4) != 0); + __pyx_t_1 = __pyx_t_5; __pyx_L4_bool_binop_done:; if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":137 + /* "l0learn/interface.pyx":223 * * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") # <<<<<<<<<<<<<< - * * n, p = X.shape + * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: */ - __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 137, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 223, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -3453,44 +3514,44 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_9 += 71; __Pyx_GIVEREF(__pyx_kp_u_expected_X_to_be_a_2D_non_degene); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_X_to_be_a_2D_non_degene); - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_X, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 137, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_6); - __pyx_t_6 = 0; + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_X, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_2); + __pyx_t_2 = 0; __Pyx_INCREF(__pyx_kp_u__5); __pyx_t_9 += 1; __Pyx_GIVEREF(__pyx_kp_u__5); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u__5); - __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 137, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 137, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 223, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 137, __pyx_L1_error) + __PYX_ERR(0, 223, __pyx_L1_error) - /* "l0learn/interface.pyx":136 + /* "l0learn/interface.pyx":222 * """ * * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): # <<<<<<<<<<<<<< * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") - * + * n, p = X.shape */ } - /* "l0learn/interface.pyx":139 + /* "l0learn/interface.pyx":224 + * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") - * * n, p = X.shape # <<<<<<<<<<<<<< * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") */ - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 139, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 224, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if ((likely(PyTuple_CheckExact(__pyx_t_7))) || (PyList_CheckExact(__pyx_t_7))) { PyObject* sequence = __pyx_t_7; @@ -3498,36 +3559,36 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 139, __pyx_L1_error) + __PYX_ERR(0, 224, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_2 = PyTuple_GET_ITEM(sequence, 1); + __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); } else { - __pyx_t_6 = PyList_GET_ITEM(sequence, 0); - __pyx_t_2 = PyList_GET_ITEM(sequence, 1); + __pyx_t_2 = PyList_GET_ITEM(sequence, 0); + __pyx_t_3 = PyList_GET_ITEM(sequence, 1); } - __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); #else - __pyx_t_6 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 139, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 139, __pyx_L1_error) + __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 224, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); #endif __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else { Py_ssize_t index = -1; - __pyx_t_8 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 139, __pyx_L1_error) + __pyx_t_8 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 224, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_11 = Py_TYPE(__pyx_t_8)->tp_iternext; - index = 0; __pyx_t_6 = __pyx_t_11(__pyx_t_8); if (unlikely(!__pyx_t_6)) goto __pyx_L10_unpacking_failed; - __Pyx_GOTREF(__pyx_t_6); - index = 1; __pyx_t_2 = __pyx_t_11(__pyx_t_8); if (unlikely(!__pyx_t_2)) goto __pyx_L10_unpacking_failed; + index = 0; __pyx_t_2 = __pyx_t_11(__pyx_t_8); if (unlikely(!__pyx_t_2)) goto __pyx_L10_unpacking_failed; __Pyx_GOTREF(__pyx_t_2); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_8), 2) < 0) __PYX_ERR(0, 139, __pyx_L1_error) + index = 1; __pyx_t_3 = __pyx_t_11(__pyx_t_8); if (unlikely(!__pyx_t_3)) goto __pyx_L10_unpacking_failed; + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_8), 2) < 0) __PYX_ERR(0, 224, __pyx_L1_error) __pyx_t_11 = NULL; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L11_unpacking_done; @@ -3535,317 +3596,329 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_11 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 139, __pyx_L1_error) + __PYX_ERR(0, 224, __pyx_L1_error) __pyx_L11_unpacking_done:; } - __pyx_v_n = __pyx_t_6; - __pyx_t_6 = 0; - __pyx_v_p = __pyx_t_2; + __pyx_v_n = __pyx_t_2; __pyx_t_2 = 0; + __pyx_v_p = __pyx_t_3; + __pyx_t_3 = 0; - /* "l0learn/interface.pyx":140 - * + /* "l0learn/interface.pyx":225 + * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") * n, p = X.shape * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: # <<<<<<<<<<<<<< * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") - * + * if loss not in SUPPORTED_LOSS: */ - __pyx_t_4 = __Pyx_TypeCheck(((PyObject *)__pyx_v_y), __pyx_ptype_5numpy_ndarray); - __pyx_t_3 = ((!(__pyx_t_4 != 0)) != 0); - if (!__pyx_t_3) { + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 225, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 225, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_5 = PyObject_IsInstance(__pyx_v_y, __pyx_t_3); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 225, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = ((!(__pyx_t_5 != 0)) != 0); + if (!__pyx_t_4) { } else { - __pyx_t_1 = __pyx_t_3; + __pyx_t_1 = __pyx_t_4; goto __pyx_L13_bool_binop_done; } - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 140, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 225, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 225, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 140, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_6); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); - __Pyx_INCREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_6, function); + __Pyx_DECREF_SET(__pyx_t_2, function); } } - __pyx_t_7 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_2, ((PyObject *)__pyx_v_y)) : __Pyx_PyObject_CallOneArg(__pyx_t_6, ((PyObject *)__pyx_v_y)); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 140, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 140, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = ((!__pyx_t_3) != 0); - if (!__pyx_t_4) { + __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_7, __pyx_v_y) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_y); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 225, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 225, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = ((!__pyx_t_4) != 0); + if (!__pyx_t_5) { } else { - __pyx_t_1 = __pyx_t_4; + __pyx_t_1 = __pyx_t_5; goto __pyx_L13_bool_binop_done; } - __pyx_t_4 = ((__pyx_v_y->nd != 1) != 0); - if (!__pyx_t_4) { + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_y, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 225, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyInt_NeObjC(__pyx_t_3, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 225, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 225, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (!__pyx_t_5) { } else { - __pyx_t_1 = __pyx_t_4; + __pyx_t_1 = __pyx_t_5; goto __pyx_L13_bool_binop_done; } - __pyx_t_9 = PyObject_Length(((PyObject *)__pyx_v_y)); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 140, __pyx_L1_error) - __pyx_t_7 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 140, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = PyObject_RichCompare(__pyx_t_7, __pyx_v_n, Py_NE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 140, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 140, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_1 = __pyx_t_4; + __pyx_t_9 = PyObject_Length(__pyx_v_y); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 225, __pyx_L1_error) + __pyx_t_2 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 225, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyObject_RichCompare(__pyx_t_2, __pyx_v_n, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 225, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 225, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __pyx_t_5; __pyx_L13_bool_binop_done:; if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":141 + /* "l0learn/interface.pyx":226 * n, p = X.shape * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") # <<<<<<<<<<<<<< - * * if loss not in SUPPORTED_LOSS: + * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") */ - __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 141, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_expected_y_to_be_a_1D_real_numpy); __pyx_t_9 += 42; __Pyx_GIVEREF(__pyx_kp_u_expected_y_to_be_a_1D_real_numpy); - PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_y_to_be_a_1D_real_numpy); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(((PyObject *)__pyx_v_y), __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 141, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_7); - __pyx_t_7 = 0; + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_y_to_be_a_1D_real_numpy); + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_y, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); + __pyx_t_2 = 0; __Pyx_INCREF(__pyx_kp_u__5); __pyx_t_9 += 1; __Pyx_GIVEREF(__pyx_kp_u__5); - PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u__5); - __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_6, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 141, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 141, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 141, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u__5); + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 226, __pyx_L1_error) - /* "l0learn/interface.pyx":140 - * + /* "l0learn/interface.pyx":225 + * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") * n, p = X.shape * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: # <<<<<<<<<<<<<< * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") - * + * if loss not in SUPPORTED_LOSS: */ } - /* "l0learn/interface.pyx":143 + /* "l0learn/interface.pyx":227 + * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") - * * if loss not in SUPPORTED_LOSS: # <<<<<<<<<<<<<< * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") - * + * if penalty not in SUPPORTED_PENALTY: */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 143, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_loss, __pyx_t_6, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 143, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_4 = (__pyx_t_1 != 0); - if (unlikely(__pyx_t_4)) { + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 227, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_loss, __pyx_t_3, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 227, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = (__pyx_t_1 != 0); + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":144 - * + /* "l0learn/interface.pyx":228 + * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") * if loss not in SUPPORTED_LOSS: * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") # <<<<<<<<<<<<<< - * * if penalty not in SUPPORTED_PENALTY: + * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") */ - __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 144, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_expected_loss_parameter_to_be_on); __pyx_t_9 += 36; __Pyx_GIVEREF(__pyx_kp_u_expected_loss_parameter_to_be_on); - PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_loss_parameter_to_be_on); - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 144, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 144, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_loss_parameter_to_be_on); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 228, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_2); - __pyx_t_2 = 0; + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7); + __pyx_t_7 = 0; __Pyx_INCREF(__pyx_kp_u_but_got); __pyx_t_9 += 10; __Pyx_GIVEREF(__pyx_kp_u_but_got); - PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u_but_got); - __pyx_t_2 = __Pyx_PyUnicode_Unicode(__pyx_v_loss); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 144, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_2); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_6, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 144, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 144, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 144, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_but_got); + __pyx_t_7 = __Pyx_PyUnicode_Unicode(__pyx_v_loss); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 228, __pyx_L1_error) - /* "l0learn/interface.pyx":143 + /* "l0learn/interface.pyx":227 + * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") - * * if loss not in SUPPORTED_LOSS: # <<<<<<<<<<<<<< * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") - * + * if penalty not in SUPPORTED_PENALTY: */ } - /* "l0learn/interface.pyx":146 + /* "l0learn/interface.pyx":229 + * if loss not in SUPPORTED_LOSS: * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") - * * if penalty not in SUPPORTED_PENALTY: # <<<<<<<<<<<<<< * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") * if algorithm not in SUPPORTED_ALGORITHM: */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_SUPPORTED_PENALTY); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 146, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_4 = (__Pyx_PySequence_ContainsTF(__pyx_v_penalty, __pyx_t_6, Py_NE)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 146, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_1 = (__pyx_t_4 != 0); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SUPPORTED_PENALTY); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_v_penalty, __pyx_t_3, Py_NE)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 229, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = (__pyx_t_5 != 0); if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":147 - * + /* "l0learn/interface.pyx":230 + * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") * if penalty not in SUPPORTED_PENALTY: * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") # <<<<<<<<<<<<<< * if algorithm not in SUPPORTED_ALGORITHM: * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") */ - __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 147, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_expected_penalty_parameter_to_be); __pyx_t_9 += 39; __Pyx_GIVEREF(__pyx_kp_u_expected_penalty_parameter_to_be); - PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_penalty_parameter_to_be); - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SUPPORTED_PENALTY); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 147, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 147, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_penalty_parameter_to_be); + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_SUPPORTED_PENALTY); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 230, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_7); - __pyx_t_7 = 0; + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); + __pyx_t_2 = 0; __Pyx_INCREF(__pyx_kp_u_but_got); __pyx_t_9 += 10; __Pyx_GIVEREF(__pyx_kp_u_but_got); - PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u_but_got); - __pyx_t_7 = __Pyx_PyUnicode_Unicode(__pyx_v_penalty); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 147, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_7); - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_6, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 147, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 147, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 147, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_but_got); + __pyx_t_2 = __Pyx_PyUnicode_Unicode(__pyx_v_penalty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 230, __pyx_L1_error) - /* "l0learn/interface.pyx":146 + /* "l0learn/interface.pyx":229 + * if loss not in SUPPORTED_LOSS: * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") - * * if penalty not in SUPPORTED_PENALTY: # <<<<<<<<<<<<<< * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") * if algorithm not in SUPPORTED_ALGORITHM: */ } - /* "l0learn/interface.pyx":148 + /* "l0learn/interface.pyx":231 * if penalty not in SUPPORTED_PENALTY: * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") * if algorithm not in SUPPORTED_ALGORITHM: # <<<<<<<<<<<<<< * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_SUPPORTED_ALGORITHM); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 148, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_algorithm, __pyx_t_6, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 148, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_4 = (__pyx_t_1 != 0); - if (unlikely(__pyx_t_4)) { + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SUPPORTED_ALGORITHM); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 231, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_algorithm, __pyx_t_3, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 231, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = (__pyx_t_1 != 0); + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":149 + /* "l0learn/interface.pyx":232 * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") * if algorithm not in SUPPORTED_ALGORITHM: * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") # <<<<<<<<<<<<<< * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," */ - __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 149, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_expected_algorithm_parameter_to); __pyx_t_9 += 41; __Pyx_GIVEREF(__pyx_kp_u_expected_algorithm_parameter_to); - PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_algorithm_parameter_to); - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_SUPPORTED_ALGORITHM); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 149, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 149, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_algorithm_parameter_to); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SUPPORTED_ALGORITHM); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 232, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_2); - __pyx_t_2 = 0; + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7); + __pyx_t_7 = 0; __Pyx_INCREF(__pyx_kp_u_but_got); __pyx_t_9 += 10; __Pyx_GIVEREF(__pyx_kp_u_but_got); - PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u_but_got); - __pyx_t_2 = __Pyx_PyUnicode_Unicode(__pyx_v_algorithm); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 149, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_2); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_6, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 149, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 149, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 149, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_but_got); + __pyx_t_7 = __Pyx_PyUnicode_Unicode(__pyx_v_algorithm); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 232, __pyx_L1_error) - /* "l0learn/interface.pyx":148 + /* "l0learn/interface.pyx":231 * if penalty not in SUPPORTED_PENALTY: * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") * if algorithm not in SUPPORTED_ALGORITHM: # <<<<<<<<<<<<<< @@ -3854,7 +3927,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":150 + /* "l0learn/interface.pyx":233 * if algorithm not in SUPPORTED_ALGORITHM: * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): # <<<<<<<<<<<<<< @@ -3862,84 +3935,84 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx * f" but got {max_support_size}") */ __pyx_t_1 = PyInt_Check(__pyx_v_max_support_size); - __pyx_t_3 = ((!(__pyx_t_1 != 0)) != 0); - if (!__pyx_t_3) { + __pyx_t_4 = ((!(__pyx_t_1 != 0)) != 0); + if (!__pyx_t_4) { } else { - __pyx_t_4 = __pyx_t_3; + __pyx_t_5 = __pyx_t_4; goto __pyx_L21_bool_binop_done; } - __pyx_t_6 = PyObject_RichCompare(__pyx_int_0, __pyx_v_max_support_size, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 150, __pyx_L1_error) - if (__Pyx_PyObject_IsTrue(__pyx_t_6)) { - __Pyx_DECREF(__pyx_t_6); - __pyx_t_6 = PyObject_RichCompare(__pyx_v_max_support_size, __pyx_v_p, Py_LE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 150, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_int_0, __pyx_v_max_support_size, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 233, __pyx_L1_error) + if (__Pyx_PyObject_IsTrue(__pyx_t_3)) { + __Pyx_DECREF(__pyx_t_3); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_max_support_size, __pyx_v_p, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 233, __pyx_L1_error) } - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 150, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_1 = ((!__pyx_t_3) != 0); - __pyx_t_4 = __pyx_t_1; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 233, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = ((!__pyx_t_4) != 0); + __pyx_t_5 = __pyx_t_1; __pyx_L21_bool_binop_done:; - if (unlikely(__pyx_t_4)) { + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":151 + /* "l0learn/interface.pyx":234 * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," # <<<<<<<<<<<<<< * f" but got {max_support_size}") * if gamma_max < 0: */ - __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 151, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_expected_max_support_size_parame); __pyx_t_9 += 71; __Pyx_GIVEREF(__pyx_kp_u_expected_max_support_size_parame); - PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_max_support_size_parame); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 151, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_2); - __pyx_t_2 = 0; + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_max_support_size_parame); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7); + __pyx_t_7 = 0; __Pyx_INCREF(__pyx_kp_u_but_got); __pyx_t_9 += 10; __Pyx_GIVEREF(__pyx_kp_u_but_got); - PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u_but_got); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_but_got); - /* "l0learn/interface.pyx":152 + /* "l0learn/interface.pyx":235 * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," * f" but got {max_support_size}") # <<<<<<<<<<<<<< * if gamma_max < 0: * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") */ - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_max_support_size, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 152, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_2); - __pyx_t_2 = 0; + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_max_support_size, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_7); + __pyx_t_7 = 0; - /* "l0learn/interface.pyx":151 + /* "l0learn/interface.pyx":234 * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," # <<<<<<<<<<<<<< * f" but got {max_support_size}") * if gamma_max < 0: */ - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_6, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 151, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 151, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 151, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 234, __pyx_L1_error) - /* "l0learn/interface.pyx":150 + /* "l0learn/interface.pyx":233 * if algorithm not in SUPPORTED_ALGORITHM: * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): # <<<<<<<<<<<<<< @@ -3948,39 +4021,39 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":153 + /* "l0learn/interface.pyx":236 * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," * f" but got {max_support_size}") * if gamma_max < 0: # <<<<<<<<<<<<<< * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") * if gamma_min < 0 or gamma_min > gamma_max: */ - __pyx_t_4 = ((__pyx_v_gamma_max < 0.0) != 0); - if (unlikely(__pyx_t_4)) { + __pyx_t_5 = ((__pyx_v_gamma_max < 0.0) != 0); + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":154 + /* "l0learn/interface.pyx":237 * f" but got {max_support_size}") * if gamma_max < 0: * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") # <<<<<<<<<<<<<< * if gamma_min < 0 or gamma_min > gamma_max: * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," */ - __pyx_t_6 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 154, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_6, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 154, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_gamma_max_parameter_to, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 154, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 154, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_Raise(__pyx_t_2, 0, 0, 0); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 154, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 237, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 237, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_gamma_max_parameter_to, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 237, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 237, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(0, 237, __pyx_L1_error) - /* "l0learn/interface.pyx":153 + /* "l0learn/interface.pyx":236 * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," * f" but got {max_support_size}") * if gamma_max < 0: # <<<<<<<<<<<<<< @@ -3989,7 +4062,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":155 + /* "l0learn/interface.pyx":238 * if gamma_max < 0: * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") * if gamma_min < 0 or gamma_min > gamma_max: # <<<<<<<<<<<<<< @@ -3999,45 +4072,45 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_1 = ((__pyx_v_gamma_min < 0.0) != 0); if (!__pyx_t_1) { } else { - __pyx_t_4 = __pyx_t_1; + __pyx_t_5 = __pyx_t_1; goto __pyx_L25_bool_binop_done; } __pyx_t_1 = ((__pyx_v_gamma_min > __pyx_v_gamma_max) != 0); - __pyx_t_4 = __pyx_t_1; + __pyx_t_5 = __pyx_t_1; __pyx_L25_bool_binop_done:; - if (unlikely(__pyx_t_4)) { + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":157 + /* "l0learn/interface.pyx":240 * if gamma_min < 0 or gamma_min > gamma_max: * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," * f" but got {gamma_min}") # <<<<<<<<<<<<<< * if not isinstance(partial_sort, bool): * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") */ - __pyx_t_2 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 157, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 157, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_7 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - /* "l0learn/interface.pyx":156 + /* "l0learn/interface.pyx":239 * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") * if gamma_min < 0 or gamma_min > gamma_max: * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," # <<<<<<<<<<<<<< * f" but got {gamma_min}") * if not isinstance(partial_sort, bool): */ - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_gamma_max_parameter_to_2, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 156, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 156, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 156, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_gamma_max_parameter_to_2, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 239, __pyx_L1_error) - /* "l0learn/interface.pyx":155 + /* "l0learn/interface.pyx":238 * if gamma_max < 0: * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") * if gamma_min < 0 or gamma_min > gamma_max: # <<<<<<<<<<<<<< @@ -4046,40 +4119,40 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":158 + /* "l0learn/interface.pyx":241 * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," * f" but got {gamma_min}") * if not isinstance(partial_sort, bool): # <<<<<<<<<<<<<< * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") * if not isinstance(max_iter, int) or max_iter < 1: */ - __pyx_t_6 = ((PyObject*)&PyBool_Type); - __Pyx_INCREF(__pyx_t_6); - __pyx_t_4 = PyObject_IsInstance(__pyx_v_partial_sort, __pyx_t_6); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 158, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_1 = ((!(__pyx_t_4 != 0)) != 0); + __pyx_t_3 = ((PyObject*)&PyBool_Type); + __Pyx_INCREF(__pyx_t_3); + __pyx_t_5 = PyObject_IsInstance(__pyx_v_partial_sort, __pyx_t_3); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 241, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = ((!(__pyx_t_5 != 0)) != 0); if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":159 + /* "l0learn/interface.pyx":242 * f" but got {gamma_min}") * if not isinstance(partial_sort, bool): * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") # <<<<<<<<<<<<<< * if not isinstance(max_iter, int) or max_iter < 1: * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") */ - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_partial_sort, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 159, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_partial_sort_parameter, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 159, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 159, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 159, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_partial_sort, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_partial_sort_parameter, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 242, __pyx_L1_error) - /* "l0learn/interface.pyx":158 + /* "l0learn/interface.pyx":241 * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," * f" but got {gamma_min}") * if not isinstance(partial_sort, bool): # <<<<<<<<<<<<<< @@ -4088,47 +4161,47 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":160 + /* "l0learn/interface.pyx":243 * if not isinstance(partial_sort, bool): * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") * if not isinstance(max_iter, int) or max_iter < 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") * if rtol < 0 or rtol >= 1: */ - __pyx_t_4 = PyInt_Check(__pyx_v_max_iter); - __pyx_t_3 = ((!(__pyx_t_4 != 0)) != 0); - if (!__pyx_t_3) { + __pyx_t_5 = PyInt_Check(__pyx_v_max_iter); + __pyx_t_4 = ((!(__pyx_t_5 != 0)) != 0); + if (!__pyx_t_4) { } else { - __pyx_t_1 = __pyx_t_3; + __pyx_t_1 = __pyx_t_4; goto __pyx_L29_bool_binop_done; } - __pyx_t_6 = PyObject_RichCompare(__pyx_v_max_iter, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 160, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 160, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = PyObject_RichCompare(__pyx_v_max_iter, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 243, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 243, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __pyx_t_4; __pyx_L29_bool_binop_done:; if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":161 + /* "l0learn/interface.pyx":244 * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") * if not isinstance(max_iter, int) or max_iter < 1: * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") # <<<<<<<<<<<<<< * if rtol < 0 or rtol >= 1: * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") */ - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_max_iter, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 161, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_iter_parameter_to_b, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 161, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 161, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 161, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_max_iter, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 244, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_iter_parameter_to_b, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 244, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 244, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 244, __pyx_L1_error) - /* "l0learn/interface.pyx":160 + /* "l0learn/interface.pyx":243 * if not isinstance(partial_sort, bool): * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") * if not isinstance(max_iter, int) or max_iter < 1: # <<<<<<<<<<<<<< @@ -4137,47 +4210,47 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":162 + /* "l0learn/interface.pyx":245 * if not isinstance(max_iter, int) or max_iter < 1: * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") * if rtol < 0 or rtol >= 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") * if atol < 0: */ - __pyx_t_3 = ((__pyx_v_rtol < 0.0) != 0); - if (!__pyx_t_3) { + __pyx_t_4 = ((__pyx_v_rtol < 0.0) != 0); + if (!__pyx_t_4) { } else { - __pyx_t_1 = __pyx_t_3; + __pyx_t_1 = __pyx_t_4; goto __pyx_L32_bool_binop_done; } - __pyx_t_3 = ((__pyx_v_rtol >= 1.0) != 0); - __pyx_t_1 = __pyx_t_3; + __pyx_t_4 = ((__pyx_v_rtol >= 1.0) != 0); + __pyx_t_1 = __pyx_t_4; __pyx_L32_bool_binop_done:; if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":163 + /* "l0learn/interface.pyx":246 * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") * if rtol < 0 or rtol >= 1: * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") # <<<<<<<<<<<<<< * if atol < 0: * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") */ - __pyx_t_6 = PyFloat_FromDouble(__pyx_v_rtol); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 163, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_6, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 163, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_rtol_parameter_to_exist, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 163, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 163, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_Raise(__pyx_t_2, 0, 0, 0); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 163, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_rtol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_rtol_parameter_to_exist, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(0, 246, __pyx_L1_error) - /* "l0learn/interface.pyx":162 + /* "l0learn/interface.pyx":245 * if not isinstance(max_iter, int) or max_iter < 1: * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") * if rtol < 0 or rtol >= 1: # <<<<<<<<<<<<<< @@ -4186,7 +4259,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":164 + /* "l0learn/interface.pyx":247 * if rtol < 0 or rtol >= 1: * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") * if atol < 0: # <<<<<<<<<<<<<< @@ -4196,29 +4269,29 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_1 = ((__pyx_v_atol < 0.0) != 0); if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":165 + /* "l0learn/interface.pyx":248 * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") * if atol < 0: * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") # <<<<<<<<<<<<<< * if not isinstance(active_set, bool): * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") */ - __pyx_t_2 = PyFloat_FromDouble(__pyx_v_atol); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 165, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 165, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_atol_parameter_to_exist, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 165, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 165, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 165, __pyx_L1_error) + __pyx_t_7 = PyFloat_FromDouble(__pyx_v_atol); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_atol_parameter_to_exist, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 248, __pyx_L1_error) - /* "l0learn/interface.pyx":164 + /* "l0learn/interface.pyx":247 * if rtol < 0 or rtol >= 1: * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") * if atol < 0: # <<<<<<<<<<<<<< @@ -4227,40 +4300,40 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":166 + /* "l0learn/interface.pyx":249 * if atol < 0: * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") * if not isinstance(active_set, bool): # <<<<<<<<<<<<<< * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") * if not isinstance(active_set_num, int) or active_set_num < 1: */ - __pyx_t_6 = ((PyObject*)&PyBool_Type); - __Pyx_INCREF(__pyx_t_6); - __pyx_t_1 = PyObject_IsInstance(__pyx_v_active_set, __pyx_t_6); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 166, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_3 = ((!(__pyx_t_1 != 0)) != 0); - if (unlikely(__pyx_t_3)) { + __pyx_t_3 = ((PyObject*)&PyBool_Type); + __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = PyObject_IsInstance(__pyx_v_active_set, __pyx_t_3); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 249, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = ((!(__pyx_t_1 != 0)) != 0); + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":167 + /* "l0learn/interface.pyx":250 * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") * if not isinstance(active_set, bool): * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") # <<<<<<<<<<<<<< * if not isinstance(active_set_num, int) or active_set_num < 1: * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") */ - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_active_set, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 167, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_active_set_parameter_to, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 167, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 167, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 167, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_active_set, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_active_set_parameter_to, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 250, __pyx_L1_error) - /* "l0learn/interface.pyx":166 + /* "l0learn/interface.pyx":249 * if atol < 0: * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") * if not isinstance(active_set, bool): # <<<<<<<<<<<<<< @@ -4269,7 +4342,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":168 + /* "l0learn/interface.pyx":251 * if not isinstance(active_set, bool): * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") * if not isinstance(active_set_num, int) or active_set_num < 1: # <<<<<<<<<<<<<< @@ -4277,39 +4350,39 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx * if not isinstance(max_swaps, int) or max_swaps < 1: */ __pyx_t_1 = PyInt_Check(__pyx_v_active_set_num); - __pyx_t_4 = ((!(__pyx_t_1 != 0)) != 0); - if (!__pyx_t_4) { + __pyx_t_5 = ((!(__pyx_t_1 != 0)) != 0); + if (!__pyx_t_5) { } else { - __pyx_t_3 = __pyx_t_4; + __pyx_t_4 = __pyx_t_5; goto __pyx_L37_bool_binop_done; } - __pyx_t_6 = PyObject_RichCompare(__pyx_v_active_set_num, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 168, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 168, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_3 = __pyx_t_4; + __pyx_t_3 = PyObject_RichCompare(__pyx_v_active_set_num, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 251, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 251, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = __pyx_t_5; __pyx_L37_bool_binop_done:; - if (unlikely(__pyx_t_3)) { + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":169 + /* "l0learn/interface.pyx":252 * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") * if not isinstance(active_set_num, int) or active_set_num < 1: * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") # <<<<<<<<<<<<<< * if not isinstance(max_swaps, int) or max_swaps < 1: * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") */ - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_active_set_num, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 169, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_active_set_num_paramete, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 169, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 169, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 169, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_active_set_num, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_active_set_num_paramete, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 252, __pyx_L1_error) - /* "l0learn/interface.pyx":168 + /* "l0learn/interface.pyx":251 * if not isinstance(active_set, bool): * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") * if not isinstance(active_set_num, int) or active_set_num < 1: # <<<<<<<<<<<<<< @@ -4318,47 +4391,47 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":170 + /* "l0learn/interface.pyx":253 * if not isinstance(active_set_num, int) or active_set_num < 1: * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") * if not isinstance(max_swaps, int) or max_swaps < 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") * if not (0 < scale_down_factor < 1): */ - __pyx_t_4 = PyInt_Check(__pyx_v_max_swaps); - __pyx_t_1 = ((!(__pyx_t_4 != 0)) != 0); + __pyx_t_5 = PyInt_Check(__pyx_v_max_swaps); + __pyx_t_1 = ((!(__pyx_t_5 != 0)) != 0); if (!__pyx_t_1) { } else { - __pyx_t_3 = __pyx_t_1; + __pyx_t_4 = __pyx_t_1; goto __pyx_L40_bool_binop_done; } - __pyx_t_6 = PyObject_RichCompare(__pyx_v_max_swaps, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 170, __pyx_L1_error) - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 170, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_3 = __pyx_t_1; + __pyx_t_3 = PyObject_RichCompare(__pyx_v_max_swaps, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 253, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 253, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = __pyx_t_1; __pyx_L40_bool_binop_done:; - if (unlikely(__pyx_t_3)) { + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":171 + /* "l0learn/interface.pyx":254 * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") * if not isinstance(max_swaps, int) or max_swaps < 1: * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") # <<<<<<<<<<<<<< * if not (0 < scale_down_factor < 1): * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") */ - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_max_swaps, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 171, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_swaps_parameter_to, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 171, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 171, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 171, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_max_swaps, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_swaps_parameter_to, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 254, __pyx_L1_error) - /* "l0learn/interface.pyx":170 + /* "l0learn/interface.pyx":253 * if not isinstance(active_set_num, int) or active_set_num < 1: * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") * if not isinstance(max_swaps, int) or max_swaps < 1: # <<<<<<<<<<<<<< @@ -4367,236 +4440,284 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":172 + /* "l0learn/interface.pyx":255 * if not isinstance(max_swaps, int) or max_swaps < 1: * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") * if not (0 < scale_down_factor < 1): # <<<<<<<<<<<<<< * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") - * if not isinstance(screen_size, int) or screen_size < 1: + * if not isinstance(screen_size, int) or screen_size < 1 or screen_size > p: */ - __pyx_t_3 = (0.0 < __pyx_v_scale_down_factor); - if (__pyx_t_3) { - __pyx_t_3 = (__pyx_v_scale_down_factor < 1.0); + __pyx_t_4 = (0.0 < __pyx_v_scale_down_factor); + if (__pyx_t_4) { + __pyx_t_4 = (__pyx_v_scale_down_factor < 1.0); } - __pyx_t_1 = ((!(__pyx_t_3 != 0)) != 0); + __pyx_t_1 = ((!(__pyx_t_4 != 0)) != 0); if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":173 + /* "l0learn/interface.pyx":256 * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") * if not (0 < scale_down_factor < 1): * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") # <<<<<<<<<<<<<< - * if not isinstance(screen_size, int) or screen_size < 1: - * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") + * if not isinstance(screen_size, int) or screen_size < 1 or screen_size > p: + * raise ValueError(f"expected screen_size parameter to be a positive integer less than {p}," */ - __pyx_t_6 = PyFloat_FromDouble(__pyx_v_scale_down_factor); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 173, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_6, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 173, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_scale_down_factor_param, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 173, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 173, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_Raise(__pyx_t_2, 0, 0, 0); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 173, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_scale_down_factor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_scale_down_factor_param, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(0, 256, __pyx_L1_error) - /* "l0learn/interface.pyx":172 + /* "l0learn/interface.pyx":255 * if not isinstance(max_swaps, int) or max_swaps < 1: * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") * if not (0 < scale_down_factor < 1): # <<<<<<<<<<<<<< * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") - * if not isinstance(screen_size, int) or screen_size < 1: + * if not isinstance(screen_size, int) or screen_size < 1 or screen_size > p: */ } - /* "l0learn/interface.pyx":174 + /* "l0learn/interface.pyx":257 * if not (0 < scale_down_factor < 1): * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") - * if not isinstance(screen_size, int) or screen_size < 1: # <<<<<<<<<<<<<< - * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") - * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): + * if not isinstance(screen_size, int) or screen_size < 1 or screen_size > p: # <<<<<<<<<<<<<< + * raise ValueError(f"expected screen_size parameter to be a positive integer less than {p}," + * f" but got {screen_size}") */ - __pyx_t_3 = PyInt_Check(__pyx_v_screen_size); - __pyx_t_4 = ((!(__pyx_t_3 != 0)) != 0); - if (!__pyx_t_4) { + __pyx_t_4 = PyInt_Check(__pyx_v_screen_size); + __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); + if (!__pyx_t_5) { } else { - __pyx_t_1 = __pyx_t_4; + __pyx_t_1 = __pyx_t_5; goto __pyx_L44_bool_binop_done; } - __pyx_t_2 = PyObject_RichCompare(__pyx_v_screen_size, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 174, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 174, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_1 = __pyx_t_4; + __pyx_t_7 = PyObject_RichCompare(__pyx_v_screen_size, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 257, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 257, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (!__pyx_t_5) { + } else { + __pyx_t_1 = __pyx_t_5; + goto __pyx_L44_bool_binop_done; + } + __pyx_t_7 = PyObject_RichCompare(__pyx_v_screen_size, __pyx_v_p, Py_GT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 257, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 257, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_1 = __pyx_t_5; __pyx_L44_bool_binop_done:; if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":175 + /* "l0learn/interface.pyx":258 * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") - * if not isinstance(screen_size, int) or screen_size < 1: - * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") # <<<<<<<<<<<<<< + * if not isinstance(screen_size, int) or screen_size < 1 or screen_size > p: + * raise ValueError(f"expected screen_size parameter to be a positive integer less than {p}," # <<<<<<<<<<<<<< + * f" but got {screen_size}") + * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): + */ + __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 258, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_screen_size_parameter_t); + __pyx_t_9 += 66; + __Pyx_GIVEREF(__pyx_kp_u_expected_screen_size_parameter_t); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_screen_size_parameter_t); + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 258, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_3); + __pyx_t_3 = 0; + __Pyx_INCREF(__pyx_kp_u_but_got); + __pyx_t_9 += 10; + __Pyx_GIVEREF(__pyx_kp_u_but_got); + PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_but_got); + + /* "l0learn/interface.pyx":259 + * if not isinstance(screen_size, int) or screen_size < 1 or screen_size > p: + * raise ValueError(f"expected screen_size parameter to be a positive integer less than {p}," + * f" but got {screen_size}") # <<<<<<<<<<<<<< * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " */ - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_screen_size, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 175, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_screen_size_parameter_t, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 175, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 175, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_Raise(__pyx_t_2, 0, 0, 0); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 175, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_screen_size, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 259, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_3); + __pyx_t_3 = 0; - /* "l0learn/interface.pyx":174 - * if not (0 < scale_down_factor < 1): + /* "l0learn/interface.pyx":258 * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") - * if not isinstance(screen_size, int) or screen_size < 1: # <<<<<<<<<<<<<< - * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") + * if not isinstance(screen_size, int) or screen_size < 1 or screen_size > p: + * raise ValueError(f"expected screen_size parameter to be a positive integer less than {p}," # <<<<<<<<<<<<<< + * f" but got {screen_size}") * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): */ - } - - /* "l0learn/interface.pyx":176 - * if not isinstance(screen_size, int) or screen_size < 1: - * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") + __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 258, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 258, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(0, 258, __pyx_L1_error) + + /* "l0learn/interface.pyx":257 + * if not (0 < scale_down_factor < 1): + * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") + * if not isinstance(screen_size, int) or screen_size < 1 or screen_size > p: # <<<<<<<<<<<<<< + * raise ValueError(f"expected screen_size parameter to be a positive integer less than {p}," + * f" but got {screen_size}") + */ + } + + /* "l0learn/interface.pyx":260 + * raise ValueError(f"expected screen_size parameter to be a positive integer less than {p}," + * f" but got {screen_size}") * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): # <<<<<<<<<<<<<< * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " * f"but got {exclude_first_k}") */ - __pyx_t_4 = PyInt_Check(__pyx_v_exclude_first_k); - __pyx_t_3 = ((!(__pyx_t_4 != 0)) != 0); - if (!__pyx_t_3) { + __pyx_t_5 = PyInt_Check(__pyx_v_exclude_first_k); + __pyx_t_4 = ((!(__pyx_t_5 != 0)) != 0); + if (!__pyx_t_4) { } else { - __pyx_t_1 = __pyx_t_3; - goto __pyx_L47_bool_binop_done; + __pyx_t_1 = __pyx_t_4; + goto __pyx_L48_bool_binop_done; } - __pyx_t_2 = PyObject_RichCompare(__pyx_int_0, __pyx_v_exclude_first_k, Py_LE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 176, __pyx_L1_error) - if (__Pyx_PyObject_IsTrue(__pyx_t_2)) { - __Pyx_DECREF(__pyx_t_2); - __pyx_t_2 = PyObject_RichCompare(__pyx_v_exclude_first_k, __pyx_v_p, Py_LE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 176, __pyx_L1_error) + __pyx_t_7 = PyObject_RichCompare(__pyx_int_0, __pyx_v_exclude_first_k, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 260, __pyx_L1_error) + if (__Pyx_PyObject_IsTrue(__pyx_t_7)) { + __Pyx_DECREF(__pyx_t_7); + __pyx_t_7 = PyObject_RichCompare(__pyx_v_exclude_first_k, __pyx_v_p, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 260, __pyx_L1_error) } - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 176, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = ((!__pyx_t_3) != 0); - __pyx_t_1 = __pyx_t_4; - __pyx_L47_bool_binop_done:; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 260, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_5 = ((!__pyx_t_4) != 0); + __pyx_t_1 = __pyx_t_5; + __pyx_L48_bool_binop_done:; if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":177 - * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") + /* "l0learn/interface.pyx":261 + * f" but got {screen_size}") * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " # <<<<<<<<<<<<<< * f"but got {exclude_first_k}") * if not isinstance(intercept, bool): */ - __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 177, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_expected_exclude_first_k_paramet); __pyx_t_9 += 70; __Pyx_GIVEREF(__pyx_kp_u_expected_exclude_first_k_paramet); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_u_expected_exclude_first_k_paramet); - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 177, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_6); - __pyx_t_6 = 0; + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_exclude_first_k_paramet); + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_3); + __pyx_t_3 = 0; __Pyx_INCREF(__pyx_kp_u_but_got); __pyx_t_9 += 10; __Pyx_GIVEREF(__pyx_kp_u_but_got); - PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_kp_u_but_got); + PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_but_got); - /* "l0learn/interface.pyx":178 + /* "l0learn/interface.pyx":262 * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " * f"but got {exclude_first_k}") # <<<<<<<<<<<<<< * if not isinstance(intercept, bool): * raise ValueError(f"expected intercept parameter to be a bool, " */ - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_exclude_first_k, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 178, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_6); - __pyx_t_6 = 0; + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_exclude_first_k, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 262, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_3); + __pyx_t_3 = 0; - /* "l0learn/interface.pyx":177 - * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") + /* "l0learn/interface.pyx":261 + * f" but got {screen_size}") * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " # <<<<<<<<<<<<<< * f"but got {exclude_first_k}") * if not isinstance(intercept, bool): */ - __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_2, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 177, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 177, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_Raise(__pyx_t_2, 0, 0, 0); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 177, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(0, 261, __pyx_L1_error) - /* "l0learn/interface.pyx":176 - * if not isinstance(screen_size, int) or screen_size < 1: - * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") + /* "l0learn/interface.pyx":260 + * raise ValueError(f"expected screen_size parameter to be a positive integer less than {p}," + * f" but got {screen_size}") * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): # <<<<<<<<<<<<<< * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " * f"but got {exclude_first_k}") */ } - /* "l0learn/interface.pyx":179 + /* "l0learn/interface.pyx":263 * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " * f"but got {exclude_first_k}") * if not isinstance(intercept, bool): # <<<<<<<<<<<<<< * raise ValueError(f"expected intercept parameter to be a bool, " * f"but got {intercept}") */ - __pyx_t_2 = ((PyObject*)&PyBool_Type); - __Pyx_INCREF(__pyx_t_2); - __pyx_t_1 = PyObject_IsInstance(__pyx_v_intercept, __pyx_t_2); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 179, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = ((!(__pyx_t_1 != 0)) != 0); - if (unlikely(__pyx_t_4)) { + __pyx_t_7 = ((PyObject*)&PyBool_Type); + __Pyx_INCREF(__pyx_t_7); + __pyx_t_1 = PyObject_IsInstance(__pyx_v_intercept, __pyx_t_7); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 263, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_5 = ((!(__pyx_t_1 != 0)) != 0); + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":181 + /* "l0learn/interface.pyx":265 * if not isinstance(intercept, bool): * raise ValueError(f"expected intercept parameter to be a bool, " * f"but got {intercept}") # <<<<<<<<<<<<<< * * if loss in CLASSIFICATION_LOSS: */ - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_intercept, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 181, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_intercept, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); - /* "l0learn/interface.pyx":180 + /* "l0learn/interface.pyx":264 * f"but got {exclude_first_k}") * if not isinstance(intercept, bool): * raise ValueError(f"expected intercept parameter to be a bool, " # <<<<<<<<<<<<<< * f"but got {intercept}") * */ - __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_intercept_parameter_to, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 180, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 180, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_Raise(__pyx_t_2, 0, 0, 0); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 180, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_intercept_parameter_to, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(0, 264, __pyx_L1_error) - /* "l0learn/interface.pyx":179 + /* "l0learn/interface.pyx":263 * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " * f"but got {exclude_first_k}") * if not isinstance(intercept, bool): # <<<<<<<<<<<<<< @@ -4605,184 +4726,258 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":183 + /* "l0learn/interface.pyx":267 * f"but got {intercept}") * * if loss in CLASSIFICATION_LOSS: # <<<<<<<<<<<<<< - * if sorted(np.unique(y)) != [-1, 1]: - * raise ValueError(f"expected y vector to only have two unique values (-1 and 1) (Binary Classification), " + * unique_items = sorted(np.unique(y)) + * if 0 >= len(unique_items) > 2: */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_CLASSIFICATION_LOSS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 183, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = (__Pyx_PySequence_ContainsTF(__pyx_v_loss, __pyx_t_2, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 183, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_1 = (__pyx_t_4 != 0); + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_CLASSIFICATION_LOSS); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_v_loss, __pyx_t_7, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 267, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_1 = (__pyx_t_5 != 0); if (__pyx_t_1) { - /* "l0learn/interface.pyx":184 + /* "l0learn/interface.pyx":268 * * if loss in CLASSIFICATION_LOSS: - * if sorted(np.unique(y)) != [-1, 1]: # <<<<<<<<<<<<<< - * raise ValueError(f"expected y vector to only have two unique values (-1 and 1) (Binary Classification), " - * f"but got {np.unique(y)}") + * unique_items = sorted(np.unique(y)) # <<<<<<<<<<<<<< + * if 0 >= len(unique_items) > 2: + * raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 184, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_unique); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_unique); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 268, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = NULL; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); - if (likely(__pyx_t_7)) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); - __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } - __pyx_t_6 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_7, ((PyObject *)__pyx_v_y)) : __Pyx_PyObject_CallOneArg(__pyx_t_8, ((PyObject *)__pyx_v_y)); - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 184, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_2, __pyx_v_y) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_y); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = PySequence_List(__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 184, __pyx_L1_error) + __pyx_t_8 = PySequence_List(__pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 268, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_2 = ((PyObject*)__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = ((PyObject*)__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_12 = PyList_Sort(__pyx_t_2); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 184, __pyx_L1_error) - __pyx_t_8 = PyList_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 184, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_INCREF(__pyx_int_neg_1); - __Pyx_GIVEREF(__pyx_int_neg_1); - PyList_SET_ITEM(__pyx_t_8, 0, __pyx_int_neg_1); - __Pyx_INCREF(__pyx_int_1); - __Pyx_GIVEREF(__pyx_int_1); - PyList_SET_ITEM(__pyx_t_8, 1, __pyx_int_1); - __pyx_t_6 = PyObject_RichCompare(__pyx_t_2, __pyx_t_8, Py_NE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 184, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 184, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(__pyx_t_1)) { + __pyx_t_12 = PyList_Sort(__pyx_t_7); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 268, __pyx_L1_error) + __pyx_v_unique_items = ((PyObject*)__pyx_t_7); + __pyx_t_7 = 0; - /* "l0learn/interface.pyx":186 - * if sorted(np.unique(y)) != [-1, 1]: - * raise ValueError(f"expected y vector to only have two unique values (-1 and 1) (Binary Classification), " - * f"but got {np.unique(y)}") # <<<<<<<<<<<<<< - * - * if penalty == "L0": + /* "l0learn/interface.pyx":269 + * if loss in CLASSIFICATION_LOSS: + * unique_items = sorted(np.unique(y)) + * if 0 >= len(unique_items) > 2: # <<<<<<<<<<<<<< + * raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " + * f"but got {unique_items}") + */ + if (unlikely(__pyx_v_unique_items == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(0, 269, __pyx_L1_error) + } + __pyx_t_9 = PyList_GET_SIZE(__pyx_v_unique_items); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 269, __pyx_L1_error) + __pyx_t_1 = (0 >= __pyx_t_9); + if (__pyx_t_1) { + __pyx_t_1 = (__pyx_t_9 > 2); + } + __pyx_t_5 = (__pyx_t_1 != 0); + if (unlikely(__pyx_t_5)) { + + /* "l0learn/interface.pyx":271 + * if 0 >= len(unique_items) > 2: + * raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " + * f"but got {unique_items}") # <<<<<<<<<<<<<< + * else: + * a, *_ = unique_items # a is the lower value + */ + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_unique_items, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 271, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + + /* "l0learn/interface.pyx":270 + * unique_items = sorted(np.unique(y)) + * if 0 >= len(unique_items) > 2: + * raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " # <<<<<<<<<<<<<< + * f"but got {unique_items}") + * else: */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 186, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_y_vector_to_only_have_t, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 270, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_unique); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 186, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 270, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(0, 270, __pyx_L1_error) + + /* "l0learn/interface.pyx":269 + * if loss in CLASSIFICATION_LOSS: + * unique_items = sorted(np.unique(y)) + * if 0 >= len(unique_items) > 2: # <<<<<<<<<<<<<< + * raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " + * f"but got {unique_items}") + */ + } + + /* "l0learn/interface.pyx":273 + * f"but got {unique_items}") + * else: + * a, *_ = unique_items # a is the lower value # <<<<<<<<<<<<<< + * y = np.copy(y) + * y[y==a] = -1 + */ + /*else*/ { + { + Py_ssize_t index = -1; + PyObject** temps[2] = {&__pyx_t_7}; + __pyx_t_8 = PyObject_GetIter(__pyx_v_unique_items); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_11 = Py_TYPE(__pyx_t_8)->tp_iternext; + for (index=0; index < 1; index++) { + PyObject* item = __pyx_t_11(__pyx_t_8); if (unlikely(!item)) goto __pyx_L53_unpacking_failed; + __Pyx_GOTREF(item); + *(temps[index]) = item; + } + goto __pyx_L54_unpacking_done; + __pyx_L53_unpacking_failed:; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_11 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 273, __pyx_L1_error) + __pyx_L54_unpacking_done:; + } + __pyx_t_3 = PySequence_List(__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_v_a = __pyx_t_7; + __pyx_t_7 = 0; + __pyx_v__ = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "l0learn/interface.pyx":274 + * else: + * a, *_ = unique_items # a is the lower value + * y = np.copy(y) # <<<<<<<<<<<<<< + * y[y==a] = -1 + * y[y!=a] = 1 + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_copy); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); + __Pyx_DECREF_SET(__pyx_t_8, function); } } - __pyx_t_6 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_8, ((PyObject *)__pyx_v_y)) : __Pyx_PyObject_CallOneArg(__pyx_t_2, ((PyObject *)__pyx_v_y)); - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 186, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_6, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 186, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_7, __pyx_v_y) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_y); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF_SET(__pyx_v_y, __pyx_t_3); + __pyx_t_3 = 0; - /* "l0learn/interface.pyx":185 - * if loss in CLASSIFICATION_LOSS: - * if sorted(np.unique(y)) != [-1, 1]: - * raise ValueError(f"expected y vector to only have two unique values (-1 and 1) (Binary Classification), " # <<<<<<<<<<<<<< - * f"but got {np.unique(y)}") + /* "l0learn/interface.pyx":275 + * a, *_ = unique_items # a is the lower value + * y = np.copy(y) + * y[y==a] = -1 # <<<<<<<<<<<<<< + * y[y!=a] = 1 * */ - __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_y_vector_to_only_have_t, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 185, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 185, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_Raise(__pyx_t_2, 0, 0, 0); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 185, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_y, __pyx_v_a, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 275, __pyx_L1_error) + if (unlikely(PyObject_SetItem(__pyx_v_y, __pyx_t_3, __pyx_int_neg_1) < 0)) __PYX_ERR(0, 275, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":184 + /* "l0learn/interface.pyx":276 + * y = np.copy(y) + * y[y==a] = -1 + * y[y!=a] = 1 # <<<<<<<<<<<<<< * - * if loss in CLASSIFICATION_LOSS: - * if sorted(np.unique(y)) != [-1, 1]: # <<<<<<<<<<<<<< - * raise ValueError(f"expected y vector to only have two unique values (-1 and 1) (Binary Classification), " - * f"but got {np.unique(y)}") + * if penalty == "L0": */ + __pyx_t_3 = PyObject_RichCompare(__pyx_v_y, __pyx_v_a, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 276, __pyx_L1_error) + if (unlikely(PyObject_SetItem(__pyx_v_y, __pyx_t_3, __pyx_int_1) < 0)) __PYX_ERR(0, 276, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } - /* "l0learn/interface.pyx":188 - * f"but got {np.unique(y)}") + /* "l0learn/interface.pyx":278 + * y[y!=a] = 1 * * if penalty == "L0": # <<<<<<<<<<<<<< * # TODO: Must be corrected in R code: https://github.com/hazimehh/L0Learn/blob/7a65474dfdb01489a0c263d7b24fbafad56fba61/R/fit.R#L136 * # Pure L0 is not supported for classification */ - __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 188, __pyx_L1_error) - __pyx_t_4 = (__pyx_t_1 != 0); - if (__pyx_t_4) { + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 278, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_5 != 0); + if (__pyx_t_1) { - /* "l0learn/interface.pyx":193 + /* "l0learn/interface.pyx":283 * # Below we add a small L2 component. * * if len(lambda_grid) != 1: # <<<<<<<<<<<<<< * # If this error checking was left to the lower section, it would confuse users as * # we are converting L0 to L0L2 with small L2 penalty. */ - __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 193, __pyx_L1_error) - __pyx_t_4 = ((__pyx_t_9 != 1) != 0); - if (unlikely(__pyx_t_4)) { + __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 283, __pyx_L1_error) + __pyx_t_1 = ((__pyx_t_9 != 1) != 0); + if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":198 + /* "l0learn/interface.pyx":288 * # Here we must check if lambdaGrid is supplied (And thus use 'autolambda') * # If 'lambdaGrid' is supplied, we must only supply 1 list of lambda values * raise ValueError(f"L0 Penalty requires 'lambda_grid' to be a list of length 1, but got {lambda_grid}.") # <<<<<<<<<<<<<< * * penalty = "L0L2" */ - __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 198, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_L0_Penalty_requires_lambda_grid); __pyx_t_9 += 68; __Pyx_GIVEREF(__pyx_kp_u_L0_Penalty_requires_lambda_grid); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_u_L0_Penalty_requires_lambda_grid); - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 198, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_6); - __pyx_t_6 = 0; + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_L0_Penalty_requires_lambda_grid); + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_8); + __pyx_t_8 = 0; __Pyx_INCREF(__pyx_kp_u__5); __pyx_t_9 += 1; __Pyx_GIVEREF(__pyx_kp_u__5); - PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_kp_u__5); - __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_2, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 198, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 198, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_Raise(__pyx_t_2, 0, 0, 0); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 198, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u__5); + __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 288, __pyx_L1_error) - /* "l0learn/interface.pyx":193 + /* "l0learn/interface.pyx":283 * # Below we add a small L2 component. * * if len(lambda_grid) != 1: # <<<<<<<<<<<<<< @@ -4791,8 +4986,8 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":188 - * f"but got {np.unique(y)}") + /* "l0learn/interface.pyx":278 + * y[y!=a] = 1 * * if penalty == "L0": # <<<<<<<<<<<<<< * # TODO: Must be corrected in R code: https://github.com/hazimehh/L0Learn/blob/7a65474dfdb01489a0c263d7b24fbafad56fba61/R/fit.R#L136 @@ -4800,7 +4995,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":200 + /* "l0learn/interface.pyx":290 * raise ValueError(f"L0 Penalty requires 'lambda_grid' to be a list of length 1, but got {lambda_grid}.") * * penalty = "L0L2" # <<<<<<<<<<<<<< @@ -4810,65 +5005,162 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_INCREF(__pyx_n_u_L0L2); __Pyx_DECREF_SET(__pyx_v_penalty, __pyx_n_u_L0L2); - /* "l0learn/interface.pyx":201 + /* "l0learn/interface.pyx":291 * * penalty = "L0L2" * gamma_max = 1e-7 # <<<<<<<<<<<<<< * gamma_min = 1e-7 - * + * elif penalty != "L0" and num_gamma == 1: */ __pyx_v_gamma_max = 1e-7; - /* "l0learn/interface.pyx":202 + /* "l0learn/interface.pyx":292 * penalty = "L0L2" * gamma_max = 1e-7 * gamma_min = 1e-7 # <<<<<<<<<<<<<< - * - * if lambda_grid is None: + * elif penalty != "L0" and num_gamma == 1: + * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") */ __pyx_v_gamma_min = 1e-7; - /* "l0learn/interface.pyx":183 + /* "l0learn/interface.pyx":267 * f"but got {intercept}") * * if loss in CLASSIFICATION_LOSS: # <<<<<<<<<<<<<< - * if sorted(np.unique(y)) != [-1, 1]: - * raise ValueError(f"expected y vector to only have two unique values (-1 and 1) (Binary Classification), " + * unique_items = sorted(np.unique(y)) + * if 0 >= len(unique_items) > 2: + */ + goto __pyx_L51; + } + + /* "l0learn/interface.pyx":293 + * gamma_max = 1e-7 + * gamma_min = 1e-7 + * elif penalty != "L0" and num_gamma == 1: # <<<<<<<<<<<<<< + * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") + * */ + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_NE)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 293, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_5 != 0); + if (__pyx_t_4) { + } else { + __pyx_t_1 = __pyx_t_4; + goto __pyx_L57_bool_binop_done; } + __pyx_t_3 = __Pyx_PyInt_EqObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 293, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __pyx_t_4; + __pyx_L57_bool_binop_done:; + if (__pyx_t_1) { - /* "l0learn/interface.pyx":204 + /* "l0learn/interface.pyx":294 * gamma_min = 1e-7 + * elif penalty != "L0" and num_gamma == 1: + * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") # <<<<<<<<<<<<<< + * + * if lambda_grid is None: + */ + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_warn); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 294, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = PyTuple_New(5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 294, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_num_gamma_set_to_1_with); + __pyx_t_9 += 24; + __Pyx_GIVEREF(__pyx_kp_u_num_gamma_set_to_1_with); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_num_gamma_set_to_1_with); + __pyx_t_2 = __Pyx_PyUnicode_Unicode(__pyx_v_penalty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 294, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_kp_u_penalty_Only_one); + __pyx_t_9 += 19; + __Pyx_GIVEREF(__pyx_kp_u_penalty_Only_one); + PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_penalty_Only_one); + if (unlikely(__pyx_v_penalty == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 294, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_PyUnicode_Substring(__pyx_v_penalty, 2, PY_SSIZE_T_MAX); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 294, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_kp_u_penalty_value_will_be_fit); + __pyx_t_9 += 27; + __Pyx_GIVEREF(__pyx_kp_u_penalty_value_will_be_fit); + PyTuple_SET_ITEM(__pyx_t_7, 4, __pyx_kp_u_penalty_value_will_be_fit); + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_7, 5, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 294, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + } + } + __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_7, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_2); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 294, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "l0learn/interface.pyx":293 + * gamma_max = 1e-7 + * gamma_min = 1e-7 + * elif penalty != "L0" and num_gamma == 1: # <<<<<<<<<<<<<< + * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") + * + */ + } + __pyx_L51:; + + /* "l0learn/interface.pyx":296 + * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") * * if lambda_grid is None: # <<<<<<<<<<<<<< * lambda_grid = [[0.]] * auto_lambda = True */ - __pyx_t_4 = (__pyx_v_lambda_grid == Py_None); - __pyx_t_1 = (__pyx_t_4 != 0); - if (__pyx_t_1) { + __pyx_t_1 = (__pyx_v_lambda_grid == Py_None); + __pyx_t_4 = (__pyx_t_1 != 0); + if (__pyx_t_4) { - /* "l0learn/interface.pyx":205 + /* "l0learn/interface.pyx":297 * * if lambda_grid is None: * lambda_grid = [[0.]] # <<<<<<<<<<<<<< * auto_lambda = True * if not isinstance(num_lambda, int) or num_lambda < 1: */ - __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 205, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_float_0_); __Pyx_GIVEREF(__pyx_float_0_); - PyList_SET_ITEM(__pyx_t_2, 0, __pyx_float_0_); - __pyx_t_6 = PyList_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 205, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_2); - PyList_SET_ITEM(__pyx_t_6, 0, __pyx_t_2); - __pyx_t_2 = 0; - __Pyx_DECREF_SET(__pyx_v_lambda_grid, __pyx_t_6); - __pyx_t_6 = 0; + PyList_SET_ITEM(__pyx_t_3, 0, __pyx_float_0_); + __pyx_t_8 = PyList_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_3); + PyList_SET_ITEM(__pyx_t_8, 0, __pyx_t_3); + __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_lambda_grid, __pyx_t_8); + __pyx_t_8 = 0; - /* "l0learn/interface.pyx":206 + /* "l0learn/interface.pyx":298 * if lambda_grid is None: * lambda_grid = [[0.]] * auto_lambda = True # <<<<<<<<<<<<<< @@ -4877,64 +5169,64 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ __pyx_v_auto_lambda = 1; - /* "l0learn/interface.pyx":207 + /* "l0learn/interface.pyx":299 * lambda_grid = [[0.]] * auto_lambda = True * if not isinstance(num_lambda, int) or num_lambda < 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") * if not isinstance(num_gamma, int) or num_gamma < 1: */ - __pyx_t_4 = PyInt_Check(__pyx_v_num_lambda); - __pyx_t_3 = ((!(__pyx_t_4 != 0)) != 0); - if (!__pyx_t_3) { + __pyx_t_1 = PyInt_Check(__pyx_v_num_lambda); + __pyx_t_5 = ((!(__pyx_t_1 != 0)) != 0); + if (!__pyx_t_5) { } else { - __pyx_t_1 = __pyx_t_3; - goto __pyx_L56_bool_binop_done; - } - __pyx_t_6 = PyObject_RichCompare(__pyx_v_num_lambda, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 207, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 207, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_1 = __pyx_t_3; - __pyx_L56_bool_binop_done:; - if (unlikely(__pyx_t_1)) { + __pyx_t_4 = __pyx_t_5; + goto __pyx_L61_bool_binop_done; + } + __pyx_t_8 = PyObject_RichCompare(__pyx_v_num_lambda, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 299, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 299, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_4 = __pyx_t_5; + __pyx_L61_bool_binop_done:; + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":208 + /* "l0learn/interface.pyx":300 * auto_lambda = True * if not isinstance(num_lambda, int) or num_lambda < 1: * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") # <<<<<<<<<<<<<< * if not isinstance(num_gamma, int) or num_gamma < 1: * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") */ - __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 208, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 300, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_expected_num_lambda_to_a_positiv); __pyx_t_9 += 76; __Pyx_GIVEREF(__pyx_kp_u_expected_num_lambda_to_a_positiv); - PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_num_lambda_to_a_positiv); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 208, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_2); - __pyx_t_2 = 0; + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_u_expected_num_lambda_to_a_positiv); + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 300, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_3); + __pyx_t_3 = 0; __Pyx_INCREF(__pyx_kp_u__5); __pyx_t_9 += 1; __Pyx_GIVEREF(__pyx_kp_u__5); - PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u__5); - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_6, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 208, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 208, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 208, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__5); + __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 300, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 300, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(0, 300, __pyx_L1_error) - /* "l0learn/interface.pyx":207 + /* "l0learn/interface.pyx":299 * lambda_grid = [[0.]] * auto_lambda = True * if not isinstance(num_lambda, int) or num_lambda < 1: # <<<<<<<<<<<<<< @@ -4943,64 +5235,64 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":209 + /* "l0learn/interface.pyx":301 * if not isinstance(num_lambda, int) or num_lambda < 1: * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") * if not isinstance(num_gamma, int) or num_gamma < 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") * if penalty == "L0" and num_gamma != 1: */ - __pyx_t_3 = PyInt_Check(__pyx_v_num_gamma); - __pyx_t_4 = ((!(__pyx_t_3 != 0)) != 0); - if (!__pyx_t_4) { + __pyx_t_5 = PyInt_Check(__pyx_v_num_gamma); + __pyx_t_1 = ((!(__pyx_t_5 != 0)) != 0); + if (!__pyx_t_1) { } else { - __pyx_t_1 = __pyx_t_4; - goto __pyx_L59_bool_binop_done; + __pyx_t_4 = __pyx_t_1; + goto __pyx_L64_bool_binop_done; } - __pyx_t_6 = PyObject_RichCompare(__pyx_v_num_gamma, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 209, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 209, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_1 = __pyx_t_4; - __pyx_L59_bool_binop_done:; - if (unlikely(__pyx_t_1)) { + __pyx_t_8 = PyObject_RichCompare(__pyx_v_num_gamma, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 301, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 301, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_4 = __pyx_t_1; + __pyx_L64_bool_binop_done:; + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":210 + /* "l0learn/interface.pyx":302 * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") * if not isinstance(num_gamma, int) or num_gamma < 1: * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") # <<<<<<<<<<<<<< * if penalty == "L0" and num_gamma != 1: * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") */ - __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 210, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 302, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_expected_num_gamma_to_a_positive); __pyx_t_9 += 75; __Pyx_GIVEREF(__pyx_kp_u_expected_num_gamma_to_a_positive); - PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_num_gamma_to_a_positive); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 210, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_2); - __pyx_t_2 = 0; + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_u_expected_num_gamma_to_a_positive); + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 302, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_3); + __pyx_t_3 = 0; __Pyx_INCREF(__pyx_kp_u__5); __pyx_t_9 += 1; __Pyx_GIVEREF(__pyx_kp_u__5); - PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u__5); - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_6, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 210, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 210, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 210, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__5); + __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 302, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 302, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(0, 302, __pyx_L1_error) - /* "l0learn/interface.pyx":209 + /* "l0learn/interface.pyx":301 * if not isinstance(num_lambda, int) or num_lambda < 1: * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") * if not isinstance(num_gamma, int) or num_gamma < 1: # <<<<<<<<<<<<<< @@ -5009,65 +5301,65 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":211 + /* "l0learn/interface.pyx":303 * if not isinstance(num_gamma, int) or num_gamma < 1: * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") * else: # lambda_grid should be a List[List[float]] */ - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 211, __pyx_L1_error) - __pyx_t_3 = (__pyx_t_4 != 0); - if (__pyx_t_3) { + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 303, __pyx_L1_error) + __pyx_t_5 = (__pyx_t_1 != 0); + if (__pyx_t_5) { } else { - __pyx_t_1 = __pyx_t_3; - goto __pyx_L62_bool_binop_done; - } - __pyx_t_6 = __Pyx_PyInt_NeObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 211, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 211, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_1 = __pyx_t_3; - __pyx_L62_bool_binop_done:; - if (unlikely(__pyx_t_1)) { + __pyx_t_4 = __pyx_t_5; + goto __pyx_L67_bool_binop_done; + } + __pyx_t_8 = __Pyx_PyInt_NeObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 303, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 303, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_4 = __pyx_t_5; + __pyx_L67_bool_binop_done:; + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":212 + /* "l0learn/interface.pyx":304 * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") * if penalty == "L0" and num_gamma != 1: * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") # <<<<<<<<<<<<<< * else: # lambda_grid should be a List[List[float]] * if num_gamma is not None: */ - __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 212, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 304, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_expected_num_gamma_to_1_when_pen); __pyx_t_9 += 53; __Pyx_GIVEREF(__pyx_kp_u_expected_num_gamma_to_1_when_pen); - PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_num_gamma_to_1_when_pen); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 212, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_2); - __pyx_t_2 = 0; + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_u_expected_num_gamma_to_1_when_pen); + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 304, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_3); + __pyx_t_3 = 0; __Pyx_INCREF(__pyx_kp_u__5); __pyx_t_9 += 1; __Pyx_GIVEREF(__pyx_kp_u__5); - PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u__5); - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_6, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 212, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 212, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 212, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__5); + __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 304, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 304, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(0, 304, __pyx_L1_error) - /* "l0learn/interface.pyx":211 + /* "l0learn/interface.pyx":303 * if not isinstance(num_gamma, int) or num_gamma < 1: * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< @@ -5076,17 +5368,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":204 - * gamma_min = 1e-7 + /* "l0learn/interface.pyx":296 + * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") * * if lambda_grid is None: # <<<<<<<<<<<<<< * lambda_grid = [[0.]] * auto_lambda = True */ - goto __pyx_L54; + goto __pyx_L59; } - /* "l0learn/interface.pyx":214 + /* "l0learn/interface.pyx":306 * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") * else: # lambda_grid should be a List[List[float]] * if num_gamma is not None: # <<<<<<<<<<<<<< @@ -5094,38 +5386,38 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx * f"but got {num_gamma}") */ /*else*/ { - __pyx_t_1 = (__pyx_v_num_gamma != Py_None); - __pyx_t_3 = (__pyx_t_1 != 0); - if (unlikely(__pyx_t_3)) { + __pyx_t_4 = (__pyx_v_num_gamma != Py_None); + __pyx_t_5 = (__pyx_t_4 != 0); + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":216 + /* "l0learn/interface.pyx":308 * if num_gamma is not None: * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " * f"but got {num_gamma}") # <<<<<<<<<<<<<< * num_gamma = len(lambda_grid) * */ - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 216, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 308, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); - /* "l0learn/interface.pyx":215 + /* "l0learn/interface.pyx":307 * else: # lambda_grid should be a List[List[float]] * if num_gamma is not None: * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " # <<<<<<<<<<<<<< * f"but got {num_gamma}") * num_gamma = len(lambda_grid) */ - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_gamma_to_be_None_if, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 215, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 215, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 215, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_gamma_to_be_None_if, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 307, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 307, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(0, 307, __pyx_L1_error) - /* "l0learn/interface.pyx":214 + /* "l0learn/interface.pyx":306 * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") * else: # lambda_grid should be a List[List[float]] * if num_gamma is not None: # <<<<<<<<<<<<<< @@ -5134,58 +5426,58 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":217 + /* "l0learn/interface.pyx":309 * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " * f"but got {num_gamma}") * num_gamma = len(lambda_grid) # <<<<<<<<<<<<<< * * if num_lambda is not None: */ - __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 217, __pyx_L1_error) - __pyx_t_6 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 217, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF_SET(__pyx_v_num_gamma, __pyx_t_6); - __pyx_t_6 = 0; + __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 309, __pyx_L1_error) + __pyx_t_8 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 309, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF_SET(__pyx_v_num_gamma, __pyx_t_8); + __pyx_t_8 = 0; - /* "l0learn/interface.pyx":219 + /* "l0learn/interface.pyx":311 * num_gamma = len(lambda_grid) * * if num_lambda is not None: # <<<<<<<<<<<<<< * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " * f"but got {num_lambda}") */ - __pyx_t_3 = (__pyx_v_num_lambda != Py_None); - __pyx_t_1 = (__pyx_t_3 != 0); - if (unlikely(__pyx_t_1)) { + __pyx_t_5 = (__pyx_v_num_lambda != Py_None); + __pyx_t_4 = (__pyx_t_5 != 0); + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":221 + /* "l0learn/interface.pyx":313 * if num_lambda is not None: * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " * f"but got {num_lambda}") # <<<<<<<<<<<<<< * num_lambda = 0 # This value is ignored. * auto_lambda = False */ - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 221, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 313, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); - /* "l0learn/interface.pyx":220 + /* "l0learn/interface.pyx":312 * * if num_lambda is not None: * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " # <<<<<<<<<<<<<< * f"but got {num_lambda}") * num_lambda = 0 # This value is ignored. */ - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_lambda_to_be_None_i, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 220, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 220, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 220, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_lambda_to_be_None_i, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 312, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 312, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(0, 312, __pyx_L1_error) - /* "l0learn/interface.pyx":219 + /* "l0learn/interface.pyx":311 * num_gamma = len(lambda_grid) * * if num_lambda is not None: # <<<<<<<<<<<<<< @@ -5194,7 +5486,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":222 + /* "l0learn/interface.pyx":314 * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " * f"but got {num_lambda}") * num_lambda = 0 # This value is ignored. # <<<<<<<<<<<<<< @@ -5204,7 +5496,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_INCREF(__pyx_int_0); __Pyx_DECREF_SET(__pyx_v_num_lambda, __pyx_int_0); - /* "l0learn/interface.pyx":223 + /* "l0learn/interface.pyx":315 * f"but got {num_lambda}") * num_lambda = 0 # This value is ignored. * auto_lambda = False # <<<<<<<<<<<<<< @@ -5213,7 +5505,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ __pyx_v_auto_lambda = 0; - /* "l0learn/interface.pyx":224 + /* "l0learn/interface.pyx":316 * num_lambda = 0 # This value is ignored. * auto_lambda = False * bad_lambda_grid = False # <<<<<<<<<<<<<< @@ -5222,49 +5514,49 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ __pyx_v_bad_lambda_grid = 0; - /* "l0learn/interface.pyx":226 + /* "l0learn/interface.pyx":318 * bad_lambda_grid = False * * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") * */ - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 226, __pyx_L1_error) - __pyx_t_4 = (__pyx_t_3 != 0); - if (__pyx_t_4) { + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 318, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_5 != 0); + if (__pyx_t_1) { } else { - __pyx_t_1 = __pyx_t_4; - goto __pyx_L67_bool_binop_done; + __pyx_t_4 = __pyx_t_1; + goto __pyx_L72_bool_binop_done; } - __pyx_t_6 = __Pyx_PyInt_NeObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 226, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 226, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_1 = __pyx_t_4; - __pyx_L67_bool_binop_done:; - if (unlikely(__pyx_t_1)) { + __pyx_t_8 = __Pyx_PyInt_NeObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 318, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 318, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_4 = __pyx_t_1; + __pyx_L72_bool_binop_done:; + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":227 + /* "l0learn/interface.pyx":319 * * if penalty == "L0" and num_gamma != 1: * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") # <<<<<<<<<<<<<< * * for i, sub_lambda_grid in enumerate(lambda_grid): */ - __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 227, __pyx_L1_error) - __pyx_t_6 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_9, 0, ' ', 'd'); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 227, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_of_lengt, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 227, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 227, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 227, __pyx_L1_error) + __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 319, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_9, 0, ' ', 'd'); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 319, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_of_lengt, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 319, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 319, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(0, 319, __pyx_L1_error) - /* "l0learn/interface.pyx":226 + /* "l0learn/interface.pyx":318 * bad_lambda_grid = False * * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< @@ -5273,7 +5565,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":229 + /* "l0learn/interface.pyx":321 * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") * * for i, sub_lambda_grid in enumerate(lambda_grid): # <<<<<<<<<<<<<< @@ -5281,89 +5573,89 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx * if sub_lambda_grid[0] <= 0: */ __Pyx_INCREF(__pyx_int_0); - __pyx_t_6 = __pyx_int_0; + __pyx_t_8 = __pyx_int_0; if (likely(PyList_CheckExact(__pyx_v_lambda_grid)) || PyTuple_CheckExact(__pyx_v_lambda_grid)) { - __pyx_t_2 = __pyx_v_lambda_grid; __Pyx_INCREF(__pyx_t_2); __pyx_t_9 = 0; + __pyx_t_3 = __pyx_v_lambda_grid; __Pyx_INCREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_13 = NULL; } else { - __pyx_t_9 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_lambda_grid); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 229, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_13 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 229, __pyx_L1_error) + __pyx_t_9 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_lambda_grid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 321, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_13 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 321, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_13)) { - if (likely(PyList_CheckExact(__pyx_t_2))) { - if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_2)) break; + if (likely(PyList_CheckExact(__pyx_t_3))) { + if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_8 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_9); __Pyx_INCREF(__pyx_t_8); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 229, __pyx_L1_error) + __pyx_t_2 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_9); __Pyx_INCREF(__pyx_t_2); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 321, __pyx_L1_error) #else - __pyx_t_8 = PySequence_ITEM(__pyx_t_2, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 229, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); + __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 321, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); #endif } else { - if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_2)) break; + if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_9); __Pyx_INCREF(__pyx_t_8); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 229, __pyx_L1_error) + __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_9); __Pyx_INCREF(__pyx_t_2); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 321, __pyx_L1_error) #else - __pyx_t_8 = PySequence_ITEM(__pyx_t_2, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 229, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); + __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 321, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); #endif } } else { - __pyx_t_8 = __pyx_t_13(__pyx_t_2); - if (unlikely(!__pyx_t_8)) { + __pyx_t_2 = __pyx_t_13(__pyx_t_3); + if (unlikely(!__pyx_t_2)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(0, 229, __pyx_L1_error) + else __PYX_ERR(0, 321, __pyx_L1_error) } break; } - __Pyx_GOTREF(__pyx_t_8); + __Pyx_GOTREF(__pyx_t_2); } - __Pyx_XDECREF_SET(__pyx_v_sub_lambda_grid, __pyx_t_8); - __pyx_t_8 = 0; - __Pyx_INCREF(__pyx_t_6); - __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_6); - __pyx_t_8 = __Pyx_PyInt_AddObjC(__pyx_t_6, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 229, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_6); - __pyx_t_6 = __pyx_t_8; - __pyx_t_8 = 0; + __Pyx_XDECREF_SET(__pyx_v_sub_lambda_grid, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_t_8); + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_8); + __pyx_t_2 = __Pyx_PyInt_AddObjC(__pyx_t_8, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 321, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_8); + __pyx_t_8 = __pyx_t_2; + __pyx_t_2 = 0; - /* "l0learn/interface.pyx":230 + /* "l0learn/interface.pyx":322 * * for i, sub_lambda_grid in enumerate(lambda_grid): * current = float("inf") # <<<<<<<<<<<<<< * if sub_lambda_grid[0] <= 0: * raise ValueError(f"Expected all values of lambda_grid to be positive, " */ - __pyx_t_14 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 230, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 322, __pyx_L1_error) __pyx_v_current = __pyx_t_14; - /* "l0learn/interface.pyx":231 + /* "l0learn/interface.pyx":323 * for i, sub_lambda_grid in enumerate(lambda_grid): * current = float("inf") * if sub_lambda_grid[0] <= 0: # <<<<<<<<<<<<<< * raise ValueError(f"Expected all values of lambda_grid to be positive, " * f"but got lambda_grid[{i}] containing a negative value") */ - __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_sub_lambda_grid, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 231, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = PyObject_RichCompare(__pyx_t_8, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 231, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 231, __pyx_L1_error) + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_sub_lambda_grid, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 323, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = PyObject_RichCompare(__pyx_t_2, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 323, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 323, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(__pyx_t_1)) { + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":232 + /* "l0learn/interface.pyx":324 * current = float("inf") * if sub_lambda_grid[0] <= 0: * raise ValueError(f"Expected all values of lambda_grid to be positive, " # <<<<<<<<<<<<<< * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): */ - __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 232, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 324, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_15 = 0; __pyx_t_10 = 127; @@ -5372,43 +5664,43 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_GIVEREF(__pyx_kp_u_Expected_all_values_of_lambda_gr); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_Expected_all_values_of_lambda_gr); - /* "l0learn/interface.pyx":233 + /* "l0learn/interface.pyx":325 * if sub_lambda_grid[0] <= 0: * raise ValueError(f"Expected all values of lambda_grid to be positive, " * f"but got lambda_grid[{i}] containing a negative value") # <<<<<<<<<<<<<< * if any(np.diff(sub_lambda_grid) >= 0): * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " */ - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 233, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; - __pyx_t_15 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); - __Pyx_GIVEREF(__pyx_t_8); - PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_8); - __pyx_t_8 = 0; + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 325, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_15 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_2); + __pyx_t_2 = 0; __Pyx_INCREF(__pyx_kp_u_containing_a_negative_value); __pyx_t_15 += 29; __Pyx_GIVEREF(__pyx_kp_u_containing_a_negative_value); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_containing_a_negative_value); - /* "l0learn/interface.pyx":232 + /* "l0learn/interface.pyx":324 * current = float("inf") * if sub_lambda_grid[0] <= 0: * raise ValueError(f"Expected all values of lambda_grid to be positive, " # <<<<<<<<<<<<<< * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): */ - __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 232, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 324, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 232, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 324, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 232, __pyx_L1_error) + __PYX_ERR(0, 324, __pyx_L1_error) - /* "l0learn/interface.pyx":231 + /* "l0learn/interface.pyx":323 * for i, sub_lambda_grid in enumerate(lambda_grid): * current = float("inf") * if sub_lambda_grid[0] <= 0: # <<<<<<<<<<<<<< @@ -5417,50 +5709,50 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":234 + /* "l0learn/interface.pyx":326 * raise ValueError(f"Expected all values of lambda_grid to be positive, " * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): # <<<<<<<<<<<<<< * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " * f"but got lambda_grid[{i}] containing an increasing value.") */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 234, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_diff); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 326, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_diff); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 326, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = NULL; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_16))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_16); - if (likely(__pyx_t_8)) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_16); + if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_16); - __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_16, function); } } - __pyx_t_7 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_16, __pyx_t_8, __pyx_v_sub_lambda_grid) : __Pyx_PyObject_CallOneArg(__pyx_t_16, __pyx_v_sub_lambda_grid); - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 234, __pyx_L1_error) + __pyx_t_7 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_16, __pyx_t_2, __pyx_v_sub_lambda_grid) : __Pyx_PyObject_CallOneArg(__pyx_t_16, __pyx_v_sub_lambda_grid); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 326, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_16 = PyObject_RichCompare(__pyx_t_7, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_16); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 234, __pyx_L1_error) + __pyx_t_16 = PyObject_RichCompare(__pyx_t_7, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_16); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 326, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_16); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 234, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_16); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 326, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 234, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 326, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(__pyx_t_1)) { + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":235 + /* "l0learn/interface.pyx":327 * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " # <<<<<<<<<<<<<< * f"but got lambda_grid[{i}] containing an increasing value.") * */ - __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 235, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 327, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_15 = 0; __pyx_t_10 = 127; @@ -5469,14 +5761,14 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_GIVEREF(__pyx_kp_u_Expected_each_element_of_lambda); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_Expected_each_element_of_lambda); - /* "l0learn/interface.pyx":236 + /* "l0learn/interface.pyx":328 * if any(np.diff(sub_lambda_grid) >= 0): * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " * f"but got lambda_grid[{i}] containing an increasing value.") # <<<<<<<<<<<<<< * * n, p = X.shape */ - __pyx_t_16 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 236, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 328, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_16) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_16) : __pyx_t_10; __pyx_t_15 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_16); @@ -5488,24 +5780,24 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_GIVEREF(__pyx_kp_u_containing_an_increasing_value); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_containing_an_increasing_value); - /* "l0learn/interface.pyx":235 + /* "l0learn/interface.pyx":327 * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " # <<<<<<<<<<<<<< * f"but got lambda_grid[{i}] containing an increasing value.") * */ - __pyx_t_16 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 235, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 327, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_16); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 235, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_16); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 327, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 235, __pyx_L1_error) + __PYX_ERR(0, 327, __pyx_L1_error) - /* "l0learn/interface.pyx":234 + /* "l0learn/interface.pyx":326 * raise ValueError(f"Expected all values of lambda_grid to be positive, " * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): # <<<<<<<<<<<<<< @@ -5514,7 +5806,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":229 + /* "l0learn/interface.pyx":321 * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") * * for i, sub_lambda_grid in enumerate(lambda_grid): # <<<<<<<<<<<<<< @@ -5522,72 +5814,72 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx * if sub_lambda_grid[0] <= 0: */ } - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } - __pyx_L54:; + __pyx_L59:; - /* "l0learn/interface.pyx":238 + /* "l0learn/interface.pyx":330 * f"but got lambda_grid[{i}] containing an increasing value.") * * n, p = X.shape # <<<<<<<<<<<<<< * with_bounds = False * */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 238, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if ((likely(PyTuple_CheckExact(__pyx_t_6))) || (PyList_CheckExact(__pyx_t_6))) { - PyObject* sequence = __pyx_t_6; + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 330, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if ((likely(PyTuple_CheckExact(__pyx_t_8))) || (PyList_CheckExact(__pyx_t_8))) { + PyObject* sequence = __pyx_t_8; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 238, __pyx_L1_error) + __PYX_ERR(0, 330, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_7 = PyTuple_GET_ITEM(sequence, 1); } else { - __pyx_t_2 = PyList_GET_ITEM(sequence, 0); + __pyx_t_3 = PyList_GET_ITEM(sequence, 0); __pyx_t_7 = PyList_GET_ITEM(sequence, 1); } - __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_7); #else - __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 238, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 238, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 330, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 330, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); #endif - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { Py_ssize_t index = -1; - __pyx_t_16 = PyObject_GetIter(__pyx_t_6); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 238, __pyx_L1_error) + __pyx_t_16 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 330, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_11 = Py_TYPE(__pyx_t_16)->tp_iternext; - index = 0; __pyx_t_2 = __pyx_t_11(__pyx_t_16); if (unlikely(!__pyx_t_2)) goto __pyx_L73_unpacking_failed; - __Pyx_GOTREF(__pyx_t_2); - index = 1; __pyx_t_7 = __pyx_t_11(__pyx_t_16); if (unlikely(!__pyx_t_7)) goto __pyx_L73_unpacking_failed; + index = 0; __pyx_t_3 = __pyx_t_11(__pyx_t_16); if (unlikely(!__pyx_t_3)) goto __pyx_L78_unpacking_failed; + __Pyx_GOTREF(__pyx_t_3); + index = 1; __pyx_t_7 = __pyx_t_11(__pyx_t_16); if (unlikely(!__pyx_t_7)) goto __pyx_L78_unpacking_failed; __Pyx_GOTREF(__pyx_t_7); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_16), 2) < 0) __PYX_ERR(0, 238, __pyx_L1_error) + if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_16), 2) < 0) __PYX_ERR(0, 330, __pyx_L1_error) __pyx_t_11 = NULL; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - goto __pyx_L74_unpacking_done; - __pyx_L73_unpacking_failed:; + goto __pyx_L79_unpacking_done; + __pyx_L78_unpacking_failed:; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_11 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 238, __pyx_L1_error) - __pyx_L74_unpacking_done:; + __PYX_ERR(0, 330, __pyx_L1_error) + __pyx_L79_unpacking_done:; } - __Pyx_DECREF_SET(__pyx_v_n, __pyx_t_2); - __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_n, __pyx_t_3); + __pyx_t_3 = 0; __Pyx_DECREF_SET(__pyx_v_p, __pyx_t_7); __pyx_t_7 = 0; - /* "l0learn/interface.pyx":239 + /* "l0learn/interface.pyx":331 * * n, p = X.shape * with_bounds = False # <<<<<<<<<<<<<< @@ -5596,49 +5888,49 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ __pyx_v_with_bounds = 0; - /* "l0learn/interface.pyx":241 + /* "l0learn/interface.pyx":333 * with_bounds = False * * if isinstance(lows, float): # <<<<<<<<<<<<<< * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") */ - __pyx_t_1 = PyFloat_Check(__pyx_v_lows); - __pyx_t_4 = (__pyx_t_1 != 0); - if (__pyx_t_4) { + __pyx_t_4 = PyFloat_Check(__pyx_v_lows); + __pyx_t_1 = (__pyx_t_4 != 0); + if (__pyx_t_1) { - /* "l0learn/interface.pyx":242 + /* "l0learn/interface.pyx":334 * * if isinstance(lows, float): * if lows > 0: # <<<<<<<<<<<<<< * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") * elif lows > -float('inf'): */ - __pyx_t_6 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_GT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 242, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 242, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(__pyx_t_4)) { + __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_GT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 334, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 334, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":243 + /* "l0learn/interface.pyx":335 * if isinstance(lows, float): * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") # <<<<<<<<<<<<<< * elif lows > -float('inf'): * with_bounds = True */ - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 243, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lows_to_be_a_non_positi, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 243, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 335, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lows_to_be_a_non_positi, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 335, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 243, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 335, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 243, __pyx_L1_error) + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(0, 335, __pyx_L1_error) - /* "l0learn/interface.pyx":242 + /* "l0learn/interface.pyx":334 * * if isinstance(lows, float): * if lows > 0: # <<<<<<<<<<<<<< @@ -5647,23 +5939,23 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":244 + /* "l0learn/interface.pyx":336 * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") * elif lows > -float('inf'): # <<<<<<<<<<<<<< * with_bounds = True * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): */ - __pyx_t_14 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 244, __pyx_L1_error) - __pyx_t_6 = PyFloat_FromDouble((-__pyx_t_14)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 244, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = PyObject_RichCompare(__pyx_v_lows, __pyx_t_6, Py_GT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 244, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 244, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 336, __pyx_L1_error) + __pyx_t_8 = PyFloat_FromDouble((-__pyx_t_14)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 336, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = PyObject_RichCompare(__pyx_v_lows, __pyx_t_8, Py_GT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 336, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 336, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (__pyx_t_4) { + if (__pyx_t_1) { - /* "l0learn/interface.pyx":245 + /* "l0learn/interface.pyx":337 * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") * elif lows > -float('inf'): * with_bounds = True # <<<<<<<<<<<<<< @@ -5672,7 +5964,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ __pyx_v_with_bounds = 1; - /* "l0learn/interface.pyx":244 + /* "l0learn/interface.pyx":336 * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") * elif lows > -float('inf'): # <<<<<<<<<<<<<< @@ -5681,65 +5973,71 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":241 + /* "l0learn/interface.pyx":333 * with_bounds = False * * if isinstance(lows, float): # <<<<<<<<<<<<<< * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") */ - goto __pyx_L75; + goto __pyx_L80; } - /* "l0learn/interface.pyx":246 + /* "l0learn/interface.pyx":338 * elif lows > -float('inf'): * with_bounds = True * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): # <<<<<<<<<<<<<< * with_bounds = True * else: */ - __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_lows, __pyx_ptype_5numpy_ndarray); - __pyx_t_3 = (__pyx_t_1 != 0); - if (__pyx_t_3) { + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 338, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 338, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_4 = PyObject_IsInstance(__pyx_v_lows, __pyx_t_8); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 338, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_5 = (__pyx_t_4 != 0); + if (__pyx_t_5) { } else { - __pyx_t_4 = __pyx_t_3; - goto __pyx_L77_bool_binop_done; + __pyx_t_1 = __pyx_t_5; + goto __pyx_L82_bool_binop_done; } - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_lows, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 246, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_lows, __pyx_n_s_ndim); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 338, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = __Pyx_PyInt_EqObjC(__pyx_t_8, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 338, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = __Pyx_PyInt_EqObjC(__pyx_t_7, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 246, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 338, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 246, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (__pyx_t_3) { + if (__pyx_t_5) { } else { - __pyx_t_4 = __pyx_t_3; - goto __pyx_L77_bool_binop_done; + __pyx_t_1 = __pyx_t_5; + goto __pyx_L82_bool_binop_done; } - __pyx_t_9 = PyObject_Length(__pyx_v_lows); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 246, __pyx_L1_error) - __pyx_t_6 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 246, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = PyObject_RichCompare(__pyx_t_6, __pyx_v_p, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 246, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 246, __pyx_L1_error) + __pyx_t_9 = PyObject_Length(__pyx_v_lows); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 338, __pyx_L1_error) + __pyx_t_7 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 338, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = PyObject_RichCompare(__pyx_t_7, __pyx_v_p, Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 338, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (__pyx_t_3) { + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 338, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (__pyx_t_5) { } else { - __pyx_t_4 = __pyx_t_3; - goto __pyx_L77_bool_binop_done; + __pyx_t_1 = __pyx_t_5; + goto __pyx_L82_bool_binop_done; } - __pyx_t_7 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 246, __pyx_L1_error) - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_all, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 246, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 338, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_all, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 338, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 338, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 246, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_4 = __pyx_t_3; - __pyx_L77_bool_binop_done:; - if (likely(__pyx_t_4)) { + __pyx_t_1 = __pyx_t_5; + __pyx_L82_bool_binop_done:; + if (likely(__pyx_t_1)) { - /* "l0learn/interface.pyx":247 + /* "l0learn/interface.pyx":339 * with_bounds = True * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): * with_bounds = True # <<<<<<<<<<<<<< @@ -5748,17 +6046,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ __pyx_v_with_bounds = 1; - /* "l0learn/interface.pyx":246 + /* "l0learn/interface.pyx":338 * elif lows > -float('inf'): * with_bounds = True * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): # <<<<<<<<<<<<<< * with_bounds = True * else: */ - goto __pyx_L75; + goto __pyx_L80; } - /* "l0learn/interface.pyx":249 + /* "l0learn/interface.pyx":341 * with_bounds = True * else: * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " # <<<<<<<<<<<<<< @@ -5766,103 +6064,103 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx * */ /*else*/ { - __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 249, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 341, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_expected_lows_to_be_a_non_positi_2); __pyx_t_9 += 72; __Pyx_GIVEREF(__pyx_kp_u_expected_lows_to_be_a_non_positi_2); - PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_lows_to_be_a_non_positi_2); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 249, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_7); - __pyx_t_7 = 0; + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_lows_to_be_a_non_positi_2); + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 341, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_8); + __pyx_t_8 = 0; __Pyx_INCREF(__pyx_kp_u_of_non_positives_floats_but_got); __pyx_t_9 += 34; __Pyx_GIVEREF(__pyx_kp_u_of_non_positives_floats_but_got); - PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u_of_non_positives_floats_but_got); + PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_of_non_positives_floats_but_got); - /* "l0learn/interface.pyx":250 + /* "l0learn/interface.pyx":342 * else: * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " * f"floats, but got {lows}") # <<<<<<<<<<<<<< * * if isinstance(highs, float): */ - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 250, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_7); - __pyx_t_7 = 0; + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 342, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_8); + __pyx_t_8 = 0; - /* "l0learn/interface.pyx":249 + /* "l0learn/interface.pyx":341 * with_bounds = True * else: * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " # <<<<<<<<<<<<<< * f"floats, but got {lows}") * */ - __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_6, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 249, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 341, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 341, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 249, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 249, __pyx_L1_error) + __PYX_ERR(0, 341, __pyx_L1_error) } - __pyx_L75:; + __pyx_L80:; - /* "l0learn/interface.pyx":252 + /* "l0learn/interface.pyx":344 * f"floats, but got {lows}") * * if isinstance(highs, float): # <<<<<<<<<<<<<< * if highs < 0: * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") */ - __pyx_t_4 = PyFloat_Check(__pyx_v_highs); - __pyx_t_3 = (__pyx_t_4 != 0); - if (__pyx_t_3) { + __pyx_t_1 = PyFloat_Check(__pyx_v_highs); + __pyx_t_5 = (__pyx_t_1 != 0); + if (__pyx_t_5) { - /* "l0learn/interface.pyx":253 + /* "l0learn/interface.pyx":345 * * if isinstance(highs, float): * if highs < 0: # <<<<<<<<<<<<<< * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") * if highs < float('inf'): */ - __pyx_t_6 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 253, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 253, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(__pyx_t_3)) { + __pyx_t_7 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 345, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 345, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":254 + /* "l0learn/interface.pyx":346 * if isinstance(highs, float): * if highs < 0: * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") # <<<<<<<<<<<<<< * if highs < float('inf'): * with_bounds = True */ - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 254, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_highs_to_be_a_non_negat, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 254, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 346, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 254, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_highs_to_be_a_non_negat, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 346, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 346, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 254, __pyx_L1_error) + __PYX_ERR(0, 346, __pyx_L1_error) - /* "l0learn/interface.pyx":253 + /* "l0learn/interface.pyx":345 * * if isinstance(highs, float): * if highs < 0: # <<<<<<<<<<<<<< @@ -5871,22 +6169,22 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":255 + /* "l0learn/interface.pyx":347 * if highs < 0: * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") * if highs < float('inf'): # <<<<<<<<<<<<<< * with_bounds = True * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): */ - __pyx_t_6 = __Pyx_PyNumber_Float(__pyx_n_u_inf); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 255, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = PyObject_RichCompare(__pyx_v_highs, __pyx_t_6, Py_LT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 255, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 255, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyNumber_Float(__pyx_n_u_inf); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = PyObject_RichCompare(__pyx_v_highs, __pyx_t_7, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 347, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (__pyx_t_3) { + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 347, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (__pyx_t_5) { - /* "l0learn/interface.pyx":256 + /* "l0learn/interface.pyx":348 * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") * if highs < float('inf'): * with_bounds = True # <<<<<<<<<<<<<< @@ -5895,7 +6193,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ __pyx_v_with_bounds = 1; - /* "l0learn/interface.pyx":255 + /* "l0learn/interface.pyx":347 * if highs < 0: * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") * if highs < float('inf'): # <<<<<<<<<<<<<< @@ -5904,62 +6202,68 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":252 + /* "l0learn/interface.pyx":344 * f"floats, but got {lows}") * * if isinstance(highs, float): # <<<<<<<<<<<<<< * if highs < 0: * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") */ - goto __pyx_L81; + goto __pyx_L86; } - /* "l0learn/interface.pyx":257 + /* "l0learn/interface.pyx":349 * if highs < float('inf'): * with_bounds = True * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): # <<<<<<<<<<<<<< * with_bounds = True * else: */ - __pyx_t_4 = __Pyx_TypeCheck(__pyx_v_highs, __pyx_ptype_5numpy_ndarray); - __pyx_t_1 = (__pyx_t_4 != 0); - if (__pyx_t_1) { + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_1 = PyObject_IsInstance(__pyx_v_highs, __pyx_t_7); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 349, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_4 = (__pyx_t_1 != 0); + if (__pyx_t_4) { } else { - __pyx_t_3 = __pyx_t_1; - goto __pyx_L84_bool_binop_done; + __pyx_t_5 = __pyx_t_4; + goto __pyx_L89_bool_binop_done; } - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_highs, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 257, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_highs, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 349, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = __Pyx_PyInt_EqObjC(__pyx_t_7, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 257, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyInt_EqObjC(__pyx_t_7, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 257, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (__pyx_t_1) { + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 349, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (__pyx_t_4) { } else { - __pyx_t_3 = __pyx_t_1; - goto __pyx_L84_bool_binop_done; + __pyx_t_5 = __pyx_t_4; + goto __pyx_L89_bool_binop_done; } - __pyx_t_9 = PyObject_Length(__pyx_v_highs); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 257, __pyx_L1_error) - __pyx_t_6 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 257, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = PyObject_RichCompare(__pyx_t_6, __pyx_v_p, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 257, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 257, __pyx_L1_error) + __pyx_t_9 = PyObject_Length(__pyx_v_highs); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 349, __pyx_L1_error) + __pyx_t_8 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = PyObject_RichCompare(__pyx_t_8, __pyx_v_p, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 349, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 349, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (__pyx_t_1) { + if (__pyx_t_4) { } else { - __pyx_t_3 = __pyx_t_1; - goto __pyx_L84_bool_binop_done; + __pyx_t_5 = __pyx_t_4; + goto __pyx_L89_bool_binop_done; } - __pyx_t_7 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 257, __pyx_L1_error) - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 257, __pyx_L1_error) + __pyx_t_7 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 349, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 349, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_3 = __pyx_t_1; - __pyx_L84_bool_binop_done:; - if (likely(__pyx_t_3)) { + __pyx_t_5 = __pyx_t_4; + __pyx_L89_bool_binop_done:; + if (likely(__pyx_t_5)) { - /* "l0learn/interface.pyx":258 + /* "l0learn/interface.pyx":350 * with_bounds = True * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): * with_bounds = True # <<<<<<<<<<<<<< @@ -5968,17 +6272,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ __pyx_v_with_bounds = 1; - /* "l0learn/interface.pyx":257 + /* "l0learn/interface.pyx":349 * if highs < float('inf'): * with_bounds = True * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): # <<<<<<<<<<<<<< * with_bounds = True * else: */ - goto __pyx_L81; + goto __pyx_L86; } - /* "l0learn/interface.pyx":260 + /* "l0learn/interface.pyx":352 * with_bounds = True * else: * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " # <<<<<<<<<<<<<< @@ -5986,7 +6290,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx * */ /*else*/ { - __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 260, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 352, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -5994,107 +6298,107 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_9 += 73; __Pyx_GIVEREF(__pyx_kp_u_expected_highs_to_be_a_non_negat_2); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_highs_to_be_a_non_negat_2); - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 260, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_6); - __pyx_t_6 = 0; + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 352, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_8); + __pyx_t_8 = 0; __Pyx_INCREF(__pyx_kp_u_of_non_negative_floats_but_got); __pyx_t_9 += 33; __Pyx_GIVEREF(__pyx_kp_u_of_non_negative_floats_but_got); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_of_non_negative_floats_but_got); - /* "l0learn/interface.pyx":261 + /* "l0learn/interface.pyx":353 * else: * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " * f"non-negative floats, but got {highs}") # <<<<<<<<<<<<<< * * if with_bounds: */ - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 261, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_6); - __pyx_t_6 = 0; + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_8); + __pyx_t_8 = 0; - /* "l0learn/interface.pyx":260 + /* "l0learn/interface.pyx":352 * with_bounds = True * else: * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " # <<<<<<<<<<<<<< * f"non-negative floats, but got {highs}") * */ - __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 260, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 352, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 260, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 352, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 260, __pyx_L1_error) + __PYX_ERR(0, 352, __pyx_L1_error) } - __pyx_L81:; + __pyx_L86:; - /* "l0learn/interface.pyx":263 + /* "l0learn/interface.pyx":355 * f"non-negative floats, but got {highs}") * * if with_bounds: # <<<<<<<<<<<<<< * if isinstance(lows, float): * lows = np.ones(p) * lows */ - __pyx_t_3 = (__pyx_v_with_bounds != 0); - if (__pyx_t_3) { + __pyx_t_5 = (__pyx_v_with_bounds != 0); + if (__pyx_t_5) { - /* "l0learn/interface.pyx":264 + /* "l0learn/interface.pyx":356 * * if with_bounds: * if isinstance(lows, float): # <<<<<<<<<<<<<< * lows = np.ones(p) * lows * if isinstance(highs, float): */ - __pyx_t_3 = PyFloat_Check(__pyx_v_lows); - __pyx_t_1 = (__pyx_t_3 != 0); - if (__pyx_t_1) { + __pyx_t_5 = PyFloat_Check(__pyx_v_lows); + __pyx_t_4 = (__pyx_t_5 != 0); + if (__pyx_t_4) { - /* "l0learn/interface.pyx":265 + /* "l0learn/interface.pyx":357 * if with_bounds: * if isinstance(lows, float): * lows = np.ones(p) * lows # <<<<<<<<<<<<<< * if isinstance(highs, float): * highs = np.ones(p) * highs */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 265, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_ones); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 265, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_6)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_6); + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 357, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_ones); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 357, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); + __Pyx_DECREF_SET(__pyx_t_3, function); } } - __pyx_t_7 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_6, __pyx_v_p) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_p); - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 265, __pyx_L1_error) + __pyx_t_7 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_8, __pyx_v_p) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_p); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 357, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = PyNumber_Multiply(__pyx_t_7, __pyx_v_lows); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 265, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyNumber_Multiply(__pyx_t_7, __pyx_v_lows); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 357, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_2); - __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_3); + __pyx_t_3 = 0; - /* "l0learn/interface.pyx":264 + /* "l0learn/interface.pyx":356 * * if with_bounds: * if isinstance(lows, float): # <<<<<<<<<<<<<< @@ -6103,51 +6407,51 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":266 + /* "l0learn/interface.pyx":358 * if isinstance(lows, float): * lows = np.ones(p) * lows * if isinstance(highs, float): # <<<<<<<<<<<<<< * highs = np.ones(p) * highs * */ - __pyx_t_1 = PyFloat_Check(__pyx_v_highs); - __pyx_t_3 = (__pyx_t_1 != 0); - if (__pyx_t_3) { + __pyx_t_4 = PyFloat_Check(__pyx_v_highs); + __pyx_t_5 = (__pyx_t_4 != 0); + if (__pyx_t_5) { - /* "l0learn/interface.pyx":267 + /* "l0learn/interface.pyx":359 * lows = np.ones(p) * lows * if isinstance(highs, float): * highs = np.ones(p) * highs # <<<<<<<<<<<<<< * * if any(lows >= highs): */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 267, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 359, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ones); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 267, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ones); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 359, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_7)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_6, function); + __Pyx_DECREF_SET(__pyx_t_8, function); } } - __pyx_t_2 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_v_p) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_p); + __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_7, __pyx_v_p) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_p); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 267, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyNumber_Multiply(__pyx_t_2, __pyx_v_highs); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 267, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_6); - __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 359, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyNumber_Multiply(__pyx_t_3, __pyx_v_highs); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 359, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_8); + __pyx_t_8 = 0; - /* "l0learn/interface.pyx":266 + /* "l0learn/interface.pyx":358 * if isinstance(lows, float): * lows = np.ones(p) * lows * if isinstance(highs, float): # <<<<<<<<<<<<<< @@ -6156,34 +6460,34 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":269 + /* "l0learn/interface.pyx":361 * highs = np.ones(p) * highs * * if any(lows >= highs): # <<<<<<<<<<<<<< * bad_bounds = np.argwhere(lows >= highs) * raise ValueError(f"expected to be high to be elementwise greater than lows, " */ - __pyx_t_6 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 269, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 269, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 269, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(__pyx_t_3)) { + __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 361, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 361, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 361, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":270 + /* "l0learn/interface.pyx":362 * * if any(lows >= highs): * bad_bounds = np.argwhere(lows >= highs) # <<<<<<<<<<<<<< * raise ValueError(f"expected to be high to be elementwise greater than lows, " * f"but got indices {bad_bounds[0]} where that is not the case ") */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 270, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_argwhere); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 270, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 362, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_argwhere); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 362, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 270, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 362, __pyx_L1_error) __pyx_t_16 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_7); @@ -6194,71 +6498,71 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_DECREF_SET(__pyx_t_7, function); } } - __pyx_t_2 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_16, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); + __pyx_t_3 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_16, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 270, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 362, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_v_bad_bounds = __pyx_t_2; - __pyx_t_2 = 0; + __pyx_v_bad_bounds = __pyx_t_3; + __pyx_t_3 = 0; - /* "l0learn/interface.pyx":271 + /* "l0learn/interface.pyx":363 * if any(lows >= highs): * bad_bounds = np.argwhere(lows >= highs) * raise ValueError(f"expected to be high to be elementwise greater than lows, " # <<<<<<<<<<<<<< * f"but got indices {bad_bounds[0]} where that is not the case ") * else: */ - __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 271, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_expected_to_be_high_to_be_elemen); __pyx_t_9 += 73; __Pyx_GIVEREF(__pyx_kp_u_expected_to_be_high_to_be_elemen); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_u_expected_to_be_high_to_be_elemen); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_to_be_high_to_be_elemen); - /* "l0learn/interface.pyx":272 + /* "l0learn/interface.pyx":364 * bad_bounds = np.argwhere(lows >= highs) * raise ValueError(f"expected to be high to be elementwise greater than lows, " * f"but got indices {bad_bounds[0]} where that is not the case ") # <<<<<<<<<<<<<< * else: * lows = np.array([0.]) */ - __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_bad_bounds, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 272, __pyx_L1_error) + __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_bad_bounds, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 364, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 272, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_6); - __pyx_t_6 = 0; + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_8); + __pyx_t_8 = 0; __Pyx_INCREF(__pyx_kp_u_where_that_is_not_the_case); __pyx_t_9 += 28; __Pyx_GIVEREF(__pyx_kp_u_where_that_is_not_the_case); - PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_kp_u_where_that_is_not_the_case); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_where_that_is_not_the_case); - /* "l0learn/interface.pyx":271 + /* "l0learn/interface.pyx":363 * if any(lows >= highs): * bad_bounds = np.argwhere(lows >= highs) * raise ValueError(f"expected to be high to be elementwise greater than lows, " # <<<<<<<<<<<<<< * f"but got indices {bad_bounds[0]} where that is not the case ") * else: */ - __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_2, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 271, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 271, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_Raise(__pyx_t_2, 0, 0, 0); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 271, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 363, __pyx_L1_error) - /* "l0learn/interface.pyx":269 + /* "l0learn/interface.pyx":361 * highs = np.ones(p) * highs * * if any(lows >= highs): # <<<<<<<<<<<<<< @@ -6267,17 +6571,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":263 + /* "l0learn/interface.pyx":355 * f"non-negative floats, but got {highs}") * * if with_bounds: # <<<<<<<<<<<<<< * if isinstance(lows, float): * lows = np.ones(p) * lows */ - goto __pyx_L88; + goto __pyx_L93; } - /* "l0learn/interface.pyx":274 + /* "l0learn/interface.pyx":366 * f"but got indices {bad_bounds[0]} where that is not the case ") * else: * lows = np.array([0.]) # <<<<<<<<<<<<<< @@ -6285,16 +6589,16 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx * */ /*else*/ { - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 274, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_array); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 274, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 366, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_array); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 366, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyList_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 274, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyList_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 366, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __Pyx_INCREF(__pyx_float_0_); __Pyx_GIVEREF(__pyx_float_0_); - PyList_SET_ITEM(__pyx_t_6, 0, __pyx_float_0_); + PyList_SET_ITEM(__pyx_t_8, 0, __pyx_float_0_); __pyx_t_16 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_7); @@ -6305,54 +6609,54 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_DECREF_SET(__pyx_t_7, function); } } - __pyx_t_2 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_16, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); + __pyx_t_3 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_16, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 274, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 366, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_2); - __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_3); + __pyx_t_3 = 0; - /* "l0learn/interface.pyx":275 + /* "l0learn/interface.pyx":367 * else: * lows = np.array([0.]) * highs = np.array(([0.])) # <<<<<<<<<<<<<< * * cdef vector[vector[double]] c_lambda_grid */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 275, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 367, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_array); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 275, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_array); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 367, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = PyList_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 275, __pyx_L1_error) + __pyx_t_7 = PyList_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 367, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_INCREF(__pyx_float_0_); __Pyx_GIVEREF(__pyx_float_0_); PyList_SET_ITEM(__pyx_t_7, 0, __pyx_float_0_); __pyx_t_16 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { - __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_6); + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_16)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_16); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_6, function); + __Pyx_DECREF_SET(__pyx_t_8, function); } } - __pyx_t_2 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_16, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); + __pyx_t_3 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_16, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 275, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_2); - __pyx_t_2 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 367, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_3); + __pyx_t_3 = 0; } - __pyx_L88:; + __pyx_L93:; - /* "l0learn/interface.pyx":278 + /* "l0learn/interface.pyx":370 * * cdef vector[vector[double]] c_lambda_grid * try: # <<<<<<<<<<<<<< @@ -6368,17 +6672,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_XGOTREF(__pyx_t_19); /*try:*/ { - /* "l0learn/interface.pyx":279 + /* "l0learn/interface.pyx":371 * cdef vector[vector[double]] c_lambda_grid * try: * c_lambda_grid = lambda_grid # <<<<<<<<<<<<<< * except TypeError: * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") */ - __pyx_t_20 = __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_lambda_grid); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 279, __pyx_L92_error) + __pyx_t_20 = __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_lambda_grid); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 371, __pyx_L97_error) __pyx_v_c_lambda_grid = __pyx_t_20; - /* "l0learn/interface.pyx":278 + /* "l0learn/interface.pyx":370 * * cdef vector[vector[double]] c_lambda_grid * try: # <<<<<<<<<<<<<< @@ -6389,15 +6693,15 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; - goto __pyx_L97_try_end; - __pyx_L92_error:; + goto __pyx_L102_try_end; + __pyx_L97_error:; __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "l0learn/interface.pyx":280 + /* "l0learn/interface.pyx":372 * try: * c_lambda_grid = lambda_grid * except TypeError: # <<<<<<<<<<<<<< @@ -6407,34 +6711,34 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_21 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); if (__pyx_t_21) { __Pyx_AddTraceback("l0learn.interface.fit", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(0, 280, __pyx_L94_except_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_t_6); + if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_8, &__pyx_t_7) < 0) __PYX_ERR(0, 372, __pyx_L99_except_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_t_8); __Pyx_GOTREF(__pyx_t_7); - /* "l0learn/interface.pyx":281 + /* "l0learn/interface.pyx":373 * c_lambda_grid = lambda_grid * except TypeError: * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") # <<<<<<<<<<<<<< * * cdef string c_loss = loss.encode('UTF-8') */ - __pyx_t_16 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 281, __pyx_L94_except_error) + __pyx_t_16 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 373, __pyx_L99_except_error) __Pyx_GOTREF(__pyx_t_16); - __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_be_a_lis, __pyx_t_16); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 281, __pyx_L94_except_error) - __Pyx_GOTREF(__pyx_t_8); + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_be_a_lis, __pyx_t_16); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 373, __pyx_L99_except_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_16 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 281, __pyx_L94_except_error) + __pyx_t_16 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 373, __pyx_L99_except_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_16, 0, 0, 0); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __PYX_ERR(0, 281, __pyx_L94_except_error) + __PYX_ERR(0, 373, __pyx_L99_except_error) } - goto __pyx_L94_except_error; - __pyx_L94_except_error:; + goto __pyx_L99_except_error; + __pyx_L99_except_error:; - /* "l0learn/interface.pyx":278 + /* "l0learn/interface.pyx":370 * * cdef vector[vector[double]] c_lambda_grid * try: # <<<<<<<<<<<<<< @@ -6446,10 +6750,10 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_18, __pyx_t_19); goto __pyx_L1_error; - __pyx_L97_try_end:; + __pyx_L102_try_end:; } - /* "l0learn/interface.pyx":283 + /* "l0learn/interface.pyx":375 * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") * * cdef string c_loss = loss.encode('UTF-8') # <<<<<<<<<<<<<< @@ -6458,15 +6762,15 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ if (unlikely(__pyx_v_loss == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 283, __pyx_L1_error) + __PYX_ERR(0, 375, __pyx_L1_error) } - __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_loss); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 283, __pyx_L1_error) + __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_loss); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 375, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 283, __pyx_L1_error) + __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 375, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_c_loss = __pyx_t_22; - /* "l0learn/interface.pyx":284 + /* "l0learn/interface.pyx":376 * * cdef string c_loss = loss.encode('UTF-8') * cdef string c_penalty = penalty.encode('UTF-8') # <<<<<<<<<<<<<< @@ -6475,404 +6779,467 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ if (unlikely(__pyx_v_penalty == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 284, __pyx_L1_error) + __PYX_ERR(0, 376, __pyx_L1_error) } - __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_penalty); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 284, __pyx_L1_error) + __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_penalty); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 376, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 284, __pyx_L1_error) + __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 376, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_c_penalty = __pyx_t_22; - /* "l0learn/interface.pyx":285 + /* "l0learn/interface.pyx":377 * cdef string c_loss = loss.encode('UTF-8') * cdef string c_penalty = penalty.encode('UTF-8') * cdef string c_algorithim = algorithm.encode('UTF-8') # <<<<<<<<<<<<<< * - * cdef fitmodel results + * cdef fitmodel c_results */ if (unlikely(__pyx_v_algorithm == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 285, __pyx_L1_error) + __PYX_ERR(0, 377, __pyx_L1_error) } - __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_algorithm); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 285, __pyx_L1_error) + __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_algorithm); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 377, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 285, __pyx_L1_error) + __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 377, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_c_algorithim = __pyx_t_22; - /* "l0learn/interface.pyx":288 + /* "l0learn/interface.pyx":380 * - * cdef fitmodel results + * cdef fitmodel c_results * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< - * results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), - * y=numpy_to_dvec_d(y), + * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), + * y=numpy_to_dvec_d(y), */ - __pyx_t_3 = __Pyx_TypeCheck(__pyx_v_X, __pyx_ptype_5numpy_ndarray); - __pyx_t_1 = (__pyx_t_3 != 0); - if (__pyx_t_1) { + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 380, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 380, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_5 = PyObject_IsInstance(__pyx_v_X, __pyx_t_8); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 380, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_4 = (__pyx_t_5 != 0); + if (__pyx_t_4) { - /* "l0learn/interface.pyx":289 - * cdef fitmodel results + /* "l0learn/interface.pyx":381 + * cdef fitmodel c_results * if isinstance(X, np.ndarray): - * results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< - * y=numpy_to_dvec_d(y), - * Loss=c_loss, + * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< + * y=numpy_to_dvec_d(y), + * Loss=c_loss, */ - if (!(likely(((__pyx_v_X) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_X, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 289, __pyx_L1_error) + if (!(likely(((__pyx_v_X) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_X, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 381, __pyx_L1_error) - /* "l0learn/interface.pyx":294 - * Penalty=c_penalty, - * Algorithm=c_algorithim, - * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< - * G_ncols=num_lambda, - * G_nrows=num_gamma, + /* "l0learn/interface.pyx":382 + * if isinstance(X, np.ndarray): + * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), + * y=numpy_to_dvec_d(y), # <<<<<<<<<<<<<< + * Loss=c_loss, + * Penalty=c_penalty, */ - __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 294, __pyx_L1_error) + if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 382, __pyx_L1_error) - /* "l0learn/interface.pyx":295 - * Algorithm=c_algorithim, - * NnzStopNum=max_support_size, - * G_ncols=num_lambda, # <<<<<<<<<<<<<< - * G_nrows=num_gamma, - * Lambda2Max=gamma_max, + /* "l0learn/interface.pyx":386 + * Penalty=c_penalty, + * Algorithm=c_algorithim, + * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< + * G_ncols=num_lambda, + * G_nrows=num_gamma, */ - __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 295, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 386, __pyx_L1_error) - /* "l0learn/interface.pyx":296 - * NnzStopNum=max_support_size, - * G_ncols=num_lambda, - * G_nrows=num_gamma, # <<<<<<<<<<<<<< - * Lambda2Max=gamma_max, - * Lambda2Min=gamma_min, + /* "l0learn/interface.pyx":387 + * Algorithm=c_algorithim, + * NnzStopNum=max_support_size, + * G_ncols=num_lambda, # <<<<<<<<<<<<<< + * G_nrows=num_gamma, + * Lambda2Max=gamma_max, */ - __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 296, __pyx_L1_error) + __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 387, __pyx_L1_error) - /* "l0learn/interface.pyx":299 - * Lambda2Max=gamma_max, - * Lambda2Min=gamma_min, - * PartialSort=partial_sort, # <<<<<<<<<<<<<< - * MaxIters=max_iter, - * rtol=rtol, + /* "l0learn/interface.pyx":388 + * NnzStopNum=max_support_size, + * G_ncols=num_lambda, + * G_nrows=num_gamma, # <<<<<<<<<<<<<< + * Lambda2Max=gamma_max, + * Lambda2Min=gamma_min, */ - __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 299, __pyx_L1_error) + __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 388, __pyx_L1_error) - /* "l0learn/interface.pyx":300 - * Lambda2Min=gamma_min, - * PartialSort=partial_sort, - * MaxIters=max_iter, # <<<<<<<<<<<<<< - * rtol=rtol, - * atol=atol, + /* "l0learn/interface.pyx":391 + * Lambda2Max=gamma_max, + * Lambda2Min=gamma_min, + * PartialSort=partial_sort, # <<<<<<<<<<<<<< + * MaxIters=max_iter, + * rtol=rtol, */ - __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 300, __pyx_L1_error) + __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 391, __pyx_L1_error) - /* "l0learn/interface.pyx":303 - * rtol=rtol, - * atol=atol, - * ActiveSet=active_set, # <<<<<<<<<<<<<< - * ActiveSetNum=active_set_num, - * MaxNumSwaps=max_swaps, + /* "l0learn/interface.pyx":392 + * Lambda2Min=gamma_min, + * PartialSort=partial_sort, + * MaxIters=max_iter, # <<<<<<<<<<<<<< + * rtol=rtol, + * atol=atol, */ - __pyx_t_28 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_28 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 303, __pyx_L1_error) + __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 392, __pyx_L1_error) - /* "l0learn/interface.pyx":304 - * atol=atol, - * ActiveSet=active_set, - * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< - * MaxNumSwaps=max_swaps, - * ScaleDownFactor=scale_down_factor, + /* "l0learn/interface.pyx":395 + * rtol=rtol, + * atol=atol, + * ActiveSet=active_set, # <<<<<<<<<<<<<< + * ActiveSetNum=active_set_num, + * MaxNumSwaps=max_swaps, */ - __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 304, __pyx_L1_error) + __pyx_t_28 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_28 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 395, __pyx_L1_error) - /* "l0learn/interface.pyx":305 - * ActiveSet=active_set, - * ActiveSetNum=active_set_num, - * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< - * ScaleDownFactor=scale_down_factor, - * ScreenSize=screen_size, + /* "l0learn/interface.pyx":396 + * atol=atol, + * ActiveSet=active_set, + * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< + * MaxNumSwaps=max_swaps, + * ScaleDownFactor=scale_down_factor, */ - __pyx_t_30 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_30 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 305, __pyx_L1_error) + __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 396, __pyx_L1_error) - /* "l0learn/interface.pyx":307 - * MaxNumSwaps=max_swaps, - * ScaleDownFactor=scale_down_factor, - * ScreenSize=screen_size, # <<<<<<<<<<<<<< - * LambdaU=not auto_lambda, - * Lambdas=c_lambda_grid, + /* "l0learn/interface.pyx":397 + * ActiveSet=active_set, + * ActiveSetNum=active_set_num, + * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< + * ScaleDownFactor=scale_down_factor, + * ScreenSize=screen_size, */ - __pyx_t_31 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_31 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 307, __pyx_L1_error) + __pyx_t_30 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_30 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 397, __pyx_L1_error) - /* "l0learn/interface.pyx":310 - * LambdaU=not auto_lambda, - * Lambdas=c_lambda_grid, - * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< - * Intercept=intercept, - * withBounds=with_bounds, + /* "l0learn/interface.pyx":399 + * MaxNumSwaps=max_swaps, + * ScaleDownFactor=scale_down_factor, + * ScreenSize=screen_size, # <<<<<<<<<<<<<< + * LambdaU=not auto_lambda, + * Lambdas=c_lambda_grid, */ - __pyx_t_32 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_32 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 310, __pyx_L1_error) + __pyx_t_31 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_31 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 399, __pyx_L1_error) - /* "l0learn/interface.pyx":311 - * Lambdas=c_lambda_grid, - * ExcludeFirstK=exclude_first_k, - * Intercept=intercept, # <<<<<<<<<<<<<< - * withBounds=with_bounds, - * Lows=numpy_to_dvec_d(lows), + /* "l0learn/interface.pyx":402 + * LambdaU=not auto_lambda, + * Lambdas=c_lambda_grid, + * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< + * Intercept=intercept, + * withBounds=with_bounds, */ - __pyx_t_33 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_33 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 311, __pyx_L1_error) + __pyx_t_32 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_32 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 402, __pyx_L1_error) - /* "l0learn/interface.pyx":313 - * Intercept=intercept, - * withBounds=with_bounds, - * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< - * Highs=numpy_to_dvec_d(highs)) + /* "l0learn/interface.pyx":403 + * Lambdas=c_lambda_grid, + * ExcludeFirstK=exclude_first_k, + * Intercept=intercept, # <<<<<<<<<<<<<< + * withBounds=with_bounds, + * Lows=numpy_to_dvec_d(lows), + */ + __pyx_t_33 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_33 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 403, __pyx_L1_error) + + /* "l0learn/interface.pyx":405 + * Intercept=intercept, + * withBounds=with_bounds, + * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< + * Highs=numpy_to_dvec_d(highs)) * else: # isinstance(X, csc_matrix) */ - if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 313, __pyx_L1_error) + if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 405, __pyx_L1_error) - /* "l0learn/interface.pyx":314 - * withBounds=with_bounds, - * Lows=numpy_to_dvec_d(lows), - * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< + /* "l0learn/interface.pyx":406 + * withBounds=with_bounds, + * Lows=numpy_to_dvec_d(lows), + * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< * else: # isinstance(X, csc_matrix) - * results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), + * c_results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), */ - if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 314, __pyx_L1_error) + if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 406, __pyx_L1_error) - /* "l0learn/interface.pyx":289 - * cdef fitmodel results + /* "l0learn/interface.pyx":381 + * cdef fitmodel c_results * if isinstance(X, np.ndarray): - * results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< - * y=numpy_to_dvec_d(y), - * Loss=c_loss, + * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< + * y=numpy_to_dvec_d(y), + * Loss=c_loss, + */ + __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnFit_dense(__pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_X)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_23, __pyx_t_24, __pyx_t_25, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_26, __pyx_t_27, __pyx_v_rtol, __pyx_v_atol, __pyx_t_28, __pyx_t_29, __pyx_t_30, __pyx_v_scale_down_factor, __pyx_t_31, (!(__pyx_v_auto_lambda != 0)), __pyx_v_c_lambda_grid, __pyx_t_32, __pyx_t_33, __pyx_v_with_bounds, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); + + /* "l0learn/interface.pyx":380 + * + * cdef fitmodel c_results + * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< + * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), + * y=numpy_to_dvec_d(y), + */ + goto __pyx_L105; + } + + /* "l0learn/interface.pyx":408 + * Highs=numpy_to_dvec_d(highs)) + * else: # isinstance(X, csc_matrix) + * c_results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< + * y=numpy_to_dvec_d(y), + * Loss=c_loss, + */ + /*else*/ { + + /* "l0learn/interface.pyx":409 + * else: # isinstance(X, csc_matrix) + * c_results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), + * y=numpy_to_dvec_d(y), # <<<<<<<<<<<<<< + * Loss=c_loss, + * Penalty=c_penalty, + */ + if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 409, __pyx_L1_error) + + /* "l0learn/interface.pyx":413 + * Penalty=c_penalty, + * Algorithm=c_algorithim, + * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< + * G_ncols=num_lambda, + * G_nrows=num_gamma, + */ + __pyx_t_32 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_32 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 413, __pyx_L1_error) + + /* "l0learn/interface.pyx":414 + * Algorithm=c_algorithim, + * NnzStopNum=max_support_size, + * G_ncols=num_lambda, # <<<<<<<<<<<<<< + * G_nrows=num_gamma, + * Lambda2Max=gamma_max, + */ + __pyx_t_31 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_31 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 414, __pyx_L1_error) + + /* "l0learn/interface.pyx":415 + * NnzStopNum=max_support_size, + * G_ncols=num_lambda, + * G_nrows=num_gamma, # <<<<<<<<<<<<<< + * Lambda2Max=gamma_max, + * Lambda2Min=gamma_min, + */ + __pyx_t_30 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_30 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 415, __pyx_L1_error) + + /* "l0learn/interface.pyx":418 + * Lambda2Max=gamma_max, + * Lambda2Min=gamma_min, + * PartialSort=partial_sort, # <<<<<<<<<<<<<< + * MaxIters=max_iter, + * rtol=rtol, + */ + __pyx_t_33 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_33 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 418, __pyx_L1_error) + + /* "l0learn/interface.pyx":419 + * Lambda2Min=gamma_min, + * PartialSort=partial_sort, + * MaxIters=max_iter, # <<<<<<<<<<<<<< + * rtol=rtol, + * atol=atol, + */ + __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 419, __pyx_L1_error) + + /* "l0learn/interface.pyx":422 + * rtol=rtol, + * atol=atol, + * ActiveSet=active_set, # <<<<<<<<<<<<<< + * ActiveSetNum=active_set_num, + * MaxNumSwaps=max_swaps, */ - __pyx_v_results = __pyx_f_7l0learn_9interface__L0LearnFit_dense(__pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_X)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_23, __pyx_t_24, __pyx_t_25, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_26, __pyx_t_27, __pyx_v_rtol, __pyx_v_atol, __pyx_t_28, __pyx_t_29, __pyx_t_30, __pyx_v_scale_down_factor, __pyx_t_31, (!(__pyx_v_auto_lambda != 0)), __pyx_v_c_lambda_grid, __pyx_t_32, __pyx_t_33, __pyx_v_with_bounds, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); + __pyx_t_28 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_28 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 422, __pyx_L1_error) - /* "l0learn/interface.pyx":288 - * - * cdef fitmodel results - * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< - * results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), - * y=numpy_to_dvec_d(y), + /* "l0learn/interface.pyx":423 + * atol=atol, + * ActiveSet=active_set, + * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< + * MaxNumSwaps=max_swaps, + * ScaleDownFactor=scale_down_factor, */ - goto __pyx_L100; - } + __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 423, __pyx_L1_error) - /* "l0learn/interface.pyx":316 - * Highs=numpy_to_dvec_d(highs)) - * else: # isinstance(X, csc_matrix) - * results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< - * y=numpy_to_dvec_d(y), - * Loss=c_loss, + /* "l0learn/interface.pyx":424 + * ActiveSet=active_set, + * ActiveSetNum=active_set_num, + * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< + * ScaleDownFactor=scale_down_factor, + * ScreenSize=screen_size, */ - /*else*/ { + __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 424, __pyx_L1_error) - /* "l0learn/interface.pyx":321 - * Penalty=c_penalty, - * Algorithm=c_algorithim, - * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< - * G_ncols=num_lambda, - * G_nrows=num_gamma, + /* "l0learn/interface.pyx":426 + * MaxNumSwaps=max_swaps, + * ScaleDownFactor=scale_down_factor, + * ScreenSize=screen_size, # <<<<<<<<<<<<<< + * LambdaU=not auto_lambda, + * Lambdas=c_lambda_grid, */ - __pyx_t_32 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_32 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 321, __pyx_L1_error) + __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 426, __pyx_L1_error) - /* "l0learn/interface.pyx":322 - * Algorithm=c_algorithim, - * NnzStopNum=max_support_size, - * G_ncols=num_lambda, # <<<<<<<<<<<<<< - * G_nrows=num_gamma, - * Lambda2Max=gamma_max, + /* "l0learn/interface.pyx":429 + * LambdaU=not auto_lambda, + * Lambdas=c_lambda_grid, + * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< + * Intercept=intercept, + * withBounds=with_bounds, */ - __pyx_t_31 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_31 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 322, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 429, __pyx_L1_error) - /* "l0learn/interface.pyx":323 - * NnzStopNum=max_support_size, - * G_ncols=num_lambda, - * G_nrows=num_gamma, # <<<<<<<<<<<<<< - * Lambda2Max=gamma_max, - * Lambda2Min=gamma_min, + /* "l0learn/interface.pyx":430 + * Lambdas=c_lambda_grid, + * ExcludeFirstK=exclude_first_k, + * Intercept=intercept, # <<<<<<<<<<<<<< + * withBounds=with_bounds, + * Lows=numpy_to_dvec_d(lows), */ - __pyx_t_30 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_30 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 323, __pyx_L1_error) + __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 430, __pyx_L1_error) - /* "l0learn/interface.pyx":326 - * Lambda2Max=gamma_max, - * Lambda2Min=gamma_min, - * PartialSort=partial_sort, # <<<<<<<<<<<<<< - * MaxIters=max_iter, - * rtol=rtol, + /* "l0learn/interface.pyx":432 + * Intercept=intercept, + * withBounds=with_bounds, + * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< + * Highs=numpy_to_dvec_d(highs)) + * */ - __pyx_t_33 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_33 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 326, __pyx_L1_error) + if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 432, __pyx_L1_error) - /* "l0learn/interface.pyx":327 - * Lambda2Min=gamma_min, - * PartialSort=partial_sort, - * MaxIters=max_iter, # <<<<<<<<<<<<<< - * rtol=rtol, - * atol=atol, + /* "l0learn/interface.pyx":433 + * withBounds=with_bounds, + * Lows=numpy_to_dvec_d(lows), + * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< + * + * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, */ - __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 327, __pyx_L1_error) + if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 433, __pyx_L1_error) - /* "l0learn/interface.pyx":330 - * rtol=rtol, - * atol=atol, - * ActiveSet=active_set, # <<<<<<<<<<<<<< - * ActiveSetNum=active_set_num, - * MaxNumSwaps=max_swaps, + /* "l0learn/interface.pyx":408 + * Highs=numpy_to_dvec_d(highs)) + * else: # isinstance(X, csc_matrix) + * c_results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< + * y=numpy_to_dvec_d(y), + * Loss=c_loss, */ - __pyx_t_28 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_28 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 330, __pyx_L1_error) + __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnFit_sparse(__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(__pyx_v_X), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_32, __pyx_t_31, __pyx_t_30, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_33, __pyx_t_29, __pyx_v_rtol, __pyx_v_atol, __pyx_t_28, __pyx_t_27, __pyx_t_25, __pyx_v_scale_down_factor, __pyx_t_24, (!(__pyx_v_auto_lambda != 0)), __pyx_v_c_lambda_grid, __pyx_t_23, __pyx_t_26, __pyx_v_with_bounds, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); + } + __pyx_L105:; - /* "l0learn/interface.pyx":331 - * atol=atol, - * ActiveSet=active_set, - * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< - * MaxNumSwaps=max_swaps, - * ScaleDownFactor=scale_down_factor, + /* "l0learn/interface.pyx":435 + * Highs=numpy_to_dvec_d(highs)) + * + * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, # <<<<<<<<<<<<<< + * lambda_0=c_results.Lambda0, + * gamma=c_results.Lambda12, */ - __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 331, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_FitModel); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 435, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 435, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 435, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 435, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 435, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 435, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_settings, __pyx_t_3) < 0) __PYX_ERR(0, 435, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":332 - * ActiveSet=active_set, - * ActiveSetNum=active_set_num, - * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< - * ScaleDownFactor=scale_down_factor, - * ScreenSize=screen_size, + /* "l0learn/interface.pyx":436 + * + * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, + * lambda_0=c_results.Lambda0, # <<<<<<<<<<<<<< + * gamma=c_results.Lambda12, + * support_size=c_results.NnzCount, */ - __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 332, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Lambda0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 436, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_lambda_0, __pyx_t_3) < 0) __PYX_ERR(0, 435, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":334 - * MaxNumSwaps=max_swaps, - * ScaleDownFactor=scale_down_factor, - * ScreenSize=screen_size, # <<<<<<<<<<<<<< - * LambdaU=not auto_lambda, - * Lambdas=c_lambda_grid, + /* "l0learn/interface.pyx":437 + * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, + * lambda_0=c_results.Lambda0, + * gamma=c_results.Lambda12, # <<<<<<<<<<<<<< + * support_size=c_results.NnzCount, + * coeffs=sp_dmat_field_to_list(c_results.Beta), */ - __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 334, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_double(__pyx_v_c_results.Lambda12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 437, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_gamma, __pyx_t_3) < 0) __PYX_ERR(0, 435, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":337 - * LambdaU=not auto_lambda, - * Lambdas=c_lambda_grid, - * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< - * Intercept=intercept, - * withBounds=with_bounds, + /* "l0learn/interface.pyx":438 + * lambda_0=c_results.Lambda0, + * gamma=c_results.Lambda12, + * support_size=c_results.NnzCount, # <<<<<<<<<<<<<< + * coeffs=sp_dmat_field_to_list(c_results.Beta), + * intercepts=c_results.Intercept, */ - __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 337, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(__pyx_v_c_results.NnzCount); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 438, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_support_size, __pyx_t_3) < 0) __PYX_ERR(0, 435, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":338 - * Lambdas=c_lambda_grid, - * ExcludeFirstK=exclude_first_k, - * Intercept=intercept, # <<<<<<<<<<<<<< - * withBounds=with_bounds, - * Lows=numpy_to_dvec_d(lows), + /* "l0learn/interface.pyx":439 + * gamma=c_results.Lambda12, + * support_size=c_results.NnzCount, + * coeffs=sp_dmat_field_to_list(c_results.Beta), # <<<<<<<<<<<<<< + * intercepts=c_results.Intercept, + * converged=c_results.Converged) */ - __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 338, __pyx_L1_error) + __pyx_t_3 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_c_results.Beta); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 439, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_coeffs, __pyx_t_3) < 0) __PYX_ERR(0, 435, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":340 - * Intercept=intercept, - * withBounds=with_bounds, - * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< - * Highs=numpy_to_dvec_d(highs)) - * + /* "l0learn/interface.pyx":440 + * support_size=c_results.NnzCount, + * coeffs=sp_dmat_field_to_list(c_results.Beta), + * intercepts=c_results.Intercept, # <<<<<<<<<<<<<< + * converged=c_results.Converged) + * return results */ - if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 340, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Intercept); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 440, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_intercepts, __pyx_t_3) < 0) __PYX_ERR(0, 435, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":341 - * withBounds=with_bounds, - * Lows=numpy_to_dvec_d(lows), - * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< + /* "l0learn/interface.pyx":441 + * coeffs=sp_dmat_field_to_list(c_results.Beta), + * intercepts=c_results.Intercept, + * converged=c_results.Converged) # <<<<<<<<<<<<<< + * return results * - * return {"NnzCount": results.NnzCount, */ - if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 341, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(__pyx_v_c_results.Converged); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 441, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_converged, __pyx_t_3) < 0) __PYX_ERR(0, 435, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":316 - * Highs=numpy_to_dvec_d(highs)) - * else: # isinstance(X, csc_matrix) - * results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< - * y=numpy_to_dvec_d(y), - * Loss=c_loss, + /* "l0learn/interface.pyx":435 + * Highs=numpy_to_dvec_d(highs)) + * + * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, # <<<<<<<<<<<<<< + * lambda_0=c_results.Lambda0, + * gamma=c_results.Lambda12, */ - __pyx_v_results = __pyx_f_7l0learn_9interface__L0LearnFit_sparse(__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(__pyx_v_X), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_32, __pyx_t_31, __pyx_t_30, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_33, __pyx_t_29, __pyx_v_rtol, __pyx_v_atol, __pyx_t_28, __pyx_t_27, __pyx_t_25, __pyx_v_scale_down_factor, __pyx_t_24, (!(__pyx_v_auto_lambda != 0)), __pyx_v_c_lambda_grid, __pyx_t_23, __pyx_t_26, __pyx_v_with_bounds, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); - } - __pyx_L100:; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_empty_tuple, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 435, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_v_results = __pyx_t_3; + __pyx_t_3 = 0; - /* "l0learn/interface.pyx":343 - * Highs=numpy_to_dvec_d(highs)) + /* "l0learn/interface.pyx":442 + * intercepts=c_results.Intercept, + * converged=c_results.Converged) + * return results # <<<<<<<<<<<<<< + * * - * return {"NnzCount": results.NnzCount, # <<<<<<<<<<<<<< - * "Lambda0": results.Lambda0, - * "Lambda12": results.Lambda12, */ __Pyx_XDECREF(__pyx_r); - __pyx_t_7 = __Pyx_PyDict_NewPresized(6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 343, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(__pyx_v_results.NnzCount); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 343, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_NnzCount, __pyx_t_6) < 0) __PYX_ERR(0, 343, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - - /* "l0learn/interface.pyx":344 - * - * return {"NnzCount": results.NnzCount, - * "Lambda0": results.Lambda0, # <<<<<<<<<<<<<< - * "Lambda12": results.Lambda12, - * "Beta": sp_dmat_field_to_list(results.Beta), - */ - __pyx_t_6 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_results.Lambda0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 344, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_Lambda0, __pyx_t_6) < 0) __PYX_ERR(0, 343, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - - /* "l0learn/interface.pyx":345 - * return {"NnzCount": results.NnzCount, - * "Lambda0": results.Lambda0, - * "Lambda12": results.Lambda12, # <<<<<<<<<<<<<< - * "Beta": sp_dmat_field_to_list(results.Beta), - * "Intercept": results.Intercept, - */ - __pyx_t_6 = __pyx_convert_vector_to_py_double(__pyx_v_results.Lambda12); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 345, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_Lambda12, __pyx_t_6) < 0) __PYX_ERR(0, 343, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - - /* "l0learn/interface.pyx":346 - * "Lambda0": results.Lambda0, - * "Lambda12": results.Lambda12, - * "Beta": sp_dmat_field_to_list(results.Beta), # <<<<<<<<<<<<<< - * "Intercept": results.Intercept, - * "Converged": results.Converged} - */ - __pyx_t_6 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_results.Beta); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 346, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_Beta, __pyx_t_6) < 0) __PYX_ERR(0, 343, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - - /* "l0learn/interface.pyx":347 - * "Lambda12": results.Lambda12, - * "Beta": sp_dmat_field_to_list(results.Beta), - * "Intercept": results.Intercept, # <<<<<<<<<<<<<< - * "Converged": results.Converged} - * - */ - __pyx_t_6 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_results.Intercept); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 347, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_Intercept, __pyx_t_6) < 0) __PYX_ERR(0, 343, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - - /* "l0learn/interface.pyx":348 - * "Beta": sp_dmat_field_to_list(results.Beta), - * "Intercept": results.Intercept, - * "Converged": results.Converged} # <<<<<<<<<<<<<< - * - * def cvfit(X: Union[np.ndarray, csc_matrix], - */ - __pyx_t_6 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(__pyx_v_results.Converged); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 348, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_Converged, __pyx_t_6) < 0) __PYX_ERR(0, 343, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_r = __pyx_t_7; - __pyx_t_7 = 0; + __Pyx_INCREF(__pyx_v_results); + __pyx_r = __pyx_v_results; goto __pyx_L0; - /* "l0learn/interface.pyx":62 - * + /* "l0learn/interface.pyx":50 + * SUPPORTED_ALGORITHM = ("CD", "CDPSI") * * def fit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< * y: np.ndarray, @@ -6882,7 +7249,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_16); @@ -6891,9 +7258,14 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_L0:; __Pyx_XDECREF(__pyx_v_n); __Pyx_XDECREF(__pyx_v_p); + __Pyx_XDECREF(__pyx_v_unique_items); + __Pyx_XDECREF(__pyx_v_a); + __Pyx_XDECREF(__pyx_v__); __Pyx_XDECREF(__pyx_v_i); __Pyx_XDECREF(__pyx_v_sub_lambda_grid); __Pyx_XDECREF(__pyx_v_bad_bounds); + __Pyx_XDECREF(__pyx_v_results); + __Pyx_XDECREF(__pyx_v_y); __Pyx_XDECREF(__pyx_v_penalty); __Pyx_XDECREF(__pyx_v_num_lambda); __Pyx_XDECREF(__pyx_v_num_gamma); @@ -6905,8 +7277,8 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx return __pyx_r; } -/* "l0learn/interface.pyx":350 - * "Converged": results.Converged} +/* "l0learn/interface.pyx":445 + * * * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< * y: np.ndarray, @@ -6915,11 +7287,11 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx /* Python wrapper */ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_7l0learn_9interface_4cvfit[] = "cvfit(X: Union[np.ndarray, csc_matrix], ndarray y: np.ndarray, unicode loss: str = u'SquaredHinge', unicode penalty: str = u'L0', unicode algorithm: str = u'CD', num_folds: int = 10, seed: int = 1, max_support_size: int = 100, num_lambda: Optional[int] = 100, num_gamma: Optional[int] = 1, double gamma_max: float = 10., double gamma_min: float = .0001, partial_sort: bool = True, max_iter: int = 200, double rtol: float = 1e-6, double atol: float = 1e-9, active_set: bool = True, active_set_num: int = 3, max_swaps: int = 100, double scale_down_factor: float = 0.8, screen_size: int = 1000, lambda_grid: Optional[List[List[float]]] = None, exclude_first_k: int = 0, intercept: bool = True, lows: Union[np.ndarray, float] = -float(u'inf'), highs: Union[np.ndarray, float] = +float(u'inf'))"; +static char __pyx_doc_7l0learn_9interface_4cvfit[] = "cvfit(X: Union[np.ndarray, csc_matrix], y: np.ndarray, unicode loss: str = u'SquaredHinge', unicode penalty: str = u'L0', unicode algorithm: str = u'CD', num_folds: int = 10, seed: int = 1, max_support_size: int = 100, num_lambda: Optional[int] = 100, num_gamma: Optional[int] = 1, double gamma_max: float = 10., double gamma_min: float = .0001, partial_sort: bool = True, max_iter: int = 200, double rtol: float = 1e-6, double atol: float = 1e-9, active_set: bool = True, active_set_num: int = 3, max_swaps: int = 100, double scale_down_factor: float = 0.8, screen_size: int = 1000, lambda_grid: Optional[List[List[float]]] = None, exclude_first_k: int = 0, intercept: bool = True, lows: Union[np.ndarray, float] = -float(u'inf'), highs: Union[np.ndarray, float] = +float(u'inf'))"; static PyMethodDef __pyx_mdef_7l0learn_9interface_5cvfit = {"cvfit", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7l0learn_9interface_5cvfit, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7l0learn_9interface_4cvfit}; static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_X = 0; - PyArrayObject *__pyx_v_y = 0; + PyObject *__pyx_v_y = 0; PyObject *__pyx_v_loss = 0; PyObject *__pyx_v_penalty = 0; PyObject *__pyx_v_algorithm = 0; @@ -6962,7 +7334,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj values[8] = ((PyObject *)__pyx_int_100); values[9] = ((PyObject *)__pyx_int_1); - /* "l0learn/interface.pyx":362 + /* "l0learn/interface.pyx":457 * gamma_max: float = 10., * gamma_min: float = .0001, * partial_sort: bool = True, # <<<<<<<<<<<<<< @@ -6972,7 +7344,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj values[12] = ((PyObject *)Py_True); values[13] = ((PyObject *)__pyx_int_200); - /* "l0learn/interface.pyx":366 + /* "l0learn/interface.pyx":461 * rtol: float = 1e-6, * atol: float = 1e-9, * active_set: bool = True, # <<<<<<<<<<<<<< @@ -6984,7 +7356,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj values[18] = ((PyObject *)__pyx_int_100); values[20] = ((PyObject *)__pyx_int_1000); - /* "l0learn/interface.pyx":371 + /* "l0learn/interface.pyx":466 * scale_down_factor: float = 0.8, * screen_size: int = 1000, * lambda_grid: Optional[List[List[float]]] = None, # <<<<<<<<<<<<<< @@ -6994,7 +7366,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj values[21] = ((PyObject *)Py_None); values[22] = ((PyObject *)__pyx_int_0); - /* "l0learn/interface.pyx":373 + /* "l0learn/interface.pyx":468 * lambda_grid: Optional[List[List[float]]] = None, * exclude_first_k: int = 0, * intercept: bool = True, # <<<<<<<<<<<<<< @@ -7072,7 +7444,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("cvfit", 0, 2, 26, 1); __PYX_ERR(0, 350, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("cvfit", 0, 2, 26, 1); __PYX_ERR(0, 445, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: @@ -7220,7 +7592,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "cvfit") < 0)) __PYX_ERR(0, 350, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "cvfit") < 0)) __PYX_ERR(0, 445, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -7279,7 +7651,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj } } __pyx_v_X = values[0]; - __pyx_v_y = ((PyArrayObject *)values[1]); + __pyx_v_y = values[1]; __pyx_v_loss = ((PyObject*)values[2]); __pyx_v_penalty = ((PyObject*)values[3]); __pyx_v_algorithm = ((PyObject*)values[4]); @@ -7289,24 +7661,24 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj __pyx_v_num_lambda = values[8]; __pyx_v_num_gamma = values[9]; if (values[10]) { - __pyx_v_gamma_max = __pyx_PyFloat_AsDouble(values[10]); if (unlikely((__pyx_v_gamma_max == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 360, __pyx_L3_error) + __pyx_v_gamma_max = __pyx_PyFloat_AsDouble(values[10]); if (unlikely((__pyx_v_gamma_max == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 455, __pyx_L3_error) } else { __pyx_v_gamma_max = ((double)10.); } if (values[11]) { - __pyx_v_gamma_min = __pyx_PyFloat_AsDouble(values[11]); if (unlikely((__pyx_v_gamma_min == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 361, __pyx_L3_error) + __pyx_v_gamma_min = __pyx_PyFloat_AsDouble(values[11]); if (unlikely((__pyx_v_gamma_min == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 456, __pyx_L3_error) } else { __pyx_v_gamma_min = ((double).0001); } __pyx_v_partial_sort = values[12]; __pyx_v_max_iter = values[13]; if (values[14]) { - __pyx_v_rtol = __pyx_PyFloat_AsDouble(values[14]); if (unlikely((__pyx_v_rtol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 364, __pyx_L3_error) + __pyx_v_rtol = __pyx_PyFloat_AsDouble(values[14]); if (unlikely((__pyx_v_rtol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 459, __pyx_L3_error) } else { __pyx_v_rtol = ((double)1e-6); } if (values[15]) { - __pyx_v_atol = __pyx_PyFloat_AsDouble(values[15]); if (unlikely((__pyx_v_atol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 365, __pyx_L3_error) + __pyx_v_atol = __pyx_PyFloat_AsDouble(values[15]); if (unlikely((__pyx_v_atol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 460, __pyx_L3_error) } else { __pyx_v_atol = ((double)1e-9); } @@ -7314,7 +7686,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj __pyx_v_active_set_num = values[17]; __pyx_v_max_swaps = values[18]; if (values[19]) { - __pyx_v_scale_down_factor = __pyx_PyFloat_AsDouble(values[19]); if (unlikely((__pyx_v_scale_down_factor == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 369, __pyx_L3_error) + __pyx_v_scale_down_factor = __pyx_PyFloat_AsDouble(values[19]); if (unlikely((__pyx_v_scale_down_factor == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 464, __pyx_L3_error) } else { __pyx_v_scale_down_factor = ((double)0.8); } @@ -7327,20 +7699,19 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("cvfit", 0, 2, 26, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 350, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("cvfit", 0, 2, 26, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 445, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("l0learn.interface.cvfit", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_y), __pyx_ptype_5numpy_ndarray, 1, "y", 0))) __PYX_ERR(0, 351, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loss), (&PyUnicode_Type), 1, "loss", 1))) __PYX_ERR(0, 352, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_penalty), (&PyUnicode_Type), 1, "penalty", 1))) __PYX_ERR(0, 353, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_algorithm), (&PyUnicode_Type), 1, "algorithm", 1))) __PYX_ERR(0, 354, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loss), (&PyUnicode_Type), 1, "loss", 1))) __PYX_ERR(0, 447, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_penalty), (&PyUnicode_Type), 1, "penalty", 1))) __PYX_ERR(0, 448, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_algorithm), (&PyUnicode_Type), 1, "algorithm", 1))) __PYX_ERR(0, 449, __pyx_L1_error) __pyx_r = __pyx_pf_7l0learn_9interface_4cvfit(__pyx_self, __pyx_v_X, __pyx_v_y, __pyx_v_loss, __pyx_v_penalty, __pyx_v_algorithm, __pyx_v_num_folds, __pyx_v_seed, __pyx_v_max_support_size, __pyx_v_num_lambda, __pyx_v_num_gamma, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_v_partial_sort, __pyx_v_max_iter, __pyx_v_rtol, __pyx_v_atol, __pyx_v_active_set, __pyx_v_active_set_num, __pyx_v_max_swaps, __pyx_v_scale_down_factor, __pyx_v_screen_size, __pyx_v_lambda_grid, __pyx_v_exclude_first_k, __pyx_v_intercept, __pyx_v_lows, __pyx_v_highs); - /* "l0learn/interface.pyx":350 - * "Converged": results.Converged} + /* "l0learn/interface.pyx":445 + * * * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< * y: np.ndarray, @@ -7356,9 +7727,12 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj return __pyx_r; } -static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyArrayObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_num_folds, PyObject *__pyx_v_seed, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs) { +static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_num_folds, PyObject *__pyx_v_seed, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs) { PyObject *__pyx_v_n = NULL; PyObject *__pyx_v_p = NULL; + PyObject *__pyx_v_unique_items = NULL; + PyObject *__pyx_v_a = NULL; + CYTHON_UNUSED PyObject *__pyx_v__ = NULL; int __pyx_v_auto_lambda; CYTHON_UNUSED int __pyx_v_bad_lambda_grid; PyObject *__pyx_v_i = NULL; @@ -7370,15 +7744,16 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p std::string __pyx_v_c_loss; std::string __pyx_v_c_penalty; std::string __pyx_v_c_algorithim; - cvfitmodel __pyx_v_results; + cvfitmodel __pyx_v_c_results; + PyObject *__pyx_v_results = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; - int __pyx_t_3; + PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; - PyObject *__pyx_t_6 = NULL; + int __pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; Py_ssize_t __pyx_t_9; @@ -7411,6 +7786,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("cvfit", 0); + __Pyx_INCREF(__pyx_v_y); __Pyx_INCREF(__pyx_v_penalty); __Pyx_INCREF(__pyx_v_num_lambda); __Pyx_INCREF(__pyx_v_num_gamma); @@ -7418,111 +7794,117 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_INCREF(__pyx_v_lows); __Pyx_INCREF(__pyx_v_highs); - /* "l0learn/interface.pyx":376 + /* "l0learn/interface.pyx":471 * lows: Union[np.ndarray, float] = -float('inf'), * highs: Union[np.ndarray, float] = +float('inf'),): * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): # <<<<<<<<<<<<<< * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") * */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 376, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 471, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __Pyx_TypeCheck(__pyx_v_X, __pyx_ptype_5numpy_ndarray); - __pyx_t_5 = (__pyx_t_4 != 0); - if (!__pyx_t_5) { + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 471, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 471, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = PyObject_IsInstance(__pyx_v_X, __pyx_t_3); + __pyx_t_6 = (__pyx_t_5 != 0); + if (!__pyx_t_6) { } else { - __pyx_t_3 = __pyx_t_5; + __pyx_t_4 = __pyx_t_6; goto __pyx_L6_bool_binop_done; } - __pyx_t_5 = PyObject_IsInstance(__pyx_v_X, __pyx_t_2); - __pyx_t_4 = (__pyx_t_5 != 0); - __pyx_t_3 = __pyx_t_4; + __pyx_t_6 = PyObject_IsInstance(__pyx_v_X, __pyx_t_2); + __pyx_t_5 = (__pyx_t_6 != 0); + __pyx_t_4 = __pyx_t_5; __pyx_L6_bool_binop_done:; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = ((!(__pyx_t_3 != 0)) != 0); - if (!__pyx_t_4) { + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); + if (!__pyx_t_5) { } else { - __pyx_t_1 = __pyx_t_4; + __pyx_t_1 = __pyx_t_5; goto __pyx_L4_bool_binop_done; } - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 376, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 376, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 471, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 471, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = NULL; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { - __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7); - if (likely(__pyx_t_6)) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); - __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } - __pyx_t_2 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_6, __pyx_v_X) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_X); - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 376, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_2, __pyx_v_X) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_X); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 471, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 376, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = ((!__pyx_t_4) != 0); - if (!__pyx_t_3) { + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 471, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = ((!__pyx_t_5) != 0); + if (!__pyx_t_4) { } else { - __pyx_t_1 = __pyx_t_3; + __pyx_t_1 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 376, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyInt_NeObjC(__pyx_t_2, __pyx_int_2, 2, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 376, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 471, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyInt_NeObjC(__pyx_t_3, __pyx_int_2, 2, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 471, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 376, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 471, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (!__pyx_t_3) { + if (!__pyx_t_4) { } else { - __pyx_t_1 = __pyx_t_3; + __pyx_t_1 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 376, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_product); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 376, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 376, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 471, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_product); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 471, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 471, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __pyx_t_8 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_6, function); + __Pyx_DECREF_SET(__pyx_t_2, function); } } - __pyx_t_7 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_8, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_2); + __pyx_t_7 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_8, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 376, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 471, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 376, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 471, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = ((!__pyx_t_3) != 0); - __pyx_t_1 = __pyx_t_4; + __pyx_t_5 = ((!__pyx_t_4) != 0); + __pyx_t_1 = __pyx_t_5; __pyx_L4_bool_binop_done:; if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":377 + /* "l0learn/interface.pyx":472 * highs: Union[np.ndarray, float] = +float('inf'),): * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") # <<<<<<<<<<<<<< * * n, p = X.shape */ - __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 377, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 472, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -7530,28 +7912,28 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_9 += 71; __Pyx_GIVEREF(__pyx_kp_u_expected_X_to_be_a_2D_non_degene); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_X_to_be_a_2D_non_degene); - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_X, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 377, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_6); - __pyx_t_6 = 0; + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_X, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 472, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_2); + __pyx_t_2 = 0; __Pyx_INCREF(__pyx_kp_u__5); __pyx_t_9 += 1; __Pyx_GIVEREF(__pyx_kp_u__5); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u__5); - __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 377, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 472, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 377, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 472, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 377, __pyx_L1_error) + __PYX_ERR(0, 472, __pyx_L1_error) - /* "l0learn/interface.pyx":376 + /* "l0learn/interface.pyx":471 * lows: Union[np.ndarray, float] = -float('inf'), * highs: Union[np.ndarray, float] = +float('inf'),): * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): # <<<<<<<<<<<<<< @@ -7560,14 +7942,14 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":379 + /* "l0learn/interface.pyx":474 * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") * * n, p = X.shape # <<<<<<<<<<<<<< * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") */ - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 379, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if ((likely(PyTuple_CheckExact(__pyx_t_7))) || (PyList_CheckExact(__pyx_t_7))) { PyObject* sequence = __pyx_t_7; @@ -7575,36 +7957,36 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 379, __pyx_L1_error) + __PYX_ERR(0, 474, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_2 = PyTuple_GET_ITEM(sequence, 1); + __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); } else { - __pyx_t_6 = PyList_GET_ITEM(sequence, 0); - __pyx_t_2 = PyList_GET_ITEM(sequence, 1); + __pyx_t_2 = PyList_GET_ITEM(sequence, 0); + __pyx_t_3 = PyList_GET_ITEM(sequence, 1); } - __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); #else - __pyx_t_6 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 379, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 379, __pyx_L1_error) + __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 474, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); #endif __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else { Py_ssize_t index = -1; - __pyx_t_8 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 379, __pyx_L1_error) + __pyx_t_8 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_11 = Py_TYPE(__pyx_t_8)->tp_iternext; - index = 0; __pyx_t_6 = __pyx_t_11(__pyx_t_8); if (unlikely(!__pyx_t_6)) goto __pyx_L10_unpacking_failed; - __Pyx_GOTREF(__pyx_t_6); - index = 1; __pyx_t_2 = __pyx_t_11(__pyx_t_8); if (unlikely(!__pyx_t_2)) goto __pyx_L10_unpacking_failed; + index = 0; __pyx_t_2 = __pyx_t_11(__pyx_t_8); if (unlikely(!__pyx_t_2)) goto __pyx_L10_unpacking_failed; __Pyx_GOTREF(__pyx_t_2); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_8), 2) < 0) __PYX_ERR(0, 379, __pyx_L1_error) + index = 1; __pyx_t_3 = __pyx_t_11(__pyx_t_8); if (unlikely(!__pyx_t_3)) goto __pyx_L10_unpacking_failed; + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_8), 2) < 0) __PYX_ERR(0, 474, __pyx_L1_error) __pyx_t_11 = NULL; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L11_unpacking_done; @@ -7612,110 +7994,122 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_11 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 379, __pyx_L1_error) + __PYX_ERR(0, 474, __pyx_L1_error) __pyx_L11_unpacking_done:; } - __pyx_v_n = __pyx_t_6; - __pyx_t_6 = 0; - __pyx_v_p = __pyx_t_2; + __pyx_v_n = __pyx_t_2; __pyx_t_2 = 0; + __pyx_v_p = __pyx_t_3; + __pyx_t_3 = 0; - /* "l0learn/interface.pyx":380 + /* "l0learn/interface.pyx":475 * * n, p = X.shape * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: # <<<<<<<<<<<<<< * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") * */ - __pyx_t_4 = __Pyx_TypeCheck(((PyObject *)__pyx_v_y), __pyx_ptype_5numpy_ndarray); - __pyx_t_3 = ((!(__pyx_t_4 != 0)) != 0); - if (!__pyx_t_3) { + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 475, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 475, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_5 = PyObject_IsInstance(__pyx_v_y, __pyx_t_3); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 475, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = ((!(__pyx_t_5 != 0)) != 0); + if (!__pyx_t_4) { } else { - __pyx_t_1 = __pyx_t_3; + __pyx_t_1 = __pyx_t_4; goto __pyx_L13_bool_binop_done; } - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 380, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 475, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 475, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 380, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_6); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); - __Pyx_INCREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_6, function); + __Pyx_DECREF_SET(__pyx_t_2, function); } } - __pyx_t_7 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_2, ((PyObject *)__pyx_v_y)) : __Pyx_PyObject_CallOneArg(__pyx_t_6, ((PyObject *)__pyx_v_y)); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 380, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 380, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = ((!__pyx_t_3) != 0); - if (!__pyx_t_4) { + __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_7, __pyx_v_y) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_y); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 475, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 475, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = ((!__pyx_t_4) != 0); + if (!__pyx_t_5) { } else { - __pyx_t_1 = __pyx_t_4; + __pyx_t_1 = __pyx_t_5; goto __pyx_L13_bool_binop_done; } - __pyx_t_4 = ((__pyx_v_y->nd != 1) != 0); - if (!__pyx_t_4) { + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_y, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 475, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyInt_NeObjC(__pyx_t_3, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 475, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 475, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (!__pyx_t_5) { } else { - __pyx_t_1 = __pyx_t_4; + __pyx_t_1 = __pyx_t_5; goto __pyx_L13_bool_binop_done; } - __pyx_t_9 = PyObject_Length(((PyObject *)__pyx_v_y)); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 380, __pyx_L1_error) - __pyx_t_7 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 380, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = PyObject_RichCompare(__pyx_t_7, __pyx_v_n, Py_NE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 380, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 380, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_1 = __pyx_t_4; + __pyx_t_9 = PyObject_Length(__pyx_v_y); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 475, __pyx_L1_error) + __pyx_t_2 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 475, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyObject_RichCompare(__pyx_t_2, __pyx_v_n, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 475, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 475, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __pyx_t_5; __pyx_L13_bool_binop_done:; if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":381 + /* "l0learn/interface.pyx":476 * n, p = X.shape * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") # <<<<<<<<<<<<<< * * if loss not in SUPPORTED_LOSS: */ - __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 381, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 476, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_expected_y_to_be_a_1D_real_numpy); __pyx_t_9 += 42; __Pyx_GIVEREF(__pyx_kp_u_expected_y_to_be_a_1D_real_numpy); - PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_y_to_be_a_1D_real_numpy); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(((PyObject *)__pyx_v_y), __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 381, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_7); - __pyx_t_7 = 0; + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_y_to_be_a_1D_real_numpy); + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_y, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 476, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); + __pyx_t_2 = 0; __Pyx_INCREF(__pyx_kp_u__5); __pyx_t_9 += 1; __Pyx_GIVEREF(__pyx_kp_u__5); - PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u__5); - __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_6, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 381, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 381, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 381, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u__5); + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 476, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 476, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 476, __pyx_L1_error) - /* "l0learn/interface.pyx":380 + /* "l0learn/interface.pyx":475 * * n, p = X.shape * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: # <<<<<<<<<<<<<< @@ -7724,67 +8118,67 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":383 + /* "l0learn/interface.pyx":478 * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") * * if loss not in SUPPORTED_LOSS: # <<<<<<<<<<<<<< * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") * */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 383, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_loss, __pyx_t_6, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 383, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_4 = (__pyx_t_1 != 0); - if (unlikely(__pyx_t_4)) { + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 478, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_loss, __pyx_t_3, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 478, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = (__pyx_t_1 != 0); + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":384 + /* "l0learn/interface.pyx":479 * * if loss not in SUPPORTED_LOSS: * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") # <<<<<<<<<<<<<< * * if penalty not in SUPPORTED_PENALTY: */ - __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 384, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 479, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_expected_loss_parameter_to_be_on); __pyx_t_9 += 36; __Pyx_GIVEREF(__pyx_kp_u_expected_loss_parameter_to_be_on); - PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_loss_parameter_to_be_on); - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 384, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 384, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_loss_parameter_to_be_on); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 479, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_2); - __pyx_t_2 = 0; + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 479, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7); + __pyx_t_7 = 0; __Pyx_INCREF(__pyx_kp_u_but_got); __pyx_t_9 += 10; __Pyx_GIVEREF(__pyx_kp_u_but_got); - PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u_but_got); - __pyx_t_2 = __Pyx_PyUnicode_Unicode(__pyx_v_loss); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 384, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_2); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_6, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 384, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 384, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 384, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_but_got); + __pyx_t_7 = __Pyx_PyUnicode_Unicode(__pyx_v_loss); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 479, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 479, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 479, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 479, __pyx_L1_error) - /* "l0learn/interface.pyx":383 + /* "l0learn/interface.pyx":478 * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") * * if loss not in SUPPORTED_LOSS: # <<<<<<<<<<<<<< @@ -7793,67 +8187,67 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":386 + /* "l0learn/interface.pyx":481 * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") * * if penalty not in SUPPORTED_PENALTY: # <<<<<<<<<<<<<< * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") * if algorithm not in SUPPORTED_ALGORITHM: */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_SUPPORTED_PENALTY); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 386, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_4 = (__Pyx_PySequence_ContainsTF(__pyx_v_penalty, __pyx_t_6, Py_NE)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 386, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_1 = (__pyx_t_4 != 0); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SUPPORTED_PENALTY); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 481, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_v_penalty, __pyx_t_3, Py_NE)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 481, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = (__pyx_t_5 != 0); if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":387 + /* "l0learn/interface.pyx":482 * * if penalty not in SUPPORTED_PENALTY: * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") # <<<<<<<<<<<<<< * if algorithm not in SUPPORTED_ALGORITHM: * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") */ - __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 387, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 482, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_expected_penalty_parameter_to_be); __pyx_t_9 += 39; __Pyx_GIVEREF(__pyx_kp_u_expected_penalty_parameter_to_be); - PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_penalty_parameter_to_be); - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SUPPORTED_PENALTY); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 387, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 387, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_penalty_parameter_to_be); + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_SUPPORTED_PENALTY); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 482, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_7); - __pyx_t_7 = 0; + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 482, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); + __pyx_t_2 = 0; __Pyx_INCREF(__pyx_kp_u_but_got); __pyx_t_9 += 10; __Pyx_GIVEREF(__pyx_kp_u_but_got); - PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u_but_got); - __pyx_t_7 = __Pyx_PyUnicode_Unicode(__pyx_v_penalty); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 387, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_7); - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_6, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 387, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 387, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 387, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_but_got); + __pyx_t_2 = __Pyx_PyUnicode_Unicode(__pyx_v_penalty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 482, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 482, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 482, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 482, __pyx_L1_error) - /* "l0learn/interface.pyx":386 + /* "l0learn/interface.pyx":481 * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") * * if penalty not in SUPPORTED_PENALTY: # <<<<<<<<<<<<<< @@ -7862,67 +8256,67 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":388 + /* "l0learn/interface.pyx":483 * if penalty not in SUPPORTED_PENALTY: * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") * if algorithm not in SUPPORTED_ALGORITHM: # <<<<<<<<<<<<<< * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") * if not isinstance(num_folds, int) or num_folds < 2: */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_SUPPORTED_ALGORITHM); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 388, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_algorithm, __pyx_t_6, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 388, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_4 = (__pyx_t_1 != 0); - if (unlikely(__pyx_t_4)) { + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SUPPORTED_ALGORITHM); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 483, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_algorithm, __pyx_t_3, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 483, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = (__pyx_t_1 != 0); + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":389 + /* "l0learn/interface.pyx":484 * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") * if algorithm not in SUPPORTED_ALGORITHM: * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") # <<<<<<<<<<<<<< * if not isinstance(num_folds, int) or num_folds < 2: * raise ValueError(f"expected num_folds parameter to be a integer greater than 2, but got {num_folds}") */ - __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 389, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 484, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_expected_algorithm_parameter_to); __pyx_t_9 += 41; __Pyx_GIVEREF(__pyx_kp_u_expected_algorithm_parameter_to); - PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_algorithm_parameter_to); - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_SUPPORTED_ALGORITHM); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 389, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 389, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_algorithm_parameter_to); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SUPPORTED_ALGORITHM); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 484, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_2); - __pyx_t_2 = 0; + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 484, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7); + __pyx_t_7 = 0; __Pyx_INCREF(__pyx_kp_u_but_got); __pyx_t_9 += 10; __Pyx_GIVEREF(__pyx_kp_u_but_got); - PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u_but_got); - __pyx_t_2 = __Pyx_PyUnicode_Unicode(__pyx_v_algorithm); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 389, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_2); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_6, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 389, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 389, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 389, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_but_got); + __pyx_t_7 = __Pyx_PyUnicode_Unicode(__pyx_v_algorithm); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 484, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 484, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 484, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 484, __pyx_L1_error) - /* "l0learn/interface.pyx":388 + /* "l0learn/interface.pyx":483 * if penalty not in SUPPORTED_PENALTY: * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") * if algorithm not in SUPPORTED_ALGORITHM: # <<<<<<<<<<<<<< @@ -7931,7 +8325,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":390 + /* "l0learn/interface.pyx":485 * if algorithm not in SUPPORTED_ALGORITHM: * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") * if not isinstance(num_folds, int) or num_folds < 2: # <<<<<<<<<<<<<< @@ -7939,39 +8333,39 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p * if not isinstance(seed, int): */ __pyx_t_1 = PyInt_Check(__pyx_v_num_folds); - __pyx_t_3 = ((!(__pyx_t_1 != 0)) != 0); - if (!__pyx_t_3) { + __pyx_t_4 = ((!(__pyx_t_1 != 0)) != 0); + if (!__pyx_t_4) { } else { - __pyx_t_4 = __pyx_t_3; + __pyx_t_5 = __pyx_t_4; goto __pyx_L21_bool_binop_done; } - __pyx_t_6 = PyObject_RichCompare(__pyx_v_num_folds, __pyx_int_2, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 390, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 390, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_4 = __pyx_t_3; + __pyx_t_3 = PyObject_RichCompare(__pyx_v_num_folds, __pyx_int_2, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 485, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 485, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __pyx_t_4; __pyx_L21_bool_binop_done:; - if (unlikely(__pyx_t_4)) { + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":391 + /* "l0learn/interface.pyx":486 * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") * if not isinstance(num_folds, int) or num_folds < 2: * raise ValueError(f"expected num_folds parameter to be a integer greater than 2, but got {num_folds}") # <<<<<<<<<<<<<< * if not isinstance(seed, int): * raise ValueError(f"expected seed parameter to be an integer, but got {seed}") */ - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_num_folds, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 391, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_folds_parameter_to, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 391, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 391, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 391, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_num_folds, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 486, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_folds_parameter_to, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 486, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 486, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 486, __pyx_L1_error) - /* "l0learn/interface.pyx":390 + /* "l0learn/interface.pyx":485 * if algorithm not in SUPPORTED_ALGORITHM: * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") * if not isinstance(num_folds, int) or num_folds < 2: # <<<<<<<<<<<<<< @@ -7980,37 +8374,37 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":392 + /* "l0learn/interface.pyx":487 * if not isinstance(num_folds, int) or num_folds < 2: * raise ValueError(f"expected num_folds parameter to be a integer greater than 2, but got {num_folds}") * if not isinstance(seed, int): # <<<<<<<<<<<<<< * raise ValueError(f"expected seed parameter to be an integer, but got {seed}") * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): */ - __pyx_t_4 = PyInt_Check(__pyx_v_seed); - __pyx_t_3 = ((!(__pyx_t_4 != 0)) != 0); - if (unlikely(__pyx_t_3)) { + __pyx_t_5 = PyInt_Check(__pyx_v_seed); + __pyx_t_4 = ((!(__pyx_t_5 != 0)) != 0); + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":393 + /* "l0learn/interface.pyx":488 * raise ValueError(f"expected num_folds parameter to be a integer greater than 2, but got {num_folds}") * if not isinstance(seed, int): * raise ValueError(f"expected seed parameter to be an integer, but got {seed}") # <<<<<<<<<<<<<< * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," */ - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_seed, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 393, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_seed_parameter_to_be_an, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 393, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 393, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 393, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_seed, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 488, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_seed_parameter_to_be_an, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 488, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 488, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 488, __pyx_L1_error) - /* "l0learn/interface.pyx":392 + /* "l0learn/interface.pyx":487 * if not isinstance(num_folds, int) or num_folds < 2: * raise ValueError(f"expected num_folds parameter to be a integer greater than 2, but got {num_folds}") * if not isinstance(seed, int): # <<<<<<<<<<<<<< @@ -8019,92 +8413,92 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":394 + /* "l0learn/interface.pyx":489 * if not isinstance(seed, int): * raise ValueError(f"expected seed parameter to be an integer, but got {seed}") * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): # <<<<<<<<<<<<<< * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," * f" but got {max_support_size}") */ - __pyx_t_4 = PyInt_Check(__pyx_v_max_support_size); - __pyx_t_1 = ((!(__pyx_t_4 != 0)) != 0); + __pyx_t_5 = PyInt_Check(__pyx_v_max_support_size); + __pyx_t_1 = ((!(__pyx_t_5 != 0)) != 0); if (!__pyx_t_1) { } else { - __pyx_t_3 = __pyx_t_1; + __pyx_t_4 = __pyx_t_1; goto __pyx_L25_bool_binop_done; } - __pyx_t_6 = PyObject_RichCompare(__pyx_int_0, __pyx_v_max_support_size, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 394, __pyx_L1_error) - if (__Pyx_PyObject_IsTrue(__pyx_t_6)) { - __Pyx_DECREF(__pyx_t_6); - __pyx_t_6 = PyObject_RichCompare(__pyx_v_max_support_size, __pyx_v_p, Py_LE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 394, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_int_0, __pyx_v_max_support_size, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 489, __pyx_L1_error) + if (__Pyx_PyObject_IsTrue(__pyx_t_3)) { + __Pyx_DECREF(__pyx_t_3); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_max_support_size, __pyx_v_p, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 489, __pyx_L1_error) } - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 394, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_4 = ((!__pyx_t_1) != 0); - __pyx_t_3 = __pyx_t_4; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 489, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = ((!__pyx_t_1) != 0); + __pyx_t_4 = __pyx_t_5; __pyx_L25_bool_binop_done:; - if (unlikely(__pyx_t_3)) { + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":395 + /* "l0learn/interface.pyx":490 * raise ValueError(f"expected seed parameter to be an integer, but got {seed}") * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," # <<<<<<<<<<<<<< * f" but got {max_support_size}") * if gamma_max < 0: */ - __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 395, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 490, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_expected_max_support_size_parame); __pyx_t_9 += 71; __Pyx_GIVEREF(__pyx_kp_u_expected_max_support_size_parame); - PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_max_support_size_parame); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 395, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_2); - __pyx_t_2 = 0; + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_max_support_size_parame); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 490, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7); + __pyx_t_7 = 0; __Pyx_INCREF(__pyx_kp_u_but_got); __pyx_t_9 += 10; __Pyx_GIVEREF(__pyx_kp_u_but_got); - PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u_but_got); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_but_got); - /* "l0learn/interface.pyx":396 + /* "l0learn/interface.pyx":491 * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," * f" but got {max_support_size}") # <<<<<<<<<<<<<< * if gamma_max < 0: * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") */ - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_max_support_size, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 396, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_2); - __pyx_t_2 = 0; + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_max_support_size, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 491, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_7); + __pyx_t_7 = 0; - /* "l0learn/interface.pyx":395 + /* "l0learn/interface.pyx":490 * raise ValueError(f"expected seed parameter to be an integer, but got {seed}") * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," # <<<<<<<<<<<<<< * f" but got {max_support_size}") * if gamma_max < 0: */ - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_6, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 395, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 395, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 395, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 490, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 490, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 490, __pyx_L1_error) - /* "l0learn/interface.pyx":394 + /* "l0learn/interface.pyx":489 * if not isinstance(seed, int): * raise ValueError(f"expected seed parameter to be an integer, but got {seed}") * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): # <<<<<<<<<<<<<< @@ -8113,39 +8507,39 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":397 + /* "l0learn/interface.pyx":492 * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," * f" but got {max_support_size}") * if gamma_max < 0: # <<<<<<<<<<<<<< * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") * if gamma_min < 0 or gamma_min > gamma_max: */ - __pyx_t_3 = ((__pyx_v_gamma_max < 0.0) != 0); - if (unlikely(__pyx_t_3)) { + __pyx_t_4 = ((__pyx_v_gamma_max < 0.0) != 0); + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":398 + /* "l0learn/interface.pyx":493 * f" but got {max_support_size}") * if gamma_max < 0: * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") # <<<<<<<<<<<<<< * if gamma_min < 0 or gamma_min > gamma_max: * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," */ - __pyx_t_6 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 398, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_6, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 398, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_gamma_max_parameter_to, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 398, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 398, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_Raise(__pyx_t_2, 0, 0, 0); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 398, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_gamma_max_parameter_to, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(0, 493, __pyx_L1_error) - /* "l0learn/interface.pyx":397 + /* "l0learn/interface.pyx":492 * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," * f" but got {max_support_size}") * if gamma_max < 0: # <<<<<<<<<<<<<< @@ -8154,55 +8548,55 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":399 + /* "l0learn/interface.pyx":494 * if gamma_max < 0: * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") * if gamma_min < 0 or gamma_min > gamma_max: # <<<<<<<<<<<<<< * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," * f" but got {gamma_min}") */ - __pyx_t_4 = ((__pyx_v_gamma_min < 0.0) != 0); - if (!__pyx_t_4) { + __pyx_t_5 = ((__pyx_v_gamma_min < 0.0) != 0); + if (!__pyx_t_5) { } else { - __pyx_t_3 = __pyx_t_4; + __pyx_t_4 = __pyx_t_5; goto __pyx_L29_bool_binop_done; } - __pyx_t_4 = ((__pyx_v_gamma_min > __pyx_v_gamma_max) != 0); - __pyx_t_3 = __pyx_t_4; + __pyx_t_5 = ((__pyx_v_gamma_min > __pyx_v_gamma_max) != 0); + __pyx_t_4 = __pyx_t_5; __pyx_L29_bool_binop_done:; - if (unlikely(__pyx_t_3)) { + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":401 + /* "l0learn/interface.pyx":496 * if gamma_min < 0 or gamma_min > gamma_max: * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," * f" but got {gamma_min}") # <<<<<<<<<<<<<< * if not isinstance(partial_sort, bool): * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") */ - __pyx_t_2 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 401, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 401, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_7 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 496, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 496, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - /* "l0learn/interface.pyx":400 + /* "l0learn/interface.pyx":495 * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") * if gamma_min < 0 or gamma_min > gamma_max: * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," # <<<<<<<<<<<<<< * f" but got {gamma_min}") * if not isinstance(partial_sort, bool): */ - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_gamma_max_parameter_to_2, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 400, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 400, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 400, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_gamma_max_parameter_to_2, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 495, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 495, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 495, __pyx_L1_error) - /* "l0learn/interface.pyx":399 + /* "l0learn/interface.pyx":494 * if gamma_max < 0: * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") * if gamma_min < 0 or gamma_min > gamma_max: # <<<<<<<<<<<<<< @@ -8211,40 +8605,40 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":402 + /* "l0learn/interface.pyx":497 * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," * f" but got {gamma_min}") * if not isinstance(partial_sort, bool): # <<<<<<<<<<<<<< * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") * if not isinstance(max_iter, int) or max_iter < 1: */ - __pyx_t_6 = ((PyObject*)&PyBool_Type); - __Pyx_INCREF(__pyx_t_6); - __pyx_t_3 = PyObject_IsInstance(__pyx_v_partial_sort, __pyx_t_6); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 402, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_4 = ((!(__pyx_t_3 != 0)) != 0); - if (unlikely(__pyx_t_4)) { + __pyx_t_3 = ((PyObject*)&PyBool_Type); + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = PyObject_IsInstance(__pyx_v_partial_sort, __pyx_t_3); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 497, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":403 + /* "l0learn/interface.pyx":498 * f" but got {gamma_min}") * if not isinstance(partial_sort, bool): * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") # <<<<<<<<<<<<<< * if not isinstance(max_iter, int) or max_iter < 1: * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") */ - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_partial_sort, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 403, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_partial_sort_parameter, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 403, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 403, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 403, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_partial_sort, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 498, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_partial_sort_parameter, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 498, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 498, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 498, __pyx_L1_error) - /* "l0learn/interface.pyx":402 + /* "l0learn/interface.pyx":497 * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," * f" but got {gamma_min}") * if not isinstance(partial_sort, bool): # <<<<<<<<<<<<<< @@ -8253,47 +8647,47 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":404 + /* "l0learn/interface.pyx":499 * if not isinstance(partial_sort, bool): * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") * if not isinstance(max_iter, int) or max_iter < 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") * if rtol < 0 or rtol >= 1: */ - __pyx_t_3 = PyInt_Check(__pyx_v_max_iter); - __pyx_t_1 = ((!(__pyx_t_3 != 0)) != 0); + __pyx_t_4 = PyInt_Check(__pyx_v_max_iter); + __pyx_t_1 = ((!(__pyx_t_4 != 0)) != 0); if (!__pyx_t_1) { } else { - __pyx_t_4 = __pyx_t_1; + __pyx_t_5 = __pyx_t_1; goto __pyx_L33_bool_binop_done; } - __pyx_t_6 = PyObject_RichCompare(__pyx_v_max_iter, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 404, __pyx_L1_error) - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 404, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_4 = __pyx_t_1; + __pyx_t_3 = PyObject_RichCompare(__pyx_v_max_iter, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 499, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 499, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __pyx_t_1; __pyx_L33_bool_binop_done:; - if (unlikely(__pyx_t_4)) { + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":405 + /* "l0learn/interface.pyx":500 * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") * if not isinstance(max_iter, int) or max_iter < 1: * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") # <<<<<<<<<<<<<< * if rtol < 0 or rtol >= 1: * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") */ - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_max_iter, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 405, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_iter_parameter_to_b, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 405, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 405, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 405, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_max_iter, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 500, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_iter_parameter_to_b, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 500, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 500, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 500, __pyx_L1_error) - /* "l0learn/interface.pyx":404 + /* "l0learn/interface.pyx":499 * if not isinstance(partial_sort, bool): * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") * if not isinstance(max_iter, int) or max_iter < 1: # <<<<<<<<<<<<<< @@ -8302,7 +8696,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":406 + /* "l0learn/interface.pyx":501 * if not isinstance(max_iter, int) or max_iter < 1: * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") * if rtol < 0 or rtol >= 1: # <<<<<<<<<<<<<< @@ -8312,37 +8706,37 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_1 = ((__pyx_v_rtol < 0.0) != 0); if (!__pyx_t_1) { } else { - __pyx_t_4 = __pyx_t_1; + __pyx_t_5 = __pyx_t_1; goto __pyx_L36_bool_binop_done; } __pyx_t_1 = ((__pyx_v_rtol >= 1.0) != 0); - __pyx_t_4 = __pyx_t_1; + __pyx_t_5 = __pyx_t_1; __pyx_L36_bool_binop_done:; - if (unlikely(__pyx_t_4)) { + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":407 + /* "l0learn/interface.pyx":502 * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") * if rtol < 0 or rtol >= 1: * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") # <<<<<<<<<<<<<< * if atol < 0: * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") */ - __pyx_t_6 = PyFloat_FromDouble(__pyx_v_rtol); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 407, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_6, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 407, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_rtol_parameter_to_exist, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 407, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 407, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_Raise(__pyx_t_2, 0, 0, 0); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 407, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_rtol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 502, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 502, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_rtol_parameter_to_exist, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 502, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 502, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(0, 502, __pyx_L1_error) - /* "l0learn/interface.pyx":406 + /* "l0learn/interface.pyx":501 * if not isinstance(max_iter, int) or max_iter < 1: * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") * if rtol < 0 or rtol >= 1: # <<<<<<<<<<<<<< @@ -8351,39 +8745,39 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":408 + /* "l0learn/interface.pyx":503 * if rtol < 0 or rtol >= 1: * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") * if atol < 0: # <<<<<<<<<<<<<< * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") * if not isinstance(active_set, bool): */ - __pyx_t_4 = ((__pyx_v_atol < 0.0) != 0); - if (unlikely(__pyx_t_4)) { + __pyx_t_5 = ((__pyx_v_atol < 0.0) != 0); + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":409 + /* "l0learn/interface.pyx":504 * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") * if atol < 0: * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") # <<<<<<<<<<<<<< * if not isinstance(active_set, bool): * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") */ - __pyx_t_2 = PyFloat_FromDouble(__pyx_v_atol); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 409, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 409, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_atol_parameter_to_exist, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 409, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 409, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 409, __pyx_L1_error) + __pyx_t_7 = PyFloat_FromDouble(__pyx_v_atol); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 504, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 504, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_atol_parameter_to_exist, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 504, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 504, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 504, __pyx_L1_error) - /* "l0learn/interface.pyx":408 + /* "l0learn/interface.pyx":503 * if rtol < 0 or rtol >= 1: * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") * if atol < 0: # <<<<<<<<<<<<<< @@ -8392,40 +8786,40 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":410 + /* "l0learn/interface.pyx":505 * if atol < 0: * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") * if not isinstance(active_set, bool): # <<<<<<<<<<<<<< * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") * if not isinstance(active_set_num, int) or active_set_num < 1: */ - __pyx_t_6 = ((PyObject*)&PyBool_Type); - __Pyx_INCREF(__pyx_t_6); - __pyx_t_4 = PyObject_IsInstance(__pyx_v_active_set, __pyx_t_6); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 410, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_1 = ((!(__pyx_t_4 != 0)) != 0); + __pyx_t_3 = ((PyObject*)&PyBool_Type); + __Pyx_INCREF(__pyx_t_3); + __pyx_t_5 = PyObject_IsInstance(__pyx_v_active_set, __pyx_t_3); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 505, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = ((!(__pyx_t_5 != 0)) != 0); if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":411 + /* "l0learn/interface.pyx":506 * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") * if not isinstance(active_set, bool): * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") # <<<<<<<<<<<<<< * if not isinstance(active_set_num, int) or active_set_num < 1: * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") */ - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_active_set, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 411, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_active_set_parameter_to, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 411, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 411, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 411, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_active_set, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 506, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_active_set_parameter_to, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 506, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 506, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 506, __pyx_L1_error) - /* "l0learn/interface.pyx":410 + /* "l0learn/interface.pyx":505 * if atol < 0: * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") * if not isinstance(active_set, bool): # <<<<<<<<<<<<<< @@ -8434,47 +8828,47 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":412 + /* "l0learn/interface.pyx":507 * if not isinstance(active_set, bool): * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") * if not isinstance(active_set_num, int) or active_set_num < 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") * if not isinstance(max_swaps, int) or max_swaps < 1: */ - __pyx_t_4 = PyInt_Check(__pyx_v_active_set_num); - __pyx_t_3 = ((!(__pyx_t_4 != 0)) != 0); - if (!__pyx_t_3) { + __pyx_t_5 = PyInt_Check(__pyx_v_active_set_num); + __pyx_t_4 = ((!(__pyx_t_5 != 0)) != 0); + if (!__pyx_t_4) { } else { - __pyx_t_1 = __pyx_t_3; + __pyx_t_1 = __pyx_t_4; goto __pyx_L41_bool_binop_done; } - __pyx_t_6 = PyObject_RichCompare(__pyx_v_active_set_num, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 412, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 412, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = PyObject_RichCompare(__pyx_v_active_set_num, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 507, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 507, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __pyx_t_4; __pyx_L41_bool_binop_done:; if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":413 + /* "l0learn/interface.pyx":508 * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") * if not isinstance(active_set_num, int) or active_set_num < 1: * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") # <<<<<<<<<<<<<< * if not isinstance(max_swaps, int) or max_swaps < 1: * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") */ - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_active_set_num, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 413, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_active_set_num_paramete, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 413, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 413, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 413, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_active_set_num, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 508, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_active_set_num_paramete, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 508, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 508, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 508, __pyx_L1_error) - /* "l0learn/interface.pyx":412 + /* "l0learn/interface.pyx":507 * if not isinstance(active_set, bool): * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") * if not isinstance(active_set_num, int) or active_set_num < 1: # <<<<<<<<<<<<<< @@ -8483,47 +8877,47 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":414 + /* "l0learn/interface.pyx":509 * if not isinstance(active_set_num, int) or active_set_num < 1: * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") * if not isinstance(max_swaps, int) or max_swaps < 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") * if not (0 < scale_down_factor < 1): */ - __pyx_t_3 = PyInt_Check(__pyx_v_max_swaps); - __pyx_t_4 = ((!(__pyx_t_3 != 0)) != 0); - if (!__pyx_t_4) { + __pyx_t_4 = PyInt_Check(__pyx_v_max_swaps); + __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); + if (!__pyx_t_5) { } else { - __pyx_t_1 = __pyx_t_4; + __pyx_t_1 = __pyx_t_5; goto __pyx_L44_bool_binop_done; } - __pyx_t_6 = PyObject_RichCompare(__pyx_v_max_swaps, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 414, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 414, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_1 = __pyx_t_4; + __pyx_t_3 = PyObject_RichCompare(__pyx_v_max_swaps, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 509, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 509, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __pyx_t_5; __pyx_L44_bool_binop_done:; if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":415 + /* "l0learn/interface.pyx":510 * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") * if not isinstance(max_swaps, int) or max_swaps < 1: * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") # <<<<<<<<<<<<<< * if not (0 < scale_down_factor < 1): * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") */ - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_max_swaps, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 415, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_swaps_parameter_to, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 415, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 415, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 415, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_max_swaps, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 510, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_swaps_parameter_to, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 510, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 510, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 510, __pyx_L1_error) - /* "l0learn/interface.pyx":414 + /* "l0learn/interface.pyx":509 * if not isinstance(active_set_num, int) or active_set_num < 1: * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") * if not isinstance(max_swaps, int) or max_swaps < 1: # <<<<<<<<<<<<<< @@ -8532,7 +8926,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":416 + /* "l0learn/interface.pyx":511 * if not isinstance(max_swaps, int) or max_swaps < 1: * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") * if not (0 < scale_down_factor < 1): # <<<<<<<<<<<<<< @@ -8543,32 +8937,32 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p if (__pyx_t_1) { __pyx_t_1 = (__pyx_v_scale_down_factor < 1.0); } - __pyx_t_4 = ((!(__pyx_t_1 != 0)) != 0); - if (unlikely(__pyx_t_4)) { + __pyx_t_5 = ((!(__pyx_t_1 != 0)) != 0); + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":417 + /* "l0learn/interface.pyx":512 * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") * if not (0 < scale_down_factor < 1): * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") # <<<<<<<<<<<<<< * if not isinstance(screen_size, int) or screen_size < 1: * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") */ - __pyx_t_6 = PyFloat_FromDouble(__pyx_v_scale_down_factor); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 417, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_6, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 417, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_scale_down_factor_param, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 417, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 417, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_Raise(__pyx_t_2, 0, 0, 0); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 417, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_scale_down_factor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_scale_down_factor_param, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(0, 512, __pyx_L1_error) - /* "l0learn/interface.pyx":416 + /* "l0learn/interface.pyx":511 * if not isinstance(max_swaps, int) or max_swaps < 1: * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") * if not (0 < scale_down_factor < 1): # <<<<<<<<<<<<<< @@ -8577,7 +8971,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":418 + /* "l0learn/interface.pyx":513 * if not (0 < scale_down_factor < 1): * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") * if not isinstance(screen_size, int) or screen_size < 1: # <<<<<<<<<<<<<< @@ -8585,39 +8979,39 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): */ __pyx_t_1 = PyInt_Check(__pyx_v_screen_size); - __pyx_t_3 = ((!(__pyx_t_1 != 0)) != 0); - if (!__pyx_t_3) { + __pyx_t_4 = ((!(__pyx_t_1 != 0)) != 0); + if (!__pyx_t_4) { } else { - __pyx_t_4 = __pyx_t_3; + __pyx_t_5 = __pyx_t_4; goto __pyx_L48_bool_binop_done; } - __pyx_t_2 = PyObject_RichCompare(__pyx_v_screen_size, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 418, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 418, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __pyx_t_3; + __pyx_t_7 = PyObject_RichCompare(__pyx_v_screen_size, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 513, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 513, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_5 = __pyx_t_4; __pyx_L48_bool_binop_done:; - if (unlikely(__pyx_t_4)) { + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":419 + /* "l0learn/interface.pyx":514 * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") * if not isinstance(screen_size, int) or screen_size < 1: * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") # <<<<<<<<<<<<<< * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " */ - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_screen_size, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 419, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_screen_size_parameter_t, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 419, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 419, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_Raise(__pyx_t_2, 0, 0, 0); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 419, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_screen_size, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_screen_size_parameter_t_2, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(0, 514, __pyx_L1_error) - /* "l0learn/interface.pyx":418 + /* "l0learn/interface.pyx":513 * if not (0 < scale_down_factor < 1): * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") * if not isinstance(screen_size, int) or screen_size < 1: # <<<<<<<<<<<<<< @@ -8626,92 +9020,92 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":420 + /* "l0learn/interface.pyx":515 * if not isinstance(screen_size, int) or screen_size < 1: * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): # <<<<<<<<<<<<<< * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " * f"but got {exclude_first_k}") */ - __pyx_t_3 = PyInt_Check(__pyx_v_exclude_first_k); - __pyx_t_1 = ((!(__pyx_t_3 != 0)) != 0); + __pyx_t_4 = PyInt_Check(__pyx_v_exclude_first_k); + __pyx_t_1 = ((!(__pyx_t_4 != 0)) != 0); if (!__pyx_t_1) { } else { - __pyx_t_4 = __pyx_t_1; + __pyx_t_5 = __pyx_t_1; goto __pyx_L51_bool_binop_done; } - __pyx_t_2 = PyObject_RichCompare(__pyx_int_0, __pyx_v_exclude_first_k, Py_LE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 420, __pyx_L1_error) - if (__Pyx_PyObject_IsTrue(__pyx_t_2)) { - __Pyx_DECREF(__pyx_t_2); - __pyx_t_2 = PyObject_RichCompare(__pyx_v_exclude_first_k, __pyx_v_p, Py_LE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 420, __pyx_L1_error) + __pyx_t_7 = PyObject_RichCompare(__pyx_int_0, __pyx_v_exclude_first_k, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 515, __pyx_L1_error) + if (__Pyx_PyObject_IsTrue(__pyx_t_7)) { + __Pyx_DECREF(__pyx_t_7); + __pyx_t_7 = PyObject_RichCompare(__pyx_v_exclude_first_k, __pyx_v_p, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 515, __pyx_L1_error) } - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 420, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = ((!__pyx_t_1) != 0); - __pyx_t_4 = __pyx_t_3; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 515, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_4 = ((!__pyx_t_1) != 0); + __pyx_t_5 = __pyx_t_4; __pyx_L51_bool_binop_done:; - if (unlikely(__pyx_t_4)) { + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":421 + /* "l0learn/interface.pyx":516 * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " # <<<<<<<<<<<<<< * f"but got {exclude_first_k}") * if not isinstance(intercept, bool): */ - __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 421, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 516, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_expected_exclude_first_k_paramet); __pyx_t_9 += 70; __Pyx_GIVEREF(__pyx_kp_u_expected_exclude_first_k_paramet); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_u_expected_exclude_first_k_paramet); - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 421, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_6); - __pyx_t_6 = 0; + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_exclude_first_k_paramet); + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 516, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_3); + __pyx_t_3 = 0; __Pyx_INCREF(__pyx_kp_u_but_got); __pyx_t_9 += 10; __Pyx_GIVEREF(__pyx_kp_u_but_got); - PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_kp_u_but_got); + PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_but_got); - /* "l0learn/interface.pyx":422 + /* "l0learn/interface.pyx":517 * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " * f"but got {exclude_first_k}") # <<<<<<<<<<<<<< * if not isinstance(intercept, bool): * raise ValueError(f"expected intercept parameter to be a bool, " */ - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_exclude_first_k, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 422, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_6); - __pyx_t_6 = 0; + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_exclude_first_k, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 517, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_3); + __pyx_t_3 = 0; - /* "l0learn/interface.pyx":421 + /* "l0learn/interface.pyx":516 * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " # <<<<<<<<<<<<<< * f"but got {exclude_first_k}") * if not isinstance(intercept, bool): */ - __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_2, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 421, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 421, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_Raise(__pyx_t_2, 0, 0, 0); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 421, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 516, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 516, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(0, 516, __pyx_L1_error) - /* "l0learn/interface.pyx":420 + /* "l0learn/interface.pyx":515 * if not isinstance(screen_size, int) or screen_size < 1: * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): # <<<<<<<<<<<<<< @@ -8720,48 +9114,48 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":423 + /* "l0learn/interface.pyx":518 * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " * f"but got {exclude_first_k}") * if not isinstance(intercept, bool): # <<<<<<<<<<<<<< * raise ValueError(f"expected intercept parameter to be a bool, " * f"but got {intercept}") */ - __pyx_t_2 = ((PyObject*)&PyBool_Type); - __Pyx_INCREF(__pyx_t_2); - __pyx_t_4 = PyObject_IsInstance(__pyx_v_intercept, __pyx_t_2); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 423, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = ((!(__pyx_t_4 != 0)) != 0); - if (unlikely(__pyx_t_3)) { + __pyx_t_7 = ((PyObject*)&PyBool_Type); + __Pyx_INCREF(__pyx_t_7); + __pyx_t_5 = PyObject_IsInstance(__pyx_v_intercept, __pyx_t_7); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 518, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_4 = ((!(__pyx_t_5 != 0)) != 0); + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":425 + /* "l0learn/interface.pyx":520 * if not isinstance(intercept, bool): * raise ValueError(f"expected intercept parameter to be a bool, " * f"but got {intercept}") # <<<<<<<<<<<<<< * * if loss in CLASSIFICATION_LOSS: */ - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_intercept, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 425, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_intercept, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 520, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); - /* "l0learn/interface.pyx":424 + /* "l0learn/interface.pyx":519 * f"but got {exclude_first_k}") * if not isinstance(intercept, bool): * raise ValueError(f"expected intercept parameter to be a bool, " # <<<<<<<<<<<<<< * f"but got {intercept}") * */ - __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_intercept_parameter_to, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 424, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 424, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_Raise(__pyx_t_2, 0, 0, 0); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 424, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_intercept_parameter_to, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 519, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 519, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(0, 519, __pyx_L1_error) - /* "l0learn/interface.pyx":423 + /* "l0learn/interface.pyx":518 * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " * f"but got {exclude_first_k}") * if not isinstance(intercept, bool): # <<<<<<<<<<<<<< @@ -8770,184 +9164,258 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":427 + /* "l0learn/interface.pyx":522 * f"but got {intercept}") * * if loss in CLASSIFICATION_LOSS: # <<<<<<<<<<<<<< - * if sorted(np.unique(y)) != [-1, 1]: - * raise ValueError(f"expected y vector to only have two unique values (-1 and 1) (Binary Classification), " + * unique_items = sorted(np.unique(y)) + * if 0 >= len(unique_items) > 2: */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_CLASSIFICATION_LOSS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 427, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = (__Pyx_PySequence_ContainsTF(__pyx_v_loss, __pyx_t_2, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 427, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = (__pyx_t_3 != 0); - if (__pyx_t_4) { + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_CLASSIFICATION_LOSS); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_4 = (__Pyx_PySequence_ContainsTF(__pyx_v_loss, __pyx_t_7, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 522, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_5 = (__pyx_t_4 != 0); + if (__pyx_t_5) { - /* "l0learn/interface.pyx":428 + /* "l0learn/interface.pyx":523 * * if loss in CLASSIFICATION_LOSS: - * if sorted(np.unique(y)) != [-1, 1]: # <<<<<<<<<<<<<< - * raise ValueError(f"expected y vector to only have two unique values (-1 and 1) (Binary Classification), " - * f"but got {np.unique(y)}") + * unique_items = sorted(np.unique(y)) # <<<<<<<<<<<<<< + * if 0 >= len(unique_items) > 2: + * raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 428, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_unique); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 428, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_unique); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 523, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = NULL; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); - if (likely(__pyx_t_7)) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); - __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } - __pyx_t_6 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_7, ((PyObject *)__pyx_v_y)) : __Pyx_PyObject_CallOneArg(__pyx_t_8, ((PyObject *)__pyx_v_y)); - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 428, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_2, __pyx_v_y) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_y); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = PySequence_List(__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 428, __pyx_L1_error) + __pyx_t_8 = PySequence_List(__pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 523, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_2 = ((PyObject*)__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = ((PyObject*)__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_12 = PyList_Sort(__pyx_t_2); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 428, __pyx_L1_error) - __pyx_t_8 = PyList_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 428, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_INCREF(__pyx_int_neg_1); - __Pyx_GIVEREF(__pyx_int_neg_1); - PyList_SET_ITEM(__pyx_t_8, 0, __pyx_int_neg_1); - __Pyx_INCREF(__pyx_int_1); - __Pyx_GIVEREF(__pyx_int_1); - PyList_SET_ITEM(__pyx_t_8, 1, __pyx_int_1); - __pyx_t_6 = PyObject_RichCompare(__pyx_t_2, __pyx_t_8, Py_NE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 428, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 428, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_12 = PyList_Sort(__pyx_t_7); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 523, __pyx_L1_error) + __pyx_v_unique_items = ((PyObject*)__pyx_t_7); + __pyx_t_7 = 0; + + /* "l0learn/interface.pyx":524 + * if loss in CLASSIFICATION_LOSS: + * unique_items = sorted(np.unique(y)) + * if 0 >= len(unique_items) > 2: # <<<<<<<<<<<<<< + * raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " + * f"but got {unique_items}") + */ + if (unlikely(__pyx_v_unique_items == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(0, 524, __pyx_L1_error) + } + __pyx_t_9 = PyList_GET_SIZE(__pyx_v_unique_items); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 524, __pyx_L1_error) + __pyx_t_5 = (0 >= __pyx_t_9); + if (__pyx_t_5) { + __pyx_t_5 = (__pyx_t_9 > 2); + } + __pyx_t_4 = (__pyx_t_5 != 0); if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":430 - * if sorted(np.unique(y)) != [-1, 1]: - * raise ValueError(f"expected y vector to only have two unique values (-1 and 1) (Binary Classification), " - * f"but got {np.unique(y)}") # <<<<<<<<<<<<<< - * - * if penalty == "L0": + /* "l0learn/interface.pyx":526 + * if 0 >= len(unique_items) > 2: + * raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " + * f"but got {unique_items}") # <<<<<<<<<<<<<< + * else: + * a, *_ = unique_items # a is the lower value + */ + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_unique_items, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 526, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + + /* "l0learn/interface.pyx":525 + * unique_items = sorted(np.unique(y)) + * if 0 >= len(unique_items) > 2: + * raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " # <<<<<<<<<<<<<< + * f"but got {unique_items}") + * else: */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 430, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_y_vector_to_only_have_t, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 525, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_unique); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 430, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 525, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(0, 525, __pyx_L1_error) + + /* "l0learn/interface.pyx":524 + * if loss in CLASSIFICATION_LOSS: + * unique_items = sorted(np.unique(y)) + * if 0 >= len(unique_items) > 2: # <<<<<<<<<<<<<< + * raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " + * f"but got {unique_items}") + */ + } + + /* "l0learn/interface.pyx":528 + * f"but got {unique_items}") + * else: + * a, *_ = unique_items # a is the lower value # <<<<<<<<<<<<<< + * y = np.copy(y) + * y[y==a] = -1 + */ + /*else*/ { + { + Py_ssize_t index = -1; + PyObject** temps[2] = {&__pyx_t_7}; + __pyx_t_8 = PyObject_GetIter(__pyx_v_unique_items); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 528, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_11 = Py_TYPE(__pyx_t_8)->tp_iternext; + for (index=0; index < 1; index++) { + PyObject* item = __pyx_t_11(__pyx_t_8); if (unlikely(!item)) goto __pyx_L56_unpacking_failed; + __Pyx_GOTREF(item); + *(temps[index]) = item; + } + goto __pyx_L57_unpacking_done; + __pyx_L56_unpacking_failed:; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_11 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 528, __pyx_L1_error) + __pyx_L57_unpacking_done:; + } + __pyx_t_3 = PySequence_List(__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 528, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_v_a = __pyx_t_7; + __pyx_t_7 = 0; + __pyx_v__ = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "l0learn/interface.pyx":529 + * else: + * a, *_ = unique_items # a is the lower value + * y = np.copy(y) # <<<<<<<<<<<<<< + * y[y==a] = -1 + * y[y!=a] = 1 + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 529, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_copy); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 529, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); + __Pyx_DECREF_SET(__pyx_t_8, function); } } - __pyx_t_6 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_8, ((PyObject *)__pyx_v_y)) : __Pyx_PyObject_CallOneArg(__pyx_t_2, ((PyObject *)__pyx_v_y)); - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 430, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_6, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 430, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_7, __pyx_v_y) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_y); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 529, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF_SET(__pyx_v_y, __pyx_t_3); + __pyx_t_3 = 0; - /* "l0learn/interface.pyx":429 - * if loss in CLASSIFICATION_LOSS: - * if sorted(np.unique(y)) != [-1, 1]: - * raise ValueError(f"expected y vector to only have two unique values (-1 and 1) (Binary Classification), " # <<<<<<<<<<<<<< - * f"but got {np.unique(y)}") + /* "l0learn/interface.pyx":530 + * a, *_ = unique_items # a is the lower value + * y = np.copy(y) + * y[y==a] = -1 # <<<<<<<<<<<<<< + * y[y!=a] = 1 * */ - __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_y_vector_to_only_have_t, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 429, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 429, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_Raise(__pyx_t_2, 0, 0, 0); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 429, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_y, __pyx_v_a, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 530, __pyx_L1_error) + if (unlikely(PyObject_SetItem(__pyx_v_y, __pyx_t_3, __pyx_int_neg_1) < 0)) __PYX_ERR(0, 530, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":428 + /* "l0learn/interface.pyx":531 + * y = np.copy(y) + * y[y==a] = -1 + * y[y!=a] = 1 # <<<<<<<<<<<<<< * - * if loss in CLASSIFICATION_LOSS: - * if sorted(np.unique(y)) != [-1, 1]: # <<<<<<<<<<<<<< - * raise ValueError(f"expected y vector to only have two unique values (-1 and 1) (Binary Classification), " - * f"but got {np.unique(y)}") + * if penalty == "L0": */ + __pyx_t_3 = PyObject_RichCompare(__pyx_v_y, __pyx_v_a, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 531, __pyx_L1_error) + if (unlikely(PyObject_SetItem(__pyx_v_y, __pyx_t_3, __pyx_int_1) < 0)) __PYX_ERR(0, 531, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } - /* "l0learn/interface.pyx":432 - * f"but got {np.unique(y)}") + /* "l0learn/interface.pyx":533 + * y[y!=a] = 1 * * if penalty == "L0": # <<<<<<<<<<<<<< * # TODO: Must be corrected in R code: https://github.com/hazimehh/L0Learn/blob/7a65474dfdb01489a0c263d7b24fbafad56fba61/R/fit.R#L136 * # Pure L0 is not supported for classification */ - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 432, __pyx_L1_error) - __pyx_t_3 = (__pyx_t_4 != 0); - if (__pyx_t_3) { + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 533, __pyx_L1_error) + __pyx_t_5 = (__pyx_t_4 != 0); + if (__pyx_t_5) { - /* "l0learn/interface.pyx":437 + /* "l0learn/interface.pyx":538 * # Below we add a small L2 component. * * if len(lambda_grid) != 1: # <<<<<<<<<<<<<< * # If this error checking was left to the lower section, it would confuse users as * # we are converting L0 to L0L2 with small L2 penalty. */ - __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 437, __pyx_L1_error) - __pyx_t_3 = ((__pyx_t_9 != 1) != 0); - if (unlikely(__pyx_t_3)) { + __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 538, __pyx_L1_error) + __pyx_t_5 = ((__pyx_t_9 != 1) != 0); + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":442 + /* "l0learn/interface.pyx":543 * # Here we must check if lambdaGrid is supplied (And thus use 'autolambda') * # If 'lambdaGrid' is supplied, we must only supply 1 list of lambda values * raise ValueError(f"L0 Penalty requires 'lambda_grid' to be a list of length 1, but got {lambda_grid}.") # <<<<<<<<<<<<<< * * penalty = "L0L2" */ - __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 442, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 543, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_L0_Penalty_requires_lambda_grid); __pyx_t_9 += 68; __Pyx_GIVEREF(__pyx_kp_u_L0_Penalty_requires_lambda_grid); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_u_L0_Penalty_requires_lambda_grid); - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 442, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_6); - __pyx_t_6 = 0; + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_L0_Penalty_requires_lambda_grid); + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 543, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_8); + __pyx_t_8 = 0; __Pyx_INCREF(__pyx_kp_u__5); __pyx_t_9 += 1; __Pyx_GIVEREF(__pyx_kp_u__5); - PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_kp_u__5); - __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_2, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 442, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 442, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_Raise(__pyx_t_2, 0, 0, 0); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 442, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u__5); + __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 543, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 543, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 543, __pyx_L1_error) - /* "l0learn/interface.pyx":437 + /* "l0learn/interface.pyx":538 * # Below we add a small L2 component. * * if len(lambda_grid) != 1: # <<<<<<<<<<<<<< @@ -8956,8 +9424,8 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":432 - * f"but got {np.unique(y)}") + /* "l0learn/interface.pyx":533 + * y[y!=a] = 1 * * if penalty == "L0": # <<<<<<<<<<<<<< * # TODO: Must be corrected in R code: https://github.com/hazimehh/L0Learn/blob/7a65474dfdb01489a0c263d7b24fbafad56fba61/R/fit.R#L136 @@ -8965,7 +9433,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":444 + /* "l0learn/interface.pyx":545 * raise ValueError(f"L0 Penalty requires 'lambda_grid' to be a list of length 1, but got {lambda_grid}.") * * penalty = "L0L2" # <<<<<<<<<<<<<< @@ -8975,65 +9443,162 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_INCREF(__pyx_n_u_L0L2); __Pyx_DECREF_SET(__pyx_v_penalty, __pyx_n_u_L0L2); - /* "l0learn/interface.pyx":445 + /* "l0learn/interface.pyx":546 * * penalty = "L0L2" * gamma_max = 1e-7 # <<<<<<<<<<<<<< * gamma_min = 1e-7 - * + * elif penalty != "L0" and num_gamma == 1: */ __pyx_v_gamma_max = 1e-7; - /* "l0learn/interface.pyx":446 - * penalty = "L0L2" - * gamma_max = 1e-7 - * gamma_min = 1e-7 # <<<<<<<<<<<<<< + /* "l0learn/interface.pyx":547 + * penalty = "L0L2" + * gamma_max = 1e-7 + * gamma_min = 1e-7 # <<<<<<<<<<<<<< + * elif penalty != "L0" and num_gamma == 1: + * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") + */ + __pyx_v_gamma_min = 1e-7; + + /* "l0learn/interface.pyx":522 + * f"but got {intercept}") + * + * if loss in CLASSIFICATION_LOSS: # <<<<<<<<<<<<<< + * unique_items = sorted(np.unique(y)) + * if 0 >= len(unique_items) > 2: + */ + goto __pyx_L54; + } + + /* "l0learn/interface.pyx":548 + * gamma_max = 1e-7 + * gamma_min = 1e-7 + * elif penalty != "L0" and num_gamma == 1: # <<<<<<<<<<<<<< + * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") + * + */ + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_NE)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 548, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_4 != 0); + if (__pyx_t_1) { + } else { + __pyx_t_5 = __pyx_t_1; + goto __pyx_L60_bool_binop_done; + } + __pyx_t_3 = __Pyx_PyInt_EqObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 548, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 548, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __pyx_t_1; + __pyx_L60_bool_binop_done:; + if (__pyx_t_5) { + + /* "l0learn/interface.pyx":549 + * gamma_min = 1e-7 + * elif penalty != "L0" and num_gamma == 1: + * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") # <<<<<<<<<<<<<< * * if lambda_grid is None: */ - __pyx_v_gamma_min = 1e-7; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_warn); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 549, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = PyTuple_New(5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 549, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_num_gamma_set_to_1_with); + __pyx_t_9 += 24; + __Pyx_GIVEREF(__pyx_kp_u_num_gamma_set_to_1_with); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_num_gamma_set_to_1_with); + __pyx_t_2 = __Pyx_PyUnicode_Unicode(__pyx_v_penalty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 549, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_kp_u_penalty_Only_one); + __pyx_t_9 += 19; + __Pyx_GIVEREF(__pyx_kp_u_penalty_Only_one); + PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_penalty_Only_one); + if (unlikely(__pyx_v_penalty == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 549, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_PyUnicode_Substring(__pyx_v_penalty, 2, PY_SSIZE_T_MAX); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 549, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_kp_u_penalty_value_will_be_fit); + __pyx_t_9 += 27; + __Pyx_GIVEREF(__pyx_kp_u_penalty_value_will_be_fit); + PyTuple_SET_ITEM(__pyx_t_7, 4, __pyx_kp_u_penalty_value_will_be_fit); + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_7, 5, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 549, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + } + } + __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_7, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_2); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 549, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":427 - * f"but got {intercept}") + /* "l0learn/interface.pyx":548 + * gamma_max = 1e-7 + * gamma_min = 1e-7 + * elif penalty != "L0" and num_gamma == 1: # <<<<<<<<<<<<<< + * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") * - * if loss in CLASSIFICATION_LOSS: # <<<<<<<<<<<<<< - * if sorted(np.unique(y)) != [-1, 1]: - * raise ValueError(f"expected y vector to only have two unique values (-1 and 1) (Binary Classification), " */ } + __pyx_L54:; - /* "l0learn/interface.pyx":448 - * gamma_min = 1e-7 + /* "l0learn/interface.pyx":551 + * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") * * if lambda_grid is None: # <<<<<<<<<<<<<< * lambda_grid = [[0.]] * auto_lambda = True */ - __pyx_t_3 = (__pyx_v_lambda_grid == Py_None); - __pyx_t_4 = (__pyx_t_3 != 0); - if (__pyx_t_4) { + __pyx_t_5 = (__pyx_v_lambda_grid == Py_None); + __pyx_t_1 = (__pyx_t_5 != 0); + if (__pyx_t_1) { - /* "l0learn/interface.pyx":449 + /* "l0learn/interface.pyx":552 * * if lambda_grid is None: * lambda_grid = [[0.]] # <<<<<<<<<<<<<< * auto_lambda = True * if not isinstance(num_lambda, int) or num_lambda < 1: */ - __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 449, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 552, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_float_0_); __Pyx_GIVEREF(__pyx_float_0_); - PyList_SET_ITEM(__pyx_t_2, 0, __pyx_float_0_); - __pyx_t_6 = PyList_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 449, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_2); - PyList_SET_ITEM(__pyx_t_6, 0, __pyx_t_2); - __pyx_t_2 = 0; - __Pyx_DECREF_SET(__pyx_v_lambda_grid, __pyx_t_6); - __pyx_t_6 = 0; + PyList_SET_ITEM(__pyx_t_3, 0, __pyx_float_0_); + __pyx_t_8 = PyList_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 552, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_3); + PyList_SET_ITEM(__pyx_t_8, 0, __pyx_t_3); + __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_lambda_grid, __pyx_t_8); + __pyx_t_8 = 0; - /* "l0learn/interface.pyx":450 + /* "l0learn/interface.pyx":553 * if lambda_grid is None: * lambda_grid = [[0.]] * auto_lambda = True # <<<<<<<<<<<<<< @@ -9042,64 +9607,64 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ __pyx_v_auto_lambda = 1; - /* "l0learn/interface.pyx":451 + /* "l0learn/interface.pyx":554 * lambda_grid = [[0.]] * auto_lambda = True * if not isinstance(num_lambda, int) or num_lambda < 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") * if not isinstance(num_gamma, int) or num_gamma < 1: */ - __pyx_t_3 = PyInt_Check(__pyx_v_num_lambda); - __pyx_t_1 = ((!(__pyx_t_3 != 0)) != 0); - if (!__pyx_t_1) { + __pyx_t_5 = PyInt_Check(__pyx_v_num_lambda); + __pyx_t_4 = ((!(__pyx_t_5 != 0)) != 0); + if (!__pyx_t_4) { } else { - __pyx_t_4 = __pyx_t_1; - goto __pyx_L60_bool_binop_done; + __pyx_t_1 = __pyx_t_4; + goto __pyx_L64_bool_binop_done; } - __pyx_t_6 = PyObject_RichCompare(__pyx_v_num_lambda, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 451, __pyx_L1_error) - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 451, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_4 = __pyx_t_1; - __pyx_L60_bool_binop_done:; - if (unlikely(__pyx_t_4)) { + __pyx_t_8 = PyObject_RichCompare(__pyx_v_num_lambda, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 554, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 554, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_1 = __pyx_t_4; + __pyx_L64_bool_binop_done:; + if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":452 + /* "l0learn/interface.pyx":555 * auto_lambda = True * if not isinstance(num_lambda, int) or num_lambda < 1: * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") # <<<<<<<<<<<<<< * if not isinstance(num_gamma, int) or num_gamma < 1: * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") */ - __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 452, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 555, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_expected_num_lambda_to_a_positiv); __pyx_t_9 += 76; __Pyx_GIVEREF(__pyx_kp_u_expected_num_lambda_to_a_positiv); - PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_num_lambda_to_a_positiv); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 452, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_2); - __pyx_t_2 = 0; + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_u_expected_num_lambda_to_a_positiv); + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 555, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_3); + __pyx_t_3 = 0; __Pyx_INCREF(__pyx_kp_u__5); __pyx_t_9 += 1; __Pyx_GIVEREF(__pyx_kp_u__5); - PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u__5); - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_6, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 452, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 452, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 452, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__5); + __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 555, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 555, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(0, 555, __pyx_L1_error) - /* "l0learn/interface.pyx":451 + /* "l0learn/interface.pyx":554 * lambda_grid = [[0.]] * auto_lambda = True * if not isinstance(num_lambda, int) or num_lambda < 1: # <<<<<<<<<<<<<< @@ -9108,64 +9673,64 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":453 + /* "l0learn/interface.pyx":556 * if not isinstance(num_lambda, int) or num_lambda < 1: * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") * if not isinstance(num_gamma, int) or num_gamma < 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") * if penalty == "L0" and num_gamma != 1: */ - __pyx_t_1 = PyInt_Check(__pyx_v_num_gamma); - __pyx_t_3 = ((!(__pyx_t_1 != 0)) != 0); - if (!__pyx_t_3) { + __pyx_t_4 = PyInt_Check(__pyx_v_num_gamma); + __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); + if (!__pyx_t_5) { } else { - __pyx_t_4 = __pyx_t_3; - goto __pyx_L63_bool_binop_done; - } - __pyx_t_6 = PyObject_RichCompare(__pyx_v_num_gamma, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 453, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 453, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_4 = __pyx_t_3; - __pyx_L63_bool_binop_done:; - if (unlikely(__pyx_t_4)) { + __pyx_t_1 = __pyx_t_5; + goto __pyx_L67_bool_binop_done; + } + __pyx_t_8 = PyObject_RichCompare(__pyx_v_num_gamma, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 556, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 556, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_1 = __pyx_t_5; + __pyx_L67_bool_binop_done:; + if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":454 + /* "l0learn/interface.pyx":557 * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") * if not isinstance(num_gamma, int) or num_gamma < 1: * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") # <<<<<<<<<<<<<< * if penalty == "L0" and num_gamma != 1: * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") */ - __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 454, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 557, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_expected_num_gamma_to_a_positive); __pyx_t_9 += 75; __Pyx_GIVEREF(__pyx_kp_u_expected_num_gamma_to_a_positive); - PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_num_gamma_to_a_positive); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 454, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_2); - __pyx_t_2 = 0; + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_u_expected_num_gamma_to_a_positive); + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 557, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_3); + __pyx_t_3 = 0; __Pyx_INCREF(__pyx_kp_u__5); __pyx_t_9 += 1; __Pyx_GIVEREF(__pyx_kp_u__5); - PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u__5); - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_6, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 454, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 454, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 454, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__5); + __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 557, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 557, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(0, 557, __pyx_L1_error) - /* "l0learn/interface.pyx":453 + /* "l0learn/interface.pyx":556 * if not isinstance(num_lambda, int) or num_lambda < 1: * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") * if not isinstance(num_gamma, int) or num_gamma < 1: # <<<<<<<<<<<<<< @@ -9174,65 +9739,65 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":455 + /* "l0learn/interface.pyx":558 * if not isinstance(num_gamma, int) or num_gamma < 1: * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") * else: # lambda_grid should be a List[List[float]] */ - __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 455, __pyx_L1_error) - __pyx_t_1 = (__pyx_t_3 != 0); - if (__pyx_t_1) { + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 558, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_5 != 0); + if (__pyx_t_4) { } else { - __pyx_t_4 = __pyx_t_1; - goto __pyx_L66_bool_binop_done; + __pyx_t_1 = __pyx_t_4; + goto __pyx_L70_bool_binop_done; } - __pyx_t_6 = __Pyx_PyInt_NeObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 455, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 455, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_4 = __pyx_t_1; - __pyx_L66_bool_binop_done:; - if (unlikely(__pyx_t_4)) { + __pyx_t_8 = __Pyx_PyInt_NeObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 558, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 558, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_1 = __pyx_t_4; + __pyx_L70_bool_binop_done:; + if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":456 + /* "l0learn/interface.pyx":559 * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") * if penalty == "L0" and num_gamma != 1: * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") # <<<<<<<<<<<<<< * else: # lambda_grid should be a List[List[float]] * if num_gamma is not None: */ - __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 456, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 559, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_expected_num_gamma_to_1_when_pen); __pyx_t_9 += 53; __Pyx_GIVEREF(__pyx_kp_u_expected_num_gamma_to_1_when_pen); - PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_num_gamma_to_1_when_pen); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 456, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_2); - __pyx_t_2 = 0; + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_u_expected_num_gamma_to_1_when_pen); + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 559, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_3); + __pyx_t_3 = 0; __Pyx_INCREF(__pyx_kp_u__5); __pyx_t_9 += 1; __Pyx_GIVEREF(__pyx_kp_u__5); - PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u__5); - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_6, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 456, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 456, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 456, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__5); + __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 559, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 559, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(0, 559, __pyx_L1_error) - /* "l0learn/interface.pyx":455 + /* "l0learn/interface.pyx":558 * if not isinstance(num_gamma, int) or num_gamma < 1: * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< @@ -9241,17 +9806,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":448 - * gamma_min = 1e-7 + /* "l0learn/interface.pyx":551 + * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") * * if lambda_grid is None: # <<<<<<<<<<<<<< * lambda_grid = [[0.]] * auto_lambda = True */ - goto __pyx_L58; + goto __pyx_L62; } - /* "l0learn/interface.pyx":458 + /* "l0learn/interface.pyx":561 * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") * else: # lambda_grid should be a List[List[float]] * if num_gamma is not None: # <<<<<<<<<<<<<< @@ -9259,38 +9824,38 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p * f"but got {num_gamma}") */ /*else*/ { - __pyx_t_4 = (__pyx_v_num_gamma != Py_None); - __pyx_t_1 = (__pyx_t_4 != 0); - if (unlikely(__pyx_t_1)) { + __pyx_t_1 = (__pyx_v_num_gamma != Py_None); + __pyx_t_4 = (__pyx_t_1 != 0); + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":460 + /* "l0learn/interface.pyx":563 * if num_gamma is not None: * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " * f"but got {num_gamma}") # <<<<<<<<<<<<<< * num_gamma = len(lambda_grid) * */ - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 460, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 563, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); - /* "l0learn/interface.pyx":459 + /* "l0learn/interface.pyx":562 * else: # lambda_grid should be a List[List[float]] * if num_gamma is not None: * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " # <<<<<<<<<<<<<< * f"but got {num_gamma}") * num_gamma = len(lambda_grid) */ - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_gamma_to_be_None_if, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 459, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 459, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 459, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_gamma_to_be_None_if, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 562, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 562, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(0, 562, __pyx_L1_error) - /* "l0learn/interface.pyx":458 + /* "l0learn/interface.pyx":561 * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") * else: # lambda_grid should be a List[List[float]] * if num_gamma is not None: # <<<<<<<<<<<<<< @@ -9299,58 +9864,58 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":461 + /* "l0learn/interface.pyx":564 * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " * f"but got {num_gamma}") * num_gamma = len(lambda_grid) # <<<<<<<<<<<<<< * * if num_lambda is not None: */ - __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 461, __pyx_L1_error) - __pyx_t_6 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 461, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF_SET(__pyx_v_num_gamma, __pyx_t_6); - __pyx_t_6 = 0; + __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 564, __pyx_L1_error) + __pyx_t_8 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 564, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF_SET(__pyx_v_num_gamma, __pyx_t_8); + __pyx_t_8 = 0; - /* "l0learn/interface.pyx":463 + /* "l0learn/interface.pyx":566 * num_gamma = len(lambda_grid) * * if num_lambda is not None: # <<<<<<<<<<<<<< * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " * f"but got {num_lambda}") */ - __pyx_t_1 = (__pyx_v_num_lambda != Py_None); - __pyx_t_4 = (__pyx_t_1 != 0); - if (unlikely(__pyx_t_4)) { + __pyx_t_4 = (__pyx_v_num_lambda != Py_None); + __pyx_t_1 = (__pyx_t_4 != 0); + if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":465 + /* "l0learn/interface.pyx":568 * if num_lambda is not None: * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " * f"but got {num_lambda}") # <<<<<<<<<<<<<< * num_lambda = 0 # This value is ignored. * auto_lambda = False */ - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 465, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 568, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); - /* "l0learn/interface.pyx":464 + /* "l0learn/interface.pyx":567 * * if num_lambda is not None: * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " # <<<<<<<<<<<<<< * f"but got {num_lambda}") * num_lambda = 0 # This value is ignored. */ - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_lambda_to_be_None_i, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 464, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 464, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 464, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_lambda_to_be_None_i, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 567, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 567, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(0, 567, __pyx_L1_error) - /* "l0learn/interface.pyx":463 + /* "l0learn/interface.pyx":566 * num_gamma = len(lambda_grid) * * if num_lambda is not None: # <<<<<<<<<<<<<< @@ -9359,7 +9924,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":466 + /* "l0learn/interface.pyx":569 * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " * f"but got {num_lambda}") * num_lambda = 0 # This value is ignored. # <<<<<<<<<<<<<< @@ -9369,7 +9934,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_INCREF(__pyx_int_0); __Pyx_DECREF_SET(__pyx_v_num_lambda, __pyx_int_0); - /* "l0learn/interface.pyx":467 + /* "l0learn/interface.pyx":570 * f"but got {num_lambda}") * num_lambda = 0 # This value is ignored. * auto_lambda = False # <<<<<<<<<<<<<< @@ -9378,7 +9943,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ __pyx_v_auto_lambda = 0; - /* "l0learn/interface.pyx":468 + /* "l0learn/interface.pyx":571 * num_lambda = 0 # This value is ignored. * auto_lambda = False * bad_lambda_grid = False # <<<<<<<<<<<<<< @@ -9387,49 +9952,49 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ __pyx_v_bad_lambda_grid = 0; - /* "l0learn/interface.pyx":470 + /* "l0learn/interface.pyx":573 * bad_lambda_grid = False * * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") * */ - __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 470, __pyx_L1_error) - __pyx_t_3 = (__pyx_t_1 != 0); - if (__pyx_t_3) { + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 573, __pyx_L1_error) + __pyx_t_5 = (__pyx_t_4 != 0); + if (__pyx_t_5) { } else { - __pyx_t_4 = __pyx_t_3; - goto __pyx_L71_bool_binop_done; - } - __pyx_t_6 = __Pyx_PyInt_NeObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 470, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 470, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_4 = __pyx_t_3; - __pyx_L71_bool_binop_done:; - if (unlikely(__pyx_t_4)) { + __pyx_t_1 = __pyx_t_5; + goto __pyx_L75_bool_binop_done; + } + __pyx_t_8 = __Pyx_PyInt_NeObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 573, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_1 = __pyx_t_5; + __pyx_L75_bool_binop_done:; + if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":471 + /* "l0learn/interface.pyx":574 * * if penalty == "L0" and num_gamma != 1: * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") # <<<<<<<<<<<<<< * * for i, sub_lambda_grid in enumerate(lambda_grid): */ - __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 471, __pyx_L1_error) - __pyx_t_6 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_9, 0, ' ', 'd'); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 471, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_of_lengt, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 471, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 471, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 471, __pyx_L1_error) + __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 574, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_9, 0, ' ', 'd'); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_of_lengt, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(0, 574, __pyx_L1_error) - /* "l0learn/interface.pyx":470 + /* "l0learn/interface.pyx":573 * bad_lambda_grid = False * * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< @@ -9438,7 +10003,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":473 + /* "l0learn/interface.pyx":576 * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") * * for i, sub_lambda_grid in enumerate(lambda_grid): # <<<<<<<<<<<<<< @@ -9446,89 +10011,89 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p * if sub_lambda_grid[0] <= 0: */ __Pyx_INCREF(__pyx_int_0); - __pyx_t_6 = __pyx_int_0; + __pyx_t_8 = __pyx_int_0; if (likely(PyList_CheckExact(__pyx_v_lambda_grid)) || PyTuple_CheckExact(__pyx_v_lambda_grid)) { - __pyx_t_2 = __pyx_v_lambda_grid; __Pyx_INCREF(__pyx_t_2); __pyx_t_9 = 0; + __pyx_t_3 = __pyx_v_lambda_grid; __Pyx_INCREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_13 = NULL; } else { - __pyx_t_9 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_lambda_grid); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 473, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_13 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 473, __pyx_L1_error) + __pyx_t_9 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_lambda_grid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 576, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_13 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 576, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_13)) { - if (likely(PyList_CheckExact(__pyx_t_2))) { - if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_2)) break; + if (likely(PyList_CheckExact(__pyx_t_3))) { + if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_8 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_9); __Pyx_INCREF(__pyx_t_8); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 473, __pyx_L1_error) + __pyx_t_2 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_9); __Pyx_INCREF(__pyx_t_2); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 576, __pyx_L1_error) #else - __pyx_t_8 = PySequence_ITEM(__pyx_t_2, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 473, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); + __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 576, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); #endif } else { - if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_2)) break; + if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_9); __Pyx_INCREF(__pyx_t_8); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 473, __pyx_L1_error) + __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_9); __Pyx_INCREF(__pyx_t_2); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 576, __pyx_L1_error) #else - __pyx_t_8 = PySequence_ITEM(__pyx_t_2, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 473, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); + __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 576, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); #endif } } else { - __pyx_t_8 = __pyx_t_13(__pyx_t_2); - if (unlikely(!__pyx_t_8)) { + __pyx_t_2 = __pyx_t_13(__pyx_t_3); + if (unlikely(!__pyx_t_2)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(0, 473, __pyx_L1_error) + else __PYX_ERR(0, 576, __pyx_L1_error) } break; } - __Pyx_GOTREF(__pyx_t_8); + __Pyx_GOTREF(__pyx_t_2); } - __Pyx_XDECREF_SET(__pyx_v_sub_lambda_grid, __pyx_t_8); - __pyx_t_8 = 0; - __Pyx_INCREF(__pyx_t_6); - __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_6); - __pyx_t_8 = __Pyx_PyInt_AddObjC(__pyx_t_6, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 473, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_6); - __pyx_t_6 = __pyx_t_8; - __pyx_t_8 = 0; + __Pyx_XDECREF_SET(__pyx_v_sub_lambda_grid, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_t_8); + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_8); + __pyx_t_2 = __Pyx_PyInt_AddObjC(__pyx_t_8, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 576, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_8); + __pyx_t_8 = __pyx_t_2; + __pyx_t_2 = 0; - /* "l0learn/interface.pyx":474 + /* "l0learn/interface.pyx":577 * * for i, sub_lambda_grid in enumerate(lambda_grid): * current = float("inf") # <<<<<<<<<<<<<< * if sub_lambda_grid[0] <= 0: * raise ValueError(f"Expected all values of lambda_grid to be positive, " */ - __pyx_t_14 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 474, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 577, __pyx_L1_error) __pyx_v_current = __pyx_t_14; - /* "l0learn/interface.pyx":475 + /* "l0learn/interface.pyx":578 * for i, sub_lambda_grid in enumerate(lambda_grid): * current = float("inf") * if sub_lambda_grid[0] <= 0: # <<<<<<<<<<<<<< * raise ValueError(f"Expected all values of lambda_grid to be positive, " * f"but got lambda_grid[{i}] containing a negative value") */ - __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_sub_lambda_grid, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 475, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = PyObject_RichCompare(__pyx_t_8, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 475, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 475, __pyx_L1_error) + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_sub_lambda_grid, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 578, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = PyObject_RichCompare(__pyx_t_2, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 578, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 578, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(__pyx_t_4)) { + if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":476 + /* "l0learn/interface.pyx":579 * current = float("inf") * if sub_lambda_grid[0] <= 0: * raise ValueError(f"Expected all values of lambda_grid to be positive, " # <<<<<<<<<<<<<< * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): */ - __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 476, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 579, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_15 = 0; __pyx_t_10 = 127; @@ -9537,43 +10102,43 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_GIVEREF(__pyx_kp_u_Expected_all_values_of_lambda_gr); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_Expected_all_values_of_lambda_gr); - /* "l0learn/interface.pyx":477 + /* "l0learn/interface.pyx":580 * if sub_lambda_grid[0] <= 0: * raise ValueError(f"Expected all values of lambda_grid to be positive, " * f"but got lambda_grid[{i}] containing a negative value") # <<<<<<<<<<<<<< * if any(np.diff(sub_lambda_grid) >= 0): * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " */ - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 477, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; - __pyx_t_15 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); - __Pyx_GIVEREF(__pyx_t_8); - PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_8); - __pyx_t_8 = 0; + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 580, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_15 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_2); + __pyx_t_2 = 0; __Pyx_INCREF(__pyx_kp_u_containing_a_negative_value); __pyx_t_15 += 29; __Pyx_GIVEREF(__pyx_kp_u_containing_a_negative_value); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_containing_a_negative_value); - /* "l0learn/interface.pyx":476 + /* "l0learn/interface.pyx":579 * current = float("inf") * if sub_lambda_grid[0] <= 0: * raise ValueError(f"Expected all values of lambda_grid to be positive, " # <<<<<<<<<<<<<< * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): */ - __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 476, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 476, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 579, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 476, __pyx_L1_error) + __PYX_ERR(0, 579, __pyx_L1_error) - /* "l0learn/interface.pyx":475 + /* "l0learn/interface.pyx":578 * for i, sub_lambda_grid in enumerate(lambda_grid): * current = float("inf") * if sub_lambda_grid[0] <= 0: # <<<<<<<<<<<<<< @@ -9582,50 +10147,50 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":478 + /* "l0learn/interface.pyx":581 * raise ValueError(f"Expected all values of lambda_grid to be positive, " * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): # <<<<<<<<<<<<<< * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " * f"but got lambda_grid[{i}] containing an increasing value.") */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 478, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_diff); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 478, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 581, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_diff); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 581, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = NULL; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_16))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_16); - if (likely(__pyx_t_8)) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_16); + if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_16); - __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_16, function); } } - __pyx_t_7 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_16, __pyx_t_8, __pyx_v_sub_lambda_grid) : __Pyx_PyObject_CallOneArg(__pyx_t_16, __pyx_v_sub_lambda_grid); - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 478, __pyx_L1_error) + __pyx_t_7 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_16, __pyx_t_2, __pyx_v_sub_lambda_grid) : __Pyx_PyObject_CallOneArg(__pyx_t_16, __pyx_v_sub_lambda_grid); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 581, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_16 = PyObject_RichCompare(__pyx_t_7, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_16); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 478, __pyx_L1_error) + __pyx_t_16 = PyObject_RichCompare(__pyx_t_7, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_16); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 581, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_16); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 478, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_16); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 581, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 478, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 581, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(__pyx_t_4)) { + if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":479 + /* "l0learn/interface.pyx":582 * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " # <<<<<<<<<<<<<< * f"but got lambda_grid[{i}] containing an increasing value.") * */ - __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 479, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 582, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_15 = 0; __pyx_t_10 = 127; @@ -9634,14 +10199,14 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_GIVEREF(__pyx_kp_u_Expected_each_element_of_lambda); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_Expected_each_element_of_lambda); - /* "l0learn/interface.pyx":480 + /* "l0learn/interface.pyx":583 * if any(np.diff(sub_lambda_grid) >= 0): * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " * f"but got lambda_grid[{i}] containing an increasing value.") # <<<<<<<<<<<<<< * * n, p = X.shape */ - __pyx_t_16 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 480, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 583, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_16) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_16) : __pyx_t_10; __pyx_t_15 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_16); @@ -9653,24 +10218,24 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_GIVEREF(__pyx_kp_u_containing_an_increasing_value); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_containing_an_increasing_value); - /* "l0learn/interface.pyx":479 + /* "l0learn/interface.pyx":582 * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " # <<<<<<<<<<<<<< * f"but got lambda_grid[{i}] containing an increasing value.") * */ - __pyx_t_16 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 479, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 582, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_16); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 479, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_16); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 582, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 479, __pyx_L1_error) + __PYX_ERR(0, 582, __pyx_L1_error) - /* "l0learn/interface.pyx":478 + /* "l0learn/interface.pyx":581 * raise ValueError(f"Expected all values of lambda_grid to be positive, " * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): # <<<<<<<<<<<<<< @@ -9679,7 +10244,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":473 + /* "l0learn/interface.pyx":576 * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") * * for i, sub_lambda_grid in enumerate(lambda_grid): # <<<<<<<<<<<<<< @@ -9687,72 +10252,72 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p * if sub_lambda_grid[0] <= 0: */ } - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } - __pyx_L58:; + __pyx_L62:; - /* "l0learn/interface.pyx":482 + /* "l0learn/interface.pyx":585 * f"but got lambda_grid[{i}] containing an increasing value.") * * n, p = X.shape # <<<<<<<<<<<<<< * with_bounds = False * */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 482, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if ((likely(PyTuple_CheckExact(__pyx_t_6))) || (PyList_CheckExact(__pyx_t_6))) { - PyObject* sequence = __pyx_t_6; + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 585, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if ((likely(PyTuple_CheckExact(__pyx_t_8))) || (PyList_CheckExact(__pyx_t_8))) { + PyObject* sequence = __pyx_t_8; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 482, __pyx_L1_error) + __PYX_ERR(0, 585, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_7 = PyTuple_GET_ITEM(sequence, 1); } else { - __pyx_t_2 = PyList_GET_ITEM(sequence, 0); + __pyx_t_3 = PyList_GET_ITEM(sequence, 0); __pyx_t_7 = PyList_GET_ITEM(sequence, 1); } - __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_7); #else - __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 482, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 482, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 585, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 585, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); #endif - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { Py_ssize_t index = -1; - __pyx_t_16 = PyObject_GetIter(__pyx_t_6); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 482, __pyx_L1_error) + __pyx_t_16 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 585, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_11 = Py_TYPE(__pyx_t_16)->tp_iternext; - index = 0; __pyx_t_2 = __pyx_t_11(__pyx_t_16); if (unlikely(!__pyx_t_2)) goto __pyx_L77_unpacking_failed; - __Pyx_GOTREF(__pyx_t_2); - index = 1; __pyx_t_7 = __pyx_t_11(__pyx_t_16); if (unlikely(!__pyx_t_7)) goto __pyx_L77_unpacking_failed; + index = 0; __pyx_t_3 = __pyx_t_11(__pyx_t_16); if (unlikely(!__pyx_t_3)) goto __pyx_L81_unpacking_failed; + __Pyx_GOTREF(__pyx_t_3); + index = 1; __pyx_t_7 = __pyx_t_11(__pyx_t_16); if (unlikely(!__pyx_t_7)) goto __pyx_L81_unpacking_failed; __Pyx_GOTREF(__pyx_t_7); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_16), 2) < 0) __PYX_ERR(0, 482, __pyx_L1_error) + if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_16), 2) < 0) __PYX_ERR(0, 585, __pyx_L1_error) __pyx_t_11 = NULL; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - goto __pyx_L78_unpacking_done; - __pyx_L77_unpacking_failed:; + goto __pyx_L82_unpacking_done; + __pyx_L81_unpacking_failed:; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_11 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 482, __pyx_L1_error) - __pyx_L78_unpacking_done:; + __PYX_ERR(0, 585, __pyx_L1_error) + __pyx_L82_unpacking_done:; } - __Pyx_DECREF_SET(__pyx_v_n, __pyx_t_2); - __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_n, __pyx_t_3); + __pyx_t_3 = 0; __Pyx_DECREF_SET(__pyx_v_p, __pyx_t_7); __pyx_t_7 = 0; - /* "l0learn/interface.pyx":483 + /* "l0learn/interface.pyx":586 * * n, p = X.shape * with_bounds = False # <<<<<<<<<<<<<< @@ -9761,49 +10326,49 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ __pyx_v_with_bounds = 0; - /* "l0learn/interface.pyx":485 + /* "l0learn/interface.pyx":588 * with_bounds = False * * if isinstance(lows, float): # <<<<<<<<<<<<<< * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") */ - __pyx_t_4 = PyFloat_Check(__pyx_v_lows); - __pyx_t_3 = (__pyx_t_4 != 0); - if (__pyx_t_3) { + __pyx_t_1 = PyFloat_Check(__pyx_v_lows); + __pyx_t_5 = (__pyx_t_1 != 0); + if (__pyx_t_5) { - /* "l0learn/interface.pyx":486 + /* "l0learn/interface.pyx":589 * * if isinstance(lows, float): * if lows > 0: # <<<<<<<<<<<<<< * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") * elif lows > -float('inf'): */ - __pyx_t_6 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_GT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 486, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 486, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(__pyx_t_3)) { + __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_GT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 589, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 589, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":487 + /* "l0learn/interface.pyx":590 * if isinstance(lows, float): * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") # <<<<<<<<<<<<<< * elif lows > -float('inf'): * with_bounds = True */ - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 487, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lows_to_be_a_non_positi, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 487, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 590, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lows_to_be_a_non_positi, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 590, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 487, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 590, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 487, __pyx_L1_error) + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(0, 590, __pyx_L1_error) - /* "l0learn/interface.pyx":486 + /* "l0learn/interface.pyx":589 * * if isinstance(lows, float): * if lows > 0: # <<<<<<<<<<<<<< @@ -9812,23 +10377,23 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":488 + /* "l0learn/interface.pyx":591 * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") * elif lows > -float('inf'): # <<<<<<<<<<<<<< * with_bounds = True * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): */ - __pyx_t_14 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 488, __pyx_L1_error) - __pyx_t_6 = PyFloat_FromDouble((-__pyx_t_14)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 488, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = PyObject_RichCompare(__pyx_v_lows, __pyx_t_6, Py_GT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 488, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 488, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 591, __pyx_L1_error) + __pyx_t_8 = PyFloat_FromDouble((-__pyx_t_14)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 591, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = PyObject_RichCompare(__pyx_v_lows, __pyx_t_8, Py_GT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 591, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 591, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (__pyx_t_3) { + if (__pyx_t_5) { - /* "l0learn/interface.pyx":489 + /* "l0learn/interface.pyx":592 * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") * elif lows > -float('inf'): * with_bounds = True # <<<<<<<<<<<<<< @@ -9837,7 +10402,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ __pyx_v_with_bounds = 1; - /* "l0learn/interface.pyx":488 + /* "l0learn/interface.pyx":591 * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") * elif lows > -float('inf'): # <<<<<<<<<<<<<< @@ -9846,65 +10411,71 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":485 + /* "l0learn/interface.pyx":588 * with_bounds = False * * if isinstance(lows, float): # <<<<<<<<<<<<<< * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") */ - goto __pyx_L79; + goto __pyx_L83; } - /* "l0learn/interface.pyx":490 + /* "l0learn/interface.pyx":593 * elif lows > -float('inf'): * with_bounds = True * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): # <<<<<<<<<<<<<< * with_bounds = True * else: */ - __pyx_t_4 = __Pyx_TypeCheck(__pyx_v_lows, __pyx_ptype_5numpy_ndarray); - __pyx_t_1 = (__pyx_t_4 != 0); - if (__pyx_t_1) { + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 593, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 593, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_1 = PyObject_IsInstance(__pyx_v_lows, __pyx_t_8); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 593, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_4 = (__pyx_t_1 != 0); + if (__pyx_t_4) { } else { - __pyx_t_3 = __pyx_t_1; - goto __pyx_L81_bool_binop_done; + __pyx_t_5 = __pyx_t_4; + goto __pyx_L85_bool_binop_done; } - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_lows, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 490, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_lows, __pyx_n_s_ndim); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 593, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = __Pyx_PyInt_EqObjC(__pyx_t_8, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 593, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = __Pyx_PyInt_EqObjC(__pyx_t_7, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 490, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 593, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 490, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (__pyx_t_1) { + if (__pyx_t_4) { } else { - __pyx_t_3 = __pyx_t_1; - goto __pyx_L81_bool_binop_done; + __pyx_t_5 = __pyx_t_4; + goto __pyx_L85_bool_binop_done; } - __pyx_t_9 = PyObject_Length(__pyx_v_lows); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 490, __pyx_L1_error) - __pyx_t_6 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 490, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = PyObject_RichCompare(__pyx_t_6, __pyx_v_p, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 490, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 490, __pyx_L1_error) + __pyx_t_9 = PyObject_Length(__pyx_v_lows); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 593, __pyx_L1_error) + __pyx_t_7 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 593, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = PyObject_RichCompare(__pyx_t_7, __pyx_v_p, Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 593, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (__pyx_t_1) { + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 593, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (__pyx_t_4) { } else { - __pyx_t_3 = __pyx_t_1; - goto __pyx_L81_bool_binop_done; + __pyx_t_5 = __pyx_t_4; + goto __pyx_L85_bool_binop_done; } - __pyx_t_7 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 490, __pyx_L1_error) - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_all, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 490, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 593, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_all, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 593, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 593, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 490, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_3 = __pyx_t_1; - __pyx_L81_bool_binop_done:; - if (likely(__pyx_t_3)) { + __pyx_t_5 = __pyx_t_4; + __pyx_L85_bool_binop_done:; + if (likely(__pyx_t_5)) { - /* "l0learn/interface.pyx":491 + /* "l0learn/interface.pyx":594 * with_bounds = True * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): * with_bounds = True # <<<<<<<<<<<<<< @@ -9913,17 +10484,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ __pyx_v_with_bounds = 1; - /* "l0learn/interface.pyx":490 + /* "l0learn/interface.pyx":593 * elif lows > -float('inf'): * with_bounds = True * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): # <<<<<<<<<<<<<< * with_bounds = True * else: */ - goto __pyx_L79; + goto __pyx_L83; } - /* "l0learn/interface.pyx":493 + /* "l0learn/interface.pyx":596 * with_bounds = True * else: * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " # <<<<<<<<<<<<<< @@ -9931,103 +10502,103 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p * */ /*else*/ { - __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 493, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 596, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_expected_lows_to_be_a_non_positi_2); __pyx_t_9 += 72; __Pyx_GIVEREF(__pyx_kp_u_expected_lows_to_be_a_non_positi_2); - PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_lows_to_be_a_non_positi_2); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 493, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_7); - __pyx_t_7 = 0; + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_lows_to_be_a_non_positi_2); + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 596, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_8); + __pyx_t_8 = 0; __Pyx_INCREF(__pyx_kp_u_of_non_positives_floats_but_got); __pyx_t_9 += 34; __Pyx_GIVEREF(__pyx_kp_u_of_non_positives_floats_but_got); - PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u_of_non_positives_floats_but_got); + PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_of_non_positives_floats_but_got); - /* "l0learn/interface.pyx":494 + /* "l0learn/interface.pyx":597 * else: * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " * f"floats, but got {lows}") # <<<<<<<<<<<<<< * * if isinstance(highs, float): */ - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 494, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_7); - __pyx_t_7 = 0; + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 597, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_8); + __pyx_t_8 = 0; - /* "l0learn/interface.pyx":493 + /* "l0learn/interface.pyx":596 * with_bounds = True * else: * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " # <<<<<<<<<<<<<< * f"floats, but got {lows}") * */ - __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_6, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 493, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 596, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 596, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 493, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 493, __pyx_L1_error) + __PYX_ERR(0, 596, __pyx_L1_error) } - __pyx_L79:; + __pyx_L83:; - /* "l0learn/interface.pyx":496 + /* "l0learn/interface.pyx":599 * f"floats, but got {lows}") * * if isinstance(highs, float): # <<<<<<<<<<<<<< * if highs < 0: * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") */ - __pyx_t_3 = PyFloat_Check(__pyx_v_highs); - __pyx_t_1 = (__pyx_t_3 != 0); - if (__pyx_t_1) { + __pyx_t_5 = PyFloat_Check(__pyx_v_highs); + __pyx_t_4 = (__pyx_t_5 != 0); + if (__pyx_t_4) { - /* "l0learn/interface.pyx":497 + /* "l0learn/interface.pyx":600 * * if isinstance(highs, float): * if highs < 0: # <<<<<<<<<<<<<< * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") * if highs < float('inf'): */ - __pyx_t_6 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 497, __pyx_L1_error) - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 497, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(__pyx_t_1)) { + __pyx_t_7 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 600, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 600, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":498 + /* "l0learn/interface.pyx":601 * if isinstance(highs, float): * if highs < 0: * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") # <<<<<<<<<<<<<< * if highs < float('inf'): * with_bounds = True */ - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 498, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_highs_to_be_a_non_negat, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 498, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 601, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 498, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_highs_to_be_a_non_negat, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 601, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 601, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_6, 0, 0, 0); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(0, 498, __pyx_L1_error) + __PYX_ERR(0, 601, __pyx_L1_error) - /* "l0learn/interface.pyx":497 + /* "l0learn/interface.pyx":600 * * if isinstance(highs, float): * if highs < 0: # <<<<<<<<<<<<<< @@ -10036,22 +10607,22 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":499 + /* "l0learn/interface.pyx":602 * if highs < 0: * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") * if highs < float('inf'): # <<<<<<<<<<<<<< * with_bounds = True * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): */ - __pyx_t_6 = __Pyx_PyNumber_Float(__pyx_n_u_inf); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 499, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = PyObject_RichCompare(__pyx_v_highs, __pyx_t_6, Py_LT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 499, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 499, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyNumber_Float(__pyx_n_u_inf); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 602, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = PyObject_RichCompare(__pyx_v_highs, __pyx_t_7, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 602, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (__pyx_t_1) { + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 602, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (__pyx_t_4) { - /* "l0learn/interface.pyx":500 + /* "l0learn/interface.pyx":603 * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") * if highs < float('inf'): * with_bounds = True # <<<<<<<<<<<<<< @@ -10060,7 +10631,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ __pyx_v_with_bounds = 1; - /* "l0learn/interface.pyx":499 + /* "l0learn/interface.pyx":602 * if highs < 0: * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") * if highs < float('inf'): # <<<<<<<<<<<<<< @@ -10069,62 +10640,68 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":496 + /* "l0learn/interface.pyx":599 * f"floats, but got {lows}") * * if isinstance(highs, float): # <<<<<<<<<<<<<< * if highs < 0: * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") */ - goto __pyx_L85; + goto __pyx_L89; } - /* "l0learn/interface.pyx":501 + /* "l0learn/interface.pyx":604 * if highs < float('inf'): * with_bounds = True * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): # <<<<<<<<<<<<<< * with_bounds = True * else: */ - __pyx_t_3 = __Pyx_TypeCheck(__pyx_v_highs, __pyx_ptype_5numpy_ndarray); - __pyx_t_4 = (__pyx_t_3 != 0); - if (__pyx_t_4) { + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 604, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 604, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_5 = PyObject_IsInstance(__pyx_v_highs, __pyx_t_7); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 604, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_1 = (__pyx_t_5 != 0); + if (__pyx_t_1) { } else { - __pyx_t_1 = __pyx_t_4; - goto __pyx_L88_bool_binop_done; + __pyx_t_4 = __pyx_t_1; + goto __pyx_L92_bool_binop_done; } - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_highs, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 501, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_highs, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 604, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = __Pyx_PyInt_EqObjC(__pyx_t_7, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 501, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyInt_EqObjC(__pyx_t_7, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 604, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 501, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (__pyx_t_4) { + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 604, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (__pyx_t_1) { } else { - __pyx_t_1 = __pyx_t_4; - goto __pyx_L88_bool_binop_done; + __pyx_t_4 = __pyx_t_1; + goto __pyx_L92_bool_binop_done; } - __pyx_t_9 = PyObject_Length(__pyx_v_highs); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 501, __pyx_L1_error) - __pyx_t_6 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 501, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = PyObject_RichCompare(__pyx_t_6, __pyx_v_p, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 501, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 501, __pyx_L1_error) + __pyx_t_9 = PyObject_Length(__pyx_v_highs); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 604, __pyx_L1_error) + __pyx_t_8 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 604, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = PyObject_RichCompare(__pyx_t_8, __pyx_v_p, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 604, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 604, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (__pyx_t_4) { + if (__pyx_t_1) { } else { - __pyx_t_1 = __pyx_t_4; - goto __pyx_L88_bool_binop_done; + __pyx_t_4 = __pyx_t_1; + goto __pyx_L92_bool_binop_done; } - __pyx_t_7 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 501, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 501, __pyx_L1_error) + __pyx_t_7 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 604, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 604, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_1 = __pyx_t_4; - __pyx_L88_bool_binop_done:; - if (likely(__pyx_t_1)) { + __pyx_t_4 = __pyx_t_1; + __pyx_L92_bool_binop_done:; + if (likely(__pyx_t_4)) { - /* "l0learn/interface.pyx":502 + /* "l0learn/interface.pyx":605 * with_bounds = True * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): * with_bounds = True # <<<<<<<<<<<<<< @@ -10133,17 +10710,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ __pyx_v_with_bounds = 1; - /* "l0learn/interface.pyx":501 + /* "l0learn/interface.pyx":604 * if highs < float('inf'): * with_bounds = True * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): # <<<<<<<<<<<<<< * with_bounds = True * else: */ - goto __pyx_L85; + goto __pyx_L89; } - /* "l0learn/interface.pyx":504 + /* "l0learn/interface.pyx":607 * with_bounds = True * else: * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " # <<<<<<<<<<<<<< @@ -10151,7 +10728,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p * */ /*else*/ { - __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 504, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 607, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -10159,107 +10736,107 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_9 += 73; __Pyx_GIVEREF(__pyx_kp_u_expected_highs_to_be_a_non_negat_2); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_highs_to_be_a_non_negat_2); - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 504, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_6); - __pyx_t_6 = 0; + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 607, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_8); + __pyx_t_8 = 0; __Pyx_INCREF(__pyx_kp_u_of_non_negative_floats_but_got); __pyx_t_9 += 33; __Pyx_GIVEREF(__pyx_kp_u_of_non_negative_floats_but_got); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_of_non_negative_floats_but_got); - /* "l0learn/interface.pyx":505 + /* "l0learn/interface.pyx":608 * else: * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " * f"non-negative floats, but got {highs}") # <<<<<<<<<<<<<< * * if with_bounds: */ - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 505, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_6); - __pyx_t_6 = 0; + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 608, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_8); + __pyx_t_8 = 0; - /* "l0learn/interface.pyx":504 + /* "l0learn/interface.pyx":607 * with_bounds = True * else: * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " # <<<<<<<<<<<<<< * f"non-negative floats, but got {highs}") * */ - __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 504, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 607, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 504, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 607, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 504, __pyx_L1_error) + __PYX_ERR(0, 607, __pyx_L1_error) } - __pyx_L85:; + __pyx_L89:; - /* "l0learn/interface.pyx":507 + /* "l0learn/interface.pyx":610 * f"non-negative floats, but got {highs}") * * if with_bounds: # <<<<<<<<<<<<<< * if isinstance(lows, float): * lows = np.ones(p) * lows */ - __pyx_t_1 = (__pyx_v_with_bounds != 0); - if (__pyx_t_1) { + __pyx_t_4 = (__pyx_v_with_bounds != 0); + if (__pyx_t_4) { - /* "l0learn/interface.pyx":508 + /* "l0learn/interface.pyx":611 * * if with_bounds: * if isinstance(lows, float): # <<<<<<<<<<<<<< * lows = np.ones(p) * lows * if isinstance(highs, float): */ - __pyx_t_1 = PyFloat_Check(__pyx_v_lows); - __pyx_t_4 = (__pyx_t_1 != 0); - if (__pyx_t_4) { + __pyx_t_4 = PyFloat_Check(__pyx_v_lows); + __pyx_t_1 = (__pyx_t_4 != 0); + if (__pyx_t_1) { - /* "l0learn/interface.pyx":509 + /* "l0learn/interface.pyx":612 * if with_bounds: * if isinstance(lows, float): * lows = np.ones(p) * lows # <<<<<<<<<<<<<< * if isinstance(highs, float): * highs = np.ones(p) * highs */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 509, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_ones); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 509, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_6)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_6); + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 612, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_ones); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 612, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); + __Pyx_DECREF_SET(__pyx_t_3, function); } } - __pyx_t_7 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_6, __pyx_v_p) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_p); - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 509, __pyx_L1_error) + __pyx_t_7 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_8, __pyx_v_p) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_p); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 612, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = PyNumber_Multiply(__pyx_t_7, __pyx_v_lows); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 509, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyNumber_Multiply(__pyx_t_7, __pyx_v_lows); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 612, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_2); - __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_3); + __pyx_t_3 = 0; - /* "l0learn/interface.pyx":508 + /* "l0learn/interface.pyx":611 * * if with_bounds: * if isinstance(lows, float): # <<<<<<<<<<<<<< @@ -10268,51 +10845,51 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":510 + /* "l0learn/interface.pyx":613 * if isinstance(lows, float): * lows = np.ones(p) * lows * if isinstance(highs, float): # <<<<<<<<<<<<<< * highs = np.ones(p) * highs * */ - __pyx_t_4 = PyFloat_Check(__pyx_v_highs); - __pyx_t_1 = (__pyx_t_4 != 0); - if (__pyx_t_1) { + __pyx_t_1 = PyFloat_Check(__pyx_v_highs); + __pyx_t_4 = (__pyx_t_1 != 0); + if (__pyx_t_4) { - /* "l0learn/interface.pyx":511 + /* "l0learn/interface.pyx":614 * lows = np.ones(p) * lows * if isinstance(highs, float): * highs = np.ones(p) * highs # <<<<<<<<<<<<<< * * if any(lows >= highs): */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 511, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 614, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ones); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 511, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ones); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_7)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_6, function); + __Pyx_DECREF_SET(__pyx_t_8, function); } } - __pyx_t_2 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_v_p) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_p); + __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_7, __pyx_v_p) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_p); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 511, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyNumber_Multiply(__pyx_t_2, __pyx_v_highs); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 511, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_6); - __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyNumber_Multiply(__pyx_t_3, __pyx_v_highs); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_8); + __pyx_t_8 = 0; - /* "l0learn/interface.pyx":510 + /* "l0learn/interface.pyx":613 * if isinstance(lows, float): * lows = np.ones(p) * lows * if isinstance(highs, float): # <<<<<<<<<<<<<< @@ -10321,34 +10898,34 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":513 + /* "l0learn/interface.pyx":616 * highs = np.ones(p) * highs * * if any(lows >= highs): # <<<<<<<<<<<<<< * bad_bounds = np.argwhere(lows >= highs) * raise ValueError(f"expected to be high to be elementwise greater than lows, " */ - __pyx_t_6 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 513, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 513, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 513, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(__pyx_t_1)) { + __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 616, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 616, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":514 + /* "l0learn/interface.pyx":617 * * if any(lows >= highs): * bad_bounds = np.argwhere(lows >= highs) # <<<<<<<<<<<<<< * raise ValueError(f"expected to be high to be elementwise greater than lows, " * f"but got indices {bad_bounds[0]} where that is not the case ") */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 514, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_argwhere); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 514, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 617, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_argwhere); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 617, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 514, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 617, __pyx_L1_error) __pyx_t_16 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_7); @@ -10359,71 +10936,71 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_DECREF_SET(__pyx_t_7, function); } } - __pyx_t_2 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_16, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); + __pyx_t_3 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_16, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 514, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 617, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_v_bad_bounds = __pyx_t_2; - __pyx_t_2 = 0; + __pyx_v_bad_bounds = __pyx_t_3; + __pyx_t_3 = 0; - /* "l0learn/interface.pyx":515 + /* "l0learn/interface.pyx":618 * if any(lows >= highs): * bad_bounds = np.argwhere(lows >= highs) * raise ValueError(f"expected to be high to be elementwise greater than lows, " # <<<<<<<<<<<<<< * f"but got indices {bad_bounds[0]} where that is not the case ") * else: */ - __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 515, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_expected_to_be_high_to_be_elemen); __pyx_t_9 += 73; __Pyx_GIVEREF(__pyx_kp_u_expected_to_be_high_to_be_elemen); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_u_expected_to_be_high_to_be_elemen); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_to_be_high_to_be_elemen); - /* "l0learn/interface.pyx":516 + /* "l0learn/interface.pyx":619 * bad_bounds = np.argwhere(lows >= highs) * raise ValueError(f"expected to be high to be elementwise greater than lows, " * f"but got indices {bad_bounds[0]} where that is not the case ") # <<<<<<<<<<<<<< * else: * lows = np.array([0.]) */ - __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_bad_bounds, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 516, __pyx_L1_error) + __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_bad_bounds, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 619, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 516, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 619, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); - __Pyx_GIVEREF(__pyx_t_6); - PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_6); - __pyx_t_6 = 0; + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_8); + __pyx_t_8 = 0; __Pyx_INCREF(__pyx_kp_u_where_that_is_not_the_case); __pyx_t_9 += 28; __Pyx_GIVEREF(__pyx_kp_u_where_that_is_not_the_case); - PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_kp_u_where_that_is_not_the_case); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_where_that_is_not_the_case); - /* "l0learn/interface.pyx":515 + /* "l0learn/interface.pyx":618 * if any(lows >= highs): * bad_bounds = np.argwhere(lows >= highs) * raise ValueError(f"expected to be high to be elementwise greater than lows, " # <<<<<<<<<<<<<< * f"but got indices {bad_bounds[0]} where that is not the case ") * else: */ - __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_2, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 515, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 515, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_Raise(__pyx_t_2, 0, 0, 0); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 515, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 618, __pyx_L1_error) - /* "l0learn/interface.pyx":513 + /* "l0learn/interface.pyx":616 * highs = np.ones(p) * highs * * if any(lows >= highs): # <<<<<<<<<<<<<< @@ -10432,17 +11009,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":507 + /* "l0learn/interface.pyx":610 * f"non-negative floats, but got {highs}") * * if with_bounds: # <<<<<<<<<<<<<< * if isinstance(lows, float): * lows = np.ones(p) * lows */ - goto __pyx_L92; + goto __pyx_L96; } - /* "l0learn/interface.pyx":518 + /* "l0learn/interface.pyx":621 * f"but got indices {bad_bounds[0]} where that is not the case ") * else: * lows = np.array([0.]) # <<<<<<<<<<<<<< @@ -10450,16 +11027,16 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p * */ /*else*/ { - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 518, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_array); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 518, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 621, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_array); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 621, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyList_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 518, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyList_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 621, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __Pyx_INCREF(__pyx_float_0_); __Pyx_GIVEREF(__pyx_float_0_); - PyList_SET_ITEM(__pyx_t_6, 0, __pyx_float_0_); + PyList_SET_ITEM(__pyx_t_8, 0, __pyx_float_0_); __pyx_t_16 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_7); @@ -10470,54 +11047,54 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_DECREF_SET(__pyx_t_7, function); } } - __pyx_t_2 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_16, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); + __pyx_t_3 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_16, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 518, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 621, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_2); - __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_3); + __pyx_t_3 = 0; - /* "l0learn/interface.pyx":519 + /* "l0learn/interface.pyx":622 * else: * lows = np.array([0.]) * highs = np.array(([0.])) # <<<<<<<<<<<<<< * * cdef vector[vector[double]] c_lambda_grid */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 519, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 622, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_array); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 519, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_array); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 622, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = PyList_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 519, __pyx_L1_error) + __pyx_t_7 = PyList_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 622, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_INCREF(__pyx_float_0_); __Pyx_GIVEREF(__pyx_float_0_); PyList_SET_ITEM(__pyx_t_7, 0, __pyx_float_0_); __pyx_t_16 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { - __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_6); + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_16)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_16); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_6, function); + __Pyx_DECREF_SET(__pyx_t_8, function); } } - __pyx_t_2 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_16, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); + __pyx_t_3 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_16, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 519, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_2); - __pyx_t_2 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 622, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_3); + __pyx_t_3 = 0; } - __pyx_L92:; + __pyx_L96:; - /* "l0learn/interface.pyx":522 + /* "l0learn/interface.pyx":625 * * cdef vector[vector[double]] c_lambda_grid * try: # <<<<<<<<<<<<<< @@ -10533,17 +11110,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_XGOTREF(__pyx_t_19); /*try:*/ { - /* "l0learn/interface.pyx":523 + /* "l0learn/interface.pyx":626 * cdef vector[vector[double]] c_lambda_grid * try: * c_lambda_grid = lambda_grid # <<<<<<<<<<<<<< * except TypeError: * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") */ - __pyx_t_20 = __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_lambda_grid); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 523, __pyx_L96_error) + __pyx_t_20 = __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_lambda_grid); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 626, __pyx_L100_error) __pyx_v_c_lambda_grid = __pyx_t_20; - /* "l0learn/interface.pyx":522 + /* "l0learn/interface.pyx":625 * * cdef vector[vector[double]] c_lambda_grid * try: # <<<<<<<<<<<<<< @@ -10554,15 +11131,15 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; - goto __pyx_L101_try_end; - __pyx_L96_error:; + goto __pyx_L105_try_end; + __pyx_L100_error:; __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "l0learn/interface.pyx":524 + /* "l0learn/interface.pyx":627 * try: * c_lambda_grid = lambda_grid * except TypeError: # <<<<<<<<<<<<<< @@ -10572,34 +11149,34 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_21 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); if (__pyx_t_21) { __Pyx_AddTraceback("l0learn.interface.cvfit", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(0, 524, __pyx_L98_except_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_t_6); + if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_8, &__pyx_t_7) < 0) __PYX_ERR(0, 627, __pyx_L102_except_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_t_8); __Pyx_GOTREF(__pyx_t_7); - /* "l0learn/interface.pyx":525 + /* "l0learn/interface.pyx":628 * c_lambda_grid = lambda_grid * except TypeError: * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") # <<<<<<<<<<<<<< * * cdef string c_loss = loss.encode('UTF-8') */ - __pyx_t_16 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 525, __pyx_L98_except_error) + __pyx_t_16 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 628, __pyx_L102_except_error) __Pyx_GOTREF(__pyx_t_16); - __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_be_a_lis, __pyx_t_16); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 525, __pyx_L98_except_error) - __Pyx_GOTREF(__pyx_t_8); + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_be_a_lis, __pyx_t_16); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 628, __pyx_L102_except_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_16 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 525, __pyx_L98_except_error) + __pyx_t_16 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 628, __pyx_L102_except_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_16, 0, 0, 0); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __PYX_ERR(0, 525, __pyx_L98_except_error) + __PYX_ERR(0, 628, __pyx_L102_except_error) } - goto __pyx_L98_except_error; - __pyx_L98_except_error:; + goto __pyx_L102_except_error; + __pyx_L102_except_error:; - /* "l0learn/interface.pyx":522 + /* "l0learn/interface.pyx":625 * * cdef vector[vector[double]] c_lambda_grid * try: # <<<<<<<<<<<<<< @@ -10611,10 +11188,10 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_18, __pyx_t_19); goto __pyx_L1_error; - __pyx_L101_try_end:; + __pyx_L105_try_end:; } - /* "l0learn/interface.pyx":527 + /* "l0learn/interface.pyx":630 * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") * * cdef string c_loss = loss.encode('UTF-8') # <<<<<<<<<<<<<< @@ -10623,15 +11200,15 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ if (unlikely(__pyx_v_loss == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 527, __pyx_L1_error) + __PYX_ERR(0, 630, __pyx_L1_error) } - __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_loss); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 527, __pyx_L1_error) + __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_loss); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 630, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 527, __pyx_L1_error) + __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 630, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_c_loss = __pyx_t_22; - /* "l0learn/interface.pyx":528 + /* "l0learn/interface.pyx":631 * * cdef string c_loss = loss.encode('UTF-8') * cdef string c_penalty = penalty.encode('UTF-8') # <<<<<<<<<<<<<< @@ -10640,478 +11217,527 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ if (unlikely(__pyx_v_penalty == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 528, __pyx_L1_error) + __PYX_ERR(0, 631, __pyx_L1_error) } - __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_penalty); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 528, __pyx_L1_error) + __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_penalty); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 631, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 528, __pyx_L1_error) + __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 631, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_c_penalty = __pyx_t_22; - /* "l0learn/interface.pyx":529 + /* "l0learn/interface.pyx":632 * cdef string c_loss = loss.encode('UTF-8') * cdef string c_penalty = penalty.encode('UTF-8') * cdef string c_algorithim = algorithm.encode('UTF-8') # <<<<<<<<<<<<<< * - * cdef cvfitmodel results + * cdef cvfitmodel c_results */ if (unlikely(__pyx_v_algorithm == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 529, __pyx_L1_error) + __PYX_ERR(0, 632, __pyx_L1_error) } - __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_algorithm); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 529, __pyx_L1_error) + __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_algorithm); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 632, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 529, __pyx_L1_error) + __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 632, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_c_algorithim = __pyx_t_22; - /* "l0learn/interface.pyx":532 + /* "l0learn/interface.pyx":635 * - * cdef cvfitmodel results + * cdef cvfitmodel c_results * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< - * results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), + * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), * y=numpy_to_dvec_d(y), */ - __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_X, __pyx_ptype_5numpy_ndarray); - __pyx_t_4 = (__pyx_t_1 != 0); - if (__pyx_t_4) { + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 635, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 635, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_4 = PyObject_IsInstance(__pyx_v_X, __pyx_t_8); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 635, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_1 = (__pyx_t_4 != 0); + if (__pyx_t_1) { - /* "l0learn/interface.pyx":533 - * cdef cvfitmodel results + /* "l0learn/interface.pyx":636 + * cdef cvfitmodel c_results * if isinstance(X, np.ndarray): - * results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< + * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< * y=numpy_to_dvec_d(y), * Loss=c_loss, */ - if (!(likely(((__pyx_v_X) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_X, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 533, __pyx_L1_error) + if (!(likely(((__pyx_v_X) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_X, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 636, __pyx_L1_error) + + /* "l0learn/interface.pyx":637 + * if isinstance(X, np.ndarray): + * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), + * y=numpy_to_dvec_d(y), # <<<<<<<<<<<<<< + * Loss=c_loss, + * Penalty=c_penalty, + */ + if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 637, __pyx_L1_error) - /* "l0learn/interface.pyx":538 + /* "l0learn/interface.pyx":641 * Penalty=c_penalty, * Algorithm=c_algorithim, * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< * G_ncols=num_lambda, * G_nrows=num_gamma, */ - __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 538, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 641, __pyx_L1_error) - /* "l0learn/interface.pyx":539 + /* "l0learn/interface.pyx":642 * Algorithm=c_algorithim, * NnzStopNum=max_support_size, * G_ncols=num_lambda, # <<<<<<<<<<<<<< * G_nrows=num_gamma, * Lambda2Max=gamma_max, */ - __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 539, __pyx_L1_error) + __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 642, __pyx_L1_error) - /* "l0learn/interface.pyx":540 + /* "l0learn/interface.pyx":643 * NnzStopNum=max_support_size, * G_ncols=num_lambda, * G_nrows=num_gamma, # <<<<<<<<<<<<<< * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, */ - __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 540, __pyx_L1_error) + __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 643, __pyx_L1_error) - /* "l0learn/interface.pyx":543 + /* "l0learn/interface.pyx":646 * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, * PartialSort=partial_sort, # <<<<<<<<<<<<<< * MaxIters=max_iter, * rtol=rtol, */ - __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 543, __pyx_L1_error) + __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 646, __pyx_L1_error) - /* "l0learn/interface.pyx":544 + /* "l0learn/interface.pyx":647 * Lambda2Min=gamma_min, * PartialSort=partial_sort, * MaxIters=max_iter, # <<<<<<<<<<<<<< * rtol=rtol, * atol=atol, */ - __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 544, __pyx_L1_error) + __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 647, __pyx_L1_error) - /* "l0learn/interface.pyx":547 + /* "l0learn/interface.pyx":650 * rtol=rtol, * atol=atol, * ActiveSet=active_set, # <<<<<<<<<<<<<< * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, */ - __pyx_t_28 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_28 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 547, __pyx_L1_error) + __pyx_t_28 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_28 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 650, __pyx_L1_error) - /* "l0learn/interface.pyx":548 + /* "l0learn/interface.pyx":651 * atol=atol, * ActiveSet=active_set, * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, */ - __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 548, __pyx_L1_error) + __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 651, __pyx_L1_error) - /* "l0learn/interface.pyx":549 + /* "l0learn/interface.pyx":652 * ActiveSet=active_set, * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, */ - __pyx_t_30 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_30 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 549, __pyx_L1_error) + __pyx_t_30 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_30 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 652, __pyx_L1_error) - /* "l0learn/interface.pyx":551 + /* "l0learn/interface.pyx":654 * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, # <<<<<<<<<<<<<< * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, */ - __pyx_t_31 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_31 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 551, __pyx_L1_error) + __pyx_t_31 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_31 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 654, __pyx_L1_error) - /* "l0learn/interface.pyx":554 + /* "l0learn/interface.pyx":657 * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, * nfolds=num_folds, # <<<<<<<<<<<<<< * seed=seed, * ExcludeFirstK=exclude_first_k, */ - __pyx_t_32 = __Pyx_PyInt_As_unsigned_int(__pyx_v_num_folds); if (unlikely((__pyx_t_32 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 554, __pyx_L1_error) + __pyx_t_32 = __Pyx_PyInt_As_unsigned_int(__pyx_v_num_folds); if (unlikely((__pyx_t_32 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 657, __pyx_L1_error) - /* "l0learn/interface.pyx":555 + /* "l0learn/interface.pyx":658 * Lambdas=c_lambda_grid, * nfolds=num_folds, * seed=seed, # <<<<<<<<<<<<<< * ExcludeFirstK=exclude_first_k, * Intercept=intercept, */ - __pyx_t_14 = __pyx_PyFloat_AsDouble(__pyx_v_seed); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 555, __pyx_L1_error) + __pyx_t_14 = __pyx_PyFloat_AsDouble(__pyx_v_seed); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 658, __pyx_L1_error) - /* "l0learn/interface.pyx":556 + /* "l0learn/interface.pyx":659 * nfolds=num_folds, * seed=seed, * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< * Intercept=intercept, * withBounds=with_bounds, */ - __pyx_t_33 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_33 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 556, __pyx_L1_error) + __pyx_t_33 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_33 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 659, __pyx_L1_error) - /* "l0learn/interface.pyx":557 + /* "l0learn/interface.pyx":660 * seed=seed, * ExcludeFirstK=exclude_first_k, * Intercept=intercept, # <<<<<<<<<<<<<< * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), */ - __pyx_t_34 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_34 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 557, __pyx_L1_error) + __pyx_t_34 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_34 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 660, __pyx_L1_error) - /* "l0learn/interface.pyx":559 + /* "l0learn/interface.pyx":662 * Intercept=intercept, * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< * Highs=numpy_to_dvec_d(highs)) * else: # isinstance(X, csc_matrix) */ - if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 559, __pyx_L1_error) + if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 662, __pyx_L1_error) - /* "l0learn/interface.pyx":560 + /* "l0learn/interface.pyx":663 * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< * else: # isinstance(X, csc_matrix) - * results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), + * c_results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), */ - if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 560, __pyx_L1_error) + if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 663, __pyx_L1_error) - /* "l0learn/interface.pyx":533 - * cdef cvfitmodel results + /* "l0learn/interface.pyx":636 + * cdef cvfitmodel c_results * if isinstance(X, np.ndarray): - * results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< + * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< * y=numpy_to_dvec_d(y), * Loss=c_loss, */ - __pyx_v_results = __pyx_f_7l0learn_9interface__L0LearnCV_dense(__pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_X)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_23, __pyx_t_24, __pyx_t_25, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_26, __pyx_t_27, __pyx_v_rtol, __pyx_v_atol, __pyx_t_28, __pyx_t_29, __pyx_t_30, __pyx_v_scale_down_factor, __pyx_t_31, (!(__pyx_v_auto_lambda != 0)), __pyx_v_c_lambda_grid, __pyx_t_32, __pyx_t_14, __pyx_t_33, __pyx_t_34, __pyx_v_with_bounds, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); + __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnCV_dense(__pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_X)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_23, __pyx_t_24, __pyx_t_25, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_26, __pyx_t_27, __pyx_v_rtol, __pyx_v_atol, __pyx_t_28, __pyx_t_29, __pyx_t_30, __pyx_v_scale_down_factor, __pyx_t_31, (!(__pyx_v_auto_lambda != 0)), __pyx_v_c_lambda_grid, __pyx_t_32, __pyx_t_14, __pyx_t_33, __pyx_t_34, __pyx_v_with_bounds, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); - /* "l0learn/interface.pyx":532 + /* "l0learn/interface.pyx":635 * - * cdef cvfitmodel results + * cdef cvfitmodel c_results * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< - * results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), + * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), * y=numpy_to_dvec_d(y), */ - goto __pyx_L104; + goto __pyx_L108; } - /* "l0learn/interface.pyx":562 + /* "l0learn/interface.pyx":665 * Highs=numpy_to_dvec_d(highs)) * else: # isinstance(X, csc_matrix) - * results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< + * c_results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< * y=numpy_to_dvec_d(y), * Loss=c_loss, */ /*else*/ { - /* "l0learn/interface.pyx":567 + /* "l0learn/interface.pyx":666 + * else: # isinstance(X, csc_matrix) + * c_results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), + * y=numpy_to_dvec_d(y), # <<<<<<<<<<<<<< + * Loss=c_loss, + * Penalty=c_penalty, + */ + if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 666, __pyx_L1_error) + + /* "l0learn/interface.pyx":670 * Penalty=c_penalty, * Algorithm=c_algorithim, * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< * G_ncols=num_lambda, * G_nrows=num_gamma, */ - __pyx_t_33 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_33 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 567, __pyx_L1_error) + __pyx_t_33 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_33 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 670, __pyx_L1_error) - /* "l0learn/interface.pyx":568 + /* "l0learn/interface.pyx":671 * Algorithm=c_algorithim, * NnzStopNum=max_support_size, * G_ncols=num_lambda, # <<<<<<<<<<<<<< * G_nrows=num_gamma, * Lambda2Max=gamma_max, */ - __pyx_t_31 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_31 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 568, __pyx_L1_error) + __pyx_t_31 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_31 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 671, __pyx_L1_error) - /* "l0learn/interface.pyx":569 + /* "l0learn/interface.pyx":672 * NnzStopNum=max_support_size, * G_ncols=num_lambda, * G_nrows=num_gamma, # <<<<<<<<<<<<<< * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, */ - __pyx_t_30 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_30 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 569, __pyx_L1_error) + __pyx_t_30 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_30 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 672, __pyx_L1_error) - /* "l0learn/interface.pyx":572 + /* "l0learn/interface.pyx":675 * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, * PartialSort=partial_sort, # <<<<<<<<<<<<<< * MaxIters=max_iter, * rtol=rtol, */ - __pyx_t_34 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_34 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 572, __pyx_L1_error) + __pyx_t_34 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_34 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 675, __pyx_L1_error) - /* "l0learn/interface.pyx":573 + /* "l0learn/interface.pyx":676 * Lambda2Min=gamma_min, * PartialSort=partial_sort, * MaxIters=max_iter, # <<<<<<<<<<<<<< * rtol=rtol, * atol=atol, */ - __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 573, __pyx_L1_error) + __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 676, __pyx_L1_error) - /* "l0learn/interface.pyx":576 + /* "l0learn/interface.pyx":679 * rtol=rtol, * atol=atol, * ActiveSet=active_set, # <<<<<<<<<<<<<< * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, */ - __pyx_t_28 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_28 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 576, __pyx_L1_error) + __pyx_t_28 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_28 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 679, __pyx_L1_error) - /* "l0learn/interface.pyx":577 + /* "l0learn/interface.pyx":680 * atol=atol, * ActiveSet=active_set, * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, */ - __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 577, __pyx_L1_error) + __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 680, __pyx_L1_error) - /* "l0learn/interface.pyx":578 + /* "l0learn/interface.pyx":681 * ActiveSet=active_set, * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, */ - __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 578, __pyx_L1_error) + __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 681, __pyx_L1_error) - /* "l0learn/interface.pyx":580 + /* "l0learn/interface.pyx":683 * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, # <<<<<<<<<<<<<< * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, */ - __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 580, __pyx_L1_error) + __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 683, __pyx_L1_error) - /* "l0learn/interface.pyx":583 + /* "l0learn/interface.pyx":686 * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, * nfolds=num_folds, # <<<<<<<<<<<<<< * seed=seed, * ExcludeFirstK=exclude_first_k, */ - __pyx_t_32 = __Pyx_PyInt_As_unsigned_int(__pyx_v_num_folds); if (unlikely((__pyx_t_32 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 583, __pyx_L1_error) + __pyx_t_32 = __Pyx_PyInt_As_unsigned_int(__pyx_v_num_folds); if (unlikely((__pyx_t_32 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 686, __pyx_L1_error) - /* "l0learn/interface.pyx":584 + /* "l0learn/interface.pyx":687 * Lambdas=c_lambda_grid, * nfolds=num_folds, * seed=seed, # <<<<<<<<<<<<<< * ExcludeFirstK=exclude_first_k, * Intercept=intercept, */ - __pyx_t_14 = __pyx_PyFloat_AsDouble(__pyx_v_seed); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 584, __pyx_L1_error) + __pyx_t_14 = __pyx_PyFloat_AsDouble(__pyx_v_seed); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 687, __pyx_L1_error) - /* "l0learn/interface.pyx":585 + /* "l0learn/interface.pyx":688 * nfolds=num_folds, * seed=seed, * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< * Intercept=intercept, * withBounds=with_bounds, */ - __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 585, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 688, __pyx_L1_error) - /* "l0learn/interface.pyx":586 + /* "l0learn/interface.pyx":689 * seed=seed, * ExcludeFirstK=exclude_first_k, * Intercept=intercept, # <<<<<<<<<<<<<< * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), */ - __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 586, __pyx_L1_error) + __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 689, __pyx_L1_error) - /* "l0learn/interface.pyx":588 + /* "l0learn/interface.pyx":691 * Intercept=intercept, * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< * Highs=numpy_to_dvec_d(highs)) * */ - if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 588, __pyx_L1_error) + if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 691, __pyx_L1_error) - /* "l0learn/interface.pyx":589 + /* "l0learn/interface.pyx":692 * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< * - * return {"NnzCount": results.NnzCount, + * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, */ - if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 589, __pyx_L1_error) + if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 692, __pyx_L1_error) - /* "l0learn/interface.pyx":562 + /* "l0learn/interface.pyx":665 * Highs=numpy_to_dvec_d(highs)) * else: # isinstance(X, csc_matrix) - * results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< + * c_results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< * y=numpy_to_dvec_d(y), * Loss=c_loss, */ - __pyx_v_results = __pyx_f_7l0learn_9interface__L0LearnCV_sparse(__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(__pyx_v_X), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_33, __pyx_t_31, __pyx_t_30, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_34, __pyx_t_29, __pyx_v_rtol, __pyx_v_atol, __pyx_t_28, __pyx_t_27, __pyx_t_25, __pyx_v_scale_down_factor, __pyx_t_24, (!(__pyx_v_auto_lambda != 0)), __pyx_v_c_lambda_grid, __pyx_t_32, __pyx_t_14, __pyx_t_23, __pyx_t_26, __pyx_v_with_bounds, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); + __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnCV_sparse(__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(__pyx_v_X), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_33, __pyx_t_31, __pyx_t_30, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_34, __pyx_t_29, __pyx_v_rtol, __pyx_v_atol, __pyx_t_28, __pyx_t_27, __pyx_t_25, __pyx_v_scale_down_factor, __pyx_t_24, (!(__pyx_v_auto_lambda != 0)), __pyx_v_c_lambda_grid, __pyx_t_32, __pyx_t_14, __pyx_t_23, __pyx_t_26, __pyx_v_with_bounds, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); } - __pyx_L104:; + __pyx_L108:; - /* "l0learn/interface.pyx":591 + /* "l0learn/interface.pyx":694 * Highs=numpy_to_dvec_d(highs)) * - * return {"NnzCount": results.NnzCount, # <<<<<<<<<<<<<< - * "Lambda0": results.Lambda0, - * "Lambda12": results.Lambda12, + * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, # <<<<<<<<<<<<<< + * lambda_0=c_results.Lambda0, + * gamma=c_results.Lambda12, */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_7 = __Pyx_PyDict_NewPresized(8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 591, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_CVFitModel); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 694, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = __Pyx_PyDict_NewPresized(9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 694, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(__pyx_v_results.NnzCount); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 591, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_NnzCount, __pyx_t_6) < 0) __PYX_ERR(0, 591, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_3 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 694, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 694, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 694, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 694, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_settings, __pyx_t_3) < 0) __PYX_ERR(0, 694, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":592 + /* "l0learn/interface.pyx":695 * - * return {"NnzCount": results.NnzCount, - * "Lambda0": results.Lambda0, # <<<<<<<<<<<<<< - * "Lambda12": results.Lambda12, - * "Beta": sp_dmat_field_to_list(results.Beta), + * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, + * lambda_0=c_results.Lambda0, # <<<<<<<<<<<<<< + * gamma=c_results.Lambda12, + * support_size=c_results.NnzCount, */ - __pyx_t_6 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_results.Lambda0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 592, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_Lambda0, __pyx_t_6) < 0) __PYX_ERR(0, 591, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Lambda0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 695, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_lambda_0, __pyx_t_3) < 0) __PYX_ERR(0, 694, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":593 - * return {"NnzCount": results.NnzCount, - * "Lambda0": results.Lambda0, - * "Lambda12": results.Lambda12, # <<<<<<<<<<<<<< - * "Beta": sp_dmat_field_to_list(results.Beta), - * "Intercept": results.Intercept, - */ - __pyx_t_6 = __pyx_convert_vector_to_py_double(__pyx_v_results.Lambda12); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 593, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_Lambda12, __pyx_t_6) < 0) __PYX_ERR(0, 591, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - - /* "l0learn/interface.pyx":594 - * "Lambda0": results.Lambda0, - * "Lambda12": results.Lambda12, - * "Beta": sp_dmat_field_to_list(results.Beta), # <<<<<<<<<<<<<< - * "Intercept": results.Intercept, - * "Converged": results.Converged, - */ - __pyx_t_6 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_results.Beta); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 594, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_Beta, __pyx_t_6) < 0) __PYX_ERR(0, 591, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - - /* "l0learn/interface.pyx":595 - * "Lambda12": results.Lambda12, - * "Beta": sp_dmat_field_to_list(results.Beta), - * "Intercept": results.Intercept, # <<<<<<<<<<<<<< - * "Converged": results.Converged, - * "CVMeans": dvec_field_to_list(results.CVMeans)[0], - */ - __pyx_t_6 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_results.Intercept); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 595, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_Intercept, __pyx_t_6) < 0) __PYX_ERR(0, 591, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + /* "l0learn/interface.pyx":696 + * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, + * lambda_0=c_results.Lambda0, + * gamma=c_results.Lambda12, # <<<<<<<<<<<<<< + * support_size=c_results.NnzCount, + * coeffs=sp_dmat_field_to_list(c_results.Beta), + */ + __pyx_t_3 = __pyx_convert_vector_to_py_double(__pyx_v_c_results.Lambda12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 696, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_gamma, __pyx_t_3) < 0) __PYX_ERR(0, 694, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":596 - * "Beta": sp_dmat_field_to_list(results.Beta), - * "Intercept": results.Intercept, - * "Converged": results.Converged, # <<<<<<<<<<<<<< - * "CVMeans": dvec_field_to_list(results.CVMeans)[0], - * "CVSDs": dvec_field_to_list(results.CVSDs)[0]} - */ - __pyx_t_6 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(__pyx_v_results.Converged); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 596, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_Converged, __pyx_t_6) < 0) __PYX_ERR(0, 591, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - - /* "l0learn/interface.pyx":597 - * "Intercept": results.Intercept, - * "Converged": results.Converged, - * "CVMeans": dvec_field_to_list(results.CVMeans)[0], # <<<<<<<<<<<<<< - * "CVSDs": dvec_field_to_list(results.CVSDs)[0]} - * - */ - __pyx_t_6 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_results.CVMeans); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 597, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - if (unlikely(__pyx_t_6 == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(0, 597, __pyx_L1_error) - } - __pyx_t_2 = __Pyx_GetItemInt_List(__pyx_t_6, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 597, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_CVMeans, __pyx_t_2) < 0) __PYX_ERR(0, 591, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + /* "l0learn/interface.pyx":697 + * lambda_0=c_results.Lambda0, + * gamma=c_results.Lambda12, + * support_size=c_results.NnzCount, # <<<<<<<<<<<<<< + * coeffs=sp_dmat_field_to_list(c_results.Beta), + * intercepts=c_results.Intercept, + */ + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(__pyx_v_c_results.NnzCount); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 697, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_support_size, __pyx_t_3) < 0) __PYX_ERR(0, 694, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "l0learn/interface.pyx":698 + * gamma=c_results.Lambda12, + * support_size=c_results.NnzCount, + * coeffs=sp_dmat_field_to_list(c_results.Beta), # <<<<<<<<<<<<<< + * intercepts=c_results.Intercept, + * converged=c_results.Converged, + */ + __pyx_t_3 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_c_results.Beta); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 698, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_coeffs, __pyx_t_3) < 0) __PYX_ERR(0, 694, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "l0learn/interface.pyx":699 + * support_size=c_results.NnzCount, + * coeffs=sp_dmat_field_to_list(c_results.Beta), + * intercepts=c_results.Intercept, # <<<<<<<<<<<<<< + * converged=c_results.Converged, + * cv_means=dvec_field_to_list(c_results.CVMeans), + */ + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Intercept); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 699, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_intercepts, __pyx_t_3) < 0) __PYX_ERR(0, 694, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "l0learn/interface.pyx":700 + * coeffs=sp_dmat_field_to_list(c_results.Beta), + * intercepts=c_results.Intercept, + * converged=c_results.Converged, # <<<<<<<<<<<<<< + * cv_means=dvec_field_to_list(c_results.CVMeans), + * cv_sds=dvec_field_to_list(c_results.CVSDs)) + */ + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(__pyx_v_c_results.Converged); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_converged, __pyx_t_3) < 0) __PYX_ERR(0, 694, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "l0learn/interface.pyx":701 + * intercepts=c_results.Intercept, + * converged=c_results.Converged, + * cv_means=dvec_field_to_list(c_results.CVMeans), # <<<<<<<<<<<<<< + * cv_sds=dvec_field_to_list(c_results.CVSDs)) + * return results + */ + __pyx_t_3 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_c_results.CVMeans); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 701, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_cv_means, __pyx_t_3) < 0) __PYX_ERR(0, 694, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "l0learn/interface.pyx":702 + * converged=c_results.Converged, + * cv_means=dvec_field_to_list(c_results.CVMeans), + * cv_sds=dvec_field_to_list(c_results.CVSDs)) # <<<<<<<<<<<<<< + * return results + * + */ + __pyx_t_3 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_c_results.CVSDs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 702, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_cv_sds, __pyx_t_3) < 0) __PYX_ERR(0, 694, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "l0learn/interface.pyx":694 + * Highs=numpy_to_dvec_d(highs)) + * + * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, # <<<<<<<<<<<<<< + * lambda_0=c_results.Lambda0, + * gamma=c_results.Lambda12, + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_empty_tuple, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 694, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_v_results = __pyx_t_3; + __pyx_t_3 = 0; - /* "l0learn/interface.pyx":598 - * "Converged": results.Converged, - * "CVMeans": dvec_field_to_list(results.CVMeans)[0], - * "CVSDs": dvec_field_to_list(results.CVSDs)[0]} # <<<<<<<<<<<<<< + /* "l0learn/interface.pyx":703 + * cv_means=dvec_field_to_list(c_results.CVMeans), + * cv_sds=dvec_field_to_list(c_results.CVSDs)) + * return results # <<<<<<<<<<<<<< * * */ - __pyx_t_2 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_results.CVSDs); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 598, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (unlikely(__pyx_t_2 == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(0, 598, __pyx_L1_error) - } - __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_t_2, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 598, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_CVSDs, __pyx_t_6) < 0) __PYX_ERR(0, 591, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_r = __pyx_t_7; - __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_results); + __pyx_r = __pyx_v_results; goto __pyx_L0; - /* "l0learn/interface.pyx":350 - * "Converged": results.Converged} + /* "l0learn/interface.pyx":445 + * * * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< * y: np.ndarray, @@ -11121,7 +11747,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_16); @@ -11130,9 +11756,14 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_L0:; __Pyx_XDECREF(__pyx_v_n); __Pyx_XDECREF(__pyx_v_p); + __Pyx_XDECREF(__pyx_v_unique_items); + __Pyx_XDECREF(__pyx_v_a); + __Pyx_XDECREF(__pyx_v__); __Pyx_XDECREF(__pyx_v_i); __Pyx_XDECREF(__pyx_v_sub_lambda_grid); __Pyx_XDECREF(__pyx_v_bad_bounds); + __Pyx_XDECREF(__pyx_v_results); + __Pyx_XDECREF(__pyx_v_y); __Pyx_XDECREF(__pyx_v_penalty); __Pyx_XDECREF(__pyx_v_num_lambda); __Pyx_XDECREF(__pyx_v_num_gamma); @@ -11144,7 +11775,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p return __pyx_r; } -/* "l0learn/interface.pyx":601 +/* "l0learn/interface.pyx":706 * * * cdef fitmodel _L0LearnFit_dense(const dmat& X, # <<<<<<<<<<<<<< @@ -11157,7 +11788,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_dense(arma::dmat const & __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_L0LearnFit_dense", 0); - /* "l0learn/interface.pyx":627 + /* "l0learn/interface.pyx":732 * const dvec &Lows, * const dvec &Highs): * return L0LearnFit[dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< @@ -11167,7 +11798,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_dense(arma::dmat const & __pyx_r = L0LearnFit(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); goto __pyx_L0; - /* "l0learn/interface.pyx":601 + /* "l0learn/interface.pyx":706 * * * cdef fitmodel _L0LearnFit_dense(const dmat& X, # <<<<<<<<<<<<<< @@ -11181,7 +11812,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_dense(arma::dmat const & return __pyx_r; } -/* "l0learn/interface.pyx":632 +/* "l0learn/interface.pyx":737 * * * cdef fitmodel _L0LearnFit_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< @@ -11194,7 +11825,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_sparse(arma::sp_dmat con __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_L0LearnFit_sparse", 0); - /* "l0learn/interface.pyx":658 + /* "l0learn/interface.pyx":763 * const dvec &Lows, * const dvec &Highs): * return L0LearnFit[sp_dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< @@ -11204,7 +11835,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_sparse(arma::sp_dmat con __pyx_r = L0LearnFit(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); goto __pyx_L0; - /* "l0learn/interface.pyx":632 + /* "l0learn/interface.pyx":737 * * * cdef fitmodel _L0LearnFit_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< @@ -11218,7 +11849,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_sparse(arma::sp_dmat con return __pyx_r; } -/* "l0learn/interface.pyx":663 +/* "l0learn/interface.pyx":768 * * * cdef cvfitmodel _L0LearnCV_dense(const dmat& X, # <<<<<<<<<<<<<< @@ -11231,7 +11862,7 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_dense(arma::dmat const __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_L0LearnCV_dense", 0); - /* "l0learn/interface.pyx":691 + /* "l0learn/interface.pyx":796 * const dvec &Lows, * const dvec &Highs): * return L0LearnCV[dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< @@ -11241,7 +11872,7 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_dense(arma::dmat const __pyx_r = L0LearnCV(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_nfolds, __pyx_v_seed, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); goto __pyx_L0; - /* "l0learn/interface.pyx":663 + /* "l0learn/interface.pyx":768 * * * cdef cvfitmodel _L0LearnCV_dense(const dmat& X, # <<<<<<<<<<<<<< @@ -11255,7 +11886,7 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_dense(arma::dmat const return __pyx_r; } -/* "l0learn/interface.pyx":696 +/* "l0learn/interface.pyx":801 * * * cdef cvfitmodel _L0LearnCV_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< @@ -11268,7 +11899,7 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_sparse(arma::sp_dmat co __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_L0LearnCV_sparse", 0); - /* "l0learn/interface.pyx":724 + /* "l0learn/interface.pyx":829 * const dvec &Lows, * const dvec &Highs): * return L0LearnCV[sp_dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< @@ -11278,7 +11909,7 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_sparse(arma::sp_dmat co __pyx_r = L0LearnCV(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_nfolds, __pyx_v_seed, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); goto __pyx_L0; - /* "l0learn/interface.pyx":696 + /* "l0learn/interface.pyx":801 * * * cdef cvfitmodel _L0LearnCV_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< @@ -12438,13 +13069,13 @@ static std::string __pyx_convert_string_from_py_std__in_string(PyObject *__pyx_v /* "vector.to_py":60 * - * @cname("__pyx_convert_vector_to_py_size_t") - * cdef object __pyx_convert_vector_to_py_size_t(vector[X]& v): # <<<<<<<<<<<<<< + * @cname("__pyx_convert_vector_to_py_double") + * cdef object __pyx_convert_vector_to_py_double(vector[X]& v): # <<<<<<<<<<<<<< * return [v[i] for i in range(v.size())] * */ -static PyObject *__pyx_convert_vector_to_py_size_t(const std::vector &__pyx_v_v) { +static PyObject *__pyx_convert_vector_to_py_double(const std::vector &__pyx_v_v) { size_t __pyx_v_i; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations @@ -12456,11 +13087,11 @@ static PyObject *__pyx_convert_vector_to_py_size_t(const std::vector &_ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_size_t", 0); + __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_double", 0); /* "vector.to_py":61 - * @cname("__pyx_convert_vector_to_py_size_t") - * cdef object __pyx_convert_vector_to_py_size_t(vector[X]& v): + * @cname("__pyx_convert_vector_to_py_double") + * cdef object __pyx_convert_vector_to_py_double(vector[X]& v): * return [v[i] for i in range(v.size())] # <<<<<<<<<<<<<< * * @@ -12472,7 +13103,7 @@ static PyObject *__pyx_convert_vector_to_py_size_t(const std::vector &_ __pyx_t_3 = __pyx_t_2; for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; - __pyx_t_5 = __Pyx_PyInt_FromSize_t((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 61, __pyx_L1_error) + __pyx_t_5 = PyFloat_FromDouble((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 61, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(2, 61, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; @@ -12483,8 +13114,8 @@ static PyObject *__pyx_convert_vector_to_py_size_t(const std::vector &_ /* "vector.to_py":60 * - * @cname("__pyx_convert_vector_to_py_size_t") - * cdef object __pyx_convert_vector_to_py_size_t(vector[X]& v): # <<<<<<<<<<<<<< + * @cname("__pyx_convert_vector_to_py_double") + * cdef object __pyx_convert_vector_to_py_double(vector[X]& v): # <<<<<<<<<<<<<< * return [v[i] for i in range(v.size())] * */ @@ -12493,7 +13124,7 @@ static PyObject *__pyx_convert_vector_to_py_size_t(const std::vector &_ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_size_t", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_double", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -12501,7 +13132,7 @@ static PyObject *__pyx_convert_vector_to_py_size_t(const std::vector &_ return __pyx_r; } -static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(const std::vector > &__pyx_v_v) { +static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(const std::vector > &__pyx_v_v) { size_t __pyx_v_i; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations @@ -12513,11 +13144,11 @@ static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(co int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___", 0); + __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___", 0); /* "vector.to_py":61 - * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___") - * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(vector[X]& v): + * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___") + * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(vector[X]& v): * return [v[i] for i in range(v.size())] # <<<<<<<<<<<<<< * * @@ -12529,7 +13160,7 @@ static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(co __pyx_t_3 = __pyx_t_2; for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; - __pyx_t_5 = __pyx_convert_vector_to_py_size_t((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 61, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_vector_to_py_double((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 61, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(2, 61, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; @@ -12540,8 +13171,8 @@ static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(co /* "vector.to_py":60 * - * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___") - * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(vector[X]& v): # <<<<<<<<<<<<<< + * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___") + * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(vector[X]& v): # <<<<<<<<<<<<<< * return [v[i] for i in range(v.size())] * */ @@ -12550,7 +13181,7 @@ static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(co __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -12558,7 +13189,7 @@ static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(co return __pyx_r; } -static PyObject *__pyx_convert_vector_to_py_double(const std::vector &__pyx_v_v) { +static PyObject *__pyx_convert_vector_to_py_size_t(const std::vector &__pyx_v_v) { size_t __pyx_v_i; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations @@ -12570,11 +13201,11 @@ static PyObject *__pyx_convert_vector_to_py_double(const std::vector &_ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_double", 0); + __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_size_t", 0); /* "vector.to_py":61 - * @cname("__pyx_convert_vector_to_py_double") - * cdef object __pyx_convert_vector_to_py_double(vector[X]& v): + * @cname("__pyx_convert_vector_to_py_size_t") + * cdef object __pyx_convert_vector_to_py_size_t(vector[X]& v): * return [v[i] for i in range(v.size())] # <<<<<<<<<<<<<< * * @@ -12586,7 +13217,7 @@ static PyObject *__pyx_convert_vector_to_py_double(const std::vector &_ __pyx_t_3 = __pyx_t_2; for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; - __pyx_t_5 = PyFloat_FromDouble((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 61, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_FromSize_t((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 61, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(2, 61, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; @@ -12597,8 +13228,8 @@ static PyObject *__pyx_convert_vector_to_py_double(const std::vector &_ /* "vector.to_py":60 * - * @cname("__pyx_convert_vector_to_py_double") - * cdef object __pyx_convert_vector_to_py_double(vector[X]& v): # <<<<<<<<<<<<<< + * @cname("__pyx_convert_vector_to_py_size_t") + * cdef object __pyx_convert_vector_to_py_size_t(vector[X]& v): # <<<<<<<<<<<<<< * return [v[i] for i in range(v.size())] * */ @@ -12607,7 +13238,7 @@ static PyObject *__pyx_convert_vector_to_py_double(const std::vector &_ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_double", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_size_t", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -12615,7 +13246,7 @@ static PyObject *__pyx_convert_vector_to_py_double(const std::vector &_ return __pyx_r; } -static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(const std::vector > &__pyx_v_v) { +static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(const std::vector > &__pyx_v_v) { size_t __pyx_v_i; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations @@ -12627,11 +13258,11 @@ static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(co int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___", 0); + __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___", 0); /* "vector.to_py":61 - * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___") - * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(vector[X]& v): + * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___") + * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(vector[X]& v): * return [v[i] for i in range(v.size())] # <<<<<<<<<<<<<< * * @@ -12643,7 +13274,7 @@ static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(co __pyx_t_3 = __pyx_t_2; for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_i = __pyx_t_4; - __pyx_t_5 = __pyx_convert_vector_to_py_double((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 61, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_vector_to_py_size_t((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 61, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(2, 61, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; @@ -12654,8 +13285,8 @@ static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(co /* "vector.to_py":60 * - * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___") - * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(vector[X]& v): # <<<<<<<<<<<<<< + * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___") + * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(vector[X]& v): # <<<<<<<<<<<<<< * return [v[i] for i in range(v.size())] * */ @@ -12664,7 +13295,7 @@ static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(co __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -12832,27 +13463,21 @@ static struct PyModuleDef __pyx_moduledef = { #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { - {&__pyx_n_u_Beta, __pyx_k_Beta, sizeof(__pyx_k_Beta), 0, 1, 0, 1}, {&__pyx_n_u_CD, __pyx_k_CD, sizeof(__pyx_k_CD), 0, 1, 0, 1}, {&__pyx_n_u_CDPSI, __pyx_k_CDPSI, sizeof(__pyx_k_CDPSI), 0, 1, 0, 1}, {&__pyx_n_s_CLASSIFICATION_LOSS, __pyx_k_CLASSIFICATION_LOSS, sizeof(__pyx_k_CLASSIFICATION_LOSS), 0, 0, 1, 1}, - {&__pyx_n_u_CVMeans, __pyx_k_CVMeans, sizeof(__pyx_k_CVMeans), 0, 1, 0, 1}, - {&__pyx_n_u_CVSDs, __pyx_k_CVSDs, sizeof(__pyx_k_CVSDs), 0, 1, 0, 1}, - {&__pyx_n_u_Converged, __pyx_k_Converged, sizeof(__pyx_k_Converged), 0, 1, 0, 1}, + {&__pyx_n_s_CVFitModel, __pyx_k_CVFitModel, sizeof(__pyx_k_CVFitModel), 0, 0, 1, 1}, {&__pyx_kp_u_Expected_all_values_of_lambda_gr, __pyx_k_Expected_all_values_of_lambda_gr, sizeof(__pyx_k_Expected_all_values_of_lambda_gr), 0, 1, 0, 0}, {&__pyx_kp_u_Expected_each_element_of_lambda, __pyx_k_Expected_each_element_of_lambda, sizeof(__pyx_k_Expected_each_element_of_lambda), 0, 1, 0, 0}, {&__pyx_n_u_F_CONTIGUOUS, __pyx_k_F_CONTIGUOUS, sizeof(__pyx_k_F_CONTIGUOUS), 0, 1, 0, 1}, + {&__pyx_n_s_FitModel, __pyx_k_FitModel, sizeof(__pyx_k_FitModel), 0, 0, 1, 1}, {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1}, - {&__pyx_n_u_Intercept, __pyx_k_Intercept, sizeof(__pyx_k_Intercept), 0, 1, 0, 1}, {&__pyx_n_u_L0, __pyx_k_L0, sizeof(__pyx_k_L0), 0, 1, 0, 1}, {&__pyx_n_u_L0L1, __pyx_k_L0L1, sizeof(__pyx_k_L0L1), 0, 1, 0, 1}, {&__pyx_n_u_L0L2, __pyx_k_L0L2, sizeof(__pyx_k_L0L2), 0, 1, 0, 1}, {&__pyx_kp_u_L0_Penalty_requires_lambda_grid, __pyx_k_L0_Penalty_requires_lambda_grid, sizeof(__pyx_k_L0_Penalty_requires_lambda_grid), 0, 1, 0, 0}, - {&__pyx_n_u_Lambda0, __pyx_k_Lambda0, sizeof(__pyx_k_Lambda0), 0, 1, 0, 1}, - {&__pyx_n_u_Lambda12, __pyx_k_Lambda12, sizeof(__pyx_k_Lambda12), 0, 1, 0, 1}, {&__pyx_n_s_List, __pyx_k_List, sizeof(__pyx_k_List), 0, 0, 1, 1}, {&__pyx_n_u_Logistic, __pyx_k_Logistic, sizeof(__pyx_k_Logistic), 0, 1, 0, 1}, - {&__pyx_n_u_NnzCount, __pyx_k_NnzCount, sizeof(__pyx_k_NnzCount), 0, 1, 0, 1}, {&__pyx_kp_u_None, __pyx_k_None, sizeof(__pyx_k_None), 0, 1, 0, 0}, {&__pyx_n_s_NotImplementedError, __pyx_k_NotImplementedError, sizeof(__pyx_k_NotImplementedError), 0, 0, 1, 1}, {&__pyx_kp_u_Not_supported, __pyx_k_Not_supported, sizeof(__pyx_k_Not_supported), 0, 1, 0, 0}, @@ -12866,7 +13491,9 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_Union, __pyx_k_Union, sizeof(__pyx_k_Union), 0, 0, 1, 1}, {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, {&__pyx_n_s_X, __pyx_k_X, sizeof(__pyx_k_X), 0, 0, 1, 1}, + {&__pyx_n_s__18, __pyx_k__18, sizeof(__pyx_k__18), 0, 0, 1, 1}, {&__pyx_kp_u__5, __pyx_k__5, sizeof(__pyx_k__5), 0, 1, 0, 0}, + {&__pyx_n_s_a, __pyx_k_a, sizeof(__pyx_k_a), 0, 0, 1, 1}, {&__pyx_n_s_active_set, __pyx_k_active_set, sizeof(__pyx_k_active_set), 0, 0, 1, 1}, {&__pyx_n_s_active_set_num, __pyx_k_active_set_num, sizeof(__pyx_k_active_set_num), 0, 0, 1, 1}, {&__pyx_n_s_algorithm, __pyx_k_algorithm, sizeof(__pyx_k_algorithm), 0, 0, 1, 1}, @@ -12884,11 +13511,17 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_c_lambda_grid, __pyx_k_c_lambda_grid, sizeof(__pyx_k_c_lambda_grid), 0, 0, 1, 1}, {&__pyx_n_s_c_loss, __pyx_k_c_loss, sizeof(__pyx_k_c_loss), 0, 0, 1, 1}, {&__pyx_n_s_c_penalty, __pyx_k_c_penalty, sizeof(__pyx_k_c_penalty), 0, 0, 1, 1}, + {&__pyx_n_s_c_results, __pyx_k_c_results, sizeof(__pyx_k_c_results), 0, 0, 1, 1}, {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_n_s_coeffs, __pyx_k_coeffs, sizeof(__pyx_k_coeffs), 0, 0, 1, 1}, {&__pyx_kp_u_containing_a_negative_value, __pyx_k_containing_a_negative_value, sizeof(__pyx_k_containing_a_negative_value), 0, 1, 0, 0}, {&__pyx_kp_u_containing_an_increasing_value, __pyx_k_containing_an_increasing_value, sizeof(__pyx_k_containing_an_increasing_value), 0, 1, 0, 0}, + {&__pyx_n_s_converged, __pyx_k_converged, sizeof(__pyx_k_converged), 0, 0, 1, 1}, + {&__pyx_n_s_copy, __pyx_k_copy, sizeof(__pyx_k_copy), 0, 0, 1, 1}, {&__pyx_n_s_csc_matrix, __pyx_k_csc_matrix, sizeof(__pyx_k_csc_matrix), 0, 0, 1, 1}, {&__pyx_n_s_current, __pyx_k_current, sizeof(__pyx_k_current), 0, 0, 1, 1}, + {&__pyx_n_s_cv_means, __pyx_k_cv_means, sizeof(__pyx_k_cv_means), 0, 0, 1, 1}, + {&__pyx_n_s_cv_sds, __pyx_k_cv_sds, sizeof(__pyx_k_cv_sds), 0, 0, 1, 1}, {&__pyx_n_s_cvfit, __pyx_k_cvfit, sizeof(__pyx_k_cvfit), 0, 0, 1, 1}, {&__pyx_n_s_data, __pyx_k_data, sizeof(__pyx_k_data), 0, 0, 1, 1}, {&__pyx_n_s_diff, __pyx_k_diff, sizeof(__pyx_k_diff), 0, 0, 1, 1}, @@ -12935,12 +13568,14 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_kp_u_expected_rtol_parameter_to_exist, __pyx_k_expected_rtol_parameter_to_exist, sizeof(__pyx_k_expected_rtol_parameter_to_exist), 0, 1, 0, 0}, {&__pyx_kp_u_expected_scale_down_factor_param, __pyx_k_expected_scale_down_factor_param, sizeof(__pyx_k_expected_scale_down_factor_param), 0, 1, 0, 0}, {&__pyx_kp_u_expected_screen_size_parameter_t, __pyx_k_expected_screen_size_parameter_t, sizeof(__pyx_k_expected_screen_size_parameter_t), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_screen_size_parameter_t_2, __pyx_k_expected_screen_size_parameter_t_2, sizeof(__pyx_k_expected_screen_size_parameter_t_2), 0, 1, 0, 0}, {&__pyx_kp_u_expected_seed_parameter_to_be_an, __pyx_k_expected_seed_parameter_to_be_an, sizeof(__pyx_k_expected_seed_parameter_to_be_an), 0, 1, 0, 0}, {&__pyx_kp_u_expected_to_be_high_to_be_elemen, __pyx_k_expected_to_be_high_to_be_elemen, sizeof(__pyx_k_expected_to_be_high_to_be_elemen), 0, 1, 0, 0}, {&__pyx_kp_u_expected_y_to_be_a_1D_real_numpy, __pyx_k_expected_y_to_be_a_1D_real_numpy, sizeof(__pyx_k_expected_y_to_be_a_1D_real_numpy), 0, 1, 0, 0}, {&__pyx_kp_u_expected_y_vector_to_only_have_t, __pyx_k_expected_y_vector_to_only_have_t, sizeof(__pyx_k_expected_y_vector_to_only_have_t), 0, 1, 0, 0}, {&__pyx_n_s_fit, __pyx_k_fit, sizeof(__pyx_k_fit), 0, 0, 1, 1}, {&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 1}, + {&__pyx_n_s_gamma, __pyx_k_gamma, sizeof(__pyx_k_gamma), 0, 0, 1, 1}, {&__pyx_n_s_gamma_max, __pyx_k_gamma_max, sizeof(__pyx_k_gamma_max), 0, 0, 1, 1}, {&__pyx_n_s_gamma_min, __pyx_k_gamma_min, sizeof(__pyx_k_gamma_min), 0, 0, 1, 1}, {&__pyx_n_s_highs, __pyx_k_highs, sizeof(__pyx_k_highs), 0, 0, 1, 1}, @@ -12950,12 +13585,17 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_indptr, __pyx_k_indptr, sizeof(__pyx_k_indptr), 0, 0, 1, 1}, {&__pyx_n_u_inf, __pyx_k_inf, sizeof(__pyx_k_inf), 0, 1, 0, 1}, {&__pyx_n_s_intercept, __pyx_k_intercept, sizeof(__pyx_k_intercept), 0, 0, 1, 1}, + {&__pyx_n_u_intercept, __pyx_k_intercept, sizeof(__pyx_k_intercept), 0, 1, 0, 1}, + {&__pyx_n_s_intercepts, __pyx_k_intercepts, sizeof(__pyx_k_intercepts), 0, 0, 1, 1}, {&__pyx_n_s_isrealobj, __pyx_k_isrealobj, sizeof(__pyx_k_isrealobj), 0, 0, 1, 1}, {&__pyx_n_s_issubdtype, __pyx_k_issubdtype, sizeof(__pyx_k_issubdtype), 0, 0, 1, 1}, {&__pyx_n_s_l0learn_interface, __pyx_k_l0learn_interface, sizeof(__pyx_k_l0learn_interface), 0, 0, 1, 1}, {&__pyx_kp_s_l0learn_interface_pyx, __pyx_k_l0learn_interface_pyx, sizeof(__pyx_k_l0learn_interface_pyx), 0, 0, 1, 0}, + {&__pyx_n_s_l0learn_utils, __pyx_k_l0learn_utils, sizeof(__pyx_k_l0learn_utils), 0, 0, 1, 1}, + {&__pyx_n_s_lambda_0, __pyx_k_lambda_0, sizeof(__pyx_k_lambda_0), 0, 0, 1, 1}, {&__pyx_n_s_lambda_grid, __pyx_k_lambda_grid, sizeof(__pyx_k_lambda_grid), 0, 0, 1, 1}, {&__pyx_n_s_loss, __pyx_k_loss, sizeof(__pyx_k_loss), 0, 0, 1, 1}, + {&__pyx_n_u_loss, __pyx_k_loss, sizeof(__pyx_k_loss), 0, 1, 0, 1}, {&__pyx_n_s_lows, __pyx_k_lows, sizeof(__pyx_k_lows), 0, 0, 1, 1}, {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, {&__pyx_n_s_max_iter, __pyx_k_max_iter, sizeof(__pyx_k_max_iter), 0, 0, 1, 1}, @@ -12963,11 +13603,13 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_max_swaps, __pyx_k_max_swaps, sizeof(__pyx_k_max_swaps), 0, 0, 1, 1}, {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1}, {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_n_s_ndarray, __pyx_k_ndarray, sizeof(__pyx_k_ndarray), 0, 0, 1, 1}, {&__pyx_n_s_ndim, __pyx_k_ndim, sizeof(__pyx_k_ndim), 0, 0, 1, 1}, {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, {&__pyx_n_s_np_to_arma_check, __pyx_k_np_to_arma_check, sizeof(__pyx_k_np_to_arma_check), 0, 0, 1, 1}, {&__pyx_n_s_num_folds, __pyx_k_num_folds, sizeof(__pyx_k_num_folds), 0, 0, 1, 1}, {&__pyx_n_s_num_gamma, __pyx_k_num_gamma, sizeof(__pyx_k_num_gamma), 0, 0, 1, 1}, + {&__pyx_kp_u_num_gamma_set_to_1_with, __pyx_k_num_gamma_set_to_1_with, sizeof(__pyx_k_num_gamma_set_to_1_with), 0, 1, 0, 0}, {&__pyx_n_s_num_lambda, __pyx_k_num_lambda, sizeof(__pyx_k_num_lambda), 0, 0, 1, 1}, {&__pyx_n_s_number, __pyx_k_number, sizeof(__pyx_k_number), 0, 0, 1, 1}, {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, @@ -12980,6 +13622,9 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_p, __pyx_k_p, sizeof(__pyx_k_p), 0, 0, 1, 1}, {&__pyx_n_s_partial_sort, __pyx_k_partial_sort, sizeof(__pyx_k_partial_sort), 0, 0, 1, 1}, {&__pyx_n_s_penalty, __pyx_k_penalty, sizeof(__pyx_k_penalty), 0, 0, 1, 1}, + {&__pyx_n_u_penalty, __pyx_k_penalty, sizeof(__pyx_k_penalty), 0, 1, 0, 1}, + {&__pyx_kp_u_penalty_Only_one, __pyx_k_penalty_Only_one, sizeof(__pyx_k_penalty_Only_one), 0, 1, 0, 0}, + {&__pyx_kp_u_penalty_value_will_be_fit, __pyx_k_penalty_value_will_be_fit, sizeof(__pyx_k_penalty_value_will_be_fit), 0, 1, 0, 0}, {&__pyx_n_s_product, __pyx_k_product, sizeof(__pyx_k_product), 0, 0, 1, 1}, {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, {&__pyx_n_s_results, __pyx_k_results, sizeof(__pyx_k_results), 0, 0, 1, 1}, @@ -12988,23 +13633,28 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_scipy_sparse, __pyx_k_scipy_sparse, sizeof(__pyx_k_scipy_sparse), 0, 0, 1, 1}, {&__pyx_n_s_screen_size, __pyx_k_screen_size, sizeof(__pyx_k_screen_size), 0, 0, 1, 1}, {&__pyx_n_s_seed, __pyx_k_seed, sizeof(__pyx_k_seed), 0, 0, 1, 1}, + {&__pyx_n_s_settings, __pyx_k_settings, sizeof(__pyx_k_settings), 0, 0, 1, 1}, {&__pyx_n_s_shape, __pyx_k_shape, sizeof(__pyx_k_shape), 0, 0, 1, 1}, {&__pyx_n_s_sub_lambda_grid, __pyx_k_sub_lambda_grid, sizeof(__pyx_k_sub_lambda_grid), 0, 0, 1, 1}, + {&__pyx_n_s_support_size, __pyx_k_support_size, sizeof(__pyx_k_support_size), 0, 0, 1, 1}, {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, {&__pyx_n_s_typing, __pyx_k_typing, sizeof(__pyx_k_typing), 0, 0, 1, 1}, {&__pyx_n_s_unique, __pyx_k_unique, sizeof(__pyx_k_unique), 0, 0, 1, 1}, + {&__pyx_n_s_unique_items, __pyx_k_unique_items, sizeof(__pyx_k_unique_items), 0, 0, 1, 1}, + {&__pyx_n_s_warn, __pyx_k_warn, sizeof(__pyx_k_warn), 0, 0, 1, 1}, + {&__pyx_n_s_warnings, __pyx_k_warnings, sizeof(__pyx_k_warnings), 0, 0, 1, 1}, {&__pyx_kp_u_where_that_is_not_the_case, __pyx_k_where_that_is_not_the_case, sizeof(__pyx_k_where_that_is_not_the_case), 0, 1, 0, 0}, {&__pyx_n_s_with_bounds, __pyx_k_with_bounds, sizeof(__pyx_k_with_bounds), 0, 0, 1, 1}, {&__pyx_n_s_y, __pyx_k_y, sizeof(__pyx_k_y), 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0} }; static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { - __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 30, __pyx_L1_error) - __pyx_builtin_NotImplementedError = __Pyx_GetBuiltinName(__pyx_n_s_NotImplementedError); if (!__pyx_builtin_NotImplementedError) __PYX_ERR(0, 39, __pyx_L1_error) - __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(0, 229, __pyx_L1_error) - __pyx_builtin_any = __Pyx_GetBuiltinName(__pyx_n_s_any); if (!__pyx_builtin_any) __PYX_ERR(0, 234, __pyx_L1_error) - __pyx_builtin_all = __Pyx_GetBuiltinName(__pyx_n_s_all); if (!__pyx_builtin_all) __PYX_ERR(0, 246, __pyx_L1_error) - __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 280, __pyx_L1_error) + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 19, __pyx_L1_error) + __pyx_builtin_NotImplementedError = __Pyx_GetBuiltinName(__pyx_n_s_NotImplementedError); if (!__pyx_builtin_NotImplementedError) __PYX_ERR(0, 28, __pyx_L1_error) + __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(0, 321, __pyx_L1_error) + __pyx_builtin_any = __Pyx_GetBuiltinName(__pyx_n_s_any); if (!__pyx_builtin_any) __PYX_ERR(0, 326, __pyx_L1_error) + __pyx_builtin_all = __Pyx_GetBuiltinName(__pyx_n_s_all); if (!__pyx_builtin_all) __PYX_ERR(0, 338, __pyx_L1_error) + __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 372, __pyx_L1_error) __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 884, __pyx_L1_error) __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(2, 61, __pyx_L1_error) return 0; @@ -13016,58 +13666,58 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - /* "l0learn/interface.pyx":30 + /* "l0learn/interface.pyx":19 * if isinstance(arr, np.ndarray): * if not arr.flags['F_CONTIGUOUS']: * raise ValueError("expected arr to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< * elif isinstance(arr, csc_matrix): * if not arr.data.flags['F_CONTIGUOUS']: */ - __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_expected_arr_to_be_F_CONTIGUOUS); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 30, __pyx_L1_error) + __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_expected_arr_to_be_F_CONTIGUOUS); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple_); __Pyx_GIVEREF(__pyx_tuple_); - /* "l0learn/interface.pyx":33 + /* "l0learn/interface.pyx":22 * elif isinstance(arr, csc_matrix): * if not arr.data.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.data to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< * if not arr.indices.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") */ - __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_data_to_be_F_CONTIG); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 33, __pyx_L1_error) + __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_data_to_be_F_CONTIG); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 22, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__2); __Pyx_GIVEREF(__pyx_tuple__2); - /* "l0learn/interface.pyx":35 + /* "l0learn/interface.pyx":24 * raise ValueError("expected arr.data to be F_CONTIGUOUS.") * if not arr.indices.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< * if not arr.indptr.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") */ - __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_indices_to_be_F_CON); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 35, __pyx_L1_error) + __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_indices_to_be_F_CON); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 24, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__3); __Pyx_GIVEREF(__pyx_tuple__3); - /* "l0learn/interface.pyx":37 + /* "l0learn/interface.pyx":26 * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") * if not arr.indptr.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< * else: * raise NotImplementedError(f"expected arr to be of type {np.ndarray} or {csc_matrix}, but got {type(arr)}.") */ - __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_indptr_to_be_F_CONT); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 37, __pyx_L1_error) + __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_indptr_to_be_F_CONT); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 26, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__4); __Pyx_GIVEREF(__pyx_tuple__4); - /* "l0learn/interface.pyx":42 + /* "l0learn/interface.pyx":31 * * if arr.ndim == 0: * raise ValueError("expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar") # <<<<<<<<<<<<<< * elif arr.ndim > 2: * raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") */ - __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_ndim_to_be_1_or_2_b); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 42, __pyx_L1_error) + __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_ndim_to_be_1_or_2_b); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 31, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__6); __Pyx_GIVEREF(__pyx_tuple__6); @@ -13093,74 +13743,74 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_GOTREF(__pyx_tuple__12); __Pyx_GIVEREF(__pyx_tuple__12); - /* "l0learn/interface.pyx":26 - * + /* "l0learn/interface.pyx":15 + * from l0learn.utils import FitModel, CVFitModel * * def np_to_arma_check(arr): # <<<<<<<<<<<<<< * # TODO: Add checks for Behaved and OwnsData * if isinstance(arr, np.ndarray): */ - __pyx_tuple__13 = PyTuple_Pack(1, __pyx_n_s_arr); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 26, __pyx_L1_error) + __pyx_tuple__13 = PyTuple_Pack(1, __pyx_n_s_arr); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__13); __Pyx_GIVEREF(__pyx_tuple__13); - __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_np_to_arma_check, 26, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(0, 26, __pyx_L1_error) + __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_np_to_arma_check, 15, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(0, 15, __pyx_L1_error) - /* "l0learn/interface.pyx":56 + /* "l0learn/interface.pyx":45 * * * SUPPORTED_LOSS = ("SquaredError", "Logistic", "SquaredHinge") # <<<<<<<<<<<<<< * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") */ - __pyx_tuple__15 = PyTuple_Pack(3, __pyx_n_u_SquaredError, __pyx_n_u_Logistic, __pyx_n_u_SquaredHinge); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 56, __pyx_L1_error) + __pyx_tuple__15 = PyTuple_Pack(3, __pyx_n_u_SquaredError, __pyx_n_u_Logistic, __pyx_n_u_SquaredHinge); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 45, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__15); __Pyx_GIVEREF(__pyx_tuple__15); - /* "l0learn/interface.pyx":58 + /* "l0learn/interface.pyx":47 * SUPPORTED_LOSS = ("SquaredError", "Logistic", "SquaredHinge") * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") # <<<<<<<<<<<<<< * SUPPORTED_ALGORITHM = ("CD", "CDPSI") * */ - __pyx_tuple__16 = PyTuple_Pack(3, __pyx_n_u_L0, __pyx_n_u_L0L1, __pyx_n_u_L0L2); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 58, __pyx_L1_error) + __pyx_tuple__16 = PyTuple_Pack(3, __pyx_n_u_L0, __pyx_n_u_L0L1, __pyx_n_u_L0L2); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 47, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__16); __Pyx_GIVEREF(__pyx_tuple__16); - /* "l0learn/interface.pyx":59 + /* "l0learn/interface.pyx":48 * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") * SUPPORTED_ALGORITHM = ("CD", "CDPSI") # <<<<<<<<<<<<<< * - * + * def fit(X: Union[np.ndarray, csc_matrix], */ - __pyx_tuple__17 = PyTuple_Pack(2, __pyx_n_u_CD, __pyx_n_u_CDPSI); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(0, 59, __pyx_L1_error) + __pyx_tuple__17 = PyTuple_Pack(2, __pyx_n_u_CD, __pyx_n_u_CDPSI); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(0, 48, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__17); __Pyx_GIVEREF(__pyx_tuple__17); - /* "l0learn/interface.pyx":62 - * + /* "l0learn/interface.pyx":50 + * SUPPORTED_ALGORITHM = ("CD", "CDPSI") * * def fit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< * y: np.ndarray, * loss: str = "SquaredHinge", */ - __pyx_tuple__18 = PyTuple_Pack(38, __pyx_n_s_X, __pyx_n_s_y, __pyx_n_s_loss, __pyx_n_s_penalty, __pyx_n_s_algorithm, __pyx_n_s_max_support_size, __pyx_n_s_num_lambda, __pyx_n_s_num_gamma, __pyx_n_s_gamma_max, __pyx_n_s_gamma_min, __pyx_n_s_partial_sort, __pyx_n_s_max_iter, __pyx_n_s_rtol, __pyx_n_s_atol, __pyx_n_s_active_set, __pyx_n_s_active_set_num, __pyx_n_s_max_swaps, __pyx_n_s_scale_down_factor, __pyx_n_s_screen_size, __pyx_n_s_lambda_grid, __pyx_n_s_exclude_first_k, __pyx_n_s_intercept, __pyx_n_s_lows, __pyx_n_s_highs, __pyx_n_s_n, __pyx_n_s_p, __pyx_n_s_auto_lambda, __pyx_n_s_bad_lambda_grid, __pyx_n_s_i, __pyx_n_s_sub_lambda_grid, __pyx_n_s_current, __pyx_n_s_with_bounds, __pyx_n_s_bad_bounds, __pyx_n_s_c_lambda_grid, __pyx_n_s_c_loss, __pyx_n_s_c_penalty, __pyx_n_s_c_algorithim, __pyx_n_s_results); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(0, 62, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__18); - __Pyx_GIVEREF(__pyx_tuple__18); - __pyx_codeobj__19 = (PyObject*)__Pyx_PyCode_New(24, 0, 38, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_fit, 62, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__19)) __PYX_ERR(0, 62, __pyx_L1_error) + __pyx_tuple__19 = PyTuple_Pack(42, __pyx_n_s_X, __pyx_n_s_y, __pyx_n_s_loss, __pyx_n_s_penalty, __pyx_n_s_algorithm, __pyx_n_s_max_support_size, __pyx_n_s_num_lambda, __pyx_n_s_num_gamma, __pyx_n_s_gamma_max, __pyx_n_s_gamma_min, __pyx_n_s_partial_sort, __pyx_n_s_max_iter, __pyx_n_s_rtol, __pyx_n_s_atol, __pyx_n_s_active_set, __pyx_n_s_active_set_num, __pyx_n_s_max_swaps, __pyx_n_s_scale_down_factor, __pyx_n_s_screen_size, __pyx_n_s_lambda_grid, __pyx_n_s_exclude_first_k, __pyx_n_s_intercept, __pyx_n_s_lows, __pyx_n_s_highs, __pyx_n_s_n, __pyx_n_s_p, __pyx_n_s_unique_items, __pyx_n_s_a, __pyx_n_s__18, __pyx_n_s_auto_lambda, __pyx_n_s_bad_lambda_grid, __pyx_n_s_i, __pyx_n_s_sub_lambda_grid, __pyx_n_s_current, __pyx_n_s_with_bounds, __pyx_n_s_bad_bounds, __pyx_n_s_c_lambda_grid, __pyx_n_s_c_loss, __pyx_n_s_c_penalty, __pyx_n_s_c_algorithim, __pyx_n_s_c_results, __pyx_n_s_results); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(0, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__19); + __Pyx_GIVEREF(__pyx_tuple__19); + __pyx_codeobj__20 = (PyObject*)__Pyx_PyCode_New(24, 0, 42, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__19, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_fit, 50, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__20)) __PYX_ERR(0, 50, __pyx_L1_error) - /* "l0learn/interface.pyx":350 - * "Converged": results.Converged} + /* "l0learn/interface.pyx":445 + * * * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< * y: np.ndarray, * loss: str = "SquaredHinge", */ - __pyx_tuple__20 = PyTuple_Pack(40, __pyx_n_s_X, __pyx_n_s_y, __pyx_n_s_loss, __pyx_n_s_penalty, __pyx_n_s_algorithm, __pyx_n_s_num_folds, __pyx_n_s_seed, __pyx_n_s_max_support_size, __pyx_n_s_num_lambda, __pyx_n_s_num_gamma, __pyx_n_s_gamma_max, __pyx_n_s_gamma_min, __pyx_n_s_partial_sort, __pyx_n_s_max_iter, __pyx_n_s_rtol, __pyx_n_s_atol, __pyx_n_s_active_set, __pyx_n_s_active_set_num, __pyx_n_s_max_swaps, __pyx_n_s_scale_down_factor, __pyx_n_s_screen_size, __pyx_n_s_lambda_grid, __pyx_n_s_exclude_first_k, __pyx_n_s_intercept, __pyx_n_s_lows, __pyx_n_s_highs, __pyx_n_s_n, __pyx_n_s_p, __pyx_n_s_auto_lambda, __pyx_n_s_bad_lambda_grid, __pyx_n_s_i, __pyx_n_s_sub_lambda_grid, __pyx_n_s_current, __pyx_n_s_with_bounds, __pyx_n_s_bad_bounds, __pyx_n_s_c_lambda_grid, __pyx_n_s_c_loss, __pyx_n_s_c_penalty, __pyx_n_s_c_algorithim, __pyx_n_s_results); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(0, 350, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__20); - __Pyx_GIVEREF(__pyx_tuple__20); - __pyx_codeobj__21 = (PyObject*)__Pyx_PyCode_New(26, 0, 40, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__20, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_cvfit, 350, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__21)) __PYX_ERR(0, 350, __pyx_L1_error) + __pyx_tuple__21 = PyTuple_Pack(44, __pyx_n_s_X, __pyx_n_s_y, __pyx_n_s_loss, __pyx_n_s_penalty, __pyx_n_s_algorithm, __pyx_n_s_num_folds, __pyx_n_s_seed, __pyx_n_s_max_support_size, __pyx_n_s_num_lambda, __pyx_n_s_num_gamma, __pyx_n_s_gamma_max, __pyx_n_s_gamma_min, __pyx_n_s_partial_sort, __pyx_n_s_max_iter, __pyx_n_s_rtol, __pyx_n_s_atol, __pyx_n_s_active_set, __pyx_n_s_active_set_num, __pyx_n_s_max_swaps, __pyx_n_s_scale_down_factor, __pyx_n_s_screen_size, __pyx_n_s_lambda_grid, __pyx_n_s_exclude_first_k, __pyx_n_s_intercept, __pyx_n_s_lows, __pyx_n_s_highs, __pyx_n_s_n, __pyx_n_s_p, __pyx_n_s_unique_items, __pyx_n_s_a, __pyx_n_s__18, __pyx_n_s_auto_lambda, __pyx_n_s_bad_lambda_grid, __pyx_n_s_i, __pyx_n_s_sub_lambda_grid, __pyx_n_s_current, __pyx_n_s_with_bounds, __pyx_n_s_bad_bounds, __pyx_n_s_c_lambda_grid, __pyx_n_s_c_loss, __pyx_n_s_c_penalty, __pyx_n_s_c_algorithim, __pyx_n_s_c_results, __pyx_n_s_results); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(0, 445, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__21); + __Pyx_GIVEREF(__pyx_tuple__21); + __pyx_codeobj__22 = (PyObject*)__Pyx_PyCode_New(26, 0, 44, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__21, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_cvfit, 445, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__22)) __PYX_ERR(0, 445, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; @@ -13512,113 +14162,162 @@ if (!__Pyx_RefNanny) { if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif - /* "l0learn/interface.pyx":6 + /* "l0learn/interface.pyx":4 * from libcpp.string cimport string * from libcpp cimport bool as cppbool * import numpy as np # <<<<<<<<<<<<<< * from scipy.sparse import csc_matrix - * + * from warnings import warn */ - __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) + __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 6, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":7 + /* "l0learn/interface.pyx":5 * from libcpp cimport bool as cppbool * import numpy as np * from scipy.sparse import csc_matrix # <<<<<<<<<<<<<< + * from warnings import warn * - * from typing import Union, Optional, List */ - __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_csc_matrix); __Pyx_GIVEREF(__pyx_n_s_csc_matrix); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_csc_matrix); - __pyx_t_2 = __Pyx_Import(__pyx_n_s_scipy_sparse, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 7, __pyx_L1_error) + __pyx_t_2 = __Pyx_Import(__pyx_n_s_scipy_sparse, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 7, __pyx_L1_error) + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_csc_matrix, __pyx_t_1) < 0) __PYX_ERR(0, 7, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_csc_matrix, __pyx_t_1) < 0) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "l0learn/interface.pyx":9 + /* "l0learn/interface.pyx":6 + * import numpy as np * from scipy.sparse import csc_matrix + * from warnings import warn # <<<<<<<<<<<<<< + * + * from typing import Union, Optional, List + */ + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_warn); + __Pyx_GIVEREF(__pyx_n_s_warn); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_warn); + __pyx_t_1 = __Pyx_Import(__pyx_n_s_warnings, __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_warn); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_warn, __pyx_t_2) < 0) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "l0learn/interface.pyx":8 + * from warnings import warn * * from typing import Union, Optional, List # <<<<<<<<<<<<<< * * from l0learn.cyarma cimport dmat, sp_dmat, numpy_to_sp_dmat_d, numpy_to_dmat_d, dvec, numpy_to_dvec_d, \ */ - __pyx_t_2 = PyList_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = PyList_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_Union); __Pyx_GIVEREF(__pyx_n_s_Union); - PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_Union); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_Union); __Pyx_INCREF(__pyx_n_s_Optional); __Pyx_GIVEREF(__pyx_n_s_Optional); - PyList_SET_ITEM(__pyx_t_2, 1, __pyx_n_s_Optional); + PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_Optional); __Pyx_INCREF(__pyx_n_s_List); __Pyx_GIVEREF(__pyx_n_s_List); - PyList_SET_ITEM(__pyx_t_2, 2, __pyx_n_s_List); - __pyx_t_1 = __Pyx_Import(__pyx_n_s_typing, __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error) + PyList_SET_ITEM(__pyx_t_1, 2, __pyx_n_s_List); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_typing, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Union); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Union, __pyx_t_1) < 0) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Optional); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Optional, __pyx_t_1) < 0) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_List); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_List, __pyx_t_1) < 0) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_Union); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 9, __pyx_L1_error) + + /* "l0learn/interface.pyx":13 + * sp_dmat_field_to_list, dvec_field_to_list + * + * from l0learn.utils import FitModel, CVFitModel # <<<<<<<<<<<<<< + * + * def np_to_arma_check(arr): + */ + __pyx_t_2 = PyList_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_Union, __pyx_t_2) < 0) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_INCREF(__pyx_n_s_FitModel); + __Pyx_GIVEREF(__pyx_n_s_FitModel); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_FitModel); + __Pyx_INCREF(__pyx_n_s_CVFitModel); + __Pyx_GIVEREF(__pyx_n_s_CVFitModel); + PyList_SET_ITEM(__pyx_t_2, 1, __pyx_n_s_CVFitModel); + __pyx_t_1 = __Pyx_Import(__pyx_n_s_l0learn_utils, __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_Optional); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 9, __pyx_L1_error) + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_FitModel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_Optional, __pyx_t_2) < 0) __PYX_ERR(0, 9, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_FitModel, __pyx_t_2) < 0) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_List); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 9, __pyx_L1_error) + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_CVFitModel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_List, __pyx_t_2) < 0) __PYX_ERR(0, 9, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_CVFitModel, __pyx_t_2) < 0) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":26 - * + /* "l0learn/interface.pyx":15 + * from l0learn.utils import FitModel, CVFitModel * * def np_to_arma_check(arr): # <<<<<<<<<<<<<< * # TODO: Add checks for Behaved and OwnsData * if isinstance(arr, np.ndarray): */ - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_1np_to_arma_check, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 26, __pyx_L1_error) + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_1np_to_arma_check, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_np_to_arma_check, __pyx_t_1) < 0) __PYX_ERR(0, 26, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_np_to_arma_check, __pyx_t_1) < 0) __PYX_ERR(0, 15, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":56 + /* "l0learn/interface.pyx":45 * * * SUPPORTED_LOSS = ("SquaredError", "Logistic", "SquaredHinge") # <<<<<<<<<<<<<< * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_SUPPORTED_LOSS, __pyx_tuple__15) < 0) __PYX_ERR(0, 56, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SUPPORTED_LOSS, __pyx_tuple__15) < 0) __PYX_ERR(0, 45, __pyx_L1_error) - /* "l0learn/interface.pyx":57 + /* "l0learn/interface.pyx":46 * * SUPPORTED_LOSS = ("SquaredError", "Logistic", "SquaredHinge") * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] # <<<<<<<<<<<<<< * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") * SUPPORTED_ALGORITHM = ("CD", "CDPSI") */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 46, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 57, __pyx_L1_error) + __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 46, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 46, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 57, __pyx_L1_error) + __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 46, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 46, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); @@ -13626,111 +14325,111 @@ if (!__Pyx_RefNanny) { PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3); __pyx_t_2 = 0; __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_CLASSIFICATION_LOSS, __pyx_t_1) < 0) __PYX_ERR(0, 57, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_CLASSIFICATION_LOSS, __pyx_t_1) < 0) __PYX_ERR(0, 46, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":58 + /* "l0learn/interface.pyx":47 * SUPPORTED_LOSS = ("SquaredError", "Logistic", "SquaredHinge") * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") # <<<<<<<<<<<<<< * SUPPORTED_ALGORITHM = ("CD", "CDPSI") * */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_SUPPORTED_PENALTY, __pyx_tuple__16) < 0) __PYX_ERR(0, 58, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SUPPORTED_PENALTY, __pyx_tuple__16) < 0) __PYX_ERR(0, 47, __pyx_L1_error) - /* "l0learn/interface.pyx":59 + /* "l0learn/interface.pyx":48 * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") * SUPPORTED_ALGORITHM = ("CD", "CDPSI") # <<<<<<<<<<<<<< * - * + * def fit(X: Union[np.ndarray, csc_matrix], */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_SUPPORTED_ALGORITHM, __pyx_tuple__17) < 0) __PYX_ERR(0, 59, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SUPPORTED_ALGORITHM, __pyx_tuple__17) < 0) __PYX_ERR(0, 48, __pyx_L1_error) - /* "l0learn/interface.pyx":84 + /* "l0learn/interface.pyx":72 * exclude_first_k: int = 0, * intercept: bool = True, * lows: Union[np.ndarray, float] = -float('inf'), # <<<<<<<<<<<<<< * highs: Union[np.ndarray, float] = +float('inf'),): * """ */ - __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 84, __pyx_L1_error) - __pyx_t_1 = PyFloat_FromDouble((-__pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 84, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 72, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble((-__pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 72, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_k__7 = __pyx_t_1; __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":85 + /* "l0learn/interface.pyx":73 * intercept: bool = True, * lows: Union[np.ndarray, float] = -float('inf'), * highs: Union[np.ndarray, float] = +float('inf'),): # <<<<<<<<<<<<<< * """ * Computes the regularization path for the specified loss function and penalty function. */ - __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 85, __pyx_L1_error) - __pyx_t_1 = PyFloat_FromDouble(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 85, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 73, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 73, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_k__8 = __pyx_t_1; __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":62 - * + /* "l0learn/interface.pyx":50 + * SUPPORTED_ALGORITHM = ("CD", "CDPSI") * * def fit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< * y: np.ndarray, * loss: str = "SquaredHinge", */ - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_3fit, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 62, __pyx_L1_error) + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_3fit, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 50, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_fit, __pyx_t_1) < 0) __PYX_ERR(0, 62, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_fit, __pyx_t_1) < 0) __PYX_ERR(0, 50, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":374 + /* "l0learn/interface.pyx":469 * exclude_first_k: int = 0, * intercept: bool = True, * lows: Union[np.ndarray, float] = -float('inf'), # <<<<<<<<<<<<<< * highs: Union[np.ndarray, float] = +float('inf'),): * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): */ - __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 374, __pyx_L1_error) - __pyx_t_1 = PyFloat_FromDouble((-__pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 374, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 469, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble((-__pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 469, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_k__9 = __pyx_t_1; __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":375 + /* "l0learn/interface.pyx":470 * intercept: bool = True, * lows: Union[np.ndarray, float] = -float('inf'), * highs: Union[np.ndarray, float] = +float('inf'),): # <<<<<<<<<<<<<< * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") */ - __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 375, __pyx_L1_error) - __pyx_t_1 = PyFloat_FromDouble(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 375, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 470, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 470, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_k__10 = __pyx_t_1; __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":350 - * "Converged": results.Converged} + /* "l0learn/interface.pyx":445 + * * * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< * y: np.ndarray, * loss: str = "SquaredHinge", */ - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_5cvfit, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 350, __pyx_L1_error) + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_5cvfit, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 445, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_cvfit, __pyx_t_1) < 0) __PYX_ERR(0, 350, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_cvfit, __pyx_t_1) < 0) __PYX_ERR(0, 445, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "l0learn/interface.pyx":1 - * cimport numpy # <<<<<<<<<<<<<< - * cimport numpy as np - * from libcpp.vector cimport vector + * from libcpp.vector cimport vector # <<<<<<<<<<<<<< + * from libcpp.string cimport string + * from libcpp cimport bool as cppbool */ __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -13817,6 +14516,67 @@ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { return result; } +/* PyDictVersioning */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { + PyObject **dictptr = NULL; + Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; + if (offset) { +#if CYTHON_COMPILING_IN_CPYTHON + dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); +#else + dictptr = _PyObject_GetDictPtr(obj); +#endif + } + return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; +} +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) + return 0; + return obj_dict_version == __Pyx_get_object_dict_version(obj); +} +#endif + +/* GetModuleGlobalName */ +#if CYTHON_USE_DICT_VERSIONS +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) +#else +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) +#endif +{ + PyObject *result; +#if !CYTHON_AVOID_BORROWED_REFS +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 + result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } else if (unlikely(PyErr_Occurred())) { + return NULL; + } +#else + result = PyDict_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } +#endif +#else + result = PyObject_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } + PyErr_Clear(); +#endif + return __Pyx_GetBuiltinName(name); +} + /* DictGetItem */ #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { @@ -14044,67 +14804,6 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject } #endif -/* PyDictVersioning */ -#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { - PyObject *dict = Py_TYPE(obj)->tp_dict; - return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; -} -static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { - PyObject **dictptr = NULL; - Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; - if (offset) { -#if CYTHON_COMPILING_IN_CPYTHON - dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); -#else - dictptr = _PyObject_GetDictPtr(obj); -#endif - } - return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; -} -static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { - PyObject *dict = Py_TYPE(obj)->tp_dict; - if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) - return 0; - return obj_dict_version == __Pyx_get_object_dict_version(obj); -} -#endif - -/* GetModuleGlobalName */ -#if CYTHON_USE_DICT_VERSIONS -static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) -#else -static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) -#endif -{ - PyObject *result; -#if !CYTHON_AVOID_BORROWED_REFS -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 - result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } else if (unlikely(PyErr_Occurred())) { - return NULL; - } -#else - result = PyDict_GetItem(__pyx_d, name); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } -#endif -#else - result = PyObject_GetItem(__pyx_d, name); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } - PyErr_Clear(); -#endif - return __Pyx_GetBuiltinName(name); -} - /* JoinPyUnicode */ static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, CYTHON_UNUSED Py_UCS4 max_char) { @@ -14911,6 +15610,31 @@ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int #endif } +/* PyUnicode_Substring */ +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_Substring( + PyObject* text, Py_ssize_t start, Py_ssize_t stop) { + Py_ssize_t length; + if (unlikely(__Pyx_PyUnicode_READY(text) == -1)) return NULL; + length = __Pyx_PyUnicode_GET_LENGTH(text); + if (start < 0) { + start += length; + if (start < 0) + start = 0; + } + if (stop < 0) + stop += length; + else if (stop > length) + stop = length; + if (stop <= start) + return __Pyx_NewRef(__pyx_empty_unicode); +#if CYTHON_PEP393_ENABLED + return PyUnicode_FromKindAndData(PyUnicode_KIND(text), + PyUnicode_1BYTE_DATA(text) + start*PyUnicode_KIND(text), stop-start); +#else + return PyUnicode_FromUnicode(PyUnicode_AS_UNICODE(text)+start, stop-start); +#endif +} + /* CIntToDigits */ static const char DIGIT_PAIRS_10[2*10*10+1] = { "00010203040506070809" diff --git a/python/l0learn/interface.pyx b/python/l0learn/interface.pyx index 364398c..1fd167e 100644 --- a/python/l0learn/interface.pyx +++ b/python/l0learn/interface.pyx @@ -1,27 +1,16 @@ -cimport numpy -cimport numpy as np from libcpp.vector cimport vector from libcpp.string cimport string from libcpp cimport bool as cppbool import numpy as np from scipy.sparse import csc_matrix +from warnings import warn from typing import Union, Optional, List from l0learn.cyarma cimport dmat, sp_dmat, numpy_to_sp_dmat_d, numpy_to_dmat_d, dvec, numpy_to_dvec_d, \ sp_dmat_field_to_list, dvec_field_to_list -# def gen_synthetic(): -# raise NotImplementedError -# -# -# def gen_synthetic_high_corr(): -# raise NotImplementedError -# -# -# def gen_synthetic_logistic(): -# raise NotImplementedError - +from l0learn.utils import FitModel, CVFitModel def np_to_arma_check(arr): # TODO: Add checks for Behaved and OwnsData @@ -58,7 +47,6 @@ CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") SUPPORTED_ALGORITHM = ("CD", "CDPSI") - def fit(X: Union[np.ndarray, csc_matrix], y: np.ndarray, loss: str = "SquaredHinge", @@ -90,59 +78,154 @@ def fit(X: Union[np.ndarray, csc_matrix], ---------- X : np.ndarray or csc_matrix of shape (N, P) Data Matrix where rows of X are observations and columns of X are features + y : np.ndarray of shape (P) The response vector where y[i] corresponds to X[i, :] For classification, a binary vector (-1, 1) is requried . + loss : str The loss function. Currently supports the choices: "SquaredError" (for regression), "Logistic" (for logistic regression), and "SquaredHinge" (for smooth SVM). + penalty : str The type of regularization. This can take either one of the following choices: "L0", "L0L2", and "L0L1" + algorithm : str The type of algorithm used to minimize the objective function. Currently "CD" and "CDPSI" are are supported. "CD" is a variant of cyclic coordinate descent and runs very fast. "CDPSI" performs local combinatorial search on top of CD and typically achieves higher quality solutions (at the expense of increased running time). - max_support_size - num_lambda - num_gamma - gamma_max - gamma_min - partial_sort - max_iter - rtol - atol - active_set - active_set_num - max_swaps - scale_down_factor - screen_size - lambda_grid - exclude_first_k - intercept - lows - highs + + max_support_size : int + Must be greater than 0. + The maximum support size at which to terminate the regularization path. We recommend setting this to a small + fraction of min(n,p) (e.g. 0.05 * min(n,p)) as L0 regularization typically selects a small portion of non-zeros. + + num_lambda : int, optional + The number of lambda values to select in the regularization path. + This value must be None if lambda_grid is supplied.When supplied, must be greater than 0. + Note: lambda is the regularization parameter corresponding to the L0 norm. + + num_gamma: int, optional + The number of gamma values to select in the regularization path. + This value must be None if lambda_grid is supplied. When supplied, must be greater than 0. + Note: gamma is the regularization parameter corresponding to L1 or L2, depending on the chosen penalty). + + gamma_max : float + The maximum value of gamma when using the L0L2 penalty. + This value must be greater than 0. + + Note: For the L0L1 penalty this is automatically selected. + + gamma_min : float + The minimum value of Gamma when using the L0L2 penalty. + This value must be greater than 0 but less than gamma_max. + Note: For the L0L1 penalty, the minimum value of gamma in the grid is set to gammaMin * gammaMax. + + partial_sort : bool + If TRUE partial sorting will be used for sorting the coordinates to do greedy cycling (see our paper for + for details). Otherwise, full sorting is used. #TODO: Add link for paper + + max_iter : int + The maximum number of iterations (full cycles) for CD per grid point. The algorithm may not use the full number + of iteration per grid point if convergence is found (defined by rtol and atol parameter) + Must be greater than 0 + + rtol : float + The relative tolerance which decides when to terminate optimization as based on the relative change in the + objective between iterations. + Must be greater than 0 and less than 1. + + atol : float + The absolute tolerance which decides when to terminate optimization as based on the absolute L2 norm of the + residuals + Must be greater than 0 + + active_set : bool + If TRUE, performs active set updates. (see our paper for for details). #TODO: Add link for paper + + active_set_num : int + The number of consecutive times a support should appear before declaring support stabilization. + (see our paper for for details). #TODO: Add link for paper + + Must be greater than 0. + + max_swaps : int + The maximum number of swaps used by CDPSI for each grid point. + Must be greater than 0. Ignored by CD algorithims. + + scale_down_factor : float + Roughly amount each lambda value is scaled by between grid points. Larger values lead to closer lambdas and + typically to smaller gaps between the support sizes. + + For details, see our paper - Section 5 on Adaptive Selection of Tuning Parameters). #TODO: Add link for paper + + Must be greater than 0 and less than 1 (strictly for both.) + + screen_size : int + The number of coordinates to cycle over when performing initial correlation screening. #TODO: Add link for paper + + Must be greater than 0 and less than number of columns of X. + + lambda_grid : list of list of floats + A grid of lambda values to use in computing the regularization path. This is by default an empty list + and is ignored. When specified, lambda_grid should be a list of list of floats, where the ith element + (corresponding to the ith gamma) should be a decreasing sequence of lambda values. The length of this sequence + is directly the number of lambdas to be tried for that gamma. + + In the the "L0" penalty case, lambda_grid should be a list of 1. + In the "L0LX" penalty cases, lambda_grid can be a list of any length. The length of lambda_grid will be the + number of gamma values tried. + + See the example notebook for more details. + + Note: When lambda_grid is supplied, num_gamma and num_lambda must be None. + + exclude_first_k : int + The first exclude_first_k features in X will be excluded from variable selection. In other words, the first + exclude_first_k variables will not be included in the L0-norm penalty however they will be included in the + L1 or L2 norm penalties, if they are specified. + + Must be a positive integer less than the columns of X. + + intercept : bool + If False, no intercept term is included or fit in the regularization path + Intercept terms are not regularized by L0 or L1/L2. + + lows : np array or float + Lower bounds for coefficients. Either a scalar for all coefficients to have the same bound or a vector of + size p (number of columns of X) where lows[i] is the lower bound for coefficient i. + + Lower bounds can not be above 0 (i.e. we can not specify that all coefficients must be larger than a > 0). + Lower bounds can be set to 0 iff the corresponding upper bound for that coefficient is also not 0. + + highs : np array or float + Upper bounds for coefficients. Either a scalar for all coefficients to have the same bound or a vector of + size p (number of columns of X) where highs[i] is the upper bound for coefficient i. + + Upper bounds can not be below 0 (i.e. we can not specify that all coefficients must be smaller than a < 0). + Upper bounds can be set to 0 iff the corresponding looer bound for that coefficient is also not 0. Returns ------- + + Examples + -------- """ if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") - n, p = X.shape if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") - if loss not in SUPPORTED_LOSS: raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") - if penalty not in SUPPORTED_PENALTY: raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") if algorithm not in SUPPORTED_ALGORITHM: @@ -171,8 +254,9 @@ def fit(X: Union[np.ndarray, csc_matrix], raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") if not (0 < scale_down_factor < 1): raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") - if not isinstance(screen_size, int) or screen_size < 1: - raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") + if not isinstance(screen_size, int) or screen_size < 1 or screen_size > p: + raise ValueError(f"expected screen_size parameter to be a positive integer less than {p}," + f" but got {screen_size}") if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " f"but got {exclude_first_k}") @@ -181,16 +265,21 @@ def fit(X: Union[np.ndarray, csc_matrix], f"but got {intercept}") if loss in CLASSIFICATION_LOSS: - if sorted(np.unique(y)) != [-1, 1]: - raise ValueError(f"expected y vector to only have two unique values (-1 and 1) (Binary Classification), " - f"but got {np.unique(y)}") + unique_items = sorted(np.unique(y)) + if 0 >= len(unique_items) > 2: + raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " + f"but got {unique_items}") + else: + a, *_ = unique_items # a is the lower value + y = np.copy(y) + y[y==a] = -1 + y[y!=a] = 1 if penalty == "L0": - # TODO: Must be corrected in R code: https://github.com/hazimehh/L0Learn/blob/7a65474dfdb01489a0c263d7b24fbafad56fba61/R/fit.R#L136 # Pure L0 is not supported for classification # Below we add a small L2 component. - if len(lambda_grid) != 1: + if lambda_grid is not None and len(lambda_grid) != 1: # If this error checking was left to the lower section, it would confuse users as # we are converting L0 to L0L2 with small L2 penalty. # Here we must check if lambdaGrid is supplied (And thus use 'autolambda') @@ -200,6 +289,8 @@ def fit(X: Union[np.ndarray, csc_matrix], penalty = "L0L2" gamma_max = 1e-7 gamma_min = 1e-7 + elif penalty != "L0" and num_gamma == 1: + warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") if lambda_grid is None: lambda_grid = [[0.]] @@ -284,68 +375,71 @@ def fit(X: Union[np.ndarray, csc_matrix], cdef string c_penalty = penalty.encode('UTF-8') cdef string c_algorithim = algorithm.encode('UTF-8') - cdef fitmodel results + cdef fitmodel c_results if isinstance(X, np.ndarray): - results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), - y=numpy_to_dvec_d(y), - Loss=c_loss, - Penalty=c_penalty, - Algorithm=c_algorithim, - NnzStopNum=max_support_size, - G_ncols=num_lambda, - G_nrows=num_gamma, - Lambda2Max=gamma_max, - Lambda2Min=gamma_min, - PartialSort=partial_sort, - MaxIters=max_iter, - rtol=rtol, - atol=atol, - ActiveSet=active_set, - ActiveSetNum=active_set_num, - MaxNumSwaps=max_swaps, - ScaleDownFactor=scale_down_factor, - ScreenSize=screen_size, - LambdaU=not auto_lambda, - Lambdas=c_lambda_grid, - ExcludeFirstK=exclude_first_k, - Intercept=intercept, - withBounds=with_bounds, - Lows=numpy_to_dvec_d(lows), - Highs=numpy_to_dvec_d(highs)) + c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), + y=numpy_to_dvec_d(y), + Loss=c_loss, + Penalty=c_penalty, + Algorithm=c_algorithim, + NnzStopNum=max_support_size, + G_ncols=num_lambda, + G_nrows=num_gamma, + Lambda2Max=gamma_max, + Lambda2Min=gamma_min, + PartialSort=partial_sort, + MaxIters=max_iter, + rtol=rtol, + atol=atol, + ActiveSet=active_set, + ActiveSetNum=active_set_num, + MaxNumSwaps=max_swaps, + ScaleDownFactor=scale_down_factor, + ScreenSize=screen_size, + LambdaU=not auto_lambda, + Lambdas=c_lambda_grid, + ExcludeFirstK=exclude_first_k, + Intercept=intercept, + withBounds=with_bounds, + Lows=numpy_to_dvec_d(lows), + Highs=numpy_to_dvec_d(highs)) else: # isinstance(X, csc_matrix) - results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), - y=numpy_to_dvec_d(y), - Loss=c_loss, - Penalty=c_penalty, - Algorithm=c_algorithim, - NnzStopNum=max_support_size, - G_ncols=num_lambda, - G_nrows=num_gamma, - Lambda2Max=gamma_max, - Lambda2Min=gamma_min, - PartialSort=partial_sort, - MaxIters=max_iter, - rtol=rtol, - atol=atol, - ActiveSet=active_set, - ActiveSetNum=active_set_num, - MaxNumSwaps=max_swaps, - ScaleDownFactor=scale_down_factor, - ScreenSize=screen_size, - LambdaU=not auto_lambda, - Lambdas=c_lambda_grid, - ExcludeFirstK=exclude_first_k, - Intercept=intercept, - withBounds=with_bounds, - Lows=numpy_to_dvec_d(lows), - Highs=numpy_to_dvec_d(highs)) + c_results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), + y=numpy_to_dvec_d(y), + Loss=c_loss, + Penalty=c_penalty, + Algorithm=c_algorithim, + NnzStopNum=max_support_size, + G_ncols=num_lambda, + G_nrows=num_gamma, + Lambda2Max=gamma_max, + Lambda2Min=gamma_min, + PartialSort=partial_sort, + MaxIters=max_iter, + rtol=rtol, + atol=atol, + ActiveSet=active_set, + ActiveSetNum=active_set_num, + MaxNumSwaps=max_swaps, + ScaleDownFactor=scale_down_factor, + ScreenSize=screen_size, + LambdaU=not auto_lambda, + Lambdas=c_lambda_grid, + ExcludeFirstK=exclude_first_k, + Intercept=intercept, + withBounds=with_bounds, + Lows=numpy_to_dvec_d(lows), + Highs=numpy_to_dvec_d(highs)) + + results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, + lambda_0=c_results.Lambda0, + gamma=c_results.Lambda12, + support_size=c_results.NnzCount, + coeffs=sp_dmat_field_to_list(c_results.Beta), + intercepts=c_results.Intercept, + converged=c_results.Converged) + return results - return {"NnzCount": results.NnzCount, - "Lambda0": results.Lambda0, - "Lambda12": results.Lambda12, - "Beta": sp_dmat_field_to_list(results.Beta), - "Intercept": results.Intercept, - "Converged": results.Converged} def cvfit(X: Union[np.ndarray, csc_matrix], y: np.ndarray, @@ -425,16 +519,21 @@ def cvfit(X: Union[np.ndarray, csc_matrix], f"but got {intercept}") if loss in CLASSIFICATION_LOSS: - if sorted(np.unique(y)) != [-1, 1]: - raise ValueError(f"expected y vector to only have two unique values (-1 and 1) (Binary Classification), " - f"but got {np.unique(y)}") + unique_items = sorted(np.unique(y)) + if 0 >= len(unique_items) > 2: + raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " + f"but got {unique_items}") + else: + a, *_ = unique_items # a is the lower value + y = np.copy(y) + y[y==a] = -1 + y[y!=a] = 1 if penalty == "L0": - # TODO: Must be corrected in R code: https://github.com/hazimehh/L0Learn/blob/7a65474dfdb01489a0c263d7b24fbafad56fba61/R/fit.R#L136 # Pure L0 is not supported for classification # Below we add a small L2 component. - if len(lambda_grid) != 1: + if lambda_grid is not None and len(lambda_grid) != 1: # If this error checking was left to the lower section, it would confuse users as # we are converting L0 to L0L2 with small L2 penalty. # Here we must check if lambdaGrid is supplied (And thus use 'autolambda') @@ -444,6 +543,8 @@ def cvfit(X: Union[np.ndarray, csc_matrix], penalty = "L0L2" gamma_max = 1e-7 gamma_min = 1e-7 + elif penalty != "L0" and num_gamma == 1: + warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") if lambda_grid is None: lambda_grid = [[0.]] @@ -528,9 +629,9 @@ def cvfit(X: Union[np.ndarray, csc_matrix], cdef string c_penalty = penalty.encode('UTF-8') cdef string c_algorithim = algorithm.encode('UTF-8') - cdef cvfitmodel results + cdef cvfitmodel c_results if isinstance(X, np.ndarray): - results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), + c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), y=numpy_to_dvec_d(y), Loss=c_loss, Penalty=c_penalty, @@ -559,7 +660,7 @@ def cvfit(X: Union[np.ndarray, csc_matrix], Lows=numpy_to_dvec_d(lows), Highs=numpy_to_dvec_d(highs)) else: # isinstance(X, csc_matrix) - results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), + c_results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), y=numpy_to_dvec_d(y), Loss=c_loss, Penalty=c_penalty, @@ -588,14 +689,16 @@ def cvfit(X: Union[np.ndarray, csc_matrix], Lows=numpy_to_dvec_d(lows), Highs=numpy_to_dvec_d(highs)) - return {"NnzCount": results.NnzCount, - "Lambda0": results.Lambda0, - "Lambda12": results.Lambda12, - "Beta": sp_dmat_field_to_list(results.Beta), - "Intercept": results.Intercept, - "Converged": results.Converged, - "CVMeans": dvec_field_to_list(results.CVMeans)[0], - "CVSDs": dvec_field_to_list(results.CVSDs)[0]} + results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, + lambda_0=c_results.Lambda0, + gamma=c_results.Lambda12, + support_size=c_results.NnzCount, + coeffs=sp_dmat_field_to_list(c_results.Beta), + intercepts=c_results.Intercept, + converged=c_results.Converged, + cv_means=dvec_field_to_list(c_results.CVMeans), + cv_sds=dvec_field_to_list(c_results.CVSDs)) + return results cdef fitmodel _L0LearnFit_dense(const dmat& X, diff --git a/python/l0learn/utils.py b/python/l0learn/utils.py new file mode 100644 index 0000000..0739b17 --- /dev/null +++ b/python/l0learn/utils.py @@ -0,0 +1,654 @@ +import warnings +from dataclasses import dataclass, field +from typing import List, Dict, Any, Optional, Tuple, Union + +import numpy as np +import pandas as pd +from matplotlib import pyplot as plt +from scipy.sparse import csc_matrix, vstack, hstack, find +from scipy.stats import multivariate_normal, binom + + +def regularization_loss(coeffs: csc_matrix, + l0: float = 0, + l1: float = 0, + l2: float = 0, + sum_all_paths: bool = True) -> Union[float, np.ndarray]: + if coeffs.ndim != 2: + raise NotImplementedError("expected coeffs to be a 2D array") + + if sum_all_paths or coeffs.shape[1] == 1: + _, _, values = find(coeffs) + loss = (l0 * len(values) + + l1 * sum(abs(values)) + + l2 * sum(values ** 2)) + else: # TODO: Implement this regularization loss better than a for loop over rows and cols! + rows, cols = coeffs.shape + loss = np.zeros(cols) + for col in range(cols): + loss[col] = regularization_loss(coeffs[:, col], l0=l0, l1=l1, l2=l2, sum_all_paths=True) + + return loss + + +def squared_error(y_true: np.ndarray, + y_pred: np.ndarray, + coeffs: Optional[csc_matrix] = None, + l0: float = 0, + l1: float = 0, + l2: float = 0, + sum_all_paths: bool = True) -> Union[float, np.ndarray]: + loss = 0 + if coeffs: + loss = regularization_loss(coeffs=coeffs, l0=l0, l1=l1, l2=l2, sum_all_paths=sum_all_paths) + + squared_residuals = 0.5 * np.square(y_true - y_pred) + if sum_all_paths: + return squared_residuals.sum() + loss + else: + return squared_residuals.sum(axis=0) + loss + + +def logistic_loss(y_true: np.ndarray, + y_pred: np.ndarray, + coeffs: Optional[csc_matrix] = None, + l0: float = 0, + l1: float = 0, + l2: float = 0, + sum_all_paths: bool = True) -> Union[float, np.ndarray]: + # TODO: Check this formula. If there is an error here, there might be an error in the C++ code for Logistic. + + loss = 0 + if coeffs: + loss += regularization_loss(coeffs=coeffs, l0=l0, l1=l1, l2=l2, sum_all_paths=sum_all_paths) + + # C++ Src Code: + # ExpyXB = arma::exp(this->y % (*(this->X) * this->B + this->b0)); + # return arma::sum(arma::log(1 + 1 / expyXB)) + regularization + + exp_y_XB = np.exp(y_true * np.log(y_pred)) + log_loss = np.log(1 + 1 / exp_y_XB) + + if sum_all_paths: + return log_loss.sum() + loss + else: + return log_loss.sum(axis=0) + loss + + +def squared_hinge_loss(y_true: np.ndarray, + y_pred: np.ndarray, + coeffs: Optional[csc_matrix] = None, + l0: float = 0, + l1: float = 0, + l2: float = 0, + sum_all_paths: bool = True) -> Union[float, np.ndarray]: + # TODO: Check this formula. If there is an error here, there might be an error in the C++ code for Logistic. + + loss = 0 + if coeffs: + loss += regularization_loss(coeffs=coeffs, l0=l0, l1=l1, l2=l2, sum_all_paths=sum_all_paths) + + # C++ Src Code: + # onemyxb = 1 - this->y % (*(this->X) * this->B + this->b0); + # arma::uvec indices = arma::find(onemyxb > 0); + # return arma::sum(onemyxb.elem(indices) % onemyxb.elem(indices)) + this->lambda0 * n_nonzero( + # B) + this->lambda1 * arma::norm(B, 1) + this->lambda2 * l2norm * l2norm; + + square_one_minus_y_XB = np.square(np.max(1 - y_true * y_pred, 0)) + if sum_all_paths: + return square_one_minus_y_XB.sum() + loss + else: + return square_one_minus_y_XB.sum(axis=0) + loss + + +@dataclass(frozen=True, repr=False) +class FitModel: + settings: Dict[str, Any] + lambda_0: List[List[float]] = field(repr=False) + gamma: List[float] = field(repr=False) + support_size: List[List[int]] = field(repr=False) + coeffs: List[csc_matrix] = field(repr=False) + intercepts: List[List[float]] = field(repr=False) + converged: List[List[bool]] = field(repr=False) + + def characteristics_as_pandas_table(self, new_data: Optional[Tuple[List[float], + List[List[float]], + List[List[int]], + List[List[float]], + List[List[bool]]]] = None) -> pd.DataFrame: + if new_data is not None: + gamma, lambda_0, support_size, intercepts, converged = new_data + else: + gamma, lambda_0, support_size, intercepts, converged = (self.gamma, + self.lambda_0, + self.support_size, + self.intercepts, + self.converged) + tables = [] + for gamma, lambda_sequence, support_sequence, intercept_sequence, converged_sequence in zip(gamma, + lambda_0, + support_size, + intercepts, + converged): + + data = {'l0': lambda_sequence, + 'support_size': support_sequence, + 'intercept': intercept_sequence, + 'converged': converged_sequence} + + if len(self.settings['penalty']) > 2: + data[self.settings['penalty'][2:].lower()] = [gamma] * len(lambda_sequence) + + tables.append(pd.DataFrame(data)) + + return pd.concat(tables).reset_index(drop=True) + + def _repr_html_(self): + return self.characteristics_as_pandas_table()._repr_html_() + + def __repr__(self) -> str: + return f"{self.__class__.__name__}({self.settings})" + + def coeff(self, + lambda_0: Optional[float] = None, + gamma: Optional[float] = None, + include_intercept: bool = True) -> csc_matrix: + """ Extracts the coefficient according to lambda_0 and gamma + + If both lambda_0 and gamma are not supplied, then a matrix of coefficients for all the solutions in the + regularization path is returned. + + If lambda_0 is supplied but gamma is not, the smallest value of gamma is used. + + If gamma is supplied but not lambda_0, then a matrix of coefficients for all the solutions in the + regularization path for gamma is returned. + + Parameters + ---------- + lambda_0 : float, optional + gamma : float, optional + include_intercept : bool, default True + + Returns + ------- + coeff: csc_matrix + + """ + if gamma is None: + if lambda_0 is None: + # Return all solutions + solutions = hstack(self.coeffs) + intercepts = [[intercept for intercept_list in self.intercepts for intercept in intercept_list]] + else: + # Return solution with closest lambda in first gamma + return self.coeff(gamma=self.gamma[0], + lambda_0=lambda_0, + include_intercept=include_intercept) + else: + gamma_index = int(np.argmin(np.abs(np.asarray(self.gamma) - gamma))) + if lambda_0 is None: + # Return all solutions for specific gamma + solutions = self.coeffs[gamma_index] + intercepts = [self.intercepts[gamma_index]] + else: + # Return solution with closest lambda in gamma_index + lambda_index = int(np.argmin(np.abs(np.asarray(self.lambda_0[gamma_index]) - lambda_0))) + solutions = self.coeffs[gamma_index][:, lambda_index] + intercepts = [self.intercepts[gamma_index][lambda_index]] + + if include_intercept: + solutions = vstack([intercepts[0], solutions]) + + return solutions + + def characteristics(self, + lambda_0: Optional[float] = None, + gamma: Optional[float] = None, + include_intercept: bool = True) -> pd.DataFrame: + + if gamma is None: + if lambda_0 is None: + # Return all solutions + intercepts = [[intercept for intercept_list in self.intercepts for intercept in intercept_list]] + lambda_0 = self.lambda_0 + gamma = self.gamma + support_size = self.support_size + converged = self.converged + else: + # Return solution with closest lambda in first gamma + return self.characteristics(gamma=self.gamma[0], + lambda_0=lambda_0, + include_intercept=include_intercept) + else: + gamma_index = int(np.argmin(np.abs(np.asarray(self.gamma) - gamma))) + if lambda_0 is None: + # Return all solutions for specific gamma + intercepts = [self.intercepts[gamma_index]] + lambda_0 = [self.lambda_0[gamma_index]] + gamma = [self.gamma[gamma_index]] + support_size = [self.support_size[gamma_index]] + converged = [self.converged[gamma_index]] + else: + # Return solution with closest lambda in gamma_index + lambda_index = int(np.argmin(np.abs(np.asarray(self.lambda_0[gamma_index]) - lambda_0))) + intercepts = [self.intercepts[gamma_index][lambda_index]] + lambda_0 = [self.lambda_0[gamma_index][lambda_index]] + gamma = [self.gamma[gamma_index]] + support_size = [self.support_size[gamma_index][lambda_index]] + converged = [self.converged[gamma_index][lambda_index]] + + return self.characteristics_as_pandas_table(new_data=(gamma, lambda_0, support_size, intercepts, converged)) + + def plot(self, gamma: float = 0, show_lines: bool = False, **kwargs): + """ Plots the regularization path for a given gamma. + + Parameters + ---------- + gamma : float + The value of gamma at which to plot + show_lines : bool + If True, the lines connecting the points in the plot are shown. + kwargs : dict of str to any + Key Word arguments passed to matplotlib.pyplot + + Notes + ----- + If the solutions with the same support size exist in a regularization path, the first support size is plotted. + + Returns + ------- + ax : matplotlib.axes._subplots.AxesSubplot + """ + + gamma_to_plot = self.coeff(gamma=gamma, include_intercept=False) + p = gamma_to_plot.shape[1] + + # Find what coeffs are seen in regularization path. Skip later solutions + seen_supports = set() + seen_coeffs = set() + for col in range(p): + rows, cols, values = find(gamma_to_plot[:, col]) + support_size = len(rows) + if support_size in seen_supports or not support_size: + warnings.warn(f"Duplicate solution seen at support size {support_size}. Plotting only first solution") + continue + seen_coeffs.update(rows) + + # For each coefficient seen in regularization path, record value of each coefficient over + seen_coeffs = list(sorted(seen_coeffs)) + coef_value_over_path = gamma_to_plot[seen_coeffs, :].toarray() + path_support_size = (gamma_to_plot != 0).sum(axis=0).T + + f, ax = plt.subplots(**kwargs) + + if show_lines: + linestyle = kwargs.pop("linestyle", "_.") + else: + linestyle = kwargs.pop("linestyle", "None") + + marker = kwargs.pop("marker", "o") + + for i, coeff in enumerate(seen_coeffs): + ax.plot(path_support_size, coef_value_over_path[i, :], label=coeff, linestyle=linestyle, marker=marker) + + plt.ylabel("Coefficient Value") + plt.xlabel("Support Size") + + return ax + + def score(self, + x: np.ndarray, + y: np.ndarray, + lambda_0: Optional[float] = None, + gamma: Optional[float] = None, + training: bool = False, + include_characteristics: bool = False) -> Union[pd.DataFrame, np.ndarray]: + """ + + Parameters + ---------- + x + y + lambda_0 + gamma + + Returns + ------- + + """ + predictions = self.predict(x=x, lambda_0=lambda_0, gamma=gamma) + characteristics = self.characteristics(lambda_0=lambda_0, gamma=gamma) + + if training: + coeffs = self.coeff(lambda_0=lambda_0, gamma=gamma) + l0 = characteristics.get('l0') + l1 = characteristics.get('l1') + l2 = characteristics.get('l2') + else: + coeffs = None + l0 = 0 + l1 = 0 + l2 = 0 + + if self.settings['loss'] == "SquaredError": + score = squared_error(y_true=y, y_pred=predictions, coeffs=coeffs, l0=l0, l1=l1, l2=l2, + sum_all_paths=False) + elif self.settings['loss'] == "Logistic": + score = logistic_loss(y_true=y, y_pred=predictions, coeffs=coeffs, l0=l0, l1=l1, l2=l2, + sum_all_paths=False) + else: + score = squared_hinge_loss(y_true=y, y_pred=predictions, coeffs=coeffs, l0=l0, l1=l1, l2=l2, + sum_all_paths=False) + + if include_characteristics: + characteristics[self.settings['loss']] = score + return characteristics + else: + return score + + def predict(self, + x: np.ndarray, + lambda_0: Optional[float] = None, + gamma: Optional[float] = None) -> np.ndarray: + """ Predicts the response for a given sample. + + Parameters + ---------- + x: array-like + An array of feature observations on which predictions are made. + X should have shape (N, P). Intercept terms will be added by the predict function is specified during + original training. + lambda_0 : float, optional + Which lambda_0 value to use for predictions + + See FitModel.coeff for details on lambda_0 specifications + gamma : float, optional + Which gamma value to use for predictions + + See FitModel.coeff for details on gamma specifications + Returns + ------- + predictions : np.ndarray + Predictions of the response vector given x. + + For logistic regression (loss specified as "Logistic"), values are non-threshold + + When multiple coeffs are specified due to the settings of lambda_0 and gamma the prediction array is still + as expected with: + + predictions[i, j] (row i, column j) refers to predicted response for observation i using coefficients from + solution j. + """ + coeffs = self.coeff(lambda_0=lambda_0, + gamma=gamma, + include_intercept=self.settings['intercept']) + + n = x.shape[0] + if self.settings['intercept']: + x = np.hstack([np.ones((n, 1)), x]) + + activations = x@coeffs + + if self.settings['loss'] == "Logistic": + return 1 / (1 + np.exp(-activations)) + else: + return activations + + +@dataclass(frozen=True, repr=False) +class CVFitModel(FitModel): + cv_means: List[np.ndarray] = field(repr=False) + cv_sds: List[np.ndarray] = field(repr=False) + + def cv_plot(self, gamma: float = 0, **kwargs): + """ + Plot the cross-validation errors for a given gamma. + + Parameters + ---------- + gamma : float + The value of gamma at which to plot + kwargs + Key Word arguments passed to matplotlib.pyplot + Returns + ------- + ax : matplotlib.axes._subplots.AxesSubplot + """ + gamma_index = int(np.argmin(np.abs(np.asarray(self.gamma) - gamma))) + f, ax = plt.subplots(**kwargs) + + plt.errorbar(x=self.support_size[gamma_index], + y=self.cv_means[gamma_index], + yerr=self.cv_sds[gamma_index], ) + + plt.ylabel("Cross-Validation Error") + plt.xlabel("Support Size") + + return ax + + +def gen_synthetic(n: int, + p: int, + k: int, + seed: Optional[int] = None, + rho: float = 0, + b0: float = 0, + snr: float = 1 + ) -> Dict[str, Union[float, np.ndarray]]: + """ + Generates a synthetic dataset as follows: + 1) Sample every element in data matrix X from N(0,1). + 2) Generate a vector B with the first k entries set to 1 and the rest are zeros. + 3) Sample every element in the noise vector e from N(0,A) where A is selected so y, X, B have snr as specified. + 4) Set y = XB + b0 + e. + + Parameters + ---------- + n : int + Number of samples + p : int + Number of features + k : int + Number of non-zeros in true vector of coefficients + seed : int, optional + The seed used for randomly generating the data + If None, numbers will be random + rho : float, default 0. + The threshold for setting X values to 0. if |X[i, j]| < rho => X[i, j] <- 0 + b0 : float, default 0 + The intercept value to translate y by. + snr : float, default 1 + Desired Signal-to-Noise ratio. This sets the magnitude of the error term 'e'. + + Note: SNR is defined as SNR = Var(XB)/Var(e) + + Returns + ------- + Data: Dict + A dict containing: + the data matrix X, + the response vector y, + the coefficients B, + the error vector e, + the intercept term b0. + + Examples + -------- + >>>data = gen_synthetic(n=500,p=1000,k=10,seed=1) + """ + + # TODO: Don't re-seed generator. https://numpy.org/doc/stable/reference/random/generated/numpy.random.seed.html + np.random.seed(seed) + + X = np.random.normal(size=(n, p)) + X[abs(X) < rho] = 0 + B = np.zeros(p) + B[0:k] = 1 + + if snr == float("Inf"): + sd_e = 0 + else: + sd_e = np.sqrt(np.var(X @ B) / snr) + + e = np.random.normal(n, scale=sd_e) + y = X @ B + e + b0 + return {"X": X, "y": y, "B": B, "e": e, "b0": b0} + + +def cor_matrix(p: int, base_cor: float): + if not (0 < base_cor < 1): + raise ValueError(f"Expected base_cor to be a float between 0 and 1 exclusively, but got {base_cor}") + + cor_mat = base_cor * np.ones((p, p)) + pow_mat = abs(np.arange(p) - np.arange(p).reshape(-1, 1)) + + return np.power(cor_mat, pow_mat) + + +def gen_synthetic_high_corr(n: int, + p: int, + k: int, + seed: Optional[int] = None, + rho: float = 0, + b0: float = 0, + snr: float = 1, + mu: float = 0, + base_cor: float = 0.8, + ) -> Dict[str, Union[float, np.ndarray]]: + """ + Generates a synthetic dataset as follows: + 1) Generate a correlation matrix, SIG, where item [i, j] = base_core^|i-j|. + 2) Draw from a Multivariate Normal Distribution using (mu and SIG) to generate X. + 3) Generate a vector B with every ~p/k entry set to 1 and the rest are zeros. + 4) Sample every element in the noise vector e from N(0,A) where A is selected so y, X, B have snr as specified. + 5) Set y = XB + b0 + e. + + Parameters + ---------- + n : int + Number of samples + p : int + Number of features + k : int + Number of non-zeros in true vector of coefficients + seed : int + The seed used for randomly generating the data + rho : float + The threshold for setting values to 0. if |X(i, j)| < rho => X(i, j) <- 0 + b0 : float + intercept value to scale y by. + snr : float + desired Signal-to-Noise ratio. This sets the magnitude of the error term 'e'. + SNR is defined as SNR = Var(XB)/Var(e) + mu : float + The mean for drawing from the Multivariate Normal Distribution. A scalar of vector of length p. + base_cor : float + The base correlation, A in [i, j] = A^|i-j|. + + Returns + ------- + data : dict + A dict containing: + the data matrix X, + the response vector y, + the coefficients B, + the error vector e, + the intercept term b0. + + Examples + -------- + >>>gen_synthetic_high_corr(n=500,p=1000,k=10,seed=1) + + """ + # TODO: Don't re-seed generator. https://numpy.org/doc/stable/reference/random/generated/numpy.random.seed.html + np.random.seed(seed) + + cor = cor_matrix(p, base_cor) + X = multivariate_normal(n, mu, cor) + + X[abs(X) < rho] = 0. + + B = np.zeros(p) + for i in np.round(np.linspace(start=0, stop=p, num=k)).astype(int): + B[i] = 1 + + if snr == float("inf"): + sd_e = 0 + else: + sd_e = np.sqrt(np.var(X @ B) / snr) + + e = np.random.normal(n, scale=sd_e) + y = X @ B + e + b0 + + return {"X": X, "y": y, "B": B, "e": e, "b0": b0} + + +def gen_synthetic_logistic(n: int, + p: int, + k: int, + seed: Optional[int] = None, + rho: float = 0, + b0: float = 0, + s: float = 1, + mu: Optional[float] = None, + base_cor: Optional[float] = None, + ) -> Dict[str, Union[float, np.ndarray]]: + """ + Generates a synthetic dataset as follows: + 1) Generate a data matrix, X, drawn from either N(0, 1) (see gen_synthetic) or a multivariate_normal(mu, sigma) + (See gen_synthetic_high_corr) + gen_synthetic_logistic delegates these caluclations to the respective functions. + 2) Generate a vector B with k entries set to 1 and the rest are zeros. + 3) Every coordinate yi of the outcome vector y exists in {0, 1}^n is sampled independently from a Bernoulli + distribution with success probability: + P(yi = 1|xi) = 1/(1 + exp(-s)) + Source https://arxiv.org/pdf/2001.06471.pdf Section 5.1 Data Generation + + Parameters + ---------- + n : int + Number of samples + p : int + Number of features + k : int + Number of non-zeros in true vector of coefficients + seed : int + The seed used for randomly generating the data + rho : float + The threshold for setting values to 0. if |X(i, j)| > rho => X(i, j) <- 0 + b0 : float + The intercept value to scale the log odds of y by. + As b0 -> +inf, y will contain more 1s + As b0 -> -inf, y will contain more 0s + s : float + Signal-to-noise parameter. As s -> +Inf, the data generated becomes linearly separable. + mu : float, optional + The mean for drawing from the Multivariate Normal Distribution. A scalar of vector of length p. + If mu and base_cor are not specified, will be drawn from N(0, 1) using gen_synthetic. + If mu and base_cor are specified will be drawn from multivariate_normal(mu, sigma) see gen_synthetic_high_corr + base_cor + The base correlation, A in [i, j] = A^|i-j|. + If mu and base_cor are not specified, will be drawn from N(0, 1) + If mu and base_cor are specified will be drawn from multivariate_normal(mu, sigma) see gen_synthetic_high_corr + Returns + ------- + data : dict + A dict containing: + the data matrix X + the response vector y, + the coefficients B, + the intercept term b0. + + """ + if mu is None and base_cor is None: + data = gen_synthetic(n=n, p=p, k=k, seed=seed, rho=rho, b0=b0, snr=float("Inf")) + else: + data = gen_synthetic_high_corr(n=n, p=p, k=k, seed=seed, rho=rho, b0=b0, snr=float("Inf"), mu=mu, + base_cor=base_cor) + + y = binom.rvs(1, 1 / (1 + np.exp(-s * data["X"] @ data['B'])), size=n) + + data['y'] = y + del data['e'] + + return data diff --git a/python/tests/test_utils.py b/python/tests/test_utils.py new file mode 100644 index 0000000..27f9acd --- /dev/null +++ b/python/tests/test_utils.py @@ -0,0 +1,58 @@ +import numpy as np +from scipy.sparse import csc_matrix + +from l0learn.utils import FitModel + +from pytest import fixture + + +@fixture +def sample_FitModel(): + gamma = [2, 1, 0] + lambda_0 = [[10, 5], [10], [10, 5, 0]] + intercepts = [[-1, -2], [-3], [-4, -5, -6]] + beta1 = csc_matrix([[0, 0], + [1, 2]]) + beta2 = csc_matrix([[0], + [3]]) + beta3 = csc_matrix([[0, 0, 0], + [4, 5, 6]]) + + return FitModel(lambda_0=lambda_0, + gamma=gamma, + support_size=[[0]], + coeffs=[beta1, beta2, beta3], + intercepts=intercepts, + converged=[[True]]) + + +def test_FitModel_coeff(sample_FitModel): + np.testing.assert_array_equal(sample_FitModel.coeff().toarray(), np.array([[-1, -2, -3, -4, -5, -6], + [0, 0, 0, 0, 0, 0], + [1, 2, 3, 4, 5, 6]])) + np.testing.assert_array_equal(sample_FitModel.coeff(include_intercept=False).toarray(), + np.array([[0, 0, 0, 0, 0, 0], + [1, 2, 3, 4, 5, 6]])) + + np.testing.assert_array_equal(sample_FitModel.coeff(gamma=1).toarray(), np.array([[-3, ], + [0, ], + [3, ]])) + np.testing.assert_array_equal(sample_FitModel.coeff(gamma=1, include_intercept=False).toarray(), + np.array([[0, ], + [3, ]])) + + np.testing.assert_array_equal(sample_FitModel.coeff(lambda_0=6).toarray(), np.array([[-2, ], + [0, ], + [2, ]])) + + np.testing.assert_array_equal(sample_FitModel.coeff(lambda_0=6, include_intercept=False).toarray(), + np.array([[0, ], + [2, ]])) + + np.testing.assert_array_equal(sample_FitModel.coeff(gamma=0, lambda_0=6).toarray(), np.array([[-5, ], + [0, ], + [5, ]])) + + np.testing.assert_array_equal(sample_FitModel.coeff(gamma=0, lambda_0=6, include_intercept=False).toarray(), + np.array([[0, ], + [5, ]])) From f402e2ede8feaadcc8c63ae9d22cfc4aeb9e2676 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Sat, 25 Sep 2021 16:01:36 -0500 Subject: [PATCH 007/125] miscellaneous changes and fixes --- python/README.md | 0 python/Untitled.ipynb | 62 + python/l0learn/cyarma.cpp | 743 +++---- python/l0learn/cyarma.pyx | 12 +- python/l0learn/interface.cpp | 2720 ++++++++++++------------ python/l0learn/interface.pyx | 2 +- python/l0learn/{utils.py => models.py} | 204 +- python/l0learn/testing_utils.cpp | 324 +-- python/l0learn/testing_utils.pyx | 8 +- python/pyproject.toml | 9 + python/setup.py | 110 +- python/sparse.ipynb | 254 +++ python/tests/test_cyarma.py | 8 +- python/tests/test_models.py | 160 ++ python/tests/test_utils.py | 58 - 15 files changed, 2571 insertions(+), 2103 deletions(-) create mode 100644 python/README.md create mode 100644 python/Untitled.ipynb rename python/l0learn/{utils.py => models.py} (79%) create mode 100644 python/pyproject.toml create mode 100644 python/sparse.ipynb create mode 100644 python/tests/test_models.py delete mode 100644 python/tests/test_utils.py diff --git a/python/README.md b/python/README.md new file mode 100644 index 0000000..e69de29 diff --git a/python/Untitled.ipynb b/python/Untitled.ipynb new file mode 100644 index 0000000..cc7a5aa --- /dev/null +++ b/python/Untitled.ipynb @@ -0,0 +1,62 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "x = 5" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "ename": "AssertionError", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mAssertionError\u001b[0m: " + ] + } + ], + "source": [ + "assert x == 4" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.7" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/python/l0learn/cyarma.cpp b/python/l0learn/cyarma.cpp index 3843ec1..4e2dfce 100644 --- a/python/l0learn/cyarma.cpp +++ b/python/l0learn/cyarma.cpp @@ -1804,13 +1804,13 @@ static const char __pyx_k_astype[] = "astype"; static const char __pyx_k_double[] = "double"; static const char __pyx_k_import[] = "__import__"; static const char __pyx_k_indptr[] = "indptr"; -static const char __pyx_k_isreal[] = "isreal"; static const char __pyx_k_uint64[] = "uint64"; static const char __pyx_k_but_got[] = ", but got "; static const char __pyx_k_indices[] = "indices"; static const char __pyx_k_owndata[] = "owndata"; static const char __pyx_k_TypeError[] = "TypeError"; static const char __pyx_k_enumerate[] = "enumerate"; +static const char __pyx_k_isrealobj[] = "isrealobj"; static const char __pyx_k_ValueError[] = "ValueError"; static const char __pyx_k_csc_matrix[] = "csc_matrix"; static const char __pyx_k_ImportError[] = "ImportError"; @@ -1844,7 +1844,7 @@ static PyObject *__pyx_n_s_flags; static PyObject *__pyx_n_s_import; static PyObject *__pyx_n_s_indices; static PyObject *__pyx_n_s_indptr; -static PyObject *__pyx_n_s_isreal; +static PyObject *__pyx_n_s_isrealobj; static PyObject *__pyx_n_s_main; static PyObject *__pyx_n_s_name; static PyObject *__pyx_n_s_ndim; @@ -1865,9 +1865,9 @@ static PyObject *__pyx_tuple_; static PyObject *__pyx_tuple__2; /* Late includes */ -/* "l0learn/cyarma.pyx":86 - * +/* "l0learn/cyarma.pyx":87 * ##### Tools to convert numpy arrays to armadillo arrays ###### + * @cython.boundscheck(False) * cdef field[sp_dmat] list_to_sp_dmat_field(list values): # <<<<<<<<<<<<<< * cdef field[sp_dmat] f = field[sp_dmat](len(values)) * for i, value in enumerate(values): @@ -1893,25 +1893,25 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_fiel int __pyx_clineno = 0; __Pyx_RefNannySetupContext("list_to_sp_dmat_field", 0); - /* "l0learn/cyarma.pyx":87 - * ##### Tools to convert numpy arrays to armadillo arrays ###### + /* "l0learn/cyarma.pyx":88 + * @cython.boundscheck(False) * cdef field[sp_dmat] list_to_sp_dmat_field(list values): * cdef field[sp_dmat] f = field[sp_dmat](len(values)) # <<<<<<<<<<<<<< * for i, value in enumerate(values): - * if not isinstance(value, csc_matrix) or value.ndim != 2 or np.isreal(value): + * if not isinstance(value, csc_matrix) or value.ndim != 2 or not np.isrealobj(value): */ if (unlikely(__pyx_v_values == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(0, 87, __pyx_L1_error) + __PYX_ERR(0, 88, __pyx_L1_error) } - __pyx_t_1 = PyList_GET_SIZE(__pyx_v_values); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 87, __pyx_L1_error) + __pyx_t_1 = PyList_GET_SIZE(__pyx_v_values); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 88, __pyx_L1_error) __pyx_v_f = arma::field (__pyx_t_1); - /* "l0learn/cyarma.pyx":88 + /* "l0learn/cyarma.pyx":89 * cdef field[sp_dmat] list_to_sp_dmat_field(list values): * cdef field[sp_dmat] f = field[sp_dmat](len(values)) * for i, value in enumerate(values): # <<<<<<<<<<<<<< - * if not isinstance(value, csc_matrix) or value.ndim != 2 or np.isreal(value): + * if not isinstance(value, csc_matrix) or value.ndim != 2 or not np.isrealobj(value): * raise TypeError(f"expected each value in values to be a 2D real csc_matrix, but got {value}") */ __pyx_t_1 = 0; @@ -1919,9 +1919,9 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_fiel for (;;) { if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_4 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_4); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 88, __pyx_L1_error) + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_4); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 89, __pyx_L1_error) #else - __pyx_t_4 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 88, __pyx_L1_error) + __pyx_t_4 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 89, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #endif __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_4); @@ -1929,16 +1929,16 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_fiel __pyx_v_i = __pyx_t_1; __pyx_t_1 = (__pyx_t_1 + 1); - /* "l0learn/cyarma.pyx":89 + /* "l0learn/cyarma.pyx":90 * cdef field[sp_dmat] f = field[sp_dmat](len(values)) * for i, value in enumerate(values): - * if not isinstance(value, csc_matrix) or value.ndim != 2 or np.isreal(value): # <<<<<<<<<<<<<< + * if not isinstance(value, csc_matrix) or value.ndim != 2 or not np.isrealobj(value): # <<<<<<<<<<<<<< * raise TypeError(f"expected each value in values to be a 2D real csc_matrix, but got {value}") * f[i] = numpy_to_sp_dmat_d(value) */ - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 90, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_6 = PyObject_IsInstance(__pyx_v_value, __pyx_t_4); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 89, __pyx_L1_error) + __pyx_t_6 = PyObject_IsInstance(__pyx_v_value, __pyx_t_4); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 90, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_7 = ((!(__pyx_t_6 != 0)) != 0); if (!__pyx_t_7) { @@ -1946,21 +1946,21 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_fiel __pyx_t_5 = __pyx_t_7; goto __pyx_L6_bool_binop_done; } - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_value, __pyx_n_s_ndim); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 89, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_value, __pyx_n_s_ndim); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 90, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_8 = __Pyx_PyInt_NeObjC(__pyx_t_4, __pyx_int_2, 2, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 89, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_NeObjC(__pyx_t_4, __pyx_int_2, 2, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 90, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 89, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 90, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (!__pyx_t_7) { } else { __pyx_t_5 = __pyx_t_7; goto __pyx_L6_bool_binop_done; } - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 90, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_isreal); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 89, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 90, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; @@ -1975,45 +1975,46 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_fiel } __pyx_t_8 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_4, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_v_value); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 89, __pyx_L1_error) + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 90, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 89, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 90, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_5 = __pyx_t_7; + __pyx_t_6 = ((!__pyx_t_7) != 0); + __pyx_t_5 = __pyx_t_6; __pyx_L6_bool_binop_done:; if (unlikely(__pyx_t_5)) { - /* "l0learn/cyarma.pyx":90 + /* "l0learn/cyarma.pyx":91 * for i, value in enumerate(values): - * if not isinstance(value, csc_matrix) or value.ndim != 2 or np.isreal(value): + * if not isinstance(value, csc_matrix) or value.ndim != 2 or not np.isrealobj(value): * raise TypeError(f"expected each value in values to be a 2D real csc_matrix, but got {value}") # <<<<<<<<<<<<<< * f[i] = numpy_to_sp_dmat_d(value) * return f */ - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_value, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 90, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_value, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 91, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_9 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_each_value_in_values_to, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 90, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_each_value_in_values_to, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 91, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 90, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 91, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 90, __pyx_L1_error) + __PYX_ERR(0, 91, __pyx_L1_error) - /* "l0learn/cyarma.pyx":89 + /* "l0learn/cyarma.pyx":90 * cdef field[sp_dmat] f = field[sp_dmat](len(values)) * for i, value in enumerate(values): - * if not isinstance(value, csc_matrix) or value.ndim != 2 or np.isreal(value): # <<<<<<<<<<<<<< + * if not isinstance(value, csc_matrix) or value.ndim != 2 or not np.isrealobj(value): # <<<<<<<<<<<<<< * raise TypeError(f"expected each value in values to be a 2D real csc_matrix, but got {value}") * f[i] = numpy_to_sp_dmat_d(value) */ } - /* "l0learn/cyarma.pyx":91 - * if not isinstance(value, csc_matrix) or value.ndim != 2 or np.isreal(value): + /* "l0learn/cyarma.pyx":92 + * if not isinstance(value, csc_matrix) or value.ndim != 2 or not np.isrealobj(value): * raise TypeError(f"expected each value in values to be a 2D real csc_matrix, but got {value}") * f[i] = numpy_to_sp_dmat_d(value) # <<<<<<<<<<<<<< * return f @@ -2021,29 +2022,29 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_fiel */ (__pyx_v_f[__pyx_v_i]) = __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(__pyx_v_value); - /* "l0learn/cyarma.pyx":88 + /* "l0learn/cyarma.pyx":89 * cdef field[sp_dmat] list_to_sp_dmat_field(list values): * cdef field[sp_dmat] f = field[sp_dmat](len(values)) * for i, value in enumerate(values): # <<<<<<<<<<<<<< - * if not isinstance(value, csc_matrix) or value.ndim != 2 or np.isreal(value): + * if not isinstance(value, csc_matrix) or value.ndim != 2 or not np.isrealobj(value): * raise TypeError(f"expected each value in values to be a 2D real csc_matrix, but got {value}") */ } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "l0learn/cyarma.pyx":92 + /* "l0learn/cyarma.pyx":93 * raise TypeError(f"expected each value in values to be a 2D real csc_matrix, but got {value}") * f[i] = numpy_to_sp_dmat_d(value) * return f # <<<<<<<<<<<<<< * - * cdef field[dvec] list_to_dvec_field(list values): + * */ __pyx_r = __pyx_v_f; goto __pyx_L0; - /* "l0learn/cyarma.pyx":86 - * + /* "l0learn/cyarma.pyx":87 * ##### Tools to convert numpy arrays to armadillo arrays ###### + * @cython.boundscheck(False) * cdef field[sp_dmat] list_to_sp_dmat_field(list values): # <<<<<<<<<<<<<< * cdef field[sp_dmat] f = field[sp_dmat](len(values)) * for i, value in enumerate(values): @@ -2063,9 +2064,9 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_fiel return __pyx_r; } -/* "l0learn/cyarma.pyx":94 - * return f +/* "l0learn/cyarma.pyx":97 * + * @cython.boundscheck(False) * cdef field[dvec] list_to_dvec_field(list values): # <<<<<<<<<<<<<< * cdef field[dvec] f = field[dvec](len(values)) * for i, value in enumerate(values): @@ -2091,25 +2092,25 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_dvec_field(PyOb int __pyx_clineno = 0; __Pyx_RefNannySetupContext("list_to_dvec_field", 0); - /* "l0learn/cyarma.pyx":95 - * + /* "l0learn/cyarma.pyx":98 + * @cython.boundscheck(False) * cdef field[dvec] list_to_dvec_field(list values): * cdef field[dvec] f = field[dvec](len(values)) # <<<<<<<<<<<<<< * for i, value in enumerate(values): - * if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isreal(value): + * if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isrealobj(value): */ if (unlikely(__pyx_v_values == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(0, 95, __pyx_L1_error) + __PYX_ERR(0, 98, __pyx_L1_error) } - __pyx_t_1 = PyList_GET_SIZE(__pyx_v_values); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 95, __pyx_L1_error) + __pyx_t_1 = PyList_GET_SIZE(__pyx_v_values); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 98, __pyx_L1_error) __pyx_v_f = arma::field (__pyx_t_1); - /* "l0learn/cyarma.pyx":96 + /* "l0learn/cyarma.pyx":99 * cdef field[dvec] list_to_dvec_field(list values): * cdef field[dvec] f = field[dvec](len(values)) * for i, value in enumerate(values): # <<<<<<<<<<<<<< - * if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isreal(value): + * if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isrealobj(value): * raise TypeError(f"expected each value in values to be a 1D real numpy matrix, but got {value}") */ __pyx_t_1 = 0; @@ -2117,9 +2118,9 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_dvec_field(PyOb for (;;) { if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_4 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_4); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 96, __pyx_L1_error) + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_4); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 99, __pyx_L1_error) #else - __pyx_t_4 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 96, __pyx_L1_error) + __pyx_t_4 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 99, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #endif __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_4); @@ -2127,10 +2128,10 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_dvec_field(PyOb __pyx_v_i = __pyx_t_1; __pyx_t_1 = (__pyx_t_1 + 1); - /* "l0learn/cyarma.pyx":97 + /* "l0learn/cyarma.pyx":100 * cdef field[dvec] f = field[dvec](len(values)) * for i, value in enumerate(values): - * if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isreal(value): # <<<<<<<<<<<<<< + * if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isrealobj(value): # <<<<<<<<<<<<<< * raise TypeError(f"expected each value in values to be a 1D real numpy matrix, but got {value}") * f[i] = numpy_to_dvec_d(value) */ @@ -2141,21 +2142,21 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_dvec_field(PyOb __pyx_t_5 = __pyx_t_7; goto __pyx_L6_bool_binop_done; } - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_value, __pyx_n_s_ndim); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 97, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_value, __pyx_n_s_ndim); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 100, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_8 = __Pyx_PyInt_NeObjC(__pyx_t_4, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 97, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_NeObjC(__pyx_t_4, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 100, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 97, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 100, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (!__pyx_t_7) { } else { __pyx_t_5 = __pyx_t_7; goto __pyx_L6_bool_binop_done; } - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 100, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_isreal); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 97, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 100, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; @@ -2170,77 +2171,77 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_dvec_field(PyOb } __pyx_t_8 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_4, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_v_value); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 97, __pyx_L1_error) + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 100, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 97, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 100, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = ((!__pyx_t_7) != 0); __pyx_t_5 = __pyx_t_6; __pyx_L6_bool_binop_done:; if (unlikely(__pyx_t_5)) { - /* "l0learn/cyarma.pyx":98 + /* "l0learn/cyarma.pyx":101 * for i, value in enumerate(values): - * if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isreal(value): + * if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isrealobj(value): * raise TypeError(f"expected each value in values to be a 1D real numpy matrix, but got {value}") # <<<<<<<<<<<<<< * f[i] = numpy_to_dvec_d(value) * return f */ - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_value, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 98, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_value, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 101, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_9 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_each_value_in_values_to_2, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 98, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_each_value_in_values_to_2, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 101, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 98, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 101, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 98, __pyx_L1_error) + __PYX_ERR(0, 101, __pyx_L1_error) - /* "l0learn/cyarma.pyx":97 + /* "l0learn/cyarma.pyx":100 * cdef field[dvec] f = field[dvec](len(values)) * for i, value in enumerate(values): - * if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isreal(value): # <<<<<<<<<<<<<< + * if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isrealobj(value): # <<<<<<<<<<<<<< * raise TypeError(f"expected each value in values to be a 1D real numpy matrix, but got {value}") * f[i] = numpy_to_dvec_d(value) */ } - /* "l0learn/cyarma.pyx":99 - * if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isreal(value): + /* "l0learn/cyarma.pyx":102 + * if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isrealobj(value): * raise TypeError(f"expected each value in values to be a 1D real numpy matrix, but got {value}") * f[i] = numpy_to_dvec_d(value) # <<<<<<<<<<<<<< * return f * */ - if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 99, __pyx_L1_error) + if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 102, __pyx_L1_error) (__pyx_v_f[__pyx_v_i]) = __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_value)); - /* "l0learn/cyarma.pyx":96 + /* "l0learn/cyarma.pyx":99 * cdef field[dvec] list_to_dvec_field(list values): * cdef field[dvec] f = field[dvec](len(values)) * for i, value in enumerate(values): # <<<<<<<<<<<<<< - * if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isreal(value): + * if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isrealobj(value): * raise TypeError(f"expected each value in values to be a 1D real numpy matrix, but got {value}") */ } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "l0learn/cyarma.pyx":100 + /* "l0learn/cyarma.pyx":103 * raise TypeError(f"expected each value in values to be a 1D real numpy matrix, but got {value}") * f[i] = numpy_to_dvec_d(value) * return f # <<<<<<<<<<<<<< * - * cdef dmat * numpy_to_dmat(np.ndarray[np.double_t, ndim=2] X): + * */ __pyx_r = __pyx_v_f; goto __pyx_L0; - /* "l0learn/cyarma.pyx":94 - * return f + /* "l0learn/cyarma.pyx":97 * + * @cython.boundscheck(False) * cdef field[dvec] list_to_dvec_field(list values): # <<<<<<<<<<<<<< * cdef field[dvec] f = field[dvec](len(values)) * for i, value in enumerate(values): @@ -2260,8 +2261,8 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_dvec_field(PyOb return __pyx_r; } -/* "l0learn/cyarma.pyx":102 - * return f +/* "l0learn/cyarma.pyx":106 + * * * cdef dmat * numpy_to_dmat(np.ndarray[np.double_t, ndim=2] X): # <<<<<<<<<<<<<< * # TODO: Add checks on X (Size, ...) @@ -2295,58 +2296,58 @@ static arma::dmat *__pyx_f_7l0learn_6cyarma_numpy_to_dmat(PyArrayObject *__pyx_v __pyx_pybuffernd_X.rcbuffer = &__pyx_pybuffer_X; { __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_X.rcbuffer->pybuffer, (PyObject*)__pyx_v_X, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 102, __pyx_L1_error) + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_X.rcbuffer->pybuffer, (PyObject*)__pyx_v_X, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 106, __pyx_L1_error) } __pyx_pybuffernd_X.diminfo[0].strides = __pyx_pybuffernd_X.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_X.diminfo[0].shape = __pyx_pybuffernd_X.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_X.diminfo[1].strides = __pyx_pybuffernd_X.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_X.diminfo[1].shape = __pyx_pybuffernd_X.rcbuffer->pybuffer.shape[1]; - /* "l0learn/cyarma.pyx":107 + /* "l0learn/cyarma.pyx":111 * # mat(ptr_aux_mem, n_rows, n_cols, copy_aux_mem = true, strict = false) * # TODO: raise Warning on copy or replication of data * if not (X.flags.f_contiguous or X.flags.owndata): # <<<<<<<<<<<<<< * X = X.copy(order="F") * cdef dmat *aR_p = new dmat( X.data, X.shape[0], X.shape[1], False, True) */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_X), __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 107, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_X), __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 111, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_f_contiguous); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 107, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_f_contiguous); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 111, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 107, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 111, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (!__pyx_t_4) { } else { __pyx_t_1 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_X), __pyx_n_s_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 107, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_X), __pyx_n_s_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 111, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_owndata); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 107, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_owndata); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 111, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 107, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 111, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_1 = __pyx_t_4; __pyx_L4_bool_binop_done:; __pyx_t_4 = ((!__pyx_t_1) != 0); if (__pyx_t_4) { - /* "l0learn/cyarma.pyx":108 + /* "l0learn/cyarma.pyx":112 * # TODO: raise Warning on copy or replication of data * if not (X.flags.f_contiguous or X.flags.owndata): * X = X.copy(order="F") # <<<<<<<<<<<<<< * cdef dmat *aR_p = new dmat( X.data, X.shape[0], X.shape[1], False, True) * return aR_p */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_X), __pyx_n_s_copy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 108, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_X), __pyx_n_s_copy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 112, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 108, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 112, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_order, __pyx_n_u_F) < 0) __PYX_ERR(0, 108, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 108, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_order, __pyx_n_u_F) < 0) __PYX_ERR(0, 112, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 112, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 108, __pyx_L1_error) + if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 112, __pyx_L1_error) __pyx_t_6 = ((PyArrayObject *)__pyx_t_5); { __Pyx_BufFmt_StackElem __pyx_stack[1]; @@ -2363,13 +2364,13 @@ static arma::dmat *__pyx_f_7l0learn_6cyarma_numpy_to_dmat(PyArrayObject *__pyx_v __pyx_t_8 = __pyx_t_9 = __pyx_t_10 = 0; } __pyx_pybuffernd_X.diminfo[0].strides = __pyx_pybuffernd_X.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_X.diminfo[0].shape = __pyx_pybuffernd_X.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_X.diminfo[1].strides = __pyx_pybuffernd_X.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_X.diminfo[1].shape = __pyx_pybuffernd_X.rcbuffer->pybuffer.shape[1]; - if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 108, __pyx_L1_error) + if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 112, __pyx_L1_error) } __pyx_t_6 = 0; __Pyx_DECREF_SET(__pyx_v_X, ((PyArrayObject *)__pyx_t_5)); __pyx_t_5 = 0; - /* "l0learn/cyarma.pyx":107 + /* "l0learn/cyarma.pyx":111 * # mat(ptr_aux_mem, n_rows, n_cols, copy_aux_mem = true, strict = false) * # TODO: raise Warning on copy or replication of data * if not (X.flags.f_contiguous or X.flags.owndata): # <<<<<<<<<<<<<< @@ -2378,7 +2379,7 @@ static arma::dmat *__pyx_f_7l0learn_6cyarma_numpy_to_dmat(PyArrayObject *__pyx_v */ } - /* "l0learn/cyarma.pyx":109 + /* "l0learn/cyarma.pyx":113 * if not (X.flags.f_contiguous or X.flags.owndata): * X = X.copy(order="F") * cdef dmat *aR_p = new dmat( X.data, X.shape[0], X.shape[1], False, True) # <<<<<<<<<<<<<< @@ -2387,7 +2388,7 @@ static arma::dmat *__pyx_f_7l0learn_6cyarma_numpy_to_dmat(PyArrayObject *__pyx_v */ __pyx_v_aR_p = new arma::dmat(((double *)__pyx_v_X->data), (__pyx_v_X->dimensions[0]), (__pyx_v_X->dimensions[1]), 0, 1); - /* "l0learn/cyarma.pyx":110 + /* "l0learn/cyarma.pyx":114 * X = X.copy(order="F") * cdef dmat *aR_p = new dmat( X.data, X.shape[0], X.shape[1], False, True) * return aR_p # <<<<<<<<<<<<<< @@ -2397,8 +2398,8 @@ static arma::dmat *__pyx_f_7l0learn_6cyarma_numpy_to_dmat(PyArrayObject *__pyx_v __pyx_r = __pyx_v_aR_p; goto __pyx_L0; - /* "l0learn/cyarma.pyx":102 - * return f + /* "l0learn/cyarma.pyx":106 + * * * cdef dmat * numpy_to_dmat(np.ndarray[np.double_t, ndim=2] X): # <<<<<<<<<<<<<< * # TODO: Add checks on X (Size, ...) @@ -2427,7 +2428,7 @@ static arma::dmat *__pyx_f_7l0learn_6cyarma_numpy_to_dmat(PyArrayObject *__pyx_v return __pyx_r; } -/* "l0learn/cyarma.pyx":112 +/* "l0learn/cyarma.pyx":116 * return aR_p * * cdef dmat numpy_to_dmat_d(np.ndarray[np.double_t, ndim=2] X): # <<<<<<<<<<<<<< @@ -2452,11 +2453,11 @@ static arma::dmat __pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(PyArrayObject *__pyx_ __pyx_pybuffernd_X.rcbuffer = &__pyx_pybuffer_X; { __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_X.rcbuffer->pybuffer, (PyObject*)__pyx_v_X, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 112, __pyx_L1_error) + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_X.rcbuffer->pybuffer, (PyObject*)__pyx_v_X, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 116, __pyx_L1_error) } __pyx_pybuffernd_X.diminfo[0].strides = __pyx_pybuffernd_X.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_X.diminfo[0].shape = __pyx_pybuffernd_X.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_X.diminfo[1].strides = __pyx_pybuffernd_X.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_X.diminfo[1].shape = __pyx_pybuffernd_X.rcbuffer->pybuffer.shape[1]; - /* "l0learn/cyarma.pyx":113 + /* "l0learn/cyarma.pyx":117 * * cdef dmat numpy_to_dmat_d(np.ndarray[np.double_t, ndim=2] X): * cdef dmat * aR_p = numpy_to_dmat(X) # <<<<<<<<<<<<<< @@ -2465,7 +2466,7 @@ static arma::dmat __pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(PyArrayObject *__pyx_ */ __pyx_v_aR_p = __pyx_f_7l0learn_6cyarma_numpy_to_dmat(((PyArrayObject *)__pyx_v_X)); - /* "l0learn/cyarma.pyx":114 + /* "l0learn/cyarma.pyx":118 * cdef dmat numpy_to_dmat_d(np.ndarray[np.double_t, ndim=2] X): * cdef dmat * aR_p = numpy_to_dmat(X) * cdef dmat aR = deref(aR_p) # <<<<<<<<<<<<<< @@ -2474,7 +2475,7 @@ static arma::dmat __pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(PyArrayObject *__pyx_ */ __pyx_v_aR = (*__pyx_v_aR_p); - /* "l0learn/cyarma.pyx":115 + /* "l0learn/cyarma.pyx":119 * cdef dmat * aR_p = numpy_to_dmat(X) * cdef dmat aR = deref(aR_p) * del aR_p # <<<<<<<<<<<<<< @@ -2483,7 +2484,7 @@ static arma::dmat __pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(PyArrayObject *__pyx_ */ delete __pyx_v_aR_p; - /* "l0learn/cyarma.pyx":116 + /* "l0learn/cyarma.pyx":120 * cdef dmat aR = deref(aR_p) * del aR_p * return aR # <<<<<<<<<<<<<< @@ -2493,7 +2494,7 @@ static arma::dmat __pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(PyArrayObject *__pyx_ __pyx_r = __pyx_v_aR; goto __pyx_L0; - /* "l0learn/cyarma.pyx":112 + /* "l0learn/cyarma.pyx":116 * return aR_p * * cdef dmat numpy_to_dmat_d(np.ndarray[np.double_t, ndim=2] X): # <<<<<<<<<<<<<< @@ -2519,7 +2520,7 @@ static arma::dmat __pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(PyArrayObject *__pyx_ return __pyx_r; } -/* "l0learn/cyarma.pyx":118 +/* "l0learn/cyarma.pyx":122 * return aR * * cdef dvec * numpy_to_dvec(np.ndarray[np.double_t, ndim=1] x): # <<<<<<<<<<<<<< @@ -2554,49 +2555,49 @@ static arma::dvec *__pyx_f_7l0learn_6cyarma_numpy_to_dvec(PyArrayObject *__pyx_v __pyx_pybuffernd_x.rcbuffer = &__pyx_pybuffer_x; { __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_v_x, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 118, __pyx_L1_error) + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_v_x, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 122, __pyx_L1_error) } __pyx_pybuffernd_x.diminfo[0].strides = __pyx_pybuffernd_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x.diminfo[0].shape = __pyx_pybuffernd_x.rcbuffer->pybuffer.shape[0]; - /* "l0learn/cyarma.pyx":119 + /* "l0learn/cyarma.pyx":123 * * cdef dvec * numpy_to_dvec(np.ndarray[np.double_t, ndim=1] x): * if not (x.flags.f_contiguous or x.flags.owndata): # <<<<<<<<<<<<<< * x = x.copy() * cdef dvec *ar_p = new dvec( x.data, x.shape[0], False, True) */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_x), __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 119, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_x), __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_f_contiguous); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 119, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_f_contiguous); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 119, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (!__pyx_t_4) { } else { __pyx_t_1 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_x), __pyx_n_s_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 119, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_x), __pyx_n_s_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_owndata); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 119, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_owndata); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 119, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_1 = __pyx_t_4; __pyx_L4_bool_binop_done:; __pyx_t_4 = ((!__pyx_t_1) != 0); if (__pyx_t_4) { - /* "l0learn/cyarma.pyx":120 + /* "l0learn/cyarma.pyx":124 * cdef dvec * numpy_to_dvec(np.ndarray[np.double_t, ndim=1] x): * if not (x.flags.f_contiguous or x.flags.owndata): * x = x.copy() # <<<<<<<<<<<<<< * cdef dvec *ar_p = new dvec( x.data, x.shape[0], False, True) * return ar_p */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_x), __pyx_n_s_copy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 120, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_x), __pyx_n_s_copy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 124, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { @@ -2610,10 +2611,10 @@ static arma::dvec *__pyx_f_7l0learn_6cyarma_numpy_to_dvec(PyArrayObject *__pyx_v } __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 120, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 124, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 120, __pyx_L1_error) + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 124, __pyx_L1_error) __pyx_t_6 = ((PyArrayObject *)__pyx_t_2); { __Pyx_BufFmt_StackElem __pyx_stack[1]; @@ -2630,13 +2631,13 @@ static arma::dvec *__pyx_f_7l0learn_6cyarma_numpy_to_dvec(PyArrayObject *__pyx_v __pyx_t_8 = __pyx_t_9 = __pyx_t_10 = 0; } __pyx_pybuffernd_x.diminfo[0].strides = __pyx_pybuffernd_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x.diminfo[0].shape = __pyx_pybuffernd_x.rcbuffer->pybuffer.shape[0]; - if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 120, __pyx_L1_error) + if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 124, __pyx_L1_error) } __pyx_t_6 = 0; __Pyx_DECREF_SET(__pyx_v_x, ((PyArrayObject *)__pyx_t_2)); __pyx_t_2 = 0; - /* "l0learn/cyarma.pyx":119 + /* "l0learn/cyarma.pyx":123 * * cdef dvec * numpy_to_dvec(np.ndarray[np.double_t, ndim=1] x): * if not (x.flags.f_contiguous or x.flags.owndata): # <<<<<<<<<<<<<< @@ -2645,7 +2646,7 @@ static arma::dvec *__pyx_f_7l0learn_6cyarma_numpy_to_dvec(PyArrayObject *__pyx_v */ } - /* "l0learn/cyarma.pyx":121 + /* "l0learn/cyarma.pyx":125 * if not (x.flags.f_contiguous or x.flags.owndata): * x = x.copy() * cdef dvec *ar_p = new dvec( x.data, x.shape[0], False, True) # <<<<<<<<<<<<<< @@ -2654,7 +2655,7 @@ static arma::dvec *__pyx_f_7l0learn_6cyarma_numpy_to_dvec(PyArrayObject *__pyx_v */ __pyx_v_ar_p = new arma::dvec(((double *)__pyx_v_x->data), (__pyx_v_x->dimensions[0]), 0, 1); - /* "l0learn/cyarma.pyx":122 + /* "l0learn/cyarma.pyx":126 * x = x.copy() * cdef dvec *ar_p = new dvec( x.data, x.shape[0], False, True) * return ar_p # <<<<<<<<<<<<<< @@ -2664,7 +2665,7 @@ static arma::dvec *__pyx_f_7l0learn_6cyarma_numpy_to_dvec(PyArrayObject *__pyx_v __pyx_r = __pyx_v_ar_p; goto __pyx_L0; - /* "l0learn/cyarma.pyx":118 + /* "l0learn/cyarma.pyx":122 * return aR * * cdef dvec * numpy_to_dvec(np.ndarray[np.double_t, ndim=1] x): # <<<<<<<<<<<<<< @@ -2694,7 +2695,7 @@ static arma::dvec *__pyx_f_7l0learn_6cyarma_numpy_to_dvec(PyArrayObject *__pyx_v return __pyx_r; } -/* "l0learn/cyarma.pyx":124 +/* "l0learn/cyarma.pyx":128 * return ar_p * * cdef dvec numpy_to_dvec_d(np.ndarray[np.double_t, ndim=1] x): # <<<<<<<<<<<<<< @@ -2719,11 +2720,11 @@ static arma::dvec __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(PyArrayObject *__pyx_ __pyx_pybuffernd_x.rcbuffer = &__pyx_pybuffer_x; { __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_v_x, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 124, __pyx_L1_error) + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_v_x, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 128, __pyx_L1_error) } __pyx_pybuffernd_x.diminfo[0].strides = __pyx_pybuffernd_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x.diminfo[0].shape = __pyx_pybuffernd_x.rcbuffer->pybuffer.shape[0]; - /* "l0learn/cyarma.pyx":125 + /* "l0learn/cyarma.pyx":129 * * cdef dvec numpy_to_dvec_d(np.ndarray[np.double_t, ndim=1] x): * cdef dvec *ar_p = numpy_to_dvec(x) # <<<<<<<<<<<<<< @@ -2732,7 +2733,7 @@ static arma::dvec __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(PyArrayObject *__pyx_ */ __pyx_v_ar_p = __pyx_f_7l0learn_6cyarma_numpy_to_dvec(((PyArrayObject *)__pyx_v_x)); - /* "l0learn/cyarma.pyx":126 + /* "l0learn/cyarma.pyx":130 * cdef dvec numpy_to_dvec_d(np.ndarray[np.double_t, ndim=1] x): * cdef dvec *ar_p = numpy_to_dvec(x) * cdef dvec ar = deref(ar_p) # <<<<<<<<<<<<<< @@ -2741,7 +2742,7 @@ static arma::dvec __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(PyArrayObject *__pyx_ */ __pyx_v_ar = (*__pyx_v_ar_p); - /* "l0learn/cyarma.pyx":127 + /* "l0learn/cyarma.pyx":131 * cdef dvec *ar_p = numpy_to_dvec(x) * cdef dvec ar = deref(ar_p) * del ar_p # <<<<<<<<<<<<<< @@ -2750,7 +2751,7 @@ static arma::dvec __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(PyArrayObject *__pyx_ */ delete __pyx_v_ar_p; - /* "l0learn/cyarma.pyx":128 + /* "l0learn/cyarma.pyx":132 * cdef dvec ar = deref(ar_p) * del ar_p * return ar # <<<<<<<<<<<<<< @@ -2760,7 +2761,7 @@ static arma::dvec __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(PyArrayObject *__pyx_ __pyx_r = __pyx_v_ar; goto __pyx_L0; - /* "l0learn/cyarma.pyx":124 + /* "l0learn/cyarma.pyx":128 * return ar_p * * cdef dvec numpy_to_dvec_d(np.ndarray[np.double_t, ndim=1] x): # <<<<<<<<<<<<<< @@ -2786,7 +2787,7 @@ static arma::dvec __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(PyArrayObject *__pyx_ return __pyx_r; } -/* "l0learn/cyarma.pyx":130 +/* "l0learn/cyarma.pyx":134 * return ar * * cdef uvec * numpy_to_uvec(np.ndarray[np.uint64_t, ndim=1] x): # <<<<<<<<<<<<<< @@ -2821,49 +2822,49 @@ static arma::uvec *__pyx_f_7l0learn_6cyarma_numpy_to_uvec(PyArrayObject *__pyx_v __pyx_pybuffernd_x.rcbuffer = &__pyx_pybuffer_x; { __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_v_x, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 130, __pyx_L1_error) + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_v_x, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 134, __pyx_L1_error) } __pyx_pybuffernd_x.diminfo[0].strides = __pyx_pybuffernd_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x.diminfo[0].shape = __pyx_pybuffernd_x.rcbuffer->pybuffer.shape[0]; - /* "l0learn/cyarma.pyx":131 + /* "l0learn/cyarma.pyx":135 * * cdef uvec * numpy_to_uvec(np.ndarray[np.uint64_t, ndim=1] x): * if not (x.flags.f_contiguous or x.flags.owndata): # <<<<<<<<<<<<<< * x = x.copy() * cdef uvec *ar_p = new uvec( x.data, x.shape[0], False, True) */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_x), __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 131, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_x), __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 135, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_f_contiguous); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 131, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_f_contiguous); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 135, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 131, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 135, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (!__pyx_t_4) { } else { __pyx_t_1 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_x), __pyx_n_s_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 131, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_x), __pyx_n_s_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 135, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_owndata); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 131, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_owndata); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 135, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 131, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 135, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_1 = __pyx_t_4; __pyx_L4_bool_binop_done:; __pyx_t_4 = ((!__pyx_t_1) != 0); if (__pyx_t_4) { - /* "l0learn/cyarma.pyx":132 + /* "l0learn/cyarma.pyx":136 * cdef uvec * numpy_to_uvec(np.ndarray[np.uint64_t, ndim=1] x): * if not (x.flags.f_contiguous or x.flags.owndata): * x = x.copy() # <<<<<<<<<<<<<< * cdef uvec *ar_p = new uvec( x.data, x.shape[0], False, True) * return ar_p */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_x), __pyx_n_s_copy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 132, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_x), __pyx_n_s_copy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 136, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { @@ -2877,10 +2878,10 @@ static arma::uvec *__pyx_f_7l0learn_6cyarma_numpy_to_uvec(PyArrayObject *__pyx_v } __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 132, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 132, __pyx_L1_error) + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 136, __pyx_L1_error) __pyx_t_6 = ((PyArrayObject *)__pyx_t_2); { __Pyx_BufFmt_StackElem __pyx_stack[1]; @@ -2897,13 +2898,13 @@ static arma::uvec *__pyx_f_7l0learn_6cyarma_numpy_to_uvec(PyArrayObject *__pyx_v __pyx_t_8 = __pyx_t_9 = __pyx_t_10 = 0; } __pyx_pybuffernd_x.diminfo[0].strides = __pyx_pybuffernd_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x.diminfo[0].shape = __pyx_pybuffernd_x.rcbuffer->pybuffer.shape[0]; - if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 132, __pyx_L1_error) + if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 136, __pyx_L1_error) } __pyx_t_6 = 0; __Pyx_DECREF_SET(__pyx_v_x, ((PyArrayObject *)__pyx_t_2)); __pyx_t_2 = 0; - /* "l0learn/cyarma.pyx":131 + /* "l0learn/cyarma.pyx":135 * * cdef uvec * numpy_to_uvec(np.ndarray[np.uint64_t, ndim=1] x): * if not (x.flags.f_contiguous or x.flags.owndata): # <<<<<<<<<<<<<< @@ -2912,7 +2913,7 @@ static arma::uvec *__pyx_f_7l0learn_6cyarma_numpy_to_uvec(PyArrayObject *__pyx_v */ } - /* "l0learn/cyarma.pyx":133 + /* "l0learn/cyarma.pyx":137 * if not (x.flags.f_contiguous or x.flags.owndata): * x = x.copy() * cdef uvec *ar_p = new uvec( x.data, x.shape[0], False, True) # <<<<<<<<<<<<<< @@ -2921,7 +2922,7 @@ static arma::uvec *__pyx_f_7l0learn_6cyarma_numpy_to_uvec(PyArrayObject *__pyx_v */ __pyx_v_ar_p = new arma::uvec(((unsigned PY_LONG_LONG *)__pyx_v_x->data), (__pyx_v_x->dimensions[0]), 0, 1); - /* "l0learn/cyarma.pyx":134 + /* "l0learn/cyarma.pyx":138 * x = x.copy() * cdef uvec *ar_p = new uvec( x.data, x.shape[0], False, True) * return ar_p # <<<<<<<<<<<<<< @@ -2931,7 +2932,7 @@ static arma::uvec *__pyx_f_7l0learn_6cyarma_numpy_to_uvec(PyArrayObject *__pyx_v __pyx_r = __pyx_v_ar_p; goto __pyx_L0; - /* "l0learn/cyarma.pyx":130 + /* "l0learn/cyarma.pyx":134 * return ar * * cdef uvec * numpy_to_uvec(np.ndarray[np.uint64_t, ndim=1] x): # <<<<<<<<<<<<<< @@ -2961,7 +2962,7 @@ static arma::uvec *__pyx_f_7l0learn_6cyarma_numpy_to_uvec(PyArrayObject *__pyx_v return __pyx_r; } -/* "l0learn/cyarma.pyx":136 +/* "l0learn/cyarma.pyx":140 * return ar_p * * cdef uvec numpy_to_uvec_d(np.ndarray[np.uint64_t, ndim=1] x): # <<<<<<<<<<<<<< @@ -2986,11 +2987,11 @@ static arma::uvec __pyx_f_7l0learn_6cyarma_numpy_to_uvec_d(PyArrayObject *__pyx_ __pyx_pybuffernd_x.rcbuffer = &__pyx_pybuffer_x; { __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_v_x, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 136, __pyx_L1_error) + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_v_x, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 140, __pyx_L1_error) } __pyx_pybuffernd_x.diminfo[0].strides = __pyx_pybuffernd_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x.diminfo[0].shape = __pyx_pybuffernd_x.rcbuffer->pybuffer.shape[0]; - /* "l0learn/cyarma.pyx":137 + /* "l0learn/cyarma.pyx":141 * * cdef uvec numpy_to_uvec_d(np.ndarray[np.uint64_t, ndim=1] x): * cdef uvec *ar_p = numpy_to_uvec(x) # <<<<<<<<<<<<<< @@ -2999,7 +3000,7 @@ static arma::uvec __pyx_f_7l0learn_6cyarma_numpy_to_uvec_d(PyArrayObject *__pyx_ */ __pyx_v_ar_p = __pyx_f_7l0learn_6cyarma_numpy_to_uvec(((PyArrayObject *)__pyx_v_x)); - /* "l0learn/cyarma.pyx":138 + /* "l0learn/cyarma.pyx":142 * cdef uvec numpy_to_uvec_d(np.ndarray[np.uint64_t, ndim=1] x): * cdef uvec *ar_p = numpy_to_uvec(x) * cdef uvec ar = deref(ar_p) # <<<<<<<<<<<<<< @@ -3008,7 +3009,7 @@ static arma::uvec __pyx_f_7l0learn_6cyarma_numpy_to_uvec_d(PyArrayObject *__pyx_ */ __pyx_v_ar = (*__pyx_v_ar_p); - /* "l0learn/cyarma.pyx":139 + /* "l0learn/cyarma.pyx":143 * cdef uvec *ar_p = numpy_to_uvec(x) * cdef uvec ar = deref(ar_p) * del ar_p # <<<<<<<<<<<<<< @@ -3017,17 +3018,17 @@ static arma::uvec __pyx_f_7l0learn_6cyarma_numpy_to_uvec_d(PyArrayObject *__pyx_ */ delete __pyx_v_ar_p; - /* "l0learn/cyarma.pyx":140 + /* "l0learn/cyarma.pyx":144 * cdef uvec ar = deref(ar_p) * del ar_p * return ar # <<<<<<<<<<<<<< * - * cdef sp_dmat * numpy_to_sp_dmat(x): + * */ __pyx_r = __pyx_v_ar; goto __pyx_L0; - /* "l0learn/cyarma.pyx":136 + /* "l0learn/cyarma.pyx":140 * return ar_p * * cdef uvec numpy_to_uvec_d(np.ndarray[np.uint64_t, ndim=1] x): # <<<<<<<<<<<<<< @@ -3053,8 +3054,8 @@ static arma::uvec __pyx_f_7l0learn_6cyarma_numpy_to_uvec_d(PyArrayObject *__pyx_ return __pyx_r; } -/* "l0learn/cyarma.pyx":142 - * return ar +/* "l0learn/cyarma.pyx":147 + * * * cdef sp_dmat * numpy_to_sp_dmat(x): # <<<<<<<<<<<<<< * if not isinstance(x, csc_matrix): @@ -3107,28 +3108,28 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ __pyx_pybuffernd_indices.data = NULL; __pyx_pybuffernd_indices.rcbuffer = &__pyx_pybuffer_indices; - /* "l0learn/cyarma.pyx":143 + /* "l0learn/cyarma.pyx":148 * * cdef sp_dmat * numpy_to_sp_dmat(x): * if not isinstance(x, csc_matrix): # <<<<<<<<<<<<<< * raise ValueError(f"expected x to be of type {csc_matrix}, but got {type(x)}") * */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 143, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 148, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyObject_IsInstance(__pyx_v_x, __pyx_t_1); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 143, __pyx_L1_error) + __pyx_t_2 = PyObject_IsInstance(__pyx_v_x, __pyx_t_1); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 148, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = ((!(__pyx_t_2 != 0)) != 0); if (unlikely(__pyx_t_3)) { - /* "l0learn/cyarma.pyx":144 + /* "l0learn/cyarma.pyx":149 * cdef sp_dmat * numpy_to_sp_dmat(x): * if not isinstance(x, csc_matrix): * raise ValueError(f"expected x to be of type {csc_matrix}, but got {type(x)}") # <<<<<<<<<<<<<< * * cdef np.ndarray[np.double_t, ndim=1] data = x.data */ - __pyx_t_1 = PyTuple_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 144, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 149, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = 0; __pyx_t_5 = 127; @@ -3136,9 +3137,9 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ __pyx_t_4 += 25; __Pyx_GIVEREF(__pyx_kp_u_expected_x_to_be_of_type); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_expected_x_to_be_of_type); - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 149, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_6, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 144, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_6, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 149, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_5 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_5) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_5; @@ -3150,24 +3151,24 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ __pyx_t_4 += 10; __Pyx_GIVEREF(__pyx_kp_u_but_got); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_but_got); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(((PyObject *)Py_TYPE(__pyx_v_x)), __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 144, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_FormatSimple(((PyObject *)Py_TYPE(__pyx_v_x)), __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 149, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_5 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_5) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_5; __pyx_t_4 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_1, 4, __pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 144, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_1, 4, __pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 149, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 144, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 149, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(0, 144, __pyx_L1_error) + __PYX_ERR(0, 149, __pyx_L1_error) - /* "l0learn/cyarma.pyx":143 + /* "l0learn/cyarma.pyx":148 * * cdef sp_dmat * numpy_to_sp_dmat(x): * if not isinstance(x, csc_matrix): # <<<<<<<<<<<<<< @@ -3176,22 +3177,22 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ */ } - /* "l0learn/cyarma.pyx":146 + /* "l0learn/cyarma.pyx":151 * raise ValueError(f"expected x to be of type {csc_matrix}, but got {type(x)}") * * cdef np.ndarray[np.double_t, ndim=1] data = x.data # <<<<<<<<<<<<<< * cdef dvec values = numpy_to_dvec_d(data) * */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 146, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 151, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 146, __pyx_L1_error) + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 151, __pyx_L1_error) __pyx_t_8 = ((PyArrayObject *)__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_data.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { __pyx_v_data = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_data.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 146, __pyx_L1_error) + __PYX_ERR(0, 151, __pyx_L1_error) } else {__pyx_pybuffernd_data.diminfo[0].strides = __pyx_pybuffernd_data.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_data.diminfo[0].shape = __pyx_pybuffernd_data.rcbuffer->pybuffer.shape[0]; } } @@ -3199,7 +3200,7 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ __pyx_v_data = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/cyarma.pyx":147 + /* "l0learn/cyarma.pyx":152 * * cdef np.ndarray[np.double_t, ndim=1] data = x.data * cdef dvec values = numpy_to_dvec_d(data) # <<<<<<<<<<<<<< @@ -3208,21 +3209,21 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ */ __pyx_v_values = __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_data)); - /* "l0learn/cyarma.pyx":149 + /* "l0learn/cyarma.pyx":154 * cdef dvec values = numpy_to_dvec_d(data) * * cdef np.ndarray[np.uint64_t, ndim=1] indptr = x.indptr.astype(np.uint64) # <<<<<<<<<<<<<< * cdef uvec colptr = numpy_to_uvec_d(indptr) * */ - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_indptr); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 149, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_indptr); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_astype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 149, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_astype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_uint64); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 149, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_uint64); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; @@ -3238,16 +3239,16 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ __pyx_t_1 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_t_9) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_9); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 149, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 149, __pyx_L1_error) + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 154, __pyx_L1_error) __pyx_t_10 = ((PyArrayObject *)__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_indptr.rcbuffer->pybuffer, (PyObject*)__pyx_t_10, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { __pyx_v_indptr = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_indptr.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 149, __pyx_L1_error) + __PYX_ERR(0, 154, __pyx_L1_error) } else {__pyx_pybuffernd_indptr.diminfo[0].strides = __pyx_pybuffernd_indptr.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_indptr.diminfo[0].shape = __pyx_pybuffernd_indptr.rcbuffer->pybuffer.shape[0]; } } @@ -3255,7 +3256,7 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ __pyx_v_indptr = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/cyarma.pyx":150 + /* "l0learn/cyarma.pyx":155 * * cdef np.ndarray[np.uint64_t, ndim=1] indptr = x.indptr.astype(np.uint64) * cdef uvec colptr = numpy_to_uvec_d(indptr) # <<<<<<<<<<<<<< @@ -3264,21 +3265,21 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ */ __pyx_v_colptr = __pyx_f_7l0learn_6cyarma_numpy_to_uvec_d(((PyArrayObject *)__pyx_v_indptr)); - /* "l0learn/cyarma.pyx":152 + /* "l0learn/cyarma.pyx":157 * cdef uvec colptr = numpy_to_uvec_d(indptr) * * cdef np.ndarray[np.uint64_t, ndim=1] indices = x.indices.astype(np.uint64) # <<<<<<<<<<<<<< * cdef uvec rowind = numpy_to_uvec_d(indices) * */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_indices); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 152, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_indices); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 157, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_astype); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 152, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_astype); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 157, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 152, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 157, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_uint64); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 152, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_uint64); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 157, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = NULL; @@ -3294,16 +3295,16 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ __pyx_t_1 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_6, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_7); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 152, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 157, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 152, __pyx_L1_error) + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 157, __pyx_L1_error) __pyx_t_11 = ((PyArrayObject *)__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_indices.rcbuffer->pybuffer, (PyObject*)__pyx_t_11, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { __pyx_v_indices = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_indices.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 152, __pyx_L1_error) + __PYX_ERR(0, 157, __pyx_L1_error) } else {__pyx_pybuffernd_indices.diminfo[0].strides = __pyx_pybuffernd_indices.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_indices.diminfo[0].shape = __pyx_pybuffernd_indices.rcbuffer->pybuffer.shape[0]; } } @@ -3311,7 +3312,7 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ __pyx_v_indices = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/cyarma.pyx":153 + /* "l0learn/cyarma.pyx":158 * * cdef np.ndarray[np.uint64_t, ndim=1] indices = x.indices.astype(np.uint64) * cdef uvec rowind = numpy_to_uvec_d(indices) # <<<<<<<<<<<<<< @@ -3320,41 +3321,41 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ */ __pyx_v_rowind = __pyx_f_7l0learn_6cyarma_numpy_to_uvec_d(((PyArrayObject *)__pyx_v_indices)); - /* "l0learn/cyarma.pyx":155 + /* "l0learn/cyarma.pyx":160 * cdef uvec rowind = numpy_to_uvec_d(indices) * * cdef sp_dmat * ar = new sp_dmat(rowind, colptr, values, x.shape[0], x.shape[1]) # <<<<<<<<<<<<<< * * return ar */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 155, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 155, __pyx_L1_error) + __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 160, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_9); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 155, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_9); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 160, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_shape); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 155, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_shape); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 160, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_9, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 155, __pyx_L1_error) + __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_9, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_13 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_13 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 155, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_13 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 160, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_ar = new arma::sp_dmat(__pyx_v_rowind, __pyx_v_colptr, __pyx_v_values, __pyx_t_12, __pyx_t_13); - /* "l0learn/cyarma.pyx":157 + /* "l0learn/cyarma.pyx":162 * cdef sp_dmat * ar = new sp_dmat(rowind, colptr, values, x.shape[0], x.shape[1]) * * return ar # <<<<<<<<<<<<<< * - * cdef sp_dmat numpy_to_sp_dmat_d(x): + * */ __pyx_r = __pyx_v_ar; goto __pyx_L0; - /* "l0learn/cyarma.pyx":142 - * return ar + /* "l0learn/cyarma.pyx":147 + * * * cdef sp_dmat * numpy_to_sp_dmat(x): # <<<<<<<<<<<<<< * if not isinstance(x, csc_matrix): @@ -3390,8 +3391,8 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ return __pyx_r; } -/* "l0learn/cyarma.pyx":159 - * return ar +/* "l0learn/cyarma.pyx":165 + * * * cdef sp_dmat numpy_to_sp_dmat_d(x): # <<<<<<<<<<<<<< * cdef sp_dmat *ar_p = numpy_to_sp_dmat(x) @@ -3405,7 +3406,7 @@ static arma::sp_dmat __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(PyObject *__pyx __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("numpy_to_sp_dmat_d", 0); - /* "l0learn/cyarma.pyx":160 + /* "l0learn/cyarma.pyx":166 * * cdef sp_dmat numpy_to_sp_dmat_d(x): * cdef sp_dmat *ar_p = numpy_to_sp_dmat(x) # <<<<<<<<<<<<<< @@ -3414,7 +3415,7 @@ static arma::sp_dmat __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(PyObject *__pyx */ __pyx_v_ar_p = __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(__pyx_v_x); - /* "l0learn/cyarma.pyx":161 + /* "l0learn/cyarma.pyx":167 * cdef sp_dmat numpy_to_sp_dmat_d(x): * cdef sp_dmat *ar_p = numpy_to_sp_dmat(x) * cdef sp_dmat ar = deref(ar_p) # <<<<<<<<<<<<<< @@ -3423,7 +3424,7 @@ static arma::sp_dmat __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(PyObject *__pyx */ __pyx_v_ar = (*__pyx_v_ar_p); - /* "l0learn/cyarma.pyx":162 + /* "l0learn/cyarma.pyx":168 * cdef sp_dmat *ar_p = numpy_to_sp_dmat(x) * cdef sp_dmat ar = deref(ar_p) * del ar_p # <<<<<<<<<<<<<< @@ -3432,7 +3433,7 @@ static arma::sp_dmat __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(PyObject *__pyx */ delete __pyx_v_ar_p; - /* "l0learn/cyarma.pyx":163 + /* "l0learn/cyarma.pyx":169 * cdef sp_dmat ar = deref(ar_p) * del ar_p * return ar # <<<<<<<<<<<<<< @@ -3442,8 +3443,8 @@ static arma::sp_dmat __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(PyObject *__pyx __pyx_r = __pyx_v_ar; goto __pyx_L0; - /* "l0learn/cyarma.pyx":159 - * return ar + /* "l0learn/cyarma.pyx":165 + * * * cdef sp_dmat numpy_to_sp_dmat_d(x): # <<<<<<<<<<<<<< * cdef sp_dmat *ar_p = numpy_to_sp_dmat(x) @@ -3456,7 +3457,7 @@ static arma::sp_dmat __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(PyObject *__pyx return __pyx_r; } -/* "l0learn/cyarma.pyx":170 +/* "l0learn/cyarma.pyx":177 * * @cython.boundscheck(False) * cdef list sp_dmat_field_to_list(field[sp_dmat] f): # <<<<<<<<<<<<<< @@ -3479,19 +3480,19 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(arma::fieldpybuffer, (PyObject*)__pyx_v_D, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 184, __pyx_L1_error) + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_D.rcbuffer->pybuffer, (PyObject*)__pyx_v_D, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 192, __pyx_L1_error) } __pyx_pybuffernd_D.diminfo[0].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_D.diminfo[0].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_D.diminfo[1].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_D.diminfo[1].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[1]; - /* "l0learn/cyarma.pyx":186 + /* "l0learn/cyarma.pyx":194 * cdef np.ndarray[np.double_t, ndim=2] dmat_to_numpy(const dmat & X, np.ndarray[np.double_t, ndim=2] D): * # TODO: Check order of X and D * cdef const double * Xptr = X.memptr() # <<<<<<<<<<<<<< @@ -3694,7 +3695,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dmat_to_numpy(arma::dmat const &_ */ __pyx_v_Xptr = __pyx_v_X.memptr(); - /* "l0learn/cyarma.pyx":188 + /* "l0learn/cyarma.pyx":196 * cdef const double * Xptr = X.memptr() * * if D is None: # <<<<<<<<<<<<<< @@ -3705,23 +3706,23 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dmat_to_numpy(arma::dmat const &_ __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "l0learn/cyarma.pyx":189 + /* "l0learn/cyarma.pyx":197 * * if D is None: * D = np.empty((X.n_rows, X.n_cols), dtype=np.double, order="F") # <<<<<<<<<<<<<< * cdef double * Dptr = D.data * for i in range(X.n_rows*X.n_cols): */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 189, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_X.n_rows); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 189, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_X.n_rows); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_X.n_cols); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 189, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_X.n_cols); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 189, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3); @@ -3729,27 +3730,27 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dmat_to_numpy(arma::dmat const &_ PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_5); __pyx_t_3 = 0; __pyx_t_5 = 0; - __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 189, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 189, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_double); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 189, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_double); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_7) < 0) __PYX_ERR(0, 189, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_7) < 0) __PYX_ERR(0, 197, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_order, __pyx_n_u_F) < 0) __PYX_ERR(0, 189, __pyx_L1_error) - __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 189, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_order, __pyx_n_u_F) < 0) __PYX_ERR(0, 197, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (!(likely(((__pyx_t_7) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_7, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 189, __pyx_L1_error) + if (!(likely(((__pyx_t_7) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_7, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 197, __pyx_L1_error) __pyx_t_8 = ((PyArrayObject *)__pyx_t_7); { __Pyx_BufFmt_StackElem __pyx_stack[1]; @@ -3766,13 +3767,13 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dmat_to_numpy(arma::dmat const &_ __pyx_t_10 = __pyx_t_11 = __pyx_t_12 = 0; } __pyx_pybuffernd_D.diminfo[0].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_D.diminfo[0].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_D.diminfo[1].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_D.diminfo[1].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[1]; - if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 189, __pyx_L1_error) + if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 197, __pyx_L1_error) } __pyx_t_8 = 0; __Pyx_DECREF_SET(__pyx_v_D, ((PyArrayObject *)__pyx_t_7)); __pyx_t_7 = 0; - /* "l0learn/cyarma.pyx":188 + /* "l0learn/cyarma.pyx":196 * cdef const double * Xptr = X.memptr() * * if D is None: # <<<<<<<<<<<<<< @@ -3781,7 +3782,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dmat_to_numpy(arma::dmat const &_ */ } - /* "l0learn/cyarma.pyx":190 + /* "l0learn/cyarma.pyx":198 * if D is None: * D = np.empty((X.n_rows, X.n_cols), dtype=np.double, order="F") * cdef double * Dptr = D.data # <<<<<<<<<<<<<< @@ -3790,7 +3791,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dmat_to_numpy(arma::dmat const &_ */ __pyx_v_Dptr = ((double *)__pyx_v_D->data); - /* "l0learn/cyarma.pyx":191 + /* "l0learn/cyarma.pyx":199 * D = np.empty((X.n_rows, X.n_cols), dtype=np.double, order="F") * cdef double * Dptr = D.data * for i in range(X.n_rows*X.n_cols): # <<<<<<<<<<<<<< @@ -3802,7 +3803,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dmat_to_numpy(arma::dmat const &_ for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { __pyx_v_i = __pyx_t_14; - /* "l0learn/cyarma.pyx":192 + /* "l0learn/cyarma.pyx":200 * cdef double * Dptr = D.data * for i in range(X.n_rows*X.n_cols): * Dptr[i] = Xptr[i] # <<<<<<<<<<<<<< @@ -3812,7 +3813,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dmat_to_numpy(arma::dmat const &_ (__pyx_v_Dptr[__pyx_v_i]) = (__pyx_v_Xptr[__pyx_v_i]); } - /* "l0learn/cyarma.pyx":193 + /* "l0learn/cyarma.pyx":201 * for i in range(X.n_rows*X.n_cols): * Dptr[i] = Xptr[i] * return D # <<<<<<<<<<<<<< @@ -3824,7 +3825,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dmat_to_numpy(arma::dmat const &_ __pyx_r = ((PyArrayObject *)__pyx_v_D); goto __pyx_L0; - /* "l0learn/cyarma.pyx":184 + /* "l0learn/cyarma.pyx":192 * * @cython.boundscheck(False) * cdef np.ndarray[np.double_t, ndim=2] dmat_to_numpy(const dmat & X, np.ndarray[np.double_t, ndim=2] D): # <<<<<<<<<<<<<< @@ -3857,7 +3858,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dmat_to_numpy(arma::dmat const &_ return __pyx_r; } -/* "l0learn/cyarma.pyx":196 +/* "l0learn/cyarma.pyx":204 * * @cython.boundscheck(False) * cdef np.ndarray[np.double_t, ndim=1] dvec_to_numpy(const dvec & X, np.ndarray[np.double_t, ndim=1] D): # <<<<<<<<<<<<<< @@ -3898,11 +3899,11 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &_ __pyx_pybuffernd_D.rcbuffer = &__pyx_pybuffer_D; { __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_D.rcbuffer->pybuffer, (PyObject*)__pyx_v_D, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 196, __pyx_L1_error) + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_D.rcbuffer->pybuffer, (PyObject*)__pyx_v_D, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 204, __pyx_L1_error) } __pyx_pybuffernd_D.diminfo[0].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_D.diminfo[0].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[0]; - /* "l0learn/cyarma.pyx":197 + /* "l0learn/cyarma.pyx":205 * @cython.boundscheck(False) * cdef np.ndarray[np.double_t, ndim=1] dvec_to_numpy(const dvec & X, np.ndarray[np.double_t, ndim=1] D): * cdef const double * Xptr = X.memptr() # <<<<<<<<<<<<<< @@ -3911,7 +3912,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &_ */ __pyx_v_Xptr = __pyx_v_X.memptr(); - /* "l0learn/cyarma.pyx":199 + /* "l0learn/cyarma.pyx":207 * cdef const double * Xptr = X.memptr() * * if D is None: # <<<<<<<<<<<<<< @@ -3922,40 +3923,40 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &_ __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "l0learn/cyarma.pyx":200 + /* "l0learn/cyarma.pyx":208 * * if D is None: * D = np.empty(X.n_elem, dtype=np.double) # <<<<<<<<<<<<<< * cdef double * Dptr = D.data * for i in range(X.n_elem): */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 208, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 200, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 208, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_X.n_elem); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 200, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_X.n_elem); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 208, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 200, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 208, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 200, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 208, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 208, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_double); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 200, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_double); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 208, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_7) < 0) __PYX_ERR(0, 200, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_7) < 0) __PYX_ERR(0, 208, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 200, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 208, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (!(likely(((__pyx_t_7) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_7, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 200, __pyx_L1_error) + if (!(likely(((__pyx_t_7) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_7, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 208, __pyx_L1_error) __pyx_t_8 = ((PyArrayObject *)__pyx_t_7); { __Pyx_BufFmt_StackElem __pyx_stack[1]; @@ -3972,13 +3973,13 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &_ __pyx_t_10 = __pyx_t_11 = __pyx_t_12 = 0; } __pyx_pybuffernd_D.diminfo[0].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_D.diminfo[0].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[0]; - if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 200, __pyx_L1_error) + if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 208, __pyx_L1_error) } __pyx_t_8 = 0; __Pyx_DECREF_SET(__pyx_v_D, ((PyArrayObject *)__pyx_t_7)); __pyx_t_7 = 0; - /* "l0learn/cyarma.pyx":199 + /* "l0learn/cyarma.pyx":207 * cdef const double * Xptr = X.memptr() * * if D is None: # <<<<<<<<<<<<<< @@ -3987,7 +3988,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &_ */ } - /* "l0learn/cyarma.pyx":201 + /* "l0learn/cyarma.pyx":209 * if D is None: * D = np.empty(X.n_elem, dtype=np.double) * cdef double * Dptr = D.data # <<<<<<<<<<<<<< @@ -3996,7 +3997,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &_ */ __pyx_v_Dptr = ((double *)__pyx_v_D->data); - /* "l0learn/cyarma.pyx":202 + /* "l0learn/cyarma.pyx":210 * D = np.empty(X.n_elem, dtype=np.double) * cdef double * Dptr = D.data * for i in range(X.n_elem): # <<<<<<<<<<<<<< @@ -4008,7 +4009,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &_ for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { __pyx_v_i = __pyx_t_14; - /* "l0learn/cyarma.pyx":203 + /* "l0learn/cyarma.pyx":211 * cdef double * Dptr = D.data * for i in range(X.n_elem): * Dptr[i] = Xptr[i] # <<<<<<<<<<<<<< @@ -4018,7 +4019,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &_ (__pyx_v_Dptr[__pyx_v_i]) = (__pyx_v_Xptr[__pyx_v_i]); } - /* "l0learn/cyarma.pyx":204 + /* "l0learn/cyarma.pyx":212 * for i in range(X.n_elem): * Dptr[i] = Xptr[i] * return D # <<<<<<<<<<<<<< @@ -4030,7 +4031,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &_ __pyx_r = ((PyArrayObject *)__pyx_v_D); goto __pyx_L0; - /* "l0learn/cyarma.pyx":196 + /* "l0learn/cyarma.pyx":204 * * @cython.boundscheck(False) * cdef np.ndarray[np.double_t, ndim=1] dvec_to_numpy(const dvec & X, np.ndarray[np.double_t, ndim=1] D): # <<<<<<<<<<<<<< @@ -4063,7 +4064,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &_ return __pyx_r; } -/* "l0learn/cyarma.pyx":208 +/* "l0learn/cyarma.pyx":216 * * @cython.boundscheck(False) * cdef np.ndarray[np.uint64_t, ndim=1] uvec_to_numpy(const uvec & X, np.ndarray[np.uint64_t, ndim=1] D): # <<<<<<<<<<<<<< @@ -4104,11 +4105,11 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &_ __pyx_pybuffernd_D.rcbuffer = &__pyx_pybuffer_D; { __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_D.rcbuffer->pybuffer, (PyObject*)__pyx_v_D, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 208, __pyx_L1_error) + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_D.rcbuffer->pybuffer, (PyObject*)__pyx_v_D, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 216, __pyx_L1_error) } __pyx_pybuffernd_D.diminfo[0].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_D.diminfo[0].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[0]; - /* "l0learn/cyarma.pyx":209 + /* "l0learn/cyarma.pyx":217 * @cython.boundscheck(False) * cdef np.ndarray[np.uint64_t, ndim=1] uvec_to_numpy(const uvec & X, np.ndarray[np.uint64_t, ndim=1] D): * cdef const unsigned long long * Xptr = X.memptr() # <<<<<<<<<<<<<< @@ -4117,7 +4118,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &_ */ __pyx_v_Xptr = __pyx_v_X.memptr(); - /* "l0learn/cyarma.pyx":211 + /* "l0learn/cyarma.pyx":219 * cdef const unsigned long long * Xptr = X.memptr() * * if D is None: # <<<<<<<<<<<<<< @@ -4128,40 +4129,40 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &_ __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "l0learn/cyarma.pyx":212 + /* "l0learn/cyarma.pyx":220 * * if D is None: * D = np.empty(X.n_elem, dtype=np.uint64) # <<<<<<<<<<<<<< * cdef unsigned long long * Dptr = D.data * for i in range(X.n_elem): */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 212, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 212, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_X.n_elem); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 212, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_X.n_elem); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 212, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 212, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 212, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_uint64); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 212, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_uint64); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_7) < 0) __PYX_ERR(0, 212, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_7) < 0) __PYX_ERR(0, 220, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 212, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (!(likely(((__pyx_t_7) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_7, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 212, __pyx_L1_error) + if (!(likely(((__pyx_t_7) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_7, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 220, __pyx_L1_error) __pyx_t_8 = ((PyArrayObject *)__pyx_t_7); { __Pyx_BufFmt_StackElem __pyx_stack[1]; @@ -4178,13 +4179,13 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &_ __pyx_t_10 = __pyx_t_11 = __pyx_t_12 = 0; } __pyx_pybuffernd_D.diminfo[0].strides = __pyx_pybuffernd_D.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_D.diminfo[0].shape = __pyx_pybuffernd_D.rcbuffer->pybuffer.shape[0]; - if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 212, __pyx_L1_error) + if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 220, __pyx_L1_error) } __pyx_t_8 = 0; __Pyx_DECREF_SET(__pyx_v_D, ((PyArrayObject *)__pyx_t_7)); __pyx_t_7 = 0; - /* "l0learn/cyarma.pyx":211 + /* "l0learn/cyarma.pyx":219 * cdef const unsigned long long * Xptr = X.memptr() * * if D is None: # <<<<<<<<<<<<<< @@ -4193,7 +4194,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &_ */ } - /* "l0learn/cyarma.pyx":213 + /* "l0learn/cyarma.pyx":221 * if D is None: * D = np.empty(X.n_elem, dtype=np.uint64) * cdef unsigned long long * Dptr = D.data # <<<<<<<<<<<<<< @@ -4202,7 +4203,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &_ */ __pyx_v_Dptr = ((unsigned PY_LONG_LONG *)__pyx_v_D->data); - /* "l0learn/cyarma.pyx":214 + /* "l0learn/cyarma.pyx":222 * D = np.empty(X.n_elem, dtype=np.uint64) * cdef unsigned long long * Dptr = D.data * for i in range(X.n_elem): # <<<<<<<<<<<<<< @@ -4214,7 +4215,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &_ for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { __pyx_v_i = __pyx_t_14; - /* "l0learn/cyarma.pyx":215 + /* "l0learn/cyarma.pyx":223 * cdef unsigned long long * Dptr = D.data * for i in range(X.n_elem): * Dptr[i] = Xptr[i] # <<<<<<<<<<<<<< @@ -4224,7 +4225,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &_ (__pyx_v_Dptr[__pyx_v_i]) = (__pyx_v_Xptr[__pyx_v_i]); } - /* "l0learn/cyarma.pyx":216 + /* "l0learn/cyarma.pyx":224 * for i in range(X.n_elem): * Dptr[i] = Xptr[i] * return D # <<<<<<<<<<<<<< @@ -4236,7 +4237,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &_ __pyx_r = ((PyArrayObject *)__pyx_v_D); goto __pyx_L0; - /* "l0learn/cyarma.pyx":208 + /* "l0learn/cyarma.pyx":216 * * @cython.boundscheck(False) * cdef np.ndarray[np.uint64_t, ndim=1] uvec_to_numpy(const uvec & X, np.ndarray[np.uint64_t, ndim=1] D): # <<<<<<<<<<<<<< @@ -4269,7 +4270,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &_ return __pyx_r; } -/* "l0learn/cyarma.pyx":220 +/* "l0learn/cyarma.pyx":228 * * @cython.boundscheck(False) * cdef sp_dmat_to_numpy(const sp_dmat & X, np.ndarray[np.uint64_t, ndim=1] rowind, # <<<<<<<<<<<<<< @@ -4327,21 +4328,21 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & __pyx_pybuffernd_values.rcbuffer = &__pyx_pybuffer_values; { __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_rowind.rcbuffer->pybuffer, (PyObject*)__pyx_v_rowind, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 220, __pyx_L1_error) + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_rowind.rcbuffer->pybuffer, (PyObject*)__pyx_v_rowind, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 228, __pyx_L1_error) } __pyx_pybuffernd_rowind.diminfo[0].strides = __pyx_pybuffernd_rowind.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_rowind.diminfo[0].shape = __pyx_pybuffernd_rowind.rcbuffer->pybuffer.shape[0]; { __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_colind.rcbuffer->pybuffer, (PyObject*)__pyx_v_colind, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 220, __pyx_L1_error) + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_colind.rcbuffer->pybuffer, (PyObject*)__pyx_v_colind, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 228, __pyx_L1_error) } __pyx_pybuffernd_colind.diminfo[0].strides = __pyx_pybuffernd_colind.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_colind.diminfo[0].shape = __pyx_pybuffernd_colind.rcbuffer->pybuffer.shape[0]; { __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_values.rcbuffer->pybuffer, (PyObject*)__pyx_v_values, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 220, __pyx_L1_error) + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_values.rcbuffer->pybuffer, (PyObject*)__pyx_v_values, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 228, __pyx_L1_error) } __pyx_pybuffernd_values.diminfo[0].strides = __pyx_pybuffernd_values.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_values.diminfo[0].shape = __pyx_pybuffernd_values.rcbuffer->pybuffer.shape[0]; - /* "l0learn/cyarma.pyx":223 + /* "l0learn/cyarma.pyx":231 * np.ndarray[np.uint64_t, ndim=1] colind, np.ndarray[np.double_t, ndim=1] values): * # TODO: Check order of X and D * if rowind is None: # <<<<<<<<<<<<<< @@ -4352,40 +4353,40 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "l0learn/cyarma.pyx":224 + /* "l0learn/cyarma.pyx":232 * # TODO: Check order of X and D * if rowind is None: * rowind = np.empty(X.n_nonzero, dtype=np.uint64) # <<<<<<<<<<<<<< * if colind is None: * colind = np.empty(X.n_nonzero, dtype=np.uint64) */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 232, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 224, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 232, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_X.n_nonzero); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 224, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_X.n_nonzero); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 232, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 224, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 232, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 224, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 232, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 232, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_uint64); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 224, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_uint64); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 232, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_7) < 0) __PYX_ERR(0, 224, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_7) < 0) __PYX_ERR(0, 232, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 224, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 232, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (!(likely(((__pyx_t_7) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_7, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 224, __pyx_L1_error) + if (!(likely(((__pyx_t_7) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_7, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 232, __pyx_L1_error) __pyx_t_8 = ((PyArrayObject *)__pyx_t_7); { __Pyx_BufFmt_StackElem __pyx_stack[1]; @@ -4402,13 +4403,13 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & __pyx_t_10 = __pyx_t_11 = __pyx_t_12 = 0; } __pyx_pybuffernd_rowind.diminfo[0].strides = __pyx_pybuffernd_rowind.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_rowind.diminfo[0].shape = __pyx_pybuffernd_rowind.rcbuffer->pybuffer.shape[0]; - if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 224, __pyx_L1_error) + if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 232, __pyx_L1_error) } __pyx_t_8 = 0; __Pyx_DECREF_SET(__pyx_v_rowind, ((PyArrayObject *)__pyx_t_7)); __pyx_t_7 = 0; - /* "l0learn/cyarma.pyx":223 + /* "l0learn/cyarma.pyx":231 * np.ndarray[np.uint64_t, ndim=1] colind, np.ndarray[np.double_t, ndim=1] values): * # TODO: Check order of X and D * if rowind is None: # <<<<<<<<<<<<<< @@ -4417,7 +4418,7 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & */ } - /* "l0learn/cyarma.pyx":225 + /* "l0learn/cyarma.pyx":233 * if rowind is None: * rowind = np.empty(X.n_nonzero, dtype=np.uint64) * if colind is None: # <<<<<<<<<<<<<< @@ -4428,40 +4429,40 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { - /* "l0learn/cyarma.pyx":226 + /* "l0learn/cyarma.pyx":234 * rowind = np.empty(X.n_nonzero, dtype=np.uint64) * if colind is None: * colind = np.empty(X.n_nonzero, dtype=np.uint64) # <<<<<<<<<<<<<< * if values is None: * values = np.empty(X.n_nonzero, dtype=np.double) */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_empty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 226, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_empty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_X.n_nonzero); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 226, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_X.n_nonzero); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 226, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 226, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_uint64); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 226, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_uint64); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(0, 226, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 226, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 226, __pyx_L1_error) + if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 234, __pyx_L1_error) __pyx_t_13 = ((PyArrayObject *)__pyx_t_6); { __Pyx_BufFmt_StackElem __pyx_stack[1]; @@ -4478,13 +4479,13 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & __pyx_t_12 = __pyx_t_11 = __pyx_t_10 = 0; } __pyx_pybuffernd_colind.diminfo[0].strides = __pyx_pybuffernd_colind.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_colind.diminfo[0].shape = __pyx_pybuffernd_colind.rcbuffer->pybuffer.shape[0]; - if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 226, __pyx_L1_error) + if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 234, __pyx_L1_error) } __pyx_t_13 = 0; __Pyx_DECREF_SET(__pyx_v_colind, ((PyArrayObject *)__pyx_t_6)); __pyx_t_6 = 0; - /* "l0learn/cyarma.pyx":225 + /* "l0learn/cyarma.pyx":233 * if rowind is None: * rowind = np.empty(X.n_nonzero, dtype=np.uint64) * if colind is None: # <<<<<<<<<<<<<< @@ -4493,7 +4494,7 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & */ } - /* "l0learn/cyarma.pyx":227 + /* "l0learn/cyarma.pyx":235 * if colind is None: * colind = np.empty(X.n_nonzero, dtype=np.uint64) * if values is None: # <<<<<<<<<<<<<< @@ -4504,40 +4505,40 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "l0learn/cyarma.pyx":228 + /* "l0learn/cyarma.pyx":236 * colind = np.empty(X.n_nonzero, dtype=np.uint64) * if values is None: * values = np.empty(X.n_nonzero, dtype=np.double) # <<<<<<<<<<<<<< * * cdef sp_dmat.const_iterator it = X.begin() */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 228, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 236, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_empty); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 228, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_empty); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 236, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_X.n_nonzero); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 228, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_X.n_nonzero); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 236, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 228, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 236, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 228, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 236, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 228, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 236, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_double); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 228, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_double); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 236, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(0, 228, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(0, 236, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 228, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 236, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 228, __pyx_L1_error) + if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 236, __pyx_L1_error) __pyx_t_14 = ((PyArrayObject *)__pyx_t_4); { __Pyx_BufFmt_StackElem __pyx_stack[1]; @@ -4554,13 +4555,13 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & __pyx_t_10 = __pyx_t_11 = __pyx_t_12 = 0; } __pyx_pybuffernd_values.diminfo[0].strides = __pyx_pybuffernd_values.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_values.diminfo[0].shape = __pyx_pybuffernd_values.rcbuffer->pybuffer.shape[0]; - if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 228, __pyx_L1_error) + if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 236, __pyx_L1_error) } __pyx_t_14 = 0; __Pyx_DECREF_SET(__pyx_v_values, ((PyArrayObject *)__pyx_t_4)); __pyx_t_4 = 0; - /* "l0learn/cyarma.pyx":227 + /* "l0learn/cyarma.pyx":235 * if colind is None: * colind = np.empty(X.n_nonzero, dtype=np.uint64) * if values is None: # <<<<<<<<<<<<<< @@ -4569,7 +4570,7 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & */ } - /* "l0learn/cyarma.pyx":230 + /* "l0learn/cyarma.pyx":238 * values = np.empty(X.n_nonzero, dtype=np.double) * * cdef sp_dmat.const_iterator it = X.begin() # <<<<<<<<<<<<<< @@ -4578,7 +4579,7 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & */ __pyx_v_it = __pyx_v_X.begin(); - /* "l0learn/cyarma.pyx":232 + /* "l0learn/cyarma.pyx":240 * cdef sp_dmat.const_iterator it = X.begin() * * for i in range(X.n_nonzero): # <<<<<<<<<<<<<< @@ -4590,7 +4591,7 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_15; __pyx_t_16+=1) { __pyx_v_i = __pyx_t_16; - /* "l0learn/cyarma.pyx":235 + /* "l0learn/cyarma.pyx":243 * # TODO: Double check the following comment... * # Arma is column major so rows are columns and columns are rows when converting back to l0learn (row major) * rowind[i] = it.col() # <<<<<<<<<<<<<< @@ -4601,7 +4602,7 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & if (__pyx_t_17 < 0) __pyx_t_17 += __pyx_pybuffernd_rowind.diminfo[0].shape; *__Pyx_BufPtrStrided1d(__pyx_t_5numpy_uint64_t *, __pyx_pybuffernd_rowind.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_rowind.diminfo[0].strides) = __pyx_v_it.col(); - /* "l0learn/cyarma.pyx":236 + /* "l0learn/cyarma.pyx":244 * # Arma is column major so rows are columns and columns are rows when converting back to l0learn (row major) * rowind[i] = it.col() * colind[i] = it.row() # <<<<<<<<<<<<<< @@ -4612,7 +4613,7 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & if (__pyx_t_17 < 0) __pyx_t_17 += __pyx_pybuffernd_colind.diminfo[0].shape; *__Pyx_BufPtrStrided1d(__pyx_t_5numpy_uint64_t *, __pyx_pybuffernd_colind.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_colind.diminfo[0].strides) = __pyx_v_it.row(); - /* "l0learn/cyarma.pyx":237 + /* "l0learn/cyarma.pyx":245 * rowind[i] = it.col() * colind[i] = it.row() * values[i] = deref(it) # <<<<<<<<<<<<<< @@ -4623,7 +4624,7 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & if (__pyx_t_17 < 0) __pyx_t_17 += __pyx_pybuffernd_values.diminfo[0].shape; *__Pyx_BufPtrStrided1d(__pyx_t_5numpy_double_t *, __pyx_pybuffernd_values.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_values.diminfo[0].strides) = (*__pyx_v_it); - /* "l0learn/cyarma.pyx":238 + /* "l0learn/cyarma.pyx":246 * colind[i] = it.row() * values[i] = deref(it) * inc(it) # <<<<<<<<<<<<<< @@ -4633,15 +4634,15 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & (void)((++__pyx_v_it)); } - /* "l0learn/cyarma.pyx":240 + /* "l0learn/cyarma.pyx":248 * inc(it) * * return csc_matrix((values, (colind, rowind)), shape=(X.n_rows, X.n_cols)) # <<<<<<<<<<<<<< */ __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 248, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 240, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 248, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(((PyObject *)__pyx_v_colind)); __Pyx_GIVEREF(((PyObject *)__pyx_v_colind)); @@ -4649,7 +4650,7 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & __Pyx_INCREF(((PyObject *)__pyx_v_rowind)); __Pyx_GIVEREF(((PyObject *)__pyx_v_rowind)); PyTuple_SET_ITEM(__pyx_t_6, 1, ((PyObject *)__pyx_v_rowind)); - __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 240, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 248, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_INCREF(((PyObject *)__pyx_v_values)); __Pyx_GIVEREF(((PyObject *)__pyx_v_values)); @@ -4657,18 +4658,18 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 240, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 248, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 240, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 248, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_X.n_rows); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 240, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_X.n_rows); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 248, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_X.n_cols); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 240, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_X.n_cols); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 248, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_18 = PyTuple_New(2); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 240, __pyx_L1_error) + __pyx_t_18 = PyTuple_New(2); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 248, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_18); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_7); @@ -4676,9 +4677,9 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & PyTuple_SET_ITEM(__pyx_t_18, 1, __pyx_t_3); __pyx_t_7 = 0; __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_shape, __pyx_t_18) < 0) __PYX_ERR(0, 240, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_shape, __pyx_t_18) < 0) __PYX_ERR(0, 248, __pyx_L1_error) __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; - __pyx_t_18 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, __pyx_t_5); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 240, __pyx_L1_error) + __pyx_t_18 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, __pyx_t_5); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 248, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_18); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; @@ -4687,7 +4688,7 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & __pyx_t_18 = 0; goto __pyx_L0; - /* "l0learn/cyarma.pyx":220 + /* "l0learn/cyarma.pyx":228 * * @cython.boundscheck(False) * cdef sp_dmat_to_numpy(const sp_dmat & X, np.ndarray[np.uint64_t, ndim=1] rowind, # <<<<<<<<<<<<<< @@ -5638,7 +5639,7 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, {&__pyx_n_s_indices, __pyx_k_indices, sizeof(__pyx_k_indices), 0, 0, 1, 1}, {&__pyx_n_s_indptr, __pyx_k_indptr, sizeof(__pyx_k_indptr), 0, 0, 1, 1}, - {&__pyx_n_s_isreal, __pyx_k_isreal, sizeof(__pyx_k_isreal), 0, 0, 1, 1}, + {&__pyx_n_s_isrealobj, __pyx_k_isrealobj, sizeof(__pyx_k_isrealobj), 0, 0, 1, 1}, {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, {&__pyx_n_s_ndim, __pyx_k_ndim, sizeof(__pyx_k_ndim), 0, 0, 1, 1}, @@ -5656,10 +5657,10 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {0, 0, 0, 0, 0, 0, 0} }; static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { - __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(0, 88, __pyx_L1_error) - __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 90, __pyx_L1_error) - __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 144, __pyx_L1_error) - __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 172, __pyx_L1_error) + __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(0, 89, __pyx_L1_error) + __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 91, __pyx_L1_error) + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 149, __pyx_L1_error) + __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 179, __pyx_L1_error) __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 884, __pyx_L1_error) return 0; __pyx_L1_error:; diff --git a/python/l0learn/cyarma.pyx b/python/l0learn/cyarma.pyx index f198f84..4d61597 100644 --- a/python/l0learn/cyarma.pyx +++ b/python/l0learn/cyarma.pyx @@ -83,22 +83,26 @@ cdef extern from "armadillo" namespace "arma" nogil: ## TODO: refactor to return pointer, but other function derefed. ##### Tools to convert numpy arrays to armadillo arrays ###### +@cython.boundscheck(False) cdef field[sp_dmat] list_to_sp_dmat_field(list values): cdef field[sp_dmat] f = field[sp_dmat](len(values)) for i, value in enumerate(values): - if not isinstance(value, csc_matrix) or value.ndim != 2 or np.isreal(value): + if not isinstance(value, csc_matrix) or value.ndim != 2 or not np.isrealobj(value): raise TypeError(f"expected each value in values to be a 2D real csc_matrix, but got {value}") f[i] = numpy_to_sp_dmat_d(value) return f + +@cython.boundscheck(False) cdef field[dvec] list_to_dvec_field(list values): cdef field[dvec] f = field[dvec](len(values)) for i, value in enumerate(values): - if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isreal(value): + if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isrealobj(value): raise TypeError(f"expected each value in values to be a 1D real numpy matrix, but got {value}") f[i] = numpy_to_dvec_d(value) return f + cdef dmat * numpy_to_dmat(np.ndarray[np.double_t, ndim=2] X): # TODO: Add checks on X (Size, ...) # TODO: Add flags for new dmat. See: Advanced constructors in http://arma.sourceforge.net/docs.html#Mat @@ -139,6 +143,7 @@ cdef uvec numpy_to_uvec_d(np.ndarray[np.uint64_t, ndim=1] x): del ar_p return ar + cdef sp_dmat * numpy_to_sp_dmat(x): if not isinstance(x, csc_matrix): raise ValueError(f"expected x to be of type {csc_matrix}, but got {type(x)}") @@ -156,6 +161,7 @@ cdef sp_dmat * numpy_to_sp_dmat(x): return ar + cdef sp_dmat numpy_to_sp_dmat_d(x): cdef sp_dmat *ar_p = numpy_to_sp_dmat(x) cdef sp_dmat ar = deref(ar_p) @@ -166,6 +172,7 @@ cdef sp_dmat numpy_to_sp_dmat_d(x): # all data will be copied since numpy doesn't own the data and can't clean up # otherwise. Maybe this can be improved. ####### + @cython.boundscheck(False) cdef list sp_dmat_field_to_list(field[sp_dmat] f): cdef list lst = [] @@ -173,6 +180,7 @@ cdef list sp_dmat_field_to_list(field[sp_dmat] f): lst.append(sp_dmat_to_numpy(f[i], None, None, None)) return lst + @cython.boundscheck(False) cdef list dvec_field_to_list(field[dvec] f): cdef list lst = [] diff --git a/python/l0learn/interface.cpp b/python/l0learn/interface.cpp index c465e5e..0d8f3d2 100644 --- a/python/l0learn/interface.cpp +++ b/python/l0learn/interface.cpp @@ -1924,9 +1924,9 @@ static const char __pyx_k_support_size[] = "support_size"; static const char __pyx_k_unique_items[] = "unique_items"; static const char __pyx_k_Not_supported[] = ". Not supported"; static const char __pyx_k_c_lambda_grid[] = "c_lambda_grid"; -static const char __pyx_k_l0learn_utils[] = "l0learn.utils"; static const char __pyx_k_SUPPORTED_LOSS[] = "SUPPORTED_LOSS"; static const char __pyx_k_active_set_num[] = "active_set_num"; +static const char __pyx_k_l0learn_models[] = "l0learn.models"; static const char __pyx_k_bad_lambda_grid[] = "bad_lambda_grid"; static const char __pyx_k_exclude_first_k[] = "exclude_first_k"; static const char __pyx_k_sub_lambda_grid[] = "sub_lambda_grid"; @@ -2126,7 +2126,7 @@ static PyObject *__pyx_n_s_isrealobj; static PyObject *__pyx_n_s_issubdtype; static PyObject *__pyx_n_s_l0learn_interface; static PyObject *__pyx_kp_s_l0learn_interface_pyx; -static PyObject *__pyx_n_s_l0learn_utils; +static PyObject *__pyx_n_s_l0learn_models; static PyObject *__pyx_n_s_lambda_0; static PyObject *__pyx_n_s_lambda_grid; static PyObject *__pyx_n_s_loss; @@ -2217,7 +2217,7 @@ static PyObject *__pyx_codeobj__22; /* Late includes */ /* "l0learn/interface.pyx":15 - * from l0learn.utils import FitModel, CVFitModel + * from l0learn.models import FitModel, CVFitModel * * def np_to_arma_check(arr): # <<<<<<<<<<<<<< * # TODO: Add checks for Behaved and OwnsData @@ -2881,7 +2881,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO } /* "l0learn/interface.pyx":15 - * from l0learn.utils import FitModel, CVFitModel + * from l0learn.models import FitModel, CVFitModel * * def np_to_arma_check(arr): # <<<<<<<<<<<<<< * # TODO: Add checks for Behaved and OwnsData @@ -4923,32 +4923,41 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx * y[y!=a] = 1 * * if penalty == "L0": # <<<<<<<<<<<<<< - * # TODO: Must be corrected in R code: https://github.com/hazimehh/L0Learn/blob/7a65474dfdb01489a0c263d7b24fbafad56fba61/R/fit.R#L136 * # Pure L0 is not supported for classification + * # Below we add a small L2 component. */ __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 278, __pyx_L1_error) __pyx_t_1 = (__pyx_t_5 != 0); if (__pyx_t_1) { - /* "l0learn/interface.pyx":283 + /* "l0learn/interface.pyx":282 * # Below we add a small L2 component. * - * if len(lambda_grid) != 1: # <<<<<<<<<<<<<< + * if lambda_grid is not None and len(lambda_grid) != 1: # <<<<<<<<<<<<<< * # If this error checking was left to the lower section, it would confuse users as * # we are converting L0 to L0L2 with small L2 penalty. */ - __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 283, __pyx_L1_error) - __pyx_t_1 = ((__pyx_t_9 != 1) != 0); + __pyx_t_5 = (__pyx_v_lambda_grid != Py_None); + __pyx_t_4 = (__pyx_t_5 != 0); + if (__pyx_t_4) { + } else { + __pyx_t_1 = __pyx_t_4; + goto __pyx_L57_bool_binop_done; + } + __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 282, __pyx_L1_error) + __pyx_t_4 = ((__pyx_t_9 != 1) != 0); + __pyx_t_1 = __pyx_t_4; + __pyx_L57_bool_binop_done:; if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":288 + /* "l0learn/interface.pyx":287 * # Here we must check if lambdaGrid is supplied (And thus use 'autolambda') * # If 'lambdaGrid' is supplied, we must only supply 1 list of lambda values * raise ValueError(f"L0 Penalty requires 'lambda_grid' to be a list of length 1, but got {lambda_grid}.") # <<<<<<<<<<<<<< * * penalty = "L0L2" */ - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 288, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 287, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -4956,7 +4965,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_9 += 68; __Pyx_GIVEREF(__pyx_kp_u_L0_Penalty_requires_lambda_grid); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_L0_Penalty_requires_lambda_grid); - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 288, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 287, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); @@ -4967,20 +4976,20 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_9 += 1; __Pyx_GIVEREF(__pyx_kp_u__5); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u__5); - __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 288, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 287, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 288, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 287, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 288, __pyx_L1_error) + __PYX_ERR(0, 287, __pyx_L1_error) - /* "l0learn/interface.pyx":283 + /* "l0learn/interface.pyx":282 * # Below we add a small L2 component. * - * if len(lambda_grid) != 1: # <<<<<<<<<<<<<< + * if lambda_grid is not None and len(lambda_grid) != 1: # <<<<<<<<<<<<<< * # If this error checking was left to the lower section, it would confuse users as * # we are converting L0 to L0L2 with small L2 penalty. */ @@ -4990,12 +4999,12 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx * y[y!=a] = 1 * * if penalty == "L0": # <<<<<<<<<<<<<< - * # TODO: Must be corrected in R code: https://github.com/hazimehh/L0Learn/blob/7a65474dfdb01489a0c263d7b24fbafad56fba61/R/fit.R#L136 * # Pure L0 is not supported for classification + * # Below we add a small L2 component. */ } - /* "l0learn/interface.pyx":290 + /* "l0learn/interface.pyx":289 * raise ValueError(f"L0 Penalty requires 'lambda_grid' to be a list of length 1, but got {lambda_grid}.") * * penalty = "L0L2" # <<<<<<<<<<<<<< @@ -5005,7 +5014,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_INCREF(__pyx_n_u_L0L2); __Pyx_DECREF_SET(__pyx_v_penalty, __pyx_n_u_L0L2); - /* "l0learn/interface.pyx":291 + /* "l0learn/interface.pyx":290 * * penalty = "L0L2" * gamma_max = 1e-7 # <<<<<<<<<<<<<< @@ -5014,7 +5023,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ __pyx_v_gamma_max = 1e-7; - /* "l0learn/interface.pyx":292 + /* "l0learn/interface.pyx":291 * penalty = "L0L2" * gamma_max = 1e-7 * gamma_min = 1e-7 # <<<<<<<<<<<<<< @@ -5033,38 +5042,38 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx goto __pyx_L51; } - /* "l0learn/interface.pyx":293 + /* "l0learn/interface.pyx":292 * gamma_max = 1e-7 * gamma_min = 1e-7 * elif penalty != "L0" and num_gamma == 1: # <<<<<<<<<<<<<< * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") * */ - __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_NE)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 293, __pyx_L1_error) - __pyx_t_4 = (__pyx_t_5 != 0); - if (__pyx_t_4) { + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_NE)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 292, __pyx_L1_error) + __pyx_t_5 = (__pyx_t_4 != 0); + if (__pyx_t_5) { } else { - __pyx_t_1 = __pyx_t_4; - goto __pyx_L57_bool_binop_done; + __pyx_t_1 = __pyx_t_5; + goto __pyx_L59_bool_binop_done; } - __pyx_t_3 = __Pyx_PyInt_EqObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 293, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_EqObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 292, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 293, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 292, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_1 = __pyx_t_4; - __pyx_L57_bool_binop_done:; + __pyx_t_1 = __pyx_t_5; + __pyx_L59_bool_binop_done:; if (__pyx_t_1) { - /* "l0learn/interface.pyx":294 + /* "l0learn/interface.pyx":293 * gamma_min = 1e-7 * elif penalty != "L0" and num_gamma == 1: * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") # <<<<<<<<<<<<<< * * if lambda_grid is None: */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_warn); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 294, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_warn); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 293, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = PyTuple_New(5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 294, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 293, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -5072,7 +5081,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_9 += 24; __Pyx_GIVEREF(__pyx_kp_u_num_gamma_set_to_1_with); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_num_gamma_set_to_1_with); - __pyx_t_2 = __Pyx_PyUnicode_Unicode(__pyx_v_penalty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 294, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyUnicode_Unicode(__pyx_v_penalty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 293, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); @@ -5085,9 +5094,9 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_penalty_Only_one); if (unlikely(__pyx_v_penalty == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(0, 294, __pyx_L1_error) + __PYX_ERR(0, 293, __pyx_L1_error) } - __pyx_t_2 = __Pyx_PyUnicode_Substring(__pyx_v_penalty, 2, PY_SSIZE_T_MAX); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 294, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyUnicode_Substring(__pyx_v_penalty, 2, PY_SSIZE_T_MAX); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 293, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); @@ -5098,7 +5107,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_9 += 27; __Pyx_GIVEREF(__pyx_kp_u_penalty_value_will_be_fit); PyTuple_SET_ITEM(__pyx_t_7, 4, __pyx_kp_u_penalty_value_will_be_fit); - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_7, 5, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 294, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_7, 5, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 293, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; @@ -5114,12 +5123,12 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_7, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_2); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 294, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 293, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":293 + /* "l0learn/interface.pyx":292 * gamma_max = 1e-7 * gamma_min = 1e-7 * elif penalty != "L0" and num_gamma == 1: # <<<<<<<<<<<<<< @@ -5129,7 +5138,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx } __pyx_L51:; - /* "l0learn/interface.pyx":296 + /* "l0learn/interface.pyx":295 * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") * * if lambda_grid is None: # <<<<<<<<<<<<<< @@ -5137,22 +5146,22 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx * auto_lambda = True */ __pyx_t_1 = (__pyx_v_lambda_grid == Py_None); - __pyx_t_4 = (__pyx_t_1 != 0); - if (__pyx_t_4) { + __pyx_t_5 = (__pyx_t_1 != 0); + if (__pyx_t_5) { - /* "l0learn/interface.pyx":297 + /* "l0learn/interface.pyx":296 * * if lambda_grid is None: * lambda_grid = [[0.]] # <<<<<<<<<<<<<< * auto_lambda = True * if not isinstance(num_lambda, int) or num_lambda < 1: */ - __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 297, __pyx_L1_error) + __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 296, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_float_0_); __Pyx_GIVEREF(__pyx_float_0_); PyList_SET_ITEM(__pyx_t_3, 0, __pyx_float_0_); - __pyx_t_8 = PyList_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 297, __pyx_L1_error) + __pyx_t_8 = PyList_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 296, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_GIVEREF(__pyx_t_3); PyList_SET_ITEM(__pyx_t_8, 0, __pyx_t_3); @@ -5160,7 +5169,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_DECREF_SET(__pyx_v_lambda_grid, __pyx_t_8); __pyx_t_8 = 0; - /* "l0learn/interface.pyx":298 + /* "l0learn/interface.pyx":297 * if lambda_grid is None: * lambda_grid = [[0.]] * auto_lambda = True # <<<<<<<<<<<<<< @@ -5169,7 +5178,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ __pyx_v_auto_lambda = 1; - /* "l0learn/interface.pyx":299 + /* "l0learn/interface.pyx":298 * lambda_grid = [[0.]] * auto_lambda = True * if not isinstance(num_lambda, int) or num_lambda < 1: # <<<<<<<<<<<<<< @@ -5177,27 +5186,27 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx * if not isinstance(num_gamma, int) or num_gamma < 1: */ __pyx_t_1 = PyInt_Check(__pyx_v_num_lambda); - __pyx_t_5 = ((!(__pyx_t_1 != 0)) != 0); - if (!__pyx_t_5) { + __pyx_t_4 = ((!(__pyx_t_1 != 0)) != 0); + if (!__pyx_t_4) { } else { - __pyx_t_4 = __pyx_t_5; - goto __pyx_L61_bool_binop_done; + __pyx_t_5 = __pyx_t_4; + goto __pyx_L63_bool_binop_done; } - __pyx_t_8 = PyObject_RichCompare(__pyx_v_num_lambda, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 299, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 299, __pyx_L1_error) + __pyx_t_8 = PyObject_RichCompare(__pyx_v_num_lambda, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 298, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 298, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_4 = __pyx_t_5; - __pyx_L61_bool_binop_done:; - if (unlikely(__pyx_t_4)) { + __pyx_t_5 = __pyx_t_4; + __pyx_L63_bool_binop_done:; + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":300 + /* "l0learn/interface.pyx":299 * auto_lambda = True * if not isinstance(num_lambda, int) or num_lambda < 1: * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") # <<<<<<<<<<<<<< * if not isinstance(num_gamma, int) or num_gamma < 1: * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") */ - __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 300, __pyx_L1_error) + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 299, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -5205,7 +5214,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_9 += 76; __Pyx_GIVEREF(__pyx_kp_u_expected_num_lambda_to_a_positiv); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_u_expected_num_lambda_to_a_positiv); - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 300, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 299, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); @@ -5216,17 +5225,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_9 += 1; __Pyx_GIVEREF(__pyx_kp_u__5); PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__5); - __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 300, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 299, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 300, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 299, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 300, __pyx_L1_error) + __PYX_ERR(0, 299, __pyx_L1_error) - /* "l0learn/interface.pyx":299 + /* "l0learn/interface.pyx":298 * lambda_grid = [[0.]] * auto_lambda = True * if not isinstance(num_lambda, int) or num_lambda < 1: # <<<<<<<<<<<<<< @@ -5235,35 +5244,35 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":301 + /* "l0learn/interface.pyx":300 * if not isinstance(num_lambda, int) or num_lambda < 1: * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") * if not isinstance(num_gamma, int) or num_gamma < 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") * if penalty == "L0" and num_gamma != 1: */ - __pyx_t_5 = PyInt_Check(__pyx_v_num_gamma); - __pyx_t_1 = ((!(__pyx_t_5 != 0)) != 0); + __pyx_t_4 = PyInt_Check(__pyx_v_num_gamma); + __pyx_t_1 = ((!(__pyx_t_4 != 0)) != 0); if (!__pyx_t_1) { } else { - __pyx_t_4 = __pyx_t_1; - goto __pyx_L64_bool_binop_done; + __pyx_t_5 = __pyx_t_1; + goto __pyx_L66_bool_binop_done; } - __pyx_t_8 = PyObject_RichCompare(__pyx_v_num_gamma, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 301, __pyx_L1_error) - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 301, __pyx_L1_error) + __pyx_t_8 = PyObject_RichCompare(__pyx_v_num_gamma, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 300, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 300, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_4 = __pyx_t_1; - __pyx_L64_bool_binop_done:; - if (unlikely(__pyx_t_4)) { + __pyx_t_5 = __pyx_t_1; + __pyx_L66_bool_binop_done:; + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":302 + /* "l0learn/interface.pyx":301 * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") * if not isinstance(num_gamma, int) or num_gamma < 1: * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") # <<<<<<<<<<<<<< * if penalty == "L0" and num_gamma != 1: * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") */ - __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 302, __pyx_L1_error) + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 301, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -5271,7 +5280,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_9 += 75; __Pyx_GIVEREF(__pyx_kp_u_expected_num_gamma_to_a_positive); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_u_expected_num_gamma_to_a_positive); - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 302, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 301, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); @@ -5282,17 +5291,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_9 += 1; __Pyx_GIVEREF(__pyx_kp_u__5); PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__5); - __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 302, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 301, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 302, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 301, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 302, __pyx_L1_error) + __PYX_ERR(0, 301, __pyx_L1_error) - /* "l0learn/interface.pyx":301 + /* "l0learn/interface.pyx":300 * if not isinstance(num_lambda, int) or num_lambda < 1: * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") * if not isinstance(num_gamma, int) or num_gamma < 1: # <<<<<<<<<<<<<< @@ -5301,36 +5310,36 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":303 + /* "l0learn/interface.pyx":302 * if not isinstance(num_gamma, int) or num_gamma < 1: * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") * else: # lambda_grid should be a List[List[float]] */ - __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 303, __pyx_L1_error) - __pyx_t_5 = (__pyx_t_1 != 0); - if (__pyx_t_5) { + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 302, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_1 != 0); + if (__pyx_t_4) { } else { - __pyx_t_4 = __pyx_t_5; - goto __pyx_L67_bool_binop_done; + __pyx_t_5 = __pyx_t_4; + goto __pyx_L69_bool_binop_done; } - __pyx_t_8 = __Pyx_PyInt_NeObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 303, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_NeObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 302, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 303, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 302, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_4 = __pyx_t_5; - __pyx_L67_bool_binop_done:; - if (unlikely(__pyx_t_4)) { + __pyx_t_5 = __pyx_t_4; + __pyx_L69_bool_binop_done:; + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":304 + /* "l0learn/interface.pyx":303 * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") * if penalty == "L0" and num_gamma != 1: * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") # <<<<<<<<<<<<<< * else: # lambda_grid should be a List[List[float]] * if num_gamma is not None: */ - __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 304, __pyx_L1_error) + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 303, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -5338,7 +5347,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_9 += 53; __Pyx_GIVEREF(__pyx_kp_u_expected_num_gamma_to_1_when_pen); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_u_expected_num_gamma_to_1_when_pen); - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 304, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 303, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); @@ -5349,17 +5358,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_9 += 1; __Pyx_GIVEREF(__pyx_kp_u__5); PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__5); - __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 304, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 303, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 304, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 303, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 304, __pyx_L1_error) + __PYX_ERR(0, 303, __pyx_L1_error) - /* "l0learn/interface.pyx":303 + /* "l0learn/interface.pyx":302 * if not isinstance(num_gamma, int) or num_gamma < 1: * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< @@ -5368,17 +5377,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":296 + /* "l0learn/interface.pyx":295 * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") * * if lambda_grid is None: # <<<<<<<<<<<<<< * lambda_grid = [[0.]] * auto_lambda = True */ - goto __pyx_L59; + goto __pyx_L61; } - /* "l0learn/interface.pyx":306 + /* "l0learn/interface.pyx":305 * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") * else: # lambda_grid should be a List[List[float]] * if num_gamma is not None: # <<<<<<<<<<<<<< @@ -5386,38 +5395,38 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx * f"but got {num_gamma}") */ /*else*/ { - __pyx_t_4 = (__pyx_v_num_gamma != Py_None); - __pyx_t_5 = (__pyx_t_4 != 0); - if (unlikely(__pyx_t_5)) { + __pyx_t_5 = (__pyx_v_num_gamma != Py_None); + __pyx_t_4 = (__pyx_t_5 != 0); + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":308 + /* "l0learn/interface.pyx":307 * if num_gamma is not None: * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " * f"but got {num_gamma}") # <<<<<<<<<<<<<< * num_gamma = len(lambda_grid) * */ - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 308, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 307, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - /* "l0learn/interface.pyx":307 + /* "l0learn/interface.pyx":306 * else: # lambda_grid should be a List[List[float]] * if num_gamma is not None: * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " # <<<<<<<<<<<<<< * f"but got {num_gamma}") * num_gamma = len(lambda_grid) */ - __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_gamma_to_be_None_if, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 307, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_gamma_to_be_None_if, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 306, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 307, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 306, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 307, __pyx_L1_error) + __PYX_ERR(0, 306, __pyx_L1_error) - /* "l0learn/interface.pyx":306 + /* "l0learn/interface.pyx":305 * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") * else: # lambda_grid should be a List[List[float]] * if num_gamma is not None: # <<<<<<<<<<<<<< @@ -5426,58 +5435,58 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":309 + /* "l0learn/interface.pyx":308 * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " * f"but got {num_gamma}") * num_gamma = len(lambda_grid) # <<<<<<<<<<<<<< * * if num_lambda is not None: */ - __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 309, __pyx_L1_error) - __pyx_t_8 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 309, __pyx_L1_error) + __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 308, __pyx_L1_error) + __pyx_t_8 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 308, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF_SET(__pyx_v_num_gamma, __pyx_t_8); __pyx_t_8 = 0; - /* "l0learn/interface.pyx":311 + /* "l0learn/interface.pyx":310 * num_gamma = len(lambda_grid) * * if num_lambda is not None: # <<<<<<<<<<<<<< * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " * f"but got {num_lambda}") */ - __pyx_t_5 = (__pyx_v_num_lambda != Py_None); - __pyx_t_4 = (__pyx_t_5 != 0); - if (unlikely(__pyx_t_4)) { + __pyx_t_4 = (__pyx_v_num_lambda != Py_None); + __pyx_t_5 = (__pyx_t_4 != 0); + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":313 + /* "l0learn/interface.pyx":312 * if num_lambda is not None: * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " * f"but got {num_lambda}") # <<<<<<<<<<<<<< * num_lambda = 0 # This value is ignored. * auto_lambda = False */ - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 313, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 312, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - /* "l0learn/interface.pyx":312 + /* "l0learn/interface.pyx":311 * * if num_lambda is not None: * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " # <<<<<<<<<<<<<< * f"but got {num_lambda}") * num_lambda = 0 # This value is ignored. */ - __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_lambda_to_be_None_i, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 312, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_lambda_to_be_None_i, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 311, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 312, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 311, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 312, __pyx_L1_error) + __PYX_ERR(0, 311, __pyx_L1_error) - /* "l0learn/interface.pyx":311 + /* "l0learn/interface.pyx":310 * num_gamma = len(lambda_grid) * * if num_lambda is not None: # <<<<<<<<<<<<<< @@ -5486,7 +5495,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":314 + /* "l0learn/interface.pyx":313 * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " * f"but got {num_lambda}") * num_lambda = 0 # This value is ignored. # <<<<<<<<<<<<<< @@ -5496,7 +5505,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_INCREF(__pyx_int_0); __Pyx_DECREF_SET(__pyx_v_num_lambda, __pyx_int_0); - /* "l0learn/interface.pyx":315 + /* "l0learn/interface.pyx":314 * f"but got {num_lambda}") * num_lambda = 0 # This value is ignored. * auto_lambda = False # <<<<<<<<<<<<<< @@ -5505,7 +5514,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ __pyx_v_auto_lambda = 0; - /* "l0learn/interface.pyx":316 + /* "l0learn/interface.pyx":315 * num_lambda = 0 # This value is ignored. * auto_lambda = False * bad_lambda_grid = False # <<<<<<<<<<<<<< @@ -5514,49 +5523,49 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ __pyx_v_bad_lambda_grid = 0; - /* "l0learn/interface.pyx":318 + /* "l0learn/interface.pyx":317 * bad_lambda_grid = False * * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") * */ - __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 318, __pyx_L1_error) - __pyx_t_1 = (__pyx_t_5 != 0); + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 317, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_4 != 0); if (__pyx_t_1) { } else { - __pyx_t_4 = __pyx_t_1; - goto __pyx_L72_bool_binop_done; + __pyx_t_5 = __pyx_t_1; + goto __pyx_L74_bool_binop_done; } - __pyx_t_8 = __Pyx_PyInt_NeObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 318, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_NeObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 317, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 318, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 317, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_4 = __pyx_t_1; - __pyx_L72_bool_binop_done:; - if (unlikely(__pyx_t_4)) { + __pyx_t_5 = __pyx_t_1; + __pyx_L74_bool_binop_done:; + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":319 + /* "l0learn/interface.pyx":318 * * if penalty == "L0" and num_gamma != 1: * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") # <<<<<<<<<<<<<< * * for i, sub_lambda_grid in enumerate(lambda_grid): */ - __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 319, __pyx_L1_error) - __pyx_t_8 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_9, 0, ' ', 'd'); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 319, __pyx_L1_error) + __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 318, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_9, 0, ' ', 'd'); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 318, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_of_lengt, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 319, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_of_lengt, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 318, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 319, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 318, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 319, __pyx_L1_error) + __PYX_ERR(0, 318, __pyx_L1_error) - /* "l0learn/interface.pyx":318 + /* "l0learn/interface.pyx":317 * bad_lambda_grid = False * * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< @@ -5565,7 +5574,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":321 + /* "l0learn/interface.pyx":320 * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") * * for i, sub_lambda_grid in enumerate(lambda_grid): # <<<<<<<<<<<<<< @@ -5578,26 +5587,26 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_3 = __pyx_v_lambda_grid; __Pyx_INCREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_13 = NULL; } else { - __pyx_t_9 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_lambda_grid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 321, __pyx_L1_error) + __pyx_t_9 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_lambda_grid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 320, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_13 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 321, __pyx_L1_error) + __pyx_t_13 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 320, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_13)) { if (likely(PyList_CheckExact(__pyx_t_3))) { if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_2 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_9); __Pyx_INCREF(__pyx_t_2); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 321, __pyx_L1_error) + __pyx_t_2 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_9); __Pyx_INCREF(__pyx_t_2); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 320, __pyx_L1_error) #else - __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 321, __pyx_L1_error) + __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 320, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #endif } else { if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_9); __Pyx_INCREF(__pyx_t_2); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 321, __pyx_L1_error) + __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_9); __Pyx_INCREF(__pyx_t_2); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 320, __pyx_L1_error) #else - __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 321, __pyx_L1_error) + __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 320, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #endif } @@ -5607,7 +5616,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(0, 321, __pyx_L1_error) + else __PYX_ERR(0, 320, __pyx_L1_error) } break; } @@ -5617,45 +5626,45 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_2 = 0; __Pyx_INCREF(__pyx_t_8); __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_8); - __pyx_t_2 = __Pyx_PyInt_AddObjC(__pyx_t_8, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 321, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_AddObjC(__pyx_t_8, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 320, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = __pyx_t_2; __pyx_t_2 = 0; - /* "l0learn/interface.pyx":322 + /* "l0learn/interface.pyx":321 * * for i, sub_lambda_grid in enumerate(lambda_grid): * current = float("inf") # <<<<<<<<<<<<<< * if sub_lambda_grid[0] <= 0: * raise ValueError(f"Expected all values of lambda_grid to be positive, " */ - __pyx_t_14 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 322, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 321, __pyx_L1_error) __pyx_v_current = __pyx_t_14; - /* "l0learn/interface.pyx":323 + /* "l0learn/interface.pyx":322 * for i, sub_lambda_grid in enumerate(lambda_grid): * current = float("inf") * if sub_lambda_grid[0] <= 0: # <<<<<<<<<<<<<< * raise ValueError(f"Expected all values of lambda_grid to be positive, " * f"but got lambda_grid[{i}] containing a negative value") */ - __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_sub_lambda_grid, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 323, __pyx_L1_error) + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_sub_lambda_grid, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 322, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = PyObject_RichCompare(__pyx_t_2, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 323, __pyx_L1_error) + __pyx_t_7 = PyObject_RichCompare(__pyx_t_2, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 322, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 323, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 322, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(__pyx_t_4)) { + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":324 + /* "l0learn/interface.pyx":323 * current = float("inf") * if sub_lambda_grid[0] <= 0: * raise ValueError(f"Expected all values of lambda_grid to be positive, " # <<<<<<<<<<<<<< * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): */ - __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 324, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 323, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_15 = 0; __pyx_t_10 = 127; @@ -5664,14 +5673,14 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_GIVEREF(__pyx_kp_u_Expected_all_values_of_lambda_gr); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_Expected_all_values_of_lambda_gr); - /* "l0learn/interface.pyx":325 + /* "l0learn/interface.pyx":324 * if sub_lambda_grid[0] <= 0: * raise ValueError(f"Expected all values of lambda_grid to be positive, " * f"but got lambda_grid[{i}] containing a negative value") # <<<<<<<<<<<<<< * if any(np.diff(sub_lambda_grid) >= 0): * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " */ - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 325, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 324, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; __pyx_t_15 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); @@ -5683,24 +5692,24 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_GIVEREF(__pyx_kp_u_containing_a_negative_value); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_containing_a_negative_value); - /* "l0learn/interface.pyx":324 + /* "l0learn/interface.pyx":323 * current = float("inf") * if sub_lambda_grid[0] <= 0: * raise ValueError(f"Expected all values of lambda_grid to be positive, " # <<<<<<<<<<<<<< * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): */ - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 324, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 323, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 324, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 323, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 324, __pyx_L1_error) + __PYX_ERR(0, 323, __pyx_L1_error) - /* "l0learn/interface.pyx":323 + /* "l0learn/interface.pyx":322 * for i, sub_lambda_grid in enumerate(lambda_grid): * current = float("inf") * if sub_lambda_grid[0] <= 0: # <<<<<<<<<<<<<< @@ -5709,16 +5718,16 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":326 + /* "l0learn/interface.pyx":325 * raise ValueError(f"Expected all values of lambda_grid to be positive, " * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): # <<<<<<<<<<<<<< * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " * f"but got lambda_grid[{i}] containing an increasing value.") */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 326, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_diff); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 326, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_diff); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; @@ -5733,26 +5742,26 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx } __pyx_t_7 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_16, __pyx_t_2, __pyx_v_sub_lambda_grid) : __Pyx_PyObject_CallOneArg(__pyx_t_16, __pyx_v_sub_lambda_grid); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 326, __pyx_L1_error) + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_16 = PyObject_RichCompare(__pyx_t_7, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_16); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 326, __pyx_L1_error) + __pyx_t_16 = PyObject_RichCompare(__pyx_t_7, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_16); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 325, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_16); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 326, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_16); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 326, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 325, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(__pyx_t_4)) { + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":327 + /* "l0learn/interface.pyx":326 * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " # <<<<<<<<<<<<<< * f"but got lambda_grid[{i}] containing an increasing value.") * */ - __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 327, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 326, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_15 = 0; __pyx_t_10 = 127; @@ -5761,14 +5770,14 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_GIVEREF(__pyx_kp_u_Expected_each_element_of_lambda); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_Expected_each_element_of_lambda); - /* "l0learn/interface.pyx":328 + /* "l0learn/interface.pyx":327 * if any(np.diff(sub_lambda_grid) >= 0): * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " * f"but got lambda_grid[{i}] containing an increasing value.") # <<<<<<<<<<<<<< * * n, p = X.shape */ - __pyx_t_16 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 328, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 327, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_16) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_16) : __pyx_t_10; __pyx_t_15 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_16); @@ -5780,24 +5789,24 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_GIVEREF(__pyx_kp_u_containing_an_increasing_value); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_containing_an_increasing_value); - /* "l0learn/interface.pyx":327 + /* "l0learn/interface.pyx":326 * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " # <<<<<<<<<<<<<< * f"but got lambda_grid[{i}] containing an increasing value.") * */ - __pyx_t_16 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 327, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 326, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_16); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 327, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_16); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 326, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 327, __pyx_L1_error) + __PYX_ERR(0, 326, __pyx_L1_error) - /* "l0learn/interface.pyx":326 + /* "l0learn/interface.pyx":325 * raise ValueError(f"Expected all values of lambda_grid to be positive, " * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): # <<<<<<<<<<<<<< @@ -5806,7 +5815,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":321 + /* "l0learn/interface.pyx":320 * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") * * for i, sub_lambda_grid in enumerate(lambda_grid): # <<<<<<<<<<<<<< @@ -5817,16 +5826,16 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } - __pyx_L59:; + __pyx_L61:; - /* "l0learn/interface.pyx":330 + /* "l0learn/interface.pyx":329 * f"but got lambda_grid[{i}] containing an increasing value.") * * n, p = X.shape # <<<<<<<<<<<<<< * with_bounds = False * */ - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 330, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 329, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if ((likely(PyTuple_CheckExact(__pyx_t_8))) || (PyList_CheckExact(__pyx_t_8))) { PyObject* sequence = __pyx_t_8; @@ -5834,7 +5843,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 330, __pyx_L1_error) + __PYX_ERR(0, 329, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { @@ -5847,39 +5856,39 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_7); #else - __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 330, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 329, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 330, __pyx_L1_error) + __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 329, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); #endif __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { Py_ssize_t index = -1; - __pyx_t_16 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 330, __pyx_L1_error) + __pyx_t_16 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 329, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_11 = Py_TYPE(__pyx_t_16)->tp_iternext; - index = 0; __pyx_t_3 = __pyx_t_11(__pyx_t_16); if (unlikely(!__pyx_t_3)) goto __pyx_L78_unpacking_failed; + index = 0; __pyx_t_3 = __pyx_t_11(__pyx_t_16); if (unlikely(!__pyx_t_3)) goto __pyx_L80_unpacking_failed; __Pyx_GOTREF(__pyx_t_3); - index = 1; __pyx_t_7 = __pyx_t_11(__pyx_t_16); if (unlikely(!__pyx_t_7)) goto __pyx_L78_unpacking_failed; + index = 1; __pyx_t_7 = __pyx_t_11(__pyx_t_16); if (unlikely(!__pyx_t_7)) goto __pyx_L80_unpacking_failed; __Pyx_GOTREF(__pyx_t_7); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_16), 2) < 0) __PYX_ERR(0, 330, __pyx_L1_error) + if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_16), 2) < 0) __PYX_ERR(0, 329, __pyx_L1_error) __pyx_t_11 = NULL; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - goto __pyx_L79_unpacking_done; - __pyx_L78_unpacking_failed:; + goto __pyx_L81_unpacking_done; + __pyx_L80_unpacking_failed:; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_11 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 330, __pyx_L1_error) - __pyx_L79_unpacking_done:; + __PYX_ERR(0, 329, __pyx_L1_error) + __pyx_L81_unpacking_done:; } __Pyx_DECREF_SET(__pyx_v_n, __pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF_SET(__pyx_v_p, __pyx_t_7); __pyx_t_7 = 0; - /* "l0learn/interface.pyx":331 + /* "l0learn/interface.pyx":330 * * n, p = X.shape * with_bounds = False # <<<<<<<<<<<<<< @@ -5888,49 +5897,49 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ __pyx_v_with_bounds = 0; - /* "l0learn/interface.pyx":333 + /* "l0learn/interface.pyx":332 * with_bounds = False * * if isinstance(lows, float): # <<<<<<<<<<<<<< * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") */ - __pyx_t_4 = PyFloat_Check(__pyx_v_lows); - __pyx_t_1 = (__pyx_t_4 != 0); + __pyx_t_5 = PyFloat_Check(__pyx_v_lows); + __pyx_t_1 = (__pyx_t_5 != 0); if (__pyx_t_1) { - /* "l0learn/interface.pyx":334 + /* "l0learn/interface.pyx":333 * * if isinstance(lows, float): * if lows > 0: # <<<<<<<<<<<<<< * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") * elif lows > -float('inf'): */ - __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_GT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 334, __pyx_L1_error) - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 334, __pyx_L1_error) + __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_GT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 333, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 333, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":335 + /* "l0learn/interface.pyx":334 * if isinstance(lows, float): * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") # <<<<<<<<<<<<<< * elif lows > -float('inf'): * with_bounds = True */ - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 335, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 334, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lows_to_be_a_non_positi, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 335, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lows_to_be_a_non_positi, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 334, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 335, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 334, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 335, __pyx_L1_error) + __PYX_ERR(0, 334, __pyx_L1_error) - /* "l0learn/interface.pyx":334 + /* "l0learn/interface.pyx":333 * * if isinstance(lows, float): * if lows > 0: # <<<<<<<<<<<<<< @@ -5939,23 +5948,23 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":336 + /* "l0learn/interface.pyx":335 * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") * elif lows > -float('inf'): # <<<<<<<<<<<<<< * with_bounds = True * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): */ - __pyx_t_14 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 336, __pyx_L1_error) - __pyx_t_8 = PyFloat_FromDouble((-__pyx_t_14)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 336, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 335, __pyx_L1_error) + __pyx_t_8 = PyFloat_FromDouble((-__pyx_t_14)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 335, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = PyObject_RichCompare(__pyx_v_lows, __pyx_t_8, Py_GT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 336, __pyx_L1_error) + __pyx_t_7 = PyObject_RichCompare(__pyx_v_lows, __pyx_t_8, Py_GT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 335, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 336, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 335, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (__pyx_t_1) { - /* "l0learn/interface.pyx":337 + /* "l0learn/interface.pyx":336 * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") * elif lows > -float('inf'): * with_bounds = True # <<<<<<<<<<<<<< @@ -5964,7 +5973,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ __pyx_v_with_bounds = 1; - /* "l0learn/interface.pyx":336 + /* "l0learn/interface.pyx":335 * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") * elif lows > -float('inf'): # <<<<<<<<<<<<<< @@ -5973,71 +5982,71 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":333 + /* "l0learn/interface.pyx":332 * with_bounds = False * * if isinstance(lows, float): # <<<<<<<<<<<<<< * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") */ - goto __pyx_L80; + goto __pyx_L82; } - /* "l0learn/interface.pyx":338 + /* "l0learn/interface.pyx":337 * elif lows > -float('inf'): * with_bounds = True * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): # <<<<<<<<<<<<<< * with_bounds = True * else: */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 338, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 337, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 338, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 337, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = PyObject_IsInstance(__pyx_v_lows, __pyx_t_8); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 338, __pyx_L1_error) + __pyx_t_5 = PyObject_IsInstance(__pyx_v_lows, __pyx_t_8); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 337, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_5 = (__pyx_t_4 != 0); - if (__pyx_t_5) { + __pyx_t_4 = (__pyx_t_5 != 0); + if (__pyx_t_4) { } else { - __pyx_t_1 = __pyx_t_5; - goto __pyx_L82_bool_binop_done; + __pyx_t_1 = __pyx_t_4; + goto __pyx_L84_bool_binop_done; } - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_lows, __pyx_n_s_ndim); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 338, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_lows, __pyx_n_s_ndim); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 337, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = __Pyx_PyInt_EqObjC(__pyx_t_8, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 338, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_EqObjC(__pyx_t_8, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 337, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 338, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 337, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (__pyx_t_5) { + if (__pyx_t_4) { } else { - __pyx_t_1 = __pyx_t_5; - goto __pyx_L82_bool_binop_done; + __pyx_t_1 = __pyx_t_4; + goto __pyx_L84_bool_binop_done; } - __pyx_t_9 = PyObject_Length(__pyx_v_lows); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 338, __pyx_L1_error) - __pyx_t_7 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 338, __pyx_L1_error) + __pyx_t_9 = PyObject_Length(__pyx_v_lows); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 337, __pyx_L1_error) + __pyx_t_7 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 337, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = PyObject_RichCompare(__pyx_t_7, __pyx_v_p, Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 338, __pyx_L1_error) + __pyx_t_8 = PyObject_RichCompare(__pyx_t_7, __pyx_v_p, Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 337, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 338, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 337, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (__pyx_t_5) { + if (__pyx_t_4) { } else { - __pyx_t_1 = __pyx_t_5; - goto __pyx_L82_bool_binop_done; + __pyx_t_1 = __pyx_t_4; + goto __pyx_L84_bool_binop_done; } - __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 338, __pyx_L1_error) - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_all, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 338, __pyx_L1_error) + __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 337, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_all, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 337, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 338, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 337, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_1 = __pyx_t_5; - __pyx_L82_bool_binop_done:; + __pyx_t_1 = __pyx_t_4; + __pyx_L84_bool_binop_done:; if (likely(__pyx_t_1)) { - /* "l0learn/interface.pyx":339 + /* "l0learn/interface.pyx":338 * with_bounds = True * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): * with_bounds = True # <<<<<<<<<<<<<< @@ -6046,17 +6055,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ __pyx_v_with_bounds = 1; - /* "l0learn/interface.pyx":338 + /* "l0learn/interface.pyx":337 * elif lows > -float('inf'): * with_bounds = True * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): # <<<<<<<<<<<<<< * with_bounds = True * else: */ - goto __pyx_L80; + goto __pyx_L82; } - /* "l0learn/interface.pyx":341 + /* "l0learn/interface.pyx":340 * with_bounds = True * else: * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " # <<<<<<<<<<<<<< @@ -6064,7 +6073,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx * */ /*else*/ { - __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 341, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 340, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -6072,7 +6081,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_9 += 72; __Pyx_GIVEREF(__pyx_kp_u_expected_lows_to_be_a_non_positi_2); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_lows_to_be_a_non_positi_2); - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 341, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 340, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); @@ -6084,14 +6093,14 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_GIVEREF(__pyx_kp_u_of_non_positives_floats_but_got); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_of_non_positives_floats_but_got); - /* "l0learn/interface.pyx":342 + /* "l0learn/interface.pyx":341 * else: * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " * f"floats, but got {lows}") # <<<<<<<<<<<<<< * * if isinstance(highs, float): */ - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 342, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 341, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); @@ -6099,26 +6108,26 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_8); __pyx_t_8 = 0; - /* "l0learn/interface.pyx":341 + /* "l0learn/interface.pyx":340 * with_bounds = True * else: * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " # <<<<<<<<<<<<<< * f"floats, but got {lows}") * */ - __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 341, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 340, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 341, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 340, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 341, __pyx_L1_error) + __PYX_ERR(0, 340, __pyx_L1_error) } - __pyx_L80:; + __pyx_L82:; - /* "l0learn/interface.pyx":344 + /* "l0learn/interface.pyx":343 * f"floats, but got {lows}") * * if isinstance(highs, float): # <<<<<<<<<<<<<< @@ -6126,41 +6135,41 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") */ __pyx_t_1 = PyFloat_Check(__pyx_v_highs); - __pyx_t_5 = (__pyx_t_1 != 0); - if (__pyx_t_5) { + __pyx_t_4 = (__pyx_t_1 != 0); + if (__pyx_t_4) { - /* "l0learn/interface.pyx":345 + /* "l0learn/interface.pyx":344 * * if isinstance(highs, float): * if highs < 0: # <<<<<<<<<<<<<< * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") * if highs < float('inf'): */ - __pyx_t_7 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 345, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 345, __pyx_L1_error) + __pyx_t_7 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 344, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 344, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(__pyx_t_5)) { + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":346 + /* "l0learn/interface.pyx":345 * if isinstance(highs, float): * if highs < 0: * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") # <<<<<<<<<<<<<< * if highs < float('inf'): * with_bounds = True */ - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 346, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 345, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_highs_to_be_a_non_negat, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 346, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_highs_to_be_a_non_negat, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 345, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 346, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 345, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 346, __pyx_L1_error) + __PYX_ERR(0, 345, __pyx_L1_error) - /* "l0learn/interface.pyx":345 + /* "l0learn/interface.pyx":344 * * if isinstance(highs, float): * if highs < 0: # <<<<<<<<<<<<<< @@ -6169,22 +6178,22 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":347 + /* "l0learn/interface.pyx":346 * if highs < 0: * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") * if highs < float('inf'): # <<<<<<<<<<<<<< * with_bounds = True * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): */ - __pyx_t_7 = __Pyx_PyNumber_Float(__pyx_n_u_inf); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 347, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyNumber_Float(__pyx_n_u_inf); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 346, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = PyObject_RichCompare(__pyx_v_highs, __pyx_t_7, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 347, __pyx_L1_error) + __pyx_t_8 = PyObject_RichCompare(__pyx_v_highs, __pyx_t_7, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 346, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 347, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 346, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (__pyx_t_5) { + if (__pyx_t_4) { - /* "l0learn/interface.pyx":348 + /* "l0learn/interface.pyx":347 * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") * if highs < float('inf'): * with_bounds = True # <<<<<<<<<<<<<< @@ -6193,7 +6202,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ __pyx_v_with_bounds = 1; - /* "l0learn/interface.pyx":347 + /* "l0learn/interface.pyx":346 * if highs < 0: * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") * if highs < float('inf'): # <<<<<<<<<<<<<< @@ -6202,68 +6211,68 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":344 + /* "l0learn/interface.pyx":343 * f"floats, but got {lows}") * * if isinstance(highs, float): # <<<<<<<<<<<<<< * if highs < 0: * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") */ - goto __pyx_L86; + goto __pyx_L88; } - /* "l0learn/interface.pyx":349 + /* "l0learn/interface.pyx":348 * if highs < float('inf'): * with_bounds = True * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): # <<<<<<<<<<<<<< * with_bounds = True * else: */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 349, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 348, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 349, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 348, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_1 = PyObject_IsInstance(__pyx_v_highs, __pyx_t_7); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 349, __pyx_L1_error) + __pyx_t_1 = PyObject_IsInstance(__pyx_v_highs, __pyx_t_7); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 348, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = (__pyx_t_1 != 0); - if (__pyx_t_4) { + __pyx_t_5 = (__pyx_t_1 != 0); + if (__pyx_t_5) { } else { - __pyx_t_5 = __pyx_t_4; - goto __pyx_L89_bool_binop_done; + __pyx_t_4 = __pyx_t_5; + goto __pyx_L91_bool_binop_done; } - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_highs, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 349, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_highs, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 348, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyInt_EqObjC(__pyx_t_7, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 349, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_EqObjC(__pyx_t_7, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 348, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 349, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 348, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (__pyx_t_4) { + if (__pyx_t_5) { } else { - __pyx_t_5 = __pyx_t_4; - goto __pyx_L89_bool_binop_done; + __pyx_t_4 = __pyx_t_5; + goto __pyx_L91_bool_binop_done; } - __pyx_t_9 = PyObject_Length(__pyx_v_highs); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 349, __pyx_L1_error) - __pyx_t_8 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 349, __pyx_L1_error) + __pyx_t_9 = PyObject_Length(__pyx_v_highs); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 348, __pyx_L1_error) + __pyx_t_8 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 348, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = PyObject_RichCompare(__pyx_t_8, __pyx_v_p, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 349, __pyx_L1_error) + __pyx_t_7 = PyObject_RichCompare(__pyx_t_8, __pyx_v_p, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 348, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 349, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 348, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (__pyx_t_4) { + if (__pyx_t_5) { } else { - __pyx_t_5 = __pyx_t_4; - goto __pyx_L89_bool_binop_done; + __pyx_t_4 = __pyx_t_5; + goto __pyx_L91_bool_binop_done; } - __pyx_t_7 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 349, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 349, __pyx_L1_error) + __pyx_t_7 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 348, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 348, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_5 = __pyx_t_4; - __pyx_L89_bool_binop_done:; - if (likely(__pyx_t_5)) { + __pyx_t_4 = __pyx_t_5; + __pyx_L91_bool_binop_done:; + if (likely(__pyx_t_4)) { - /* "l0learn/interface.pyx":350 + /* "l0learn/interface.pyx":349 * with_bounds = True * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): * with_bounds = True # <<<<<<<<<<<<<< @@ -6272,17 +6281,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ __pyx_v_with_bounds = 1; - /* "l0learn/interface.pyx":349 + /* "l0learn/interface.pyx":348 * if highs < float('inf'): * with_bounds = True * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): # <<<<<<<<<<<<<< * with_bounds = True * else: */ - goto __pyx_L86; + goto __pyx_L88; } - /* "l0learn/interface.pyx":352 + /* "l0learn/interface.pyx":351 * with_bounds = True * else: * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " # <<<<<<<<<<<<<< @@ -6290,7 +6299,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx * */ /*else*/ { - __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 352, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 351, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -6298,7 +6307,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_9 += 73; __Pyx_GIVEREF(__pyx_kp_u_expected_highs_to_be_a_non_negat_2); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_highs_to_be_a_non_negat_2); - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 352, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 351, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); @@ -6310,14 +6319,14 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_GIVEREF(__pyx_kp_u_of_non_negative_floats_but_got); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_of_non_negative_floats_but_got); - /* "l0learn/interface.pyx":353 + /* "l0learn/interface.pyx":352 * else: * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " * f"non-negative floats, but got {highs}") # <<<<<<<<<<<<<< * * if with_bounds: */ - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 353, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 352, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); @@ -6325,56 +6334,56 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_8); __pyx_t_8 = 0; - /* "l0learn/interface.pyx":352 + /* "l0learn/interface.pyx":351 * with_bounds = True * else: * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " # <<<<<<<<<<<<<< * f"non-negative floats, but got {highs}") * */ - __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 352, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 351, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 352, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 351, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 352, __pyx_L1_error) + __PYX_ERR(0, 351, __pyx_L1_error) } - __pyx_L86:; + __pyx_L88:; - /* "l0learn/interface.pyx":355 + /* "l0learn/interface.pyx":354 * f"non-negative floats, but got {highs}") * * if with_bounds: # <<<<<<<<<<<<<< * if isinstance(lows, float): * lows = np.ones(p) * lows */ - __pyx_t_5 = (__pyx_v_with_bounds != 0); - if (__pyx_t_5) { + __pyx_t_4 = (__pyx_v_with_bounds != 0); + if (__pyx_t_4) { - /* "l0learn/interface.pyx":356 + /* "l0learn/interface.pyx":355 * * if with_bounds: * if isinstance(lows, float): # <<<<<<<<<<<<<< * lows = np.ones(p) * lows * if isinstance(highs, float): */ - __pyx_t_5 = PyFloat_Check(__pyx_v_lows); - __pyx_t_4 = (__pyx_t_5 != 0); - if (__pyx_t_4) { + __pyx_t_4 = PyFloat_Check(__pyx_v_lows); + __pyx_t_5 = (__pyx_t_4 != 0); + if (__pyx_t_5) { - /* "l0learn/interface.pyx":357 + /* "l0learn/interface.pyx":356 * if with_bounds: * if isinstance(lows, float): * lows = np.ones(p) * lows # <<<<<<<<<<<<<< * if isinstance(highs, float): * highs = np.ones(p) * highs */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 357, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 356, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_ones); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 357, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_ones); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 356, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; @@ -6389,16 +6398,16 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx } __pyx_t_7 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_8, __pyx_v_p) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_p); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 357, __pyx_L1_error) + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 356, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PyNumber_Multiply(__pyx_t_7, __pyx_v_lows); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 357, __pyx_L1_error) + __pyx_t_3 = PyNumber_Multiply(__pyx_t_7, __pyx_v_lows); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 356, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":356 + /* "l0learn/interface.pyx":355 * * if with_bounds: * if isinstance(lows, float): # <<<<<<<<<<<<<< @@ -6407,27 +6416,27 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":358 + /* "l0learn/interface.pyx":357 * if isinstance(lows, float): * lows = np.ones(p) * lows * if isinstance(highs, float): # <<<<<<<<<<<<<< * highs = np.ones(p) * highs * */ - __pyx_t_4 = PyFloat_Check(__pyx_v_highs); - __pyx_t_5 = (__pyx_t_4 != 0); - if (__pyx_t_5) { + __pyx_t_5 = PyFloat_Check(__pyx_v_highs); + __pyx_t_4 = (__pyx_t_5 != 0); + if (__pyx_t_4) { - /* "l0learn/interface.pyx":359 + /* "l0learn/interface.pyx":358 * lows = np.ones(p) * lows * if isinstance(highs, float): * highs = np.ones(p) * highs # <<<<<<<<<<<<<< * * if any(lows >= highs): */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 359, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 358, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ones); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 359, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ones); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 358, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; @@ -6442,16 +6451,16 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx } __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_7, __pyx_v_p) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_p); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 359, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 358, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = PyNumber_Multiply(__pyx_t_3, __pyx_v_highs); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 359, __pyx_L1_error) + __pyx_t_8 = PyNumber_Multiply(__pyx_t_3, __pyx_v_highs); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 358, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_8); __pyx_t_8 = 0; - /* "l0learn/interface.pyx":358 + /* "l0learn/interface.pyx":357 * if isinstance(lows, float): * lows = np.ones(p) * lows * if isinstance(highs, float): # <<<<<<<<<<<<<< @@ -6460,34 +6469,34 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":361 + /* "l0learn/interface.pyx":360 * highs = np.ones(p) * highs * * if any(lows >= highs): # <<<<<<<<<<<<<< * bad_bounds = np.argwhere(lows >= highs) * raise ValueError(f"expected to be high to be elementwise greater than lows, " */ - __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 361, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 361, __pyx_L1_error) + __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 360, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 360, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 361, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 360, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(__pyx_t_5)) { + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":362 + /* "l0learn/interface.pyx":361 * * if any(lows >= highs): * bad_bounds = np.argwhere(lows >= highs) # <<<<<<<<<<<<<< * raise ValueError(f"expected to be high to be elementwise greater than lows, " * f"but got indices {bad_bounds[0]} where that is not the case ") */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 362, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 361, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_argwhere); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 362, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_argwhere); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 361, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 362, __pyx_L1_error) + __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 361, __pyx_L1_error) __pyx_t_16 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_7); @@ -6501,20 +6510,20 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_3 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_16, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 362, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 361, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_bad_bounds = __pyx_t_3; __pyx_t_3 = 0; - /* "l0learn/interface.pyx":363 + /* "l0learn/interface.pyx":362 * if any(lows >= highs): * bad_bounds = np.argwhere(lows >= highs) * raise ValueError(f"expected to be high to be elementwise greater than lows, " # <<<<<<<<<<<<<< * f"but got indices {bad_bounds[0]} where that is not the case ") * else: */ - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 363, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 362, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -6523,16 +6532,16 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_GIVEREF(__pyx_kp_u_expected_to_be_high_to_be_elemen); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_to_be_high_to_be_elemen); - /* "l0learn/interface.pyx":364 + /* "l0learn/interface.pyx":363 * bad_bounds = np.argwhere(lows >= highs) * raise ValueError(f"expected to be high to be elementwise greater than lows, " * f"but got indices {bad_bounds[0]} where that is not the case ") # <<<<<<<<<<<<<< * else: * lows = np.array([0.]) */ - __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_bad_bounds, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 364, __pyx_L1_error) + __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_bad_bounds, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 363, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 364, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 363, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; @@ -6545,24 +6554,24 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_GIVEREF(__pyx_kp_u_where_that_is_not_the_case); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_where_that_is_not_the_case); - /* "l0learn/interface.pyx":363 + /* "l0learn/interface.pyx":362 * if any(lows >= highs): * bad_bounds = np.argwhere(lows >= highs) * raise ValueError(f"expected to be high to be elementwise greater than lows, " # <<<<<<<<<<<<<< * f"but got indices {bad_bounds[0]} where that is not the case ") * else: */ - __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 363, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 362, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 363, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 362, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 363, __pyx_L1_error) + __PYX_ERR(0, 362, __pyx_L1_error) - /* "l0learn/interface.pyx":361 + /* "l0learn/interface.pyx":360 * highs = np.ones(p) * highs * * if any(lows >= highs): # <<<<<<<<<<<<<< @@ -6571,17 +6580,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":355 + /* "l0learn/interface.pyx":354 * f"non-negative floats, but got {highs}") * * if with_bounds: # <<<<<<<<<<<<<< * if isinstance(lows, float): * lows = np.ones(p) * lows */ - goto __pyx_L93; + goto __pyx_L95; } - /* "l0learn/interface.pyx":366 + /* "l0learn/interface.pyx":365 * f"but got indices {bad_bounds[0]} where that is not the case ") * else: * lows = np.array([0.]) # <<<<<<<<<<<<<< @@ -6589,12 +6598,12 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx * */ /*else*/ { - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 366, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 365, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_array); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 366, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_array); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 365, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = PyList_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 366, __pyx_L1_error) + __pyx_t_8 = PyList_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 365, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_INCREF(__pyx_float_0_); __Pyx_GIVEREF(__pyx_float_0_); @@ -6612,25 +6621,25 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_3 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_16, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 366, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 365, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":367 + /* "l0learn/interface.pyx":366 * else: * lows = np.array([0.]) * highs = np.array(([0.])) # <<<<<<<<<<<<<< * * cdef vector[vector[double]] c_lambda_grid */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 367, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 366, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_array); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 367, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_array); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 366, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = PyList_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 367, __pyx_L1_error) + __pyx_t_7 = PyList_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 366, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_INCREF(__pyx_float_0_); __Pyx_GIVEREF(__pyx_float_0_); @@ -6648,15 +6657,15 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_3 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_16, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 367, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 366, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_3); __pyx_t_3 = 0; } - __pyx_L93:; + __pyx_L95:; - /* "l0learn/interface.pyx":370 + /* "l0learn/interface.pyx":369 * * cdef vector[vector[double]] c_lambda_grid * try: # <<<<<<<<<<<<<< @@ -6672,17 +6681,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_XGOTREF(__pyx_t_19); /*try:*/ { - /* "l0learn/interface.pyx":371 + /* "l0learn/interface.pyx":370 * cdef vector[vector[double]] c_lambda_grid * try: * c_lambda_grid = lambda_grid # <<<<<<<<<<<<<< * except TypeError: * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") */ - __pyx_t_20 = __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_lambda_grid); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 371, __pyx_L97_error) + __pyx_t_20 = __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_lambda_grid); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 370, __pyx_L99_error) __pyx_v_c_lambda_grid = __pyx_t_20; - /* "l0learn/interface.pyx":370 + /* "l0learn/interface.pyx":369 * * cdef vector[vector[double]] c_lambda_grid * try: # <<<<<<<<<<<<<< @@ -6693,15 +6702,15 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; - goto __pyx_L102_try_end; - __pyx_L97_error:; + goto __pyx_L104_try_end; + __pyx_L99_error:; __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "l0learn/interface.pyx":372 + /* "l0learn/interface.pyx":371 * try: * c_lambda_grid = lambda_grid * except TypeError: # <<<<<<<<<<<<<< @@ -6711,34 +6720,34 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_21 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); if (__pyx_t_21) { __Pyx_AddTraceback("l0learn.interface.fit", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_8, &__pyx_t_7) < 0) __PYX_ERR(0, 372, __pyx_L99_except_error) + if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_8, &__pyx_t_7) < 0) __PYX_ERR(0, 371, __pyx_L101_except_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GOTREF(__pyx_t_8); __Pyx_GOTREF(__pyx_t_7); - /* "l0learn/interface.pyx":373 + /* "l0learn/interface.pyx":372 * c_lambda_grid = lambda_grid * except TypeError: * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") # <<<<<<<<<<<<<< * * cdef string c_loss = loss.encode('UTF-8') */ - __pyx_t_16 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 373, __pyx_L99_except_error) + __pyx_t_16 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 372, __pyx_L101_except_error) __Pyx_GOTREF(__pyx_t_16); - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_be_a_lis, __pyx_t_16); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 373, __pyx_L99_except_error) + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_be_a_lis, __pyx_t_16); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 372, __pyx_L101_except_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_16 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 373, __pyx_L99_except_error) + __pyx_t_16 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 372, __pyx_L101_except_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_16, 0, 0, 0); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __PYX_ERR(0, 373, __pyx_L99_except_error) + __PYX_ERR(0, 372, __pyx_L101_except_error) } - goto __pyx_L99_except_error; - __pyx_L99_except_error:; + goto __pyx_L101_except_error; + __pyx_L101_except_error:; - /* "l0learn/interface.pyx":370 + /* "l0learn/interface.pyx":369 * * cdef vector[vector[double]] c_lambda_grid * try: # <<<<<<<<<<<<<< @@ -6750,10 +6759,10 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_18, __pyx_t_19); goto __pyx_L1_error; - __pyx_L102_try_end:; + __pyx_L104_try_end:; } - /* "l0learn/interface.pyx":375 + /* "l0learn/interface.pyx":374 * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") * * cdef string c_loss = loss.encode('UTF-8') # <<<<<<<<<<<<<< @@ -6762,15 +6771,15 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ if (unlikely(__pyx_v_loss == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 375, __pyx_L1_error) + __PYX_ERR(0, 374, __pyx_L1_error) } - __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_loss); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 375, __pyx_L1_error) + __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_loss); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 374, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 375, __pyx_L1_error) + __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 374, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_c_loss = __pyx_t_22; - /* "l0learn/interface.pyx":376 + /* "l0learn/interface.pyx":375 * * cdef string c_loss = loss.encode('UTF-8') * cdef string c_penalty = penalty.encode('UTF-8') # <<<<<<<<<<<<<< @@ -6779,15 +6788,15 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ if (unlikely(__pyx_v_penalty == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 376, __pyx_L1_error) + __PYX_ERR(0, 375, __pyx_L1_error) } - __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_penalty); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 376, __pyx_L1_error) + __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_penalty); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 375, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 376, __pyx_L1_error) + __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 375, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_c_penalty = __pyx_t_22; - /* "l0learn/interface.pyx":377 + /* "l0learn/interface.pyx":376 * cdef string c_loss = loss.encode('UTF-8') * cdef string c_penalty = penalty.encode('UTF-8') * cdef string c_algorithim = algorithm.encode('UTF-8') # <<<<<<<<<<<<<< @@ -6796,167 +6805,167 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ if (unlikely(__pyx_v_algorithm == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 377, __pyx_L1_error) + __PYX_ERR(0, 376, __pyx_L1_error) } - __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_algorithm); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 377, __pyx_L1_error) + __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_algorithm); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 376, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 377, __pyx_L1_error) + __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 376, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_c_algorithim = __pyx_t_22; - /* "l0learn/interface.pyx":380 + /* "l0learn/interface.pyx":379 * * cdef fitmodel c_results * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), * y=numpy_to_dvec_d(y), */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 380, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 379, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 380, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 379, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_5 = PyObject_IsInstance(__pyx_v_X, __pyx_t_8); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 380, __pyx_L1_error) + __pyx_t_4 = PyObject_IsInstance(__pyx_v_X, __pyx_t_8); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 379, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_4 = (__pyx_t_5 != 0); - if (__pyx_t_4) { + __pyx_t_5 = (__pyx_t_4 != 0); + if (__pyx_t_5) { - /* "l0learn/interface.pyx":381 + /* "l0learn/interface.pyx":380 * cdef fitmodel c_results * if isinstance(X, np.ndarray): * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< * y=numpy_to_dvec_d(y), * Loss=c_loss, */ - if (!(likely(((__pyx_v_X) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_X, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 381, __pyx_L1_error) + if (!(likely(((__pyx_v_X) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_X, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 380, __pyx_L1_error) - /* "l0learn/interface.pyx":382 + /* "l0learn/interface.pyx":381 * if isinstance(X, np.ndarray): * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), * y=numpy_to_dvec_d(y), # <<<<<<<<<<<<<< * Loss=c_loss, * Penalty=c_penalty, */ - if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 382, __pyx_L1_error) + if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 381, __pyx_L1_error) - /* "l0learn/interface.pyx":386 + /* "l0learn/interface.pyx":385 * Penalty=c_penalty, * Algorithm=c_algorithim, * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< * G_ncols=num_lambda, * G_nrows=num_gamma, */ - __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 386, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 385, __pyx_L1_error) - /* "l0learn/interface.pyx":387 + /* "l0learn/interface.pyx":386 * Algorithm=c_algorithim, * NnzStopNum=max_support_size, * G_ncols=num_lambda, # <<<<<<<<<<<<<< * G_nrows=num_gamma, * Lambda2Max=gamma_max, */ - __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 387, __pyx_L1_error) + __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 386, __pyx_L1_error) - /* "l0learn/interface.pyx":388 + /* "l0learn/interface.pyx":387 * NnzStopNum=max_support_size, * G_ncols=num_lambda, * G_nrows=num_gamma, # <<<<<<<<<<<<<< * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, */ - __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 388, __pyx_L1_error) + __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 387, __pyx_L1_error) - /* "l0learn/interface.pyx":391 + /* "l0learn/interface.pyx":390 * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, * PartialSort=partial_sort, # <<<<<<<<<<<<<< * MaxIters=max_iter, * rtol=rtol, */ - __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 391, __pyx_L1_error) + __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 390, __pyx_L1_error) - /* "l0learn/interface.pyx":392 + /* "l0learn/interface.pyx":391 * Lambda2Min=gamma_min, * PartialSort=partial_sort, * MaxIters=max_iter, # <<<<<<<<<<<<<< * rtol=rtol, * atol=atol, */ - __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 392, __pyx_L1_error) + __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 391, __pyx_L1_error) - /* "l0learn/interface.pyx":395 + /* "l0learn/interface.pyx":394 * rtol=rtol, * atol=atol, * ActiveSet=active_set, # <<<<<<<<<<<<<< * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, */ - __pyx_t_28 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_28 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 395, __pyx_L1_error) + __pyx_t_28 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_28 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 394, __pyx_L1_error) - /* "l0learn/interface.pyx":396 + /* "l0learn/interface.pyx":395 * atol=atol, * ActiveSet=active_set, * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, */ - __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 396, __pyx_L1_error) + __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 395, __pyx_L1_error) - /* "l0learn/interface.pyx":397 + /* "l0learn/interface.pyx":396 * ActiveSet=active_set, * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, */ - __pyx_t_30 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_30 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 397, __pyx_L1_error) + __pyx_t_30 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_30 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 396, __pyx_L1_error) - /* "l0learn/interface.pyx":399 + /* "l0learn/interface.pyx":398 * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, # <<<<<<<<<<<<<< * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, */ - __pyx_t_31 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_31 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 399, __pyx_L1_error) + __pyx_t_31 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_31 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 398, __pyx_L1_error) - /* "l0learn/interface.pyx":402 + /* "l0learn/interface.pyx":401 * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< * Intercept=intercept, * withBounds=with_bounds, */ - __pyx_t_32 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_32 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 402, __pyx_L1_error) + __pyx_t_32 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_32 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 401, __pyx_L1_error) - /* "l0learn/interface.pyx":403 + /* "l0learn/interface.pyx":402 * Lambdas=c_lambda_grid, * ExcludeFirstK=exclude_first_k, * Intercept=intercept, # <<<<<<<<<<<<<< * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), */ - __pyx_t_33 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_33 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 403, __pyx_L1_error) + __pyx_t_33 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_33 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 402, __pyx_L1_error) - /* "l0learn/interface.pyx":405 + /* "l0learn/interface.pyx":404 * Intercept=intercept, * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< * Highs=numpy_to_dvec_d(highs)) * else: # isinstance(X, csc_matrix) */ - if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 405, __pyx_L1_error) + if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 404, __pyx_L1_error) - /* "l0learn/interface.pyx":406 + /* "l0learn/interface.pyx":405 * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< * else: # isinstance(X, csc_matrix) * c_results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), */ - if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 406, __pyx_L1_error) + if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 405, __pyx_L1_error) - /* "l0learn/interface.pyx":381 + /* "l0learn/interface.pyx":380 * cdef fitmodel c_results * if isinstance(X, np.ndarray): * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< @@ -6965,17 +6974,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnFit_dense(__pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_X)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_23, __pyx_t_24, __pyx_t_25, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_26, __pyx_t_27, __pyx_v_rtol, __pyx_v_atol, __pyx_t_28, __pyx_t_29, __pyx_t_30, __pyx_v_scale_down_factor, __pyx_t_31, (!(__pyx_v_auto_lambda != 0)), __pyx_v_c_lambda_grid, __pyx_t_32, __pyx_t_33, __pyx_v_with_bounds, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); - /* "l0learn/interface.pyx":380 + /* "l0learn/interface.pyx":379 * * cdef fitmodel c_results * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), * y=numpy_to_dvec_d(y), */ - goto __pyx_L105; + goto __pyx_L107; } - /* "l0learn/interface.pyx":408 + /* "l0learn/interface.pyx":407 * Highs=numpy_to_dvec_d(highs)) * else: # isinstance(X, csc_matrix) * c_results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< @@ -6984,133 +6993,133 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ /*else*/ { - /* "l0learn/interface.pyx":409 + /* "l0learn/interface.pyx":408 * else: # isinstance(X, csc_matrix) * c_results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), * y=numpy_to_dvec_d(y), # <<<<<<<<<<<<<< * Loss=c_loss, * Penalty=c_penalty, */ - if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 409, __pyx_L1_error) + if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 408, __pyx_L1_error) - /* "l0learn/interface.pyx":413 + /* "l0learn/interface.pyx":412 * Penalty=c_penalty, * Algorithm=c_algorithim, * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< * G_ncols=num_lambda, * G_nrows=num_gamma, */ - __pyx_t_32 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_32 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 413, __pyx_L1_error) + __pyx_t_32 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_32 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 412, __pyx_L1_error) - /* "l0learn/interface.pyx":414 + /* "l0learn/interface.pyx":413 * Algorithm=c_algorithim, * NnzStopNum=max_support_size, * G_ncols=num_lambda, # <<<<<<<<<<<<<< * G_nrows=num_gamma, * Lambda2Max=gamma_max, */ - __pyx_t_31 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_31 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 414, __pyx_L1_error) + __pyx_t_31 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_31 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 413, __pyx_L1_error) - /* "l0learn/interface.pyx":415 + /* "l0learn/interface.pyx":414 * NnzStopNum=max_support_size, * G_ncols=num_lambda, * G_nrows=num_gamma, # <<<<<<<<<<<<<< * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, */ - __pyx_t_30 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_30 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 415, __pyx_L1_error) + __pyx_t_30 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_30 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 414, __pyx_L1_error) - /* "l0learn/interface.pyx":418 + /* "l0learn/interface.pyx":417 * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, * PartialSort=partial_sort, # <<<<<<<<<<<<<< * MaxIters=max_iter, * rtol=rtol, */ - __pyx_t_33 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_33 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 418, __pyx_L1_error) + __pyx_t_33 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_33 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 417, __pyx_L1_error) - /* "l0learn/interface.pyx":419 + /* "l0learn/interface.pyx":418 * Lambda2Min=gamma_min, * PartialSort=partial_sort, * MaxIters=max_iter, # <<<<<<<<<<<<<< * rtol=rtol, * atol=atol, */ - __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 419, __pyx_L1_error) + __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 418, __pyx_L1_error) - /* "l0learn/interface.pyx":422 + /* "l0learn/interface.pyx":421 * rtol=rtol, * atol=atol, * ActiveSet=active_set, # <<<<<<<<<<<<<< * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, */ - __pyx_t_28 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_28 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 422, __pyx_L1_error) + __pyx_t_28 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_28 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 421, __pyx_L1_error) - /* "l0learn/interface.pyx":423 + /* "l0learn/interface.pyx":422 * atol=atol, * ActiveSet=active_set, * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, */ - __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 423, __pyx_L1_error) + __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 422, __pyx_L1_error) - /* "l0learn/interface.pyx":424 + /* "l0learn/interface.pyx":423 * ActiveSet=active_set, * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, */ - __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 424, __pyx_L1_error) + __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 423, __pyx_L1_error) - /* "l0learn/interface.pyx":426 + /* "l0learn/interface.pyx":425 * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, # <<<<<<<<<<<<<< * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, */ - __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 426, __pyx_L1_error) + __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 425, __pyx_L1_error) - /* "l0learn/interface.pyx":429 + /* "l0learn/interface.pyx":428 * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< * Intercept=intercept, * withBounds=with_bounds, */ - __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 429, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 428, __pyx_L1_error) - /* "l0learn/interface.pyx":430 + /* "l0learn/interface.pyx":429 * Lambdas=c_lambda_grid, * ExcludeFirstK=exclude_first_k, * Intercept=intercept, # <<<<<<<<<<<<<< * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), */ - __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 430, __pyx_L1_error) + __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 429, __pyx_L1_error) - /* "l0learn/interface.pyx":432 + /* "l0learn/interface.pyx":431 * Intercept=intercept, * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< * Highs=numpy_to_dvec_d(highs)) * */ - if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 432, __pyx_L1_error) + if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 431, __pyx_L1_error) - /* "l0learn/interface.pyx":433 + /* "l0learn/interface.pyx":432 * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< * * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, */ - if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 433, __pyx_L1_error) + if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 432, __pyx_L1_error) - /* "l0learn/interface.pyx":408 + /* "l0learn/interface.pyx":407 * Highs=numpy_to_dvec_d(highs)) * else: # isinstance(X, csc_matrix) * c_results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< @@ -7119,114 +7128,114 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnFit_sparse(__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(__pyx_v_X), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_32, __pyx_t_31, __pyx_t_30, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_33, __pyx_t_29, __pyx_v_rtol, __pyx_v_atol, __pyx_t_28, __pyx_t_27, __pyx_t_25, __pyx_v_scale_down_factor, __pyx_t_24, (!(__pyx_v_auto_lambda != 0)), __pyx_v_c_lambda_grid, __pyx_t_23, __pyx_t_26, __pyx_v_with_bounds, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); } - __pyx_L105:; + __pyx_L107:; - /* "l0learn/interface.pyx":435 + /* "l0learn/interface.pyx":434 * Highs=numpy_to_dvec_d(highs)) * * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, # <<<<<<<<<<<<<< * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_FitModel); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 435, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_FitModel); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 434, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 435, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 434, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_3 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 435, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 434, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 435, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 435, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 435, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_settings, __pyx_t_3) < 0) __PYX_ERR(0, 435, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 434, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 434, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 434, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_settings, __pyx_t_3) < 0) __PYX_ERR(0, 434, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":436 + /* "l0learn/interface.pyx":435 * * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, * lambda_0=c_results.Lambda0, # <<<<<<<<<<<<<< * gamma=c_results.Lambda12, * support_size=c_results.NnzCount, */ - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Lambda0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 436, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Lambda0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 435, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_lambda_0, __pyx_t_3) < 0) __PYX_ERR(0, 435, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_lambda_0, __pyx_t_3) < 0) __PYX_ERR(0, 434, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":437 + /* "l0learn/interface.pyx":436 * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, # <<<<<<<<<<<<<< * support_size=c_results.NnzCount, * coeffs=sp_dmat_field_to_list(c_results.Beta), */ - __pyx_t_3 = __pyx_convert_vector_to_py_double(__pyx_v_c_results.Lambda12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 437, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_double(__pyx_v_c_results.Lambda12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 436, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_gamma, __pyx_t_3) < 0) __PYX_ERR(0, 435, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_gamma, __pyx_t_3) < 0) __PYX_ERR(0, 434, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":438 + /* "l0learn/interface.pyx":437 * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, * support_size=c_results.NnzCount, # <<<<<<<<<<<<<< * coeffs=sp_dmat_field_to_list(c_results.Beta), * intercepts=c_results.Intercept, */ - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(__pyx_v_c_results.NnzCount); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 438, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(__pyx_v_c_results.NnzCount); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 437, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_support_size, __pyx_t_3) < 0) __PYX_ERR(0, 435, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_support_size, __pyx_t_3) < 0) __PYX_ERR(0, 434, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":439 + /* "l0learn/interface.pyx":438 * gamma=c_results.Lambda12, * support_size=c_results.NnzCount, * coeffs=sp_dmat_field_to_list(c_results.Beta), # <<<<<<<<<<<<<< * intercepts=c_results.Intercept, * converged=c_results.Converged) */ - __pyx_t_3 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_c_results.Beta); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 439, __pyx_L1_error) + __pyx_t_3 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_c_results.Beta); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 438, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_coeffs, __pyx_t_3) < 0) __PYX_ERR(0, 435, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_coeffs, __pyx_t_3) < 0) __PYX_ERR(0, 434, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":440 + /* "l0learn/interface.pyx":439 * support_size=c_results.NnzCount, * coeffs=sp_dmat_field_to_list(c_results.Beta), * intercepts=c_results.Intercept, # <<<<<<<<<<<<<< * converged=c_results.Converged) * return results */ - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Intercept); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 440, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Intercept); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 439, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_intercepts, __pyx_t_3) < 0) __PYX_ERR(0, 435, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_intercepts, __pyx_t_3) < 0) __PYX_ERR(0, 434, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":441 + /* "l0learn/interface.pyx":440 * coeffs=sp_dmat_field_to_list(c_results.Beta), * intercepts=c_results.Intercept, * converged=c_results.Converged) # <<<<<<<<<<<<<< * return results * */ - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(__pyx_v_c_results.Converged); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 441, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(__pyx_v_c_results.Converged); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 440, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_converged, __pyx_t_3) < 0) __PYX_ERR(0, 435, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_converged, __pyx_t_3) < 0) __PYX_ERR(0, 434, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":435 + /* "l0learn/interface.pyx":434 * Highs=numpy_to_dvec_d(highs)) * * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, # <<<<<<<<<<<<<< * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_empty_tuple, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 435, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_empty_tuple, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 434, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_results = __pyx_t_3; __pyx_t_3 = 0; - /* "l0learn/interface.pyx":442 + /* "l0learn/interface.pyx":441 * intercepts=c_results.Intercept, * converged=c_results.Converged) * return results # <<<<<<<<<<<<<< @@ -7277,7 +7286,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx return __pyx_r; } -/* "l0learn/interface.pyx":445 +/* "l0learn/interface.pyx":444 * * * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< @@ -7334,7 +7343,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj values[8] = ((PyObject *)__pyx_int_100); values[9] = ((PyObject *)__pyx_int_1); - /* "l0learn/interface.pyx":457 + /* "l0learn/interface.pyx":456 * gamma_max: float = 10., * gamma_min: float = .0001, * partial_sort: bool = True, # <<<<<<<<<<<<<< @@ -7344,7 +7353,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj values[12] = ((PyObject *)Py_True); values[13] = ((PyObject *)__pyx_int_200); - /* "l0learn/interface.pyx":461 + /* "l0learn/interface.pyx":460 * rtol: float = 1e-6, * atol: float = 1e-9, * active_set: bool = True, # <<<<<<<<<<<<<< @@ -7356,7 +7365,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj values[18] = ((PyObject *)__pyx_int_100); values[20] = ((PyObject *)__pyx_int_1000); - /* "l0learn/interface.pyx":466 + /* "l0learn/interface.pyx":465 * scale_down_factor: float = 0.8, * screen_size: int = 1000, * lambda_grid: Optional[List[List[float]]] = None, # <<<<<<<<<<<<<< @@ -7366,7 +7375,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj values[21] = ((PyObject *)Py_None); values[22] = ((PyObject *)__pyx_int_0); - /* "l0learn/interface.pyx":468 + /* "l0learn/interface.pyx":467 * lambda_grid: Optional[List[List[float]]] = None, * exclude_first_k: int = 0, * intercept: bool = True, # <<<<<<<<<<<<<< @@ -7444,7 +7453,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("cvfit", 0, 2, 26, 1); __PYX_ERR(0, 445, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("cvfit", 0, 2, 26, 1); __PYX_ERR(0, 444, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: @@ -7592,7 +7601,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "cvfit") < 0)) __PYX_ERR(0, 445, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "cvfit") < 0)) __PYX_ERR(0, 444, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -7661,24 +7670,24 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj __pyx_v_num_lambda = values[8]; __pyx_v_num_gamma = values[9]; if (values[10]) { - __pyx_v_gamma_max = __pyx_PyFloat_AsDouble(values[10]); if (unlikely((__pyx_v_gamma_max == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 455, __pyx_L3_error) + __pyx_v_gamma_max = __pyx_PyFloat_AsDouble(values[10]); if (unlikely((__pyx_v_gamma_max == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 454, __pyx_L3_error) } else { __pyx_v_gamma_max = ((double)10.); } if (values[11]) { - __pyx_v_gamma_min = __pyx_PyFloat_AsDouble(values[11]); if (unlikely((__pyx_v_gamma_min == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 456, __pyx_L3_error) + __pyx_v_gamma_min = __pyx_PyFloat_AsDouble(values[11]); if (unlikely((__pyx_v_gamma_min == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 455, __pyx_L3_error) } else { __pyx_v_gamma_min = ((double).0001); } __pyx_v_partial_sort = values[12]; __pyx_v_max_iter = values[13]; if (values[14]) { - __pyx_v_rtol = __pyx_PyFloat_AsDouble(values[14]); if (unlikely((__pyx_v_rtol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 459, __pyx_L3_error) + __pyx_v_rtol = __pyx_PyFloat_AsDouble(values[14]); if (unlikely((__pyx_v_rtol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 458, __pyx_L3_error) } else { __pyx_v_rtol = ((double)1e-6); } if (values[15]) { - __pyx_v_atol = __pyx_PyFloat_AsDouble(values[15]); if (unlikely((__pyx_v_atol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 460, __pyx_L3_error) + __pyx_v_atol = __pyx_PyFloat_AsDouble(values[15]); if (unlikely((__pyx_v_atol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 459, __pyx_L3_error) } else { __pyx_v_atol = ((double)1e-9); } @@ -7686,7 +7695,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj __pyx_v_active_set_num = values[17]; __pyx_v_max_swaps = values[18]; if (values[19]) { - __pyx_v_scale_down_factor = __pyx_PyFloat_AsDouble(values[19]); if (unlikely((__pyx_v_scale_down_factor == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 464, __pyx_L3_error) + __pyx_v_scale_down_factor = __pyx_PyFloat_AsDouble(values[19]); if (unlikely((__pyx_v_scale_down_factor == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 463, __pyx_L3_error) } else { __pyx_v_scale_down_factor = ((double)0.8); } @@ -7699,18 +7708,18 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("cvfit", 0, 2, 26, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 445, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("cvfit", 0, 2, 26, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 444, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("l0learn.interface.cvfit", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loss), (&PyUnicode_Type), 1, "loss", 1))) __PYX_ERR(0, 447, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_penalty), (&PyUnicode_Type), 1, "penalty", 1))) __PYX_ERR(0, 448, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_algorithm), (&PyUnicode_Type), 1, "algorithm", 1))) __PYX_ERR(0, 449, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loss), (&PyUnicode_Type), 1, "loss", 1))) __PYX_ERR(0, 446, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_penalty), (&PyUnicode_Type), 1, "penalty", 1))) __PYX_ERR(0, 447, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_algorithm), (&PyUnicode_Type), 1, "algorithm", 1))) __PYX_ERR(0, 448, __pyx_L1_error) __pyx_r = __pyx_pf_7l0learn_9interface_4cvfit(__pyx_self, __pyx_v_X, __pyx_v_y, __pyx_v_loss, __pyx_v_penalty, __pyx_v_algorithm, __pyx_v_num_folds, __pyx_v_seed, __pyx_v_max_support_size, __pyx_v_num_lambda, __pyx_v_num_gamma, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_v_partial_sort, __pyx_v_max_iter, __pyx_v_rtol, __pyx_v_atol, __pyx_v_active_set, __pyx_v_active_set_num, __pyx_v_max_swaps, __pyx_v_scale_down_factor, __pyx_v_screen_size, __pyx_v_lambda_grid, __pyx_v_exclude_first_k, __pyx_v_intercept, __pyx_v_lows, __pyx_v_highs); - /* "l0learn/interface.pyx":445 + /* "l0learn/interface.pyx":444 * * * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< @@ -7794,19 +7803,19 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_INCREF(__pyx_v_lows); __Pyx_INCREF(__pyx_v_highs); - /* "l0learn/interface.pyx":471 + /* "l0learn/interface.pyx":470 * lows: Union[np.ndarray, float] = -float('inf'), * highs: Union[np.ndarray, float] = +float('inf'),): * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): # <<<<<<<<<<<<<< * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") * */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 471, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 470, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 471, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 470, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 471, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 470, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_5 = PyObject_IsInstance(__pyx_v_X, __pyx_t_3); __pyx_t_6 = (__pyx_t_5 != 0); @@ -7827,9 +7836,9 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_1 = __pyx_t_5; goto __pyx_L4_bool_binop_done; } - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 471, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 470, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 471, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 470, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; @@ -7844,10 +7853,10 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p } __pyx_t_3 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_2, __pyx_v_X) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_X); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 471, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 470, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 471, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 470, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_4 = ((!__pyx_t_5) != 0); if (!__pyx_t_4) { @@ -7855,24 +7864,24 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_1 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 471, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 470, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyInt_NeObjC(__pyx_t_3, __pyx_int_2, 2, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 471, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_NeObjC(__pyx_t_3, __pyx_int_2, 2, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 470, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 471, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 470, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (!__pyx_t_4) { } else { __pyx_t_1 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 471, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 470, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_product); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 471, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_product); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 470, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 471, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 470, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_8 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -7887,24 +7896,24 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_7 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_8, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 471, __pyx_L1_error) + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 470, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 471, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 470, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_5 = ((!__pyx_t_4) != 0); __pyx_t_1 = __pyx_t_5; __pyx_L4_bool_binop_done:; if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":472 + /* "l0learn/interface.pyx":471 * highs: Union[np.ndarray, float] = +float('inf'),): * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") # <<<<<<<<<<<<<< * * n, p = X.shape */ - __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 472, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 471, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -7912,7 +7921,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_9 += 71; __Pyx_GIVEREF(__pyx_kp_u_expected_X_to_be_a_2D_non_degene); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_X_to_be_a_2D_non_degene); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_X, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 472, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_X, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 471, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); @@ -7923,17 +7932,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_9 += 1; __Pyx_GIVEREF(__pyx_kp_u__5); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u__5); - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 472, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 471, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 472, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 471, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 472, __pyx_L1_error) + __PYX_ERR(0, 471, __pyx_L1_error) - /* "l0learn/interface.pyx":471 + /* "l0learn/interface.pyx":470 * lows: Union[np.ndarray, float] = -float('inf'), * highs: Union[np.ndarray, float] = +float('inf'),): * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): # <<<<<<<<<<<<<< @@ -7942,14 +7951,14 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":474 + /* "l0learn/interface.pyx":473 * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") * * n, p = X.shape # <<<<<<<<<<<<<< * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") */ - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 474, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 473, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if ((likely(PyTuple_CheckExact(__pyx_t_7))) || (PyList_CheckExact(__pyx_t_7))) { PyObject* sequence = __pyx_t_7; @@ -7957,7 +7966,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 474, __pyx_L1_error) + __PYX_ERR(0, 473, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { @@ -7970,15 +7979,15 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); #else - __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 474, __pyx_L1_error) + __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 473, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 474, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 473, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else { Py_ssize_t index = -1; - __pyx_t_8 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 474, __pyx_L1_error) + __pyx_t_8 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 473, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_11 = Py_TYPE(__pyx_t_8)->tp_iternext; @@ -7986,7 +7995,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_GOTREF(__pyx_t_2); index = 1; __pyx_t_3 = __pyx_t_11(__pyx_t_8); if (unlikely(!__pyx_t_3)) goto __pyx_L10_unpacking_failed; __Pyx_GOTREF(__pyx_t_3); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_8), 2) < 0) __PYX_ERR(0, 474, __pyx_L1_error) + if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_8), 2) < 0) __PYX_ERR(0, 473, __pyx_L1_error) __pyx_t_11 = NULL; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L11_unpacking_done; @@ -7994,7 +8003,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_11 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 474, __pyx_L1_error) + __PYX_ERR(0, 473, __pyx_L1_error) __pyx_L11_unpacking_done:; } __pyx_v_n = __pyx_t_2; @@ -8002,19 +8011,19 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_v_p = __pyx_t_3; __pyx_t_3 = 0; - /* "l0learn/interface.pyx":475 + /* "l0learn/interface.pyx":474 * * n, p = X.shape * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: # <<<<<<<<<<<<<< * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") * */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 475, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 475, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_5 = PyObject_IsInstance(__pyx_v_y, __pyx_t_3); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 475, __pyx_L1_error) + __pyx_t_5 = PyObject_IsInstance(__pyx_v_y, __pyx_t_3); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 474, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_4 = ((!(__pyx_t_5 != 0)) != 0); if (!__pyx_t_4) { @@ -8022,9 +8031,9 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_1 = __pyx_t_4; goto __pyx_L13_bool_binop_done; } - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 475, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 475, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; @@ -8039,10 +8048,10 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p } __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_7, __pyx_v_y) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_y); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 475, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 475, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 474, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_5 = ((!__pyx_t_4) != 0); if (!__pyx_t_5) { @@ -8050,37 +8059,37 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_1 = __pyx_t_5; goto __pyx_L13_bool_binop_done; } - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_y, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 475, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_y, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_PyInt_NeObjC(__pyx_t_3, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 475, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_NeObjC(__pyx_t_3, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 475, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 474, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (!__pyx_t_5) { } else { __pyx_t_1 = __pyx_t_5; goto __pyx_L13_bool_binop_done; } - __pyx_t_9 = PyObject_Length(__pyx_v_y); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 475, __pyx_L1_error) - __pyx_t_2 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 475, __pyx_L1_error) + __pyx_t_9 = PyObject_Length(__pyx_v_y); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 474, __pyx_L1_error) + __pyx_t_2 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyObject_RichCompare(__pyx_t_2, __pyx_v_n, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 475, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_t_2, __pyx_v_n, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 474, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 475, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 474, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = __pyx_t_5; __pyx_L13_bool_binop_done:; if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":476 + /* "l0learn/interface.pyx":475 * n, p = X.shape * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") # <<<<<<<<<<<<<< * * if loss not in SUPPORTED_LOSS: */ - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 476, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 475, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -8088,7 +8097,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_9 += 42; __Pyx_GIVEREF(__pyx_kp_u_expected_y_to_be_a_1D_real_numpy); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_y_to_be_a_1D_real_numpy); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_y, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 476, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_y, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 475, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); @@ -8099,17 +8108,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_9 += 1; __Pyx_GIVEREF(__pyx_kp_u__5); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u__5); - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 476, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 475, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 476, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 475, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 476, __pyx_L1_error) + __PYX_ERR(0, 475, __pyx_L1_error) - /* "l0learn/interface.pyx":475 + /* "l0learn/interface.pyx":474 * * n, p = X.shape * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: # <<<<<<<<<<<<<< @@ -8118,28 +8127,28 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":478 + /* "l0learn/interface.pyx":477 * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") * * if loss not in SUPPORTED_LOSS: # <<<<<<<<<<<<<< * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") * */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 478, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 477, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_loss, __pyx_t_3, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 478, __pyx_L1_error) + __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_loss, __pyx_t_3, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 477, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_5 = (__pyx_t_1 != 0); if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":479 + /* "l0learn/interface.pyx":478 * * if loss not in SUPPORTED_LOSS: * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") # <<<<<<<<<<<<<< * * if penalty not in SUPPORTED_PENALTY: */ - __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 479, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 478, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -8147,9 +8156,9 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_9 += 36; __Pyx_GIVEREF(__pyx_kp_u_expected_loss_parameter_to_be_on); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_loss_parameter_to_be_on); - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 479, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 478, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 479, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 478, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; @@ -8161,24 +8170,24 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_9 += 10; __Pyx_GIVEREF(__pyx_kp_u_but_got); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_but_got); - __pyx_t_7 = __Pyx_PyUnicode_Unicode(__pyx_v_loss); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 479, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyUnicode_Unicode(__pyx_v_loss); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 478, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 479, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 478, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 479, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 478, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 479, __pyx_L1_error) + __PYX_ERR(0, 478, __pyx_L1_error) - /* "l0learn/interface.pyx":478 + /* "l0learn/interface.pyx":477 * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") * * if loss not in SUPPORTED_LOSS: # <<<<<<<<<<<<<< @@ -8187,28 +8196,28 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":481 + /* "l0learn/interface.pyx":480 * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") * * if penalty not in SUPPORTED_PENALTY: # <<<<<<<<<<<<<< * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") * if algorithm not in SUPPORTED_ALGORITHM: */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SUPPORTED_PENALTY); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 481, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SUPPORTED_PENALTY); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 480, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_v_penalty, __pyx_t_3, Py_NE)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 481, __pyx_L1_error) + __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_v_penalty, __pyx_t_3, Py_NE)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 480, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = (__pyx_t_5 != 0); if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":482 + /* "l0learn/interface.pyx":481 * * if penalty not in SUPPORTED_PENALTY: * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") # <<<<<<<<<<<<<< * if algorithm not in SUPPORTED_ALGORITHM: * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") */ - __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 482, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 481, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -8216,9 +8225,9 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_9 += 39; __Pyx_GIVEREF(__pyx_kp_u_expected_penalty_parameter_to_be); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_penalty_parameter_to_be); - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_SUPPORTED_PENALTY); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 482, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_SUPPORTED_PENALTY); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 481, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 482, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 481, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; @@ -8230,24 +8239,24 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_9 += 10; __Pyx_GIVEREF(__pyx_kp_u_but_got); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_but_got); - __pyx_t_2 = __Pyx_PyUnicode_Unicode(__pyx_v_penalty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 482, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyUnicode_Unicode(__pyx_v_penalty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 481, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 482, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 481, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 482, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 481, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 482, __pyx_L1_error) + __PYX_ERR(0, 481, __pyx_L1_error) - /* "l0learn/interface.pyx":481 + /* "l0learn/interface.pyx":480 * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") * * if penalty not in SUPPORTED_PENALTY: # <<<<<<<<<<<<<< @@ -8256,28 +8265,28 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":483 + /* "l0learn/interface.pyx":482 * if penalty not in SUPPORTED_PENALTY: * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") * if algorithm not in SUPPORTED_ALGORITHM: # <<<<<<<<<<<<<< * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") * if not isinstance(num_folds, int) or num_folds < 2: */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SUPPORTED_ALGORITHM); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 483, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SUPPORTED_ALGORITHM); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 482, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_algorithm, __pyx_t_3, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 483, __pyx_L1_error) + __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_algorithm, __pyx_t_3, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 482, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_5 = (__pyx_t_1 != 0); if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":484 + /* "l0learn/interface.pyx":483 * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") * if algorithm not in SUPPORTED_ALGORITHM: * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") # <<<<<<<<<<<<<< * if not isinstance(num_folds, int) or num_folds < 2: * raise ValueError(f"expected num_folds parameter to be a integer greater than 2, but got {num_folds}") */ - __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 484, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 483, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -8285,9 +8294,9 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_9 += 41; __Pyx_GIVEREF(__pyx_kp_u_expected_algorithm_parameter_to); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_algorithm_parameter_to); - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SUPPORTED_ALGORITHM); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 484, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SUPPORTED_ALGORITHM); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 483, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 484, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 483, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; @@ -8299,24 +8308,24 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_9 += 10; __Pyx_GIVEREF(__pyx_kp_u_but_got); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_but_got); - __pyx_t_7 = __Pyx_PyUnicode_Unicode(__pyx_v_algorithm); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 484, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyUnicode_Unicode(__pyx_v_algorithm); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 483, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 484, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 483, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 484, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 483, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 484, __pyx_L1_error) + __PYX_ERR(0, 483, __pyx_L1_error) - /* "l0learn/interface.pyx":483 + /* "l0learn/interface.pyx":482 * if penalty not in SUPPORTED_PENALTY: * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") * if algorithm not in SUPPORTED_ALGORITHM: # <<<<<<<<<<<<<< @@ -8325,7 +8334,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":485 + /* "l0learn/interface.pyx":484 * if algorithm not in SUPPORTED_ALGORITHM: * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") * if not isinstance(num_folds, int) or num_folds < 2: # <<<<<<<<<<<<<< @@ -8339,33 +8348,33 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_5 = __pyx_t_4; goto __pyx_L21_bool_binop_done; } - __pyx_t_3 = PyObject_RichCompare(__pyx_v_num_folds, __pyx_int_2, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 485, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 485, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_num_folds, __pyx_int_2, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 484, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 484, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_5 = __pyx_t_4; __pyx_L21_bool_binop_done:; if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":486 + /* "l0learn/interface.pyx":485 * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") * if not isinstance(num_folds, int) or num_folds < 2: * raise ValueError(f"expected num_folds parameter to be a integer greater than 2, but got {num_folds}") # <<<<<<<<<<<<<< * if not isinstance(seed, int): * raise ValueError(f"expected seed parameter to be an integer, but got {seed}") */ - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_num_folds, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 486, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_num_folds, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 485, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_folds_parameter_to, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 486, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_folds_parameter_to, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 485, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 486, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 485, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 486, __pyx_L1_error) + __PYX_ERR(0, 485, __pyx_L1_error) - /* "l0learn/interface.pyx":485 + /* "l0learn/interface.pyx":484 * if algorithm not in SUPPORTED_ALGORITHM: * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") * if not isinstance(num_folds, int) or num_folds < 2: # <<<<<<<<<<<<<< @@ -8374,7 +8383,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":487 + /* "l0learn/interface.pyx":486 * if not isinstance(num_folds, int) or num_folds < 2: * raise ValueError(f"expected num_folds parameter to be a integer greater than 2, but got {num_folds}") * if not isinstance(seed, int): # <<<<<<<<<<<<<< @@ -8385,26 +8394,26 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_4 = ((!(__pyx_t_5 != 0)) != 0); if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":488 + /* "l0learn/interface.pyx":487 * raise ValueError(f"expected num_folds parameter to be a integer greater than 2, but got {num_folds}") * if not isinstance(seed, int): * raise ValueError(f"expected seed parameter to be an integer, but got {seed}") # <<<<<<<<<<<<<< * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," */ - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_seed, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 488, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_seed, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 487, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_seed_parameter_to_be_an, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 488, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_seed_parameter_to_be_an, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 487, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 488, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 487, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 488, __pyx_L1_error) + __PYX_ERR(0, 487, __pyx_L1_error) - /* "l0learn/interface.pyx":487 + /* "l0learn/interface.pyx":486 * if not isinstance(num_folds, int) or num_folds < 2: * raise ValueError(f"expected num_folds parameter to be a integer greater than 2, but got {num_folds}") * if not isinstance(seed, int): # <<<<<<<<<<<<<< @@ -8413,7 +8422,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":489 + /* "l0learn/interface.pyx":488 * if not isinstance(seed, int): * raise ValueError(f"expected seed parameter to be an integer, but got {seed}") * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): # <<<<<<<<<<<<<< @@ -8427,26 +8436,26 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_4 = __pyx_t_1; goto __pyx_L25_bool_binop_done; } - __pyx_t_3 = PyObject_RichCompare(__pyx_int_0, __pyx_v_max_support_size, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 489, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_int_0, __pyx_v_max_support_size, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 488, __pyx_L1_error) if (__Pyx_PyObject_IsTrue(__pyx_t_3)) { __Pyx_DECREF(__pyx_t_3); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_max_support_size, __pyx_v_p, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 489, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_max_support_size, __pyx_v_p, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 488, __pyx_L1_error) } - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 489, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 488, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_5 = ((!__pyx_t_1) != 0); __pyx_t_4 = __pyx_t_5; __pyx_L25_bool_binop_done:; if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":490 + /* "l0learn/interface.pyx":489 * raise ValueError(f"expected seed parameter to be an integer, but got {seed}") * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," # <<<<<<<<<<<<<< * f" but got {max_support_size}") * if gamma_max < 0: */ - __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 490, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 489, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -8454,7 +8463,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_9 += 71; __Pyx_GIVEREF(__pyx_kp_u_expected_max_support_size_parame); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_max_support_size_parame); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 490, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 489, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); @@ -8466,14 +8475,14 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_GIVEREF(__pyx_kp_u_but_got); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_but_got); - /* "l0learn/interface.pyx":491 + /* "l0learn/interface.pyx":490 * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," * f" but got {max_support_size}") # <<<<<<<<<<<<<< * if gamma_max < 0: * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") */ - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_max_support_size, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 491, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_max_support_size, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 490, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); @@ -8481,24 +8490,24 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_7); __pyx_t_7 = 0; - /* "l0learn/interface.pyx":490 + /* "l0learn/interface.pyx":489 * raise ValueError(f"expected seed parameter to be an integer, but got {seed}") * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," # <<<<<<<<<<<<<< * f" but got {max_support_size}") * if gamma_max < 0: */ - __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 490, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 489, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 490, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 489, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 490, __pyx_L1_error) + __PYX_ERR(0, 489, __pyx_L1_error) - /* "l0learn/interface.pyx":489 + /* "l0learn/interface.pyx":488 * if not isinstance(seed, int): * raise ValueError(f"expected seed parameter to be an integer, but got {seed}") * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): # <<<<<<<<<<<<<< @@ -8507,7 +8516,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":492 + /* "l0learn/interface.pyx":491 * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," * f" but got {max_support_size}") * if gamma_max < 0: # <<<<<<<<<<<<<< @@ -8517,29 +8526,29 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_4 = ((__pyx_v_gamma_max < 0.0) != 0); if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":493 + /* "l0learn/interface.pyx":492 * f" but got {max_support_size}") * if gamma_max < 0: * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") # <<<<<<<<<<<<<< * if gamma_min < 0 or gamma_min > gamma_max: * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," */ - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 493, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 492, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 493, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 492, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_gamma_max_parameter_to, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 493, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_gamma_max_parameter_to, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 492, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 493, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 492, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 493, __pyx_L1_error) + __PYX_ERR(0, 492, __pyx_L1_error) - /* "l0learn/interface.pyx":492 + /* "l0learn/interface.pyx":491 * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," * f" but got {max_support_size}") * if gamma_max < 0: # <<<<<<<<<<<<<< @@ -8548,7 +8557,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":494 + /* "l0learn/interface.pyx":493 * if gamma_max < 0: * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") * if gamma_min < 0 or gamma_min > gamma_max: # <<<<<<<<<<<<<< @@ -8566,37 +8575,37 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_L29_bool_binop_done:; if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":496 + /* "l0learn/interface.pyx":495 * if gamma_min < 0 or gamma_min > gamma_max: * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," * f" but got {gamma_min}") # <<<<<<<<<<<<<< * if not isinstance(partial_sort, bool): * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") */ - __pyx_t_7 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 496, __pyx_L1_error) + __pyx_t_7 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 495, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 496, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 495, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - /* "l0learn/interface.pyx":495 + /* "l0learn/interface.pyx":494 * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") * if gamma_min < 0 or gamma_min > gamma_max: * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," # <<<<<<<<<<<<<< * f" but got {gamma_min}") * if not isinstance(partial_sort, bool): */ - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_gamma_max_parameter_to_2, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 495, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_gamma_max_parameter_to_2, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 494, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 495, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 494, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 495, __pyx_L1_error) + __PYX_ERR(0, 494, __pyx_L1_error) - /* "l0learn/interface.pyx":494 + /* "l0learn/interface.pyx":493 * if gamma_max < 0: * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") * if gamma_min < 0 or gamma_min > gamma_max: # <<<<<<<<<<<<<< @@ -8605,7 +8614,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":497 + /* "l0learn/interface.pyx":496 * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," * f" but got {gamma_min}") * if not isinstance(partial_sort, bool): # <<<<<<<<<<<<<< @@ -8614,31 +8623,31 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ __pyx_t_3 = ((PyObject*)&PyBool_Type); __Pyx_INCREF(__pyx_t_3); - __pyx_t_4 = PyObject_IsInstance(__pyx_v_partial_sort, __pyx_t_3); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 497, __pyx_L1_error) + __pyx_t_4 = PyObject_IsInstance(__pyx_v_partial_sort, __pyx_t_3); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 496, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":498 + /* "l0learn/interface.pyx":497 * f" but got {gamma_min}") * if not isinstance(partial_sort, bool): * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") # <<<<<<<<<<<<<< * if not isinstance(max_iter, int) or max_iter < 1: * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") */ - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_partial_sort, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 498, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_partial_sort, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 497, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_partial_sort_parameter, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 498, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_partial_sort_parameter, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 497, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 498, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 497, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 498, __pyx_L1_error) + __PYX_ERR(0, 497, __pyx_L1_error) - /* "l0learn/interface.pyx":497 + /* "l0learn/interface.pyx":496 * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," * f" but got {gamma_min}") * if not isinstance(partial_sort, bool): # <<<<<<<<<<<<<< @@ -8647,7 +8656,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":499 + /* "l0learn/interface.pyx":498 * if not isinstance(partial_sort, bool): * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") * if not isinstance(max_iter, int) or max_iter < 1: # <<<<<<<<<<<<<< @@ -8661,33 +8670,33 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_5 = __pyx_t_1; goto __pyx_L33_bool_binop_done; } - __pyx_t_3 = PyObject_RichCompare(__pyx_v_max_iter, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 499, __pyx_L1_error) - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 499, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_max_iter, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 498, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 498, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_5 = __pyx_t_1; __pyx_L33_bool_binop_done:; if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":500 + /* "l0learn/interface.pyx":499 * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") * if not isinstance(max_iter, int) or max_iter < 1: * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") # <<<<<<<<<<<<<< * if rtol < 0 or rtol >= 1: * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") */ - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_max_iter, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 500, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_max_iter, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 499, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_iter_parameter_to_b, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 500, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_iter_parameter_to_b, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 499, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 500, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 499, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 500, __pyx_L1_error) + __PYX_ERR(0, 499, __pyx_L1_error) - /* "l0learn/interface.pyx":499 + /* "l0learn/interface.pyx":498 * if not isinstance(partial_sort, bool): * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") * if not isinstance(max_iter, int) or max_iter < 1: # <<<<<<<<<<<<<< @@ -8696,7 +8705,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":501 + /* "l0learn/interface.pyx":500 * if not isinstance(max_iter, int) or max_iter < 1: * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") * if rtol < 0 or rtol >= 1: # <<<<<<<<<<<<<< @@ -8714,29 +8723,29 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_L36_bool_binop_done:; if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":502 + /* "l0learn/interface.pyx":501 * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") * if rtol < 0 or rtol >= 1: * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") # <<<<<<<<<<<<<< * if atol < 0: * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") */ - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_rtol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 502, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_rtol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 501, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 502, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 501, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_rtol_parameter_to_exist, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 502, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_rtol_parameter_to_exist, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 501, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 502, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 501, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 502, __pyx_L1_error) + __PYX_ERR(0, 501, __pyx_L1_error) - /* "l0learn/interface.pyx":501 + /* "l0learn/interface.pyx":500 * if not isinstance(max_iter, int) or max_iter < 1: * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") * if rtol < 0 or rtol >= 1: # <<<<<<<<<<<<<< @@ -8745,7 +8754,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":503 + /* "l0learn/interface.pyx":502 * if rtol < 0 or rtol >= 1: * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") * if atol < 0: # <<<<<<<<<<<<<< @@ -8755,29 +8764,29 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_5 = ((__pyx_v_atol < 0.0) != 0); if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":504 + /* "l0learn/interface.pyx":503 * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") * if atol < 0: * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") # <<<<<<<<<<<<<< * if not isinstance(active_set, bool): * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") */ - __pyx_t_7 = PyFloat_FromDouble(__pyx_v_atol); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 504, __pyx_L1_error) + __pyx_t_7 = PyFloat_FromDouble(__pyx_v_atol); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 503, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 504, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 503, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_atol_parameter_to_exist, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 504, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_atol_parameter_to_exist, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 503, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 504, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 503, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 504, __pyx_L1_error) + __PYX_ERR(0, 503, __pyx_L1_error) - /* "l0learn/interface.pyx":503 + /* "l0learn/interface.pyx":502 * if rtol < 0 or rtol >= 1: * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") * if atol < 0: # <<<<<<<<<<<<<< @@ -8786,7 +8795,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":505 + /* "l0learn/interface.pyx":504 * if atol < 0: * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") * if not isinstance(active_set, bool): # <<<<<<<<<<<<<< @@ -8795,31 +8804,31 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ __pyx_t_3 = ((PyObject*)&PyBool_Type); __Pyx_INCREF(__pyx_t_3); - __pyx_t_5 = PyObject_IsInstance(__pyx_v_active_set, __pyx_t_3); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 505, __pyx_L1_error) + __pyx_t_5 = PyObject_IsInstance(__pyx_v_active_set, __pyx_t_3); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 504, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = ((!(__pyx_t_5 != 0)) != 0); if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":506 + /* "l0learn/interface.pyx":505 * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") * if not isinstance(active_set, bool): * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") # <<<<<<<<<<<<<< * if not isinstance(active_set_num, int) or active_set_num < 1: * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") */ - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_active_set, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 506, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_active_set, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 505, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_active_set_parameter_to, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 506, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_active_set_parameter_to, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 505, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 506, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 505, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 506, __pyx_L1_error) + __PYX_ERR(0, 505, __pyx_L1_error) - /* "l0learn/interface.pyx":505 + /* "l0learn/interface.pyx":504 * if atol < 0: * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") * if not isinstance(active_set, bool): # <<<<<<<<<<<<<< @@ -8828,7 +8837,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":507 + /* "l0learn/interface.pyx":506 * if not isinstance(active_set, bool): * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") * if not isinstance(active_set_num, int) or active_set_num < 1: # <<<<<<<<<<<<<< @@ -8842,33 +8851,33 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_1 = __pyx_t_4; goto __pyx_L41_bool_binop_done; } - __pyx_t_3 = PyObject_RichCompare(__pyx_v_active_set_num, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 507, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 507, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_active_set_num, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 506, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 506, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = __pyx_t_4; __pyx_L41_bool_binop_done:; if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":508 + /* "l0learn/interface.pyx":507 * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") * if not isinstance(active_set_num, int) or active_set_num < 1: * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") # <<<<<<<<<<<<<< * if not isinstance(max_swaps, int) or max_swaps < 1: * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") */ - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_active_set_num, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 508, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_active_set_num, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 507, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_active_set_num_paramete, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 508, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_active_set_num_paramete, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 507, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 508, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 507, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 508, __pyx_L1_error) + __PYX_ERR(0, 507, __pyx_L1_error) - /* "l0learn/interface.pyx":507 + /* "l0learn/interface.pyx":506 * if not isinstance(active_set, bool): * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") * if not isinstance(active_set_num, int) or active_set_num < 1: # <<<<<<<<<<<<<< @@ -8877,7 +8886,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":509 + /* "l0learn/interface.pyx":508 * if not isinstance(active_set_num, int) or active_set_num < 1: * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") * if not isinstance(max_swaps, int) or max_swaps < 1: # <<<<<<<<<<<<<< @@ -8891,33 +8900,33 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_1 = __pyx_t_5; goto __pyx_L44_bool_binop_done; } - __pyx_t_3 = PyObject_RichCompare(__pyx_v_max_swaps, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 509, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 509, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_max_swaps, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 508, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 508, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = __pyx_t_5; __pyx_L44_bool_binop_done:; if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":510 + /* "l0learn/interface.pyx":509 * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") * if not isinstance(max_swaps, int) or max_swaps < 1: * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") # <<<<<<<<<<<<<< * if not (0 < scale_down_factor < 1): * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") */ - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_max_swaps, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 510, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_max_swaps, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 509, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_swaps_parameter_to, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 510, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_swaps_parameter_to, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 509, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 510, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 509, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 510, __pyx_L1_error) + __PYX_ERR(0, 509, __pyx_L1_error) - /* "l0learn/interface.pyx":509 + /* "l0learn/interface.pyx":508 * if not isinstance(active_set_num, int) or active_set_num < 1: * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") * if not isinstance(max_swaps, int) or max_swaps < 1: # <<<<<<<<<<<<<< @@ -8926,7 +8935,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":511 + /* "l0learn/interface.pyx":510 * if not isinstance(max_swaps, int) or max_swaps < 1: * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") * if not (0 < scale_down_factor < 1): # <<<<<<<<<<<<<< @@ -8940,29 +8949,29 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_5 = ((!(__pyx_t_1 != 0)) != 0); if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":512 + /* "l0learn/interface.pyx":511 * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") * if not (0 < scale_down_factor < 1): * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") # <<<<<<<<<<<<<< * if not isinstance(screen_size, int) or screen_size < 1: * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") */ - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_scale_down_factor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 512, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_scale_down_factor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 511, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 512, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 511, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_scale_down_factor_param, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 512, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_scale_down_factor_param, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 511, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 512, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 511, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 512, __pyx_L1_error) + __PYX_ERR(0, 511, __pyx_L1_error) - /* "l0learn/interface.pyx":511 + /* "l0learn/interface.pyx":510 * if not isinstance(max_swaps, int) or max_swaps < 1: * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") * if not (0 < scale_down_factor < 1): # <<<<<<<<<<<<<< @@ -8971,7 +8980,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":513 + /* "l0learn/interface.pyx":512 * if not (0 < scale_down_factor < 1): * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") * if not isinstance(screen_size, int) or screen_size < 1: # <<<<<<<<<<<<<< @@ -8985,33 +8994,33 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_5 = __pyx_t_4; goto __pyx_L48_bool_binop_done; } - __pyx_t_7 = PyObject_RichCompare(__pyx_v_screen_size, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 513, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 513, __pyx_L1_error) + __pyx_t_7 = PyObject_RichCompare(__pyx_v_screen_size, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 512, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 512, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_5 = __pyx_t_4; __pyx_L48_bool_binop_done:; if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":514 + /* "l0learn/interface.pyx":513 * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") * if not isinstance(screen_size, int) or screen_size < 1: * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") # <<<<<<<<<<<<<< * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " */ - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_screen_size, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 514, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_screen_size, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 513, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_screen_size_parameter_t_2, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 514, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_screen_size_parameter_t_2, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 513, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 514, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 513, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 514, __pyx_L1_error) + __PYX_ERR(0, 513, __pyx_L1_error) - /* "l0learn/interface.pyx":513 + /* "l0learn/interface.pyx":512 * if not (0 < scale_down_factor < 1): * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") * if not isinstance(screen_size, int) or screen_size < 1: # <<<<<<<<<<<<<< @@ -9020,7 +9029,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":515 + /* "l0learn/interface.pyx":514 * if not isinstance(screen_size, int) or screen_size < 1: * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): # <<<<<<<<<<<<<< @@ -9034,26 +9043,26 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_5 = __pyx_t_1; goto __pyx_L51_bool_binop_done; } - __pyx_t_7 = PyObject_RichCompare(__pyx_int_0, __pyx_v_exclude_first_k, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 515, __pyx_L1_error) + __pyx_t_7 = PyObject_RichCompare(__pyx_int_0, __pyx_v_exclude_first_k, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 514, __pyx_L1_error) if (__Pyx_PyObject_IsTrue(__pyx_t_7)) { __Pyx_DECREF(__pyx_t_7); - __pyx_t_7 = PyObject_RichCompare(__pyx_v_exclude_first_k, __pyx_v_p, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 515, __pyx_L1_error) + __pyx_t_7 = PyObject_RichCompare(__pyx_v_exclude_first_k, __pyx_v_p, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 514, __pyx_L1_error) } - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 515, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 514, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_4 = ((!__pyx_t_1) != 0); __pyx_t_5 = __pyx_t_4; __pyx_L51_bool_binop_done:; if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":516 + /* "l0learn/interface.pyx":515 * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " # <<<<<<<<<<<<<< * f"but got {exclude_first_k}") * if not isinstance(intercept, bool): */ - __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 516, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 515, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -9061,7 +9070,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_9 += 70; __Pyx_GIVEREF(__pyx_kp_u_expected_exclude_first_k_paramet); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_exclude_first_k_paramet); - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 516, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 515, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); @@ -9073,14 +9082,14 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_GIVEREF(__pyx_kp_u_but_got); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_but_got); - /* "l0learn/interface.pyx":517 + /* "l0learn/interface.pyx":516 * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " * f"but got {exclude_first_k}") # <<<<<<<<<<<<<< * if not isinstance(intercept, bool): * raise ValueError(f"expected intercept parameter to be a bool, " */ - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_exclude_first_k, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 517, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_exclude_first_k, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 516, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); @@ -9088,24 +9097,24 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":516 + /* "l0learn/interface.pyx":515 * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " # <<<<<<<<<<<<<< * f"but got {exclude_first_k}") * if not isinstance(intercept, bool): */ - __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 516, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 515, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 516, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 515, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 516, __pyx_L1_error) + __PYX_ERR(0, 515, __pyx_L1_error) - /* "l0learn/interface.pyx":515 + /* "l0learn/interface.pyx":514 * if not isinstance(screen_size, int) or screen_size < 1: * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): # <<<<<<<<<<<<<< @@ -9114,7 +9123,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":518 + /* "l0learn/interface.pyx":517 * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " * f"but got {exclude_first_k}") * if not isinstance(intercept, bool): # <<<<<<<<<<<<<< @@ -9123,39 +9132,39 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ __pyx_t_7 = ((PyObject*)&PyBool_Type); __Pyx_INCREF(__pyx_t_7); - __pyx_t_5 = PyObject_IsInstance(__pyx_v_intercept, __pyx_t_7); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 518, __pyx_L1_error) + __pyx_t_5 = PyObject_IsInstance(__pyx_v_intercept, __pyx_t_7); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 517, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_4 = ((!(__pyx_t_5 != 0)) != 0); if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":520 + /* "l0learn/interface.pyx":519 * if not isinstance(intercept, bool): * raise ValueError(f"expected intercept parameter to be a bool, " * f"but got {intercept}") # <<<<<<<<<<<<<< * * if loss in CLASSIFICATION_LOSS: */ - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_intercept, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 520, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_intercept, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 519, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - /* "l0learn/interface.pyx":519 + /* "l0learn/interface.pyx":518 * f"but got {exclude_first_k}") * if not isinstance(intercept, bool): * raise ValueError(f"expected intercept parameter to be a bool, " # <<<<<<<<<<<<<< * f"but got {intercept}") * */ - __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_intercept_parameter_to, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 519, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_intercept_parameter_to, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 518, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 519, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 518, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 519, __pyx_L1_error) + __PYX_ERR(0, 518, __pyx_L1_error) - /* "l0learn/interface.pyx":518 + /* "l0learn/interface.pyx":517 * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " * f"but got {exclude_first_k}") * if not isinstance(intercept, bool): # <<<<<<<<<<<<<< @@ -9164,30 +9173,30 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":522 + /* "l0learn/interface.pyx":521 * f"but got {intercept}") * * if loss in CLASSIFICATION_LOSS: # <<<<<<<<<<<<<< * unique_items = sorted(np.unique(y)) * if 0 >= len(unique_items) > 2: */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_CLASSIFICATION_LOSS); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 522, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_CLASSIFICATION_LOSS); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 521, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_4 = (__Pyx_PySequence_ContainsTF(__pyx_v_loss, __pyx_t_7, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 522, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PySequence_ContainsTF(__pyx_v_loss, __pyx_t_7, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 521, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_5 = (__pyx_t_4 != 0); if (__pyx_t_5) { - /* "l0learn/interface.pyx":523 + /* "l0learn/interface.pyx":522 * * if loss in CLASSIFICATION_LOSS: * unique_items = sorted(np.unique(y)) # <<<<<<<<<<<<<< * if 0 >= len(unique_items) > 2: * raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 522, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_unique); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 523, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_unique); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 522, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; @@ -9202,19 +9211,19 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p } __pyx_t_3 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_2, __pyx_v_y) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_y); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 523, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 522, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = PySequence_List(__pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 523, __pyx_L1_error) + __pyx_t_8 = PySequence_List(__pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 522, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_7 = ((PyObject*)__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_12 = PyList_Sort(__pyx_t_7); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 523, __pyx_L1_error) + __pyx_t_12 = PyList_Sort(__pyx_t_7); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 522, __pyx_L1_error) __pyx_v_unique_items = ((PyObject*)__pyx_t_7); __pyx_t_7 = 0; - /* "l0learn/interface.pyx":524 + /* "l0learn/interface.pyx":523 * if loss in CLASSIFICATION_LOSS: * unique_items = sorted(np.unique(y)) * if 0 >= len(unique_items) > 2: # <<<<<<<<<<<<<< @@ -9223,9 +9232,9 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ if (unlikely(__pyx_v_unique_items == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(0, 524, __pyx_L1_error) + __PYX_ERR(0, 523, __pyx_L1_error) } - __pyx_t_9 = PyList_GET_SIZE(__pyx_v_unique_items); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 524, __pyx_L1_error) + __pyx_t_9 = PyList_GET_SIZE(__pyx_v_unique_items); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 523, __pyx_L1_error) __pyx_t_5 = (0 >= __pyx_t_9); if (__pyx_t_5) { __pyx_t_5 = (__pyx_t_9 > 2); @@ -9233,34 +9242,34 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_4 = (__pyx_t_5 != 0); if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":526 + /* "l0learn/interface.pyx":525 * if 0 >= len(unique_items) > 2: * raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " * f"but got {unique_items}") # <<<<<<<<<<<<<< * else: * a, *_ = unique_items # a is the lower value */ - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_unique_items, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 526, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_unique_items, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 525, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - /* "l0learn/interface.pyx":525 + /* "l0learn/interface.pyx":524 * unique_items = sorted(np.unique(y)) * if 0 >= len(unique_items) > 2: * raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " # <<<<<<<<<<<<<< * f"but got {unique_items}") * else: */ - __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_y_vector_to_only_have_t, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 525, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_y_vector_to_only_have_t, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 524, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 525, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 524, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 525, __pyx_L1_error) + __PYX_ERR(0, 524, __pyx_L1_error) - /* "l0learn/interface.pyx":524 + /* "l0learn/interface.pyx":523 * if loss in CLASSIFICATION_LOSS: * unique_items = sorted(np.unique(y)) * if 0 >= len(unique_items) > 2: # <<<<<<<<<<<<<< @@ -9269,7 +9278,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":528 + /* "l0learn/interface.pyx":527 * f"but got {unique_items}") * else: * a, *_ = unique_items # a is the lower value # <<<<<<<<<<<<<< @@ -9280,7 +9289,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p { Py_ssize_t index = -1; PyObject** temps[2] = {&__pyx_t_7}; - __pyx_t_8 = PyObject_GetIter(__pyx_v_unique_items); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 528, __pyx_L1_error) + __pyx_t_8 = PyObject_GetIter(__pyx_v_unique_items); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 527, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_11 = Py_TYPE(__pyx_t_8)->tp_iternext; for (index=0; index < 1; index++) { @@ -9293,10 +9302,10 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_11 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 528, __pyx_L1_error) + __PYX_ERR(0, 527, __pyx_L1_error) __pyx_L57_unpacking_done:; } - __pyx_t_3 = PySequence_List(__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 528, __pyx_L1_error) + __pyx_t_3 = PySequence_List(__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 527, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_a = __pyx_t_7; @@ -9304,16 +9313,16 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_v__ = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":529 + /* "l0learn/interface.pyx":528 * else: * a, *_ = unique_items # a is the lower value * y = np.copy(y) # <<<<<<<<<<<<<< * y[y==a] = -1 * y[y!=a] = 1 */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 529, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 528, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_copy); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 529, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_copy); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 528, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; @@ -9328,65 +9337,74 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p } __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_7, __pyx_v_y) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_y); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 529, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 528, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF_SET(__pyx_v_y, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":530 + /* "l0learn/interface.pyx":529 * a, *_ = unique_items # a is the lower value * y = np.copy(y) * y[y==a] = -1 # <<<<<<<<<<<<<< * y[y!=a] = 1 * */ - __pyx_t_3 = PyObject_RichCompare(__pyx_v_y, __pyx_v_a, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 530, __pyx_L1_error) - if (unlikely(PyObject_SetItem(__pyx_v_y, __pyx_t_3, __pyx_int_neg_1) < 0)) __PYX_ERR(0, 530, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_y, __pyx_v_a, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 529, __pyx_L1_error) + if (unlikely(PyObject_SetItem(__pyx_v_y, __pyx_t_3, __pyx_int_neg_1) < 0)) __PYX_ERR(0, 529, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":531 + /* "l0learn/interface.pyx":530 * y = np.copy(y) * y[y==a] = -1 * y[y!=a] = 1 # <<<<<<<<<<<<<< * * if penalty == "L0": */ - __pyx_t_3 = PyObject_RichCompare(__pyx_v_y, __pyx_v_a, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 531, __pyx_L1_error) - if (unlikely(PyObject_SetItem(__pyx_v_y, __pyx_t_3, __pyx_int_1) < 0)) __PYX_ERR(0, 531, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_y, __pyx_v_a, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 530, __pyx_L1_error) + if (unlikely(PyObject_SetItem(__pyx_v_y, __pyx_t_3, __pyx_int_1) < 0)) __PYX_ERR(0, 530, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } - /* "l0learn/interface.pyx":533 + /* "l0learn/interface.pyx":532 * y[y!=a] = 1 * * if penalty == "L0": # <<<<<<<<<<<<<< - * # TODO: Must be corrected in R code: https://github.com/hazimehh/L0Learn/blob/7a65474dfdb01489a0c263d7b24fbafad56fba61/R/fit.R#L136 * # Pure L0 is not supported for classification + * # Below we add a small L2 component. */ - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 533, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 532, __pyx_L1_error) __pyx_t_5 = (__pyx_t_4 != 0); if (__pyx_t_5) { - /* "l0learn/interface.pyx":538 + /* "l0learn/interface.pyx":536 * # Below we add a small L2 component. * - * if len(lambda_grid) != 1: # <<<<<<<<<<<<<< + * if lambda_grid is not None and len(lambda_grid) != 1: # <<<<<<<<<<<<<< * # If this error checking was left to the lower section, it would confuse users as * # we are converting L0 to L0L2 with small L2 penalty. */ - __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 538, __pyx_L1_error) - __pyx_t_5 = ((__pyx_t_9 != 1) != 0); + __pyx_t_4 = (__pyx_v_lambda_grid != Py_None); + __pyx_t_1 = (__pyx_t_4 != 0); + if (__pyx_t_1) { + } else { + __pyx_t_5 = __pyx_t_1; + goto __pyx_L60_bool_binop_done; + } + __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 536, __pyx_L1_error) + __pyx_t_1 = ((__pyx_t_9 != 1) != 0); + __pyx_t_5 = __pyx_t_1; + __pyx_L60_bool_binop_done:; if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":543 + /* "l0learn/interface.pyx":541 * # Here we must check if lambdaGrid is supplied (And thus use 'autolambda') * # If 'lambdaGrid' is supplied, we must only supply 1 list of lambda values * raise ValueError(f"L0 Penalty requires 'lambda_grid' to be a list of length 1, but got {lambda_grid}.") # <<<<<<<<<<<<<< * * penalty = "L0L2" */ - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 543, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 541, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -9394,7 +9412,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_9 += 68; __Pyx_GIVEREF(__pyx_kp_u_L0_Penalty_requires_lambda_grid); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_L0_Penalty_requires_lambda_grid); - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 543, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 541, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); @@ -9405,35 +9423,35 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_9 += 1; __Pyx_GIVEREF(__pyx_kp_u__5); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u__5); - __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 543, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 541, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 543, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 541, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 543, __pyx_L1_error) + __PYX_ERR(0, 541, __pyx_L1_error) - /* "l0learn/interface.pyx":538 + /* "l0learn/interface.pyx":536 * # Below we add a small L2 component. * - * if len(lambda_grid) != 1: # <<<<<<<<<<<<<< + * if lambda_grid is not None and len(lambda_grid) != 1: # <<<<<<<<<<<<<< * # If this error checking was left to the lower section, it would confuse users as * # we are converting L0 to L0L2 with small L2 penalty. */ } - /* "l0learn/interface.pyx":533 + /* "l0learn/interface.pyx":532 * y[y!=a] = 1 * * if penalty == "L0": # <<<<<<<<<<<<<< - * # TODO: Must be corrected in R code: https://github.com/hazimehh/L0Learn/blob/7a65474dfdb01489a0c263d7b24fbafad56fba61/R/fit.R#L136 * # Pure L0 is not supported for classification + * # Below we add a small L2 component. */ } - /* "l0learn/interface.pyx":545 + /* "l0learn/interface.pyx":543 * raise ValueError(f"L0 Penalty requires 'lambda_grid' to be a list of length 1, but got {lambda_grid}.") * * penalty = "L0L2" # <<<<<<<<<<<<<< @@ -9443,7 +9461,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_INCREF(__pyx_n_u_L0L2); __Pyx_DECREF_SET(__pyx_v_penalty, __pyx_n_u_L0L2); - /* "l0learn/interface.pyx":546 + /* "l0learn/interface.pyx":544 * * penalty = "L0L2" * gamma_max = 1e-7 # <<<<<<<<<<<<<< @@ -9452,7 +9470,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ __pyx_v_gamma_max = 1e-7; - /* "l0learn/interface.pyx":547 + /* "l0learn/interface.pyx":545 * penalty = "L0L2" * gamma_max = 1e-7 * gamma_min = 1e-7 # <<<<<<<<<<<<<< @@ -9461,7 +9479,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ __pyx_v_gamma_min = 1e-7; - /* "l0learn/interface.pyx":522 + /* "l0learn/interface.pyx":521 * f"but got {intercept}") * * if loss in CLASSIFICATION_LOSS: # <<<<<<<<<<<<<< @@ -9471,38 +9489,38 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p goto __pyx_L54; } - /* "l0learn/interface.pyx":548 + /* "l0learn/interface.pyx":546 * gamma_max = 1e-7 * gamma_min = 1e-7 * elif penalty != "L0" and num_gamma == 1: # <<<<<<<<<<<<<< * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") * */ - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_NE)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 548, __pyx_L1_error) - __pyx_t_1 = (__pyx_t_4 != 0); - if (__pyx_t_1) { + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 546, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_1 != 0); + if (__pyx_t_4) { } else { - __pyx_t_5 = __pyx_t_1; - goto __pyx_L60_bool_binop_done; + __pyx_t_5 = __pyx_t_4; + goto __pyx_L62_bool_binop_done; } - __pyx_t_3 = __Pyx_PyInt_EqObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 548, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_EqObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 546, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 548, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 546, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_5 = __pyx_t_1; - __pyx_L60_bool_binop_done:; + __pyx_t_5 = __pyx_t_4; + __pyx_L62_bool_binop_done:; if (__pyx_t_5) { - /* "l0learn/interface.pyx":549 + /* "l0learn/interface.pyx":547 * gamma_min = 1e-7 * elif penalty != "L0" and num_gamma == 1: * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") # <<<<<<<<<<<<<< * * if lambda_grid is None: */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_warn); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 549, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_warn); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 547, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = PyTuple_New(5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 549, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 547, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -9510,7 +9528,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_9 += 24; __Pyx_GIVEREF(__pyx_kp_u_num_gamma_set_to_1_with); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_num_gamma_set_to_1_with); - __pyx_t_2 = __Pyx_PyUnicode_Unicode(__pyx_v_penalty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 549, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyUnicode_Unicode(__pyx_v_penalty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 547, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); @@ -9523,9 +9541,9 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_penalty_Only_one); if (unlikely(__pyx_v_penalty == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(0, 549, __pyx_L1_error) + __PYX_ERR(0, 547, __pyx_L1_error) } - __pyx_t_2 = __Pyx_PyUnicode_Substring(__pyx_v_penalty, 2, PY_SSIZE_T_MAX); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 549, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyUnicode_Substring(__pyx_v_penalty, 2, PY_SSIZE_T_MAX); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 547, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); @@ -9536,7 +9554,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_9 += 27; __Pyx_GIVEREF(__pyx_kp_u_penalty_value_will_be_fit); PyTuple_SET_ITEM(__pyx_t_7, 4, __pyx_kp_u_penalty_value_will_be_fit); - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_7, 5, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 549, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_7, 5, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 547, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; @@ -9552,12 +9570,12 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_7, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_2); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 549, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 547, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":548 + /* "l0learn/interface.pyx":546 * gamma_max = 1e-7 * gamma_min = 1e-7 * elif penalty != "L0" and num_gamma == 1: # <<<<<<<<<<<<<< @@ -9567,7 +9585,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p } __pyx_L54:; - /* "l0learn/interface.pyx":551 + /* "l0learn/interface.pyx":549 * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") * * if lambda_grid is None: # <<<<<<<<<<<<<< @@ -9575,22 +9593,22 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p * auto_lambda = True */ __pyx_t_5 = (__pyx_v_lambda_grid == Py_None); - __pyx_t_1 = (__pyx_t_5 != 0); - if (__pyx_t_1) { + __pyx_t_4 = (__pyx_t_5 != 0); + if (__pyx_t_4) { - /* "l0learn/interface.pyx":552 + /* "l0learn/interface.pyx":550 * * if lambda_grid is None: * lambda_grid = [[0.]] # <<<<<<<<<<<<<< * auto_lambda = True * if not isinstance(num_lambda, int) or num_lambda < 1: */ - __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 552, __pyx_L1_error) + __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 550, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_float_0_); __Pyx_GIVEREF(__pyx_float_0_); PyList_SET_ITEM(__pyx_t_3, 0, __pyx_float_0_); - __pyx_t_8 = PyList_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 552, __pyx_L1_error) + __pyx_t_8 = PyList_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 550, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_GIVEREF(__pyx_t_3); PyList_SET_ITEM(__pyx_t_8, 0, __pyx_t_3); @@ -9598,7 +9616,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_DECREF_SET(__pyx_v_lambda_grid, __pyx_t_8); __pyx_t_8 = 0; - /* "l0learn/interface.pyx":553 + /* "l0learn/interface.pyx":551 * if lambda_grid is None: * lambda_grid = [[0.]] * auto_lambda = True # <<<<<<<<<<<<<< @@ -9607,7 +9625,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ __pyx_v_auto_lambda = 1; - /* "l0learn/interface.pyx":554 + /* "l0learn/interface.pyx":552 * lambda_grid = [[0.]] * auto_lambda = True * if not isinstance(num_lambda, int) or num_lambda < 1: # <<<<<<<<<<<<<< @@ -9615,27 +9633,27 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p * if not isinstance(num_gamma, int) or num_gamma < 1: */ __pyx_t_5 = PyInt_Check(__pyx_v_num_lambda); - __pyx_t_4 = ((!(__pyx_t_5 != 0)) != 0); - if (!__pyx_t_4) { + __pyx_t_1 = ((!(__pyx_t_5 != 0)) != 0); + if (!__pyx_t_1) { } else { - __pyx_t_1 = __pyx_t_4; - goto __pyx_L64_bool_binop_done; + __pyx_t_4 = __pyx_t_1; + goto __pyx_L66_bool_binop_done; } - __pyx_t_8 = PyObject_RichCompare(__pyx_v_num_lambda, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 554, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 554, __pyx_L1_error) + __pyx_t_8 = PyObject_RichCompare(__pyx_v_num_lambda, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 552, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 552, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_1 = __pyx_t_4; - __pyx_L64_bool_binop_done:; - if (unlikely(__pyx_t_1)) { + __pyx_t_4 = __pyx_t_1; + __pyx_L66_bool_binop_done:; + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":555 + /* "l0learn/interface.pyx":553 * auto_lambda = True * if not isinstance(num_lambda, int) or num_lambda < 1: * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") # <<<<<<<<<<<<<< * if not isinstance(num_gamma, int) or num_gamma < 1: * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") */ - __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 555, __pyx_L1_error) + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 553, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -9643,7 +9661,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_9 += 76; __Pyx_GIVEREF(__pyx_kp_u_expected_num_lambda_to_a_positiv); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_u_expected_num_lambda_to_a_positiv); - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 555, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 553, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); @@ -9654,17 +9672,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_9 += 1; __Pyx_GIVEREF(__pyx_kp_u__5); PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__5); - __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 555, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 553, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 555, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 553, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 555, __pyx_L1_error) + __PYX_ERR(0, 553, __pyx_L1_error) - /* "l0learn/interface.pyx":554 + /* "l0learn/interface.pyx":552 * lambda_grid = [[0.]] * auto_lambda = True * if not isinstance(num_lambda, int) or num_lambda < 1: # <<<<<<<<<<<<<< @@ -9673,35 +9691,35 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":556 + /* "l0learn/interface.pyx":554 * if not isinstance(num_lambda, int) or num_lambda < 1: * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") * if not isinstance(num_gamma, int) or num_gamma < 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") * if penalty == "L0" and num_gamma != 1: */ - __pyx_t_4 = PyInt_Check(__pyx_v_num_gamma); - __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); + __pyx_t_1 = PyInt_Check(__pyx_v_num_gamma); + __pyx_t_5 = ((!(__pyx_t_1 != 0)) != 0); if (!__pyx_t_5) { } else { - __pyx_t_1 = __pyx_t_5; - goto __pyx_L67_bool_binop_done; + __pyx_t_4 = __pyx_t_5; + goto __pyx_L69_bool_binop_done; } - __pyx_t_8 = PyObject_RichCompare(__pyx_v_num_gamma, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 556, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 556, __pyx_L1_error) + __pyx_t_8 = PyObject_RichCompare(__pyx_v_num_gamma, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 554, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 554, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_1 = __pyx_t_5; - __pyx_L67_bool_binop_done:; - if (unlikely(__pyx_t_1)) { + __pyx_t_4 = __pyx_t_5; + __pyx_L69_bool_binop_done:; + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":557 + /* "l0learn/interface.pyx":555 * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") * if not isinstance(num_gamma, int) or num_gamma < 1: * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") # <<<<<<<<<<<<<< * if penalty == "L0" and num_gamma != 1: * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") */ - __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 557, __pyx_L1_error) + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 555, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -9709,7 +9727,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_9 += 75; __Pyx_GIVEREF(__pyx_kp_u_expected_num_gamma_to_a_positive); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_u_expected_num_gamma_to_a_positive); - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 557, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 555, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); @@ -9720,17 +9738,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_9 += 1; __Pyx_GIVEREF(__pyx_kp_u__5); PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__5); - __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 557, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 555, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 557, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 555, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 557, __pyx_L1_error) + __PYX_ERR(0, 555, __pyx_L1_error) - /* "l0learn/interface.pyx":556 + /* "l0learn/interface.pyx":554 * if not isinstance(num_lambda, int) or num_lambda < 1: * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") * if not isinstance(num_gamma, int) or num_gamma < 1: # <<<<<<<<<<<<<< @@ -9739,36 +9757,36 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":558 + /* "l0learn/interface.pyx":556 * if not isinstance(num_gamma, int) or num_gamma < 1: * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") * else: # lambda_grid should be a List[List[float]] */ - __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 558, __pyx_L1_error) - __pyx_t_4 = (__pyx_t_5 != 0); - if (__pyx_t_4) { + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 556, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_5 != 0); + if (__pyx_t_1) { } else { - __pyx_t_1 = __pyx_t_4; - goto __pyx_L70_bool_binop_done; + __pyx_t_4 = __pyx_t_1; + goto __pyx_L72_bool_binop_done; } - __pyx_t_8 = __Pyx_PyInt_NeObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 558, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_NeObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 556, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 558, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 556, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_1 = __pyx_t_4; - __pyx_L70_bool_binop_done:; - if (unlikely(__pyx_t_1)) { + __pyx_t_4 = __pyx_t_1; + __pyx_L72_bool_binop_done:; + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":559 + /* "l0learn/interface.pyx":557 * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") * if penalty == "L0" and num_gamma != 1: * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") # <<<<<<<<<<<<<< * else: # lambda_grid should be a List[List[float]] * if num_gamma is not None: */ - __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 559, __pyx_L1_error) + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 557, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -9776,7 +9794,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_9 += 53; __Pyx_GIVEREF(__pyx_kp_u_expected_num_gamma_to_1_when_pen); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_u_expected_num_gamma_to_1_when_pen); - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 559, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 557, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); @@ -9787,17 +9805,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_9 += 1; __Pyx_GIVEREF(__pyx_kp_u__5); PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__5); - __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 559, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 557, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 559, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 557, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 559, __pyx_L1_error) + __PYX_ERR(0, 557, __pyx_L1_error) - /* "l0learn/interface.pyx":558 + /* "l0learn/interface.pyx":556 * if not isinstance(num_gamma, int) or num_gamma < 1: * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< @@ -9806,17 +9824,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":551 + /* "l0learn/interface.pyx":549 * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") * * if lambda_grid is None: # <<<<<<<<<<<<<< * lambda_grid = [[0.]] * auto_lambda = True */ - goto __pyx_L62; + goto __pyx_L64; } - /* "l0learn/interface.pyx":561 + /* "l0learn/interface.pyx":559 * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") * else: # lambda_grid should be a List[List[float]] * if num_gamma is not None: # <<<<<<<<<<<<<< @@ -9824,38 +9842,38 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p * f"but got {num_gamma}") */ /*else*/ { - __pyx_t_1 = (__pyx_v_num_gamma != Py_None); - __pyx_t_4 = (__pyx_t_1 != 0); - if (unlikely(__pyx_t_4)) { + __pyx_t_4 = (__pyx_v_num_gamma != Py_None); + __pyx_t_1 = (__pyx_t_4 != 0); + if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":563 + /* "l0learn/interface.pyx":561 * if num_gamma is not None: * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " * f"but got {num_gamma}") # <<<<<<<<<<<<<< * num_gamma = len(lambda_grid) * */ - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 563, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 561, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - /* "l0learn/interface.pyx":562 + /* "l0learn/interface.pyx":560 * else: # lambda_grid should be a List[List[float]] * if num_gamma is not None: * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " # <<<<<<<<<<<<<< * f"but got {num_gamma}") * num_gamma = len(lambda_grid) */ - __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_gamma_to_be_None_if, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 562, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_gamma_to_be_None_if, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 560, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 562, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 560, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 562, __pyx_L1_error) + __PYX_ERR(0, 560, __pyx_L1_error) - /* "l0learn/interface.pyx":561 + /* "l0learn/interface.pyx":559 * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") * else: # lambda_grid should be a List[List[float]] * if num_gamma is not None: # <<<<<<<<<<<<<< @@ -9864,58 +9882,58 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":564 + /* "l0learn/interface.pyx":562 * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " * f"but got {num_gamma}") * num_gamma = len(lambda_grid) # <<<<<<<<<<<<<< * * if num_lambda is not None: */ - __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 564, __pyx_L1_error) - __pyx_t_8 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 564, __pyx_L1_error) + __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 562, __pyx_L1_error) + __pyx_t_8 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 562, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF_SET(__pyx_v_num_gamma, __pyx_t_8); __pyx_t_8 = 0; - /* "l0learn/interface.pyx":566 + /* "l0learn/interface.pyx":564 * num_gamma = len(lambda_grid) * * if num_lambda is not None: # <<<<<<<<<<<<<< * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " * f"but got {num_lambda}") */ - __pyx_t_4 = (__pyx_v_num_lambda != Py_None); - __pyx_t_1 = (__pyx_t_4 != 0); - if (unlikely(__pyx_t_1)) { + __pyx_t_1 = (__pyx_v_num_lambda != Py_None); + __pyx_t_4 = (__pyx_t_1 != 0); + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":568 + /* "l0learn/interface.pyx":566 * if num_lambda is not None: * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " * f"but got {num_lambda}") # <<<<<<<<<<<<<< * num_lambda = 0 # This value is ignored. * auto_lambda = False */ - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 568, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 566, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - /* "l0learn/interface.pyx":567 + /* "l0learn/interface.pyx":565 * * if num_lambda is not None: * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " # <<<<<<<<<<<<<< * f"but got {num_lambda}") * num_lambda = 0 # This value is ignored. */ - __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_lambda_to_be_None_i, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 567, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_lambda_to_be_None_i, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 565, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 567, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 565, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 567, __pyx_L1_error) + __PYX_ERR(0, 565, __pyx_L1_error) - /* "l0learn/interface.pyx":566 + /* "l0learn/interface.pyx":564 * num_gamma = len(lambda_grid) * * if num_lambda is not None: # <<<<<<<<<<<<<< @@ -9924,7 +9942,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":569 + /* "l0learn/interface.pyx":567 * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " * f"but got {num_lambda}") * num_lambda = 0 # This value is ignored. # <<<<<<<<<<<<<< @@ -9934,7 +9952,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_INCREF(__pyx_int_0); __Pyx_DECREF_SET(__pyx_v_num_lambda, __pyx_int_0); - /* "l0learn/interface.pyx":570 + /* "l0learn/interface.pyx":568 * f"but got {num_lambda}") * num_lambda = 0 # This value is ignored. * auto_lambda = False # <<<<<<<<<<<<<< @@ -9943,7 +9961,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ __pyx_v_auto_lambda = 0; - /* "l0learn/interface.pyx":571 + /* "l0learn/interface.pyx":569 * num_lambda = 0 # This value is ignored. * auto_lambda = False * bad_lambda_grid = False # <<<<<<<<<<<<<< @@ -9952,49 +9970,49 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ __pyx_v_bad_lambda_grid = 0; - /* "l0learn/interface.pyx":573 + /* "l0learn/interface.pyx":571 * bad_lambda_grid = False * * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") * */ - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 573, __pyx_L1_error) - __pyx_t_5 = (__pyx_t_4 != 0); + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 571, __pyx_L1_error) + __pyx_t_5 = (__pyx_t_1 != 0); if (__pyx_t_5) { } else { - __pyx_t_1 = __pyx_t_5; - goto __pyx_L75_bool_binop_done; + __pyx_t_4 = __pyx_t_5; + goto __pyx_L77_bool_binop_done; } - __pyx_t_8 = __Pyx_PyInt_NeObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 573, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_NeObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 571, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 573, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 571, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_1 = __pyx_t_5; - __pyx_L75_bool_binop_done:; - if (unlikely(__pyx_t_1)) { + __pyx_t_4 = __pyx_t_5; + __pyx_L77_bool_binop_done:; + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":574 + /* "l0learn/interface.pyx":572 * * if penalty == "L0" and num_gamma != 1: * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") # <<<<<<<<<<<<<< * * for i, sub_lambda_grid in enumerate(lambda_grid): */ - __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 574, __pyx_L1_error) - __pyx_t_8 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_9, 0, ' ', 'd'); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 574, __pyx_L1_error) + __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 572, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_9, 0, ' ', 'd'); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 572, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_of_lengt, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 574, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_of_lengt, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 572, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 574, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 572, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 574, __pyx_L1_error) + __PYX_ERR(0, 572, __pyx_L1_error) - /* "l0learn/interface.pyx":573 + /* "l0learn/interface.pyx":571 * bad_lambda_grid = False * * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< @@ -10003,7 +10021,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":576 + /* "l0learn/interface.pyx":574 * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") * * for i, sub_lambda_grid in enumerate(lambda_grid): # <<<<<<<<<<<<<< @@ -10016,26 +10034,26 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_3 = __pyx_v_lambda_grid; __Pyx_INCREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_13 = NULL; } else { - __pyx_t_9 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_lambda_grid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 576, __pyx_L1_error) + __pyx_t_9 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_lambda_grid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 574, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_13 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 576, __pyx_L1_error) + __pyx_t_13 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 574, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_13)) { if (likely(PyList_CheckExact(__pyx_t_3))) { if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_2 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_9); __Pyx_INCREF(__pyx_t_2); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 576, __pyx_L1_error) + __pyx_t_2 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_9); __Pyx_INCREF(__pyx_t_2); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 574, __pyx_L1_error) #else - __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 576, __pyx_L1_error) + __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 574, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #endif } else { if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_3)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_9); __Pyx_INCREF(__pyx_t_2); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 576, __pyx_L1_error) + __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_9); __Pyx_INCREF(__pyx_t_2); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 574, __pyx_L1_error) #else - __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 576, __pyx_L1_error) + __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 574, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #endif } @@ -10045,7 +10063,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(0, 576, __pyx_L1_error) + else __PYX_ERR(0, 574, __pyx_L1_error) } break; } @@ -10055,45 +10073,45 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_2 = 0; __Pyx_INCREF(__pyx_t_8); __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_8); - __pyx_t_2 = __Pyx_PyInt_AddObjC(__pyx_t_8, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 576, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_AddObjC(__pyx_t_8, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 574, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = __pyx_t_2; __pyx_t_2 = 0; - /* "l0learn/interface.pyx":577 + /* "l0learn/interface.pyx":575 * * for i, sub_lambda_grid in enumerate(lambda_grid): * current = float("inf") # <<<<<<<<<<<<<< * if sub_lambda_grid[0] <= 0: * raise ValueError(f"Expected all values of lambda_grid to be positive, " */ - __pyx_t_14 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 577, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 575, __pyx_L1_error) __pyx_v_current = __pyx_t_14; - /* "l0learn/interface.pyx":578 + /* "l0learn/interface.pyx":576 * for i, sub_lambda_grid in enumerate(lambda_grid): * current = float("inf") * if sub_lambda_grid[0] <= 0: # <<<<<<<<<<<<<< * raise ValueError(f"Expected all values of lambda_grid to be positive, " * f"but got lambda_grid[{i}] containing a negative value") */ - __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_sub_lambda_grid, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 578, __pyx_L1_error) + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_sub_lambda_grid, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 576, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = PyObject_RichCompare(__pyx_t_2, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 578, __pyx_L1_error) + __pyx_t_7 = PyObject_RichCompare(__pyx_t_2, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 576, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 578, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 576, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(__pyx_t_1)) { + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":579 + /* "l0learn/interface.pyx":577 * current = float("inf") * if sub_lambda_grid[0] <= 0: * raise ValueError(f"Expected all values of lambda_grid to be positive, " # <<<<<<<<<<<<<< * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): */ - __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 579, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 577, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_15 = 0; __pyx_t_10 = 127; @@ -10102,14 +10120,14 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_GIVEREF(__pyx_kp_u_Expected_all_values_of_lambda_gr); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_Expected_all_values_of_lambda_gr); - /* "l0learn/interface.pyx":580 + /* "l0learn/interface.pyx":578 * if sub_lambda_grid[0] <= 0: * raise ValueError(f"Expected all values of lambda_grid to be positive, " * f"but got lambda_grid[{i}] containing a negative value") # <<<<<<<<<<<<<< * if any(np.diff(sub_lambda_grid) >= 0): * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " */ - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 580, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 578, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; __pyx_t_15 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); @@ -10121,24 +10139,24 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_GIVEREF(__pyx_kp_u_containing_a_negative_value); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_containing_a_negative_value); - /* "l0learn/interface.pyx":579 + /* "l0learn/interface.pyx":577 * current = float("inf") * if sub_lambda_grid[0] <= 0: * raise ValueError(f"Expected all values of lambda_grid to be positive, " # <<<<<<<<<<<<<< * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): */ - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 579, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 577, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 579, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 577, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 579, __pyx_L1_error) + __PYX_ERR(0, 577, __pyx_L1_error) - /* "l0learn/interface.pyx":578 + /* "l0learn/interface.pyx":576 * for i, sub_lambda_grid in enumerate(lambda_grid): * current = float("inf") * if sub_lambda_grid[0] <= 0: # <<<<<<<<<<<<<< @@ -10147,16 +10165,16 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":581 + /* "l0learn/interface.pyx":579 * raise ValueError(f"Expected all values of lambda_grid to be positive, " * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): # <<<<<<<<<<<<<< * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " * f"but got lambda_grid[{i}] containing an increasing value.") */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 581, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 579, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_diff); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 581, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_diff); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 579, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; @@ -10171,26 +10189,26 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p } __pyx_t_7 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_16, __pyx_t_2, __pyx_v_sub_lambda_grid) : __Pyx_PyObject_CallOneArg(__pyx_t_16, __pyx_v_sub_lambda_grid); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 581, __pyx_L1_error) + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 579, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_16 = PyObject_RichCompare(__pyx_t_7, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_16); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 581, __pyx_L1_error) + __pyx_t_16 = PyObject_RichCompare(__pyx_t_7, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_16); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 579, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_16); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 581, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_16); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 579, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 581, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 579, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(__pyx_t_1)) { + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":582 + /* "l0learn/interface.pyx":580 * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " # <<<<<<<<<<<<<< * f"but got lambda_grid[{i}] containing an increasing value.") * */ - __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 582, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 580, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_15 = 0; __pyx_t_10 = 127; @@ -10199,14 +10217,14 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_GIVEREF(__pyx_kp_u_Expected_each_element_of_lambda); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_Expected_each_element_of_lambda); - /* "l0learn/interface.pyx":583 + /* "l0learn/interface.pyx":581 * if any(np.diff(sub_lambda_grid) >= 0): * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " * f"but got lambda_grid[{i}] containing an increasing value.") # <<<<<<<<<<<<<< * * n, p = X.shape */ - __pyx_t_16 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 583, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 581, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_16) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_16) : __pyx_t_10; __pyx_t_15 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_16); @@ -10218,24 +10236,24 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_GIVEREF(__pyx_kp_u_containing_an_increasing_value); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_containing_an_increasing_value); - /* "l0learn/interface.pyx":582 + /* "l0learn/interface.pyx":580 * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " # <<<<<<<<<<<<<< * f"but got lambda_grid[{i}] containing an increasing value.") * */ - __pyx_t_16 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 582, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 580, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_16); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 582, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_16); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 580, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 582, __pyx_L1_error) + __PYX_ERR(0, 580, __pyx_L1_error) - /* "l0learn/interface.pyx":581 + /* "l0learn/interface.pyx":579 * raise ValueError(f"Expected all values of lambda_grid to be positive, " * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): # <<<<<<<<<<<<<< @@ -10244,7 +10262,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":576 + /* "l0learn/interface.pyx":574 * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") * * for i, sub_lambda_grid in enumerate(lambda_grid): # <<<<<<<<<<<<<< @@ -10255,16 +10273,16 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } - __pyx_L62:; + __pyx_L64:; - /* "l0learn/interface.pyx":585 + /* "l0learn/interface.pyx":583 * f"but got lambda_grid[{i}] containing an increasing value.") * * n, p = X.shape # <<<<<<<<<<<<<< * with_bounds = False * */ - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 585, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 583, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if ((likely(PyTuple_CheckExact(__pyx_t_8))) || (PyList_CheckExact(__pyx_t_8))) { PyObject* sequence = __pyx_t_8; @@ -10272,7 +10290,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 585, __pyx_L1_error) + __PYX_ERR(0, 583, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { @@ -10285,39 +10303,39 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_7); #else - __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 585, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 583, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 585, __pyx_L1_error) + __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 583, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); #endif __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { Py_ssize_t index = -1; - __pyx_t_16 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 585, __pyx_L1_error) + __pyx_t_16 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 583, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_11 = Py_TYPE(__pyx_t_16)->tp_iternext; - index = 0; __pyx_t_3 = __pyx_t_11(__pyx_t_16); if (unlikely(!__pyx_t_3)) goto __pyx_L81_unpacking_failed; + index = 0; __pyx_t_3 = __pyx_t_11(__pyx_t_16); if (unlikely(!__pyx_t_3)) goto __pyx_L83_unpacking_failed; __Pyx_GOTREF(__pyx_t_3); - index = 1; __pyx_t_7 = __pyx_t_11(__pyx_t_16); if (unlikely(!__pyx_t_7)) goto __pyx_L81_unpacking_failed; + index = 1; __pyx_t_7 = __pyx_t_11(__pyx_t_16); if (unlikely(!__pyx_t_7)) goto __pyx_L83_unpacking_failed; __Pyx_GOTREF(__pyx_t_7); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_16), 2) < 0) __PYX_ERR(0, 585, __pyx_L1_error) + if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_16), 2) < 0) __PYX_ERR(0, 583, __pyx_L1_error) __pyx_t_11 = NULL; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - goto __pyx_L82_unpacking_done; - __pyx_L81_unpacking_failed:; + goto __pyx_L84_unpacking_done; + __pyx_L83_unpacking_failed:; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_11 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 585, __pyx_L1_error) - __pyx_L82_unpacking_done:; + __PYX_ERR(0, 583, __pyx_L1_error) + __pyx_L84_unpacking_done:; } __Pyx_DECREF_SET(__pyx_v_n, __pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF_SET(__pyx_v_p, __pyx_t_7); __pyx_t_7 = 0; - /* "l0learn/interface.pyx":586 + /* "l0learn/interface.pyx":584 * * n, p = X.shape * with_bounds = False # <<<<<<<<<<<<<< @@ -10326,49 +10344,49 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ __pyx_v_with_bounds = 0; - /* "l0learn/interface.pyx":588 + /* "l0learn/interface.pyx":586 * with_bounds = False * * if isinstance(lows, float): # <<<<<<<<<<<<<< * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") */ - __pyx_t_1 = PyFloat_Check(__pyx_v_lows); - __pyx_t_5 = (__pyx_t_1 != 0); + __pyx_t_4 = PyFloat_Check(__pyx_v_lows); + __pyx_t_5 = (__pyx_t_4 != 0); if (__pyx_t_5) { - /* "l0learn/interface.pyx":589 + /* "l0learn/interface.pyx":587 * * if isinstance(lows, float): * if lows > 0: # <<<<<<<<<<<<<< * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") * elif lows > -float('inf'): */ - __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_GT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 589, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 589, __pyx_L1_error) + __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_GT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 587, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 587, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":590 + /* "l0learn/interface.pyx":588 * if isinstance(lows, float): * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") # <<<<<<<<<<<<<< * elif lows > -float('inf'): * with_bounds = True */ - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 590, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 588, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lows_to_be_a_non_positi, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 590, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lows_to_be_a_non_positi, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 588, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 590, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 588, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 590, __pyx_L1_error) + __PYX_ERR(0, 588, __pyx_L1_error) - /* "l0learn/interface.pyx":589 + /* "l0learn/interface.pyx":587 * * if isinstance(lows, float): * if lows > 0: # <<<<<<<<<<<<<< @@ -10377,23 +10395,23 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":591 + /* "l0learn/interface.pyx":589 * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") * elif lows > -float('inf'): # <<<<<<<<<<<<<< * with_bounds = True * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): */ - __pyx_t_14 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 591, __pyx_L1_error) - __pyx_t_8 = PyFloat_FromDouble((-__pyx_t_14)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 591, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 589, __pyx_L1_error) + __pyx_t_8 = PyFloat_FromDouble((-__pyx_t_14)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 589, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = PyObject_RichCompare(__pyx_v_lows, __pyx_t_8, Py_GT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 591, __pyx_L1_error) + __pyx_t_7 = PyObject_RichCompare(__pyx_v_lows, __pyx_t_8, Py_GT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 589, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 591, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 589, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (__pyx_t_5) { - /* "l0learn/interface.pyx":592 + /* "l0learn/interface.pyx":590 * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") * elif lows > -float('inf'): * with_bounds = True # <<<<<<<<<<<<<< @@ -10402,7 +10420,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ __pyx_v_with_bounds = 1; - /* "l0learn/interface.pyx":591 + /* "l0learn/interface.pyx":589 * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") * elif lows > -float('inf'): # <<<<<<<<<<<<<< @@ -10411,71 +10429,71 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":588 + /* "l0learn/interface.pyx":586 * with_bounds = False * * if isinstance(lows, float): # <<<<<<<<<<<<<< * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") */ - goto __pyx_L83; + goto __pyx_L85; } - /* "l0learn/interface.pyx":593 + /* "l0learn/interface.pyx":591 * elif lows > -float('inf'): * with_bounds = True * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): # <<<<<<<<<<<<<< * with_bounds = True * else: */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 593, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 591, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 593, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 591, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_1 = PyObject_IsInstance(__pyx_v_lows, __pyx_t_8); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 593, __pyx_L1_error) + __pyx_t_4 = PyObject_IsInstance(__pyx_v_lows, __pyx_t_8); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 591, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_4 = (__pyx_t_1 != 0); - if (__pyx_t_4) { + __pyx_t_1 = (__pyx_t_4 != 0); + if (__pyx_t_1) { } else { - __pyx_t_5 = __pyx_t_4; - goto __pyx_L85_bool_binop_done; + __pyx_t_5 = __pyx_t_1; + goto __pyx_L87_bool_binop_done; } - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_lows, __pyx_n_s_ndim); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 593, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_lows, __pyx_n_s_ndim); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 591, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = __Pyx_PyInt_EqObjC(__pyx_t_8, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 593, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_EqObjC(__pyx_t_8, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 591, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 593, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 591, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (__pyx_t_4) { + if (__pyx_t_1) { } else { - __pyx_t_5 = __pyx_t_4; - goto __pyx_L85_bool_binop_done; + __pyx_t_5 = __pyx_t_1; + goto __pyx_L87_bool_binop_done; } - __pyx_t_9 = PyObject_Length(__pyx_v_lows); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 593, __pyx_L1_error) - __pyx_t_7 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 593, __pyx_L1_error) + __pyx_t_9 = PyObject_Length(__pyx_v_lows); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 591, __pyx_L1_error) + __pyx_t_7 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 591, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = PyObject_RichCompare(__pyx_t_7, __pyx_v_p, Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 593, __pyx_L1_error) + __pyx_t_8 = PyObject_RichCompare(__pyx_t_7, __pyx_v_p, Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 591, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 593, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 591, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (__pyx_t_4) { + if (__pyx_t_1) { } else { - __pyx_t_5 = __pyx_t_4; - goto __pyx_L85_bool_binop_done; + __pyx_t_5 = __pyx_t_1; + goto __pyx_L87_bool_binop_done; } - __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 593, __pyx_L1_error) - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_all, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 593, __pyx_L1_error) + __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 591, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_all, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 591, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 593, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 591, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_5 = __pyx_t_4; - __pyx_L85_bool_binop_done:; + __pyx_t_5 = __pyx_t_1; + __pyx_L87_bool_binop_done:; if (likely(__pyx_t_5)) { - /* "l0learn/interface.pyx":594 + /* "l0learn/interface.pyx":592 * with_bounds = True * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): * with_bounds = True # <<<<<<<<<<<<<< @@ -10484,17 +10502,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ __pyx_v_with_bounds = 1; - /* "l0learn/interface.pyx":593 + /* "l0learn/interface.pyx":591 * elif lows > -float('inf'): * with_bounds = True * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): # <<<<<<<<<<<<<< * with_bounds = True * else: */ - goto __pyx_L83; + goto __pyx_L85; } - /* "l0learn/interface.pyx":596 + /* "l0learn/interface.pyx":594 * with_bounds = True * else: * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " # <<<<<<<<<<<<<< @@ -10502,7 +10520,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p * */ /*else*/ { - __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 596, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 594, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -10510,7 +10528,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_9 += 72; __Pyx_GIVEREF(__pyx_kp_u_expected_lows_to_be_a_non_positi_2); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_lows_to_be_a_non_positi_2); - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 596, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 594, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); @@ -10522,14 +10540,14 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_GIVEREF(__pyx_kp_u_of_non_positives_floats_but_got); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_of_non_positives_floats_but_got); - /* "l0learn/interface.pyx":597 + /* "l0learn/interface.pyx":595 * else: * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " * f"floats, but got {lows}") # <<<<<<<<<<<<<< * * if isinstance(highs, float): */ - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 597, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 595, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); @@ -10537,26 +10555,26 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_8); __pyx_t_8 = 0; - /* "l0learn/interface.pyx":596 + /* "l0learn/interface.pyx":594 * with_bounds = True * else: * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " # <<<<<<<<<<<<<< * f"floats, but got {lows}") * */ - __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 596, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 594, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 596, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 594, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 596, __pyx_L1_error) + __PYX_ERR(0, 594, __pyx_L1_error) } - __pyx_L83:; + __pyx_L85:; - /* "l0learn/interface.pyx":599 + /* "l0learn/interface.pyx":597 * f"floats, but got {lows}") * * if isinstance(highs, float): # <<<<<<<<<<<<<< @@ -10564,41 +10582,41 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") */ __pyx_t_5 = PyFloat_Check(__pyx_v_highs); - __pyx_t_4 = (__pyx_t_5 != 0); - if (__pyx_t_4) { + __pyx_t_1 = (__pyx_t_5 != 0); + if (__pyx_t_1) { - /* "l0learn/interface.pyx":600 + /* "l0learn/interface.pyx":598 * * if isinstance(highs, float): * if highs < 0: # <<<<<<<<<<<<<< * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") * if highs < float('inf'): */ - __pyx_t_7 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 600, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 600, __pyx_L1_error) + __pyx_t_7 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 598, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 598, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(__pyx_t_4)) { + if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":601 + /* "l0learn/interface.pyx":599 * if isinstance(highs, float): * if highs < 0: * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") # <<<<<<<<<<<<<< * if highs < float('inf'): * with_bounds = True */ - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 601, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 599, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_highs_to_be_a_non_negat, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 601, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_highs_to_be_a_non_negat, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 599, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 601, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 599, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 601, __pyx_L1_error) + __PYX_ERR(0, 599, __pyx_L1_error) - /* "l0learn/interface.pyx":600 + /* "l0learn/interface.pyx":598 * * if isinstance(highs, float): * if highs < 0: # <<<<<<<<<<<<<< @@ -10607,22 +10625,22 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":602 + /* "l0learn/interface.pyx":600 * if highs < 0: * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") * if highs < float('inf'): # <<<<<<<<<<<<<< * with_bounds = True * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): */ - __pyx_t_7 = __Pyx_PyNumber_Float(__pyx_n_u_inf); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 602, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyNumber_Float(__pyx_n_u_inf); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 600, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = PyObject_RichCompare(__pyx_v_highs, __pyx_t_7, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 602, __pyx_L1_error) + __pyx_t_8 = PyObject_RichCompare(__pyx_v_highs, __pyx_t_7, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 600, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 602, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 600, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (__pyx_t_4) { + if (__pyx_t_1) { - /* "l0learn/interface.pyx":603 + /* "l0learn/interface.pyx":601 * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") * if highs < float('inf'): * with_bounds = True # <<<<<<<<<<<<<< @@ -10631,7 +10649,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ __pyx_v_with_bounds = 1; - /* "l0learn/interface.pyx":602 + /* "l0learn/interface.pyx":600 * if highs < 0: * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") * if highs < float('inf'): # <<<<<<<<<<<<<< @@ -10640,68 +10658,68 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":599 + /* "l0learn/interface.pyx":597 * f"floats, but got {lows}") * * if isinstance(highs, float): # <<<<<<<<<<<<<< * if highs < 0: * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") */ - goto __pyx_L89; + goto __pyx_L91; } - /* "l0learn/interface.pyx":604 + /* "l0learn/interface.pyx":602 * if highs < float('inf'): * with_bounds = True * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): # <<<<<<<<<<<<<< * with_bounds = True * else: */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 604, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 602, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 604, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 602, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_5 = PyObject_IsInstance(__pyx_v_highs, __pyx_t_7); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 604, __pyx_L1_error) + __pyx_t_5 = PyObject_IsInstance(__pyx_v_highs, __pyx_t_7); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 602, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_1 = (__pyx_t_5 != 0); - if (__pyx_t_1) { + __pyx_t_4 = (__pyx_t_5 != 0); + if (__pyx_t_4) { } else { - __pyx_t_4 = __pyx_t_1; - goto __pyx_L92_bool_binop_done; + __pyx_t_1 = __pyx_t_4; + goto __pyx_L94_bool_binop_done; } - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_highs, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 604, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_highs, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 602, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyInt_EqObjC(__pyx_t_7, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 604, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_EqObjC(__pyx_t_7, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 602, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 604, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 602, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (__pyx_t_1) { + if (__pyx_t_4) { } else { - __pyx_t_4 = __pyx_t_1; - goto __pyx_L92_bool_binop_done; + __pyx_t_1 = __pyx_t_4; + goto __pyx_L94_bool_binop_done; } - __pyx_t_9 = PyObject_Length(__pyx_v_highs); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 604, __pyx_L1_error) - __pyx_t_8 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 604, __pyx_L1_error) + __pyx_t_9 = PyObject_Length(__pyx_v_highs); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 602, __pyx_L1_error) + __pyx_t_8 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 602, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = PyObject_RichCompare(__pyx_t_8, __pyx_v_p, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 604, __pyx_L1_error) + __pyx_t_7 = PyObject_RichCompare(__pyx_t_8, __pyx_v_p, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 602, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 604, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 602, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (__pyx_t_1) { + if (__pyx_t_4) { } else { - __pyx_t_4 = __pyx_t_1; - goto __pyx_L92_bool_binop_done; + __pyx_t_1 = __pyx_t_4; + goto __pyx_L94_bool_binop_done; } - __pyx_t_7 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 604, __pyx_L1_error) - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 604, __pyx_L1_error) + __pyx_t_7 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 602, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 602, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = __pyx_t_1; - __pyx_L92_bool_binop_done:; - if (likely(__pyx_t_4)) { + __pyx_t_1 = __pyx_t_4; + __pyx_L94_bool_binop_done:; + if (likely(__pyx_t_1)) { - /* "l0learn/interface.pyx":605 + /* "l0learn/interface.pyx":603 * with_bounds = True * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): * with_bounds = True # <<<<<<<<<<<<<< @@ -10710,17 +10728,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ __pyx_v_with_bounds = 1; - /* "l0learn/interface.pyx":604 + /* "l0learn/interface.pyx":602 * if highs < float('inf'): * with_bounds = True * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): # <<<<<<<<<<<<<< * with_bounds = True * else: */ - goto __pyx_L89; + goto __pyx_L91; } - /* "l0learn/interface.pyx":607 + /* "l0learn/interface.pyx":605 * with_bounds = True * else: * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " # <<<<<<<<<<<<<< @@ -10728,7 +10746,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p * */ /*else*/ { - __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 607, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 605, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -10736,7 +10754,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_9 += 73; __Pyx_GIVEREF(__pyx_kp_u_expected_highs_to_be_a_non_negat_2); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_highs_to_be_a_non_negat_2); - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 607, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 605, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); @@ -10748,14 +10766,14 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_GIVEREF(__pyx_kp_u_of_non_negative_floats_but_got); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_of_non_negative_floats_but_got); - /* "l0learn/interface.pyx":608 + /* "l0learn/interface.pyx":606 * else: * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " * f"non-negative floats, but got {highs}") # <<<<<<<<<<<<<< * * if with_bounds: */ - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 608, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 606, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); @@ -10763,56 +10781,56 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_8); __pyx_t_8 = 0; - /* "l0learn/interface.pyx":607 + /* "l0learn/interface.pyx":605 * with_bounds = True * else: * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " # <<<<<<<<<<<<<< * f"non-negative floats, but got {highs}") * */ - __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 607, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 605, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 607, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 605, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 607, __pyx_L1_error) + __PYX_ERR(0, 605, __pyx_L1_error) } - __pyx_L89:; + __pyx_L91:; - /* "l0learn/interface.pyx":610 + /* "l0learn/interface.pyx":608 * f"non-negative floats, but got {highs}") * * if with_bounds: # <<<<<<<<<<<<<< * if isinstance(lows, float): * lows = np.ones(p) * lows */ - __pyx_t_4 = (__pyx_v_with_bounds != 0); - if (__pyx_t_4) { + __pyx_t_1 = (__pyx_v_with_bounds != 0); + if (__pyx_t_1) { - /* "l0learn/interface.pyx":611 + /* "l0learn/interface.pyx":609 * * if with_bounds: * if isinstance(lows, float): # <<<<<<<<<<<<<< * lows = np.ones(p) * lows * if isinstance(highs, float): */ - __pyx_t_4 = PyFloat_Check(__pyx_v_lows); - __pyx_t_1 = (__pyx_t_4 != 0); - if (__pyx_t_1) { + __pyx_t_1 = PyFloat_Check(__pyx_v_lows); + __pyx_t_4 = (__pyx_t_1 != 0); + if (__pyx_t_4) { - /* "l0learn/interface.pyx":612 + /* "l0learn/interface.pyx":610 * if with_bounds: * if isinstance(lows, float): * lows = np.ones(p) * lows # <<<<<<<<<<<<<< * if isinstance(highs, float): * highs = np.ones(p) * highs */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 612, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 610, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_ones); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 612, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_ones); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 610, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; @@ -10827,16 +10845,16 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p } __pyx_t_7 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_8, __pyx_v_p) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_p); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 612, __pyx_L1_error) + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 610, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PyNumber_Multiply(__pyx_t_7, __pyx_v_lows); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 612, __pyx_L1_error) + __pyx_t_3 = PyNumber_Multiply(__pyx_t_7, __pyx_v_lows); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 610, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":611 + /* "l0learn/interface.pyx":609 * * if with_bounds: * if isinstance(lows, float): # <<<<<<<<<<<<<< @@ -10845,27 +10863,27 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":613 + /* "l0learn/interface.pyx":611 * if isinstance(lows, float): * lows = np.ones(p) * lows * if isinstance(highs, float): # <<<<<<<<<<<<<< * highs = np.ones(p) * highs * */ - __pyx_t_1 = PyFloat_Check(__pyx_v_highs); - __pyx_t_4 = (__pyx_t_1 != 0); - if (__pyx_t_4) { + __pyx_t_4 = PyFloat_Check(__pyx_v_highs); + __pyx_t_1 = (__pyx_t_4 != 0); + if (__pyx_t_1) { - /* "l0learn/interface.pyx":614 + /* "l0learn/interface.pyx":612 * lows = np.ones(p) * lows * if isinstance(highs, float): * highs = np.ones(p) * highs # <<<<<<<<<<<<<< * * if any(lows >= highs): */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 614, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 612, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ones); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 614, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ones); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 612, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; @@ -10880,16 +10898,16 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p } __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_7, __pyx_v_p) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_p); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 614, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 612, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = PyNumber_Multiply(__pyx_t_3, __pyx_v_highs); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 614, __pyx_L1_error) + __pyx_t_8 = PyNumber_Multiply(__pyx_t_3, __pyx_v_highs); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 612, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_8); __pyx_t_8 = 0; - /* "l0learn/interface.pyx":613 + /* "l0learn/interface.pyx":611 * if isinstance(lows, float): * lows = np.ones(p) * lows * if isinstance(highs, float): # <<<<<<<<<<<<<< @@ -10898,34 +10916,34 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":616 + /* "l0learn/interface.pyx":614 * highs = np.ones(p) * highs * * if any(lows >= highs): # <<<<<<<<<<<<<< * bad_bounds = np.argwhere(lows >= highs) * raise ValueError(f"expected to be high to be elementwise greater than lows, " */ - __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 616, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 616, __pyx_L1_error) + __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 614, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 614, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 616, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 614, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(__pyx_t_4)) { + if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":617 + /* "l0learn/interface.pyx":615 * * if any(lows >= highs): * bad_bounds = np.argwhere(lows >= highs) # <<<<<<<<<<<<<< * raise ValueError(f"expected to be high to be elementwise greater than lows, " * f"but got indices {bad_bounds[0]} where that is not the case ") */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 617, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 615, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_argwhere); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 617, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_argwhere); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 615, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 617, __pyx_L1_error) + __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 615, __pyx_L1_error) __pyx_t_16 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_7); @@ -10939,20 +10957,20 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_3 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_16, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 617, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 615, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_bad_bounds = __pyx_t_3; __pyx_t_3 = 0; - /* "l0learn/interface.pyx":618 + /* "l0learn/interface.pyx":616 * if any(lows >= highs): * bad_bounds = np.argwhere(lows >= highs) * raise ValueError(f"expected to be high to be elementwise greater than lows, " # <<<<<<<<<<<<<< * f"but got indices {bad_bounds[0]} where that is not the case ") * else: */ - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 618, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 616, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -10961,16 +10979,16 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_GIVEREF(__pyx_kp_u_expected_to_be_high_to_be_elemen); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_to_be_high_to_be_elemen); - /* "l0learn/interface.pyx":619 + /* "l0learn/interface.pyx":617 * bad_bounds = np.argwhere(lows >= highs) * raise ValueError(f"expected to be high to be elementwise greater than lows, " * f"but got indices {bad_bounds[0]} where that is not the case ") # <<<<<<<<<<<<<< * else: * lows = np.array([0.]) */ - __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_bad_bounds, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 619, __pyx_L1_error) + __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_bad_bounds, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 617, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 619, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 617, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; @@ -10983,24 +11001,24 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_GIVEREF(__pyx_kp_u_where_that_is_not_the_case); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_where_that_is_not_the_case); - /* "l0learn/interface.pyx":618 + /* "l0learn/interface.pyx":616 * if any(lows >= highs): * bad_bounds = np.argwhere(lows >= highs) * raise ValueError(f"expected to be high to be elementwise greater than lows, " # <<<<<<<<<<<<<< * f"but got indices {bad_bounds[0]} where that is not the case ") * else: */ - __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 618, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 616, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 618, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 616, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 618, __pyx_L1_error) + __PYX_ERR(0, 616, __pyx_L1_error) - /* "l0learn/interface.pyx":616 + /* "l0learn/interface.pyx":614 * highs = np.ones(p) * highs * * if any(lows >= highs): # <<<<<<<<<<<<<< @@ -11009,17 +11027,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":610 + /* "l0learn/interface.pyx":608 * f"non-negative floats, but got {highs}") * * if with_bounds: # <<<<<<<<<<<<<< * if isinstance(lows, float): * lows = np.ones(p) * lows */ - goto __pyx_L96; + goto __pyx_L98; } - /* "l0learn/interface.pyx":621 + /* "l0learn/interface.pyx":619 * f"but got indices {bad_bounds[0]} where that is not the case ") * else: * lows = np.array([0.]) # <<<<<<<<<<<<<< @@ -11027,12 +11045,12 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p * */ /*else*/ { - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 621, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 619, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_array); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 621, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_array); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 619, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = PyList_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 621, __pyx_L1_error) + __pyx_t_8 = PyList_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 619, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_INCREF(__pyx_float_0_); __Pyx_GIVEREF(__pyx_float_0_); @@ -11050,25 +11068,25 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_3 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_16, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 621, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 619, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":622 + /* "l0learn/interface.pyx":620 * else: * lows = np.array([0.]) * highs = np.array(([0.])) # <<<<<<<<<<<<<< * * cdef vector[vector[double]] c_lambda_grid */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 622, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 620, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_array); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 622, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_array); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 620, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = PyList_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 622, __pyx_L1_error) + __pyx_t_7 = PyList_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 620, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_INCREF(__pyx_float_0_); __Pyx_GIVEREF(__pyx_float_0_); @@ -11086,15 +11104,15 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_3 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_16, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 622, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 620, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_3); __pyx_t_3 = 0; } - __pyx_L96:; + __pyx_L98:; - /* "l0learn/interface.pyx":625 + /* "l0learn/interface.pyx":623 * * cdef vector[vector[double]] c_lambda_grid * try: # <<<<<<<<<<<<<< @@ -11110,17 +11128,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_XGOTREF(__pyx_t_19); /*try:*/ { - /* "l0learn/interface.pyx":626 + /* "l0learn/interface.pyx":624 * cdef vector[vector[double]] c_lambda_grid * try: * c_lambda_grid = lambda_grid # <<<<<<<<<<<<<< * except TypeError: * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") */ - __pyx_t_20 = __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_lambda_grid); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 626, __pyx_L100_error) + __pyx_t_20 = __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_lambda_grid); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 624, __pyx_L102_error) __pyx_v_c_lambda_grid = __pyx_t_20; - /* "l0learn/interface.pyx":625 + /* "l0learn/interface.pyx":623 * * cdef vector[vector[double]] c_lambda_grid * try: # <<<<<<<<<<<<<< @@ -11131,15 +11149,15 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; - goto __pyx_L105_try_end; - __pyx_L100_error:; + goto __pyx_L107_try_end; + __pyx_L102_error:; __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "l0learn/interface.pyx":627 + /* "l0learn/interface.pyx":625 * try: * c_lambda_grid = lambda_grid * except TypeError: # <<<<<<<<<<<<<< @@ -11149,34 +11167,34 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_21 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); if (__pyx_t_21) { __Pyx_AddTraceback("l0learn.interface.cvfit", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_8, &__pyx_t_7) < 0) __PYX_ERR(0, 627, __pyx_L102_except_error) + if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_8, &__pyx_t_7) < 0) __PYX_ERR(0, 625, __pyx_L104_except_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GOTREF(__pyx_t_8); __Pyx_GOTREF(__pyx_t_7); - /* "l0learn/interface.pyx":628 + /* "l0learn/interface.pyx":626 * c_lambda_grid = lambda_grid * except TypeError: * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") # <<<<<<<<<<<<<< * * cdef string c_loss = loss.encode('UTF-8') */ - __pyx_t_16 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 628, __pyx_L102_except_error) + __pyx_t_16 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 626, __pyx_L104_except_error) __Pyx_GOTREF(__pyx_t_16); - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_be_a_lis, __pyx_t_16); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 628, __pyx_L102_except_error) + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_be_a_lis, __pyx_t_16); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 626, __pyx_L104_except_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_16 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 628, __pyx_L102_except_error) + __pyx_t_16 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 626, __pyx_L104_except_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_16, 0, 0, 0); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __PYX_ERR(0, 628, __pyx_L102_except_error) + __PYX_ERR(0, 626, __pyx_L104_except_error) } - goto __pyx_L102_except_error; - __pyx_L102_except_error:; + goto __pyx_L104_except_error; + __pyx_L104_except_error:; - /* "l0learn/interface.pyx":625 + /* "l0learn/interface.pyx":623 * * cdef vector[vector[double]] c_lambda_grid * try: # <<<<<<<<<<<<<< @@ -11188,10 +11206,10 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_18, __pyx_t_19); goto __pyx_L1_error; - __pyx_L105_try_end:; + __pyx_L107_try_end:; } - /* "l0learn/interface.pyx":630 + /* "l0learn/interface.pyx":628 * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") * * cdef string c_loss = loss.encode('UTF-8') # <<<<<<<<<<<<<< @@ -11200,15 +11218,15 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ if (unlikely(__pyx_v_loss == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 630, __pyx_L1_error) + __PYX_ERR(0, 628, __pyx_L1_error) } - __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_loss); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 630, __pyx_L1_error) + __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_loss); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 628, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 630, __pyx_L1_error) + __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 628, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_c_loss = __pyx_t_22; - /* "l0learn/interface.pyx":631 + /* "l0learn/interface.pyx":629 * * cdef string c_loss = loss.encode('UTF-8') * cdef string c_penalty = penalty.encode('UTF-8') # <<<<<<<<<<<<<< @@ -11217,15 +11235,15 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ if (unlikely(__pyx_v_penalty == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 631, __pyx_L1_error) + __PYX_ERR(0, 629, __pyx_L1_error) } - __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_penalty); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 631, __pyx_L1_error) + __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_penalty); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 629, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 631, __pyx_L1_error) + __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 629, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_c_penalty = __pyx_t_22; - /* "l0learn/interface.pyx":632 + /* "l0learn/interface.pyx":630 * cdef string c_loss = loss.encode('UTF-8') * cdef string c_penalty = penalty.encode('UTF-8') * cdef string c_algorithim = algorithm.encode('UTF-8') # <<<<<<<<<<<<<< @@ -11234,185 +11252,185 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ if (unlikely(__pyx_v_algorithm == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 632, __pyx_L1_error) + __PYX_ERR(0, 630, __pyx_L1_error) } - __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_algorithm); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 632, __pyx_L1_error) + __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_algorithm); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 630, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 632, __pyx_L1_error) + __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 630, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_c_algorithim = __pyx_t_22; - /* "l0learn/interface.pyx":635 + /* "l0learn/interface.pyx":633 * * cdef cvfitmodel c_results * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), * y=numpy_to_dvec_d(y), */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 635, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 633, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 635, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 633, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = PyObject_IsInstance(__pyx_v_X, __pyx_t_8); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 635, __pyx_L1_error) + __pyx_t_1 = PyObject_IsInstance(__pyx_v_X, __pyx_t_8); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 633, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_1 = (__pyx_t_4 != 0); - if (__pyx_t_1) { + __pyx_t_4 = (__pyx_t_1 != 0); + if (__pyx_t_4) { - /* "l0learn/interface.pyx":636 + /* "l0learn/interface.pyx":634 * cdef cvfitmodel c_results * if isinstance(X, np.ndarray): * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< * y=numpy_to_dvec_d(y), * Loss=c_loss, */ - if (!(likely(((__pyx_v_X) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_X, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 636, __pyx_L1_error) + if (!(likely(((__pyx_v_X) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_X, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 634, __pyx_L1_error) - /* "l0learn/interface.pyx":637 + /* "l0learn/interface.pyx":635 * if isinstance(X, np.ndarray): * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), * y=numpy_to_dvec_d(y), # <<<<<<<<<<<<<< * Loss=c_loss, * Penalty=c_penalty, */ - if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 637, __pyx_L1_error) + if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 635, __pyx_L1_error) - /* "l0learn/interface.pyx":641 + /* "l0learn/interface.pyx":639 * Penalty=c_penalty, * Algorithm=c_algorithim, * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< * G_ncols=num_lambda, * G_nrows=num_gamma, */ - __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 641, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 639, __pyx_L1_error) - /* "l0learn/interface.pyx":642 + /* "l0learn/interface.pyx":640 * Algorithm=c_algorithim, * NnzStopNum=max_support_size, * G_ncols=num_lambda, # <<<<<<<<<<<<<< * G_nrows=num_gamma, * Lambda2Max=gamma_max, */ - __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 642, __pyx_L1_error) + __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 640, __pyx_L1_error) - /* "l0learn/interface.pyx":643 + /* "l0learn/interface.pyx":641 * NnzStopNum=max_support_size, * G_ncols=num_lambda, * G_nrows=num_gamma, # <<<<<<<<<<<<<< * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, */ - __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 643, __pyx_L1_error) + __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 641, __pyx_L1_error) - /* "l0learn/interface.pyx":646 + /* "l0learn/interface.pyx":644 * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, * PartialSort=partial_sort, # <<<<<<<<<<<<<< * MaxIters=max_iter, * rtol=rtol, */ - __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 646, __pyx_L1_error) + __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 644, __pyx_L1_error) - /* "l0learn/interface.pyx":647 + /* "l0learn/interface.pyx":645 * Lambda2Min=gamma_min, * PartialSort=partial_sort, * MaxIters=max_iter, # <<<<<<<<<<<<<< * rtol=rtol, * atol=atol, */ - __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 647, __pyx_L1_error) + __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 645, __pyx_L1_error) - /* "l0learn/interface.pyx":650 + /* "l0learn/interface.pyx":648 * rtol=rtol, * atol=atol, * ActiveSet=active_set, # <<<<<<<<<<<<<< * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, */ - __pyx_t_28 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_28 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 650, __pyx_L1_error) + __pyx_t_28 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_28 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 648, __pyx_L1_error) - /* "l0learn/interface.pyx":651 + /* "l0learn/interface.pyx":649 * atol=atol, * ActiveSet=active_set, * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, */ - __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 651, __pyx_L1_error) + __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 649, __pyx_L1_error) - /* "l0learn/interface.pyx":652 + /* "l0learn/interface.pyx":650 * ActiveSet=active_set, * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, */ - __pyx_t_30 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_30 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 652, __pyx_L1_error) + __pyx_t_30 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_30 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 650, __pyx_L1_error) - /* "l0learn/interface.pyx":654 + /* "l0learn/interface.pyx":652 * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, # <<<<<<<<<<<<<< * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, */ - __pyx_t_31 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_31 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 654, __pyx_L1_error) + __pyx_t_31 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_31 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 652, __pyx_L1_error) - /* "l0learn/interface.pyx":657 + /* "l0learn/interface.pyx":655 * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, * nfolds=num_folds, # <<<<<<<<<<<<<< * seed=seed, * ExcludeFirstK=exclude_first_k, */ - __pyx_t_32 = __Pyx_PyInt_As_unsigned_int(__pyx_v_num_folds); if (unlikely((__pyx_t_32 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 657, __pyx_L1_error) + __pyx_t_32 = __Pyx_PyInt_As_unsigned_int(__pyx_v_num_folds); if (unlikely((__pyx_t_32 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 655, __pyx_L1_error) - /* "l0learn/interface.pyx":658 + /* "l0learn/interface.pyx":656 * Lambdas=c_lambda_grid, * nfolds=num_folds, * seed=seed, # <<<<<<<<<<<<<< * ExcludeFirstK=exclude_first_k, * Intercept=intercept, */ - __pyx_t_14 = __pyx_PyFloat_AsDouble(__pyx_v_seed); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 658, __pyx_L1_error) + __pyx_t_14 = __pyx_PyFloat_AsDouble(__pyx_v_seed); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 656, __pyx_L1_error) - /* "l0learn/interface.pyx":659 + /* "l0learn/interface.pyx":657 * nfolds=num_folds, * seed=seed, * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< * Intercept=intercept, * withBounds=with_bounds, */ - __pyx_t_33 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_33 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 659, __pyx_L1_error) + __pyx_t_33 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_33 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 657, __pyx_L1_error) - /* "l0learn/interface.pyx":660 + /* "l0learn/interface.pyx":658 * seed=seed, * ExcludeFirstK=exclude_first_k, * Intercept=intercept, # <<<<<<<<<<<<<< * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), */ - __pyx_t_34 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_34 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 660, __pyx_L1_error) + __pyx_t_34 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_34 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 658, __pyx_L1_error) - /* "l0learn/interface.pyx":662 + /* "l0learn/interface.pyx":660 * Intercept=intercept, * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< * Highs=numpy_to_dvec_d(highs)) * else: # isinstance(X, csc_matrix) */ - if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 662, __pyx_L1_error) + if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 660, __pyx_L1_error) - /* "l0learn/interface.pyx":663 + /* "l0learn/interface.pyx":661 * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< * else: # isinstance(X, csc_matrix) * c_results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), */ - if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 663, __pyx_L1_error) + if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 661, __pyx_L1_error) - /* "l0learn/interface.pyx":636 + /* "l0learn/interface.pyx":634 * cdef cvfitmodel c_results * if isinstance(X, np.ndarray): * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< @@ -11421,17 +11439,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnCV_dense(__pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_X)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_23, __pyx_t_24, __pyx_t_25, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_26, __pyx_t_27, __pyx_v_rtol, __pyx_v_atol, __pyx_t_28, __pyx_t_29, __pyx_t_30, __pyx_v_scale_down_factor, __pyx_t_31, (!(__pyx_v_auto_lambda != 0)), __pyx_v_c_lambda_grid, __pyx_t_32, __pyx_t_14, __pyx_t_33, __pyx_t_34, __pyx_v_with_bounds, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); - /* "l0learn/interface.pyx":635 + /* "l0learn/interface.pyx":633 * * cdef cvfitmodel c_results * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), * y=numpy_to_dvec_d(y), */ - goto __pyx_L108; + goto __pyx_L110; } - /* "l0learn/interface.pyx":665 + /* "l0learn/interface.pyx":663 * Highs=numpy_to_dvec_d(highs)) * else: # isinstance(X, csc_matrix) * c_results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< @@ -11440,151 +11458,151 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ /*else*/ { - /* "l0learn/interface.pyx":666 + /* "l0learn/interface.pyx":664 * else: # isinstance(X, csc_matrix) * c_results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), * y=numpy_to_dvec_d(y), # <<<<<<<<<<<<<< * Loss=c_loss, * Penalty=c_penalty, */ - if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 666, __pyx_L1_error) + if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 664, __pyx_L1_error) - /* "l0learn/interface.pyx":670 + /* "l0learn/interface.pyx":668 * Penalty=c_penalty, * Algorithm=c_algorithim, * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< * G_ncols=num_lambda, * G_nrows=num_gamma, */ - __pyx_t_33 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_33 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 670, __pyx_L1_error) + __pyx_t_33 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_33 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 668, __pyx_L1_error) - /* "l0learn/interface.pyx":671 + /* "l0learn/interface.pyx":669 * Algorithm=c_algorithim, * NnzStopNum=max_support_size, * G_ncols=num_lambda, # <<<<<<<<<<<<<< * G_nrows=num_gamma, * Lambda2Max=gamma_max, */ - __pyx_t_31 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_31 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 671, __pyx_L1_error) + __pyx_t_31 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_31 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 669, __pyx_L1_error) - /* "l0learn/interface.pyx":672 + /* "l0learn/interface.pyx":670 * NnzStopNum=max_support_size, * G_ncols=num_lambda, * G_nrows=num_gamma, # <<<<<<<<<<<<<< * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, */ - __pyx_t_30 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_30 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 672, __pyx_L1_error) + __pyx_t_30 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_30 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 670, __pyx_L1_error) - /* "l0learn/interface.pyx":675 + /* "l0learn/interface.pyx":673 * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, * PartialSort=partial_sort, # <<<<<<<<<<<<<< * MaxIters=max_iter, * rtol=rtol, */ - __pyx_t_34 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_34 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 675, __pyx_L1_error) + __pyx_t_34 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_34 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 673, __pyx_L1_error) - /* "l0learn/interface.pyx":676 + /* "l0learn/interface.pyx":674 * Lambda2Min=gamma_min, * PartialSort=partial_sort, * MaxIters=max_iter, # <<<<<<<<<<<<<< * rtol=rtol, * atol=atol, */ - __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 676, __pyx_L1_error) + __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 674, __pyx_L1_error) - /* "l0learn/interface.pyx":679 + /* "l0learn/interface.pyx":677 * rtol=rtol, * atol=atol, * ActiveSet=active_set, # <<<<<<<<<<<<<< * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, */ - __pyx_t_28 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_28 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 679, __pyx_L1_error) + __pyx_t_28 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_28 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 677, __pyx_L1_error) - /* "l0learn/interface.pyx":680 + /* "l0learn/interface.pyx":678 * atol=atol, * ActiveSet=active_set, * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, */ - __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 680, __pyx_L1_error) + __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 678, __pyx_L1_error) - /* "l0learn/interface.pyx":681 + /* "l0learn/interface.pyx":679 * ActiveSet=active_set, * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, */ - __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 681, __pyx_L1_error) + __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 679, __pyx_L1_error) - /* "l0learn/interface.pyx":683 + /* "l0learn/interface.pyx":681 * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, # <<<<<<<<<<<<<< * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, */ - __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 683, __pyx_L1_error) + __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 681, __pyx_L1_error) - /* "l0learn/interface.pyx":686 + /* "l0learn/interface.pyx":684 * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, * nfolds=num_folds, # <<<<<<<<<<<<<< * seed=seed, * ExcludeFirstK=exclude_first_k, */ - __pyx_t_32 = __Pyx_PyInt_As_unsigned_int(__pyx_v_num_folds); if (unlikely((__pyx_t_32 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 686, __pyx_L1_error) + __pyx_t_32 = __Pyx_PyInt_As_unsigned_int(__pyx_v_num_folds); if (unlikely((__pyx_t_32 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 684, __pyx_L1_error) - /* "l0learn/interface.pyx":687 + /* "l0learn/interface.pyx":685 * Lambdas=c_lambda_grid, * nfolds=num_folds, * seed=seed, # <<<<<<<<<<<<<< * ExcludeFirstK=exclude_first_k, * Intercept=intercept, */ - __pyx_t_14 = __pyx_PyFloat_AsDouble(__pyx_v_seed); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 687, __pyx_L1_error) + __pyx_t_14 = __pyx_PyFloat_AsDouble(__pyx_v_seed); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 685, __pyx_L1_error) - /* "l0learn/interface.pyx":688 + /* "l0learn/interface.pyx":686 * nfolds=num_folds, * seed=seed, * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< * Intercept=intercept, * withBounds=with_bounds, */ - __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 688, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 686, __pyx_L1_error) - /* "l0learn/interface.pyx":689 + /* "l0learn/interface.pyx":687 * seed=seed, * ExcludeFirstK=exclude_first_k, * Intercept=intercept, # <<<<<<<<<<<<<< * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), */ - __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 689, __pyx_L1_error) + __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 687, __pyx_L1_error) - /* "l0learn/interface.pyx":691 + /* "l0learn/interface.pyx":689 * Intercept=intercept, * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< * Highs=numpy_to_dvec_d(highs)) * */ - if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 691, __pyx_L1_error) + if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 689, __pyx_L1_error) - /* "l0learn/interface.pyx":692 + /* "l0learn/interface.pyx":690 * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< * * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, */ - if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 692, __pyx_L1_error) + if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 690, __pyx_L1_error) - /* "l0learn/interface.pyx":665 + /* "l0learn/interface.pyx":663 * Highs=numpy_to_dvec_d(highs)) * else: # isinstance(X, csc_matrix) * c_results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< @@ -11593,138 +11611,138 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnCV_sparse(__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(__pyx_v_X), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_33, __pyx_t_31, __pyx_t_30, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_34, __pyx_t_29, __pyx_v_rtol, __pyx_v_atol, __pyx_t_28, __pyx_t_27, __pyx_t_25, __pyx_v_scale_down_factor, __pyx_t_24, (!(__pyx_v_auto_lambda != 0)), __pyx_v_c_lambda_grid, __pyx_t_32, __pyx_t_14, __pyx_t_23, __pyx_t_26, __pyx_v_with_bounds, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); } - __pyx_L108:; + __pyx_L110:; - /* "l0learn/interface.pyx":694 + /* "l0learn/interface.pyx":692 * Highs=numpy_to_dvec_d(highs)) * * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, # <<<<<<<<<<<<<< * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_CVFitModel); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 694, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_CVFitModel); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 692, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = __Pyx_PyDict_NewPresized(9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 694, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyDict_NewPresized(9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 692, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_3 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 694, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 692, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 694, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 694, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 694, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_settings, __pyx_t_3) < 0) __PYX_ERR(0, 694, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 692, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 692, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 692, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_settings, __pyx_t_3) < 0) __PYX_ERR(0, 692, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":695 + /* "l0learn/interface.pyx":693 * * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, * lambda_0=c_results.Lambda0, # <<<<<<<<<<<<<< * gamma=c_results.Lambda12, * support_size=c_results.NnzCount, */ - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Lambda0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 695, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Lambda0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 693, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_lambda_0, __pyx_t_3) < 0) __PYX_ERR(0, 694, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_lambda_0, __pyx_t_3) < 0) __PYX_ERR(0, 692, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":696 + /* "l0learn/interface.pyx":694 * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, # <<<<<<<<<<<<<< * support_size=c_results.NnzCount, * coeffs=sp_dmat_field_to_list(c_results.Beta), */ - __pyx_t_3 = __pyx_convert_vector_to_py_double(__pyx_v_c_results.Lambda12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 696, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_double(__pyx_v_c_results.Lambda12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 694, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_gamma, __pyx_t_3) < 0) __PYX_ERR(0, 694, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_gamma, __pyx_t_3) < 0) __PYX_ERR(0, 692, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":697 + /* "l0learn/interface.pyx":695 * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, * support_size=c_results.NnzCount, # <<<<<<<<<<<<<< * coeffs=sp_dmat_field_to_list(c_results.Beta), * intercepts=c_results.Intercept, */ - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(__pyx_v_c_results.NnzCount); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 697, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(__pyx_v_c_results.NnzCount); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 695, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_support_size, __pyx_t_3) < 0) __PYX_ERR(0, 694, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_support_size, __pyx_t_3) < 0) __PYX_ERR(0, 692, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":698 + /* "l0learn/interface.pyx":696 * gamma=c_results.Lambda12, * support_size=c_results.NnzCount, * coeffs=sp_dmat_field_to_list(c_results.Beta), # <<<<<<<<<<<<<< * intercepts=c_results.Intercept, * converged=c_results.Converged, */ - __pyx_t_3 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_c_results.Beta); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 698, __pyx_L1_error) + __pyx_t_3 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_c_results.Beta); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 696, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_coeffs, __pyx_t_3) < 0) __PYX_ERR(0, 694, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_coeffs, __pyx_t_3) < 0) __PYX_ERR(0, 692, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":699 + /* "l0learn/interface.pyx":697 * support_size=c_results.NnzCount, * coeffs=sp_dmat_field_to_list(c_results.Beta), * intercepts=c_results.Intercept, # <<<<<<<<<<<<<< * converged=c_results.Converged, * cv_means=dvec_field_to_list(c_results.CVMeans), */ - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Intercept); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 699, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Intercept); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 697, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_intercepts, __pyx_t_3) < 0) __PYX_ERR(0, 694, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_intercepts, __pyx_t_3) < 0) __PYX_ERR(0, 692, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":700 + /* "l0learn/interface.pyx":698 * coeffs=sp_dmat_field_to_list(c_results.Beta), * intercepts=c_results.Intercept, * converged=c_results.Converged, # <<<<<<<<<<<<<< * cv_means=dvec_field_to_list(c_results.CVMeans), * cv_sds=dvec_field_to_list(c_results.CVSDs)) */ - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(__pyx_v_c_results.Converged); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 700, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(__pyx_v_c_results.Converged); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 698, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_converged, __pyx_t_3) < 0) __PYX_ERR(0, 694, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_converged, __pyx_t_3) < 0) __PYX_ERR(0, 692, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":701 + /* "l0learn/interface.pyx":699 * intercepts=c_results.Intercept, * converged=c_results.Converged, * cv_means=dvec_field_to_list(c_results.CVMeans), # <<<<<<<<<<<<<< * cv_sds=dvec_field_to_list(c_results.CVSDs)) * return results */ - __pyx_t_3 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_c_results.CVMeans); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 701, __pyx_L1_error) + __pyx_t_3 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_c_results.CVMeans); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 699, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_cv_means, __pyx_t_3) < 0) __PYX_ERR(0, 694, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_cv_means, __pyx_t_3) < 0) __PYX_ERR(0, 692, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":702 + /* "l0learn/interface.pyx":700 * converged=c_results.Converged, * cv_means=dvec_field_to_list(c_results.CVMeans), * cv_sds=dvec_field_to_list(c_results.CVSDs)) # <<<<<<<<<<<<<< * return results * */ - __pyx_t_3 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_c_results.CVSDs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 702, __pyx_L1_error) + __pyx_t_3 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_c_results.CVSDs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 700, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_cv_sds, __pyx_t_3) < 0) __PYX_ERR(0, 694, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_cv_sds, __pyx_t_3) < 0) __PYX_ERR(0, 692, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":694 + /* "l0learn/interface.pyx":692 * Highs=numpy_to_dvec_d(highs)) * * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, # <<<<<<<<<<<<<< * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_empty_tuple, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 694, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_empty_tuple, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 692, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_results = __pyx_t_3; __pyx_t_3 = 0; - /* "l0learn/interface.pyx":703 + /* "l0learn/interface.pyx":701 * cv_means=dvec_field_to_list(c_results.CVMeans), * cv_sds=dvec_field_to_list(c_results.CVSDs)) * return results # <<<<<<<<<<<<<< @@ -11736,7 +11754,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_r = __pyx_v_results; goto __pyx_L0; - /* "l0learn/interface.pyx":445 + /* "l0learn/interface.pyx":444 * * * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< @@ -11775,7 +11793,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p return __pyx_r; } -/* "l0learn/interface.pyx":706 +/* "l0learn/interface.pyx":704 * * * cdef fitmodel _L0LearnFit_dense(const dmat& X, # <<<<<<<<<<<<<< @@ -11788,7 +11806,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_dense(arma::dmat const & __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_L0LearnFit_dense", 0); - /* "l0learn/interface.pyx":732 + /* "l0learn/interface.pyx":730 * const dvec &Lows, * const dvec &Highs): * return L0LearnFit[dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< @@ -11798,7 +11816,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_dense(arma::dmat const & __pyx_r = L0LearnFit(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); goto __pyx_L0; - /* "l0learn/interface.pyx":706 + /* "l0learn/interface.pyx":704 * * * cdef fitmodel _L0LearnFit_dense(const dmat& X, # <<<<<<<<<<<<<< @@ -11812,7 +11830,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_dense(arma::dmat const & return __pyx_r; } -/* "l0learn/interface.pyx":737 +/* "l0learn/interface.pyx":735 * * * cdef fitmodel _L0LearnFit_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< @@ -11825,7 +11843,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_sparse(arma::sp_dmat con __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_L0LearnFit_sparse", 0); - /* "l0learn/interface.pyx":763 + /* "l0learn/interface.pyx":761 * const dvec &Lows, * const dvec &Highs): * return L0LearnFit[sp_dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< @@ -11835,7 +11853,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_sparse(arma::sp_dmat con __pyx_r = L0LearnFit(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); goto __pyx_L0; - /* "l0learn/interface.pyx":737 + /* "l0learn/interface.pyx":735 * * * cdef fitmodel _L0LearnFit_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< @@ -11849,7 +11867,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_sparse(arma::sp_dmat con return __pyx_r; } -/* "l0learn/interface.pyx":768 +/* "l0learn/interface.pyx":766 * * * cdef cvfitmodel _L0LearnCV_dense(const dmat& X, # <<<<<<<<<<<<<< @@ -11862,7 +11880,7 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_dense(arma::dmat const __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_L0LearnCV_dense", 0); - /* "l0learn/interface.pyx":796 + /* "l0learn/interface.pyx":794 * const dvec &Lows, * const dvec &Highs): * return L0LearnCV[dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< @@ -11872,7 +11890,7 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_dense(arma::dmat const __pyx_r = L0LearnCV(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_nfolds, __pyx_v_seed, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); goto __pyx_L0; - /* "l0learn/interface.pyx":768 + /* "l0learn/interface.pyx":766 * * * cdef cvfitmodel _L0LearnCV_dense(const dmat& X, # <<<<<<<<<<<<<< @@ -11886,7 +11904,7 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_dense(arma::dmat const return __pyx_r; } -/* "l0learn/interface.pyx":801 +/* "l0learn/interface.pyx":799 * * * cdef cvfitmodel _L0LearnCV_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< @@ -11899,7 +11917,7 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_sparse(arma::sp_dmat co __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_L0LearnCV_sparse", 0); - /* "l0learn/interface.pyx":829 + /* "l0learn/interface.pyx":827 * const dvec &Lows, * const dvec &Highs): * return L0LearnCV[sp_dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< @@ -11909,7 +11927,7 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_sparse(arma::sp_dmat co __pyx_r = L0LearnCV(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_nfolds, __pyx_v_seed, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); goto __pyx_L0; - /* "l0learn/interface.pyx":801 + /* "l0learn/interface.pyx":799 * * * cdef cvfitmodel _L0LearnCV_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< @@ -13591,7 +13609,7 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_issubdtype, __pyx_k_issubdtype, sizeof(__pyx_k_issubdtype), 0, 0, 1, 1}, {&__pyx_n_s_l0learn_interface, __pyx_k_l0learn_interface, sizeof(__pyx_k_l0learn_interface), 0, 0, 1, 1}, {&__pyx_kp_s_l0learn_interface_pyx, __pyx_k_l0learn_interface_pyx, sizeof(__pyx_k_l0learn_interface_pyx), 0, 0, 1, 0}, - {&__pyx_n_s_l0learn_utils, __pyx_k_l0learn_utils, sizeof(__pyx_k_l0learn_utils), 0, 0, 1, 1}, + {&__pyx_n_s_l0learn_models, __pyx_k_l0learn_models, sizeof(__pyx_k_l0learn_models), 0, 0, 1, 1}, {&__pyx_n_s_lambda_0, __pyx_k_lambda_0, sizeof(__pyx_k_lambda_0), 0, 0, 1, 1}, {&__pyx_n_s_lambda_grid, __pyx_k_lambda_grid, sizeof(__pyx_k_lambda_grid), 0, 0, 1, 1}, {&__pyx_n_s_loss, __pyx_k_loss, sizeof(__pyx_k_loss), 0, 0, 1, 1}, @@ -13651,10 +13669,10 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 19, __pyx_L1_error) __pyx_builtin_NotImplementedError = __Pyx_GetBuiltinName(__pyx_n_s_NotImplementedError); if (!__pyx_builtin_NotImplementedError) __PYX_ERR(0, 28, __pyx_L1_error) - __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(0, 321, __pyx_L1_error) - __pyx_builtin_any = __Pyx_GetBuiltinName(__pyx_n_s_any); if (!__pyx_builtin_any) __PYX_ERR(0, 326, __pyx_L1_error) - __pyx_builtin_all = __Pyx_GetBuiltinName(__pyx_n_s_all); if (!__pyx_builtin_all) __PYX_ERR(0, 338, __pyx_L1_error) - __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 372, __pyx_L1_error) + __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(0, 320, __pyx_L1_error) + __pyx_builtin_any = __Pyx_GetBuiltinName(__pyx_n_s_any); if (!__pyx_builtin_any) __PYX_ERR(0, 325, __pyx_L1_error) + __pyx_builtin_all = __Pyx_GetBuiltinName(__pyx_n_s_all); if (!__pyx_builtin_all) __PYX_ERR(0, 337, __pyx_L1_error) + __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 371, __pyx_L1_error) __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 884, __pyx_L1_error) __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(2, 61, __pyx_L1_error) return 0; @@ -13744,7 +13762,7 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_GIVEREF(__pyx_tuple__12); /* "l0learn/interface.pyx":15 - * from l0learn.utils import FitModel, CVFitModel + * from l0learn.models import FitModel, CVFitModel * * def np_to_arma_check(arr): # <<<<<<<<<<<<<< * # TODO: Add checks for Behaved and OwnsData @@ -13800,17 +13818,17 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_GIVEREF(__pyx_tuple__19); __pyx_codeobj__20 = (PyObject*)__Pyx_PyCode_New(24, 0, 42, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__19, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_fit, 50, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__20)) __PYX_ERR(0, 50, __pyx_L1_error) - /* "l0learn/interface.pyx":445 + /* "l0learn/interface.pyx":444 * * * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< * y: np.ndarray, * loss: str = "SquaredHinge", */ - __pyx_tuple__21 = PyTuple_Pack(44, __pyx_n_s_X, __pyx_n_s_y, __pyx_n_s_loss, __pyx_n_s_penalty, __pyx_n_s_algorithm, __pyx_n_s_num_folds, __pyx_n_s_seed, __pyx_n_s_max_support_size, __pyx_n_s_num_lambda, __pyx_n_s_num_gamma, __pyx_n_s_gamma_max, __pyx_n_s_gamma_min, __pyx_n_s_partial_sort, __pyx_n_s_max_iter, __pyx_n_s_rtol, __pyx_n_s_atol, __pyx_n_s_active_set, __pyx_n_s_active_set_num, __pyx_n_s_max_swaps, __pyx_n_s_scale_down_factor, __pyx_n_s_screen_size, __pyx_n_s_lambda_grid, __pyx_n_s_exclude_first_k, __pyx_n_s_intercept, __pyx_n_s_lows, __pyx_n_s_highs, __pyx_n_s_n, __pyx_n_s_p, __pyx_n_s_unique_items, __pyx_n_s_a, __pyx_n_s__18, __pyx_n_s_auto_lambda, __pyx_n_s_bad_lambda_grid, __pyx_n_s_i, __pyx_n_s_sub_lambda_grid, __pyx_n_s_current, __pyx_n_s_with_bounds, __pyx_n_s_bad_bounds, __pyx_n_s_c_lambda_grid, __pyx_n_s_c_loss, __pyx_n_s_c_penalty, __pyx_n_s_c_algorithim, __pyx_n_s_c_results, __pyx_n_s_results); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(0, 445, __pyx_L1_error) + __pyx_tuple__21 = PyTuple_Pack(44, __pyx_n_s_X, __pyx_n_s_y, __pyx_n_s_loss, __pyx_n_s_penalty, __pyx_n_s_algorithm, __pyx_n_s_num_folds, __pyx_n_s_seed, __pyx_n_s_max_support_size, __pyx_n_s_num_lambda, __pyx_n_s_num_gamma, __pyx_n_s_gamma_max, __pyx_n_s_gamma_min, __pyx_n_s_partial_sort, __pyx_n_s_max_iter, __pyx_n_s_rtol, __pyx_n_s_atol, __pyx_n_s_active_set, __pyx_n_s_active_set_num, __pyx_n_s_max_swaps, __pyx_n_s_scale_down_factor, __pyx_n_s_screen_size, __pyx_n_s_lambda_grid, __pyx_n_s_exclude_first_k, __pyx_n_s_intercept, __pyx_n_s_lows, __pyx_n_s_highs, __pyx_n_s_n, __pyx_n_s_p, __pyx_n_s_unique_items, __pyx_n_s_a, __pyx_n_s__18, __pyx_n_s_auto_lambda, __pyx_n_s_bad_lambda_grid, __pyx_n_s_i, __pyx_n_s_sub_lambda_grid, __pyx_n_s_current, __pyx_n_s_with_bounds, __pyx_n_s_bad_bounds, __pyx_n_s_c_lambda_grid, __pyx_n_s_c_loss, __pyx_n_s_c_penalty, __pyx_n_s_c_algorithim, __pyx_n_s_c_results, __pyx_n_s_results); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(0, 444, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__21); __Pyx_GIVEREF(__pyx_tuple__21); - __pyx_codeobj__22 = (PyObject*)__Pyx_PyCode_New(26, 0, 44, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__21, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_cvfit, 445, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__22)) __PYX_ERR(0, 445, __pyx_L1_error) + __pyx_codeobj__22 = (PyObject*)__Pyx_PyCode_New(26, 0, 44, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__21, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_cvfit, 444, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__22)) __PYX_ERR(0, 444, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; @@ -14254,7 +14272,7 @@ if (!__Pyx_RefNanny) { /* "l0learn/interface.pyx":13 * sp_dmat_field_to_list, dvec_field_to_list * - * from l0learn.utils import FitModel, CVFitModel # <<<<<<<<<<<<<< + * from l0learn.models import FitModel, CVFitModel # <<<<<<<<<<<<<< * * def np_to_arma_check(arr): */ @@ -14266,7 +14284,7 @@ if (!__Pyx_RefNanny) { __Pyx_INCREF(__pyx_n_s_CVFitModel); __Pyx_GIVEREF(__pyx_n_s_CVFitModel); PyList_SET_ITEM(__pyx_t_2, 1, __pyx_n_s_CVFitModel); - __pyx_t_1 = __Pyx_Import(__pyx_n_s_l0learn_utils, __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error) + __pyx_t_1 = __Pyx_Import(__pyx_n_s_l0learn_models, __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_FitModel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 13, __pyx_L1_error) @@ -14280,7 +14298,7 @@ if (!__Pyx_RefNanny) { __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "l0learn/interface.pyx":15 - * from l0learn.utils import FitModel, CVFitModel + * from l0learn.models import FitModel, CVFitModel * * def np_to_arma_check(arr): # <<<<<<<<<<<<<< * # TODO: Add checks for Behaved and OwnsData @@ -14386,44 +14404,44 @@ if (!__Pyx_RefNanny) { if (PyDict_SetItem(__pyx_d, __pyx_n_s_fit, __pyx_t_1) < 0) __PYX_ERR(0, 50, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":469 + /* "l0learn/interface.pyx":468 * exclude_first_k: int = 0, * intercept: bool = True, * lows: Union[np.ndarray, float] = -float('inf'), # <<<<<<<<<<<<<< * highs: Union[np.ndarray, float] = +float('inf'),): * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): */ - __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 469, __pyx_L1_error) - __pyx_t_1 = PyFloat_FromDouble((-__pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 469, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 468, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble((-__pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 468, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_k__9 = __pyx_t_1; __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":470 + /* "l0learn/interface.pyx":469 * intercept: bool = True, * lows: Union[np.ndarray, float] = -float('inf'), * highs: Union[np.ndarray, float] = +float('inf'),): # <<<<<<<<<<<<<< * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") */ - __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 470, __pyx_L1_error) - __pyx_t_1 = PyFloat_FromDouble(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 470, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 469, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 469, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_k__10 = __pyx_t_1; __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":445 + /* "l0learn/interface.pyx":444 * * * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< * y: np.ndarray, * loss: str = "SquaredHinge", */ - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_5cvfit, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 445, __pyx_L1_error) + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_5cvfit, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 444, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_cvfit, __pyx_t_1) < 0) __PYX_ERR(0, 445, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_cvfit, __pyx_t_1) < 0) __PYX_ERR(0, 444, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "l0learn/interface.pyx":1 diff --git a/python/l0learn/interface.pyx b/python/l0learn/interface.pyx index 1fd167e..f57088e 100644 --- a/python/l0learn/interface.pyx +++ b/python/l0learn/interface.pyx @@ -10,7 +10,7 @@ from typing import Union, Optional, List from l0learn.cyarma cimport dmat, sp_dmat, numpy_to_sp_dmat_d, numpy_to_dmat_d, dvec, numpy_to_dvec_d, \ sp_dmat_field_to_list, dvec_field_to_list -from l0learn.utils import FitModel, CVFitModel +from l0learn.models import FitModel, CVFitModel def np_to_arma_check(arr): # TODO: Add checks for Behaved and OwnsData diff --git a/python/l0learn/utils.py b/python/l0learn/models.py similarity index 79% rename from python/l0learn/utils.py rename to python/l0learn/models.py index 0739b17..b2f6112 100644 --- a/python/l0learn/utils.py +++ b/python/l0learn/models.py @@ -1,6 +1,7 @@ import warnings from dataclasses import dataclass, field -from typing import List, Dict, Any, Optional, Tuple, Union +from functools import wraps +from typing import List, Dict, Any, Optional, Tuple, Union, Sequence, Callable import numpy as np import pandas as pd @@ -10,43 +11,129 @@ def regularization_loss(coeffs: csc_matrix, - l0: float = 0, - l1: float = 0, - l2: float = 0, - sum_all_paths: bool = True) -> Union[float, np.ndarray]: + l0: Union[float, Sequence[float]] = 0, + l1: Union[float, Sequence[float]] = 0, + l2: Union[float, Sequence[float]] = 0, ) -> Union[float, np.ndarray]: + """ + Calculates the regularization loss for a path of (or individual) solution(s). + + Parameters + ---------- + coeffs + l0: + l1 + l2 + + Returns + ------- + loss : float or np.ndarray of shape (K,) where K is the number of solutions in coeffs + Let the shape of coeffs be (P, K) and l0, l1, and l2 by either a float or a sequence of length K + Then loss will be of shape: (K, ) with the following layout: + loss[i] = l0[i]*||coeffs[:, i||_0 + l1[i]*||coeffs[:, i||_1 + l2[i]*||coeffs[:, i||_2 + + Notes + ----- + + """ if coeffs.ndim != 2: raise NotImplementedError("expected coeffs to be a 2D array") - if sum_all_paths or coeffs.shape[1] == 1: + l0 = np.asarray(l0) + l1 = np.asarray(l1) + l2 = np.asarray(l2) + + _, num_solutions = coeffs.shape + + infer_penalties = l0 + l1 + l2 + + if infer_penalties.ndim == 0: + num_penalties = num_solutions + elif infer_penalties.ndim == 1: + num_penalties = len(infer_penalties) + else: + raise ValueError(f"expected penalties l0, l1, and l2 mutually broadcast to a float or a 1D array," + f" but got {infer_penalties.ndim}D array.") + + if num_penalties != num_solutions: + raise ValueError(f"expected number of penalties to be equal to the number of solutions if multiple penalties " + f"are provided, but got {num_penalties} penalties and {num_solutions} solutions.") + + l0 = np.broadcast_to(l0, [num_penalties]) + l1 = np.broadcast_to(l1, [num_penalties]) + l2 = np.broadcast_to(l2, [num_penalties]) + + if num_solutions == 1: _, _, values = find(coeffs) - loss = (l0 * len(values) - + l1 * sum(abs(values)) - + l2 * sum(values ** 2)) - else: # TODO: Implement this regularization loss better than a for loop over rows and cols! - rows, cols = coeffs.shape - loss = np.zeros(cols) - for col in range(cols): - loss[col] = regularization_loss(coeffs[:, col], l0=l0, l1=l1, l2=l2, sum_all_paths=True) + + return float(l0 * len(values) + l1 * sum(abs(values)) + sum((np.sqrt(l2) * values) ** 2)) + else: # TODO: Implement this regularization loss better than a for loop over num_solutions! + _, num_solutions = coeffs.shape + loss = np.zeros(num_solutions) + + for solution_index in range(num_solutions): + loss[solution_index] = regularization_loss(coeffs[:, solution_index], + l0=l0[solution_index], + l1=l1[solution_index], + l2=l2[solution_index]) return loss +# def broadcast_with_regularization_loss( +# metric_func: Callable[[Any], Tuple[np.ndarray, np.ndarray]]) -> Callable[[Any], np.ndarray]: +# @wraps(metric_func) +# def reshape_metric_loss(*args, **kwargs) -> np.ndarray: +# metric_loss, reg_loss = metric_func(*args, **kwargs) +# +# if reg_loss.ndim == 0: +# return metric_loss + reg_loss +# elif reg_loss.ndim == 2 and metric_loss.ndim == 2: +# # reg_loss of shape (l, k) +# # metric_loss of shape (m, k) +# return metric_loss[:, np.newaxis, :] + reg_loss # result of shape (m, l, k) +# elif reg_loss.ndim == 1 and metric_loss.ndim == 1: +# # reg_loss of shape (l,) +# # squared_residuals of shape (m, ) +# return metric_loss[:, np.newaxis] + reg_loss +# else: +# raise ValueError("This should not happen") +# +# return reshape_metric_loss + + def squared_error(y_true: np.ndarray, y_pred: np.ndarray, coeffs: Optional[csc_matrix] = None, - l0: float = 0, - l1: float = 0, - l2: float = 0, - sum_all_paths: bool = True) -> Union[float, np.ndarray]: - loss = 0 - if coeffs: - loss = regularization_loss(coeffs=coeffs, l0=l0, l1=l1, l2=l2, sum_all_paths=sum_all_paths) + l0: Union[float, Sequence[float]] = 0, + l1: Union[float, Sequence[float]] = 0, + l2: Union[float, Sequence[float]] = 0) -> Tuple[np.ndarray, np.ndarray]: + """ + Calculates Squared Error loss of solution with optional regularization + + Parameters + ---------- + y_true : np.ndarray of shape (m, ) + y_pred : np.ndarray of shape (m, ) or (m, k) + coeffs : np.ndarray of shape (p, k), optional + l0 : float or sequence of floats of shape (l) + l1 : float or sequence of floats of shape (l) + l2 : float or sequence of floats of shape (l) + + Returns + ------- + squared_error = (m, k) + + """ + reg_loss = 0 + if coeffs is not None: + reg_loss = regularization_loss(coeffs=coeffs, l0=l0, l1=l1, l2=l2) + + if y_pred.ndim == 2: + y_true = y_true[:, np.newaxis] squared_residuals = 0.5 * np.square(y_true - y_pred) - if sum_all_paths: - return squared_residuals.sum() + loss - else: - return squared_residuals.sum(axis=0) + loss + + return squared_residuals + reg_loss def logistic_loss(y_true: np.ndarray, @@ -54,13 +141,12 @@ def logistic_loss(y_true: np.ndarray, coeffs: Optional[csc_matrix] = None, l0: float = 0, l1: float = 0, - l2: float = 0, - sum_all_paths: bool = True) -> Union[float, np.ndarray]: + l2: float = 0, ) -> Union[float, np.ndarray]: # TODO: Check this formula. If there is an error here, there might be an error in the C++ code for Logistic. - loss = 0 - if coeffs: - loss += regularization_loss(coeffs=coeffs, l0=l0, l1=l1, l2=l2, sum_all_paths=sum_all_paths) + reg_loss = 0 + if coeffs is not None: + reg_loss = regularization_loss(coeffs=coeffs, l0=l0, l1=l1, l2=l2) # C++ Src Code: # ExpyXB = arma::exp(this->y % (*(this->X) * this->B + this->b0)); @@ -69,10 +155,7 @@ def logistic_loss(y_true: np.ndarray, exp_y_XB = np.exp(y_true * np.log(y_pred)) log_loss = np.log(1 + 1 / exp_y_XB) - if sum_all_paths: - return log_loss.sum() + loss - else: - return log_loss.sum(axis=0) + loss + return log_loss + reg_loss def squared_hinge_loss(y_true: np.ndarray, @@ -80,13 +163,12 @@ def squared_hinge_loss(y_true: np.ndarray, coeffs: Optional[csc_matrix] = None, l0: float = 0, l1: float = 0, - l2: float = 0, - sum_all_paths: bool = True) -> Union[float, np.ndarray]: + l2: float = 0, ) -> Union[float, np.ndarray]: # TODO: Check this formula. If there is an error here, there might be an error in the C++ code for Logistic. - loss = 0 - if coeffs: - loss += regularization_loss(coeffs=coeffs, l0=l0, l1=l1, l2=l2, sum_all_paths=sum_all_paths) + reg_loss = 0 + if coeffs is not None: + reg_loss = regularization_loss(coeffs=coeffs, l0=l0, l1=l1, l2=l2) # C++ Src Code: # onemyxb = 1 - this->y % (*(this->X) * this->B + this->b0); @@ -95,13 +177,10 @@ def squared_hinge_loss(y_true: np.ndarray, # B) + this->lambda1 * arma::norm(B, 1) + this->lambda2 * l2norm * l2norm; square_one_minus_y_XB = np.square(np.max(1 - y_true * y_pred, 0)) - if sum_all_paths: - return square_one_minus_y_XB.sum() + loss - else: - return square_one_minus_y_XB.sum(axis=0) + loss + return square_one_minus_y_XB + reg_loss -@dataclass(frozen=True, repr=False) +@dataclass(frozen=True, repr=False, eq=False) class FitModel: settings: Dict[str, Any] lambda_0: List[List[float]] = field(repr=False) @@ -197,19 +276,18 @@ def coeff(self, intercepts = [self.intercepts[gamma_index][lambda_index]] if include_intercept: - solutions = vstack([intercepts[0], solutions]) + solutions = csc_matrix(vstack([intercepts[0], solutions])) return solutions def characteristics(self, lambda_0: Optional[float] = None, - gamma: Optional[float] = None, - include_intercept: bool = True) -> pd.DataFrame: + gamma: Optional[float] = None) -> pd.DataFrame: if gamma is None: if lambda_0 is None: # Return all solutions - intercepts = [[intercept for intercept_list in self.intercepts for intercept in intercept_list]] + intercepts = self.intercepts lambda_0 = self.lambda_0 gamma = self.gamma support_size = self.support_size @@ -217,8 +295,7 @@ def characteristics(self, else: # Return solution with closest lambda in first gamma return self.characteristics(gamma=self.gamma[0], - lambda_0=lambda_0, - include_intercept=include_intercept) + lambda_0=lambda_0) else: gamma_index = int(np.argmin(np.abs(np.asarray(self.gamma) - gamma))) if lambda_0 is None: @@ -231,11 +308,11 @@ def characteristics(self, else: # Return solution with closest lambda in gamma_index lambda_index = int(np.argmin(np.abs(np.asarray(self.lambda_0[gamma_index]) - lambda_0))) - intercepts = [self.intercepts[gamma_index][lambda_index]] - lambda_0 = [self.lambda_0[gamma_index][lambda_index]] + intercepts = [[self.intercepts[gamma_index][lambda_index]]] + lambda_0 = [[self.lambda_0[gamma_index][lambda_index]]] gamma = [self.gamma[gamma_index]] - support_size = [self.support_size[gamma_index][lambda_index]] - converged = [self.converged[gamma_index][lambda_index]] + support_size = [[self.support_size[gamma_index][lambda_index]]] + converged = [[self.converged[gamma_index][lambda_index]]] return self.characteristics_as_pandas_table(new_data=(gamma, lambda_0, support_size, intercepts, converged)) @@ -321,9 +398,9 @@ def score(self, if training: coeffs = self.coeff(lambda_0=lambda_0, gamma=gamma) - l0 = characteristics.get('l0') - l1 = characteristics.get('l1') - l2 = characteristics.get('l2') + l0 = characteristics.get('l0', 0) + l1 = characteristics.get('l1', 0) + l2 = characteristics.get('l2', 0) else: coeffs = None l0 = 0 @@ -331,14 +408,11 @@ def score(self, l2 = 0 if self.settings['loss'] == "SquaredError": - score = squared_error(y_true=y, y_pred=predictions, coeffs=coeffs, l0=l0, l1=l1, l2=l2, - sum_all_paths=False) + score = squared_error(y_true=y, y_pred=predictions, coeffs=coeffs, l0=l0, l1=l1, l2=l2, ) elif self.settings['loss'] == "Logistic": - score = logistic_loss(y_true=y, y_pred=predictions, coeffs=coeffs, l0=l0, l1=l1, l2=l2, - sum_all_paths=False) + score = logistic_loss(y_true=y, y_pred=predictions, coeffs=coeffs, l0=l0, l1=l1, l2=l2, ) else: - score = squared_hinge_loss(y_true=y, y_pred=predictions, coeffs=coeffs, l0=l0, l1=l1, l2=l2, - sum_all_paths=False) + score = squared_hinge_loss(y_true=y, y_pred=predictions, coeffs=coeffs, l0=l0, l1=l1, l2=l2, ) if include_characteristics: characteristics[self.settings['loss']] = score @@ -387,7 +461,7 @@ def predict(self, if self.settings['intercept']: x = np.hstack([np.ones((n, 1)), x]) - activations = x@coeffs + activations = x @ coeffs if self.settings['loss'] == "Logistic": return 1 / (1 + np.exp(-activations)) @@ -395,7 +469,7 @@ def predict(self, return activations -@dataclass(frozen=True, repr=False) +@dataclass(frozen=True, repr=False, eq=False) class CVFitModel(FitModel): cv_means: List[np.ndarray] = field(repr=False) cv_sds: List[np.ndarray] = field(repr=False) diff --git a/python/l0learn/testing_utils.cpp b/python/l0learn/testing_utils.cpp index e787bbf..982f50c 100644 --- a/python/l0learn/testing_utils.cpp +++ b/python/l0learn/testing_utils.cpp @@ -1733,8 +1733,8 @@ static PyObject *__pyx_codeobj__14; static PyObject *__pyx_codeobj__16; /* Late includes */ -/* "l0learn/testing_utils.pyx":10 - * sp_dmat_to_numpy) +/* "l0learn/testing_utils.pyx":11 + * * * def list_csc_to_arma_csc_to_list(x): # <<<<<<<<<<<<<< * return c_list_csc_to_arma_csc_to_list(x) @@ -1765,23 +1765,23 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_list_csc_to_arma_csc_to_list( int __pyx_clineno = 0; __Pyx_RefNannySetupContext("list_csc_to_arma_csc_to_list", 0); - /* "l0learn/testing_utils.pyx":11 + /* "l0learn/testing_utils.pyx":12 * * def list_csc_to_arma_csc_to_list(x): * return c_list_csc_to_arma_csc_to_list(x) # <<<<<<<<<<<<<< * - * cdef list c_list_csc_to_arma_csc_to_list(list x): + * */ __Pyx_XDECREF(__pyx_r); - if (!(likely(PyList_CheckExact(__pyx_v_x))||((__pyx_v_x) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_x)->tp_name), 0))) __PYX_ERR(0, 11, __pyx_L1_error) - __pyx_t_1 = __pyx_f_7l0learn_13testing_utils_c_list_csc_to_arma_csc_to_list(((PyObject*)__pyx_v_x)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 11, __pyx_L1_error) + if (!(likely(PyList_CheckExact(__pyx_v_x))||((__pyx_v_x) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_x)->tp_name), 0))) __PYX_ERR(0, 12, __pyx_L1_error) + __pyx_t_1 = __pyx_f_7l0learn_13testing_utils_c_list_csc_to_arma_csc_to_list(((PyObject*)__pyx_v_x)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "l0learn/testing_utils.pyx":10 - * sp_dmat_to_numpy) + /* "l0learn/testing_utils.pyx":11 + * * * def list_csc_to_arma_csc_to_list(x): # <<<<<<<<<<<<<< * return c_list_csc_to_arma_csc_to_list(x) @@ -1799,8 +1799,8 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_list_csc_to_arma_csc_to_list( return __pyx_r; } -/* "l0learn/testing_utils.pyx":13 - * return c_list_csc_to_arma_csc_to_list(x) +/* "l0learn/testing_utils.pyx":15 + * * * cdef list c_list_csc_to_arma_csc_to_list(list x): # <<<<<<<<<<<<<< * cdef field[sp_dmat] f = list_to_sp_dmat_field(x) @@ -1818,7 +1818,7 @@ static PyObject *__pyx_f_7l0learn_13testing_utils_c_list_csc_to_arma_csc_to_list int __pyx_clineno = 0; __Pyx_RefNannySetupContext("c_list_csc_to_arma_csc_to_list", 0); - /* "l0learn/testing_utils.pyx":14 + /* "l0learn/testing_utils.pyx":16 * * cdef list c_list_csc_to_arma_csc_to_list(list x): * cdef field[sp_dmat] f = list_to_sp_dmat_field(x) # <<<<<<<<<<<<<< @@ -1827,33 +1827,33 @@ static PyObject *__pyx_f_7l0learn_13testing_utils_c_list_csc_to_arma_csc_to_list */ __pyx_v_f = __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_field(__pyx_v_x); - /* "l0learn/testing_utils.pyx":15 + /* "l0learn/testing_utils.pyx":17 * cdef list c_list_csc_to_arma_csc_to_list(list x): * cdef field[sp_dmat] f = list_to_sp_dmat_field(x) * cdef lst = sp_dmat_field_to_list(f) # <<<<<<<<<<<<<< * return lst * */ - __pyx_t_1 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_f); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 15, __pyx_L1_error) + __pyx_t_1 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_f); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_lst = __pyx_t_1; __pyx_t_1 = 0; - /* "l0learn/testing_utils.pyx":16 + /* "l0learn/testing_utils.pyx":18 * cdef field[sp_dmat] f = list_to_sp_dmat_field(x) * cdef lst = sp_dmat_field_to_list(f) * return lst # <<<<<<<<<<<<<< * - * def list_dvec_to_arma_dvec_to_list(x): + * */ __Pyx_XDECREF(__pyx_r); - if (!(likely(PyList_CheckExact(__pyx_v_lst))||((__pyx_v_lst) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_lst)->tp_name), 0))) __PYX_ERR(0, 16, __pyx_L1_error) + if (!(likely(PyList_CheckExact(__pyx_v_lst))||((__pyx_v_lst) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_lst)->tp_name), 0))) __PYX_ERR(0, 18, __pyx_L1_error) __Pyx_INCREF(__pyx_v_lst); __pyx_r = ((PyObject*)__pyx_v_lst); goto __pyx_L0; - /* "l0learn/testing_utils.pyx":13 - * return c_list_csc_to_arma_csc_to_list(x) + /* "l0learn/testing_utils.pyx":15 + * * * cdef list c_list_csc_to_arma_csc_to_list(list x): # <<<<<<<<<<<<<< * cdef field[sp_dmat] f = list_to_sp_dmat_field(x) @@ -1872,8 +1872,8 @@ static PyObject *__pyx_f_7l0learn_13testing_utils_c_list_csc_to_arma_csc_to_list return __pyx_r; } -/* "l0learn/testing_utils.pyx":18 - * return lst +/* "l0learn/testing_utils.pyx":21 + * * * def list_dvec_to_arma_dvec_to_list(x): # <<<<<<<<<<<<<< * return c_list_dvec_to_arma_dvec_to_list(x) @@ -1904,23 +1904,23 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_2list_dvec_to_arma_dvec_to_li int __pyx_clineno = 0; __Pyx_RefNannySetupContext("list_dvec_to_arma_dvec_to_list", 0); - /* "l0learn/testing_utils.pyx":19 + /* "l0learn/testing_utils.pyx":22 * * def list_dvec_to_arma_dvec_to_list(x): * return c_list_dvec_to_arma_dvec_to_list(x) # <<<<<<<<<<<<<< * - * cdef list c_list_dvec_to_arma_dvec_to_list(list x): + * */ __Pyx_XDECREF(__pyx_r); - if (!(likely(PyList_CheckExact(__pyx_v_x))||((__pyx_v_x) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_x)->tp_name), 0))) __PYX_ERR(0, 19, __pyx_L1_error) - __pyx_t_1 = __pyx_f_7l0learn_13testing_utils_c_list_dvec_to_arma_dvec_to_list(((PyObject*)__pyx_v_x)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) + if (!(likely(PyList_CheckExact(__pyx_v_x))||((__pyx_v_x) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_x)->tp_name), 0))) __PYX_ERR(0, 22, __pyx_L1_error) + __pyx_t_1 = __pyx_f_7l0learn_13testing_utils_c_list_dvec_to_arma_dvec_to_list(((PyObject*)__pyx_v_x)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "l0learn/testing_utils.pyx":18 - * return lst + /* "l0learn/testing_utils.pyx":21 + * * * def list_dvec_to_arma_dvec_to_list(x): # <<<<<<<<<<<<<< * return c_list_dvec_to_arma_dvec_to_list(x) @@ -1938,8 +1938,8 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_2list_dvec_to_arma_dvec_to_li return __pyx_r; } -/* "l0learn/testing_utils.pyx":21 - * return c_list_dvec_to_arma_dvec_to_list(x) +/* "l0learn/testing_utils.pyx":25 + * * * cdef list c_list_dvec_to_arma_dvec_to_list(list x): # <<<<<<<<<<<<<< * cdef field[dvec] f = list_to_dvec_field(x) @@ -1957,7 +1957,7 @@ static PyObject *__pyx_f_7l0learn_13testing_utils_c_list_dvec_to_arma_dvec_to_li int __pyx_clineno = 0; __Pyx_RefNannySetupContext("c_list_dvec_to_arma_dvec_to_list", 0); - /* "l0learn/testing_utils.pyx":22 + /* "l0learn/testing_utils.pyx":26 * * cdef list c_list_dvec_to_arma_dvec_to_list(list x): * cdef field[dvec] f = list_to_dvec_field(x) # <<<<<<<<<<<<<< @@ -1966,19 +1966,19 @@ static PyObject *__pyx_f_7l0learn_13testing_utils_c_list_dvec_to_arma_dvec_to_li */ __pyx_v_f = __pyx_f_7l0learn_6cyarma_list_to_dvec_field(__pyx_v_x); - /* "l0learn/testing_utils.pyx":23 + /* "l0learn/testing_utils.pyx":27 * cdef list c_list_dvec_to_arma_dvec_to_list(list x): * cdef field[dvec] f = list_to_dvec_field(x) * cdef lst = dvec_field_to_list(f) # <<<<<<<<<<<<<< * return lst * */ - __pyx_t_1 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_f); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 23, __pyx_L1_error) + __pyx_t_1 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_f); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 27, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_lst = __pyx_t_1; __pyx_t_1 = 0; - /* "l0learn/testing_utils.pyx":24 + /* "l0learn/testing_utils.pyx":28 * cdef field[dvec] f = list_to_dvec_field(x) * cdef lst = dvec_field_to_list(f) * return lst # <<<<<<<<<<<<<< @@ -1986,13 +1986,13 @@ static PyObject *__pyx_f_7l0learn_13testing_utils_c_list_dvec_to_arma_dvec_to_li * */ __Pyx_XDECREF(__pyx_r); - if (!(likely(PyList_CheckExact(__pyx_v_lst))||((__pyx_v_lst) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_lst)->tp_name), 0))) __PYX_ERR(0, 24, __pyx_L1_error) + if (!(likely(PyList_CheckExact(__pyx_v_lst))||((__pyx_v_lst) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_lst)->tp_name), 0))) __PYX_ERR(0, 28, __pyx_L1_error) __Pyx_INCREF(__pyx_v_lst); __pyx_r = ((PyObject*)__pyx_v_lst); goto __pyx_L0; - /* "l0learn/testing_utils.pyx":21 - * return c_list_dvec_to_arma_dvec_to_list(x) + /* "l0learn/testing_utils.pyx":25 + * * * cdef list c_list_dvec_to_arma_dvec_to_list(list x): # <<<<<<<<<<<<<< * cdef field[dvec] f = list_to_dvec_field(x) @@ -2011,7 +2011,7 @@ static PyObject *__pyx_f_7l0learn_13testing_utils_c_list_dvec_to_arma_dvec_to_li return __pyx_r; } -/* "l0learn/testing_utils.pyx":27 +/* "l0learn/testing_utils.pyx":31 * * * def dmat_np_to_arma_to_np(x): # <<<<<<<<<<<<<< @@ -2054,15 +2054,15 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_4dmat_np_to_arma_to_np(CYTHON __pyx_pybuffernd_x_pass.data = NULL; __pyx_pybuffernd_x_pass.rcbuffer = &__pyx_pybuffer_x_pass; - /* "l0learn/testing_utils.pyx":29 + /* "l0learn/testing_utils.pyx":33 * def dmat_np_to_arma_to_np(x): * cdef np.ndarray[np.double_t, ndim=2] x_pass * x_pass = c_dmat_np_to_arma_to_np(x) # <<<<<<<<<<<<<< * * return x_pass */ - if (!(likely(((__pyx_v_x) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_x, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 29, __pyx_L1_error) - __pyx_t_1 = ((PyObject *)__pyx_f_7l0learn_13testing_utils_c_dmat_np_to_arma_to_np(((PyArrayObject *)__pyx_v_x))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 29, __pyx_L1_error) + if (!(likely(((__pyx_v_x) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_x, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 33, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_7l0learn_13testing_utils_c_dmat_np_to_arma_to_np(((PyArrayObject *)__pyx_v_x))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; @@ -2079,12 +2079,12 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_4dmat_np_to_arma_to_np(CYTHON __pyx_t_3 = __pyx_t_4 = __pyx_t_5 = 0; } __pyx_pybuffernd_x_pass.diminfo[0].strides = __pyx_pybuffernd_x_pass.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x_pass.diminfo[0].shape = __pyx_pybuffernd_x_pass.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_x_pass.diminfo[1].strides = __pyx_pybuffernd_x_pass.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_x_pass.diminfo[1].shape = __pyx_pybuffernd_x_pass.rcbuffer->pybuffer.shape[1]; - if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 29, __pyx_L1_error) + if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 33, __pyx_L1_error) } __pyx_v_x_pass = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/testing_utils.pyx":31 + /* "l0learn/testing_utils.pyx":35 * x_pass = c_dmat_np_to_arma_to_np(x) * * return x_pass # <<<<<<<<<<<<<< @@ -2096,7 +2096,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_4dmat_np_to_arma_to_np(CYTHON __pyx_r = ((PyObject *)__pyx_v_x_pass); goto __pyx_L0; - /* "l0learn/testing_utils.pyx":27 + /* "l0learn/testing_utils.pyx":31 * * * def dmat_np_to_arma_to_np(x): # <<<<<<<<<<<<<< @@ -2125,7 +2125,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_4dmat_np_to_arma_to_np(CYTHON return __pyx_r; } -/* "l0learn/testing_utils.pyx":34 +/* "l0learn/testing_utils.pyx":38 * * * cdef np.ndarray[np.double_t, ndim=2] c_dmat_np_to_arma_to_np(np.ndarray[np.double_t, ndim=2] x): # <<<<<<<<<<<<<< @@ -2157,11 +2157,11 @@ static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_dmat_np_to_arma_to_np(P __pyx_pybuffernd_x.rcbuffer = &__pyx_pybuffer_x; { __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_v_x, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 34, __pyx_L1_error) + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_v_x, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 38, __pyx_L1_error) } __pyx_pybuffernd_x.diminfo[0].strides = __pyx_pybuffernd_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x.diminfo[0].shape = __pyx_pybuffernd_x.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_x.diminfo[1].strides = __pyx_pybuffernd_x.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_x.diminfo[1].shape = __pyx_pybuffernd_x.rcbuffer->pybuffer.shape[1]; - /* "l0learn/testing_utils.pyx":35 + /* "l0learn/testing_utils.pyx":39 * * cdef np.ndarray[np.double_t, ndim=2] c_dmat_np_to_arma_to_np(np.ndarray[np.double_t, ndim=2] x): * cdef dmat arma_x = numpy_to_dmat_d(x) # <<<<<<<<<<<<<< @@ -2170,27 +2170,27 @@ static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_dmat_np_to_arma_to_np(P */ __pyx_v_arma_x = __pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_x)); - /* "l0learn/testing_utils.pyx":37 + /* "l0learn/testing_utils.pyx":41 * cdef dmat arma_x = numpy_to_dmat_d(x) * * cdef np.ndarray[np.double_t, ndim=2] np_x = dmat_to_numpy(arma_x, None) # <<<<<<<<<<<<<< * * return np_x */ - __pyx_t_1 = ((PyObject *)__pyx_f_7l0learn_6cyarma_dmat_to_numpy(__pyx_v_arma_x, ((PyArrayObject *)Py_None))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 37, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_7l0learn_6cyarma_dmat_to_numpy(__pyx_v_arma_x, ((PyArrayObject *)Py_None))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 41, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_np_x.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_1), &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) { __pyx_v_np_x = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_np_x.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 37, __pyx_L1_error) + __PYX_ERR(0, 41, __pyx_L1_error) } else {__pyx_pybuffernd_np_x.diminfo[0].strides = __pyx_pybuffernd_np_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_np_x.diminfo[0].shape = __pyx_pybuffernd_np_x.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_np_x.diminfo[1].strides = __pyx_pybuffernd_np_x.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_np_x.diminfo[1].shape = __pyx_pybuffernd_np_x.rcbuffer->pybuffer.shape[1]; } } __pyx_v_np_x = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/testing_utils.pyx":39 + /* "l0learn/testing_utils.pyx":43 * cdef np.ndarray[np.double_t, ndim=2] np_x = dmat_to_numpy(arma_x, None) * * return np_x # <<<<<<<<<<<<<< @@ -2202,7 +2202,7 @@ static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_dmat_np_to_arma_to_np(P __pyx_r = ((PyArrayObject *)__pyx_v_np_x); goto __pyx_L0; - /* "l0learn/testing_utils.pyx":34 + /* "l0learn/testing_utils.pyx":38 * * * cdef np.ndarray[np.double_t, ndim=2] c_dmat_np_to_arma_to_np(np.ndarray[np.double_t, ndim=2] x): # <<<<<<<<<<<<<< @@ -2233,7 +2233,7 @@ static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_dmat_np_to_arma_to_np(P return __pyx_r; } -/* "l0learn/testing_utils.pyx":42 +/* "l0learn/testing_utils.pyx":46 * * * def uvec_np_to_arma_to_np(x): # <<<<<<<<<<<<<< @@ -2276,15 +2276,15 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_6uvec_np_to_arma_to_np(CYTHON __pyx_pybuffernd_x_pass.data = NULL; __pyx_pybuffernd_x_pass.rcbuffer = &__pyx_pybuffer_x_pass; - /* "l0learn/testing_utils.pyx":44 + /* "l0learn/testing_utils.pyx":48 * def uvec_np_to_arma_to_np(x): * cdef np.ndarray[np.uint64_t, ndim=1] x_pass * x_pass = c_uvec_np_to_arma_to_np(x) # <<<<<<<<<<<<<< * * return x_pass */ - if (!(likely(((__pyx_v_x) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_x, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 44, __pyx_L1_error) - __pyx_t_1 = ((PyObject *)__pyx_f_7l0learn_13testing_utils_c_uvec_np_to_arma_to_np(((PyArrayObject *)__pyx_v_x))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 44, __pyx_L1_error) + if (!(likely(((__pyx_v_x) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_x, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 48, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_7l0learn_13testing_utils_c_uvec_np_to_arma_to_np(((PyArrayObject *)__pyx_v_x))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 48, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; @@ -2301,12 +2301,12 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_6uvec_np_to_arma_to_np(CYTHON __pyx_t_3 = __pyx_t_4 = __pyx_t_5 = 0; } __pyx_pybuffernd_x_pass.diminfo[0].strides = __pyx_pybuffernd_x_pass.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x_pass.diminfo[0].shape = __pyx_pybuffernd_x_pass.rcbuffer->pybuffer.shape[0]; - if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 44, __pyx_L1_error) + if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 48, __pyx_L1_error) } __pyx_v_x_pass = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/testing_utils.pyx":46 + /* "l0learn/testing_utils.pyx":50 * x_pass = c_uvec_np_to_arma_to_np(x) * * return x_pass # <<<<<<<<<<<<<< @@ -2318,7 +2318,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_6uvec_np_to_arma_to_np(CYTHON __pyx_r = ((PyObject *)__pyx_v_x_pass); goto __pyx_L0; - /* "l0learn/testing_utils.pyx":42 + /* "l0learn/testing_utils.pyx":46 * * * def uvec_np_to_arma_to_np(x): # <<<<<<<<<<<<<< @@ -2347,7 +2347,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_6uvec_np_to_arma_to_np(CYTHON return __pyx_r; } -/* "l0learn/testing_utils.pyx":49 +/* "l0learn/testing_utils.pyx":53 * * * cdef np.ndarray[np.uint64_t, ndim=1] c_uvec_np_to_arma_to_np(np.ndarray[np.uint64_t, ndim=1] x): # <<<<<<<<<<<<<< @@ -2379,11 +2379,11 @@ static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_uvec_np_to_arma_to_np(P __pyx_pybuffernd_x.rcbuffer = &__pyx_pybuffer_x; { __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_v_x, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 49, __pyx_L1_error) + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_v_x, &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 53, __pyx_L1_error) } __pyx_pybuffernd_x.diminfo[0].strides = __pyx_pybuffernd_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x.diminfo[0].shape = __pyx_pybuffernd_x.rcbuffer->pybuffer.shape[0]; - /* "l0learn/testing_utils.pyx":50 + /* "l0learn/testing_utils.pyx":54 * * cdef np.ndarray[np.uint64_t, ndim=1] c_uvec_np_to_arma_to_np(np.ndarray[np.uint64_t, ndim=1] x): * cdef uvec arma_x = numpy_to_uvec_d(x) # <<<<<<<<<<<<<< @@ -2392,27 +2392,27 @@ static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_uvec_np_to_arma_to_np(P */ __pyx_v_arma_x = __pyx_f_7l0learn_6cyarma_numpy_to_uvec_d(((PyArrayObject *)__pyx_v_x)); - /* "l0learn/testing_utils.pyx":52 + /* "l0learn/testing_utils.pyx":56 * cdef uvec arma_x = numpy_to_uvec_d(x) * * cdef np.ndarray[np.uint64_t, ndim=1] np_x = uvec_to_numpy(arma_x, None) # <<<<<<<<<<<<<< * * return np_x */ - __pyx_t_1 = ((PyObject *)__pyx_f_7l0learn_6cyarma_uvec_to_numpy(__pyx_v_arma_x, ((PyArrayObject *)Py_None))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 52, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_7l0learn_6cyarma_uvec_to_numpy(__pyx_v_arma_x, ((PyArrayObject *)Py_None))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_np_x.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_1), &__Pyx_TypeInfo_nn___pyx_t_5numpy_uint64_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { __pyx_v_np_x = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_np_x.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 52, __pyx_L1_error) + __PYX_ERR(0, 56, __pyx_L1_error) } else {__pyx_pybuffernd_np_x.diminfo[0].strides = __pyx_pybuffernd_np_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_np_x.diminfo[0].shape = __pyx_pybuffernd_np_x.rcbuffer->pybuffer.shape[0]; } } __pyx_v_np_x = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/testing_utils.pyx":54 + /* "l0learn/testing_utils.pyx":58 * cdef np.ndarray[np.uint64_t, ndim=1] np_x = uvec_to_numpy(arma_x, None) * * return np_x # <<<<<<<<<<<<<< @@ -2424,7 +2424,7 @@ static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_uvec_np_to_arma_to_np(P __pyx_r = ((PyArrayObject *)__pyx_v_np_x); goto __pyx_L0; - /* "l0learn/testing_utils.pyx":49 + /* "l0learn/testing_utils.pyx":53 * * * cdef np.ndarray[np.uint64_t, ndim=1] c_uvec_np_to_arma_to_np(np.ndarray[np.uint64_t, ndim=1] x): # <<<<<<<<<<<<<< @@ -2455,7 +2455,7 @@ static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_uvec_np_to_arma_to_np(P return __pyx_r; } -/* "l0learn/testing_utils.pyx":57 +/* "l0learn/testing_utils.pyx":61 * * * def dvec_np_to_arma_to_np(x): # <<<<<<<<<<<<<< @@ -2498,15 +2498,15 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_8dvec_np_to_arma_to_np(CYTHON __pyx_pybuffernd_x_pass.data = NULL; __pyx_pybuffernd_x_pass.rcbuffer = &__pyx_pybuffer_x_pass; - /* "l0learn/testing_utils.pyx":59 + /* "l0learn/testing_utils.pyx":63 * def dvec_np_to_arma_to_np(x): * cdef np.ndarray[np.double_t, ndim=1] x_pass * x_pass = c_dvec_np_to_arma_to_np(x) # <<<<<<<<<<<<<< * * return x_pass */ - if (!(likely(((__pyx_v_x) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_x, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 59, __pyx_L1_error) - __pyx_t_1 = ((PyObject *)__pyx_f_7l0learn_13testing_utils_c_dvec_np_to_arma_to_np(((PyArrayObject *)__pyx_v_x))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 59, __pyx_L1_error) + if (!(likely(((__pyx_v_x) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_x, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 63, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_7l0learn_13testing_utils_c_dvec_np_to_arma_to_np(((PyArrayObject *)__pyx_v_x))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 63, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; @@ -2523,12 +2523,12 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_8dvec_np_to_arma_to_np(CYTHON __pyx_t_3 = __pyx_t_4 = __pyx_t_5 = 0; } __pyx_pybuffernd_x_pass.diminfo[0].strides = __pyx_pybuffernd_x_pass.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x_pass.diminfo[0].shape = __pyx_pybuffernd_x_pass.rcbuffer->pybuffer.shape[0]; - if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 59, __pyx_L1_error) + if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 63, __pyx_L1_error) } __pyx_v_x_pass = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/testing_utils.pyx":61 + /* "l0learn/testing_utils.pyx":65 * x_pass = c_dvec_np_to_arma_to_np(x) * * return x_pass # <<<<<<<<<<<<<< @@ -2540,7 +2540,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_8dvec_np_to_arma_to_np(CYTHON __pyx_r = ((PyObject *)__pyx_v_x_pass); goto __pyx_L0; - /* "l0learn/testing_utils.pyx":57 + /* "l0learn/testing_utils.pyx":61 * * * def dvec_np_to_arma_to_np(x): # <<<<<<<<<<<<<< @@ -2569,7 +2569,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_8dvec_np_to_arma_to_np(CYTHON return __pyx_r; } -/* "l0learn/testing_utils.pyx":64 +/* "l0learn/testing_utils.pyx":68 * * * cdef np.ndarray[np.uint64_t, ndim=1] c_dvec_np_to_arma_to_np(np.ndarray[np.double_t, ndim=1] x): # <<<<<<<<<<<<<< @@ -2601,11 +2601,11 @@ static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_dvec_np_to_arma_to_np(P __pyx_pybuffernd_x.rcbuffer = &__pyx_pybuffer_x; { __Pyx_BufFmt_StackElem __pyx_stack[1]; - if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_v_x, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 64, __pyx_L1_error) + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x.rcbuffer->pybuffer, (PyObject*)__pyx_v_x, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 68, __pyx_L1_error) } __pyx_pybuffernd_x.diminfo[0].strides = __pyx_pybuffernd_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x.diminfo[0].shape = __pyx_pybuffernd_x.rcbuffer->pybuffer.shape[0]; - /* "l0learn/testing_utils.pyx":65 + /* "l0learn/testing_utils.pyx":69 * * cdef np.ndarray[np.uint64_t, ndim=1] c_dvec_np_to_arma_to_np(np.ndarray[np.double_t, ndim=1] x): * cdef dvec arma_x = numpy_to_dvec_d(x) # <<<<<<<<<<<<<< @@ -2614,27 +2614,27 @@ static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_dvec_np_to_arma_to_np(P */ __pyx_v_arma_x = __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_x)); - /* "l0learn/testing_utils.pyx":67 + /* "l0learn/testing_utils.pyx":71 * cdef dvec arma_x = numpy_to_dvec_d(x) * * cdef np.ndarray[np.double_t, ndim=1] np_x = dvec_to_numpy(arma_x, None) # <<<<<<<<<<<<<< * * return np_x */ - __pyx_t_1 = ((PyObject *)__pyx_f_7l0learn_6cyarma_dvec_to_numpy(__pyx_v_arma_x, ((PyArrayObject *)Py_None))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 67, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_7l0learn_6cyarma_dvec_to_numpy(__pyx_v_arma_x, ((PyArrayObject *)Py_None))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 71, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_np_x.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_1), &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { __pyx_v_np_x = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_np_x.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 67, __pyx_L1_error) + __PYX_ERR(0, 71, __pyx_L1_error) } else {__pyx_pybuffernd_np_x.diminfo[0].strides = __pyx_pybuffernd_np_x.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_np_x.diminfo[0].shape = __pyx_pybuffernd_np_x.rcbuffer->pybuffer.shape[0]; } } __pyx_v_np_x = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/testing_utils.pyx":69 + /* "l0learn/testing_utils.pyx":73 * cdef np.ndarray[np.double_t, ndim=1] np_x = dvec_to_numpy(arma_x, None) * * return np_x # <<<<<<<<<<<<<< @@ -2646,7 +2646,7 @@ static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_dvec_np_to_arma_to_np(P __pyx_r = ((PyArrayObject *)__pyx_v_np_x); goto __pyx_L0; - /* "l0learn/testing_utils.pyx":64 + /* "l0learn/testing_utils.pyx":68 * * * cdef np.ndarray[np.uint64_t, ndim=1] c_dvec_np_to_arma_to_np(np.ndarray[np.double_t, ndim=1] x): # <<<<<<<<<<<<<< @@ -2677,7 +2677,7 @@ static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_dvec_np_to_arma_to_np(P return __pyx_r; } -/* "l0learn/testing_utils.pyx":72 +/* "l0learn/testing_utils.pyx":76 * * * def sp_dmat_np_to_arma_to_np(x): # <<<<<<<<<<<<<< @@ -2709,7 +2709,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_10sp_dmat_np_to_arma_to_np(CY int __pyx_clineno = 0; __Pyx_RefNannySetupContext("sp_dmat_np_to_arma_to_np", 0); - /* "l0learn/testing_utils.pyx":73 + /* "l0learn/testing_utils.pyx":77 * * def sp_dmat_np_to_arma_to_np(x): * return c_sp_dmat_np_to_arma_to_np(x) # <<<<<<<<<<<<<< @@ -2717,13 +2717,13 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_10sp_dmat_np_to_arma_to_np(CY * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_f_7l0learn_13testing_utils_c_sp_dmat_np_to_arma_to_np(__pyx_v_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 73, __pyx_L1_error) + __pyx_t_1 = __pyx_f_7l0learn_13testing_utils_c_sp_dmat_np_to_arma_to_np(__pyx_v_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "l0learn/testing_utils.pyx":72 + /* "l0learn/testing_utils.pyx":76 * * * def sp_dmat_np_to_arma_to_np(x): # <<<<<<<<<<<<<< @@ -2742,7 +2742,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_10sp_dmat_np_to_arma_to_np(CY return __pyx_r; } -/* "l0learn/testing_utils.pyx":76 +/* "l0learn/testing_utils.pyx":80 * * * cdef c_sp_dmat_np_to_arma_to_np(x): # <<<<<<<<<<<<<< @@ -2761,7 +2761,7 @@ static PyObject *__pyx_f_7l0learn_13testing_utils_c_sp_dmat_np_to_arma_to_np(PyO int __pyx_clineno = 0; __Pyx_RefNannySetupContext("c_sp_dmat_np_to_arma_to_np", 0); - /* "l0learn/testing_utils.pyx":77 + /* "l0learn/testing_utils.pyx":81 * * cdef c_sp_dmat_np_to_arma_to_np(x): * cdef sp_dmat arma_x = numpy_to_sp_dmat_d(x) # <<<<<<<<<<<<<< @@ -2770,31 +2770,31 @@ static PyObject *__pyx_f_7l0learn_13testing_utils_c_sp_dmat_np_to_arma_to_np(PyO */ __pyx_v_arma_x = __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(__pyx_v_x); - /* "l0learn/testing_utils.pyx":79 + /* "l0learn/testing_utils.pyx":83 * cdef sp_dmat arma_x = numpy_to_sp_dmat_d(x) * * np_x = sp_dmat_to_numpy(arma_x, None, None, None) # <<<<<<<<<<<<<< * return np_x * */ - __pyx_t_1 = __pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(__pyx_v_arma_x, ((PyArrayObject *)Py_None), ((PyArrayObject *)Py_None), ((PyArrayObject *)Py_None)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 79, __pyx_L1_error) + __pyx_t_1 = __pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(__pyx_v_arma_x, ((PyArrayObject *)Py_None), ((PyArrayObject *)Py_None), ((PyArrayObject *)Py_None)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 83, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_np_x = __pyx_t_1; __pyx_t_1 = 0; - /* "l0learn/testing_utils.pyx":80 + /* "l0learn/testing_utils.pyx":84 * * np_x = sp_dmat_to_numpy(arma_x, None, None, None) * return np_x # <<<<<<<<<<<<<< * - * def dmat_dot_dmat(x, y): + * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_np_x); __pyx_r = __pyx_v_np_x; goto __pyx_L0; - /* "l0learn/testing_utils.pyx":76 + /* "l0learn/testing_utils.pyx":80 * * * cdef c_sp_dmat_np_to_arma_to_np(x): # <<<<<<<<<<<<<< @@ -2814,8 +2814,8 @@ static PyObject *__pyx_f_7l0learn_13testing_utils_c_sp_dmat_np_to_arma_to_np(PyO return __pyx_r; } -/* "l0learn/testing_utils.pyx":82 - * return np_x +/* "l0learn/testing_utils.pyx":87 + * * * def dmat_dot_dmat(x, y): # <<<<<<<<<<<<<< * cdef dmat arma_x = numpy_to_dmat_d(x) @@ -2858,11 +2858,11 @@ static PyObject *__pyx_pw_7l0learn_13testing_utils_13dmat_dot_dmat(PyObject *__p case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("dmat_dot_dmat", 1, 2, 2, 1); __PYX_ERR(0, 82, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("dmat_dot_dmat", 1, 2, 2, 1); __PYX_ERR(0, 87, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "dmat_dot_dmat") < 0)) __PYX_ERR(0, 82, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "dmat_dot_dmat") < 0)) __PYX_ERR(0, 87, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -2875,7 +2875,7 @@ static PyObject *__pyx_pw_7l0learn_13testing_utils_13dmat_dot_dmat(PyObject *__p } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("dmat_dot_dmat", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 82, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("dmat_dot_dmat", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 87, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("l0learn.testing_utils.dmat_dot_dmat", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -2907,27 +2907,27 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_12dmat_dot_dmat(CYTHON_UNUSED __pyx_pybuffernd_np_xy.data = NULL; __pyx_pybuffernd_np_xy.rcbuffer = &__pyx_pybuffer_np_xy; - /* "l0learn/testing_utils.pyx":83 + /* "l0learn/testing_utils.pyx":88 * * def dmat_dot_dmat(x, y): * cdef dmat arma_x = numpy_to_dmat_d(x) # <<<<<<<<<<<<<< * cdef dmat arma_y = numpy_to_dmat_d(y) * */ - if (!(likely(((__pyx_v_x) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_x, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 83, __pyx_L1_error) + if (!(likely(((__pyx_v_x) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_x, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 88, __pyx_L1_error) __pyx_v_arma_x = __pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_x)); - /* "l0learn/testing_utils.pyx":84 + /* "l0learn/testing_utils.pyx":89 * def dmat_dot_dmat(x, y): * cdef dmat arma_x = numpy_to_dmat_d(x) * cdef dmat arma_y = numpy_to_dmat_d(y) # <<<<<<<<<<<<<< * * cdef dmat arma_xy = c_dmat_dot_dmat(arma_x, arma_y) */ - if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 84, __pyx_L1_error) + if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 89, __pyx_L1_error) __pyx_v_arma_y = __pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_y)); - /* "l0learn/testing_utils.pyx":86 + /* "l0learn/testing_utils.pyx":91 * cdef dmat arma_y = numpy_to_dmat_d(y) * * cdef dmat arma_xy = c_dmat_dot_dmat(arma_x, arma_y) # <<<<<<<<<<<<<< @@ -2936,40 +2936,40 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_12dmat_dot_dmat(CYTHON_UNUSED */ __pyx_v_arma_xy = __pyx_f_7l0learn_13testing_utils_c_dmat_dot_dmat(__pyx_v_arma_x, __pyx_v_arma_y); - /* "l0learn/testing_utils.pyx":88 + /* "l0learn/testing_utils.pyx":93 * cdef dmat arma_xy = c_dmat_dot_dmat(arma_x, arma_y) * * cdef np.ndarray[np.double_t, ndim=2] np_xy = dmat_to_numpy(arma_xy, None) # <<<<<<<<<<<<<< * * return np_xy */ - __pyx_t_1 = ((PyObject *)__pyx_f_7l0learn_6cyarma_dmat_to_numpy(__pyx_v_arma_xy, ((PyArrayObject *)Py_None))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 88, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)__pyx_f_7l0learn_6cyarma_dmat_to_numpy(__pyx_v_arma_xy, ((PyArrayObject *)Py_None))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 93, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); { __Pyx_BufFmt_StackElem __pyx_stack[1]; if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_np_xy.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_1), &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) { __pyx_v_np_xy = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_np_xy.rcbuffer->pybuffer.buf = NULL; - __PYX_ERR(0, 88, __pyx_L1_error) + __PYX_ERR(0, 93, __pyx_L1_error) } else {__pyx_pybuffernd_np_xy.diminfo[0].strides = __pyx_pybuffernd_np_xy.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_np_xy.diminfo[0].shape = __pyx_pybuffernd_np_xy.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_np_xy.diminfo[1].strides = __pyx_pybuffernd_np_xy.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_np_xy.diminfo[1].shape = __pyx_pybuffernd_np_xy.rcbuffer->pybuffer.shape[1]; } } __pyx_v_np_xy = ((PyArrayObject *)__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/testing_utils.pyx":90 + /* "l0learn/testing_utils.pyx":95 * cdef np.ndarray[np.double_t, ndim=2] np_xy = dmat_to_numpy(arma_xy, None) * * return np_xy # <<<<<<<<<<<<<< * - * cdef dmat c_dmat_dot_dmat(dmat arma_x, dmat arma_y): + * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_np_xy)); __pyx_r = ((PyObject *)__pyx_v_np_xy); goto __pyx_L0; - /* "l0learn/testing_utils.pyx":82 - * return np_x + /* "l0learn/testing_utils.pyx":87 + * * * def dmat_dot_dmat(x, y): # <<<<<<<<<<<<<< * cdef dmat arma_x = numpy_to_dmat_d(x) @@ -2997,8 +2997,8 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_12dmat_dot_dmat(CYTHON_UNUSED return __pyx_r; } -/* "l0learn/testing_utils.pyx":92 - * return np_xy +/* "l0learn/testing_utils.pyx":98 + * * * cdef dmat c_dmat_dot_dmat(dmat arma_x, dmat arma_y): # <<<<<<<<<<<<<< * cdef dmat arma_xy = arma_x*arma_y @@ -3011,7 +3011,7 @@ static arma::dmat __pyx_f_7l0learn_13testing_utils_c_dmat_dot_dmat(arma::dmat __ __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("c_dmat_dot_dmat", 0); - /* "l0learn/testing_utils.pyx":93 + /* "l0learn/testing_utils.pyx":99 * * cdef dmat c_dmat_dot_dmat(dmat arma_x, dmat arma_y): * cdef dmat arma_xy = arma_x*arma_y # <<<<<<<<<<<<<< @@ -3020,7 +3020,7 @@ static arma::dmat __pyx_f_7l0learn_13testing_utils_c_dmat_dot_dmat(arma::dmat __ */ __pyx_v_arma_xy = (__pyx_v_arma_x * __pyx_v_arma_y); - /* "l0learn/testing_utils.pyx":95 + /* "l0learn/testing_utils.pyx":101 * cdef dmat arma_xy = arma_x*arma_y * * return arma_xy # <<<<<<<<<<<<<< @@ -3028,8 +3028,8 @@ static arma::dmat __pyx_f_7l0learn_13testing_utils_c_dmat_dot_dmat(arma::dmat __ __pyx_r = __pyx_v_arma_xy; goto __pyx_L0; - /* "l0learn/testing_utils.pyx":92 - * return np_xy + /* "l0learn/testing_utils.pyx":98 + * * * cdef dmat c_dmat_dot_dmat(dmat arma_x, dmat arma_y): # <<<<<<<<<<<<<< * cdef dmat arma_xy = arma_x*arma_y @@ -3992,89 +3992,89 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_GOTREF(__pyx_tuple__2); __Pyx_GIVEREF(__pyx_tuple__2); - /* "l0learn/testing_utils.pyx":10 - * sp_dmat_to_numpy) + /* "l0learn/testing_utils.pyx":11 + * * * def list_csc_to_arma_csc_to_list(x): # <<<<<<<<<<<<<< * return c_list_csc_to_arma_csc_to_list(x) * */ - __pyx_tuple__3 = PyTuple_Pack(1, __pyx_n_s_x); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 10, __pyx_L1_error) + __pyx_tuple__3 = PyTuple_Pack(1, __pyx_n_s_x); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 11, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__3); __Pyx_GIVEREF(__pyx_tuple__3); - __pyx_codeobj__4 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_list_csc_to_arma_csc_to_list, 10, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__4)) __PYX_ERR(0, 10, __pyx_L1_error) + __pyx_codeobj__4 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_list_csc_to_arma_csc_to_list, 11, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__4)) __PYX_ERR(0, 11, __pyx_L1_error) - /* "l0learn/testing_utils.pyx":18 - * return lst + /* "l0learn/testing_utils.pyx":21 + * * * def list_dvec_to_arma_dvec_to_list(x): # <<<<<<<<<<<<<< * return c_list_dvec_to_arma_dvec_to_list(x) * */ - __pyx_tuple__5 = PyTuple_Pack(1, __pyx_n_s_x); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 18, __pyx_L1_error) + __pyx_tuple__5 = PyTuple_Pack(1, __pyx_n_s_x); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 21, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__5); __Pyx_GIVEREF(__pyx_tuple__5); - __pyx_codeobj__6 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__5, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_list_dvec_to_arma_dvec_to_list, 18, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__6)) __PYX_ERR(0, 18, __pyx_L1_error) + __pyx_codeobj__6 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__5, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_list_dvec_to_arma_dvec_to_list, 21, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__6)) __PYX_ERR(0, 21, __pyx_L1_error) - /* "l0learn/testing_utils.pyx":27 + /* "l0learn/testing_utils.pyx":31 * * * def dmat_np_to_arma_to_np(x): # <<<<<<<<<<<<<< * cdef np.ndarray[np.double_t, ndim=2] x_pass * x_pass = c_dmat_np_to_arma_to_np(x) */ - __pyx_tuple__7 = PyTuple_Pack(2, __pyx_n_s_x, __pyx_n_s_x_pass); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 27, __pyx_L1_error) + __pyx_tuple__7 = PyTuple_Pack(2, __pyx_n_s_x, __pyx_n_s_x_pass); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 31, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__7); __Pyx_GIVEREF(__pyx_tuple__7); - __pyx_codeobj__8 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__7, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_dmat_np_to_arma_to_np, 27, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__8)) __PYX_ERR(0, 27, __pyx_L1_error) + __pyx_codeobj__8 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__7, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_dmat_np_to_arma_to_np, 31, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__8)) __PYX_ERR(0, 31, __pyx_L1_error) - /* "l0learn/testing_utils.pyx":42 + /* "l0learn/testing_utils.pyx":46 * * * def uvec_np_to_arma_to_np(x): # <<<<<<<<<<<<<< * cdef np.ndarray[np.uint64_t, ndim=1] x_pass * x_pass = c_uvec_np_to_arma_to_np(x) */ - __pyx_tuple__9 = PyTuple_Pack(2, __pyx_n_s_x, __pyx_n_s_x_pass); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 42, __pyx_L1_error) + __pyx_tuple__9 = PyTuple_Pack(2, __pyx_n_s_x, __pyx_n_s_x_pass); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 46, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__9); __Pyx_GIVEREF(__pyx_tuple__9); - __pyx_codeobj__10 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__9, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_uvec_np_to_arma_to_np, 42, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__10)) __PYX_ERR(0, 42, __pyx_L1_error) + __pyx_codeobj__10 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__9, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_uvec_np_to_arma_to_np, 46, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__10)) __PYX_ERR(0, 46, __pyx_L1_error) - /* "l0learn/testing_utils.pyx":57 + /* "l0learn/testing_utils.pyx":61 * * * def dvec_np_to_arma_to_np(x): # <<<<<<<<<<<<<< * cdef np.ndarray[np.double_t, ndim=1] x_pass * x_pass = c_dvec_np_to_arma_to_np(x) */ - __pyx_tuple__11 = PyTuple_Pack(2, __pyx_n_s_x, __pyx_n_s_x_pass); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 57, __pyx_L1_error) + __pyx_tuple__11 = PyTuple_Pack(2, __pyx_n_s_x, __pyx_n_s_x_pass); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 61, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__11); __Pyx_GIVEREF(__pyx_tuple__11); - __pyx_codeobj__12 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__11, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_dvec_np_to_arma_to_np, 57, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__12)) __PYX_ERR(0, 57, __pyx_L1_error) + __pyx_codeobj__12 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__11, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_dvec_np_to_arma_to_np, 61, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__12)) __PYX_ERR(0, 61, __pyx_L1_error) - /* "l0learn/testing_utils.pyx":72 + /* "l0learn/testing_utils.pyx":76 * * * def sp_dmat_np_to_arma_to_np(x): # <<<<<<<<<<<<<< * return c_sp_dmat_np_to_arma_to_np(x) * */ - __pyx_tuple__13 = PyTuple_Pack(1, __pyx_n_s_x); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 72, __pyx_L1_error) + __pyx_tuple__13 = PyTuple_Pack(1, __pyx_n_s_x); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 76, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__13); __Pyx_GIVEREF(__pyx_tuple__13); - __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_sp_dmat_np_to_arma_to_np, 72, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(0, 72, __pyx_L1_error) + __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_sp_dmat_np_to_arma_to_np, 76, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(0, 76, __pyx_L1_error) - /* "l0learn/testing_utils.pyx":82 - * return np_x + /* "l0learn/testing_utils.pyx":87 + * * * def dmat_dot_dmat(x, y): # <<<<<<<<<<<<<< * cdef dmat arma_x = numpy_to_dmat_d(x) * cdef dmat arma_y = numpy_to_dmat_d(y) */ - __pyx_tuple__15 = PyTuple_Pack(6, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_arma_x, __pyx_n_s_arma_y, __pyx_n_s_arma_xy, __pyx_n_s_np_xy); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 82, __pyx_L1_error) + __pyx_tuple__15 = PyTuple_Pack(6, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_arma_x, __pyx_n_s_arma_y, __pyx_n_s_arma_xy, __pyx_n_s_np_xy); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 87, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__15); __Pyx_GIVEREF(__pyx_tuple__15); - __pyx_codeobj__16 = (PyObject*)__Pyx_PyCode_New(2, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__15, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_dmat_dot_dmat, 82, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__16)) __PYX_ERR(0, 82, __pyx_L1_error) + __pyx_codeobj__16 = (PyObject*)__Pyx_PyCode_New(2, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__15, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_dmat_dot_dmat, 87, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__16)) __PYX_ERR(0, 87, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; @@ -4433,88 +4433,88 @@ if (!__Pyx_RefNanny) { if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 2, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/testing_utils.pyx":10 - * sp_dmat_to_numpy) + /* "l0learn/testing_utils.pyx":11 + * * * def list_csc_to_arma_csc_to_list(x): # <<<<<<<<<<<<<< * return c_list_csc_to_arma_csc_to_list(x) * */ - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_13testing_utils_1list_csc_to_arma_csc_to_list, NULL, __pyx_n_s_l0learn_testing_utils); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 10, __pyx_L1_error) + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_13testing_utils_1list_csc_to_arma_csc_to_list, NULL, __pyx_n_s_l0learn_testing_utils); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 11, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_list_csc_to_arma_csc_to_list, __pyx_t_1) < 0) __PYX_ERR(0, 10, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_list_csc_to_arma_csc_to_list, __pyx_t_1) < 0) __PYX_ERR(0, 11, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/testing_utils.pyx":18 - * return lst + /* "l0learn/testing_utils.pyx":21 + * * * def list_dvec_to_arma_dvec_to_list(x): # <<<<<<<<<<<<<< * return c_list_dvec_to_arma_dvec_to_list(x) * */ - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_13testing_utils_3list_dvec_to_arma_dvec_to_list, NULL, __pyx_n_s_l0learn_testing_utils); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 18, __pyx_L1_error) + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_13testing_utils_3list_dvec_to_arma_dvec_to_list, NULL, __pyx_n_s_l0learn_testing_utils); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_list_dvec_to_arma_dvec_to_list, __pyx_t_1) < 0) __PYX_ERR(0, 18, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_list_dvec_to_arma_dvec_to_list, __pyx_t_1) < 0) __PYX_ERR(0, 21, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/testing_utils.pyx":27 + /* "l0learn/testing_utils.pyx":31 * * * def dmat_np_to_arma_to_np(x): # <<<<<<<<<<<<<< * cdef np.ndarray[np.double_t, ndim=2] x_pass * x_pass = c_dmat_np_to_arma_to_np(x) */ - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_13testing_utils_5dmat_np_to_arma_to_np, NULL, __pyx_n_s_l0learn_testing_utils); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 27, __pyx_L1_error) + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_13testing_utils_5dmat_np_to_arma_to_np, NULL, __pyx_n_s_l0learn_testing_utils); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 31, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_dmat_np_to_arma_to_np, __pyx_t_1) < 0) __PYX_ERR(0, 27, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_dmat_np_to_arma_to_np, __pyx_t_1) < 0) __PYX_ERR(0, 31, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/testing_utils.pyx":42 + /* "l0learn/testing_utils.pyx":46 * * * def uvec_np_to_arma_to_np(x): # <<<<<<<<<<<<<< * cdef np.ndarray[np.uint64_t, ndim=1] x_pass * x_pass = c_uvec_np_to_arma_to_np(x) */ - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_13testing_utils_7uvec_np_to_arma_to_np, NULL, __pyx_n_s_l0learn_testing_utils); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 42, __pyx_L1_error) + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_13testing_utils_7uvec_np_to_arma_to_np, NULL, __pyx_n_s_l0learn_testing_utils); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 46, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_uvec_np_to_arma_to_np, __pyx_t_1) < 0) __PYX_ERR(0, 42, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_uvec_np_to_arma_to_np, __pyx_t_1) < 0) __PYX_ERR(0, 46, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/testing_utils.pyx":57 + /* "l0learn/testing_utils.pyx":61 * * * def dvec_np_to_arma_to_np(x): # <<<<<<<<<<<<<< * cdef np.ndarray[np.double_t, ndim=1] x_pass * x_pass = c_dvec_np_to_arma_to_np(x) */ - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_13testing_utils_9dvec_np_to_arma_to_np, NULL, __pyx_n_s_l0learn_testing_utils); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 57, __pyx_L1_error) + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_13testing_utils_9dvec_np_to_arma_to_np, NULL, __pyx_n_s_l0learn_testing_utils); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 61, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_dvec_np_to_arma_to_np, __pyx_t_1) < 0) __PYX_ERR(0, 57, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_dvec_np_to_arma_to_np, __pyx_t_1) < 0) __PYX_ERR(0, 61, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/testing_utils.pyx":72 + /* "l0learn/testing_utils.pyx":76 * * * def sp_dmat_np_to_arma_to_np(x): # <<<<<<<<<<<<<< * return c_sp_dmat_np_to_arma_to_np(x) * */ - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_13testing_utils_11sp_dmat_np_to_arma_to_np, NULL, __pyx_n_s_l0learn_testing_utils); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 72, __pyx_L1_error) + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_13testing_utils_11sp_dmat_np_to_arma_to_np, NULL, __pyx_n_s_l0learn_testing_utils); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 76, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_sp_dmat_np_to_arma_to_np, __pyx_t_1) < 0) __PYX_ERR(0, 72, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_sp_dmat_np_to_arma_to_np, __pyx_t_1) < 0) __PYX_ERR(0, 76, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/testing_utils.pyx":82 - * return np_x + /* "l0learn/testing_utils.pyx":87 + * * * def dmat_dot_dmat(x, y): # <<<<<<<<<<<<<< * cdef dmat arma_x = numpy_to_dmat_d(x) * cdef dmat arma_y = numpy_to_dmat_d(y) */ - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_13testing_utils_13dmat_dot_dmat, NULL, __pyx_n_s_l0learn_testing_utils); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 82, __pyx_L1_error) + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_13testing_utils_13dmat_dot_dmat, NULL, __pyx_n_s_l0learn_testing_utils); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 87, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_dmat_dot_dmat, __pyx_t_1) < 0) __PYX_ERR(0, 82, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_dmat_dot_dmat, __pyx_t_1) < 0) __PYX_ERR(0, 87, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "l0learn/testing_utils.pyx":1 diff --git a/python/l0learn/testing_utils.pyx b/python/l0learn/testing_utils.pyx index 090653a..34308db 100644 --- a/python/l0learn/testing_utils.pyx +++ b/python/l0learn/testing_utils.pyx @@ -7,17 +7,21 @@ field, dmat, dvec, sp_dmat, uvec,numpy_to_dmat_d, dmat_to_numpy, numpy_to_uvec_d uvec_to_numpy, numpy_to_dvec_d, dvec_to_numpy, numpy_to_sp_dmat_d, sp_dmat_to_numpy) + def list_csc_to_arma_csc_to_list(x): return c_list_csc_to_arma_csc_to_list(x) + cdef list c_list_csc_to_arma_csc_to_list(list x): cdef field[sp_dmat] f = list_to_sp_dmat_field(x) cdef lst = sp_dmat_field_to_list(f) return lst + def list_dvec_to_arma_dvec_to_list(x): return c_list_dvec_to_arma_dvec_to_list(x) + cdef list c_list_dvec_to_arma_dvec_to_list(list x): cdef field[dvec] f = list_to_dvec_field(x) cdef lst = dvec_field_to_list(f) @@ -79,6 +83,7 @@ cdef c_sp_dmat_np_to_arma_to_np(x): np_x = sp_dmat_to_numpy(arma_x, None, None, None) return np_x + def dmat_dot_dmat(x, y): cdef dmat arma_x = numpy_to_dmat_d(x) cdef dmat arma_y = numpy_to_dmat_d(y) @@ -89,7 +94,8 @@ def dmat_dot_dmat(x, y): return np_xy + cdef dmat c_dmat_dot_dmat(dmat arma_x, dmat arma_y): cdef dmat arma_xy = arma_x*arma_y - return arma_xy \ No newline at end of file + return arma_xy diff --git a/python/pyproject.toml b/python/pyproject.toml new file mode 100644 index 0000000..062da13 --- /dev/null +++ b/python/pyproject.toml @@ -0,0 +1,9 @@ +[build-system] +requires = [ + "setuptools>=42", + "wheel", + "Cython", + "numpy", + "h5py", +] +build-backend = "setuptools.build_meta" \ No newline at end of file diff --git a/python/setup.py b/python/setup.py index a146083..0d24015 100644 --- a/python/setup.py +++ b/python/setup.py @@ -1,59 +1,7 @@ #!/usr/bin/python3 -# from distutils.core import setup -# from distutils.extension import Extension -# from Cython.Distutils import build_ext -# from Cython.Build import cythonize -# -# import numpy as np -# -# cyarma_extension = Extension( -# name='l0learn.l0learn.cyarma', -# sources=["l0learn/l0learn/cyarma.pyx"], -# include_dirs=['.', np.get_include()], -# language="c++", -# extra_compile_args=["-std=c++11"], -# extra_link_args=["-std=c++11"], -# ) -# -# utils_cyarma_extension = Extension( -# name='l0learn.tests.utils_cyarma', -# sources=["l0learn/tests/testing_utils.pyx"], -# include_dirs=['.', np.get_include()], -# language="c++", -# extra_compile_args=["-std=c++11"], -# extra_link_args=["-std=c++11"], -# ) -# -# bindings_extension = Extension( -# name="l0learn.l0learn.interface", -# sources=["l0learn/l0learn/interface.pyx"], -# include_dirs=['.', np.get_include()], -# language="c++", -# extra_compile_args=["-std=c++11"], -# extra_link_args=["-std=c++11"], -# ) -# -# ext_modules = [cyarma_extension, utils_cyarma_extension, bindings_extension] -# -# # setup( -# # name='py_bindings', -# # ext_modules=cythonize(ext_modules) -# # ) -# -# setup( -# name='l0learn', -# packages=['l0learn'], -# description='Python Wrapper for l0learn', -# maintainer='Tim Nonet', -# package_data={'l0learn': ['l0learn/l0learn/*.pyx', 'l0learn/l0learn/*.pxd']}, -# cmdclass={'build_ext': build_ext}, -# language_level=3, -# ext_modules=cythonize(ext_modules), -# ) - import os -from setuptools import setup, find_packages, Extension +from setuptools import setup, Extension, find_packages import numpy as np try: @@ -94,12 +42,11 @@ def no_cythonize(extensions, **_ignore): extensions = [ Extension(name='l0learn.cyarma', sources=["l0learn/cyarma.pyx"], - include_dirs=['.', np.get_include()], # "usr/local/Cellar/armadillo/10.1.1/include" + include_dirs=['.', np.get_include()], language="c++", libraries=["armadillo", "lapack", "blas"], extra_compile_args=["-std=c++11"], extra_link_args=["-std=c++11"], - # define_macros=[("NPY_NO_DEPRECATED_API", "NPY_1_7_API_VERSION")], ), Extension(name='l0learn.testing_utils', sources=["l0learn/testing_utils.pyx"], @@ -108,7 +55,6 @@ def no_cythonize(extensions, **_ignore): libraries=["armadillo", "lapack", "blas"], extra_compile_args=["-std=c++11"], extra_link_args=["-std=c++11"], - # define_macros=[("NPY_NO_DEPRECATED_API", "NPY_1_7_API_VERSION")], ), Extension(name="l0learn.interface", sources=["l0learn/interface.pyx", @@ -125,20 +71,6 @@ def no_cythonize(extensions, **_ignore): libraries=["armadillo", "lapack", "blas"], extra_compile_args=["-std=c++11"], extra_link_args=["-std=c++11"]), - # Extension("l0learn_src", - # sources=[ - # "l0learn/src/CDL012LogisticSwaps.cpp", - # "l0learn/src/Grid2D.cpp", - # "l0learn/src/CDL012SquaredHingeSwaps.cpp", - # "l0learn/src/Normalize.cpp", - # "l0learn/src/CDL012Swaps.cpp", - # "l0learn/src/Grid.cpp", - # "l0learn/src/Grid1D.cpp" - # ], - # include_dirs=["l0learn/src/include"], - # extra_compile_args=["-std=c++11"], - # extra_link_args=["-std=c++11"], - # ) ] CYTHONIZE = bool(int(os.getenv("CYTHONIZE", 0))) and cythonize is not None @@ -148,34 +80,34 @@ def no_cythonize(extensions, **_ignore): else: extensions = no_cythonize(extensions) -# with open("requirements.txt") as fp: -# install_requires = fp.read().strip().split("\n") -# -# with open("requirements-dev.txt") as fp: -# dev_requires = fp.read().strip().split("\n") - """ Installation Notes; How to ensure proper underlying armadillo is installed? MacOsX: brew install armadillo --with-hdf5 """ -install_requires = ['numpy', 'h5py'] +with open("README.md", "r", encoding="utf-8") as fh: + long_description = fh.read() setup( - ext_modules=extensions, name='l0learn', - description='Python Wrapper for L0Learn', maintainer='Tim Nonet', - install_requires=['cython'], - cmdclass={'build_ext': build_ext} + author_email="tim.nonet@gmail.com", + description="L0Learn is a highly efficient framework for solving L0-regularized learning problems.", + long_description=long_description, + long_description_content_type="text/markdown", + url="https://github.com/hazimehh/L0Learn", + project_urls={ + "Bug Tracker": "https://github.com/hazimehh/L0Learn/issues", + }, + classifiers=[ + "Programming Language :: Python :: 3", + "Operating System :: OS Independent", + ], + cmdclass={'build_ext': build_ext}, + ext_modules=extensions, + # package_dir={"": "l0learn"}, + # packages=find_packages(where="l0learn"), + python_requires=">=3.6", ) -# setup( -# ext_modules=extensions, -# install_requires=install_requires, -# extras_require={ -# "dev": dev_requires, -# "docs": ["sphinx", "sphinx-rtd-theme"] -# }, -# ) diff --git a/python/sparse.ipynb b/python/sparse.ipynb new file mode 100644 index 0000000..e502f46 --- /dev/null +++ b/python/sparse.ipynb @@ -0,0 +1,254 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "pycharm": { + "is_executing": false + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "from scipy.sparse import csc_matrix\n", + "from l0learn.models import FitModel" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "is_executing": false, + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "def sample_FitModel(loss: str = 'SquaredError', intercept: bool = True, penalty: str = 'L0L1'):\n", + " i = intercept\n", + " beta1 = csc_matrix([[0, 0],\n", + " [1, 2]])\n", + " beta2 = csc_matrix([[0],\n", + " [3]])\n", + " beta3 = csc_matrix([[0, 0, 0],\n", + " [4, 5, 6]])\n", + "\n", + " return FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty},\n", + " lambda_0=[[10, 5], [10], [10, 5, 0]],\n", + " gamma=[2, 1, 0],\n", + " support_size=[[0, 1], [3], [4, 5, 6]],\n", + " coeffs=[beta1, beta2, beta3],\n", + " intercepts=[[-1*i, -2*i], [-3*i], [-4*i, -5*i, -6*i]],\n", + " converged=[[True, True], [False], [True, False, True]])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "f = sample_FitModel()" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1, 2, 3, 4, 5, 6],\n", + " [1, 2, 3, 4, 5, 6]])" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.tile(np.arange(1, 7), (2, 1))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-1, -2, -3, -4, -5, -6],\n", + " [ 0, 0, 0, 0, 0, 0],\n", + " [ 1, 2, 3, 4, 5, 6]])" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f.coeff().toarray()" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1., 2., 3., 4., 5., 6.]])" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f.predict(np.array([[1, 2]]))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0., 0., 0., 0., 0., 0.],\n", + " [0., 0., 0., 0., 0., 0.]])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f.predict(np.ones([2,2]))" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.isrealobj(values[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "for i, value in enumerate(values):\n", + " if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isrealobj(value):\n", + " print(value)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "is_executing": false, + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "# csc_arr = csc_matrix((data, indices, indptr), shape=(5, 5)).toarray()\n", + "csc_arr = csc_matrix(arr)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "is_executing": false, + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.76355643, 0.99015561, 0.96518113, 0.9159315 , 0.76160812])" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "csc_arr.data" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.7" + }, + "pycharm": { + "stem_cell": { + "cell_type": "raw", + "metadata": { + "collapsed": false + }, + "source": [] + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/python/tests/test_cyarma.py b/python/tests/test_cyarma.py index 4889338..94f9bd7 100644 --- a/python/tests/test_cyarma.py +++ b/python/tests/test_cyarma.py @@ -1,6 +1,6 @@ import numpy as np from scipy.sparse import csc_matrix -from hypothesis import given, assume +from hypothesis import given, assume, settings, HealthCheck from hypothesis.extra import numpy as npst from hypothesis.strategies import floats, integers, lists @@ -52,10 +52,11 @@ def test_sp_dmat_np_to_arma_to_np(arr, thr): shape=npst.array_shapes(min_dims=2, max_dims=2, min_side=1, max_side=100), elements=floats()), min_size=1), - floats(0, 1)) + floats(0, 1),) +@settings(suppress_health_check=(HealthCheck(3),), deadline=None) def test_sp_dmat_field_np_to_arma_to_np(lst, thr): for i, arr in enumerate(lst): - arr[abs(arr) >= thr] = 0.0 + arr[abs(arr) <= thr] = 0.0 assume(np.sum(arr != 0) > 1) lst[i] = csc_matrix(arr) @@ -63,6 +64,7 @@ def test_sp_dmat_field_np_to_arma_to_np(lst, thr): for arr, arr2 in zip(lst, lst2): np.testing.assert_array_equal(arr.toarray(), arr2.toarray()) + @given(lists(elements=npst.arrays(np.float64, shape=npst.array_shapes(min_dims=1, max_dims=1, min_side=1, max_side=100), elements=floats()), diff --git a/python/tests/test_models.py b/python/tests/test_models.py new file mode 100644 index 0000000..c4faec5 --- /dev/null +++ b/python/tests/test_models.py @@ -0,0 +1,160 @@ +import numpy as np +import pandas as pd +from hypothesis.strategies import floats +from scipy.sparse import csc_matrix + +from l0learn.models import FitModel, regularization_loss + +from pytest import fixture +from hypothesis import given +from hypothesis.extra import numpy as npst + + +@fixture +def sample_FitModel(loss: str = 'SquaredError', intercept: bool = True, penalty: str = 'L0L1'): + i = intercept + beta1 = csc_matrix([[0, 0], + [1, 2]]) + beta2 = csc_matrix([[0], + [3]]) + beta3 = csc_matrix([[0, 0, 0], + [4, 5, 6]]) + + return FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, + lambda_0=[[10, 5], [10], [10, 5, 0]], + gamma=[2, 1, 0], + support_size=[[0, 1], [3], [4, 5, 6]], + coeffs=[beta1, beta2, beta3], + intercepts=[[-1*i, -2*i], [-3*i], [-4*i, -5*i, -6*i]], + converged=[[True, True], [False], [True, False, True]]) + + +def test_FitModel_coeff(sample_FitModel): + np.testing.assert_array_equal(sample_FitModel.coeff().toarray(), + np.array([[-1, -2, -3, -4, -5, -6], + [0, 0, 0, 0, 0, 0], + [1, 2, 3, 4, 5, 6]])) + np.testing.assert_array_equal(sample_FitModel.coeff(include_intercept=False).toarray(), + np.array([[0, 0, 0, 0, 0, 0], + [1, 2, 3, 4, 5, 6]])) + + np.testing.assert_array_equal(sample_FitModel.coeff(gamma=1).toarray(), np.array([[-3, ], + [0, ], + [3, ]])) + np.testing.assert_array_equal(sample_FitModel.coeff(gamma=1, include_intercept=False).toarray(), + np.array([[0, ], + [3, ]])) + + np.testing.assert_array_equal(sample_FitModel.coeff(lambda_0=6).toarray(), np.array([[-2, ], + [0, ], + [2, ]])) + + np.testing.assert_array_equal(sample_FitModel.coeff(lambda_0=6, include_intercept=False).toarray(), + np.array([[0, ], + [2, ]])) + + np.testing.assert_array_equal(sample_FitModel.coeff(gamma=0, lambda_0=6).toarray(), np.array([[-5, ], + [0, ], + [5, ]])) + + np.testing.assert_array_equal(sample_FitModel.coeff(gamma=0, lambda_0=6, include_intercept=False).toarray(), + np.array([[0, ], + [5, ]])) + + +def test_characteristics(sample_FitModel): + pd.testing.assert_frame_equal(sample_FitModel.characteristics(), + pd.DataFrame({'l0': [10, 5, 10, 10, 5, 0], + 'support_size': [0, 1, 3, 4, 5, 6], + 'intercept': [-1, -2, -3, -4, -5, -6], + 'converged': [True, True, False, True, False, True], + 'l1': [2, 2, 1, 0, 0, 0]})) + + pd.testing.assert_frame_equal(sample_FitModel.characteristics(gamma=1), + pd.DataFrame({'l0': [10], + 'support_size': [3], + 'intercept': [-3], + 'converged': [False], + 'l1': [1]})) + + pd.testing.assert_frame_equal(sample_FitModel.characteristics(lambda_0=6), + pd.DataFrame({'l0': [5], + 'support_size': [1], + 'intercept': [-2], + 'converged': [True], + 'l1': [2]})) + + pd.testing.assert_frame_equal(sample_FitModel.characteristics(gamma=0, lambda_0=5), + pd.DataFrame({'l0': [5], + 'support_size': [5], + 'intercept': [-5], + 'converged': [False], + 'l1': [0]})) + + +@given(coeffs=npst.arrays(dtype=np.float, + elements=floats(allow_nan=False, allow_infinity=False, max_value=1e100, min_value=-1e100), + shape=npst.array_shapes(min_dims=2, max_dims=2))) +def test_regularization_loss(coeffs): + coeffs_csc = csc_matrix(coeffs) + if coeffs.shape[1] == 1: + np.testing.assert_equal((coeffs != 0).sum(), regularization_loss(coeffs_csc, l0=1)) + np.testing.assert_equal((coeffs != 0).sum() + sum(abs(coeffs)) + sum(coeffs**2), + regularization_loss(coeffs_csc, l0=1, l1=1, l2=1)) + else: + num_solutions = coeffs.shape[1] + np.testing.assert_equal((coeffs != 0).sum(axis=0), regularization_loss(coeffs_csc, l0=[1]*num_solutions)) + np.testing.assert_equal((coeffs != 0).sum(axis=0) + abs(coeffs).sum(axis=0) + (coeffs ** 2).sum(axis=0), + regularization_loss(coeffs_csc, l0=[1]*num_solutions, l1=1, l2=1)) + np.testing.assert_equal(np.arange(num_solutions)*((coeffs != 0).sum(axis=0)) + + abs(coeffs).sum(axis=0) + + (coeffs ** 2).sum(axis=0), + regularization_loss(coeffs_csc, l0=range(num_solutions), l1=1, l2=1)) + + +def test_squared_error(): + pass + + +def test_logistic_loss(): + pass + + +def test_squared_hinge_loss(): + pass + + +def test_score(): + pass + + +def test_predict(sample_FitModel): + ones_1D = np.ones([1, 2]) + ones_2D = np.ones([2, 2]) + + np.testing.assert_array_equal(sample_FitModel.predict(ones_1D), np.zeros([1, 6])) + np.testing.assert_array_equal(sample_FitModel.predict(ones_2D), np.zeros([2, 6])) + + np.testing.assert_array_equal(sample_FitModel.predict(ones_1D, gamma=1), np.zeros([1, 1])) + np.testing.assert_array_equal(sample_FitModel.predict(ones_2D, gamma=1), np.zeros([2, 1])) + + np.testing.assert_array_equal(sample_FitModel.predict(ones_1D, lambda_0=1), np.zeros([1, 1])) + np.testing.assert_array_equal(sample_FitModel.predict(ones_2D, lambda_0=1), np.zeros([2, 1])) + + np.testing.assert_array_equal(sample_FitModel.predict(ones_1D, lambda_0=1, gamma=1), np.zeros([1, 1])) + np.testing.assert_array_equal(sample_FitModel.predict(ones_2D, lambda_0=1, gamma=1), np.zeros([2, 1])) + + x_1D = np.array([[1, 2]]) + x_2D = np.array([[1, 2], [1, 2]]) + + np.testing.assert_array_equal(sample_FitModel.predict(x_1D), np.arange(1, 7)[np.newaxis, :]) + np.testing.assert_array_equal(sample_FitModel.predict(x_2D), np.tile(np.arange(1, 7), (2, 1))) + + np.testing.assert_array_equal(sample_FitModel.predict(x_1D, gamma=1), np.array([[3]])) + np.testing.assert_array_equal(sample_FitModel.predict(x_2D, gamma=1), np.array([[3], [3]])) + + np.testing.assert_array_equal(sample_FitModel.predict(x_1D, lambda_0=1), np.array([[2]])) + np.testing.assert_array_equal(sample_FitModel.predict(x_2D, lambda_0=1), np.array([[2], [2]])) + + np.testing.assert_array_equal(sample_FitModel.predict(x_1D, lambda_0=1, gamma=1), np.array([[3]])) + np.testing.assert_array_equal(sample_FitModel.predict(x_2D, lambda_0=1, gamma=1), np.array([[3], [3]])) diff --git a/python/tests/test_utils.py b/python/tests/test_utils.py deleted file mode 100644 index 27f9acd..0000000 --- a/python/tests/test_utils.py +++ /dev/null @@ -1,58 +0,0 @@ -import numpy as np -from scipy.sparse import csc_matrix - -from l0learn.utils import FitModel - -from pytest import fixture - - -@fixture -def sample_FitModel(): - gamma = [2, 1, 0] - lambda_0 = [[10, 5], [10], [10, 5, 0]] - intercepts = [[-1, -2], [-3], [-4, -5, -6]] - beta1 = csc_matrix([[0, 0], - [1, 2]]) - beta2 = csc_matrix([[0], - [3]]) - beta3 = csc_matrix([[0, 0, 0], - [4, 5, 6]]) - - return FitModel(lambda_0=lambda_0, - gamma=gamma, - support_size=[[0]], - coeffs=[beta1, beta2, beta3], - intercepts=intercepts, - converged=[[True]]) - - -def test_FitModel_coeff(sample_FitModel): - np.testing.assert_array_equal(sample_FitModel.coeff().toarray(), np.array([[-1, -2, -3, -4, -5, -6], - [0, 0, 0, 0, 0, 0], - [1, 2, 3, 4, 5, 6]])) - np.testing.assert_array_equal(sample_FitModel.coeff(include_intercept=False).toarray(), - np.array([[0, 0, 0, 0, 0, 0], - [1, 2, 3, 4, 5, 6]])) - - np.testing.assert_array_equal(sample_FitModel.coeff(gamma=1).toarray(), np.array([[-3, ], - [0, ], - [3, ]])) - np.testing.assert_array_equal(sample_FitModel.coeff(gamma=1, include_intercept=False).toarray(), - np.array([[0, ], - [3, ]])) - - np.testing.assert_array_equal(sample_FitModel.coeff(lambda_0=6).toarray(), np.array([[-2, ], - [0, ], - [2, ]])) - - np.testing.assert_array_equal(sample_FitModel.coeff(lambda_0=6, include_intercept=False).toarray(), - np.array([[0, ], - [2, ]])) - - np.testing.assert_array_equal(sample_FitModel.coeff(gamma=0, lambda_0=6).toarray(), np.array([[-5, ], - [0, ], - [5, ]])) - - np.testing.assert_array_equal(sample_FitModel.coeff(gamma=0, lambda_0=6, include_intercept=False).toarray(), - np.array([[0, ], - [5, ]])) From c7b918b37e47a74abb50d92d0ff71f3aaa6687c8 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Sun, 26 Sep 2021 08:15:22 -0500 Subject: [PATCH 008/125] Update .travis.yml --- .travis.yml | 26 +++++++++++++++----------- 1 file changed, 15 insertions(+), 11 deletions(-) diff --git a/.travis.yml b/.travis.yml index 51d3869..cd4449b 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,11 +1,15 @@ -language: R -r: - - release -sudo: false -cache: packages -warnings_are_errors: false -after_failure: - - cat /home/travis/build/hazimehh/L0Learn/L0Learn.Rcheck/00check.log -after_success: - - cat /home/travis/build/hazimehh/L0Learn/L0Learn.Rcheck/00check.log - - travis_wait 300 Rscript -e "covr::codecov(quiet = FALSE, token='6f2e6703-ee4f-4479-b079-1d5d219786f4')" +jobs: + include: + language: R + r: + - release + before_script: + - cd R + sudo: false + cache: packages + warnings_are_errors: false + after_failure: + - cat /home/travis/build/hazimehh/L0Learn/L0Learn.Rcheck/00check.log + after_success: + - cat /home/travis/build/hazimehh/L0Learn/L0Learn.Rcheck/00check.log + - travis_wait 300 Rscript -e "covr::codecov(quiet = FALSE, token='6f2e6703-ee4f-4479-b079-1d5d219786f4')" From d7bd6c88e56394cc0fef617cffa1a250d617f9ed Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 12 Nov 2021 08:08:15 -0600 Subject: [PATCH 009/125] Update travis CI/CD to run for python and R [1/?] --- .travis.yml | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/.travis.yml b/.travis.yml index cd4449b..565ca3e 100644 --- a/.travis.yml +++ b/.travis.yml @@ -13,3 +13,27 @@ jobs: after_success: - cat /home/travis/build/hazimehh/L0Learn/L0Learn.Rcheck/00check.log - travis_wait 300 Rscript -e "covr::codecov(quiet = FALSE, token='6f2e6703-ee4f-4479-b079-1d5d219786f4')" + include: + language: python + before_script: + - cd python + os: + - linux + - osx + python: + - "3.6" + - "3.7" + - "3.8" + - "3.9" + - "3.9-dev" + - "nightly" + install: + - pip install . + - pip install pytest-cov + - pip install coveralls + script: + - pytest --cov=happenings + after_success: + - coveralls + + From b178fc2742b5ed7f07f85b9b1b09eb7090ac5a2b Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 12 Nov 2021 08:41:50 -0600 Subject: [PATCH 010/125] Remove os options for Travis CI/CD on python build --- .travis.yml | 3 --- 1 file changed, 3 deletions(-) diff --git a/.travis.yml b/.travis.yml index 565ca3e..4a3d750 100644 --- a/.travis.yml +++ b/.travis.yml @@ -17,9 +17,6 @@ jobs: language: python before_script: - cd python - os: - - linux - - osx python: - "3.6" - "3.7" From 3573d21f9ed2ba0a393efb038c2959f9cf32e565 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 12 Nov 2021 09:48:23 -0600 Subject: [PATCH 011/125] Create python_CI.yml --- .github/workflows/python_CI.yml | 42 +++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) create mode 100644 .github/workflows/python_CI.yml diff --git a/.github/workflows/python_CI.yml b/.github/workflows/python_CI.yml new file mode 100644 index 0000000..362736f --- /dev/null +++ b/.github/workflows/python_CI.yml @@ -0,0 +1,42 @@ +name: Python CI + +# Controls when the workflow will run +on: + # Triggers the workflow on push or pull request events but only for the master branch + push: + branches: [ master ] + pull_request: + branches: [ master ] + + # Allows you to run this workflow manually from the Actions tab + workflow_dispatch: + +# A workflow run is made up of one or more jobs that can run sequentially or in parallel +jobs: + # This workflow contains a single job called "build" + build: + # The type of runner that the job will run on + runs-on: [ubuntu-latest, windows-latest, macos-latest] + strategy: + matrix: + python-version: [3.6, 3.7, 3.8, 3.9] + defaults: + run: + working-directory: ./python + + steps: + - uses: actions/checkout@v2 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v2 + with: + python-version: ${{ matrix.python-version }} + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install pytest-cov + pip install coveralls + pip install . + - name: Run Tests and Coverage + run: pytest --cov=happenings + - name: Report coverage + run: coveralls From 17dbe4d166bbf7cca58c0f7d023de41535191a40 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 12 Nov 2021 09:52:17 -0600 Subject: [PATCH 012/125] Update python_CI.yml --- .github/workflows/python_CI.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/python_CI.yml b/.github/workflows/python_CI.yml index 362736f..69c8c6e 100644 --- a/.github/workflows/python_CI.yml +++ b/.github/workflows/python_CI.yml @@ -16,10 +16,11 @@ jobs: # This workflow contains a single job called "build" build: # The type of runner that the job will run on - runs-on: [ubuntu-latest, windows-latest, macos-latest] + runs-on: ${{ matrix.os }} strategy: matrix: python-version: [3.6, 3.7, 3.8, 3.9] + os: [macos-latest, ubuntu-latest, ubuntu-latest] defaults: run: working-directory: ./python From 5380a8687b860b1cc62257c8ac63a7cba8933d2a Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 12 Nov 2021 09:58:57 -0600 Subject: [PATCH 013/125] Update python_CI.yml --- .github/workflows/python_CI.yml | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/.github/workflows/python_CI.yml b/.github/workflows/python_CI.yml index 69c8c6e..80b6197 100644 --- a/.github/workflows/python_CI.yml +++ b/.github/workflows/python_CI.yml @@ -20,7 +20,10 @@ jobs: strategy: matrix: python-version: [3.6, 3.7, 3.8, 3.9] - os: [macos-latest, ubuntu-latest, ubuntu-latest] + os: [macos-latest] # , ubuntu-latest, ubuntu-latest] + include: + - os: macos-latest + INSTALL_DEPS: brew install armadillo defaults: run: working-directory: ./python From b244accdca64b5ffcdbabcaef0ae9d3c95d78d0e Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 12 Nov 2021 10:01:58 -0600 Subject: [PATCH 014/125] Update python_CI.yml --- .github/workflows/python_CI.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.github/workflows/python_CI.yml b/.github/workflows/python_CI.yml index 80b6197..ac4f227 100644 --- a/.github/workflows/python_CI.yml +++ b/.github/workflows/python_CI.yml @@ -30,6 +30,8 @@ jobs: steps: - uses: actions/checkout@v2 + - name: install-dependencies + run: ${{ matrix.INSTALL_DEPS }} - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v2 with: From b992da3fbfc5712a857f5d5cab207a527b305822 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 12 Nov 2021 10:08:55 -0600 Subject: [PATCH 015/125] Update python_CI.yml --- .github/workflows/python_CI.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/python_CI.yml b/.github/workflows/python_CI.yml index ac4f227..63ba16e 100644 --- a/.github/workflows/python_CI.yml +++ b/.github/workflows/python_CI.yml @@ -39,10 +39,11 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip + pip install wheel pip install pytest-cov pip install coveralls pip install . - name: Run Tests and Coverage - run: pytest --cov=happenings + run: pytest --cov=l0learn - name: Report coverage run: coveralls From e82dc5cbdefaa4547a7428062398fa7f17f1b3bf Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 12 Nov 2021 10:22:51 -0600 Subject: [PATCH 016/125] Update setup.py --- python/setup.py | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) diff --git a/python/setup.py b/python/setup.py index 0d24015..1d02680 100644 --- a/python/setup.py +++ b/python/setup.py @@ -106,8 +106,19 @@ def no_cythonize(extensions, **_ignore): ], cmdclass={'build_ext': build_ext}, ext_modules=extensions, - # package_dir={"": "l0learn"}, - # packages=find_packages(where="l0learn"), - python_requires=">=3.6", + install_requires=[ + "numpy>=1.19.0", + "scipy>=1.1.0", + ], + extras_require={"test": [ + "attrs>=19.2.0", # Usually installed by hypothesis, but current issue + # #https://github.com/HypothesisWorks/hypothesis/issues/2113 + "hypothesis", + "pytest", + ]} +# package_dir={"": "l0learn"}, +# packages=find_packages(where="l0learn"), +python_requires=">=3.6", ) + From a3af357f629ebdf37fe73649014ee1f74f45d1c9 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 12 Nov 2021 10:23:02 -0600 Subject: [PATCH 017/125] Update python_CI.yml --- .github/workflows/python_CI.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/python_CI.yml b/.github/workflows/python_CI.yml index 63ba16e..d65ee89 100644 --- a/.github/workflows/python_CI.yml +++ b/.github/workflows/python_CI.yml @@ -23,7 +23,7 @@ jobs: os: [macos-latest] # , ubuntu-latest, ubuntu-latest] include: - os: macos-latest - INSTALL_DEPS: brew install armadillo + INSTALL_DEPS: brew install armadillo --with-hdf5 defaults: run: working-directory: ./python @@ -42,7 +42,7 @@ jobs: pip install wheel pip install pytest-cov pip install coveralls - pip install . + pip install -e ".[test]" - name: Run Tests and Coverage run: pytest --cov=l0learn - name: Report coverage From 11ff6872d35e11223e36c6f5926091044cfe1863 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 12 Nov 2021 10:26:11 -0600 Subject: [PATCH 018/125] Update python_CI.yml --- .github/workflows/python_CI.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/python_CI.yml b/.github/workflows/python_CI.yml index d65ee89..1993db5 100644 --- a/.github/workflows/python_CI.yml +++ b/.github/workflows/python_CI.yml @@ -23,7 +23,7 @@ jobs: os: [macos-latest] # , ubuntu-latest, ubuntu-latest] include: - os: macos-latest - INSTALL_DEPS: brew install armadillo --with-hdf5 + INSTALL_DEPS: brew install armadillo defaults: run: working-directory: ./python From 40c6f7732fe8b39d77246db67c84ec780865dfa0 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 12 Nov 2021 10:30:39 -0600 Subject: [PATCH 019/125] Update setup.py --- python/setup.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/python/setup.py b/python/setup.py index 1d02680..fce94da 100644 --- a/python/setup.py +++ b/python/setup.py @@ -115,10 +115,8 @@ def no_cythonize(extensions, **_ignore): # #https://github.com/HypothesisWorks/hypothesis/issues/2113 "hypothesis", "pytest", - ]} -# package_dir={"": "l0learn"}, -# packages=find_packages(where="l0learn"), -python_requires=">=3.6", + ]}, + python_requires=">=3.6", ) From 65cb6dd4ac1d0b0bbd802166df65fd1e5fbc4abb Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 12 Nov 2021 10:37:00 -0600 Subject: [PATCH 020/125] Update setup.py --- python/setup.py | 1 + 1 file changed, 1 insertion(+) diff --git a/python/setup.py b/python/setup.py index fce94da..90bf744 100644 --- a/python/setup.py +++ b/python/setup.py @@ -109,6 +109,7 @@ def no_cythonize(extensions, **_ignore): install_requires=[ "numpy>=1.19.0", "scipy>=1.1.0", + "pandas>=1.0.0" ], extras_require={"test": [ "attrs>=19.2.0", # Usually installed by hypothesis, but current issue From 46af360796eaf2361eefc10b90534688ce5e1344 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 12 Nov 2021 10:42:46 -0600 Subject: [PATCH 021/125] Update setup.py --- python/setup.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/python/setup.py b/python/setup.py index 90bf744..1ba074b 100644 --- a/python/setup.py +++ b/python/setup.py @@ -109,7 +109,8 @@ def no_cythonize(extensions, **_ignore): install_requires=[ "numpy>=1.19.0", "scipy>=1.1.0", - "pandas>=1.0.0" + "pandas>=1.0.0", + "matplotlib>=3.0.0" ], extras_require={"test": [ "attrs>=19.2.0", # Usually installed by hypothesis, but current issue From 49eef5ba5a5ec9899e2b088a7e12e1cb9bb320e3 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 12 Nov 2021 10:49:49 -0600 Subject: [PATCH 022/125] Update setup.py --- python/setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/setup.py b/python/setup.py index 1ba074b..d83b3f0 100644 --- a/python/setup.py +++ b/python/setup.py @@ -118,7 +118,7 @@ def no_cythonize(extensions, **_ignore): "hypothesis", "pytest", ]}, - python_requires=">=3.6", + python_requires=">=3.7", ) From 645a9a9b9d55af2412a467204fb64795380ec375 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 12 Nov 2021 10:49:56 -0600 Subject: [PATCH 023/125] Update python_CI.yml --- .github/workflows/python_CI.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/python_CI.yml b/.github/workflows/python_CI.yml index 1993db5..546f20a 100644 --- a/.github/workflows/python_CI.yml +++ b/.github/workflows/python_CI.yml @@ -19,7 +19,7 @@ jobs: runs-on: ${{ matrix.os }} strategy: matrix: - python-version: [3.6, 3.7, 3.8, 3.9] + python-version: [3.7, 3.8, 3.9] os: [macos-latest] # , ubuntu-latest, ubuntu-latest] include: - os: macos-latest From 8c8765e815dea85e3aed3e042e74e465a8f2a26a Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 12 Nov 2021 11:00:50 -0600 Subject: [PATCH 024/125] Update python_CI.yml --- .github/workflows/python_CI.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.github/workflows/python_CI.yml b/.github/workflows/python_CI.yml index 546f20a..e19041e 100644 --- a/.github/workflows/python_CI.yml +++ b/.github/workflows/python_CI.yml @@ -17,6 +17,8 @@ jobs: build: # The type of runner that the job will run on runs-on: ${{ matrix.os }} + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} strategy: matrix: python-version: [3.7, 3.8, 3.9] From f91e1df522f10dd718df640cbeb04b37b2867f62 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 12 Nov 2021 11:09:30 -0600 Subject: [PATCH 025/125] Update python_CI.yml --- .github/workflows/python_CI.yml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/.github/workflows/python_CI.yml b/.github/workflows/python_CI.yml index e19041e..a1b23fe 100644 --- a/.github/workflows/python_CI.yml +++ b/.github/workflows/python_CI.yml @@ -17,8 +17,6 @@ jobs: build: # The type of runner that the job will run on runs-on: ${{ matrix.os }} - env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} strategy: matrix: python-version: [3.7, 3.8, 3.9] @@ -47,5 +45,7 @@ jobs: pip install -e ".[test]" - name: Run Tests and Coverage run: pytest --cov=l0learn - - name: Report coverage - run: coveralls + - name: Coveralls + uses: coverallsapp/github-action@master + with: + github-token: ${{ secrets.GITHUB_TOKEN }} From 130893e2e3591911e0474a1291b815c0ea9ffae8 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 12 Nov 2021 11:18:58 -0600 Subject: [PATCH 026/125] Update python_CI.yml --- .github/workflows/python_CI.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/python_CI.yml b/.github/workflows/python_CI.yml index a1b23fe..c6b86c4 100644 --- a/.github/workflows/python_CI.yml +++ b/.github/workflows/python_CI.yml @@ -44,8 +44,9 @@ jobs: pip install coveralls pip install -e ".[test]" - name: Run Tests and Coverage - run: pytest --cov=l0learn + run: python -m pytest --cov=l0learn --cov-report xml - name: Coveralls uses: coverallsapp/github-action@master with: github-token: ${{ secrets.GITHUB_TOKEN }} + path-to-lcov: coverage.xml From 325934b8b4e9408a4dfab20286b42934b0ece2d1 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 12 Nov 2021 11:34:25 -0600 Subject: [PATCH 027/125] Update python_CI.yml --- .github/workflows/python_CI.yml | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/.github/workflows/python_CI.yml b/.github/workflows/python_CI.yml index c6b86c4..6270035 100644 --- a/.github/workflows/python_CI.yml +++ b/.github/workflows/python_CI.yml @@ -44,9 +44,8 @@ jobs: pip install coveralls pip install -e ".[test]" - name: Run Tests and Coverage - run: python -m pytest --cov=l0learn --cov-report xml + run: python -m pytest --cov=l0learn - name: Coveralls - uses: coverallsapp/github-action@master - with: - github-token: ${{ secrets.GITHUB_TOKEN }} - path-to-lcov: coverage.xml + run: coveralls --service=github + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} From ed1aa7a74d3f003e57c2f4bdfac0e79ebd020fee Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 12 Nov 2021 14:01:35 -0600 Subject: [PATCH 028/125] Update python_CI.yml --- .github/workflows/python_CI.yml | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/.github/workflows/python_CI.yml b/.github/workflows/python_CI.yml index 6270035..2bb932a 100644 --- a/.github/workflows/python_CI.yml +++ b/.github/workflows/python_CI.yml @@ -20,10 +20,16 @@ jobs: strategy: matrix: python-version: [3.7, 3.8, 3.9] - os: [macos-latest] # , ubuntu-latest, ubuntu-latest] + os: [macos-latest, ubuntu-latest] #, ubuntu-latest] include: - os: macos-latest INSTALL_DEPS: brew install armadillo + - os: ubuntu-latest + INSTALL_DEPS: | + sudo apt-get install liblapack-dev + sudo apt-get install libblas-dev + sudo apt-get install libboost-dev + sudo apt-get install libarmadillo-dev defaults: run: working-directory: ./python From da5a8f470f841f379bb9795e1d382462df867781 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 12 Nov 2021 16:39:06 -0600 Subject: [PATCH 029/125] Delete .Rbuildignore --- .Rbuildignore | 4 ---- 1 file changed, 4 deletions(-) delete mode 100644 .Rbuildignore diff --git a/.Rbuildignore b/.Rbuildignore deleted file mode 100644 index 02bcd26..0000000 --- a/.Rbuildignore +++ /dev/null @@ -1,4 +0,0 @@ -^\.travis\.yml$ -^\.astylerc$ -^.*\.Rproj$ -^\.Rproj\.user$ From e85697b9406745532bf2102055bd9ea87137131c Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 12 Nov 2021 16:40:47 -0600 Subject: [PATCH 030/125] Move .astylerc file to R package --- .astylerc => R/.astylerc | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename .astylerc => R/.astylerc (100%) diff --git a/.astylerc b/R/.astylerc similarity index 100% rename from .astylerc rename to R/.astylerc From a99f1a89a6d5896f92f1fab06c736ec7315655f2 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 12 Nov 2021 16:44:57 -0600 Subject: [PATCH 031/125] Create r.yml --- .github/workflows/r.yml | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 .github/workflows/r.yml diff --git a/.github/workflows/r.yml b/.github/workflows/r.yml new file mode 100644 index 0000000..ab73a8c --- /dev/null +++ b/.github/workflows/r.yml @@ -0,0 +1,33 @@ +name: R + +on: + push: + branches: [ master ] + pull_request: + branches: [ master ] + +jobs: + build: + runs-on: macos-latest + strategy: + matrix: + r-version: ['3.6.3', '4.1.1', 'release'] + + defaults: + run: + working-directory: ./R + + steps: + - uses: actions/checkout@v2 + - name: Set up R ${{ matrix.r-version }} + uses: r-lib/actions/setup-r@f57f1301a053485946083d7a45022b278929a78a + with: + r-version: ${{ matrix.r-version }} + - name: Install dependencies + run: | + install.packages(c("remotes", "rcmdcheck")) + remotes::install_deps(dependencies = TRUE) + shell: Rscript {0} + - name: Check + run: rcmdcheck::rcmdcheck(args = "--no-manual", error_on = "error") + shell: Rscript {0} From 9166bc4263e82ba63e657f34da7ebfb4cddd0590 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 12 Nov 2021 16:45:14 -0600 Subject: [PATCH 032/125] Rename python_CI.yml to python.yml --- .github/workflows/{python_CI.yml => python.yml} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename .github/workflows/{python_CI.yml => python.yml} (100%) diff --git a/.github/workflows/python_CI.yml b/.github/workflows/python.yml similarity index 100% rename from .github/workflows/python_CI.yml rename to .github/workflows/python.yml From 1edf87242a49f128566a9375ab0bce86ce27d72e Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 12 Nov 2021 16:49:42 -0600 Subject: [PATCH 033/125] Update r.yml --- .github/workflows/r.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.github/workflows/r.yml b/.github/workflows/r.yml index ab73a8c..94e8f82 100644 --- a/.github/workflows/r.yml +++ b/.github/workflows/r.yml @@ -1,10 +1,12 @@ -name: R +name: R CI on: push: branches: [ master ] pull_request: branches: [ master ] + + workflow_dispatch: jobs: build: From 9adb5ece1336b1dc30a1a2753b9385986ded9263 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 12 Nov 2021 16:57:00 -0600 Subject: [PATCH 034/125] Update r.yml --- .github/workflows/r.yml | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/.github/workflows/r.yml b/.github/workflows/r.yml index 94e8f82..d65eab3 100644 --- a/.github/workflows/r.yml +++ b/.github/workflows/r.yml @@ -25,11 +25,14 @@ jobs: uses: r-lib/actions/setup-r@f57f1301a053485946083d7a45022b278929a78a with: r-version: ${{ matrix.r-version }} + - uses: r-lib/actions/setup-pandoc@v1 + with: + pandoc-version: '2.7.3' - name: Install dependencies run: | install.packages(c("remotes", "rcmdcheck")) remotes::install_deps(dependencies = TRUE) shell: Rscript {0} - name: Check - run: rcmdcheck::rcmdcheck(args = "--no-manual", error_on = "error") + run: rcmdcheck::rcmdcheck(args = "--no-manual", error_on = "error", check_dir = "check") shell: Rscript {0} From 2fb3ef753f8cbddcddebd4abf77e90ea3df79c1e Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 12 Nov 2021 17:19:57 -0600 Subject: [PATCH 035/125] Update test_L0Learn_intercept.R --- R/tests/testthat/test_L0Learn_intercept.R | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/R/tests/testthat/test_L0Learn_intercept.R b/R/tests/testthat/test_L0Learn_intercept.R index db19d01..13811e0 100644 --- a/R/tests/testthat/test_L0Learn_intercept.R +++ b/R/tests/testthat/test_L0Learn_intercept.R @@ -187,7 +187,7 @@ test_that("Intercepts are learned close to real values", { k = 10 for (a in c("CD", "CDPSI")){ for (b0 in c(-100, -10, -2, 2, 10, 100)){ - tmp <- L0Learn::GenSynthetic(n=500, p=200, k=k, seed=1, rho=1, b0=b0) + tmp <- L0Learn::GenSynthetic(n=5000, p=200, k=k, seed=1, rho=1, b0=b0) X2 <- tmp[[1]] y2 <- tmp[[2]] From ca7f55dc3edf5f5f11d5029029e12c450a3d37bc Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Sun, 14 Nov 2021 11:57:36 -0600 Subject: [PATCH 036/125] Update test_L0Learn_intercept.R --- R/tests/testthat/test_L0Learn_intercept.R | 29 +++++++++++++---------- 1 file changed, 17 insertions(+), 12 deletions(-) diff --git a/R/tests/testthat/test_L0Learn_intercept.R b/R/tests/testthat/test_L0Learn_intercept.R index 13811e0..68766cb 100644 --- a/R/tests/testthat/test_L0Learn_intercept.R +++ b/R/tests/testthat/test_L0Learn_intercept.R @@ -187,7 +187,7 @@ test_that("Intercepts are learned close to real values", { k = 10 for (a in c("CD", "CDPSI")){ for (b0 in c(-100, -10, -2, 2, 10, 100)){ - tmp <- L0Learn::GenSynthetic(n=5000, p=200, k=k, seed=1, rho=1, b0=b0) + tmp <- L0Learn::GenSynthetic(n=5000, p=200, k=k, seed=1, rho=0, b0=b0) X2 <- tmp[[1]] y2 <- tmp[[2]] @@ -197,21 +197,26 @@ test_that("Intercepts are learned close to real values", { } X2_sparse <- as(X2, "dgCMatrix") - x1 <- L0Learn.fit(X2_sparse, y2, penalty="L0", intercept = TRUE, algorithm = a, - autoLambda=FALSE, lambdaGrid=fineuserLambda, maxSuppSize=1000) + x1 <- L0Learn.fit(X2_sparse, y2, penalty="L0", intercept = TRUE, algorithm = a) + #autoLambda=FALSE, lambdaGrid=fineuserLambda, maxSuppSize=1000) - x2 <- L0Learn.fit(X2, y2, penalty="L0", intercept = TRUE, algorithm = a, - autoLambda=FALSE, lambdaGrid=fineuserLambda, maxSuppSize=1000) - - for (i in 1:length(x1$suppSize[[1]])){ - if (x1$suppSize[[1]][i] == k){ - expect_lt(abs(x1$a0[[1]][i] - b0), abs(.01*b0)) + x2 <- L0Learn.fit(X2, y2, penalty="L0", intercept = TRUE, algorithm = a) + #autoLambda=FALSE, lambdaGrid=fineuserLambda, maxSuppSize=1000) + y2_mean = mean(y2) + for (j in 1:length(x1$suppSize)){ + for (i in 1:length(x1$suppSize[[1]])){ + if (x1$suppSize[[j]][i] == k){ + expect_lt(abs(x1$a0[[j]][i] - b0), abs(2*(abs(b0) - abs(y2_mean)))) + print(paste(abs(x1$a0[[j]][i] - b0), abs(2*(abs(b0) - abs(y2_mean))))) + } } } - for (i in 1:length(x2$suppSize[[1]])){ - if (x2$suppSize[[1]][i] == k){ - expect_lt(abs(x2$a0[[1]][i] - b0), abs(.01*b0)) + for (j in 1:length(x1$suppSize)){ + for (i in 1:length(x2$suppSize[[j]])){ + if (x2$suppSize[[j]][i] == k){ + expect_lt(abs(x2$a0[[j]][i] - b0), abs(2*(abs(b0) - abs(y2_mean)))) + } } } } From 0fbdcb173e79d8036abd6c77acb43ecc851372ce Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Tue, 16 Nov 2021 07:57:01 -0600 Subject: [PATCH 037/125] Update README.md --- python/README.md | 95 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 95 insertions(+) diff --git a/python/README.md b/python/README.md index e69de29..4631770 100644 --- a/python/README.md +++ b/python/README.md @@ -0,0 +1,95 @@ +# l0learn: Fast Best Subset Selection + +![example workflow](https://github.com/TNonet/L0Learn/actions/workflows/python.yml/badge.svg) [![Coverage Status](https://coveralls.io/repos/github/TNonet/L0Learn/badge.svg)](https://coveralls.io/github/TNonet/L0Learn) + +### Hussein Hazimeh, Rahul Mazumder, and Tim Nonet +### Massachusetts Institute of Technology + +## Introduction +L0Learn is a highly efficient framework for solving L0-regularized learning problems. It can (approximately) solve the following three problems, where the empirical loss is penalized by combinations of the L0, L1, and L2 norms: + + + +We support both regression (using squared error loss) and classification (using logistic or squared hinge loss). Optimization is done using coordinate descent and local combinatorial search over a grid of regularization parameter(s) values. Several computational tricks and heuristics are used to speed up the algorithms and improve the solution quality. These heuristics include warm starts, active set convergence, correlation screening, greedy cycling order, and efficient methods for updating the residuals through exploiting sparsity and problem dimensions. Moreover, we employed a new computationally efficient method for dynamically selecting the regularization parameter λ in the path. We describe the details of the algorithms in our paper: *Fast Best Subset Selection: Coordinate Descent and Local Combinatorial Optimization Algorithms* ([link](https://pubsonline.informs.org/doi/10.1287/opre.2019.1919)). + +The toolkit is implemented in C++11 and can often run faster than popular sparse learning toolkits (see our experiments in the paper above). We also provide an easy-to-use R interface; see the section below for installation and usage of the R package. + +**NEW: Version 2 (03/2021) adds support for sparse matrices and box constraints on the coefficients.** + +## Package Installation +`l0learn` depends on a system version of Amardillo which can be installed by following in the instructions on [Armadillo's download page](http://arma.sourceforge.net/download.html) + +The latest version (v2.0.3) can be installed from pip as follows: +```bash +pip install l0learn +``` + +conda-forge installation methods will be released soon. + +# Source Code and Installing from Source +Alternatively, `l0learn` can be build from source +```bash +git clone https://github.com/TNonet/L0Learn.git +cd python +``` + +To install, ensure the proper packages are installed from `pyproject.toml` build from source with the following: +```bash +pip install ".[test]" +``` + +To test, run the following command: +```bash +python -m pytest +``` + +# Change Log +L0Learn's changelog can be accessed from [here](https://github.com/hazimehh/L0Learn/blob/master/ChangeLog). + + +## Usage +For a tutorial, please refer to l0learn's Vignette(Link to be added). For a detailed description of the API, check the Documentation(link to be added). + +## FAQ +#### Which penalty to use? +Pure L0 regularization can overfit when the signal strength in the data is relatively low. Adding L2 regularization can alleviate this problem and lead to competitive models (see the experiments in our paper). Thus, in practice, **we strongly recommend using the L0L2 penalty**. Ideally, the parameter gamma (for L2 regularization) should be tuned over a sufficiently large interval, and this can be performed using L0Learn's built-in [cross-validation method](https://cran.r-project.org/web/packages/L0Learn/vignettes/L0Learn-vignette.html#cross-validation). + +#### Which algorithm to use? +By default, L0Learn uses a coordinate descent-based algorithm, which achieves competitive run times compared to popular sparse learning toolkits. This can work well for many applications. We also offer a local search algorithm which is guarantteed to return higher quality solutions, at the expense of an increase in the run time. We recommend using the local search algorithm if your problem has highly correlated features or the number of samples is much smaller than the number of features---see the [local search section of the Vignette](https://cran.r-project.org/web/packages/L0Learn/vignettes/L0Learn-vignette.html#higher-quality_solutions_using_local_search) for how to use this algorithm. + +#### How to certify optimality? +While for many challenging statistical instances L0Learn leads to optimal solutions, it cannot provide certificates of optimality. Such certificates can be provided via Integer Programming. Our toolkit [L0BnB](https://github.com/alisaab/l0bnb) is a scalable integer programming framework for L0-regularized regression, which can provide such certificates and potentially improve upon the solutions of L0Learn (if they are sub-optimal). We recommend using L0Learn first to obtain a candidtate solution (or a pool of solutions) and then checking optimality using L0BnB. + + +## Citing L0Learn +If you find L0Learn useful in your research, please consider citing the following two papers. + +**Paper 1:** +``` +@article{doi:10.1287/opre.2019.1919, +author = {Hazimeh, Hussein and Mazumder, Rahul}, +title = {Fast Best Subset Selection: Coordinate Descent and Local Combinatorial Optimization Algorithms}, +journal = {Operations Research}, +volume = {68}, +number = {5}, +pages = {1517-1537}, +year = {2020}, +doi = {10.1287/opre.2019.1919}, +URL = {https://doi.org/10.1287/opre.2019.1919}, +eprint = {https://doi.org/10.1287/opre.2019.1919} +} +``` + +**Paper 2:** +``` +@article{JMLR:v22:19-1049, + author = {Antoine Dedieu and Hussein Hazimeh and Rahul Mazumder}, + title = {Learning Sparse Classifiers: Continuous and Mixed Integer Optimization Perspectives}, + journal = {Journal of Machine Learning Research}, + year = {2021}, + volume = {22}, + number = {135}, + pages = {1-47}, + url = {http://jmlr.org/papers/v22/19-1049.html} +} +``` \ No newline at end of file From 2d620799ded84e8e39ea6c7d897e29ba4b9e8f42 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Tue, 16 Nov 2021 08:05:22 -0600 Subject: [PATCH 038/125] Update r.yml --- .github/workflows/r.yml | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/.github/workflows/r.yml b/.github/workflows/r.yml index d65eab3..a28d6ba 100644 --- a/.github/workflows/r.yml +++ b/.github/workflows/r.yml @@ -36,3 +36,14 @@ jobs: - name: Check run: rcmdcheck::rcmdcheck(args = "--no-manual", error_on = "error", check_dir = "check") shell: Rscript {0} + - uses: r-lib/actions/setup-r@v1 + with: + use-public-rspm: true + + - uses: r-lib/actions/setup-r-dependencies@v1 + with: + extra-packages: covr + + - name: Test coverage + run: covr::codecov() + shell: Rscript {0} From caf80fa4bce49c0e6e2de652004d5dfab9ca3668 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Tue, 16 Nov 2021 16:20:25 -0600 Subject: [PATCH 039/125] Remove need for raster in test_L0Learn_bounds --- R/tests/testthat/test_L0Learn_bounds.R | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/R/tests/testthat/test_L0Learn_bounds.R b/R/tests/testthat/test_L0Learn_bounds.R index 70335bb..d7d13bc 100644 --- a/R/tests/testthat/test_L0Learn_bounds.R +++ b/R/tests/testthat/test_L0Learn_bounds.R @@ -1,7 +1,7 @@ library("Matrix") library("testthat") library("L0Learn") -library("raster") +library("pracma") tmp <- L0Learn::GenSynthetic(n=100, p=5000, k=10, seed=1, rho=1.5) X <- tmp[[1]] @@ -172,6 +172,12 @@ find <- function(x, inside){ which(sapply(inside, FUN=function(X) x %in% X), arr.ind = TRUE) } +clamp <- function(x, lower=-Inf, upper=Inf, ...) { + x[x < lower] <- lower + x[x > upper] <- upper + return(x) +} + test_that("L0Learn with bounds is better than no-bounds", { skip_on_cran() lows = -.02 @@ -194,7 +200,7 @@ test_that("L0Learn with bounds is better than no-bounds", { r_wb = y - X %*% beta_wb r_nb = y - X %*% beta_nb - expect_gte(norm(r_nb, "2"), norm(r_wb, "2")) + expect_gte(Norm(r_nb), Norm(r_wb)) } } } From b10f6160751cb804c10f0b137868675eed077086 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Tue, 16 Nov 2021 16:48:22 -0600 Subject: [PATCH 040/125] Update r.yml --- .github/workflows/r.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/r.yml b/.github/workflows/r.yml index a28d6ba..34f6d7d 100644 --- a/.github/workflows/r.yml +++ b/.github/workflows/r.yml @@ -34,7 +34,7 @@ jobs: remotes::install_deps(dependencies = TRUE) shell: Rscript {0} - name: Check - run: rcmdcheck::rcmdcheck(args = "--no-manual", error_on = "error", check_dir = "check") + run: rcmdcheck::rcmdcheck("R", args = "--no-manual", error_on = "error", check_dir = "check") shell: Rscript {0} - uses: r-lib/actions/setup-r@v1 with: From 8b6e6f3a8396fff8ac539d1b8ead261d6ab919d7 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Tue, 16 Nov 2021 17:29:33 -0600 Subject: [PATCH 041/125] Update r.yml --- .github/workflows/r.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/r.yml b/.github/workflows/r.yml index 34f6d7d..395238f 100644 --- a/.github/workflows/r.yml +++ b/.github/workflows/r.yml @@ -17,7 +17,7 @@ jobs: defaults: run: - working-directory: ./R + working-directory: R steps: - uses: actions/checkout@v2 @@ -43,6 +43,7 @@ jobs: - uses: r-lib/actions/setup-r-dependencies@v1 with: extra-packages: covr + working-directory: R - name: Test coverage run: covr::codecov() From 8b8a08296b526c8c70cd419d67f4519979b35ad6 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Wed, 17 Nov 2021 07:39:10 -0600 Subject: [PATCH 042/125] Create README.md --- R/README.md | 77 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 77 insertions(+) create mode 100644 R/README.md diff --git a/R/README.md b/R/README.md new file mode 100644 index 0000000..1dc37c6 --- /dev/null +++ b/R/README.md @@ -0,0 +1,77 @@ +# L0Learn: Fast Best Subset Selection +![example workflow](https://github.com/TNonet/L0Learn/actions/workflows/r.yml/badge.svg) [![CRAN](https://www.r-pkg.org/badges/version/L0Learn)](https://cran.r-project.org/package=L0Learn) [![Codacy Badge](https://app.codacy.com/project/badge/Grade/7fd68c533fd1493288e7986df3cc6f6d)](https://www.codacy.com/gh/hazimehh/L0Learn/dashboard?utm_source=github.com&utm_medium=referral&utm_content=hazimehh/L0Learn&utm_campaign=Badge_Grade) [![codecov](https://codecov.io/gh/hazimehh/L0Learn/branch/master/graph/badge.svg?token=QYDNA400OI)](https://codecov.io/gh/hazimehh/L0Learn) + +### Hussein Hazimeh, Rahul Mazumder, and Tim Nonet +### Massachusetts Institute of Technology + +Downloads from Rstudio: [![](https://cranlogs.r-pkg.org/badges/grand-total/L0Learn)](https://cran.rstudio.com/web/packages/L0Learn/index.html) + +## Introduction +L0Learn is a highly efficient framework for solving L0-regularized learning problems. It can (approximately) solve the following three problems, where the empirical loss is penalized by combinations of the L0, L1, and L2 norms: + + + +We support both regression (using squared error loss) and classification (using logistic or squared hinge loss). Optimization is done using coordinate descent and local combinatorial search over a grid of regularization parameter(s) values. Several computational tricks and heuristics are used to speed up the algorithms and improve the solution quality. These heuristics include warm starts, active set convergence, correlation screening, greedy cycling order, and efficient methods for updating the residuals through exploiting sparsity and problem dimensions. Moreover, we employed a new computationally efficient method for dynamically selecting the regularization parameter λ in the path. We describe the details of the algorithms in our paper: *Fast Best Subset Selection: Coordinate Descent and Local Combinatorial Optimization Algorithms* ([link](https://pubsonline.informs.org/doi/10.1287/opre.2019.1919)). + +The toolkit is implemented in C++11 and can often run faster than popular sparse learning toolkits (see our experiments in the paper above). We also provide an easy-to-use R interface; see the section below for installation and usage of the R package. + +**NEW: Version 2 (03/2021) adds support for sparse matrices and box constraints on the coefficients.** + +## R Package Installation +The latest version (v2.0.3) can be installed from CRAN as follows: +```{R} +install.packages("L0Learn", repos = "http://cran.rstudio.com") +``` +Alternatively, L0Learn can also be installed from Github as follows: +```{R} +library(devtools) +install_github("hazimehh/L0Learn", subdir="R") +``` +L0Learn's changelog can be accessed from [here](https://github.com/hazimehh/L0Learn/blob/master/ChangeLog). + +## Usage +For a tutorial, please refer to [L0Learn's Vignette](https://cran.r-project.org/web/packages/L0Learn/vignettes/L0Learn-vignette.html). For a detailed description of the API, check the [Reference Manual](https://cran.r-project.org/web/packages/L0Learn/L0Learn.pdf). + +## FAQ +#### Which penalty to use? +Pure L0 regularization can overfit when the signal strength in the data is relatively low. Adding L2 regularization can alleviate this problem and lead to competitive models (see the experiments in our paper). Thus, in practice, **we strongly recommend using the L0L2 penalty**. Ideally, the parameter gamma (for L2 regularization) should be tuned over a sufficiently large interval, and this can be performed using L0Learn's built-in [cross-validation method](https://cran.r-project.org/web/packages/L0Learn/vignettes/L0Learn-vignette.html#cross-validation). + +#### Which algorithm to use? +By default, L0Learn uses a coordinate descent-based algorithm, which achieves competitive run times compared to popular sparse learning toolkits. This can work well for many applications. We also offer a local search algorithm which is guarantteed to return higher quality solutions, at the expense of an increase in the run time. We recommend using the local search algorithm if your problem has highly correlated features or the number of samples is much smaller than the number of features---see the [local search section of the Vignette](https://cran.r-project.org/web/packages/L0Learn/vignettes/L0Learn-vignette.html#higher-quality_solutions_using_local_search) for how to use this algorithm. + +#### How to certify optimality? +While for many challenging statistical instances L0Learn leads to optimal solutions, it cannot provide certificates of optimality. Such certificates can be provided via Integer Programming. Our toolkit [L0BnB](https://github.com/alisaab/l0bnb) is a scalable integer programming framework for L0-regularized regression, which can provide such certificates and potentially improve upon the solutions of L0Learn (if they are sub-optimal). We recommend using L0Learn first to obtain a candidtate solution (or a pool of solutions) and then checking optimality using L0BnB. + + +## Citing L0Learn +If you find L0Learn useful in your research, please consider citing the following two papers. + +**Paper 1:** +``` +@article{doi:10.1287/opre.2019.1919, +author = {Hazimeh, Hussein and Mazumder, Rahul}, +title = {Fast Best Subset Selection: Coordinate Descent and Local Combinatorial Optimization Algorithms}, +journal = {Operations Research}, +volume = {68}, +number = {5}, +pages = {1517-1537}, +year = {2020}, +doi = {10.1287/opre.2019.1919}, +URL = {https://doi.org/10.1287/opre.2019.1919}, +eprint = {https://doi.org/10.1287/opre.2019.1919} +} +``` + +**Paper 2:** +``` +@article{JMLR:v22:19-1049, + author = {Antoine Dedieu and Hussein Hazimeh and Rahul Mazumder}, + title = {Learning Sparse Classifiers: Continuous and Mixed Integer Optimization Perspectives}, + journal = {Journal of Machine Learning Research}, + year = {2021}, + volume = {22}, + number = {135}, + pages = {1-47}, + url = {http://jmlr.org/papers/v22/19-1049.html} +} +``` From df1229193c5a458db62453a9d8d6646942a8c071 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Wed, 17 Nov 2021 07:40:26 -0600 Subject: [PATCH 043/125] Change README file type to rst --- python/{README.md => README.rst} | 0 python/setup.py | 2 +- 2 files changed, 1 insertion(+), 1 deletion(-) rename python/{README.md => README.rst} (100%) diff --git a/python/README.md b/python/README.rst similarity index 100% rename from python/README.md rename to python/README.rst diff --git a/python/setup.py b/python/setup.py index d83b3f0..da8de41 100644 --- a/python/setup.py +++ b/python/setup.py @@ -86,7 +86,7 @@ def no_cythonize(extensions, **_ignore): MacOsX: brew install armadillo --with-hdf5 """ -with open("README.md", "r", encoding="utf-8") as fh: +with open("README.rst", "r", encoding="utf-8") as fh: long_description = fh.read() setup( From abe17734087f866c728bb2774057fe9429b772f2 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 19 Nov 2021 10:36:14 -0600 Subject: [PATCH 044/125] Update r.yml --- .github/workflows/r.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/r.yml b/.github/workflows/r.yml index 395238f..58c3dfb 100644 --- a/.github/workflows/r.yml +++ b/.github/workflows/r.yml @@ -40,7 +40,7 @@ jobs: with: use-public-rspm: true - - uses: r-lib/actions/setup-r-dependencies@v1 + - uses: TNonet/actions/setup-r-dependencies@master with: extra-packages: covr working-directory: R From b25a3752f8f71b8c16f3093328a70a9d9764ee8c Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 19 Nov 2021 13:36:51 -0600 Subject: [PATCH 045/125] Update r.yml --- .github/workflows/r.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/r.yml b/.github/workflows/r.yml index 58c3dfb..3f54220 100644 --- a/.github/workflows/r.yml +++ b/.github/workflows/r.yml @@ -42,6 +42,7 @@ jobs: - uses: TNonet/actions/setup-r-dependencies@master with: + cache-version: 2 extra-packages: covr working-directory: R From 7196c2459643a4b1bd5b164ac31b264c223629bd Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 19 Nov 2021 13:39:30 -0600 Subject: [PATCH 046/125] Update r.yml --- .github/workflows/r.yml | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/.github/workflows/r.yml b/.github/workflows/r.yml index 3f54220..4d8849d 100644 --- a/.github/workflows/r.yml +++ b/.github/workflows/r.yml @@ -22,9 +22,10 @@ jobs: steps: - uses: actions/checkout@v2 - name: Set up R ${{ matrix.r-version }} - uses: r-lib/actions/setup-r@f57f1301a053485946083d7a45022b278929a78a + uses: r-lib/actions/setup-r@v1 with: r-version: ${{ matrix.r-version }} + use-public-rspm: true - uses: r-lib/actions/setup-pandoc@v1 with: pandoc-version: '2.7.3' @@ -36,13 +37,9 @@ jobs: - name: Check run: rcmdcheck::rcmdcheck("R", args = "--no-manual", error_on = "error", check_dir = "check") shell: Rscript {0} - - uses: r-lib/actions/setup-r@v1 - with: - use-public-rspm: true - - uses: TNonet/actions/setup-r-dependencies@master with: - cache-version: 2 + cache-version: 1 extra-packages: covr working-directory: R From 23af4f93c54267cca18e861b560334a1d99f484f Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 19 Nov 2021 14:06:55 -0600 Subject: [PATCH 047/125] remove `raster` and `covr` from DESCRIPTION Suggests --- R/DESCRIPTION | 2 -- 1 file changed, 2 deletions(-) diff --git a/R/DESCRIPTION b/R/DESCRIPTION index 7935f2e..7fe3fea 100644 --- a/R/DESCRIPTION +++ b/R/DESCRIPTION @@ -24,6 +24,4 @@ Suggests: rmarkdown, testthat, pracma, - raster, - covr VignetteBuilder: knitr From a74008bcad7000785cb2d0a0599f4e37340e0441 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 19 Nov 2021 15:32:47 -0600 Subject: [PATCH 048/125] Update .gitignore --- .gitignore | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.gitignore b/.gitignore index 2efdd70..245a1e5 100644 --- a/.gitignore +++ b/.gitignore @@ -156,3 +156,6 @@ dmypy.json # Cython debug symbols cython_debug/ + +# sphinx build folder +python/_build From d6bd21368820fb4d5ce8f4cbf346c748cfe4943c Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 19 Nov 2021 15:34:04 -0600 Subject: [PATCH 049/125] Update .gitignore --- .gitignore | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index 245a1e5..2db4c7c 100644 --- a/.gitignore +++ b/.gitignore @@ -158,4 +158,4 @@ dmypy.json cython_debug/ # sphinx build folder -python/_build +python/doc/_build From 3ef612fa29e6a69437e507d4917138d223acea89 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 19 Nov 2021 15:37:02 -0600 Subject: [PATCH 050/125] Update .gitignore --- .gitignore | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.gitignore b/.gitignore index 2efdd70..2db4c7c 100644 --- a/.gitignore +++ b/.gitignore @@ -156,3 +156,6 @@ dmypy.json # Cython debug symbols cython_debug/ + +# sphinx build folder +python/doc/_build From eca5c014de1996ca775080647f7231252fedbd38 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 19 Nov 2021 15:37:48 -0600 Subject: [PATCH 051/125] update python documentation --- python/doc/Makefile | 20 + python/doc/code.rst | 13 + python/doc/conf.py | 52 +++ python/doc/index.rst | 20 + python/doc/make.bat | 35 ++ python/l0learn/__init__.pxd | 0 python/l0learn/__init__.py | 2 +- python/l0learn/cyarma.cpp | 641 +++++++++++++++++++++---------- python/l0learn/interface.cpp | 581 ++++++++++++++++++++-------- python/l0learn/interface.pyx | 2 +- python/l0learn/models.py | 179 +++++++-- python/l0learn/testing_utils.cpp | 498 ++++++++++++++++++------ python/tests/test_fit.py | 9 + 13 files changed, 1536 insertions(+), 516 deletions(-) create mode 100644 python/doc/Makefile create mode 100644 python/doc/code.rst create mode 100644 python/doc/conf.py create mode 100644 python/doc/index.rst create mode 100644 python/doc/make.bat delete mode 100644 python/l0learn/__init__.pxd create mode 100644 python/tests/test_fit.py diff --git a/python/doc/Makefile b/python/doc/Makefile new file mode 100644 index 0000000..d4bb2cb --- /dev/null +++ b/python/doc/Makefile @@ -0,0 +1,20 @@ +# Minimal makefile for Sphinx documentation +# + +# You can set these variables from the command line, and also +# from the environment for the first two. +SPHINXOPTS ?= +SPHINXBUILD ?= sphinx-build +SOURCEDIR = . +BUILDDIR = _build + +# Put it first so that "make" without argument is like "make help". +help: + @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + +.PHONY: help Makefile + +# Catch-all target: route all unknown targets to Sphinx using the new +# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). +%: Makefile + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/python/doc/code.rst b/python/doc/code.rst new file mode 100644 index 0000000..056f2a0 --- /dev/null +++ b/python/doc/code.rst @@ -0,0 +1,13 @@ +Documentation for the Code +************************** + +.. automodule:: l0learn + + +useful #1 -- auto members +========================= + +This is something I want to say that is not in the docstring. + +.. automodule:: l0learn.models + :members: diff --git a/python/doc/conf.py b/python/doc/conf.py new file mode 100644 index 0000000..12d9b6b --- /dev/null +++ b/python/doc/conf.py @@ -0,0 +1,52 @@ +# Configuration file for the Sphinx documentation builder. +# +# This file only contains a selection of the most common options. For a full +# list see the documentation: +# https://www.sphinx-doc.org/en/master/usage/configuration.html + +# -- Path setup -------------------------------------------------------------- + +# If extensions (or modules to document with autodoc) are in another directory, +# add these directories to sys.path here. If the directory is relative to the +# documentation root, use os.path.abspath to make it absolute, like shown here. +# +import os +import sys +sys.path.insert(0, os.path.abspath('..')) +print(sys.executable) + + +# -- Project information ----------------------------------------------------- + +project = 'l0learn' +copyright = '2021, Hussein Hazimeh, Rahul Mazumder, and Tim Nonet' +author = 'Hussein Hazimeh, Rahul Mazumder, and Tim Nonet' + + +# -- General configuration --------------------------------------------------- + +# Add any Sphinx extension module names here, as strings. They can be +# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom +# ones. +extensions = ['sphinx.ext.autodoc'] + +# Add any paths that contain templates here, relative to this directory. +templates_path = ['_templates'] + +# List of patterns, relative to source directory, that match files and +# directories to ignore when looking for source files. +# This pattern also affects html_static_path and html_extra_path. +exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store'] + + +# -- Options for HTML output ------------------------------------------------- + +# The theme to use for HTML and HTML Help pages. See the documentation for +# a list of builtin themes. +# +html_theme = 'alabaster' + +# Add any paths that contain custom static files (such as style sheets) here, +# relative to this directory. They are copied after the builtin static files, +# so a file named "default.css" will overwrite the builtin "default.css". +html_static_path = ['_static'] \ No newline at end of file diff --git a/python/doc/index.rst b/python/doc/index.rst new file mode 100644 index 0000000..f8c2f70 --- /dev/null +++ b/python/doc/index.rst @@ -0,0 +1,20 @@ +.. l0learn documentation master file, created by + sphinx-quickstart on Wed Nov 17 07:46:32 2021. + You can adapt this file completely to your liking, but it should at least + contain the root `toctree` directive. + +Welcome to l0learn's documentation! +=================================== + +.. toctree:: + :maxdepth: 2 + + code + + +Indices and tables +================== + +* :ref:`genindex` +* :ref:`modindex` +* :ref:`search` diff --git a/python/doc/make.bat b/python/doc/make.bat new file mode 100644 index 0000000..153be5e --- /dev/null +++ b/python/doc/make.bat @@ -0,0 +1,35 @@ +@ECHO OFF + +pushd %~dp0 + +REM Command file for Sphinx documentation + +if "%SPHINXBUILD%" == "" ( + set SPHINXBUILD=sphinx-build +) +set SOURCEDIR=. +set BUILDDIR=_build + +if "%1" == "" goto help + +%SPHINXBUILD% >NUL 2>NUL +if errorlevel 9009 ( + echo. + echo.The 'sphinx-build' command was not found. Make sure you have Sphinx + echo.installed, then set the SPHINXBUILD environment variable to point + echo.to the full path of the 'sphinx-build' executable. Alternatively you + echo.may add the Sphinx directory to PATH. + echo. + echo.If you don't have Sphinx installed, grab it from + echo.https://www.sphinx-doc.org/ + exit /b 1 +) + +%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% +goto end + +:help +%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% + +:end +popd diff --git a/python/l0learn/__init__.pxd b/python/l0learn/__init__.pxd deleted file mode 100644 index e69de29..0000000 diff --git a/python/l0learn/__init__.py b/python/l0learn/__init__.py index d0d796c..aefab37 100644 --- a/python/l0learn/__init__.py +++ b/python/l0learn/__init__.py @@ -1 +1 @@ -from l0learn.interface import fit, cvfit +from .interface import fit, cvfit diff --git a/python/l0learn/cyarma.cpp b/python/l0learn/cyarma.cpp index 4e2dfce..a55d874 100644 --- a/python/l0learn/cyarma.cpp +++ b/python/l0learn/cyarma.cpp @@ -1,11 +1,14 @@ -/* Generated by Cython 0.29.21 */ +/* Generated by Cython 0.29.24 */ /* BEGIN: Cython Metadata { "distutils": { "depends": [ - "/Users/tnonet/opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/core/include/numpy/arrayobject.h", - "/Users/tnonet/opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/core/include/numpy/ufuncobject.h" + "/Users/tnonet/opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/core/include/numpy/arrayobject.h", + "/Users/tnonet/opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/core/include/numpy/arrayscalars.h", + "/Users/tnonet/opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/core/include/numpy/ndarrayobject.h", + "/Users/tnonet/opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/core/include/numpy/ndarraytypes.h", + "/Users/tnonet/opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/core/include/numpy/ufuncobject.h" ], "extra_compile_args": [ "-std=c++11" @@ -15,7 +18,7 @@ ], "include_dirs": [ ".", - "/Users/tnonet/opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/core/include" + "/Users/tnonet/opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/core/include" ], "language": "c++", "libraries": [ @@ -32,15 +35,17 @@ } END: Cython Metadata */ +#ifndef PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN +#endif /* PY_SSIZE_T_CLEAN */ #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) #error Cython requires Python 2.6+ or Python 3.3+. #else -#define CYTHON_ABI "0_29_21" -#define CYTHON_HEX_VERSION 0x001D15F0 +#define CYTHON_ABI "0_29_24" +#define CYTHON_HEX_VERSION 0x001D18F0 #define CYTHON_FUTURE_DIVISION 1 #include #ifndef offsetof @@ -472,8 +477,12 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #endif #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 + #if defined(PyUnicode_IS_READY) #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ 0 : _PyUnicode_Ready((PyObject *)(op))) + #else + #define __Pyx_PyUnicode_READY(op) (0) + #endif #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) @@ -482,7 +491,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif #else #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) #endif @@ -654,6 +667,9 @@ static CYTHON_INLINE float __PYX_NAN() { #include #include #include "numpy/arrayobject.h" +#include "numpy/ndarrayobject.h" +#include "numpy/ndarraytypes.h" +#include "numpy/arrayscalars.h" #include "numpy/ufuncobject.h" /* NumPy API declarations from "numpy/__init__.pxd" */ @@ -930,7 +946,7 @@ typedef struct { } __Pyx_BufFmt_Context; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":689 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":690 * # in Cython to enable them only on the right systems. * * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< @@ -939,7 +955,7 @@ typedef struct { */ typedef npy_int8 __pyx_t_5numpy_int8_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":690 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":691 * * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< @@ -948,7 +964,7 @@ typedef npy_int8 __pyx_t_5numpy_int8_t; */ typedef npy_int16 __pyx_t_5numpy_int16_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":691 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":692 * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< @@ -957,7 +973,7 @@ typedef npy_int16 __pyx_t_5numpy_int16_t; */ typedef npy_int32 __pyx_t_5numpy_int32_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":692 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":693 * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< @@ -966,7 +982,7 @@ typedef npy_int32 __pyx_t_5numpy_int32_t; */ typedef npy_int64 __pyx_t_5numpy_int64_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":696 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":697 * #ctypedef npy_int128 int128_t * * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< @@ -975,7 +991,7 @@ typedef npy_int64 __pyx_t_5numpy_int64_t; */ typedef npy_uint8 __pyx_t_5numpy_uint8_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":697 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":698 * * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< @@ -984,7 +1000,7 @@ typedef npy_uint8 __pyx_t_5numpy_uint8_t; */ typedef npy_uint16 __pyx_t_5numpy_uint16_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":698 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":699 * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< @@ -993,7 +1009,7 @@ typedef npy_uint16 __pyx_t_5numpy_uint16_t; */ typedef npy_uint32 __pyx_t_5numpy_uint32_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":699 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":700 * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< @@ -1002,7 +1018,7 @@ typedef npy_uint32 __pyx_t_5numpy_uint32_t; */ typedef npy_uint64 __pyx_t_5numpy_uint64_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":703 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":704 * #ctypedef npy_uint128 uint128_t * * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< @@ -1011,7 +1027,7 @@ typedef npy_uint64 __pyx_t_5numpy_uint64_t; */ typedef npy_float32 __pyx_t_5numpy_float32_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":704 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":705 * * ctypedef npy_float32 float32_t * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< @@ -1020,7 +1036,7 @@ typedef npy_float32 __pyx_t_5numpy_float32_t; */ typedef npy_float64 __pyx_t_5numpy_float64_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":713 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":714 * # The int types are mapped a bit surprising -- * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t # <<<<<<<<<<<<<< @@ -1029,7 +1045,7 @@ typedef npy_float64 __pyx_t_5numpy_float64_t; */ typedef npy_long __pyx_t_5numpy_int_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":714 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":715 * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< @@ -1038,7 +1054,7 @@ typedef npy_long __pyx_t_5numpy_int_t; */ typedef npy_longlong __pyx_t_5numpy_long_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":715 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":716 * ctypedef npy_long int_t * ctypedef npy_longlong long_t * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< @@ -1047,7 +1063,7 @@ typedef npy_longlong __pyx_t_5numpy_long_t; */ typedef npy_longlong __pyx_t_5numpy_longlong_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":717 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":718 * ctypedef npy_longlong longlong_t * * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< @@ -1056,7 +1072,7 @@ typedef npy_longlong __pyx_t_5numpy_longlong_t; */ typedef npy_ulong __pyx_t_5numpy_uint_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":718 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":719 * * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< @@ -1065,7 +1081,7 @@ typedef npy_ulong __pyx_t_5numpy_uint_t; */ typedef npy_ulonglong __pyx_t_5numpy_ulong_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":719 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":720 * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< @@ -1074,7 +1090,7 @@ typedef npy_ulonglong __pyx_t_5numpy_ulong_t; */ typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":721 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":722 * ctypedef npy_ulonglong ulonglong_t * * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< @@ -1083,7 +1099,7 @@ typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; */ typedef npy_intp __pyx_t_5numpy_intp_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":722 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":723 * * ctypedef npy_intp intp_t * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< @@ -1092,7 +1108,7 @@ typedef npy_intp __pyx_t_5numpy_intp_t; */ typedef npy_uintp __pyx_t_5numpy_uintp_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":724 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":725 * ctypedef npy_uintp uintp_t * * ctypedef npy_double float_t # <<<<<<<<<<<<<< @@ -1101,7 +1117,7 @@ typedef npy_uintp __pyx_t_5numpy_uintp_t; */ typedef npy_double __pyx_t_5numpy_float_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":725 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":726 * * ctypedef npy_double float_t * ctypedef npy_double double_t # <<<<<<<<<<<<<< @@ -1110,7 +1126,7 @@ typedef npy_double __pyx_t_5numpy_float_t; */ typedef npy_double __pyx_t_5numpy_double_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":726 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":727 * ctypedef npy_double float_t * ctypedef npy_double double_t * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< @@ -1145,7 +1161,7 @@ static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(do /*--- Type declarations ---*/ -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":728 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":729 * ctypedef npy_longdouble longdouble_t * * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< @@ -1154,7 +1170,7 @@ static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(do */ typedef npy_cfloat __pyx_t_5numpy_cfloat_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":729 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":730 * * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< @@ -1163,7 +1179,7 @@ typedef npy_cfloat __pyx_t_5numpy_cfloat_t; */ typedef npy_cdouble __pyx_t_5numpy_cdouble_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":730 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":731 * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< @@ -1172,7 +1188,7 @@ typedef npy_cdouble __pyx_t_5numpy_cdouble_t; */ typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":732 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":733 * ctypedef npy_clongdouble clongdouble_t * * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< @@ -1598,11 +1614,10 @@ typedef struct { #endif -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); - -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); +/* GCCDiagnostics.proto */ +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#define __Pyx_HAS_GCC_DIAGNOSTIC +#endif /* RealImag.proto */ #if CYTHON_CCOMPLEX @@ -1702,9 +1717,15 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); #endif #endif +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + /* CIntFromPy.proto */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); @@ -1759,6 +1780,16 @@ static PyTypeObject *__pyx_ptype_5numpy_dtype = 0; static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; +static PyTypeObject *__pyx_ptype_5numpy_generic = 0; +static PyTypeObject *__pyx_ptype_5numpy_number = 0; +static PyTypeObject *__pyx_ptype_5numpy_integer = 0; +static PyTypeObject *__pyx_ptype_5numpy_signedinteger = 0; +static PyTypeObject *__pyx_ptype_5numpy_unsignedinteger = 0; +static PyTypeObject *__pyx_ptype_5numpy_inexact = 0; +static PyTypeObject *__pyx_ptype_5numpy_floating = 0; +static PyTypeObject *__pyx_ptype_5numpy_complexfloating = 0; +static PyTypeObject *__pyx_ptype_5numpy_flexible = 0; +static PyTypeObject *__pyx_ptype_5numpy_character = 0; static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; /* Module declarations from 'cython' */ @@ -4728,7 +4759,7 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & return __pyx_r; } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":734 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":735 * ctypedef npy_cdouble complex_t * * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< @@ -4745,7 +4776,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":735 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":736 * * cdef inline object PyArray_MultiIterNew1(a): * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< @@ -4753,13 +4784,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ * cdef inline object PyArray_MultiIterNew2(a, b): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 735, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 736, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":734 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":735 * ctypedef npy_cdouble complex_t * * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< @@ -4778,7 +4809,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ return __pyx_r; } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":737 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":738 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< @@ -4795,7 +4826,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":738 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":739 * * cdef inline object PyArray_MultiIterNew2(a, b): * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< @@ -4803,13 +4834,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ * cdef inline object PyArray_MultiIterNew3(a, b, c): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 738, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 739, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":737 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":738 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< @@ -4828,7 +4859,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ return __pyx_r; } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":740 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":741 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< @@ -4845,7 +4876,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":741 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":742 * * cdef inline object PyArray_MultiIterNew3(a, b, c): * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< @@ -4853,13 +4884,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ * cdef inline object PyArray_MultiIterNew4(a, b, c, d): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 741, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 742, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":740 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":741 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< @@ -4878,7 +4909,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ return __pyx_r; } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":743 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":744 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< @@ -4895,7 +4926,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":744 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":745 * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< @@ -4903,13 +4934,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 744, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 745, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":743 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":744 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< @@ -4928,7 +4959,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ return __pyx_r; } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":746 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":747 * return PyArray_MultiIterNew(4, a, b, c, d) * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< @@ -4945,7 +4976,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":747 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":748 * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< @@ -4953,13 +4984,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ * cdef inline tuple PyDataType_SHAPE(dtype d): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 747, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 748, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":746 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":747 * return PyArray_MultiIterNew(4, a, b, c, d) * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< @@ -4978,7 +5009,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ return __pyx_r; } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":749 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":750 * return PyArray_MultiIterNew(5, a, b, c, d, e) * * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< @@ -4992,7 +5023,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ int __pyx_t_1; __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":750 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":751 * * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< @@ -5002,7 +5033,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); if (__pyx_t_1) { - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":751 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":752 * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape # <<<<<<<<<<<<<< @@ -5014,7 +5045,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":750 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":751 * * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< @@ -5023,7 +5054,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ */ } - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":753 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":754 * return d.subarray.shape * else: * return () # <<<<<<<<<<<<<< @@ -5037,7 +5068,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ goto __pyx_L0; } - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":749 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":750 * return PyArray_MultiIterNew(5, a, b, c, d, e) * * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< @@ -5052,7 +5083,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ return __pyx_r; } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":868 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":929 * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< @@ -5064,7 +5095,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_array_base", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":869 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":930 * * cdef inline void set_array_base(ndarray arr, object base): * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< @@ -5073,7 +5104,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a */ Py_INCREF(__pyx_v_base); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":870 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":931 * cdef inline void set_array_base(ndarray arr, object base): * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< @@ -5082,7 +5113,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a */ (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":868 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":929 * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< @@ -5094,7 +5125,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a __Pyx_RefNannyFinishContext(); } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":872 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":933 * PyArray_SetBaseObject(arr, base) * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< @@ -5109,7 +5140,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py int __pyx_t_1; __Pyx_RefNannySetupContext("get_array_base", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":873 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":934 * * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< @@ -5118,7 +5149,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py */ __pyx_v_base = PyArray_BASE(__pyx_v_arr); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":874 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":935 * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) * if base is NULL: # <<<<<<<<<<<<<< @@ -5128,7 +5159,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py __pyx_t_1 = ((__pyx_v_base == NULL) != 0); if (__pyx_t_1) { - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":875 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":936 * base = PyArray_BASE(arr) * if base is NULL: * return None # <<<<<<<<<<<<<< @@ -5139,7 +5170,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":874 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":935 * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) * if base is NULL: # <<<<<<<<<<<<<< @@ -5148,7 +5179,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py */ } - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":876 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":937 * if base is NULL: * return None * return base # <<<<<<<<<<<<<< @@ -5160,7 +5191,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py __pyx_r = ((PyObject *)__pyx_v_base); goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":872 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":933 * PyArray_SetBaseObject(arr, base) * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< @@ -5175,7 +5206,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py return __pyx_r; } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":880 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":941 * # Versions of the import_* functions which are more suitable for * # Cython code. * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< @@ -5199,7 +5230,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_array", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":881 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":942 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< @@ -5215,16 +5246,16 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":882 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":943 * cdef inline int import_array() except -1: * try: * __pyx_import_array() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.multiarray failed to import") */ - __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 882, __pyx_L3_error) + __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 943, __pyx_L3_error) - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":881 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":942 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< @@ -5238,7 +5269,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { goto __pyx_L8_try_end; __pyx_L3_error:; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":883 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":944 * try: * __pyx_import_array() * except Exception: # <<<<<<<<<<<<<< @@ -5248,28 +5279,28 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 883, __pyx_L5_except_error) + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 944, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":884 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":945 * __pyx_import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 884, __pyx_L5_except_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 945, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(1, 884, __pyx_L5_except_error) + __PYX_ERR(1, 945, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":881 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":942 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< @@ -5284,7 +5315,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { __pyx_L8_try_end:; } - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":880 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":941 * # Versions of the import_* functions which are more suitable for * # Cython code. * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< @@ -5307,7 +5338,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { return __pyx_r; } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":886 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":947 * raise ImportError("numpy.core.multiarray failed to import") * * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< @@ -5331,7 +5362,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_umath", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":887 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":948 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< @@ -5347,16 +5378,16 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":888 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":949 * cdef inline int import_umath() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.umath failed to import") */ - __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 888, __pyx_L3_error) + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 949, __pyx_L3_error) - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":887 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":948 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< @@ -5370,7 +5401,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { goto __pyx_L8_try_end; __pyx_L3_error:; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":889 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":950 * try: * _import_umath() * except Exception: # <<<<<<<<<<<<<< @@ -5380,28 +5411,28 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 889, __pyx_L5_except_error) + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 950, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":890 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":951 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 890, __pyx_L5_except_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 951, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(1, 890, __pyx_L5_except_error) + __PYX_ERR(1, 951, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":887 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":948 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< @@ -5416,7 +5447,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { __pyx_L8_try_end:; } - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":886 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":947 * raise ImportError("numpy.core.multiarray failed to import") * * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< @@ -5439,7 +5470,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { return __pyx_r; } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":892 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":953 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< @@ -5463,7 +5494,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_ufunc", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":893 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":954 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< @@ -5479,16 +5510,16 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":894 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":955 * cdef inline int import_ufunc() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.umath failed to import") */ - __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 894, __pyx_L3_error) + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 955, __pyx_L3_error) - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":893 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":954 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< @@ -5502,7 +5533,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { goto __pyx_L8_try_end; __pyx_L3_error:; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":895 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":956 * try: * _import_umath() * except Exception: # <<<<<<<<<<<<<< @@ -5512,28 +5543,28 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 895, __pyx_L5_except_error) + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 956, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":896 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":957 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef extern from *: */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 896, __pyx_L5_except_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 957, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(1, 896, __pyx_L5_except_error) + __PYX_ERR(1, 957, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":893 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":954 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< @@ -5548,7 +5579,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { __pyx_L8_try_end:; } - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":892 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":953 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< @@ -5571,6 +5602,180 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { return __pyx_r; } +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":967 + * + * + * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.timedelta64)` + */ + +static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_obj) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_timedelta64_object", 0); + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":979 + * bool + * """ + * return PyObject_TypeCheck(obj, &PyTimedeltaArrType_Type) # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyTimedeltaArrType_Type)); + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":967 + * + * + * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.timedelta64)` + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":982 + * + * + * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.datetime64)` + */ + +static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_obj) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_datetime64_object", 0); + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":994 + * bool + * """ + * return PyObject_TypeCheck(obj, &PyDatetimeArrType_Type) # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyDatetimeArrType_Type)); + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":982 + * + * + * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.datetime64)` + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":997 + * + * + * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy datetime64 object + */ + +static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject *__pyx_v_obj) { + npy_datetime __pyx_r; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1004 + * also needed. That can be found using `get_datetime64_unit`. + * """ + * return (obj).obval # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = ((PyDatetimeScalarObject *)__pyx_v_obj)->obval; + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":997 + * + * + * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy datetime64 object + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1007 + * + * + * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy timedelta64 object + */ + +static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject *__pyx_v_obj) { + npy_timedelta __pyx_r; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1011 + * returns the int64 value underlying scalar numpy timedelta64 object + * """ + * return (obj).obval # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = ((PyTimedeltaScalarObject *)__pyx_v_obj)->obval; + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1007 + * + * + * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy timedelta64 object + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1014 + * + * + * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the unit part of the dtype for a numpy datetime64 object. + */ + +static CYTHON_INLINE NPY_DATETIMEUNIT __pyx_f_5numpy_get_datetime64_unit(PyObject *__pyx_v_obj) { + NPY_DATETIMEUNIT __pyx_r; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1018 + * returns the unit part of the dtype for a numpy datetime64 object. + * """ + * return (obj).obmeta.base # <<<<<<<<<<<<<< + */ + __pyx_r = ((NPY_DATETIMEUNIT)((PyDatetimeScalarObject *)__pyx_v_obj)->obmeta.base); + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1014 + * + * + * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the unit part of the dtype for a numpy datetime64 object. + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; @@ -5661,7 +5866,7 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 91, __pyx_L1_error) __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 149, __pyx_L1_error) __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 179, __pyx_L1_error) - __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 884, __pyx_L1_error) + __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 945, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; @@ -5671,25 +5876,25 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":884 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":945 * __pyx_import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ - __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 884, __pyx_L1_error) + __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 945, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple_); __Pyx_GIVEREF(__pyx_tuple_); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":890 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":951 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ - __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 890, __pyx_L1_error) + __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 951, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__2); __Pyx_GIVEREF(__pyx_tuple__2); __Pyx_RefNannyFinishContext(); @@ -5789,18 +5994,38 @@ static int __Pyx_modinit_type_import_code(void) { __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(2, 9, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 199, __pyx_L1_error) + __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 200, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 199, __pyx_L1_error) + if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 200, __pyx_L1_error) __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 222, __pyx_L1_error) + if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 223, __pyx_L1_error) __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 226, __pyx_L1_error) + if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 227, __pyx_L1_error) __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 238, __pyx_L1_error) + if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 239, __pyx_L1_error) + __pyx_ptype_5numpy_generic = __Pyx_ImportType(__pyx_t_1, "numpy", "generic", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_generic) __PYX_ERR(1, 771, __pyx_L1_error) + __pyx_ptype_5numpy_number = __Pyx_ImportType(__pyx_t_1, "numpy", "number", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_number) __PYX_ERR(1, 773, __pyx_L1_error) + __pyx_ptype_5numpy_integer = __Pyx_ImportType(__pyx_t_1, "numpy", "integer", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_integer) __PYX_ERR(1, 775, __pyx_L1_error) + __pyx_ptype_5numpy_signedinteger = __Pyx_ImportType(__pyx_t_1, "numpy", "signedinteger", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_signedinteger) __PYX_ERR(1, 777, __pyx_L1_error) + __pyx_ptype_5numpy_unsignedinteger = __Pyx_ImportType(__pyx_t_1, "numpy", "unsignedinteger", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_unsignedinteger) __PYX_ERR(1, 779, __pyx_L1_error) + __pyx_ptype_5numpy_inexact = __Pyx_ImportType(__pyx_t_1, "numpy", "inexact", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_inexact) __PYX_ERR(1, 781, __pyx_L1_error) + __pyx_ptype_5numpy_floating = __Pyx_ImportType(__pyx_t_1, "numpy", "floating", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_floating) __PYX_ERR(1, 783, __pyx_L1_error) + __pyx_ptype_5numpy_complexfloating = __Pyx_ImportType(__pyx_t_1, "numpy", "complexfloating", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_complexfloating) __PYX_ERR(1, 785, __pyx_L1_error) + __pyx_ptype_5numpy_flexible = __Pyx_ImportType(__pyx_t_1, "numpy", "flexible", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_flexible) __PYX_ERR(1, 787, __pyx_L1_error) + __pyx_ptype_5numpy_character = __Pyx_ImportType(__pyx_t_1, "numpy", "character", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_character) __PYX_ERR(1, 789, __pyx_L1_error) __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 764, __pyx_L1_error) + if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 827, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; @@ -5972,11 +6197,9 @@ if (!__Pyx_RefNanny) { #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ - #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS - #ifdef WITH_THREAD /* Python build with threading support? */ + #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS PyEval_InitThreads(); #endif - #endif /*--- Module creation code ---*/ #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_m = __pyx_pyinit_module; @@ -6071,12 +6294,12 @@ if (!__Pyx_RefNanny) { if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":892 - * raise ImportError("numpy.core.umath failed to import") + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1014 * - * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() + * + * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the unit part of the dtype for a numpy datetime64 object. */ /*--- Wrapped vars code ---*/ @@ -6424,7 +6647,7 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *result; - ternaryfunc call = func->ob_type->tp_call; + ternaryfunc call = Py_TYPE(func)->tp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) @@ -6511,7 +6734,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObjec if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { return __Pyx_PyObject_CallMethO(func, arg); #if CYTHON_FAST_PYCCALL - } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { + } else if (__Pyx_PyFastCFunction_Check(func)) { return __Pyx_PyCFunction_FastCall(func, &arg, 1); #endif } @@ -8026,38 +8249,7 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { #endif - /* CIntToPy */ - static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { - const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; - const int is_unsigned = neg_one > const_zero; - if (is_unsigned) { - if (sizeof(long) < sizeof(long)) { - return PyInt_FromLong((long) value); - } else if (sizeof(long) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { - return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); -#endif - } - } else { - if (sizeof(long) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { - return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif - } - } - { - int one = 1; int little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&value; - return _PyLong_FromByteArray(bytes, sizeof(long), - little, !is_unsigned); - } -} - -/* CIntFromPyVerify */ + /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) #define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ @@ -8079,37 +8271,6 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { return (target_type) value;\ } -/* CIntToPy */ - static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { - const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; - const int is_unsigned = neg_one > const_zero; - if (is_unsigned) { - if (sizeof(int) < sizeof(long)) { - return PyInt_FromLong((long) value); - } else if (sizeof(int) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { - return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); -#endif - } - } else { - if (sizeof(int) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { - return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif - } - } - { - int one = 1; int little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&value; - return _PyLong_FromByteArray(bytes, sizeof(int), - little, !is_unsigned); - } -} - /* Declarations */ #if CYTHON_CCOMPLEX #ifdef __cplusplus @@ -8418,9 +8579,54 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { #endif #endif +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + /* CIntFromPy */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { - const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { @@ -8607,9 +8813,54 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { return (int) -1; } +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + /* CIntFromPy */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { - const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { diff --git a/python/l0learn/interface.cpp b/python/l0learn/interface.cpp index 0d8f3d2..3c3c3fd 100644 --- a/python/l0learn/interface.cpp +++ b/python/l0learn/interface.cpp @@ -1,11 +1,14 @@ -/* Generated by Cython 0.29.21 */ +/* Generated by Cython 0.29.24 */ /* BEGIN: Cython Metadata { "distutils": { "depends": [ - "/Users/tnonet/opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/core/include/numpy/arrayobject.h", - "/Users/tnonet/opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/core/include/numpy/ufuncobject.h", + "/Users/tnonet/opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/core/include/numpy/arrayobject.h", + "/Users/tnonet/opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/core/include/numpy/arrayscalars.h", + "/Users/tnonet/opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/core/include/numpy/ndarrayobject.h", + "/Users/tnonet/opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/core/include/numpy/ndarraytypes.h", + "/Users/tnonet/opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/core/include/numpy/ufuncobject.h", "l0learn/src/include/L0LearnCore.h" ], "extra_compile_args": [ @@ -17,7 +20,7 @@ "include_dirs": [ "l0learn", ".", - "/Users/tnonet/opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/core/include", + "/Users/tnonet/opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/core/include", "l0learn/src/include" ], "language": "c++", @@ -42,15 +45,17 @@ } END: Cython Metadata */ +#ifndef PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN +#endif /* PY_SSIZE_T_CLEAN */ #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) #error Cython requires Python 2.6+ or Python 3.3+. #else -#define CYTHON_ABI "0_29_21" -#define CYTHON_HEX_VERSION 0x001D15F0 +#define CYTHON_ABI "0_29_24" +#define CYTHON_HEX_VERSION 0x001D18F0 #define CYTHON_FUTURE_DIVISION 1 #include #ifndef offsetof @@ -482,8 +487,12 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #endif #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 + #if defined(PyUnicode_IS_READY) #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ 0 : _PyUnicode_Ready((PyObject *)(op))) + #else + #define __Pyx_PyUnicode_READY(op) (0) + #endif #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) @@ -492,7 +501,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif #else #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) #endif @@ -670,6 +683,9 @@ static CYTHON_INLINE float __PYX_NAN() { #include #include #include "numpy/arrayobject.h" +#include "numpy/ndarrayobject.h" +#include "numpy/ndarraytypes.h" +#include "numpy/arrayscalars.h" #include "numpy/ufuncobject.h" /* NumPy API declarations from "numpy/__init__.pxd" */ @@ -912,7 +928,7 @@ static const char *__pyx_f[] = { "type.pxd", }; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":689 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":690 * # in Cython to enable them only on the right systems. * * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< @@ -921,7 +937,7 @@ static const char *__pyx_f[] = { */ typedef npy_int8 __pyx_t_5numpy_int8_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":690 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":691 * * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< @@ -930,7 +946,7 @@ typedef npy_int8 __pyx_t_5numpy_int8_t; */ typedef npy_int16 __pyx_t_5numpy_int16_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":691 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":692 * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< @@ -939,7 +955,7 @@ typedef npy_int16 __pyx_t_5numpy_int16_t; */ typedef npy_int32 __pyx_t_5numpy_int32_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":692 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":693 * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< @@ -948,7 +964,7 @@ typedef npy_int32 __pyx_t_5numpy_int32_t; */ typedef npy_int64 __pyx_t_5numpy_int64_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":696 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":697 * #ctypedef npy_int128 int128_t * * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< @@ -957,7 +973,7 @@ typedef npy_int64 __pyx_t_5numpy_int64_t; */ typedef npy_uint8 __pyx_t_5numpy_uint8_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":697 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":698 * * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< @@ -966,7 +982,7 @@ typedef npy_uint8 __pyx_t_5numpy_uint8_t; */ typedef npy_uint16 __pyx_t_5numpy_uint16_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":698 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":699 * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< @@ -975,7 +991,7 @@ typedef npy_uint16 __pyx_t_5numpy_uint16_t; */ typedef npy_uint32 __pyx_t_5numpy_uint32_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":699 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":700 * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< @@ -984,7 +1000,7 @@ typedef npy_uint32 __pyx_t_5numpy_uint32_t; */ typedef npy_uint64 __pyx_t_5numpy_uint64_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":703 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":704 * #ctypedef npy_uint128 uint128_t * * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< @@ -993,7 +1009,7 @@ typedef npy_uint64 __pyx_t_5numpy_uint64_t; */ typedef npy_float32 __pyx_t_5numpy_float32_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":704 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":705 * * ctypedef npy_float32 float32_t * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< @@ -1002,7 +1018,7 @@ typedef npy_float32 __pyx_t_5numpy_float32_t; */ typedef npy_float64 __pyx_t_5numpy_float64_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":713 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":714 * # The int types are mapped a bit surprising -- * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t # <<<<<<<<<<<<<< @@ -1011,7 +1027,7 @@ typedef npy_float64 __pyx_t_5numpy_float64_t; */ typedef npy_long __pyx_t_5numpy_int_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":714 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":715 * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< @@ -1020,7 +1036,7 @@ typedef npy_long __pyx_t_5numpy_int_t; */ typedef npy_longlong __pyx_t_5numpy_long_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":715 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":716 * ctypedef npy_long int_t * ctypedef npy_longlong long_t * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< @@ -1029,7 +1045,7 @@ typedef npy_longlong __pyx_t_5numpy_long_t; */ typedef npy_longlong __pyx_t_5numpy_longlong_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":717 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":718 * ctypedef npy_longlong longlong_t * * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< @@ -1038,7 +1054,7 @@ typedef npy_longlong __pyx_t_5numpy_longlong_t; */ typedef npy_ulong __pyx_t_5numpy_uint_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":718 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":719 * * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< @@ -1047,7 +1063,7 @@ typedef npy_ulong __pyx_t_5numpy_uint_t; */ typedef npy_ulonglong __pyx_t_5numpy_ulong_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":719 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":720 * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< @@ -1056,7 +1072,7 @@ typedef npy_ulonglong __pyx_t_5numpy_ulong_t; */ typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":721 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":722 * ctypedef npy_ulonglong ulonglong_t * * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< @@ -1065,7 +1081,7 @@ typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; */ typedef npy_intp __pyx_t_5numpy_intp_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":722 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":723 * * ctypedef npy_intp intp_t * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< @@ -1074,7 +1090,7 @@ typedef npy_intp __pyx_t_5numpy_intp_t; */ typedef npy_uintp __pyx_t_5numpy_uintp_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":724 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":725 * ctypedef npy_uintp uintp_t * * ctypedef npy_double float_t # <<<<<<<<<<<<<< @@ -1083,7 +1099,7 @@ typedef npy_uintp __pyx_t_5numpy_uintp_t; */ typedef npy_double __pyx_t_5numpy_float_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":725 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":726 * * ctypedef npy_double float_t * ctypedef npy_double double_t # <<<<<<<<<<<<<< @@ -1092,7 +1108,7 @@ typedef npy_double __pyx_t_5numpy_float_t; */ typedef npy_double __pyx_t_5numpy_double_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":726 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":727 * ctypedef npy_double float_t * ctypedef npy_double double_t * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< @@ -1127,7 +1143,7 @@ static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(do /*--- Type declarations ---*/ -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":728 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":729 * ctypedef npy_longdouble longdouble_t * * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< @@ -1136,7 +1152,7 @@ static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(do */ typedef npy_cfloat __pyx_t_5numpy_cfloat_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":729 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":730 * * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< @@ -1145,7 +1161,7 @@ typedef npy_cfloat __pyx_t_5numpy_cfloat_t; */ typedef npy_cdouble __pyx_t_5numpy_cdouble_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":730 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":731 * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< @@ -1154,7 +1170,7 @@ typedef npy_cdouble __pyx_t_5numpy_cdouble_t; */ typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":732 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":733 * ctypedef npy_clongdouble clongdouble_t * * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< @@ -1466,6 +1482,11 @@ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int static CYTHON_INLINE PyObject* __Pyx_PyUnicode_Substring( PyObject* text, Py_ssize_t start, Py_ssize_t stop); +/* GCCDiagnostics.proto */ +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#define __Pyx_HAS_GCC_DIAGNOSTIC +#endif + /* BuildPyUnicode.proto */ static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, char* chars, int clength, int prepend_sign, char padding_char); @@ -1611,9 +1632,6 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); - /* RealImag.proto */ #if CYTHON_CCOMPLEX #ifdef __cplusplus @@ -1712,6 +1730,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); #endif #endif +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + /* CIntFromPy.proto */ static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *); @@ -1782,6 +1803,16 @@ static PyTypeObject *__pyx_ptype_5numpy_dtype = 0; static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; +static PyTypeObject *__pyx_ptype_5numpy_generic = 0; +static PyTypeObject *__pyx_ptype_5numpy_number = 0; +static PyTypeObject *__pyx_ptype_5numpy_integer = 0; +static PyTypeObject *__pyx_ptype_5numpy_signedinteger = 0; +static PyTypeObject *__pyx_ptype_5numpy_unsignedinteger = 0; +static PyTypeObject *__pyx_ptype_5numpy_inexact = 0; +static PyTypeObject *__pyx_ptype_5numpy_floating = 0; +static PyTypeObject *__pyx_ptype_5numpy_complexfloating = 0; +static PyTypeObject *__pyx_ptype_5numpy_flexible = 0; +static PyTypeObject *__pyx_ptype_5numpy_character = 0; static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; /* Module declarations from 'l0learn.cyarma' */ @@ -11941,7 +11972,7 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_sparse(arma::sp_dmat co return __pyx_r; } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":734 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":735 * ctypedef npy_cdouble complex_t * * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< @@ -11958,7 +11989,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":735 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":736 * * cdef inline object PyArray_MultiIterNew1(a): * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< @@ -11966,13 +11997,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ * cdef inline object PyArray_MultiIterNew2(a, b): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 735, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 736, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":734 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":735 * ctypedef npy_cdouble complex_t * * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< @@ -11991,7 +12022,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ return __pyx_r; } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":737 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":738 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< @@ -12008,7 +12039,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":738 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":739 * * cdef inline object PyArray_MultiIterNew2(a, b): * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< @@ -12016,13 +12047,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ * cdef inline object PyArray_MultiIterNew3(a, b, c): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 738, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 739, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":737 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":738 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< @@ -12041,7 +12072,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ return __pyx_r; } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":740 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":741 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< @@ -12058,7 +12089,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":741 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":742 * * cdef inline object PyArray_MultiIterNew3(a, b, c): * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< @@ -12066,13 +12097,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ * cdef inline object PyArray_MultiIterNew4(a, b, c, d): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 741, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 742, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":740 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":741 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< @@ -12091,7 +12122,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ return __pyx_r; } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":743 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":744 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< @@ -12108,7 +12139,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":744 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":745 * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< @@ -12116,13 +12147,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 744, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 745, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":743 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":744 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< @@ -12141,7 +12172,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ return __pyx_r; } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":746 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":747 * return PyArray_MultiIterNew(4, a, b, c, d) * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< @@ -12158,7 +12189,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":747 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":748 * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< @@ -12166,13 +12197,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ * cdef inline tuple PyDataType_SHAPE(dtype d): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 747, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 748, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":746 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":747 * return PyArray_MultiIterNew(4, a, b, c, d) * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< @@ -12191,7 +12222,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ return __pyx_r; } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":749 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":750 * return PyArray_MultiIterNew(5, a, b, c, d, e) * * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< @@ -12205,7 +12236,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ int __pyx_t_1; __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":750 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":751 * * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< @@ -12215,7 +12246,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); if (__pyx_t_1) { - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":751 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":752 * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape # <<<<<<<<<<<<<< @@ -12227,7 +12258,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":750 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":751 * * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< @@ -12236,7 +12267,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ */ } - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":753 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":754 * return d.subarray.shape * else: * return () # <<<<<<<<<<<<<< @@ -12250,7 +12281,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ goto __pyx_L0; } - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":749 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":750 * return PyArray_MultiIterNew(5, a, b, c, d, e) * * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< @@ -12265,7 +12296,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ return __pyx_r; } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":868 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":929 * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< @@ -12277,7 +12308,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_array_base", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":869 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":930 * * cdef inline void set_array_base(ndarray arr, object base): * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< @@ -12286,7 +12317,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a */ Py_INCREF(__pyx_v_base); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":870 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":931 * cdef inline void set_array_base(ndarray arr, object base): * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< @@ -12295,7 +12326,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a */ (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":868 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":929 * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< @@ -12307,7 +12338,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a __Pyx_RefNannyFinishContext(); } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":872 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":933 * PyArray_SetBaseObject(arr, base) * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< @@ -12322,7 +12353,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py int __pyx_t_1; __Pyx_RefNannySetupContext("get_array_base", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":873 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":934 * * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< @@ -12331,7 +12362,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py */ __pyx_v_base = PyArray_BASE(__pyx_v_arr); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":874 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":935 * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) * if base is NULL: # <<<<<<<<<<<<<< @@ -12341,7 +12372,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py __pyx_t_1 = ((__pyx_v_base == NULL) != 0); if (__pyx_t_1) { - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":875 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":936 * base = PyArray_BASE(arr) * if base is NULL: * return None # <<<<<<<<<<<<<< @@ -12352,7 +12383,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":874 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":935 * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) * if base is NULL: # <<<<<<<<<<<<<< @@ -12361,7 +12392,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py */ } - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":876 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":937 * if base is NULL: * return None * return base # <<<<<<<<<<<<<< @@ -12373,7 +12404,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py __pyx_r = ((PyObject *)__pyx_v_base); goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":872 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":933 * PyArray_SetBaseObject(arr, base) * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< @@ -12388,7 +12419,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py return __pyx_r; } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":880 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":941 * # Versions of the import_* functions which are more suitable for * # Cython code. * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< @@ -12412,7 +12443,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_array", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":881 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":942 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< @@ -12428,16 +12459,16 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":882 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":943 * cdef inline int import_array() except -1: * try: * __pyx_import_array() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.multiarray failed to import") */ - __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 882, __pyx_L3_error) + __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 943, __pyx_L3_error) - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":881 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":942 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< @@ -12451,7 +12482,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { goto __pyx_L8_try_end; __pyx_L3_error:; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":883 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":944 * try: * __pyx_import_array() * except Exception: # <<<<<<<<<<<<<< @@ -12461,28 +12492,28 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 883, __pyx_L5_except_error) + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 944, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":884 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":945 * __pyx_import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 884, __pyx_L5_except_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 945, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(1, 884, __pyx_L5_except_error) + __PYX_ERR(1, 945, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":881 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":942 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< @@ -12497,7 +12528,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { __pyx_L8_try_end:; } - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":880 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":941 * # Versions of the import_* functions which are more suitable for * # Cython code. * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< @@ -12520,7 +12551,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { return __pyx_r; } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":886 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":947 * raise ImportError("numpy.core.multiarray failed to import") * * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< @@ -12544,7 +12575,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_umath", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":887 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":948 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< @@ -12560,16 +12591,16 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":888 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":949 * cdef inline int import_umath() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.umath failed to import") */ - __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 888, __pyx_L3_error) + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 949, __pyx_L3_error) - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":887 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":948 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< @@ -12583,7 +12614,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { goto __pyx_L8_try_end; __pyx_L3_error:; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":889 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":950 * try: * _import_umath() * except Exception: # <<<<<<<<<<<<<< @@ -12593,28 +12624,28 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 889, __pyx_L5_except_error) + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 950, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":890 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":951 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 890, __pyx_L5_except_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 951, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(1, 890, __pyx_L5_except_error) + __PYX_ERR(1, 951, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":887 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":948 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< @@ -12629,7 +12660,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { __pyx_L8_try_end:; } - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":886 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":947 * raise ImportError("numpy.core.multiarray failed to import") * * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< @@ -12652,7 +12683,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { return __pyx_r; } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":892 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":953 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< @@ -12676,7 +12707,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_ufunc", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":893 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":954 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< @@ -12692,16 +12723,16 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":894 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":955 * cdef inline int import_ufunc() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.umath failed to import") */ - __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 894, __pyx_L3_error) + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 955, __pyx_L3_error) - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":893 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":954 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< @@ -12715,7 +12746,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { goto __pyx_L8_try_end; __pyx_L3_error:; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":895 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":956 * try: * _import_umath() * except Exception: # <<<<<<<<<<<<<< @@ -12725,28 +12756,28 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 895, __pyx_L5_except_error) + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 956, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":896 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":957 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef extern from *: */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 896, __pyx_L5_except_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 957, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(1, 896, __pyx_L5_except_error) + __PYX_ERR(1, 957, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":893 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":954 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< @@ -12761,7 +12792,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { __pyx_L8_try_end:; } - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":892 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":953 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< @@ -12784,6 +12815,180 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { return __pyx_r; } +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":967 + * + * + * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.timedelta64)` + */ + +static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_obj) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_timedelta64_object", 0); + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":979 + * bool + * """ + * return PyObject_TypeCheck(obj, &PyTimedeltaArrType_Type) # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyTimedeltaArrType_Type)); + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":967 + * + * + * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.timedelta64)` + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":982 + * + * + * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.datetime64)` + */ + +static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_obj) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_datetime64_object", 0); + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":994 + * bool + * """ + * return PyObject_TypeCheck(obj, &PyDatetimeArrType_Type) # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyDatetimeArrType_Type)); + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":982 + * + * + * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.datetime64)` + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":997 + * + * + * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy datetime64 object + */ + +static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject *__pyx_v_obj) { + npy_datetime __pyx_r; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1004 + * also needed. That can be found using `get_datetime64_unit`. + * """ + * return (obj).obval # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = ((PyDatetimeScalarObject *)__pyx_v_obj)->obval; + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":997 + * + * + * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy datetime64 object + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1007 + * + * + * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy timedelta64 object + */ + +static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject *__pyx_v_obj) { + npy_timedelta __pyx_r; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1011 + * returns the int64 value underlying scalar numpy timedelta64 object + * """ + * return (obj).obval # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = ((PyTimedeltaScalarObject *)__pyx_v_obj)->obval; + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1007 + * + * + * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy timedelta64 object + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1014 + * + * + * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the unit part of the dtype for a numpy datetime64 object. + */ + +static CYTHON_INLINE NPY_DATETIMEUNIT __pyx_f_5numpy_get_datetime64_unit(PyObject *__pyx_v_obj) { + NPY_DATETIMEUNIT __pyx_r; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1018 + * returns the unit part of the dtype for a numpy datetime64 object. + * """ + * return (obj).obmeta.base # <<<<<<<<<<<<<< + */ + __pyx_r = ((NPY_DATETIMEUNIT)((PyDatetimeScalarObject *)__pyx_v_obj)->obmeta.base); + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1014 + * + * + * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the unit part of the dtype for a numpy datetime64 object. + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + /* "vector.from_py":45 * * @cname("__pyx_convert_vector_from_py_double") @@ -13673,7 +13878,7 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_any = __Pyx_GetBuiltinName(__pyx_n_s_any); if (!__pyx_builtin_any) __PYX_ERR(0, 325, __pyx_L1_error) __pyx_builtin_all = __Pyx_GetBuiltinName(__pyx_n_s_all); if (!__pyx_builtin_all) __PYX_ERR(0, 337, __pyx_L1_error) __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 371, __pyx_L1_error) - __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 884, __pyx_L1_error) + __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 945, __pyx_L1_error) __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(2, 61, __pyx_L1_error) return 0; __pyx_L1_error:; @@ -13739,25 +13944,25 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_GOTREF(__pyx_tuple__6); __Pyx_GIVEREF(__pyx_tuple__6); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":884 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":945 * __pyx_import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ - __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 884, __pyx_L1_error) + __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 945, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__11); __Pyx_GIVEREF(__pyx_tuple__11); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":890 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":951 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ - __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 890, __pyx_L1_error) + __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 951, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__12); __Pyx_GIVEREF(__pyx_tuple__12); @@ -13922,18 +14127,38 @@ static int __Pyx_modinit_type_import_code(void) { __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(3, 9, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 199, __pyx_L1_error) + __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 200, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 199, __pyx_L1_error) + if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 200, __pyx_L1_error) __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 222, __pyx_L1_error) + if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 223, __pyx_L1_error) __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 226, __pyx_L1_error) + if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 227, __pyx_L1_error) __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 238, __pyx_L1_error) + if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 239, __pyx_L1_error) + __pyx_ptype_5numpy_generic = __Pyx_ImportType(__pyx_t_1, "numpy", "generic", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_generic) __PYX_ERR(1, 771, __pyx_L1_error) + __pyx_ptype_5numpy_number = __Pyx_ImportType(__pyx_t_1, "numpy", "number", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_number) __PYX_ERR(1, 773, __pyx_L1_error) + __pyx_ptype_5numpy_integer = __Pyx_ImportType(__pyx_t_1, "numpy", "integer", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_integer) __PYX_ERR(1, 775, __pyx_L1_error) + __pyx_ptype_5numpy_signedinteger = __Pyx_ImportType(__pyx_t_1, "numpy", "signedinteger", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_signedinteger) __PYX_ERR(1, 777, __pyx_L1_error) + __pyx_ptype_5numpy_unsignedinteger = __Pyx_ImportType(__pyx_t_1, "numpy", "unsignedinteger", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_unsignedinteger) __PYX_ERR(1, 779, __pyx_L1_error) + __pyx_ptype_5numpy_inexact = __Pyx_ImportType(__pyx_t_1, "numpy", "inexact", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_inexact) __PYX_ERR(1, 781, __pyx_L1_error) + __pyx_ptype_5numpy_floating = __Pyx_ImportType(__pyx_t_1, "numpy", "floating", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_floating) __PYX_ERR(1, 783, __pyx_L1_error) + __pyx_ptype_5numpy_complexfloating = __Pyx_ImportType(__pyx_t_1, "numpy", "complexfloating", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_complexfloating) __PYX_ERR(1, 785, __pyx_L1_error) + __pyx_ptype_5numpy_flexible = __Pyx_ImportType(__pyx_t_1, "numpy", "flexible", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_flexible) __PYX_ERR(1, 787, __pyx_L1_error) + __pyx_ptype_5numpy_character = __Pyx_ImportType(__pyx_t_1, "numpy", "character", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_character) __PYX_ERR(1, 789, __pyx_L1_error) __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 764, __pyx_L1_error) + if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 827, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; @@ -14123,11 +14348,9 @@ if (!__Pyx_RefNanny) { #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ - #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS - #ifdef WITH_THREAD /* Python build with threading support? */ + #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS PyEval_InitThreads(); #endif - #endif /*--- Module creation code ---*/ #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_m = __pyx_pyinit_module; @@ -14623,7 +14846,7 @@ static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *result; - ternaryfunc call = func->ob_type->tp_call; + ternaryfunc call = Py_TYPE(func)->tp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) @@ -15068,7 +15291,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObjec if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { return __Pyx_PyObject_CallMethO(func, arg); #if CYTHON_FAST_PYCCALL - } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { + } else if (__Pyx_PyFastCFunction_Check(func)) { return __Pyx_PyCFunction_FastCall(func, &arg, 1); #endif } @@ -15767,9 +15990,6 @@ static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, char* chars, #else #include #endif -#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) -#define GCC_DIAGNOSTIC -#endif static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char, char format_char) { char digits[sizeof(Py_ssize_t)*3+2]; char *dpos, *end = digits + sizeof(Py_ssize_t)*3+2; @@ -15777,12 +15997,12 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t length, ulength; int prepend_sign, last_one_off; Py_ssize_t remaining; -#ifdef GCC_DIAGNOSTIC +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" #endif const Py_ssize_t neg_one = (Py_ssize_t) -1, const_zero = (Py_ssize_t) 0; -#ifdef GCC_DIAGNOSTIC +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC #pragma GCC diagnostic pop #endif const int is_unsigned = neg_one > const_zero; @@ -16610,37 +16830,6 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, Py_XDECREF(py_frame); } -/* CIntToPy */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { - const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; - const int is_unsigned = neg_one > const_zero; - if (is_unsigned) { - if (sizeof(long) < sizeof(long)) { - return PyInt_FromLong((long) value); - } else if (sizeof(long) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { - return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); -#endif - } - } else { - if (sizeof(long) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { - return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif - } - } - { - int one = 1; int little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&value; - return _PyLong_FromByteArray(bytes, sizeof(long), - little, !is_unsigned); - } -} - /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) @@ -16971,9 +17160,54 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { #endif #endif +/* CIntToPy */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + /* CIntFromPy */ static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) { - const size_t neg_one = (size_t) ((size_t) 0 - (size_t) 1), const_zero = (size_t) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const size_t neg_one = (size_t) -1, const_zero = (size_t) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { @@ -17162,7 +17396,14 @@ static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) { /* CIntFromPy */ static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) { - const unsigned int neg_one = (unsigned int) ((unsigned int) 0 - (unsigned int) 1), const_zero = (unsigned int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const unsigned int neg_one = (unsigned int) -1, const_zero = (unsigned int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { @@ -17351,7 +17592,14 @@ static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) { /* CIntFromPy */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { - const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { @@ -17540,7 +17788,14 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { /* CIntFromPy */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { - const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { diff --git a/python/l0learn/interface.pyx b/python/l0learn/interface.pyx index f57088e..a8049a3 100644 --- a/python/l0learn/interface.pyx +++ b/python/l0learn/interface.pyx @@ -209,7 +209,7 @@ def fit(X: Union[np.ndarray, csc_matrix], size p (number of columns of X) where highs[i] is the upper bound for coefficient i. Upper bounds can not be below 0 (i.e. we can not specify that all coefficients must be smaller than a < 0). - Upper bounds can be set to 0 iff the corresponding looer bound for that coefficient is also not 0. + Upper bounds can be set to 0 iff the corresponding lower bound for that coefficient is also not 0. Returns ------- diff --git a/python/l0learn/models.py b/python/l0learn/models.py index b2f6112..e28e4f3 100644 --- a/python/l0learn/models.py +++ b/python/l0learn/models.py @@ -1,7 +1,9 @@ +""" +.. module:: models +""" import warnings from dataclasses import dataclass, field -from functools import wraps -from typing import List, Dict, Any, Optional, Tuple, Union, Sequence, Callable +from typing import List, Dict, Any, Optional, Tuple, Union, Sequence import numpy as np import pandas as pd @@ -182,6 +184,7 @@ def squared_hinge_loss(y_true: np.ndarray, @dataclass(frozen=True, repr=False, eq=False) class FitModel: + """ FitModel returned by calling l0learn.fit(...) """ settings: Dict[str, Any] lambda_0: List[List[float]] = field(repr=False) gamma: List[float] = field(repr=False) @@ -190,11 +193,26 @@ class FitModel: intercepts: List[List[float]] = field(repr=False) converged: List[List[bool]] = field(repr=False) - def characteristics_as_pandas_table(self, new_data: Optional[Tuple[List[float], - List[List[float]], - List[List[int]], - List[List[float]], - List[List[bool]]]] = None) -> pd.DataFrame: + def _characteristics_as_pandas_table(self, new_data: Optional[Tuple[List[float], + List[List[float]], + List[List[int]], + List[List[float]], + List[List[bool]]]] = None) -> pd.DataFrame: + """ Formats FitModel's data as a Pandas DataFrame where each row is a solution in the regularization path. + The DataFrame is in of solutions being founnd. + + Parameters + ---------- + new_data : Optional Tuple + Should be a valid subset of `self`'s instance values that represent a consecutive subsequence of solutions + + Returns + ------- + characteristics_table : pd.DataFrame: + Pandas DataFrame of characteristics of the solution path referenced by new_data, if provided, or by the + instance values of self. Specifically: + (self.gamma, self.lambda_0, self.support_size, self.intercepts, self.converged) + """ if new_data is not None: gamma, lambda_0, support_size, intercepts, converged = new_data else: @@ -223,7 +241,7 @@ def characteristics_as_pandas_table(self, new_data: Optional[Tuple[List[float], return pd.concat(tables).reset_index(drop=True) def _repr_html_(self): - return self.characteristics_as_pandas_table()._repr_html_() + return self._characteristics_as_pandas_table()._repr_html_() def __repr__(self) -> str: return f"{self.__class__.__name__}({self.settings})" @@ -232,25 +250,40 @@ def coeff(self, lambda_0: Optional[float] = None, gamma: Optional[float] = None, include_intercept: bool = True) -> csc_matrix: - """ Extracts the coefficient according to lambda_0 and gamma + """ Extracts the coefficient according to `lambda_0`, `gamma`, and `include_intercept` + + Values for lambda_0` and `gamma` do not need to be exact. The closest values, respectively, found in the + regularization path will be used - If both lambda_0 and gamma are not supplied, then a matrix of coefficients for all the solutions in the + If both `lambda_0` and `gamma` are not supplied, then a matrix of coefficients for all the solutions in the regularization path is returned. - If lambda_0 is supplied but gamma is not, the smallest value of gamma is used. + If `lambda_0` is supplied but `gamma` is not, the smallest value of `gamma` is used. - If gamma is supplied but not lambda_0, then a matrix of coefficients for all the solutions in the - regularization path for gamma is returned. + If `gamma` is supplied but not `lambda_0`, then a matrix of coefficients for all the solutions in the + regularization path for `gamma` is returned. Parameters ---------- lambda_0 : float, optional + If provided, designates which solutions will be returned based of `lambda_0` and `gamma` + gamma : float, optional + If provided, designates which solutions will be returned based of `gamma` and `lambda_0` + include_intercept : bool, default True + If provided, will include the intercepts as the first row of the coefficient matrix Returns ------- coeff: csc_matrix + Matrix of fit coefficients from the regularization path + Has shape (p, num_solutions) if `include_intercept` is True or (p+1, num_solutions) otherwise. + where num_solutions is defined by `lambda_0` and `gamma`. + + coeff[i, :] refers to features i's coefficient across the returned solutions + coeff[:, j] refers to solution j's coefficient + coeff[i, j] refers to features i's coefficient for solution j """ if gamma is None: @@ -283,6 +316,48 @@ def coeff(self, def characteristics(self, lambda_0: Optional[float] = None, gamma: Optional[float] = None) -> pd.DataFrame: + """ Formats the characteristics of the solutions that correspond to the specificed `lambda_0` and `gamma` as a + pandas DataFrame where each row is a solution in the regularization path. + The DataFrame is in of solutions being found. + + Parameters + ---------- + lambda_0 : float, optional + If provided, designates which solutions will be returned based of `lambda_0` and `gamma` + See FitModel.coeff for details on `lambda_0` specifications + :meth:`l0learn.models.FitModel.coeff` + + gamma : float, optional + If provided, designates which solutions will be returned based of `gamma` and `lambda_0` + See FitModel.coeff for details on `lambda_0` specifications + :meth:`l0learn.models.FitModel.coeff` + + Returns + ------- + characteristics : pd.DataFrame: + Pandas DataFrame of characteristics of the solution path referenced by `lambda_0` and `gamma` + + The characteristics table has the following columns with the following interpretations: + gamma: The value of the L1 or L2 regularization parameter used in the specific solution of + regularization path referred to by the row of the characteristic table. + + Inspect FitModel.settings for specific of L1 vs L2 + lambda_0: The value of the L0 regularization parameter used in the specific solution of + regularization path referred to by the row of the characteristic table. + + support_size: The number of non-zero coefficients found in the specific solution of + regularization path referred to by the row of the characteristic table. + + Inspect FitModel.settings for the max support size was specified + + intercepts: The value of the intercept term found in the specific solution of + regularization path referred to by the row of the characteristic table. + + Inspect FitModel.settings if tunable intercept was used or not + + converged: Whether or not the specific solution of regularization path referred to by the row of the + characteristic table converged or not. + """ if gamma is None: if lambda_0 is None: @@ -314,7 +389,7 @@ def characteristics(self, support_size = [[self.support_size[gamma_index][lambda_index]]] converged = [[self.converged[gamma_index][lambda_index]]] - return self.characteristics_as_pandas_table(new_data=(gamma, lambda_0, support_size, intercepts, converged)) + return self._characteristics_as_pandas_table(new_data=(gamma, lambda_0, support_size, intercepts, converged)) def plot(self, gamma: float = 0, show_lines: bool = False, **kwargs): """ Plots the regularization path for a given gamma. @@ -323,9 +398,13 @@ def plot(self, gamma: float = 0, show_lines: bool = False, **kwargs): ---------- gamma : float The value of gamma at which to plot + Values for `gamma` do not need to be exact. The closest values, respectively, found in the regularization + path will be used + show_lines : bool If True, the lines connecting the points in the plot are shown. kwargs : dict of str to any + Key Word arguments passed to matplotlib.pyplot Notes @@ -380,17 +459,55 @@ def score(self, gamma: Optional[float] = None, training: bool = False, include_characteristics: bool = False) -> Union[pd.DataFrame, np.ndarray]: - """ + """ Scores the performance of solutions in the regularization path at predicting `y_hat` based + on features in `x`. + + Scoring function used is specified by the FitModel.settings #TODO Add sphinx reference to seetings Parameters ---------- - x - y - lambda_0 - gamma + x : np.ndarray of shape (N, P) + Features or design matrix to predict `y_hat` from + Does not inclue an intercept term as the model will automatically add one if specified in + FitMode.settings + + y : np.ndarray of shape (N, ) + Observations or ground truths of `y` which will be compared with `y_hat` + + See FitModel.predict for details on predictions + :meth:`l0learn.models.FitModel.predict` + + lambda_0 : float, optional + If provided, designates which solutions will be returned based of `lambda_0` and `gamma` + See FitModel.coeff for details on `lambda_0` specifications + :meth:`l0learn.models.FitModel.coeff` + + gamma : float, optional + If provided, designates which solutions will be returned based of `gamma` and `lambda_0` + See FitModel.coeff for details on `lambda_0` specifications + :meth:`l0learn.models.FitModel.coeff` + + training: bool, default False + Whether or not to include regularization losses when calculating model performance. + + If `training` is True, all penalties according to FitModel.settings will be applied. + Otherwise, only the loss function will be calculated based on `y` and `y_hat` + + include_characteristics: bool, default False + Whether or not to include the characteristics of each solution. This will result in `score` beginning + returned as a Pandas DataFrame similar to FitModel.characteristics, but with an additional column for score + + See FitModel.characteristics for details on characteristics + :meth:`l0learn.models.FitModel.characteristics` Returns ------- + score: np.ndarray of shape (num_solutions) or pd.Dataframe of length num_solutions + + Where score[i] is the loss function between y and y_hat based on the ith solution of the regularization path + specified by `gamma` and `lamda_0` values. + + If `include_characteristics` is True, score will be added as a column of the characteristics table """ predictions = self.predict(x=x, lambda_0=lambda_0, gamma=gamma) @@ -430,16 +547,22 @@ def predict(self, ---------- x: array-like An array of feature observations on which predictions are made. - X should have shape (N, P). Intercept terms will be added by the predict function is specified during - original training. + X should have shape (N, P). + Intercept terms will be added by the predict function if specified during original training. + #TODO Sphinx Reference for Settings + lambda_0 : float, optional - Which lambda_0 value to use for predictions + Which `lambda_0` value to use for predictions + + See FitModel.coeff for details on `lambda_0` specifications + :meth:`l0learn.models.FitModel.coeff` - See FitModel.coeff for details on lambda_0 specifications gamma : float, optional Which gamma value to use for predictions - See FitModel.coeff for details on gamma specifications + See FitModel.coeff for details on `lambda_0` specifications + :meth:`l0learn.models.FitModel.coeff` + Returns ------- predictions : np.ndarray @@ -447,11 +570,9 @@ def predict(self, For logistic regression (loss specified as "Logistic"), values are non-threshold - When multiple coeffs are specified due to the settings of lambda_0 and gamma the prediction array is still - as expected with: - - predictions[i, j] (row i, column j) refers to predicted response for observation i using coefficients from - solution j. + When multiple coeffs are specified due to the settings of `lambda_0` and `gamma` the prediction array is + formatted with standard convention: + predictions[i, j] refer to predicted response for observation i using coefficients from solution j. """ coeffs = self.coeff(lambda_0=lambda_0, gamma=gamma, diff --git a/python/l0learn/testing_utils.cpp b/python/l0learn/testing_utils.cpp index 982f50c..69dcb8a 100644 --- a/python/l0learn/testing_utils.cpp +++ b/python/l0learn/testing_utils.cpp @@ -1,11 +1,14 @@ -/* Generated by Cython 0.29.21 */ +/* Generated by Cython 0.29.24 */ /* BEGIN: Cython Metadata { "distutils": { "depends": [ - "/Users/tnonet/opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/core/include/numpy/arrayobject.h", - "/Users/tnonet/opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/core/include/numpy/ufuncobject.h" + "/Users/tnonet/opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/core/include/numpy/arrayobject.h", + "/Users/tnonet/opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/core/include/numpy/arrayscalars.h", + "/Users/tnonet/opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/core/include/numpy/ndarrayobject.h", + "/Users/tnonet/opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/core/include/numpy/ndarraytypes.h", + "/Users/tnonet/opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/core/include/numpy/ufuncobject.h" ], "extra_compile_args": [ "-std=c++11" @@ -15,7 +18,7 @@ ], "include_dirs": [ ".", - "/Users/tnonet/opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/core/include" + "/Users/tnonet/opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/core/include" ], "language": "c++", "libraries": [ @@ -32,15 +35,17 @@ } END: Cython Metadata */ +#ifndef PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN +#endif /* PY_SSIZE_T_CLEAN */ #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) #error Cython requires Python 2.6+ or Python 3.3+. #else -#define CYTHON_ABI "0_29_21" -#define CYTHON_HEX_VERSION 0x001D15F0 +#define CYTHON_ABI "0_29_24" +#define CYTHON_HEX_VERSION 0x001D18F0 #define CYTHON_FUTURE_DIVISION 1 #include #ifndef offsetof @@ -472,8 +477,12 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #endif #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 + #if defined(PyUnicode_IS_READY) #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ 0 : _PyUnicode_Ready((PyObject *)(op))) + #else + #define __Pyx_PyUnicode_READY(op) (0) + #endif #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) @@ -482,7 +491,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif #else #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) #endif @@ -654,6 +667,9 @@ static CYTHON_INLINE float __PYX_NAN() { #include #include #include "numpy/arrayobject.h" +#include "numpy/ndarrayobject.h" +#include "numpy/ndarraytypes.h" +#include "numpy/arrayscalars.h" #include "numpy/ufuncobject.h" /* NumPy API declarations from "numpy/__init__.pxd" */ @@ -930,7 +946,7 @@ typedef struct { } __Pyx_BufFmt_Context; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":689 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":690 * # in Cython to enable them only on the right systems. * * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< @@ -939,7 +955,7 @@ typedef struct { */ typedef npy_int8 __pyx_t_5numpy_int8_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":690 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":691 * * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< @@ -948,7 +964,7 @@ typedef npy_int8 __pyx_t_5numpy_int8_t; */ typedef npy_int16 __pyx_t_5numpy_int16_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":691 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":692 * ctypedef npy_int8 int8_t * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< @@ -957,7 +973,7 @@ typedef npy_int16 __pyx_t_5numpy_int16_t; */ typedef npy_int32 __pyx_t_5numpy_int32_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":692 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":693 * ctypedef npy_int16 int16_t * ctypedef npy_int32 int32_t * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< @@ -966,7 +982,7 @@ typedef npy_int32 __pyx_t_5numpy_int32_t; */ typedef npy_int64 __pyx_t_5numpy_int64_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":696 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":697 * #ctypedef npy_int128 int128_t * * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< @@ -975,7 +991,7 @@ typedef npy_int64 __pyx_t_5numpy_int64_t; */ typedef npy_uint8 __pyx_t_5numpy_uint8_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":697 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":698 * * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< @@ -984,7 +1000,7 @@ typedef npy_uint8 __pyx_t_5numpy_uint8_t; */ typedef npy_uint16 __pyx_t_5numpy_uint16_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":698 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":699 * ctypedef npy_uint8 uint8_t * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< @@ -993,7 +1009,7 @@ typedef npy_uint16 __pyx_t_5numpy_uint16_t; */ typedef npy_uint32 __pyx_t_5numpy_uint32_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":699 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":700 * ctypedef npy_uint16 uint16_t * ctypedef npy_uint32 uint32_t * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< @@ -1002,7 +1018,7 @@ typedef npy_uint32 __pyx_t_5numpy_uint32_t; */ typedef npy_uint64 __pyx_t_5numpy_uint64_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":703 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":704 * #ctypedef npy_uint128 uint128_t * * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< @@ -1011,7 +1027,7 @@ typedef npy_uint64 __pyx_t_5numpy_uint64_t; */ typedef npy_float32 __pyx_t_5numpy_float32_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":704 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":705 * * ctypedef npy_float32 float32_t * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< @@ -1020,7 +1036,7 @@ typedef npy_float32 __pyx_t_5numpy_float32_t; */ typedef npy_float64 __pyx_t_5numpy_float64_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":713 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":714 * # The int types are mapped a bit surprising -- * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t # <<<<<<<<<<<<<< @@ -1029,7 +1045,7 @@ typedef npy_float64 __pyx_t_5numpy_float64_t; */ typedef npy_long __pyx_t_5numpy_int_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":714 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":715 * # numpy.int corresponds to 'l' and numpy.long to 'q' * ctypedef npy_long int_t * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< @@ -1038,7 +1054,7 @@ typedef npy_long __pyx_t_5numpy_int_t; */ typedef npy_longlong __pyx_t_5numpy_long_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":715 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":716 * ctypedef npy_long int_t * ctypedef npy_longlong long_t * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< @@ -1047,7 +1063,7 @@ typedef npy_longlong __pyx_t_5numpy_long_t; */ typedef npy_longlong __pyx_t_5numpy_longlong_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":717 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":718 * ctypedef npy_longlong longlong_t * * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< @@ -1056,7 +1072,7 @@ typedef npy_longlong __pyx_t_5numpy_longlong_t; */ typedef npy_ulong __pyx_t_5numpy_uint_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":718 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":719 * * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< @@ -1065,7 +1081,7 @@ typedef npy_ulong __pyx_t_5numpy_uint_t; */ typedef npy_ulonglong __pyx_t_5numpy_ulong_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":719 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":720 * ctypedef npy_ulong uint_t * ctypedef npy_ulonglong ulong_t * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< @@ -1074,7 +1090,7 @@ typedef npy_ulonglong __pyx_t_5numpy_ulong_t; */ typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":721 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":722 * ctypedef npy_ulonglong ulonglong_t * * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< @@ -1083,7 +1099,7 @@ typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; */ typedef npy_intp __pyx_t_5numpy_intp_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":722 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":723 * * ctypedef npy_intp intp_t * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< @@ -1092,7 +1108,7 @@ typedef npy_intp __pyx_t_5numpy_intp_t; */ typedef npy_uintp __pyx_t_5numpy_uintp_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":724 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":725 * ctypedef npy_uintp uintp_t * * ctypedef npy_double float_t # <<<<<<<<<<<<<< @@ -1101,7 +1117,7 @@ typedef npy_uintp __pyx_t_5numpy_uintp_t; */ typedef npy_double __pyx_t_5numpy_float_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":725 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":726 * * ctypedef npy_double float_t * ctypedef npy_double double_t # <<<<<<<<<<<<<< @@ -1110,7 +1126,7 @@ typedef npy_double __pyx_t_5numpy_float_t; */ typedef npy_double __pyx_t_5numpy_double_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":726 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":727 * ctypedef npy_double float_t * ctypedef npy_double double_t * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< @@ -1145,7 +1161,7 @@ static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(do /*--- Type declarations ---*/ -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":728 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":729 * ctypedef npy_longdouble longdouble_t * * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< @@ -1154,7 +1170,7 @@ static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(do */ typedef npy_cfloat __pyx_t_5numpy_cfloat_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":729 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":730 * * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< @@ -1163,7 +1179,7 @@ typedef npy_cfloat __pyx_t_5numpy_cfloat_t; */ typedef npy_cdouble __pyx_t_5numpy_cdouble_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":730 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":731 * ctypedef npy_cfloat cfloat_t * ctypedef npy_cdouble cdouble_t * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< @@ -1172,7 +1188,7 @@ typedef npy_cdouble __pyx_t_5numpy_cdouble_t; */ typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":732 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":733 * ctypedef npy_clongdouble clongdouble_t * * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< @@ -1559,6 +1575,11 @@ typedef struct { #endif #endif +/* GCCDiagnostics.proto */ +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#define __Pyx_HAS_GCC_DIAGNOSTIC +#endif + /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); @@ -1620,6 +1641,16 @@ static PyTypeObject *__pyx_ptype_5numpy_dtype = 0; static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; +static PyTypeObject *__pyx_ptype_5numpy_generic = 0; +static PyTypeObject *__pyx_ptype_5numpy_number = 0; +static PyTypeObject *__pyx_ptype_5numpy_integer = 0; +static PyTypeObject *__pyx_ptype_5numpy_signedinteger = 0; +static PyTypeObject *__pyx_ptype_5numpy_unsignedinteger = 0; +static PyTypeObject *__pyx_ptype_5numpy_inexact = 0; +static PyTypeObject *__pyx_ptype_5numpy_floating = 0; +static PyTypeObject *__pyx_ptype_5numpy_complexfloating = 0; +static PyTypeObject *__pyx_ptype_5numpy_flexible = 0; +static PyTypeObject *__pyx_ptype_5numpy_character = 0; static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; /* Module declarations from 'libcpp' */ @@ -3042,7 +3073,7 @@ static arma::dmat __pyx_f_7l0learn_13testing_utils_c_dmat_dot_dmat(arma::dmat __ return __pyx_r; } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":734 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":735 * ctypedef npy_cdouble complex_t * * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< @@ -3059,7 +3090,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":735 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":736 * * cdef inline object PyArray_MultiIterNew1(a): * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< @@ -3067,13 +3098,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ * cdef inline object PyArray_MultiIterNew2(a, b): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 735, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 736, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":734 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":735 * ctypedef npy_cdouble complex_t * * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< @@ -3092,7 +3123,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ return __pyx_r; } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":737 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":738 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< @@ -3109,7 +3140,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":738 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":739 * * cdef inline object PyArray_MultiIterNew2(a, b): * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< @@ -3117,13 +3148,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ * cdef inline object PyArray_MultiIterNew3(a, b, c): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 738, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 739, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":737 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":738 * return PyArray_MultiIterNew(1, a) * * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< @@ -3142,7 +3173,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ return __pyx_r; } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":740 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":741 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< @@ -3159,7 +3190,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":741 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":742 * * cdef inline object PyArray_MultiIterNew3(a, b, c): * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< @@ -3167,13 +3198,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ * cdef inline object PyArray_MultiIterNew4(a, b, c, d): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 741, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 742, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":740 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":741 * return PyArray_MultiIterNew(2, a, b) * * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< @@ -3192,7 +3223,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ return __pyx_r; } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":743 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":744 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< @@ -3209,7 +3240,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":744 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":745 * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< @@ -3217,13 +3248,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 744, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 745, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":743 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":744 * return PyArray_MultiIterNew(3, a, b, c) * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< @@ -3242,7 +3273,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ return __pyx_r; } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":746 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":747 * return PyArray_MultiIterNew(4, a, b, c, d) * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< @@ -3259,7 +3290,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":747 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":748 * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< @@ -3267,13 +3298,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ * cdef inline tuple PyDataType_SHAPE(dtype d): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 747, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 748, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":746 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":747 * return PyArray_MultiIterNew(4, a, b, c, d) * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< @@ -3292,7 +3323,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ return __pyx_r; } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":749 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":750 * return PyArray_MultiIterNew(5, a, b, c, d, e) * * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< @@ -3306,7 +3337,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ int __pyx_t_1; __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":750 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":751 * * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< @@ -3316,7 +3347,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); if (__pyx_t_1) { - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":751 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":752 * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): * return d.subarray.shape # <<<<<<<<<<<<<< @@ -3328,7 +3359,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":750 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":751 * * cdef inline tuple PyDataType_SHAPE(dtype d): * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< @@ -3337,7 +3368,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ */ } - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":753 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":754 * return d.subarray.shape * else: * return () # <<<<<<<<<<<<<< @@ -3351,7 +3382,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ goto __pyx_L0; } - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":749 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":750 * return PyArray_MultiIterNew(5, a, b, c, d, e) * * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< @@ -3366,7 +3397,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ return __pyx_r; } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":868 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":929 * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< @@ -3378,7 +3409,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set_array_base", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":869 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":930 * * cdef inline void set_array_base(ndarray arr, object base): * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< @@ -3387,7 +3418,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a */ Py_INCREF(__pyx_v_base); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":870 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":931 * cdef inline void set_array_base(ndarray arr, object base): * Py_INCREF(base) # important to do this before stealing the reference below! * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< @@ -3396,7 +3427,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a */ (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":868 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":929 * int _import_umath() except -1 * * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< @@ -3408,7 +3439,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a __Pyx_RefNannyFinishContext(); } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":872 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":933 * PyArray_SetBaseObject(arr, base) * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< @@ -3423,7 +3454,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py int __pyx_t_1; __Pyx_RefNannySetupContext("get_array_base", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":873 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":934 * * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< @@ -3432,7 +3463,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py */ __pyx_v_base = PyArray_BASE(__pyx_v_arr); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":874 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":935 * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) * if base is NULL: # <<<<<<<<<<<<<< @@ -3442,7 +3473,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py __pyx_t_1 = ((__pyx_v_base == NULL) != 0); if (__pyx_t_1) { - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":875 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":936 * base = PyArray_BASE(arr) * if base is NULL: * return None # <<<<<<<<<<<<<< @@ -3453,7 +3484,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":874 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":935 * cdef inline object get_array_base(ndarray arr): * base = PyArray_BASE(arr) * if base is NULL: # <<<<<<<<<<<<<< @@ -3462,7 +3493,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py */ } - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":876 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":937 * if base is NULL: * return None * return base # <<<<<<<<<<<<<< @@ -3474,7 +3505,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py __pyx_r = ((PyObject *)__pyx_v_base); goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":872 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":933 * PyArray_SetBaseObject(arr, base) * * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< @@ -3489,7 +3520,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py return __pyx_r; } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":880 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":941 * # Versions of the import_* functions which are more suitable for * # Cython code. * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< @@ -3513,7 +3544,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_array", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":881 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":942 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< @@ -3529,16 +3560,16 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":882 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":943 * cdef inline int import_array() except -1: * try: * __pyx_import_array() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.multiarray failed to import") */ - __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 882, __pyx_L3_error) + __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 943, __pyx_L3_error) - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":881 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":942 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< @@ -3552,7 +3583,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { goto __pyx_L8_try_end; __pyx_L3_error:; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":883 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":944 * try: * __pyx_import_array() * except Exception: # <<<<<<<<<<<<<< @@ -3562,28 +3593,28 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 883, __pyx_L5_except_error) + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 944, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":884 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":945 * __pyx_import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 884, __pyx_L5_except_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 945, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(1, 884, __pyx_L5_except_error) + __PYX_ERR(1, 945, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":881 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":942 * # Cython code. * cdef inline int import_array() except -1: * try: # <<<<<<<<<<<<<< @@ -3598,7 +3629,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { __pyx_L8_try_end:; } - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":880 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":941 * # Versions of the import_* functions which are more suitable for * # Cython code. * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< @@ -3621,7 +3652,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { return __pyx_r; } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":886 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":947 * raise ImportError("numpy.core.multiarray failed to import") * * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< @@ -3645,7 +3676,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_umath", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":887 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":948 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< @@ -3661,16 +3692,16 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":888 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":949 * cdef inline int import_umath() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.umath failed to import") */ - __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 888, __pyx_L3_error) + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 949, __pyx_L3_error) - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":887 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":948 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< @@ -3684,7 +3715,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { goto __pyx_L8_try_end; __pyx_L3_error:; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":889 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":950 * try: * _import_umath() * except Exception: # <<<<<<<<<<<<<< @@ -3694,28 +3725,28 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 889, __pyx_L5_except_error) + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 950, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":890 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":951 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 890, __pyx_L5_except_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 951, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(1, 890, __pyx_L5_except_error) + __PYX_ERR(1, 951, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":887 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":948 * * cdef inline int import_umath() except -1: * try: # <<<<<<<<<<<<<< @@ -3730,7 +3761,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { __pyx_L8_try_end:; } - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":886 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":947 * raise ImportError("numpy.core.multiarray failed to import") * * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< @@ -3753,7 +3784,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { return __pyx_r; } -/* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":892 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":953 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< @@ -3777,7 +3808,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_ufunc", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":893 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":954 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< @@ -3793,16 +3824,16 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":894 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":955 * cdef inline int import_ufunc() except -1: * try: * _import_umath() # <<<<<<<<<<<<<< * except Exception: * raise ImportError("numpy.core.umath failed to import") */ - __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 894, __pyx_L3_error) + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 955, __pyx_L3_error) - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":893 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":954 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< @@ -3816,7 +3847,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { goto __pyx_L8_try_end; __pyx_L3_error:; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":895 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":956 * try: * _import_umath() * except Exception: # <<<<<<<<<<<<<< @@ -3826,28 +3857,28 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 895, __pyx_L5_except_error) + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 956, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":896 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":957 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef extern from *: */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 896, __pyx_L5_except_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 957, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(1, 896, __pyx_L5_except_error) + __PYX_ERR(1, 957, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":893 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":954 * * cdef inline int import_ufunc() except -1: * try: # <<<<<<<<<<<<<< @@ -3862,7 +3893,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { __pyx_L8_try_end:; } - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":892 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":953 * raise ImportError("numpy.core.umath failed to import") * * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< @@ -3885,6 +3916,180 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { return __pyx_r; } +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":967 + * + * + * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.timedelta64)` + */ + +static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_obj) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_timedelta64_object", 0); + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":979 + * bool + * """ + * return PyObject_TypeCheck(obj, &PyTimedeltaArrType_Type) # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyTimedeltaArrType_Type)); + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":967 + * + * + * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.timedelta64)` + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":982 + * + * + * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.datetime64)` + */ + +static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_obj) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_datetime64_object", 0); + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":994 + * bool + * """ + * return PyObject_TypeCheck(obj, &PyDatetimeArrType_Type) # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyDatetimeArrType_Type)); + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":982 + * + * + * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.datetime64)` + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":997 + * + * + * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy datetime64 object + */ + +static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject *__pyx_v_obj) { + npy_datetime __pyx_r; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1004 + * also needed. That can be found using `get_datetime64_unit`. + * """ + * return (obj).obval # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = ((PyDatetimeScalarObject *)__pyx_v_obj)->obval; + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":997 + * + * + * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy datetime64 object + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1007 + * + * + * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy timedelta64 object + */ + +static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject *__pyx_v_obj) { + npy_timedelta __pyx_r; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1011 + * returns the int64 value underlying scalar numpy timedelta64 object + * """ + * return (obj).obval # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = ((PyTimedeltaScalarObject *)__pyx_v_obj)->obval; + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1007 + * + * + * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy timedelta64 object + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1014 + * + * + * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the unit part of the dtype for a numpy datetime64 object. + */ + +static CYTHON_INLINE NPY_DATETIMEUNIT __pyx_f_5numpy_get_datetime64_unit(PyObject *__pyx_v_obj) { + NPY_DATETIMEUNIT __pyx_r; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1018 + * returns the unit part of the dtype for a numpy datetime64 object. + * """ + * return (obj).obmeta.base # <<<<<<<<<<<<<< + */ + __pyx_r = ((NPY_DATETIMEUNIT)((PyDatetimeScalarObject *)__pyx_v_obj)->obmeta.base); + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1014 + * + * + * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the unit part of the dtype for a numpy datetime64 object. + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; @@ -3960,7 +4165,7 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {0, 0, 0, 0, 0, 0, 0} }; static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { - __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 884, __pyx_L1_error) + __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 945, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; @@ -3970,25 +4175,25 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":884 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":945 * __pyx_import_array() * except Exception: * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_umath() except -1: */ - __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 884, __pyx_L1_error) + __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 945, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple_); __Pyx_GIVEREF(__pyx_tuple_); - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":890 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":951 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * * cdef inline int import_ufunc() except -1: */ - __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 890, __pyx_L1_error) + __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 951, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__2); __Pyx_GIVEREF(__pyx_tuple__2); @@ -4160,18 +4365,38 @@ static int __Pyx_modinit_type_import_code(void) { __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(2, 9, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 199, __pyx_L1_error) + __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 200, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 199, __pyx_L1_error) + if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 200, __pyx_L1_error) __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 222, __pyx_L1_error) + if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 223, __pyx_L1_error) __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 226, __pyx_L1_error) + if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 227, __pyx_L1_error) __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 238, __pyx_L1_error) + if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 239, __pyx_L1_error) + __pyx_ptype_5numpy_generic = __Pyx_ImportType(__pyx_t_1, "numpy", "generic", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_generic) __PYX_ERR(1, 771, __pyx_L1_error) + __pyx_ptype_5numpy_number = __Pyx_ImportType(__pyx_t_1, "numpy", "number", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_number) __PYX_ERR(1, 773, __pyx_L1_error) + __pyx_ptype_5numpy_integer = __Pyx_ImportType(__pyx_t_1, "numpy", "integer", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_integer) __PYX_ERR(1, 775, __pyx_L1_error) + __pyx_ptype_5numpy_signedinteger = __Pyx_ImportType(__pyx_t_1, "numpy", "signedinteger", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_signedinteger) __PYX_ERR(1, 777, __pyx_L1_error) + __pyx_ptype_5numpy_unsignedinteger = __Pyx_ImportType(__pyx_t_1, "numpy", "unsignedinteger", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_unsignedinteger) __PYX_ERR(1, 779, __pyx_L1_error) + __pyx_ptype_5numpy_inexact = __Pyx_ImportType(__pyx_t_1, "numpy", "inexact", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_inexact) __PYX_ERR(1, 781, __pyx_L1_error) + __pyx_ptype_5numpy_floating = __Pyx_ImportType(__pyx_t_1, "numpy", "floating", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_floating) __PYX_ERR(1, 783, __pyx_L1_error) + __pyx_ptype_5numpy_complexfloating = __Pyx_ImportType(__pyx_t_1, "numpy", "complexfloating", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_complexfloating) __PYX_ERR(1, 785, __pyx_L1_error) + __pyx_ptype_5numpy_flexible = __Pyx_ImportType(__pyx_t_1, "numpy", "flexible", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_flexible) __PYX_ERR(1, 787, __pyx_L1_error) + __pyx_ptype_5numpy_character = __Pyx_ImportType(__pyx_t_1, "numpy", "character", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_character) __PYX_ERR(1, 789, __pyx_L1_error) __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 764, __pyx_L1_error) + if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 827, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; @@ -4365,11 +4590,9 @@ if (!__Pyx_RefNanny) { #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ - #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS - #ifdef WITH_THREAD /* Python build with threading support? */ + #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS PyEval_InitThreads(); #endif - #endif /*--- Module creation code ---*/ #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_m = __pyx_pyinit_module; @@ -4527,12 +4750,12 @@ if (!__Pyx_RefNanny) { if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "../../../../opt/anaconda3/envs/py37/lib/python3.7/site-packages/numpy/__init__.pxd":892 - * raise ImportError("numpy.core.umath failed to import") + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1014 * - * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() + * + * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the unit part of the dtype for a numpy datetime64 object. */ /*--- Wrapped vars code ---*/ @@ -5509,7 +5732,7 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *result; - ternaryfunc call = func->ob_type->tp_call; + ternaryfunc call = Py_TYPE(func)->tp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) @@ -6373,7 +6596,14 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { - const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { @@ -6426,7 +6656,14 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { /* CIntFromPy */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { - const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { @@ -6615,7 +6852,14 @@ static void __Pyx_ReleaseBuffer(Py_buffer *view) { /* CIntFromPy */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { - const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { diff --git a/python/tests/test_fit.py b/python/tests/test_fit.py new file mode 100644 index 0000000..de734aa --- /dev/null +++ b/python/tests/test_fit.py @@ -0,0 +1,9 @@ +import pytest + +import l0learn + + +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_X_checks(f): + with pytest.raises(ValueError): + f() \ No newline at end of file From 5120d6420f8abb3721adfa8307a1119518f065b3 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Sat, 20 Nov 2021 07:21:17 -0600 Subject: [PATCH 052/125] Update r.yml --- .github/workflows/r.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/r.yml b/.github/workflows/r.yml index 4d8849d..936632f 100644 --- a/.github/workflows/r.yml +++ b/.github/workflows/r.yml @@ -44,5 +44,5 @@ jobs: working-directory: R - name: Test coverage - run: covr::codecov() + run: covr::codecov(quiet = FALSE) shell: Rscript {0} From 07d9d7d1bbcb8a3006a721942887846c5de0f3a8 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Sun, 21 Nov 2021 08:00:11 -0600 Subject: [PATCH 053/125] bug fixes and test coverage for python fit / cvfit interface --- python/l0learn/interface.cpp | 10212 ++++++++++++++------------------- python/l0learn/interface.pyx | 585 +- python/tests/test_fit.py | 368 +- 3 files changed, 4987 insertions(+), 6178 deletions(-) diff --git a/python/l0learn/interface.cpp b/python/l0learn/interface.cpp index 3c3c3fd..f389a9e 100644 --- a/python/l0learn/interface.cpp +++ b/python/l0learn/interface.cpp @@ -1860,12 +1860,14 @@ static const char __pyx_k_L0[] = "L0"; static const char __pyx_k__5[] = "."; static const char __pyx_k_np[] = "np"; static const char __pyx_k_or[] = " or "; +static const char __pyx_k_Any[] = "Any"; static const char __pyx_k__18[] = "_"; static const char __pyx_k_all[] = "all"; static const char __pyx_k_any[] = "any"; static const char __pyx_k_arr[] = "arr"; static const char __pyx_k_fit[] = "fit"; static const char __pyx_k_inf[] = "inf"; +static const char __pyx_k_Dict[] = "Dict"; static const char __pyx_k_L0L1[] = "L0L1"; static const char __pyx_k_L0L2[] = "L0L2"; static const char __pyx_k_List[] = "List"; @@ -1887,6 +1889,7 @@ static const char __pyx_k_warn[] = "warn"; static const char __pyx_k_CDPSI[] = "CDPSI"; static const char __pyx_k_Union[] = "Union"; static const char __pyx_k_array[] = "array"; +static const char __pyx_k_check[] = "check"; static const char __pyx_k_cvfit[] = "cvfit"; static const char __pyx_k_dtype[] = "dtype"; static const char __pyx_k_flags[] = "flags"; @@ -1895,6 +1898,7 @@ static const char __pyx_k_highs[] = "highs"; static const char __pyx_k_numpy[] = "numpy"; static const char __pyx_k_range[] = "range"; static const char __pyx_k_shape[] = "shape"; +static const char __pyx_k_astype[] = "astype"; static const char __pyx_k_c_loss[] = "c_loss"; static const char __pyx_k_coeffs[] = "coeffs"; static const char __pyx_k_cv_sds[] = "cv_sds"; @@ -1905,7 +1909,9 @@ static const char __pyx_k_typing[] = "typing"; static const char __pyx_k_unique[] = "unique"; static const char __pyx_k_but_got[] = ", but got "; static const char __pyx_k_current[] = "current"; +static const char __pyx_k_float64[] = "float64"; static const char __pyx_k_indices[] = "indices"; +static const char __pyx_k_l0learn[] = "l0learn"; static const char __pyx_k_ndarray[] = "ndarray"; static const char __pyx_k_penalty[] = "penalty"; static const char __pyx_k_product[] = "product"; @@ -1925,6 +1931,7 @@ static const char __pyx_k_c_penalty[] = "c_penalty"; static const char __pyx_k_c_results[] = "c_results"; static const char __pyx_k_converged[] = "converged"; static const char __pyx_k_enumerate[] = "enumerate"; +static const char __pyx_k_fit_check[] = "_fit_check"; static const char __pyx_k_gamma_max[] = "gamma_max"; static const char __pyx_k_gamma_min[] = "gamma_min"; static const char __pyx_k_intercept[] = "intercept"; @@ -1936,12 +1943,14 @@ static const char __pyx_k_CVFitModel[] = "CVFitModel"; static const char __pyx_k_ValueError[] = "ValueError"; static const char __pyx_k_active_set[] = "active_set"; static const char __pyx_k_bad_bounds[] = "bad_bounds"; +static const char __pyx_k_contiguous[] = "contiguous"; static const char __pyx_k_csc_matrix[] = "csc_matrix"; static const char __pyx_k_intercepts[] = "intercepts"; static const char __pyx_k_issubdtype[] = "issubdtype"; static const char __pyx_k_num_lambda[] = "num_lambda"; static const char __pyx_k_ImportError[] = "ImportError"; static const char __pyx_k_auto_lambda[] = "auto_lambda"; +static const char __pyx_k_first_value[] = "first_value"; static const char __pyx_k_lambda_grid[] = "lambda_grid"; static const char __pyx_k_screen_size[] = "screen_size"; static const char __pyx_k_with_bounds[] = "with_bounds"; @@ -1951,6 +1960,7 @@ static const char __pyx_k_SquaredHinge[] = "SquaredHinge"; static const char __pyx_k_c_algorithim[] = "c_algorithim"; static const char __pyx_k_partial_sort[] = "partial_sort"; static const char __pyx_k_scipy_sparse[] = "scipy.sparse"; +static const char __pyx_k_second_value[] = "second_value"; static const char __pyx_k_support_size[] = "support_size"; static const char __pyx_k_unique_items[] = "unique_items"; static const char __pyx_k_Not_supported[] = ". Not supported"; @@ -1978,6 +1988,7 @@ static const char __pyx_k_expected_arr_to_be_of_type[] = "expected arr to be of static const char __pyx_k_where_that_is_not_the_case[] = " where that is not the case "; static const char __pyx_k_containing_a_negative_value[] = "] containing a negative value"; static const char __pyx_k_containing_an_increasing_value[] = "] containing an increasing value."; +static const char __pyx_k_expected_y_vector_to_have_type[] = "expected y vector to have type "; static const char __pyx_k_of_non_negative_floats_but_got[] = " of non-negative floats, but got "; static const char __pyx_k_Expected_each_element_of_lambda[] = "Expected each element of lambda_grid to be a list of decreasing value, but got lambda_grid["; static const char __pyx_k_L0_Penalty_requires_lambda_grid[] = "L0 Penalty requires 'lambda_grid' to be a list of length 1, but got "; @@ -1986,12 +1997,12 @@ static const char __pyx_k_expected_arr_to_be_F_CONTIGUOUS[] = "expected arr to b static const char __pyx_k_expected_gamma_max_parameter_to[] = "expected gamma_max parameter to be a positive float, but got "; static const char __pyx_k_expected_intercept_parameter_to[] = "expected intercept parameter to be a bool, but got "; static const char __pyx_k_expected_max_swaps_parameter_to[] = "expected max_swaps parameter to be a positive integer, but got "; -static const char __pyx_k_expected_num_folds_parameter_to[] = "expected num_folds parameter to be a integer greater than 2, but got "; +static const char __pyx_k_expected_num_folds_parameter_to[] = "expected num_folds parameter to be a positive integer less than "; static const char __pyx_k_expected_partial_sort_parameter[] = "expected partial_sort parameter to be a bool, but got "; static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import"; static const char __pyx_k_of_non_positives_floats_but_got[] = " of non-positives floats, but got "; static const char __pyx_k_Expected_all_values_of_lambda_gr[] = "Expected all values of lambda_grid to be positive, but got lambda_grid["; -static const char __pyx_k_expected_X_to_be_a_2D_non_degene[] = "expected X to be a 2D non-degenerate real numpy or csc_matrix, but got "; +static const char __pyx_k_expected_X_to_be_a_2D_continuous[] = "expected X to be a 2D continuous non-degenerate real numpy or csc_matrix, but got "; static const char __pyx_k_expected_active_set_num_paramete[] = "expected active_set_num parameter to be a positive integer, but got "; static const char __pyx_k_expected_active_set_parameter_to[] = "expected active_set parameter to be a bool, but got "; static const char __pyx_k_expected_arr_data_to_be_F_CONTIG[] = "expected arr.data to be F_CONTIGUOUS."; @@ -2006,7 +2017,7 @@ static const char __pyx_k_expected_lambda_grid_to_of_lengt[] = "expected lambda_ static const char __pyx_k_expected_loss_parameter_to_be_on[] = "expected loss parameter to be on of "; static const char __pyx_k_expected_lows_to_be_a_non_positi[] = "expected lows to be a non-positive float, but got "; static const char __pyx_k_expected_max_iter_parameter_to_b[] = "expected max_iter parameter to be a positive integer, but got "; -static const char __pyx_k_expected_max_support_size_parame[] = "expected max_support_size parameter to be a positive integer less than "; +static const char __pyx_k_expected_max_support_size_parame[] = "expected max_support_size parameter to be a positive integer, but got "; static const char __pyx_k_expected_non_complex_dtype_but_g[] = "expected non-complex dtype, but got "; static const char __pyx_k_expected_non_degenerate_dimensio[] = "expected non-degenerate dimensions of arr, but got "; static const char __pyx_k_expected_num_gamma_to_1_when_pen[] = "expected num_gamma to 1 when penalty = 'L0', but got "; @@ -2018,8 +2029,7 @@ static const char __pyx_k_expected_numerical_dtype_but_got[] = "expected numeric static const char __pyx_k_expected_penalty_parameter_to_be[] = "expected penalty parameter to be on of "; static const char __pyx_k_expected_rtol_parameter_to_exist[] = "expected rtol parameter to exist in [0, 1), but got "; static const char __pyx_k_expected_scale_down_factor_param[] = "expected scale_down_factor parameter to exist in (0, 1), but got "; -static const char __pyx_k_expected_screen_size_parameter_t[] = "expected screen_size parameter to be a positive integer less than "; -static const char __pyx_k_expected_seed_parameter_to_be_an[] = "expected seed parameter to be an integer, but got "; +static const char __pyx_k_expected_screen_size_parameter_t[] = "expected screen_size parameter to be a positive integer, but got "; static const char __pyx_k_expected_to_be_high_to_be_elemen[] = "expected to be high to be elementwise greater than lows, but got indices "; static const char __pyx_k_expected_y_to_be_a_1D_real_numpy[] = "expected y to be a 1D real numpy, but got "; static const char __pyx_k_expected_y_vector_to_only_have_t[] = "expected y vector to only have two unique values (Binary Classification), but got "; @@ -2028,11 +2038,12 @@ static const char __pyx_k_expected_gamma_max_parameter_to_2[] = "expected gamma_ static const char __pyx_k_expected_arr_ndim_to_be_1_or_2_b_2[] = "expected 'arr.ndim' to be 1 or 2, but got "; static const char __pyx_k_expected_highs_to_be_a_non_negat_2[] = "expected highs to be a non-negative float, or a 1D numpy array of length "; static const char __pyx_k_expected_lows_to_be_a_non_positi_2[] = "expected lows to be a non-positive float, or a 1D numpy array of length "; -static const char __pyx_k_expected_screen_size_parameter_t_2[] = "expected screen_size parameter to be a positive integer, but got "; +static PyObject *__pyx_n_s_Any; static PyObject *__pyx_n_u_CD; static PyObject *__pyx_n_u_CDPSI; static PyObject *__pyx_n_s_CLASSIFICATION_LOSS; static PyObject *__pyx_n_s_CVFitModel; +static PyObject *__pyx_n_s_Dict; static PyObject *__pyx_kp_u_Expected_all_values_of_lambda_gr; static PyObject *__pyx_kp_u_Expected_each_element_of_lambda; static PyObject *__pyx_n_u_F_CONTIGUOUS; @@ -2068,8 +2079,10 @@ static PyObject *__pyx_n_s_any; static PyObject *__pyx_n_s_argwhere; static PyObject *__pyx_n_s_arr; static PyObject *__pyx_n_s_array; +static PyObject *__pyx_n_s_astype; static PyObject *__pyx_n_s_atol; static PyObject *__pyx_n_s_auto_lambda; +static PyObject *__pyx_n_u_auto_lambda; static PyObject *__pyx_n_s_bad_bounds; static PyObject *__pyx_n_s_bad_lambda_grid; static PyObject *__pyx_kp_u_but_got; @@ -2078,10 +2091,12 @@ static PyObject *__pyx_n_s_c_lambda_grid; static PyObject *__pyx_n_s_c_loss; static PyObject *__pyx_n_s_c_penalty; static PyObject *__pyx_n_s_c_results; +static PyObject *__pyx_n_s_check; static PyObject *__pyx_n_s_cline_in_traceback; static PyObject *__pyx_n_s_coeffs; static PyObject *__pyx_kp_u_containing_a_negative_value; static PyObject *__pyx_kp_u_containing_an_increasing_value; +static PyObject *__pyx_n_s_contiguous; static PyObject *__pyx_n_s_converged; static PyObject *__pyx_n_s_copy; static PyObject *__pyx_n_s_csc_matrix; @@ -2094,7 +2109,7 @@ static PyObject *__pyx_n_s_diff; static PyObject *__pyx_n_s_dtype; static PyObject *__pyx_n_s_enumerate; static PyObject *__pyx_n_s_exclude_first_k; -static PyObject *__pyx_kp_u_expected_X_to_be_a_2D_non_degene; +static PyObject *__pyx_kp_u_expected_X_to_be_a_2D_continuous; static PyObject *__pyx_kp_u_expected_active_set_num_paramete; static PyObject *__pyx_kp_u_expected_active_set_parameter_to; static PyObject *__pyx_kp_u_expected_algorithm_parameter_to; @@ -2134,17 +2149,22 @@ static PyObject *__pyx_kp_u_expected_penalty_parameter_to_be; static PyObject *__pyx_kp_u_expected_rtol_parameter_to_exist; static PyObject *__pyx_kp_u_expected_scale_down_factor_param; static PyObject *__pyx_kp_u_expected_screen_size_parameter_t; -static PyObject *__pyx_kp_u_expected_screen_size_parameter_t_2; -static PyObject *__pyx_kp_u_expected_seed_parameter_to_be_an; static PyObject *__pyx_kp_u_expected_to_be_high_to_be_elemen; static PyObject *__pyx_kp_u_expected_y_to_be_a_1D_real_numpy; +static PyObject *__pyx_kp_u_expected_y_vector_to_have_type; static PyObject *__pyx_kp_u_expected_y_vector_to_only_have_t; +static PyObject *__pyx_n_s_first_value; static PyObject *__pyx_n_s_fit; +static PyObject *__pyx_n_s_fit_check; static PyObject *__pyx_n_s_flags; +static PyObject *__pyx_n_s_float64; static PyObject *__pyx_n_s_gamma; static PyObject *__pyx_n_s_gamma_max; +static PyObject *__pyx_n_u_gamma_max; static PyObject *__pyx_n_s_gamma_min; +static PyObject *__pyx_n_u_gamma_min; static PyObject *__pyx_n_s_highs; +static PyObject *__pyx_n_u_highs; static PyObject *__pyx_n_s_i; static PyObject *__pyx_n_s_import; static PyObject *__pyx_n_s_indices; @@ -2155,17 +2175,21 @@ static PyObject *__pyx_n_u_intercept; static PyObject *__pyx_n_s_intercepts; static PyObject *__pyx_n_s_isrealobj; static PyObject *__pyx_n_s_issubdtype; +static PyObject *__pyx_n_s_l0learn; static PyObject *__pyx_n_s_l0learn_interface; static PyObject *__pyx_kp_s_l0learn_interface_pyx; static PyObject *__pyx_n_s_l0learn_models; static PyObject *__pyx_n_s_lambda_0; static PyObject *__pyx_n_s_lambda_grid; +static PyObject *__pyx_n_u_lambda_grid; static PyObject *__pyx_n_s_loss; static PyObject *__pyx_n_u_loss; static PyObject *__pyx_n_s_lows; +static PyObject *__pyx_n_u_lows; static PyObject *__pyx_n_s_main; static PyObject *__pyx_n_s_max_iter; static PyObject *__pyx_n_s_max_support_size; +static PyObject *__pyx_n_u_max_support_size; static PyObject *__pyx_n_s_max_swaps; static PyObject *__pyx_n_s_n; static PyObject *__pyx_n_s_name; @@ -2175,8 +2199,10 @@ static PyObject *__pyx_n_s_np; static PyObject *__pyx_n_s_np_to_arma_check; static PyObject *__pyx_n_s_num_folds; static PyObject *__pyx_n_s_num_gamma; +static PyObject *__pyx_n_u_num_gamma; static PyObject *__pyx_kp_u_num_gamma_set_to_1_with; static PyObject *__pyx_n_s_num_lambda; +static PyObject *__pyx_n_u_num_lambda; static PyObject *__pyx_n_s_number; static PyObject *__pyx_n_s_numpy; static PyObject *__pyx_kp_u_numpy_core_multiarray_failed_to; @@ -2198,6 +2224,8 @@ static PyObject *__pyx_n_s_rtol; static PyObject *__pyx_n_s_scale_down_factor; static PyObject *__pyx_n_s_scipy_sparse; static PyObject *__pyx_n_s_screen_size; +static PyObject *__pyx_n_u_screen_size; +static PyObject *__pyx_n_s_second_value; static PyObject *__pyx_n_s_seed; static PyObject *__pyx_n_s_settings; static PyObject *__pyx_n_s_shape; @@ -2211,11 +2239,16 @@ static PyObject *__pyx_n_s_warn; static PyObject *__pyx_n_s_warnings; static PyObject *__pyx_kp_u_where_that_is_not_the_case; static PyObject *__pyx_n_s_with_bounds; +static PyObject *__pyx_n_u_with_bounds; static PyObject *__pyx_n_s_y; +static PyObject *__pyx_n_u_y; static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_arr); /* proto */ -static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs); /* proto */ -static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_num_folds, PyObject *__pyx_v_seed, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs); /* proto */ +static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs); /* proto */ +static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs); /* proto */ +static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_num_folds, PyObject *__pyx_v_seed, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs); /* proto */ static PyObject *__pyx_float_0_; +static PyObject *__pyx_float_1_0; +static PyObject *__pyx_float_neg_1_0; static PyObject *__pyx_int_0; static PyObject *__pyx_int_1; static PyObject *__pyx_int_2; @@ -2224,7 +2257,6 @@ static PyObject *__pyx_int_10; static PyObject *__pyx_int_100; static PyObject *__pyx_int_200; static PyObject *__pyx_int_1000; -static PyObject *__pyx_int_neg_1; static PyObject *__pyx_k__7; static PyObject *__pyx_k__8; static PyObject *__pyx_k__9; @@ -2242,12 +2274,14 @@ static PyObject *__pyx_tuple__16; static PyObject *__pyx_tuple__17; static PyObject *__pyx_tuple__19; static PyObject *__pyx_tuple__21; +static PyObject *__pyx_tuple__23; static PyObject *__pyx_codeobj__14; static PyObject *__pyx_codeobj__20; static PyObject *__pyx_codeobj__22; +static PyObject *__pyx_codeobj__24; /* Late includes */ -/* "l0learn/interface.pyx":15 +/* "l0learn/interface.pyx":16 * from l0learn.models import FitModel, CVFitModel * * def np_to_arma_check(arr): # <<<<<<<<<<<<<< @@ -2289,54 +2323,54 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO int __pyx_clineno = 0; __Pyx_RefNannySetupContext("np_to_arma_check", 0); - /* "l0learn/interface.pyx":17 + /* "l0learn/interface.pyx":18 * def np_to_arma_check(arr): * # TODO: Add checks for Behaved and OwnsData * if isinstance(arr, np.ndarray): # <<<<<<<<<<<<<< * if not arr.flags['F_CONTIGUOUS']: * raise ValueError("expected arr to be F_CONTIGUOUS.") */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 18, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 17, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = PyObject_IsInstance(__pyx_v_arr, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 17, __pyx_L1_error) + __pyx_t_3 = PyObject_IsInstance(__pyx_v_arr, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 18, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { - /* "l0learn/interface.pyx":18 + /* "l0learn/interface.pyx":19 * # TODO: Add checks for Behaved and OwnsData * if isinstance(arr, np.ndarray): * if not arr.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< * raise ValueError("expected arr to be F_CONTIGUOUS.") * elif isinstance(arr, csc_matrix): */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_n_u_F_CONTIGUOUS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 18, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_n_u_F_CONTIGUOUS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 18, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = ((!__pyx_t_4) != 0); if (unlikely(__pyx_t_3)) { - /* "l0learn/interface.pyx":19 + /* "l0learn/interface.pyx":20 * if isinstance(arr, np.ndarray): * if not arr.flags['F_CONTIGUOUS']: * raise ValueError("expected arr to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< * elif isinstance(arr, csc_matrix): * if not arr.data.flags['F_CONTIGUOUS']: */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 20, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(0, 19, __pyx_L1_error) + __PYX_ERR(0, 20, __pyx_L1_error) - /* "l0learn/interface.pyx":18 + /* "l0learn/interface.pyx":19 * # TODO: Add checks for Behaved and OwnsData * if isinstance(arr, np.ndarray): * if not arr.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< @@ -2345,7 +2379,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO */ } - /* "l0learn/interface.pyx":17 + /* "l0learn/interface.pyx":18 * def np_to_arma_check(arr): * # TODO: Add checks for Behaved and OwnsData * if isinstance(arr, np.ndarray): # <<<<<<<<<<<<<< @@ -2355,54 +2389,54 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO goto __pyx_L3; } - /* "l0learn/interface.pyx":20 + /* "l0learn/interface.pyx":21 * if not arr.flags['F_CONTIGUOUS']: * raise ValueError("expected arr to be F_CONTIGUOUS.") * elif isinstance(arr, csc_matrix): # <<<<<<<<<<<<<< * if not arr.data.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.data to be F_CONTIGUOUS.") */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = PyObject_IsInstance(__pyx_v_arr, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 20, __pyx_L1_error) + __pyx_t_3 = PyObject_IsInstance(__pyx_v_arr, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 21, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_4 = (__pyx_t_3 != 0); if (likely(__pyx_t_4)) { - /* "l0learn/interface.pyx":21 + /* "l0learn/interface.pyx":22 * raise ValueError("expected arr to be F_CONTIGUOUS.") * elif isinstance(arr, csc_matrix): * if not arr.data.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< * raise ValueError("expected arr.data to be F_CONTIGUOUS.") * if not arr.indices.flags['F_CONTIGUOUS']: */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 21, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_n_u_F_CONTIGUOUS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_n_u_F_CONTIGUOUS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 21, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 22, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = ((!__pyx_t_4) != 0); if (unlikely(__pyx_t_3)) { - /* "l0learn/interface.pyx":22 + /* "l0learn/interface.pyx":23 * elif isinstance(arr, csc_matrix): * if not arr.data.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.data to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< * if not arr.indices.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 23, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(0, 22, __pyx_L1_error) + __PYX_ERR(0, 23, __pyx_L1_error) - /* "l0learn/interface.pyx":21 + /* "l0learn/interface.pyx":22 * raise ValueError("expected arr to be F_CONTIGUOUS.") * elif isinstance(arr, csc_matrix): * if not arr.data.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< @@ -2411,40 +2445,40 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO */ } - /* "l0learn/interface.pyx":23 + /* "l0learn/interface.pyx":24 * if not arr.data.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.data to be F_CONTIGUOUS.") * if not arr.indices.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") * if not arr.indptr.flags['F_CONTIGUOUS']: */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_indices); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 23, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_indices); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 24, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 23, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 24, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_n_u_F_CONTIGUOUS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 23, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_n_u_F_CONTIGUOUS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 24, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 23, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 24, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_4 = ((!__pyx_t_3) != 0); if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":24 + /* "l0learn/interface.pyx":25 * raise ValueError("expected arr.data to be F_CONTIGUOUS.") * if not arr.indices.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< * if not arr.indptr.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 24, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 25, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(0, 24, __pyx_L1_error) + __PYX_ERR(0, 25, __pyx_L1_error) - /* "l0learn/interface.pyx":23 + /* "l0learn/interface.pyx":24 * if not arr.data.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.data to be F_CONTIGUOUS.") * if not arr.indices.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< @@ -2453,40 +2487,40 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO */ } - /* "l0learn/interface.pyx":25 + /* "l0learn/interface.pyx":26 * if not arr.indices.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") * if not arr.indptr.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< * raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") * else: */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_indptr); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 25, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_indptr); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 26, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 25, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 26, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_n_u_F_CONTIGUOUS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 25, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_n_u_F_CONTIGUOUS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 26, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 25, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 26, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = ((!__pyx_t_4) != 0); if (unlikely(__pyx_t_3)) { - /* "l0learn/interface.pyx":26 + /* "l0learn/interface.pyx":27 * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") * if not arr.indptr.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< * else: * raise NotImplementedError(f"expected arr to be of type {np.ndarray} or {csc_matrix}, but got {type(arr)}.") */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 26, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 27, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(0, 26, __pyx_L1_error) + __PYX_ERR(0, 27, __pyx_L1_error) - /* "l0learn/interface.pyx":25 + /* "l0learn/interface.pyx":26 * if not arr.indices.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") * if not arr.indptr.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< @@ -2495,7 +2529,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO */ } - /* "l0learn/interface.pyx":20 + /* "l0learn/interface.pyx":21 * if not arr.flags['F_CONTIGUOUS']: * raise ValueError("expected arr to be F_CONTIGUOUS.") * elif isinstance(arr, csc_matrix): # <<<<<<<<<<<<<< @@ -2505,7 +2539,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO goto __pyx_L3; } - /* "l0learn/interface.pyx":28 + /* "l0learn/interface.pyx":29 * raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") * else: * raise NotImplementedError(f"expected arr to be of type {np.ndarray} or {csc_matrix}, but got {type(arr)}.") # <<<<<<<<<<<<<< @@ -2513,7 +2547,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO * if arr.ndim == 0: */ /*else*/ { - __pyx_t_1 = PyTuple_New(7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 28, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 29, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = 0; __pyx_t_6 = 127; @@ -2521,12 +2555,12 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO __pyx_t_5 += 27; __Pyx_GIVEREF(__pyx_kp_u_expected_arr_to_be_of_type); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_expected_arr_to_be_of_type); - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 28, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 29, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 28, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 29, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 28, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 29, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_6 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_6) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_6; @@ -2538,9 +2572,9 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO __pyx_t_5 += 4; __Pyx_GIVEREF(__pyx_kp_u_or); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_or); - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 28, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 29, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 28, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 29, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_6 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_6) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_6; @@ -2552,7 +2586,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO __pyx_t_5 += 10; __Pyx_GIVEREF(__pyx_kp_u_but_got); PyTuple_SET_ITEM(__pyx_t_1, 4, __pyx_kp_u_but_got); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(((PyObject *)Py_TYPE(__pyx_v_arr)), __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 28, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_FormatSimple(((PyObject *)Py_TYPE(__pyx_v_arr)), __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 29, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_6 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_6) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_6; __pyx_t_5 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); @@ -2563,48 +2597,48 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO __pyx_t_5 += 1; __Pyx_GIVEREF(__pyx_kp_u__5); PyTuple_SET_ITEM(__pyx_t_1, 6, __pyx_kp_u__5); - __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_1, 7, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 28, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_1, 7, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 29, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_NotImplementedError, __pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 28, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_NotImplementedError, __pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 29, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(0, 28, __pyx_L1_error) + __PYX_ERR(0, 29, __pyx_L1_error) } __pyx_L3:; - /* "l0learn/interface.pyx":30 + /* "l0learn/interface.pyx":31 * raise NotImplementedError(f"expected arr to be of type {np.ndarray} or {csc_matrix}, but got {type(arr)}.") * * if arr.ndim == 0: # <<<<<<<<<<<<<< * raise ValueError("expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar") * elif arr.ndim > 2: */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 30, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 31, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_7 = __Pyx_PyInt_EqObjC(__pyx_t_1, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 30, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_EqObjC(__pyx_t_1, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 31, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 30, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 31, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(__pyx_t_3)) { - /* "l0learn/interface.pyx":31 + /* "l0learn/interface.pyx":32 * * if arr.ndim == 0: * raise ValueError("expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar") # <<<<<<<<<<<<<< * elif arr.ndim > 2: * raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") */ - __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 31, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 32, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 31, __pyx_L1_error) + __PYX_ERR(0, 32, __pyx_L1_error) - /* "l0learn/interface.pyx":30 + /* "l0learn/interface.pyx":31 * raise NotImplementedError(f"expected arr to be of type {np.ndarray} or {csc_matrix}, but got {type(arr)}.") * * if arr.ndim == 0: # <<<<<<<<<<<<<< @@ -2613,29 +2647,29 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO */ } - /* "l0learn/interface.pyx":32 + /* "l0learn/interface.pyx":33 * if arr.ndim == 0: * raise ValueError("expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar") * elif arr.ndim > 2: # <<<<<<<<<<<<<< * raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") * */ - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 32, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 33, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_1 = PyObject_RichCompare(__pyx_t_7, __pyx_int_2, Py_GT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 32, __pyx_L1_error) + __pyx_t_1 = PyObject_RichCompare(__pyx_t_7, __pyx_int_2, Py_GT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 32, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 33, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(__pyx_t_3)) { - /* "l0learn/interface.pyx":33 + /* "l0learn/interface.pyx":34 * raise ValueError("expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar") * elif arr.ndim > 2: * raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") # <<<<<<<<<<<<<< * * if np.product(arr.shape) == 0: */ - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 34, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = 0; __pyx_t_6 = 127; @@ -2643,9 +2677,9 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO __pyx_t_5 += 42; __Pyx_GIVEREF(__pyx_kp_u_expected_arr_ndim_to_be_1_or_2_b_2); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_expected_arr_ndim_to_be_1_or_2_b_2); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 33, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 34, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 33, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 34, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_6 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_6) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_6; @@ -2657,17 +2691,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO __pyx_t_5 += 15; __Pyx_GIVEREF(__pyx_kp_u_Not_supported); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_Not_supported); - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_1, 3, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 33, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_1, 3, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 34, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_NotImplementedError, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_NotImplementedError, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 34, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(0, 33, __pyx_L1_error) + __PYX_ERR(0, 34, __pyx_L1_error) - /* "l0learn/interface.pyx":32 + /* "l0learn/interface.pyx":33 * if arr.ndim == 0: * raise ValueError("expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar") * elif arr.ndim > 2: # <<<<<<<<<<<<<< @@ -2676,19 +2710,19 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO */ } - /* "l0learn/interface.pyx":35 + /* "l0learn/interface.pyx":36 * raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") * * if np.product(arr.shape) == 0: # <<<<<<<<<<<<<< * raise ValueError(f"expected non-degenerate dimensions of arr, but got {arr.ndim}") * */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 35, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 36, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_product); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 35, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_product); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 36, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 35, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 36, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_8 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { @@ -2703,39 +2737,39 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO __pyx_t_1 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_2); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 35, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 36, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyInt_EqObjC(__pyx_t_1, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 35, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_EqObjC(__pyx_t_1, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 36, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 35, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 36, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(__pyx_t_3)) { - /* "l0learn/interface.pyx":36 + /* "l0learn/interface.pyx":37 * * if np.product(arr.shape) == 0: * raise ValueError(f"expected non-degenerate dimensions of arr, but got {arr.ndim}") # <<<<<<<<<<<<<< * * if not np.issubdtype(arr.dtype, np.number): */ - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 36, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 37, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 36, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 37, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_non_degenerate_dimensio, __pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 36, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_non_degenerate_dimensio, __pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 37, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 36, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 37, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(0, 36, __pyx_L1_error) + __PYX_ERR(0, 37, __pyx_L1_error) - /* "l0learn/interface.pyx":35 + /* "l0learn/interface.pyx":36 * raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") * * if np.product(arr.shape) == 0: # <<<<<<<<<<<<<< @@ -2744,23 +2778,23 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO */ } - /* "l0learn/interface.pyx":38 + /* "l0learn/interface.pyx":39 * raise ValueError(f"expected non-degenerate dimensions of arr, but got {arr.ndim}") * * if not np.issubdtype(arr.dtype, np.number): # <<<<<<<<<<<<<< * raise ValueError(f"expected numerical dtype, but got {arr.dtype}") * */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 38, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 39, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_issubdtype); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 38, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_issubdtype); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 39, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_dtype); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 38, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_dtype); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 39, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 38, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 39, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_number); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 38, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_number); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 39, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; @@ -2778,7 +2812,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_7, __pyx_t_9}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 38, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 39, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; @@ -2788,7 +2822,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_7, __pyx_t_9}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 38, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 39, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; @@ -2796,7 +2830,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO } else #endif { - __pyx_t_11 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 38, __pyx_L1_error) + __pyx_t_11 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 39, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_8); __pyx_t_8 = NULL; @@ -2807,39 +2841,39 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_10, __pyx_t_9); __pyx_t_7 = 0; __pyx_t_9 = 0; - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 38, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 39, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 38, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 39, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_4 = ((!__pyx_t_3) != 0); if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":39 + /* "l0learn/interface.pyx":40 * * if not np.issubdtype(arr.dtype, np.number): * raise ValueError(f"expected numerical dtype, but got {arr.dtype}") # <<<<<<<<<<<<<< * * if not np.isrealobj(arr): */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 39, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 40, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_1, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 39, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_1, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 40, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_numerical_dtype_but_got, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 39, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_numerical_dtype_but_got, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 40, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 39, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 40, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 39, __pyx_L1_error) + __PYX_ERR(0, 40, __pyx_L1_error) - /* "l0learn/interface.pyx":38 + /* "l0learn/interface.pyx":39 * raise ValueError(f"expected non-degenerate dimensions of arr, but got {arr.ndim}") * * if not np.issubdtype(arr.dtype, np.number): # <<<<<<<<<<<<<< @@ -2848,16 +2882,16 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO */ } - /* "l0learn/interface.pyx":41 + /* "l0learn/interface.pyx":42 * raise ValueError(f"expected numerical dtype, but got {arr.dtype}") * * if not np.isrealobj(arr): # <<<<<<<<<<<<<< * raise ValueError(f"expected non-complex dtype, but got {arr.dtype}") * */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 41, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 42, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 41, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 42, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = NULL; @@ -2872,37 +2906,37 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO } __pyx_t_2 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_1, __pyx_v_arr) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_v_arr); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 41, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 41, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 42, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_3 = ((!__pyx_t_4) != 0); if (unlikely(__pyx_t_3)) { - /* "l0learn/interface.pyx":42 + /* "l0learn/interface.pyx":43 * * if not np.isrealobj(arr): * raise ValueError(f"expected non-complex dtype, but got {arr.dtype}") # <<<<<<<<<<<<<< * * */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_dtype); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_dtype); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 43, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_11 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 42, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 43, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_non_complex_dtype_but_g, __pyx_t_11); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_non_complex_dtype_but_g, __pyx_t_11); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 43, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __pyx_t_11 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 42, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 43, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_11, 0, 0, 0); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __PYX_ERR(0, 42, __pyx_L1_error) + __PYX_ERR(0, 43, __pyx_L1_error) - /* "l0learn/interface.pyx":41 + /* "l0learn/interface.pyx":42 * raise ValueError(f"expected numerical dtype, but got {arr.dtype}") * * if not np.isrealobj(arr): # <<<<<<<<<<<<<< @@ -2911,7 +2945,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO */ } - /* "l0learn/interface.pyx":15 + /* "l0learn/interface.pyx":16 * from l0learn.models import FitModel, CVFitModel * * def np_to_arma_check(arr): # <<<<<<<<<<<<<< @@ -2937,19 +2971,19 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO return __pyx_r; } -/* "l0learn/interface.pyx":50 - * SUPPORTED_ALGORITHM = ("CD", "CDPSI") +/* "l0learn/interface.pyx":52 * - * def fit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< - * y: np.ndarray, - * loss: str = "SquaredHinge", + * + * def _fit_check(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< + * y: np.ndarray, + * loss: str, */ /* Python wrapper */ -static PyObject *__pyx_pw_7l0learn_9interface_3fit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_7l0learn_9interface_2fit[] = "fit(X: Union[np.ndarray, csc_matrix], y: np.ndarray, unicode loss: str = u'SquaredHinge', unicode penalty: str = u'L0', unicode algorithm: str = u'CD', max_support_size: int = 100, num_lambda: Optional[int] = 100, num_gamma: Optional[int] = 1, double gamma_max: float = 10., double gamma_min: float = .0001, partial_sort: bool = True, max_iter: int = 200, double rtol: float = 1e-6, double atol: float = 1e-9, active_set: bool = True, active_set_num: int = 3, max_swaps: int = 100, double scale_down_factor: float = 0.8, screen_size: int = 1000, lambda_grid: Optional[List[List[float]]] = None, exclude_first_k: int = 0, intercept: bool = True, lows: Union[np.ndarray, float] = -float(u'inf'), highs: Union[np.ndarray, float] = +float(u'inf'))\n\n Computes the regularization path for the specified loss function and penalty function.\n\n Parameters\n ----------\n X : np.ndarray or csc_matrix of shape (N, P)\n Data Matrix where rows of X are observations and columns of X are features\n\n y : np.ndarray of shape (P)\n The response vector where y[i] corresponds to X[i, :]\n For classification, a binary vector (-1, 1) is requried .\n\n loss : str\n The loss function. Currently supports the choices:\n \"SquaredError\" (for regression),\n \"Logistic\" (for logistic regression), and\n \"SquaredHinge\" (for smooth SVM).\n\n penalty : str\n The type of regularization.\n This can take either one of the following choices:\n \"L0\",\n \"L0L2\", and\n \"L0L1\"\n\n algorithm : str\n The type of algorithm used to minimize the objective function. Currently \"CD\" and \"CDPSI\" are are supported.\n \"CD\" is a variant of cyclic coordinate descent and runs very fast. \"CDPSI\" performs local combinatorial search\n on top of CD and typically achieves higher quality solutions (at the expense of increased running time).\n\n max_support_size : i""nt\n Must be greater than 0.\n The maximum support size at which to terminate the regularization path. We recommend setting this to a small\n fraction of min(n,p) (e.g. 0.05 * min(n,p)) as L0 regularization typically selects a small portion of non-zeros.\n\n num_lambda : int, optional\n The number of lambda values to select in the regularization path.\n This value must be None if lambda_grid is supplied.When supplied, must be greater than 0.\n Note: lambda is the regularization parameter corresponding to the L0 norm.\n\n num_gamma: int, optional\n The number of gamma values to select in the regularization path.\n This value must be None if lambda_grid is supplied. When supplied, must be greater than 0.\n Note: gamma is the regularization parameter corresponding to L1 or L2, depending on the chosen penalty).\n\n gamma_max : float\n The maximum value of gamma when using the L0L2 penalty.\n This value must be greater than 0.\n\n Note: For the L0L1 penalty this is automatically selected.\n\n gamma_min : float\n The minimum value of Gamma when using the L0L2 penalty.\n This value must be greater than 0 but less than gamma_max.\n Note: For the L0L1 penalty, the minimum value of gamma in the grid is set to gammaMin * gammaMax.\n\n partial_sort : bool\n If TRUE partial sorting will be used for sorting the coordinates to do greedy cycling (see our paper for\n for details). Otherwise, full sorting is used. #TODO: Add link for paper\n\n max_iter : int\n The maximum number of iterations (full cycles) for CD per grid point. The algorithm may not use the full number\n of iteration per grid point if convergence is found (defined by rtol and atol parameter)\n Must be greater than 0\n\n rtol : float\n The relative tolerance which decides when to terminate optimization as based on the relative change in the\n o""bjective between iterations.\n Must be greater than 0 and less than 1.\n\n atol : float\n The absolute tolerance which decides when to terminate optimization as based on the absolute L2 norm of the\n residuals\n Must be greater than 0\n\n active_set : bool\n If TRUE, performs active set updates. (see our paper for for details). #TODO: Add link for paper\n\n active_set_num : int\n The number of consecutive times a support should appear before declaring support stabilization.\n (see our paper for for details). #TODO: Add link for paper\n\n Must be greater than 0.\n\n max_swaps : int\n The maximum number of swaps used by CDPSI for each grid point.\n Must be greater than 0. Ignored by CD algorithims.\n\n scale_down_factor : float\n Roughly amount each lambda value is scaled by between grid points. Larger values lead to closer lambdas and\n typically to smaller gaps between the support sizes.\n\n For details, see our paper - Section 5 on Adaptive Selection of Tuning Parameters). #TODO: Add link for paper\n\n Must be greater than 0 and less than 1 (strictly for both.)\n\n screen_size : int\n The number of coordinates to cycle over when performing initial correlation screening. #TODO: Add link for paper\n\n Must be greater than 0 and less than number of columns of X.\n\n lambda_grid : list of list of floats\n A grid of lambda values to use in computing the regularization path. This is by default an empty list\n and is ignored. When specified, lambda_grid should be a list of list of floats, where the ith element\n (corresponding to the ith gamma) should be a decreasing sequence of lambda values. The length of this sequence\n is directly the number of lambdas to be tried for that gamma.\n\n In the the \"L0\" penalty case, lambda_grid should be a list of 1.\n In the \"L0LX\" penalty cases, lambda_grid ""can be a list of any length. The length of lambda_grid will be the\n number of gamma values tried.\n\n See the example notebook for more details.\n\n Note: When lambda_grid is supplied, num_gamma and num_lambda must be None.\n\n exclude_first_k : int\n The first exclude_first_k features in X will be excluded from variable selection. In other words, the first\n exclude_first_k variables will not be included in the L0-norm penalty however they will be included in the\n L1 or L2 norm penalties, if they are specified.\n\n Must be a positive integer less than the columns of X.\n\n intercept : bool\n If False, no intercept term is included or fit in the regularization path\n Intercept terms are not regularized by L0 or L1/L2.\n\n lows : np array or float\n Lower bounds for coefficients. Either a scalar for all coefficients to have the same bound or a vector of\n size p (number of columns of X) where lows[i] is the lower bound for coefficient i.\n\n Lower bounds can not be above 0 (i.e. we can not specify that all coefficients must be larger than a > 0).\n Lower bounds can be set to 0 iff the corresponding upper bound for that coefficient is also not 0.\n\n highs : np array or float\n Upper bounds for coefficients. Either a scalar for all coefficients to have the same bound or a vector of\n size p (number of columns of X) where highs[i] is the upper bound for coefficient i.\n\n Upper bounds can not be below 0 (i.e. we can not specify that all coefficients must be smaller than a < 0).\n Upper bounds can be set to 0 iff the corresponding looer bound for that coefficient is also not 0.\n\n Returns\n -------\n\n\n Examples\n --------\n "; -static PyMethodDef __pyx_mdef_7l0learn_9interface_3fit = {"fit", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7l0learn_9interface_3fit, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7l0learn_9interface_2fit}; -static PyObject *__pyx_pw_7l0learn_9interface_3fit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_7l0learn_9interface_3_fit_check(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_7l0learn_9interface_2_fit_check[] = "_fit_check(X: Union[np.ndarray, csc_matrix], y: np.ndarray, unicode loss: str, unicode penalty: str, unicode algorithm: str, max_support_size: int, num_lambda: Union[int, None], num_gamma: Union[int, None], double gamma_max: float, double gamma_min: float, partial_sort: bool, max_iter: int, double rtol: float, double atol: float, active_set: bool, active_set_num: int, max_swaps: int, double scale_down_factor: float, screen_size: int, lambda_grid: Union[List[List[float]], None], exclude_first_k: int, intercept: bool, lows: Union[np.ndarray, float], highs: Union[np.ndarray, float]) -> Dict[str, Any]"; +static PyMethodDef __pyx_mdef_7l0learn_9interface_3_fit_check = {"_fit_check", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7l0learn_9interface_3_fit_check, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7l0learn_9interface_2_fit_check}; +static PyObject *__pyx_pw_7l0learn_9interface_3_fit_check(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_X = 0; PyObject *__pyx_v_y = 0; PyObject *__pyx_v_loss = 0; @@ -2979,59 +3013,10 @@ static PyObject *__pyx_pw_7l0learn_9interface_3fit(PyObject *__pyx_self, PyObjec int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("fit (wrapper)", 0); + __Pyx_RefNannySetupContext("_fit_check (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_X,&__pyx_n_s_y,&__pyx_n_s_loss,&__pyx_n_s_penalty,&__pyx_n_s_algorithm,&__pyx_n_s_max_support_size,&__pyx_n_s_num_lambda,&__pyx_n_s_num_gamma,&__pyx_n_s_gamma_max,&__pyx_n_s_gamma_min,&__pyx_n_s_partial_sort,&__pyx_n_s_max_iter,&__pyx_n_s_rtol,&__pyx_n_s_atol,&__pyx_n_s_active_set,&__pyx_n_s_active_set_num,&__pyx_n_s_max_swaps,&__pyx_n_s_scale_down_factor,&__pyx_n_s_screen_size,&__pyx_n_s_lambda_grid,&__pyx_n_s_exclude_first_k,&__pyx_n_s_intercept,&__pyx_n_s_lows,&__pyx_n_s_highs,0}; PyObject* values[24] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; - values[2] = ((PyObject*)__pyx_n_u_SquaredHinge); - values[3] = ((PyObject*)__pyx_n_u_L0); - values[4] = ((PyObject*)__pyx_n_u_CD); - values[5] = ((PyObject *)__pyx_int_100); - values[6] = ((PyObject *)__pyx_int_100); - values[7] = ((PyObject *)__pyx_int_1); - - /* "l0learn/interface.pyx":60 - * gamma_max: float = 10., - * gamma_min: float = .0001, - * partial_sort: bool = True, # <<<<<<<<<<<<<< - * max_iter: int = 200, - * rtol: float = 1e-6, - */ - values[10] = ((PyObject *)Py_True); - values[11] = ((PyObject *)__pyx_int_200); - - /* "l0learn/interface.pyx":64 - * rtol: float = 1e-6, - * atol: float = 1e-9, - * active_set: bool = True, # <<<<<<<<<<<<<< - * active_set_num: int = 3, - * max_swaps: int = 100, - */ - values[14] = ((PyObject *)Py_True); - values[15] = ((PyObject *)__pyx_int_3); - values[16] = ((PyObject *)__pyx_int_100); - values[18] = ((PyObject *)__pyx_int_1000); - - /* "l0learn/interface.pyx":69 - * scale_down_factor: float = 0.8, - * screen_size: int = 1000, - * lambda_grid: Optional[List[List[float]]] = None, # <<<<<<<<<<<<<< - * exclude_first_k: int = 0, - * intercept: bool = True, - */ - values[19] = ((PyObject *)Py_None); - values[20] = ((PyObject *)__pyx_int_0); - - /* "l0learn/interface.pyx":71 - * lambda_grid: Optional[List[List[float]]] = None, - * exclude_first_k: int = 0, - * intercept: bool = True, # <<<<<<<<<<<<<< - * lows: Union[np.ndarray, float] = -float('inf'), - * highs: Union[np.ndarray, float] = +float('inf'),): - */ - values[21] = ((PyObject *)Py_True); - values[22] = __pyx_k__7; - values[23] = __pyx_k__8; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); @@ -3096,195 +3081,171 @@ static PyObject *__pyx_pw_7l0learn_9interface_3fit(PyObject *__pyx_self, PyObjec case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("fit", 0, 2, 24, 1); __PYX_ERR(0, 50, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("_fit_check", 1, 24, 24, 1); __PYX_ERR(0, 52, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_loss); - if (value) { values[2] = value; kw_args--; } + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_loss)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_fit_check", 1, 24, 24, 2); __PYX_ERR(0, 52, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_penalty); - if (value) { values[3] = value; kw_args--; } + if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_penalty)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_fit_check", 1, 24, 24, 3); __PYX_ERR(0, 52, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 4: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_algorithm); - if (value) { values[4] = value; kw_args--; } + if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_algorithm)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_fit_check", 1, 24, 24, 4); __PYX_ERR(0, 52, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 5: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_support_size); - if (value) { values[5] = value; kw_args--; } + if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_support_size)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_fit_check", 1, 24, 24, 5); __PYX_ERR(0, 52, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 6: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_num_lambda); - if (value) { values[6] = value; kw_args--; } + if (likely((values[6] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_num_lambda)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_fit_check", 1, 24, 24, 6); __PYX_ERR(0, 52, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 7: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_num_gamma); - if (value) { values[7] = value; kw_args--; } + if (likely((values[7] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_num_gamma)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_fit_check", 1, 24, 24, 7); __PYX_ERR(0, 52, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 8: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_gamma_max); - if (value) { values[8] = value; kw_args--; } + if (likely((values[8] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_gamma_max)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_fit_check", 1, 24, 24, 8); __PYX_ERR(0, 52, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 9: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_gamma_min); - if (value) { values[9] = value; kw_args--; } + if (likely((values[9] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_gamma_min)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_fit_check", 1, 24, 24, 9); __PYX_ERR(0, 52, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 10: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_partial_sort); - if (value) { values[10] = value; kw_args--; } + if (likely((values[10] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_partial_sort)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_fit_check", 1, 24, 24, 10); __PYX_ERR(0, 52, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 11: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_iter); - if (value) { values[11] = value; kw_args--; } + if (likely((values[11] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_iter)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_fit_check", 1, 24, 24, 11); __PYX_ERR(0, 52, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 12: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rtol); - if (value) { values[12] = value; kw_args--; } + if (likely((values[12] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rtol)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_fit_check", 1, 24, 24, 12); __PYX_ERR(0, 52, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 13: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_atol); - if (value) { values[13] = value; kw_args--; } + if (likely((values[13] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_atol)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_fit_check", 1, 24, 24, 13); __PYX_ERR(0, 52, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 14: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_active_set); - if (value) { values[14] = value; kw_args--; } + if (likely((values[14] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_active_set)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_fit_check", 1, 24, 24, 14); __PYX_ERR(0, 52, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 15: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_active_set_num); - if (value) { values[15] = value; kw_args--; } + if (likely((values[15] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_active_set_num)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_fit_check", 1, 24, 24, 15); __PYX_ERR(0, 52, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 16: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_swaps); - if (value) { values[16] = value; kw_args--; } + if (likely((values[16] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_swaps)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_fit_check", 1, 24, 24, 16); __PYX_ERR(0, 52, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 17: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_scale_down_factor); - if (value) { values[17] = value; kw_args--; } + if (likely((values[17] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_scale_down_factor)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_fit_check", 1, 24, 24, 17); __PYX_ERR(0, 52, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 18: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_screen_size); - if (value) { values[18] = value; kw_args--; } + if (likely((values[18] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_screen_size)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_fit_check", 1, 24, 24, 18); __PYX_ERR(0, 52, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 19: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_lambda_grid); - if (value) { values[19] = value; kw_args--; } + if (likely((values[19] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_lambda_grid)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_fit_check", 1, 24, 24, 19); __PYX_ERR(0, 52, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 20: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_exclude_first_k); - if (value) { values[20] = value; kw_args--; } + if (likely((values[20] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_exclude_first_k)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_fit_check", 1, 24, 24, 20); __PYX_ERR(0, 52, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 21: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_intercept); - if (value) { values[21] = value; kw_args--; } + if (likely((values[21] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_intercept)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_fit_check", 1, 24, 24, 21); __PYX_ERR(0, 52, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 22: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_lows); - if (value) { values[22] = value; kw_args--; } + if (likely((values[22] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_lows)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_fit_check", 1, 24, 24, 22); __PYX_ERR(0, 52, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 23: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_highs); - if (value) { values[23] = value; kw_args--; } + if (likely((values[23] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_highs)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("_fit_check", 1, 24, 24, 23); __PYX_ERR(0, 52, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fit") < 0)) __PYX_ERR(0, 50, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_fit_check") < 0)) __PYX_ERR(0, 52, __pyx_L3_error) } + } else if (PyTuple_GET_SIZE(__pyx_args) != 24) { + goto __pyx_L5_argtuple_error; } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 24: values[23] = PyTuple_GET_ITEM(__pyx_args, 23); - CYTHON_FALLTHROUGH; - case 23: values[22] = PyTuple_GET_ITEM(__pyx_args, 22); - CYTHON_FALLTHROUGH; - case 22: values[21] = PyTuple_GET_ITEM(__pyx_args, 21); - CYTHON_FALLTHROUGH; - case 21: values[20] = PyTuple_GET_ITEM(__pyx_args, 20); - CYTHON_FALLTHROUGH; - case 20: values[19] = PyTuple_GET_ITEM(__pyx_args, 19); - CYTHON_FALLTHROUGH; - case 19: values[18] = PyTuple_GET_ITEM(__pyx_args, 18); - CYTHON_FALLTHROUGH; - case 18: values[17] = PyTuple_GET_ITEM(__pyx_args, 17); - CYTHON_FALLTHROUGH; - case 17: values[16] = PyTuple_GET_ITEM(__pyx_args, 16); - CYTHON_FALLTHROUGH; - case 16: values[15] = PyTuple_GET_ITEM(__pyx_args, 15); - CYTHON_FALLTHROUGH; - case 15: values[14] = PyTuple_GET_ITEM(__pyx_args, 14); - CYTHON_FALLTHROUGH; - case 14: values[13] = PyTuple_GET_ITEM(__pyx_args, 13); - CYTHON_FALLTHROUGH; - case 13: values[12] = PyTuple_GET_ITEM(__pyx_args, 12); - CYTHON_FALLTHROUGH; - case 12: values[11] = PyTuple_GET_ITEM(__pyx_args, 11); - CYTHON_FALLTHROUGH; - case 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10); - CYTHON_FALLTHROUGH; - case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9); - CYTHON_FALLTHROUGH; - case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8); - CYTHON_FALLTHROUGH; - case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); - CYTHON_FALLTHROUGH; - case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); - CYTHON_FALLTHROUGH; - case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); - CYTHON_FALLTHROUGH; - case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + values[7] = PyTuple_GET_ITEM(__pyx_args, 7); + values[8] = PyTuple_GET_ITEM(__pyx_args, 8); + values[9] = PyTuple_GET_ITEM(__pyx_args, 9); + values[10] = PyTuple_GET_ITEM(__pyx_args, 10); + values[11] = PyTuple_GET_ITEM(__pyx_args, 11); + values[12] = PyTuple_GET_ITEM(__pyx_args, 12); + values[13] = PyTuple_GET_ITEM(__pyx_args, 13); + values[14] = PyTuple_GET_ITEM(__pyx_args, 14); + values[15] = PyTuple_GET_ITEM(__pyx_args, 15); + values[16] = PyTuple_GET_ITEM(__pyx_args, 16); + values[17] = PyTuple_GET_ITEM(__pyx_args, 17); + values[18] = PyTuple_GET_ITEM(__pyx_args, 18); + values[19] = PyTuple_GET_ITEM(__pyx_args, 19); + values[20] = PyTuple_GET_ITEM(__pyx_args, 20); + values[21] = PyTuple_GET_ITEM(__pyx_args, 21); + values[22] = PyTuple_GET_ITEM(__pyx_args, 22); + values[23] = PyTuple_GET_ITEM(__pyx_args, 23); } __pyx_v_X = values[0]; __pyx_v_y = values[1]; @@ -3294,36 +3255,16 @@ static PyObject *__pyx_pw_7l0learn_9interface_3fit(PyObject *__pyx_self, PyObjec __pyx_v_max_support_size = values[5]; __pyx_v_num_lambda = values[6]; __pyx_v_num_gamma = values[7]; - if (values[8]) { - __pyx_v_gamma_max = __pyx_PyFloat_AsDouble(values[8]); if (unlikely((__pyx_v_gamma_max == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 58, __pyx_L3_error) - } else { - __pyx_v_gamma_max = ((double)10.); - } - if (values[9]) { - __pyx_v_gamma_min = __pyx_PyFloat_AsDouble(values[9]); if (unlikely((__pyx_v_gamma_min == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 59, __pyx_L3_error) - } else { - __pyx_v_gamma_min = ((double).0001); - } + __pyx_v_gamma_max = __pyx_PyFloat_AsDouble(values[8]); if (unlikely((__pyx_v_gamma_max == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 60, __pyx_L3_error) + __pyx_v_gamma_min = __pyx_PyFloat_AsDouble(values[9]); if (unlikely((__pyx_v_gamma_min == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 61, __pyx_L3_error) __pyx_v_partial_sort = values[10]; __pyx_v_max_iter = values[11]; - if (values[12]) { - __pyx_v_rtol = __pyx_PyFloat_AsDouble(values[12]); if (unlikely((__pyx_v_rtol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 62, __pyx_L3_error) - } else { - __pyx_v_rtol = ((double)1e-6); - } - if (values[13]) { - __pyx_v_atol = __pyx_PyFloat_AsDouble(values[13]); if (unlikely((__pyx_v_atol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 63, __pyx_L3_error) - } else { - __pyx_v_atol = ((double)1e-9); - } + __pyx_v_rtol = __pyx_PyFloat_AsDouble(values[12]); if (unlikely((__pyx_v_rtol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 64, __pyx_L3_error) + __pyx_v_atol = __pyx_PyFloat_AsDouble(values[13]); if (unlikely((__pyx_v_atol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 65, __pyx_L3_error) __pyx_v_active_set = values[14]; __pyx_v_active_set_num = values[15]; __pyx_v_max_swaps = values[16]; - if (values[17]) { - __pyx_v_scale_down_factor = __pyx_PyFloat_AsDouble(values[17]); if (unlikely((__pyx_v_scale_down_factor == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 67, __pyx_L3_error) - } else { - __pyx_v_scale_down_factor = ((double)0.8); - } + __pyx_v_scale_down_factor = __pyx_PyFloat_AsDouble(values[17]); if (unlikely((__pyx_v_scale_down_factor == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 69, __pyx_L3_error) __pyx_v_screen_size = values[18]; __pyx_v_lambda_grid = values[19]; __pyx_v_exclude_first_k = values[20]; @@ -3333,24 +3274,16 @@ static PyObject *__pyx_pw_7l0learn_9interface_3fit(PyObject *__pyx_self, PyObjec } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("fit", 0, 2, 24, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 50, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("_fit_check", 1, 24, 24, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 52, __pyx_L3_error) __pyx_L3_error:; - __Pyx_AddTraceback("l0learn.interface.fit", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("l0learn.interface._fit_check", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loss), (&PyUnicode_Type), 1, "loss", 1))) __PYX_ERR(0, 52, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_penalty), (&PyUnicode_Type), 1, "penalty", 1))) __PYX_ERR(0, 53, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_algorithm), (&PyUnicode_Type), 1, "algorithm", 1))) __PYX_ERR(0, 54, __pyx_L1_error) - __pyx_r = __pyx_pf_7l0learn_9interface_2fit(__pyx_self, __pyx_v_X, __pyx_v_y, __pyx_v_loss, __pyx_v_penalty, __pyx_v_algorithm, __pyx_v_max_support_size, __pyx_v_num_lambda, __pyx_v_num_gamma, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_v_partial_sort, __pyx_v_max_iter, __pyx_v_rtol, __pyx_v_atol, __pyx_v_active_set, __pyx_v_active_set_num, __pyx_v_max_swaps, __pyx_v_scale_down_factor, __pyx_v_screen_size, __pyx_v_lambda_grid, __pyx_v_exclude_first_k, __pyx_v_intercept, __pyx_v_lows, __pyx_v_highs); - - /* "l0learn/interface.pyx":50 - * SUPPORTED_ALGORITHM = ("CD", "CDPSI") - * - * def fit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< - * y: np.ndarray, - * loss: str = "SquaredHinge", - */ + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loss), (&PyUnicode_Type), 1, "loss", 1))) __PYX_ERR(0, 54, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_penalty), (&PyUnicode_Type), 1, "penalty", 1))) __PYX_ERR(0, 55, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_algorithm), (&PyUnicode_Type), 1, "algorithm", 1))) __PYX_ERR(0, 56, __pyx_L1_error) + __pyx_r = __pyx_pf_7l0learn_9interface_2_fit_check(__pyx_self, __pyx_v_X, __pyx_v_y, __pyx_v_loss, __pyx_v_penalty, __pyx_v_algorithm, __pyx_v_max_support_size, __pyx_v_num_lambda, __pyx_v_num_gamma, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_v_partial_sort, __pyx_v_max_iter, __pyx_v_rtol, __pyx_v_atol, __pyx_v_active_set, __pyx_v_active_set_num, __pyx_v_max_swaps, __pyx_v_scale_down_factor, __pyx_v_screen_size, __pyx_v_lambda_grid, __pyx_v_exclude_first_k, __pyx_v_intercept, __pyx_v_lows, __pyx_v_highs); /* function exit code */ goto __pyx_L0; @@ -3361,12 +3294,14 @@ static PyObject *__pyx_pw_7l0learn_9interface_3fit(PyObject *__pyx_self, PyObjec return __pyx_r; } -static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs) { +static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs) { PyObject *__pyx_v_n = NULL; PyObject *__pyx_v_p = NULL; PyObject *__pyx_v_unique_items = NULL; PyObject *__pyx_v_a = NULL; CYTHON_UNUSED PyObject *__pyx_v__ = NULL; + PyObject *__pyx_v_first_value = NULL; + PyObject *__pyx_v_second_value = NULL; int __pyx_v_auto_lambda; CYTHON_UNUSED int __pyx_v_bad_lambda_grid; PyObject *__pyx_v_i = NULL; @@ -3374,12 +3309,6 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx CYTHON_UNUSED double __pyx_v_current; int __pyx_v_with_bounds; PyObject *__pyx_v_bad_bounds = NULL; - std::vector > __pyx_v_c_lambda_grid; - std::string __pyx_v_c_loss; - std::string __pyx_v_c_penalty; - std::string __pyx_v_c_algorithim; - fitmodel __pyx_v_c_results; - PyObject *__pyx_v_results = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; @@ -3398,48 +3327,33 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx double __pyx_t_14; Py_ssize_t __pyx_t_15; PyObject *__pyx_t_16 = NULL; - PyObject *__pyx_t_17 = NULL; - PyObject *__pyx_t_18 = NULL; - PyObject *__pyx_t_19 = NULL; - std::vector > __pyx_t_20; - int __pyx_t_21; - std::string __pyx_t_22; - size_t __pyx_t_23; - size_t __pyx_t_24; - size_t __pyx_t_25; - bool __pyx_t_26; - size_t __pyx_t_27; - bool __pyx_t_28; - size_t __pyx_t_29; - size_t __pyx_t_30; - size_t __pyx_t_31; - size_t __pyx_t_32; - bool __pyx_t_33; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("fit", 0); + __Pyx_RefNannySetupContext("_fit_check", 0); __Pyx_INCREF(__pyx_v_y); __Pyx_INCREF(__pyx_v_penalty); + __Pyx_INCREF(__pyx_v_max_support_size); __Pyx_INCREF(__pyx_v_num_lambda); __Pyx_INCREF(__pyx_v_num_gamma); + __Pyx_INCREF(__pyx_v_screen_size); __Pyx_INCREF(__pyx_v_lambda_grid); __Pyx_INCREF(__pyx_v_lows); __Pyx_INCREF(__pyx_v_highs); - /* "l0learn/interface.pyx":222 - * """ + /* "l0learn/interface.pyx":77 + * highs: Union[np.ndarray, float]) -> Dict[str, Any]: * - * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): # <<<<<<<<<<<<<< - * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") + * if not isinstance(X, (np.ndarray, csc_matrix)) or X.dtype != np.float64 or X.ndim != 2 or not np.product(X.shape) or not X.flags.contiguous: # <<<<<<<<<<<<<< + * raise ValueError(f"expected X to be a 2D continuous non-degenerate real numpy or csc_matrix, but got {X}.") * n, p = X.shape */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 222, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 222, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 222, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_5 = PyObject_IsInstance(__pyx_v_X, __pyx_t_3); __pyx_t_6 = (__pyx_t_5 != 0); @@ -3460,290 +3374,292 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_1 = __pyx_t_5; goto __pyx_L4_bool_binop_done; } - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 222, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_dtype); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 77, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 222, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_float64); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_7); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_7, function); - } - } - __pyx_t_3 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_2, __pyx_v_X) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_X); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 222, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 222, __pyx_L1_error) + __pyx_t_2 = PyObject_RichCompare(__pyx_t_3, __pyx_t_7, Py_NE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_4 = ((!__pyx_t_5) != 0); - if (!__pyx_t_4) { + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 77, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (!__pyx_t_5) { } else { - __pyx_t_1 = __pyx_t_4; + __pyx_t_1 = __pyx_t_5; goto __pyx_L4_bool_binop_done; } - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 222, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyInt_NeObjC(__pyx_t_3, __pyx_int_2, 2, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 222, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyInt_NeObjC(__pyx_t_2, __pyx_int_2, 2, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 222, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (!__pyx_t_4) { + if (!__pyx_t_5) { } else { - __pyx_t_1 = __pyx_t_4; + __pyx_t_1 = __pyx_t_5; goto __pyx_L4_bool_binop_done; } - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 222, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_product); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 222, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 222, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_product); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __pyx_t_8 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2); + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); + __Pyx_DECREF_SET(__pyx_t_3, function); } } - __pyx_t_7 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_8, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); + __pyx_t_7 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_8, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 77, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 222, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 77, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_4 = ((!__pyx_t_5) != 0); + if (!__pyx_t_4) { + } else { + __pyx_t_1 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_flags); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 222, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_contiguous); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 77, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 77, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_5 = ((!__pyx_t_4) != 0); __pyx_t_1 = __pyx_t_5; __pyx_L4_bool_binop_done:; if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":223 + /* "l0learn/interface.pyx":78 * - * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): - * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") # <<<<<<<<<<<<<< + * if not isinstance(X, (np.ndarray, csc_matrix)) or X.dtype != np.float64 or X.ndim != 2 or not np.product(X.shape) or not X.flags.contiguous: + * raise ValueError(f"expected X to be a 2D continuous non-degenerate real numpy or csc_matrix, but got {X}.") # <<<<<<<<<<<<<< * n, p = X.shape * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: */ - __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 223, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 78, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_10 = 127; - __Pyx_INCREF(__pyx_kp_u_expected_X_to_be_a_2D_non_degene); - __pyx_t_9 += 71; - __Pyx_GIVEREF(__pyx_kp_u_expected_X_to_be_a_2D_non_degene); - PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_X_to_be_a_2D_non_degene); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_X, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 223, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_2); - __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_kp_u_expected_X_to_be_a_2D_continuous); + __pyx_t_9 += 82; + __Pyx_GIVEREF(__pyx_kp_u_expected_X_to_be_a_2D_continuous); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_X_to_be_a_2D_continuous); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_X, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 78, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7); + __pyx_t_7 = 0; __Pyx_INCREF(__pyx_kp_u__5); __pyx_t_9 += 1; __Pyx_GIVEREF(__pyx_kp_u__5); - PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u__5); - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 223, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 223, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u__5); + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 78, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 78, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 223, __pyx_L1_error) + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 78, __pyx_L1_error) - /* "l0learn/interface.pyx":222 - * """ + /* "l0learn/interface.pyx":77 + * highs: Union[np.ndarray, float]) -> Dict[str, Any]: * - * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): # <<<<<<<<<<<<<< - * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") + * if not isinstance(X, (np.ndarray, csc_matrix)) or X.dtype != np.float64 or X.ndim != 2 or not np.product(X.shape) or not X.flags.contiguous: # <<<<<<<<<<<<<< + * raise ValueError(f"expected X to be a 2D continuous non-degenerate real numpy or csc_matrix, but got {X}.") * n, p = X.shape */ } - /* "l0learn/interface.pyx":224 - * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): - * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") + /* "l0learn/interface.pyx":79 + * if not isinstance(X, (np.ndarray, csc_matrix)) or X.dtype != np.float64 or X.ndim != 2 or not np.product(X.shape) or not X.flags.contiguous: + * raise ValueError(f"expected X to be a 2D continuous non-degenerate real numpy or csc_matrix, but got {X}.") * n, p = X.shape # <<<<<<<<<<<<<< * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") */ - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 224, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if ((likely(PyTuple_CheckExact(__pyx_t_7))) || (PyList_CheckExact(__pyx_t_7))) { - PyObject* sequence = __pyx_t_7; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { + PyObject* sequence = __pyx_t_3; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 224, __pyx_L1_error) + __PYX_ERR(0, 79, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); + __pyx_t_7 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_2 = PyTuple_GET_ITEM(sequence, 1); } else { - __pyx_t_2 = PyList_GET_ITEM(sequence, 0); - __pyx_t_3 = PyList_GET_ITEM(sequence, 1); + __pyx_t_7 = PyList_GET_ITEM(sequence, 0); + __pyx_t_2 = PyList_GET_ITEM(sequence, 1); } + __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); #else - __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 224, __pyx_L1_error) + __pyx_t_7 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_2 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 79, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 224, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); #endif - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { Py_ssize_t index = -1; - __pyx_t_8 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 224, __pyx_L1_error) + __pyx_t_8 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 79, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_11 = Py_TYPE(__pyx_t_8)->tp_iternext; - index = 0; __pyx_t_2 = __pyx_t_11(__pyx_t_8); if (unlikely(!__pyx_t_2)) goto __pyx_L10_unpacking_failed; + index = 0; __pyx_t_7 = __pyx_t_11(__pyx_t_8); if (unlikely(!__pyx_t_7)) goto __pyx_L11_unpacking_failed; + __Pyx_GOTREF(__pyx_t_7); + index = 1; __pyx_t_2 = __pyx_t_11(__pyx_t_8); if (unlikely(!__pyx_t_2)) goto __pyx_L11_unpacking_failed; __Pyx_GOTREF(__pyx_t_2); - index = 1; __pyx_t_3 = __pyx_t_11(__pyx_t_8); if (unlikely(!__pyx_t_3)) goto __pyx_L10_unpacking_failed; - __Pyx_GOTREF(__pyx_t_3); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_8), 2) < 0) __PYX_ERR(0, 224, __pyx_L1_error) + if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_8), 2) < 0) __PYX_ERR(0, 79, __pyx_L1_error) __pyx_t_11 = NULL; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - goto __pyx_L11_unpacking_done; - __pyx_L10_unpacking_failed:; + goto __pyx_L12_unpacking_done; + __pyx_L11_unpacking_failed:; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_11 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 224, __pyx_L1_error) - __pyx_L11_unpacking_done:; + __PYX_ERR(0, 79, __pyx_L1_error) + __pyx_L12_unpacking_done:; } - __pyx_v_n = __pyx_t_2; + __pyx_v_n = __pyx_t_7; + __pyx_t_7 = 0; + __pyx_v_p = __pyx_t_2; __pyx_t_2 = 0; - __pyx_v_p = __pyx_t_3; - __pyx_t_3 = 0; - /* "l0learn/interface.pyx":225 - * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") + /* "l0learn/interface.pyx":80 + * raise ValueError(f"expected X to be a 2D continuous non-degenerate real numpy or csc_matrix, but got {X}.") * n, p = X.shape * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: # <<<<<<<<<<<<<< * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") * if loss not in SUPPORTED_LOSS: */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 225, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 225, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 80, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_5 = PyObject_IsInstance(__pyx_v_y, __pyx_t_3); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 225, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = PyObject_IsInstance(__pyx_v_y, __pyx_t_2); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_4 = ((!(__pyx_t_5 != 0)) != 0); if (!__pyx_t_4) { } else { __pyx_t_1 = __pyx_t_4; - goto __pyx_L13_bool_binop_done; + goto __pyx_L14_bool_binop_done; } - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 225, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 80, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 225, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_7)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); + __Pyx_DECREF_SET(__pyx_t_7, function); } } - __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_7, __pyx_v_y) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_y); - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 225, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_3, __pyx_v_y) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_y); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 80, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 225, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_5 = ((!__pyx_t_4) != 0); if (!__pyx_t_5) { } else { __pyx_t_1 = __pyx_t_5; - goto __pyx_L13_bool_binop_done; + goto __pyx_L14_bool_binop_done; } - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_y, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 225, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_PyInt_NeObjC(__pyx_t_3, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 225, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_y, __pyx_n_s_ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 80, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 225, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_NeObjC(__pyx_t_2, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (!__pyx_t_5) { } else { __pyx_t_1 = __pyx_t_5; - goto __pyx_L13_bool_binop_done; + goto __pyx_L14_bool_binop_done; } - __pyx_t_9 = PyObject_Length(__pyx_v_y); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 225, __pyx_L1_error) - __pyx_t_2 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 225, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyObject_RichCompare(__pyx_t_2, __pyx_v_n, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 225, __pyx_L1_error) + __pyx_t_9 = PyObject_Length(__pyx_v_y); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 80, __pyx_L1_error) + __pyx_t_7 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_2 = PyObject_RichCompare(__pyx_t_7, __pyx_v_n, Py_NE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 80, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 225, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = __pyx_t_5; - __pyx_L13_bool_binop_done:; + __pyx_L14_bool_binop_done:; if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":226 + /* "l0learn/interface.pyx":81 * n, p = X.shape * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") # <<<<<<<<<<<<<< * if loss not in SUPPORTED_LOSS: * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") */ - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 226, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_expected_y_to_be_a_1D_real_numpy); __pyx_t_9 += 42; __Pyx_GIVEREF(__pyx_kp_u_expected_y_to_be_a_1D_real_numpy); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_y_to_be_a_1D_real_numpy); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_y, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 226, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); - __pyx_t_2 = 0; + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_u_expected_y_to_be_a_1D_real_numpy); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_y, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_7); + __pyx_t_7 = 0; __Pyx_INCREF(__pyx_kp_u__5); __pyx_t_9 += 1; __Pyx_GIVEREF(__pyx_kp_u__5); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u__5); - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 226, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_kp_u__5); + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_2, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 81, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 226, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 226, __pyx_L1_error) + __PYX_ERR(0, 81, __pyx_L1_error) - /* "l0learn/interface.pyx":225 - * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") + /* "l0learn/interface.pyx":80 + * raise ValueError(f"expected X to be a 2D continuous non-degenerate real numpy or csc_matrix, but got {X}.") * n, p = X.shape * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: # <<<<<<<<<<<<<< * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") @@ -3751,67 +3667,67 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":227 + /* "l0learn/interface.pyx":82 * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") * if loss not in SUPPORTED_LOSS: # <<<<<<<<<<<<<< * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") * if penalty not in SUPPORTED_PENALTY: */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 227, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_loss, __pyx_t_3, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 227, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_loss, __pyx_t_2, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_5 = (__pyx_t_1 != 0); if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":228 + /* "l0learn/interface.pyx":83 * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") * if loss not in SUPPORTED_LOSS: * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") # <<<<<<<<<<<<<< * if penalty not in SUPPORTED_PENALTY: * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") */ - __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 228, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 83, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_expected_loss_parameter_to_be_on); __pyx_t_9 += 36; __Pyx_GIVEREF(__pyx_kp_u_expected_loss_parameter_to_be_on); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_loss_parameter_to_be_on); - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 228, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 228, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_u_expected_loss_parameter_to_be_on); + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 83, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7); - __pyx_t_7 = 0; + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 83, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3); + __pyx_t_3 = 0; __Pyx_INCREF(__pyx_kp_u_but_got); __pyx_t_9 += 10; __Pyx_GIVEREF(__pyx_kp_u_but_got); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_but_got); - __pyx_t_7 = __Pyx_PyUnicode_Unicode(__pyx_v_loss); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 228, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_7); - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 228, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 228, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_kp_u_but_got); + __pyx_t_3 = __Pyx_PyUnicode_Unicode(__pyx_v_loss); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 83, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_2, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 83, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 83, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 228, __pyx_L1_error) + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 83, __pyx_L1_error) - /* "l0learn/interface.pyx":227 + /* "l0learn/interface.pyx":82 * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") * if loss not in SUPPORTED_LOSS: # <<<<<<<<<<<<<< @@ -3820,67 +3736,67 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":229 + /* "l0learn/interface.pyx":84 * if loss not in SUPPORTED_LOSS: * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") * if penalty not in SUPPORTED_PENALTY: # <<<<<<<<<<<<<< * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") * if algorithm not in SUPPORTED_ALGORITHM: */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SUPPORTED_PENALTY); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 229, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_v_penalty, __pyx_t_3, Py_NE)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 229, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SUPPORTED_PENALTY); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 84, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_v_penalty, __pyx_t_2, Py_NE)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 84, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_1 = (__pyx_t_5 != 0); if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":230 + /* "l0learn/interface.pyx":85 * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") * if penalty not in SUPPORTED_PENALTY: * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") # <<<<<<<<<<<<<< * if algorithm not in SUPPORTED_ALGORITHM: * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") */ - __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 230, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_expected_penalty_parameter_to_be); __pyx_t_9 += 39; __Pyx_GIVEREF(__pyx_kp_u_expected_penalty_parameter_to_be); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_penalty_parameter_to_be); - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_SUPPORTED_PENALTY); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 230, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_u_expected_penalty_parameter_to_be); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SUPPORTED_PENALTY); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 85, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 230, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); - __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_7); + __pyx_t_7 = 0; __Pyx_INCREF(__pyx_kp_u_but_got); __pyx_t_9 += 10; __Pyx_GIVEREF(__pyx_kp_u_but_got); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_but_got); - __pyx_t_2 = __Pyx_PyUnicode_Unicode(__pyx_v_penalty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 230, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_2); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 230, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_kp_u_but_got); + __pyx_t_7 = __Pyx_PyUnicode_Unicode(__pyx_v_penalty); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_2, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 85, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 230, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 230, __pyx_L1_error) + __PYX_ERR(0, 85, __pyx_L1_error) - /* "l0learn/interface.pyx":229 + /* "l0learn/interface.pyx":84 * if loss not in SUPPORTED_LOSS: * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") * if penalty not in SUPPORTED_PENALTY: # <<<<<<<<<<<<<< @@ -3889,172 +3805,156 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":231 + /* "l0learn/interface.pyx":86 * if penalty not in SUPPORTED_PENALTY: * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") * if algorithm not in SUPPORTED_ALGORITHM: # <<<<<<<<<<<<<< * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") - * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): + * if not isinstance(max_support_size, int) or 1 > max_support_size: */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SUPPORTED_ALGORITHM); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 231, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_algorithm, __pyx_t_3, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 231, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SUPPORTED_ALGORITHM); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_algorithm, __pyx_t_2, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_5 = (__pyx_t_1 != 0); if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":232 + /* "l0learn/interface.pyx":87 * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") * if algorithm not in SUPPORTED_ALGORITHM: * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") # <<<<<<<<<<<<<< - * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): - * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," + * if not isinstance(max_support_size, int) or 1 > max_support_size: + * raise ValueError(f"expected max_support_size parameter to be a positive integer, but got {max_support_size}") */ - __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 232, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_expected_algorithm_parameter_to); __pyx_t_9 += 41; __Pyx_GIVEREF(__pyx_kp_u_expected_algorithm_parameter_to); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_algorithm_parameter_to); - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SUPPORTED_ALGORITHM); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 232, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 232, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_u_expected_algorithm_parameter_to); + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_SUPPORTED_ALGORITHM); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 87, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7); - __pyx_t_7 = 0; + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3); + __pyx_t_3 = 0; __Pyx_INCREF(__pyx_kp_u_but_got); __pyx_t_9 += 10; __Pyx_GIVEREF(__pyx_kp_u_but_got); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_but_got); - __pyx_t_7 = __Pyx_PyUnicode_Unicode(__pyx_v_algorithm); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 232, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_7); - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 232, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 232, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_kp_u_but_got); + __pyx_t_3 = __Pyx_PyUnicode_Unicode(__pyx_v_algorithm); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 87, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_2, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 87, __pyx_L1_error) - /* "l0learn/interface.pyx":231 + /* "l0learn/interface.pyx":86 * if penalty not in SUPPORTED_PENALTY: * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") * if algorithm not in SUPPORTED_ALGORITHM: # <<<<<<<<<<<<<< * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") - * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): + * if not isinstance(max_support_size, int) or 1 > max_support_size: */ } - /* "l0learn/interface.pyx":233 + /* "l0learn/interface.pyx":88 * if algorithm not in SUPPORTED_ALGORITHM: * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") - * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): # <<<<<<<<<<<<<< - * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," - * f" but got {max_support_size}") + * if not isinstance(max_support_size, int) or 1 > max_support_size: # <<<<<<<<<<<<<< + * raise ValueError(f"expected max_support_size parameter to be a positive integer, but got {max_support_size}") + * max_support_size = min(p, max_support_size) */ __pyx_t_1 = PyInt_Check(__pyx_v_max_support_size); __pyx_t_4 = ((!(__pyx_t_1 != 0)) != 0); if (!__pyx_t_4) { } else { __pyx_t_5 = __pyx_t_4; - goto __pyx_L21_bool_binop_done; - } - __pyx_t_3 = PyObject_RichCompare(__pyx_int_0, __pyx_v_max_support_size, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 233, __pyx_L1_error) - if (__Pyx_PyObject_IsTrue(__pyx_t_3)) { - __Pyx_DECREF(__pyx_t_3); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_max_support_size, __pyx_v_p, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 233, __pyx_L1_error) + goto __pyx_L22_bool_binop_done; } - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 233, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_1 = ((!__pyx_t_4) != 0); - __pyx_t_5 = __pyx_t_1; - __pyx_L21_bool_binop_done:; + __pyx_t_2 = PyObject_RichCompare(__pyx_int_1, __pyx_v_max_support_size, Py_GT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 88, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 88, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_5 = __pyx_t_4; + __pyx_L22_bool_binop_done:; if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":234 - * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") - * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): - * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," # <<<<<<<<<<<<<< - * f" but got {max_support_size}") - * if gamma_max < 0: - */ - __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 234, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_9 = 0; - __pyx_t_10 = 127; - __Pyx_INCREF(__pyx_kp_u_expected_max_support_size_parame); - __pyx_t_9 += 71; - __Pyx_GIVEREF(__pyx_kp_u_expected_max_support_size_parame); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_max_support_size_parame); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 234, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7); - __pyx_t_7 = 0; - __Pyx_INCREF(__pyx_kp_u_but_got); - __pyx_t_9 += 10; - __Pyx_GIVEREF(__pyx_kp_u_but_got); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_but_got); - - /* "l0learn/interface.pyx":235 - * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): - * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," - * f" but got {max_support_size}") # <<<<<<<<<<<<<< - * if gamma_max < 0: - * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") - */ - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_max_support_size, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 235, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_7); - __pyx_t_7 = 0; - - /* "l0learn/interface.pyx":234 + /* "l0learn/interface.pyx":89 * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") - * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): - * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," # <<<<<<<<<<<<<< - * f" but got {max_support_size}") - * if gamma_max < 0: + * if not isinstance(max_support_size, int) or 1 > max_support_size: + * raise ValueError(f"expected max_support_size parameter to be a positive integer, but got {max_support_size}") # <<<<<<<<<<<<<< + * max_support_size = min(p, max_support_size) + * */ - __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 234, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 234, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_max_support_size, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_support_size_parame, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 89, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 89, __pyx_L1_error) - /* "l0learn/interface.pyx":233 + /* "l0learn/interface.pyx":88 * if algorithm not in SUPPORTED_ALGORITHM: * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") - * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): # <<<<<<<<<<<<<< - * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," - * f" but got {max_support_size}") + * if not isinstance(max_support_size, int) or 1 > max_support_size: # <<<<<<<<<<<<<< + * raise ValueError(f"expected max_support_size parameter to be a positive integer, but got {max_support_size}") + * max_support_size = min(p, max_support_size) */ } - /* "l0learn/interface.pyx":236 - * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," - * f" but got {max_support_size}") + /* "l0learn/interface.pyx":90 + * if not isinstance(max_support_size, int) or 1 > max_support_size: + * raise ValueError(f"expected max_support_size parameter to be a positive integer, but got {max_support_size}") + * max_support_size = min(p, max_support_size) # <<<<<<<<<<<<<< + * + * if gamma_max < 0: + */ + __Pyx_INCREF(__pyx_v_max_support_size); + __pyx_t_2 = __pyx_v_max_support_size; + __Pyx_INCREF(__pyx_v_p); + __pyx_t_3 = __pyx_v_p; + __pyx_t_8 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 90, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 90, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (__pyx_t_5) { + __Pyx_INCREF(__pyx_t_2); + __pyx_t_7 = __pyx_t_2; + } else { + __Pyx_INCREF(__pyx_t_3); + __pyx_t_7 = __pyx_t_3; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __pyx_t_7; + __Pyx_INCREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF_SET(__pyx_v_max_support_size, __pyx_t_2); + __pyx_t_2 = 0; + + /* "l0learn/interface.pyx":92 + * max_support_size = min(p, max_support_size) + * * if gamma_max < 0: # <<<<<<<<<<<<<< * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") * if gamma_min < 0 or gamma_min > gamma_max: @@ -4062,86 +3962,86 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_5 = ((__pyx_v_gamma_max < 0.0) != 0); if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":237 - * f" but got {max_support_size}") + /* "l0learn/interface.pyx":93 + * * if gamma_max < 0: * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") # <<<<<<<<<<<<<< * if gamma_min < 0 or gamma_min > gamma_max: * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," */ - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 237, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 237, __pyx_L1_error) + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 93, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_gamma_max_parameter_to, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 237, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_gamma_max_parameter_to, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 237, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 93, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 237, __pyx_L1_error) + __PYX_ERR(0, 93, __pyx_L1_error) - /* "l0learn/interface.pyx":236 - * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," - * f" but got {max_support_size}") + /* "l0learn/interface.pyx":92 + * max_support_size = min(p, max_support_size) + * * if gamma_max < 0: # <<<<<<<<<<<<<< * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") * if gamma_min < 0 or gamma_min > gamma_max: */ } - /* "l0learn/interface.pyx":238 + /* "l0learn/interface.pyx":94 * if gamma_max < 0: * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") * if gamma_min < 0 or gamma_min > gamma_max: # <<<<<<<<<<<<<< * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," * f" but got {gamma_min}") */ - __pyx_t_1 = ((__pyx_v_gamma_min < 0.0) != 0); - if (!__pyx_t_1) { + __pyx_t_4 = ((__pyx_v_gamma_min < 0.0) != 0); + if (!__pyx_t_4) { } else { - __pyx_t_5 = __pyx_t_1; - goto __pyx_L25_bool_binop_done; + __pyx_t_5 = __pyx_t_4; + goto __pyx_L26_bool_binop_done; } - __pyx_t_1 = ((__pyx_v_gamma_min > __pyx_v_gamma_max) != 0); - __pyx_t_5 = __pyx_t_1; - __pyx_L25_bool_binop_done:; + __pyx_t_4 = ((__pyx_v_gamma_min > __pyx_v_gamma_max) != 0); + __pyx_t_5 = __pyx_t_4; + __pyx_L26_bool_binop_done:; if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":240 + /* "l0learn/interface.pyx":96 * if gamma_min < 0 or gamma_min > gamma_max: * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," * f" but got {gamma_min}") # <<<<<<<<<<<<<< * if not isinstance(partial_sort, bool): * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") */ - __pyx_t_7 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 240, __pyx_L1_error) + __pyx_t_7 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 96, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 96, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - /* "l0learn/interface.pyx":239 + /* "l0learn/interface.pyx":95 * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") * if gamma_min < 0 or gamma_min > gamma_max: * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," # <<<<<<<<<<<<<< * f" but got {gamma_min}") * if not isinstance(partial_sort, bool): */ - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_gamma_max_parameter_to_2, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 239, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_gamma_max_parameter_to_2, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 95, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 239, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 95, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 95, __pyx_L1_error) - /* "l0learn/interface.pyx":238 + /* "l0learn/interface.pyx":94 * if gamma_max < 0: * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") * if gamma_min < 0 or gamma_min > gamma_max: # <<<<<<<<<<<<<< @@ -4150,40 +4050,40 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":241 + /* "l0learn/interface.pyx":97 * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," * f" but got {gamma_min}") * if not isinstance(partial_sort, bool): # <<<<<<<<<<<<<< * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") * if not isinstance(max_iter, int) or max_iter < 1: */ - __pyx_t_3 = ((PyObject*)&PyBool_Type); - __Pyx_INCREF(__pyx_t_3); - __pyx_t_5 = PyObject_IsInstance(__pyx_v_partial_sort, __pyx_t_3); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 241, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_1 = ((!(__pyx_t_5 != 0)) != 0); - if (unlikely(__pyx_t_1)) { + __pyx_t_2 = ((PyObject*)&PyBool_Type); + __Pyx_INCREF(__pyx_t_2); + __pyx_t_5 = PyObject_IsInstance(__pyx_v_partial_sort, __pyx_t_2); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = ((!(__pyx_t_5 != 0)) != 0); + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":242 + /* "l0learn/interface.pyx":98 * f" but got {gamma_min}") * if not isinstance(partial_sort, bool): * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") # <<<<<<<<<<<<<< * if not isinstance(max_iter, int) or max_iter < 1: * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") */ - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_partial_sort, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 242, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_partial_sort_parameter, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 242, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_partial_sort, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_partial_sort_parameter, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 98, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 242, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 98, __pyx_L1_error) - /* "l0learn/interface.pyx":241 + /* "l0learn/interface.pyx":97 * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," * f" but got {gamma_min}") * if not isinstance(partial_sort, bool): # <<<<<<<<<<<<<< @@ -4192,7 +4092,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":243 + /* "l0learn/interface.pyx":99 * if not isinstance(partial_sort, bool): * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") * if not isinstance(max_iter, int) or max_iter < 1: # <<<<<<<<<<<<<< @@ -4200,39 +4100,39 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx * if rtol < 0 or rtol >= 1: */ __pyx_t_5 = PyInt_Check(__pyx_v_max_iter); - __pyx_t_4 = ((!(__pyx_t_5 != 0)) != 0); - if (!__pyx_t_4) { + __pyx_t_1 = ((!(__pyx_t_5 != 0)) != 0); + if (!__pyx_t_1) { } else { - __pyx_t_1 = __pyx_t_4; - goto __pyx_L29_bool_binop_done; + __pyx_t_4 = __pyx_t_1; + goto __pyx_L30_bool_binop_done; } - __pyx_t_3 = PyObject_RichCompare(__pyx_v_max_iter, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 243, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 243, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_1 = __pyx_t_4; - __pyx_L29_bool_binop_done:; - if (unlikely(__pyx_t_1)) { + __pyx_t_2 = PyObject_RichCompare(__pyx_v_max_iter, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 99, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = __pyx_t_1; + __pyx_L30_bool_binop_done:; + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":244 + /* "l0learn/interface.pyx":100 * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") * if not isinstance(max_iter, int) or max_iter < 1: * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") # <<<<<<<<<<<<<< * if rtol < 0 or rtol >= 1: * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") */ - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_max_iter, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 244, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_iter_parameter_to_b, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 244, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_max_iter, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_iter_parameter_to_b, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 100, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 244, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 244, __pyx_L1_error) + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 100, __pyx_L1_error) - /* "l0learn/interface.pyx":243 + /* "l0learn/interface.pyx":99 * if not isinstance(partial_sort, bool): * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") * if not isinstance(max_iter, int) or max_iter < 1: # <<<<<<<<<<<<<< @@ -4241,47 +4141,47 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":245 + /* "l0learn/interface.pyx":101 * if not isinstance(max_iter, int) or max_iter < 1: * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") * if rtol < 0 or rtol >= 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") * if atol < 0: */ - __pyx_t_4 = ((__pyx_v_rtol < 0.0) != 0); - if (!__pyx_t_4) { + __pyx_t_1 = ((__pyx_v_rtol < 0.0) != 0); + if (!__pyx_t_1) { } else { - __pyx_t_1 = __pyx_t_4; - goto __pyx_L32_bool_binop_done; + __pyx_t_4 = __pyx_t_1; + goto __pyx_L33_bool_binop_done; } - __pyx_t_4 = ((__pyx_v_rtol >= 1.0) != 0); - __pyx_t_1 = __pyx_t_4; - __pyx_L32_bool_binop_done:; - if (unlikely(__pyx_t_1)) { + __pyx_t_1 = ((__pyx_v_rtol >= 1.0) != 0); + __pyx_t_4 = __pyx_t_1; + __pyx_L33_bool_binop_done:; + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":246 + /* "l0learn/interface.pyx":102 * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") * if rtol < 0 or rtol >= 1: * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") # <<<<<<<<<<<<<< * if atol < 0: * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") */ - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_rtol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 246, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 246, __pyx_L1_error) + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_rtol); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 102, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_rtol_parameter_to_exist, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 246, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_rtol_parameter_to_exist, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 246, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 102, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 246, __pyx_L1_error) + __PYX_ERR(0, 102, __pyx_L1_error) - /* "l0learn/interface.pyx":245 + /* "l0learn/interface.pyx":101 * if not isinstance(max_iter, int) or max_iter < 1: * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") * if rtol < 0 or rtol >= 1: # <<<<<<<<<<<<<< @@ -4290,39 +4190,39 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":247 + /* "l0learn/interface.pyx":103 * if rtol < 0 or rtol >= 1: * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") * if atol < 0: # <<<<<<<<<<<<<< * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") * if not isinstance(active_set, bool): */ - __pyx_t_1 = ((__pyx_v_atol < 0.0) != 0); - if (unlikely(__pyx_t_1)) { + __pyx_t_4 = ((__pyx_v_atol < 0.0) != 0); + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":248 + /* "l0learn/interface.pyx":104 * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") * if atol < 0: * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") # <<<<<<<<<<<<<< * if not isinstance(active_set, bool): * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") */ - __pyx_t_7 = PyFloat_FromDouble(__pyx_v_atol); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 248, __pyx_L1_error) + __pyx_t_7 = PyFloat_FromDouble(__pyx_v_atol); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 104, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 248, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_atol_parameter_to_exist, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 248, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_atol_parameter_to_exist, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 104, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 248, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 248, __pyx_L1_error) + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 104, __pyx_L1_error) - /* "l0learn/interface.pyx":247 + /* "l0learn/interface.pyx":103 * if rtol < 0 or rtol >= 1: * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") * if atol < 0: # <<<<<<<<<<<<<< @@ -4331,40 +4231,40 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":249 + /* "l0learn/interface.pyx":105 * if atol < 0: * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") * if not isinstance(active_set, bool): # <<<<<<<<<<<<<< * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") * if not isinstance(active_set_num, int) or active_set_num < 1: */ - __pyx_t_3 = ((PyObject*)&PyBool_Type); - __Pyx_INCREF(__pyx_t_3); - __pyx_t_1 = PyObject_IsInstance(__pyx_v_active_set, __pyx_t_3); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 249, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_4 = ((!(__pyx_t_1 != 0)) != 0); - if (unlikely(__pyx_t_4)) { + __pyx_t_2 = ((PyObject*)&PyBool_Type); + __Pyx_INCREF(__pyx_t_2); + __pyx_t_4 = PyObject_IsInstance(__pyx_v_active_set, __pyx_t_2); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 105, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_1 = ((!(__pyx_t_4 != 0)) != 0); + if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":250 + /* "l0learn/interface.pyx":106 * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") * if not isinstance(active_set, bool): * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") # <<<<<<<<<<<<<< * if not isinstance(active_set_num, int) or active_set_num < 1: * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") */ - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_active_set, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 250, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_active_set_parameter_to, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 250, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_active_set, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 106, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_active_set_parameter_to, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 106, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 250, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 106, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 106, __pyx_L1_error) - /* "l0learn/interface.pyx":249 + /* "l0learn/interface.pyx":105 * if atol < 0: * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") * if not isinstance(active_set, bool): # <<<<<<<<<<<<<< @@ -4373,47 +4273,47 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":251 + /* "l0learn/interface.pyx":107 * if not isinstance(active_set, bool): * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") * if not isinstance(active_set_num, int) or active_set_num < 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") * if not isinstance(max_swaps, int) or max_swaps < 1: */ - __pyx_t_1 = PyInt_Check(__pyx_v_active_set_num); - __pyx_t_5 = ((!(__pyx_t_1 != 0)) != 0); + __pyx_t_4 = PyInt_Check(__pyx_v_active_set_num); + __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); if (!__pyx_t_5) { } else { - __pyx_t_4 = __pyx_t_5; - goto __pyx_L37_bool_binop_done; + __pyx_t_1 = __pyx_t_5; + goto __pyx_L38_bool_binop_done; } - __pyx_t_3 = PyObject_RichCompare(__pyx_v_active_set_num, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 251, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 251, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_4 = __pyx_t_5; - __pyx_L37_bool_binop_done:; - if (unlikely(__pyx_t_4)) { + __pyx_t_2 = PyObject_RichCompare(__pyx_v_active_set_num, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 107, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 107, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_1 = __pyx_t_5; + __pyx_L38_bool_binop_done:; + if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":252 + /* "l0learn/interface.pyx":108 * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") * if not isinstance(active_set_num, int) or active_set_num < 1: * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") # <<<<<<<<<<<<<< * if not isinstance(max_swaps, int) or max_swaps < 1: * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") */ - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_active_set_num, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 252, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_active_set_num_paramete, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 252, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_active_set_num, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_active_set_num_paramete, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 108, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 252, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 252, __pyx_L1_error) + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 108, __pyx_L1_error) - /* "l0learn/interface.pyx":251 + /* "l0learn/interface.pyx":107 * if not isinstance(active_set, bool): * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") * if not isinstance(active_set_num, int) or active_set_num < 1: # <<<<<<<<<<<<<< @@ -4422,7 +4322,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":253 + /* "l0learn/interface.pyx":109 * if not isinstance(active_set_num, int) or active_set_num < 1: * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") * if not isinstance(max_swaps, int) or max_swaps < 1: # <<<<<<<<<<<<<< @@ -4430,39 +4330,39 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx * if not (0 < scale_down_factor < 1): */ __pyx_t_5 = PyInt_Check(__pyx_v_max_swaps); - __pyx_t_1 = ((!(__pyx_t_5 != 0)) != 0); - if (!__pyx_t_1) { + __pyx_t_4 = ((!(__pyx_t_5 != 0)) != 0); + if (!__pyx_t_4) { } else { - __pyx_t_4 = __pyx_t_1; - goto __pyx_L40_bool_binop_done; + __pyx_t_1 = __pyx_t_4; + goto __pyx_L41_bool_binop_done; } - __pyx_t_3 = PyObject_RichCompare(__pyx_v_max_swaps, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 253, __pyx_L1_error) - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 253, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_4 = __pyx_t_1; - __pyx_L40_bool_binop_done:; - if (unlikely(__pyx_t_4)) { + __pyx_t_2 = PyObject_RichCompare(__pyx_v_max_swaps, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 109, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 109, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_1 = __pyx_t_4; + __pyx_L41_bool_binop_done:; + if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":254 + /* "l0learn/interface.pyx":110 * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") * if not isinstance(max_swaps, int) or max_swaps < 1: * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") # <<<<<<<<<<<<<< * if not (0 < scale_down_factor < 1): * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") */ - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_max_swaps, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 254, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_swaps_parameter_to, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 254, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_max_swaps, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_swaps_parameter_to, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 110, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 254, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 254, __pyx_L1_error) + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 110, __pyx_L1_error) - /* "l0learn/interface.pyx":253 + /* "l0learn/interface.pyx":109 * if not isinstance(active_set_num, int) or active_set_num < 1: * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") * if not isinstance(max_swaps, int) or max_swaps < 1: # <<<<<<<<<<<<<< @@ -4471,182 +4371,163 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":255 + /* "l0learn/interface.pyx":111 * if not isinstance(max_swaps, int) or max_swaps < 1: * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") * if not (0 < scale_down_factor < 1): # <<<<<<<<<<<<<< * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") - * if not isinstance(screen_size, int) or screen_size < 1 or screen_size > p: + * if not isinstance(screen_size, int) or screen_size < 1: */ - __pyx_t_4 = (0.0 < __pyx_v_scale_down_factor); - if (__pyx_t_4) { - __pyx_t_4 = (__pyx_v_scale_down_factor < 1.0); + __pyx_t_1 = (0.0 < __pyx_v_scale_down_factor); + if (__pyx_t_1) { + __pyx_t_1 = (__pyx_v_scale_down_factor < 1.0); } - __pyx_t_1 = ((!(__pyx_t_4 != 0)) != 0); - if (unlikely(__pyx_t_1)) { + __pyx_t_4 = ((!(__pyx_t_1 != 0)) != 0); + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":256 + /* "l0learn/interface.pyx":112 * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") * if not (0 < scale_down_factor < 1): * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") # <<<<<<<<<<<<<< - * if not isinstance(screen_size, int) or screen_size < 1 or screen_size > p: - * raise ValueError(f"expected screen_size parameter to be a positive integer less than {p}," + * if not isinstance(screen_size, int) or screen_size < 1: + * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") */ - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_scale_down_factor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 256, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 256, __pyx_L1_error) + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_scale_down_factor); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 112, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_scale_down_factor_param, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 256, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_scale_down_factor_param, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 256, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 112, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 256, __pyx_L1_error) + __PYX_ERR(0, 112, __pyx_L1_error) - /* "l0learn/interface.pyx":255 + /* "l0learn/interface.pyx":111 * if not isinstance(max_swaps, int) or max_swaps < 1: * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") * if not (0 < scale_down_factor < 1): # <<<<<<<<<<<<<< * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") - * if not isinstance(screen_size, int) or screen_size < 1 or screen_size > p: + * if not isinstance(screen_size, int) or screen_size < 1: */ } - /* "l0learn/interface.pyx":257 + /* "l0learn/interface.pyx":113 * if not (0 < scale_down_factor < 1): * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") - * if not isinstance(screen_size, int) or screen_size < 1 or screen_size > p: # <<<<<<<<<<<<<< - * raise ValueError(f"expected screen_size parameter to be a positive integer less than {p}," - * f" but got {screen_size}") + * if not isinstance(screen_size, int) or screen_size < 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") + * screen_size = min(screen_size, p) */ - __pyx_t_4 = PyInt_Check(__pyx_v_screen_size); - __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); - if (!__pyx_t_5) { - } else { - __pyx_t_1 = __pyx_t_5; - goto __pyx_L44_bool_binop_done; - } - __pyx_t_7 = PyObject_RichCompare(__pyx_v_screen_size, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 257, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 257, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_1 = PyInt_Check(__pyx_v_screen_size); + __pyx_t_5 = ((!(__pyx_t_1 != 0)) != 0); if (!__pyx_t_5) { } else { - __pyx_t_1 = __pyx_t_5; - goto __pyx_L44_bool_binop_done; + __pyx_t_4 = __pyx_t_5; + goto __pyx_L45_bool_binop_done; } - __pyx_t_7 = PyObject_RichCompare(__pyx_v_screen_size, __pyx_v_p, Py_GT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 257, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 257, __pyx_L1_error) + __pyx_t_7 = PyObject_RichCompare(__pyx_v_screen_size, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 113, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 113, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_1 = __pyx_t_5; - __pyx_L44_bool_binop_done:; - if (unlikely(__pyx_t_1)) { + __pyx_t_4 = __pyx_t_5; + __pyx_L45_bool_binop_done:; + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":258 + /* "l0learn/interface.pyx":114 * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") - * if not isinstance(screen_size, int) or screen_size < 1 or screen_size > p: - * raise ValueError(f"expected screen_size parameter to be a positive integer less than {p}," # <<<<<<<<<<<<<< - * f" but got {screen_size}") - * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): - */ - __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 258, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_9 = 0; - __pyx_t_10 = 127; - __Pyx_INCREF(__pyx_kp_u_expected_screen_size_parameter_t); - __pyx_t_9 += 66; - __Pyx_GIVEREF(__pyx_kp_u_expected_screen_size_parameter_t); - PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_screen_size_parameter_t); - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 258, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_3); - __pyx_t_3 = 0; - __Pyx_INCREF(__pyx_kp_u_but_got); - __pyx_t_9 += 10; - __Pyx_GIVEREF(__pyx_kp_u_but_got); - PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_but_got); - - /* "l0learn/interface.pyx":259 - * if not isinstance(screen_size, int) or screen_size < 1 or screen_size > p: - * raise ValueError(f"expected screen_size parameter to be a positive integer less than {p}," - * f" but got {screen_size}") # <<<<<<<<<<<<<< - * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): - * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " - */ - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_screen_size, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 259, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_3); - __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":258 - * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") - * if not isinstance(screen_size, int) or screen_size < 1 or screen_size > p: - * raise ValueError(f"expected screen_size parameter to be a positive integer less than {p}," # <<<<<<<<<<<<<< - * f" but got {screen_size}") - * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): + * if not isinstance(screen_size, int) or screen_size < 1: + * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") # <<<<<<<<<<<<<< + * screen_size = min(screen_size, p) + * */ - __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 258, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_screen_size, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_screen_size_parameter_t, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 258, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 114, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 258, __pyx_L1_error) + __PYX_ERR(0, 114, __pyx_L1_error) - /* "l0learn/interface.pyx":257 + /* "l0learn/interface.pyx":113 * if not (0 < scale_down_factor < 1): * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") - * if not isinstance(screen_size, int) or screen_size < 1 or screen_size > p: # <<<<<<<<<<<<<< - * raise ValueError(f"expected screen_size parameter to be a positive integer less than {p}," - * f" but got {screen_size}") + * if not isinstance(screen_size, int) or screen_size < 1: # <<<<<<<<<<<<<< + * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") + * screen_size = min(screen_size, p) + */ + } + + /* "l0learn/interface.pyx":115 + * if not isinstance(screen_size, int) or screen_size < 1: + * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") + * screen_size = min(screen_size, p) # <<<<<<<<<<<<<< + * + * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): */ + __Pyx_INCREF(__pyx_v_p); + __pyx_t_7 = __pyx_v_p; + __Pyx_INCREF(__pyx_v_screen_size); + __pyx_t_2 = __pyx_v_screen_size; + __pyx_t_8 = PyObject_RichCompare(__pyx_t_7, __pyx_t_2, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 115, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 115, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (__pyx_t_4) { + __Pyx_INCREF(__pyx_t_7); + __pyx_t_3 = __pyx_t_7; + } else { + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = __pyx_t_2; } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __pyx_t_3; + __Pyx_INCREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_screen_size, __pyx_t_7); + __pyx_t_7 = 0; - /* "l0learn/interface.pyx":260 - * raise ValueError(f"expected screen_size parameter to be a positive integer less than {p}," - * f" but got {screen_size}") + /* "l0learn/interface.pyx":117 + * screen_size = min(screen_size, p) + * * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): # <<<<<<<<<<<<<< * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " * f"but got {exclude_first_k}") */ __pyx_t_5 = PyInt_Check(__pyx_v_exclude_first_k); - __pyx_t_4 = ((!(__pyx_t_5 != 0)) != 0); - if (!__pyx_t_4) { + __pyx_t_1 = ((!(__pyx_t_5 != 0)) != 0); + if (!__pyx_t_1) { } else { - __pyx_t_1 = __pyx_t_4; + __pyx_t_4 = __pyx_t_1; goto __pyx_L48_bool_binop_done; } - __pyx_t_7 = PyObject_RichCompare(__pyx_int_0, __pyx_v_exclude_first_k, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 260, __pyx_L1_error) + __pyx_t_7 = PyObject_RichCompare(__pyx_int_0, __pyx_v_exclude_first_k, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 117, __pyx_L1_error) if (__Pyx_PyObject_IsTrue(__pyx_t_7)) { __Pyx_DECREF(__pyx_t_7); - __pyx_t_7 = PyObject_RichCompare(__pyx_v_exclude_first_k, __pyx_v_p, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 260, __pyx_L1_error) + __pyx_t_7 = PyObject_RichCompare(__pyx_v_exclude_first_k, __pyx_v_p, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 117, __pyx_L1_error) } - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 260, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 117, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_5 = ((!__pyx_t_4) != 0); - __pyx_t_1 = __pyx_t_5; + __pyx_t_5 = ((!__pyx_t_1) != 0); + __pyx_t_4 = __pyx_t_5; __pyx_L48_bool_binop_done:; - if (unlikely(__pyx_t_1)) { + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":261 - * f" but got {screen_size}") + /* "l0learn/interface.pyx":118 + * * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " # <<<<<<<<<<<<<< * f"but got {exclude_first_k}") * if not isinstance(intercept, bool): */ - __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 261, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 118, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -4654,7 +4535,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_9 += 70; __Pyx_GIVEREF(__pyx_kp_u_expected_exclude_first_k_paramet); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_exclude_first_k_paramet); - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 261, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 118, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); @@ -4666,14 +4547,14 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_GIVEREF(__pyx_kp_u_but_got); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_but_got); - /* "l0learn/interface.pyx":262 + /* "l0learn/interface.pyx":119 * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " * f"but got {exclude_first_k}") # <<<<<<<<<<<<<< * if not isinstance(intercept, bool): * raise ValueError(f"expected intercept parameter to be a bool, " */ - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_exclude_first_k, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 262, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_exclude_first_k, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 119, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); @@ -4681,106 +4562,106 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":261 - * f" but got {screen_size}") + /* "l0learn/interface.pyx":118 + * * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " # <<<<<<<<<<<<<< * f"but got {exclude_first_k}") * if not isinstance(intercept, bool): */ - __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 261, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 118, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 261, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 118, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 261, __pyx_L1_error) + __PYX_ERR(0, 118, __pyx_L1_error) - /* "l0learn/interface.pyx":260 - * raise ValueError(f"expected screen_size parameter to be a positive integer less than {p}," - * f" but got {screen_size}") + /* "l0learn/interface.pyx":117 + * screen_size = min(screen_size, p) + * * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): # <<<<<<<<<<<<<< * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " * f"but got {exclude_first_k}") */ } - /* "l0learn/interface.pyx":263 + /* "l0learn/interface.pyx":120 * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " * f"but got {exclude_first_k}") * if not isinstance(intercept, bool): # <<<<<<<<<<<<<< * raise ValueError(f"expected intercept parameter to be a bool, " - * f"but got {intercept}") + * f"but got {intercept}") */ __pyx_t_7 = ((PyObject*)&PyBool_Type); __Pyx_INCREF(__pyx_t_7); - __pyx_t_1 = PyObject_IsInstance(__pyx_v_intercept, __pyx_t_7); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 263, __pyx_L1_error) + __pyx_t_4 = PyObject_IsInstance(__pyx_v_intercept, __pyx_t_7); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_5 = ((!(__pyx_t_1 != 0)) != 0); + __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":265 + /* "l0learn/interface.pyx":122 * if not isinstance(intercept, bool): * raise ValueError(f"expected intercept parameter to be a bool, " - * f"but got {intercept}") # <<<<<<<<<<<<<< + * f"but got {intercept}") # <<<<<<<<<<<<<< * * if loss in CLASSIFICATION_LOSS: */ - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_intercept, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 265, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_intercept, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 122, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - /* "l0learn/interface.pyx":264 + /* "l0learn/interface.pyx":121 * f"but got {exclude_first_k}") * if not isinstance(intercept, bool): * raise ValueError(f"expected intercept parameter to be a bool, " # <<<<<<<<<<<<<< - * f"but got {intercept}") + * f"but got {intercept}") * */ - __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_intercept_parameter_to, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 264, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_intercept_parameter_to, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 121, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 264, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 121, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 264, __pyx_L1_error) + __PYX_ERR(0, 121, __pyx_L1_error) - /* "l0learn/interface.pyx":263 + /* "l0learn/interface.pyx":120 * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " * f"but got {exclude_first_k}") * if not isinstance(intercept, bool): # <<<<<<<<<<<<<< * raise ValueError(f"expected intercept parameter to be a bool, " - * f"but got {intercept}") + * f"but got {intercept}") */ } - /* "l0learn/interface.pyx":267 - * f"but got {intercept}") + /* "l0learn/interface.pyx":124 + * f"but got {intercept}") * * if loss in CLASSIFICATION_LOSS: # <<<<<<<<<<<<<< * unique_items = sorted(np.unique(y)) - * if 0 >= len(unique_items) > 2: + * if len(unique_items) != 2: */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_CLASSIFICATION_LOSS); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 267, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_CLASSIFICATION_LOSS); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 124, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_v_loss, __pyx_t_7, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 267, __pyx_L1_error) + __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_v_loss, __pyx_t_7, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 124, __pyx_L1_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_1 = (__pyx_t_5 != 0); - if (__pyx_t_1) { + __pyx_t_4 = (__pyx_t_5 != 0); + if (__pyx_t_4) { - /* "l0learn/interface.pyx":268 + /* "l0learn/interface.pyx":125 * * if loss in CLASSIFICATION_LOSS: * unique_items = sorted(np.unique(y)) # <<<<<<<<<<<<<< - * if 0 >= len(unique_items) > 2: + * if len(unique_items) != 2: * raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 268, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 125, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_unique); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 268, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_unique); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 125, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; @@ -4795,85 +4676,81 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx } __pyx_t_3 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_2, __pyx_v_y) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_y); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 268, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 125, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = PySequence_List(__pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 268, __pyx_L1_error) + __pyx_t_8 = PySequence_List(__pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 125, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_7 = ((PyObject*)__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_12 = PyList_Sort(__pyx_t_7); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 268, __pyx_L1_error) + __pyx_t_12 = PyList_Sort(__pyx_t_7); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 125, __pyx_L1_error) __pyx_v_unique_items = ((PyObject*)__pyx_t_7); __pyx_t_7 = 0; - /* "l0learn/interface.pyx":269 + /* "l0learn/interface.pyx":126 * if loss in CLASSIFICATION_LOSS: * unique_items = sorted(np.unique(y)) - * if 0 >= len(unique_items) > 2: # <<<<<<<<<<<<<< + * if len(unique_items) != 2: # <<<<<<<<<<<<<< * raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " * f"but got {unique_items}") */ if (unlikely(__pyx_v_unique_items == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(0, 269, __pyx_L1_error) - } - __pyx_t_9 = PyList_GET_SIZE(__pyx_v_unique_items); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 269, __pyx_L1_error) - __pyx_t_1 = (0 >= __pyx_t_9); - if (__pyx_t_1) { - __pyx_t_1 = (__pyx_t_9 > 2); + __PYX_ERR(0, 126, __pyx_L1_error) } - __pyx_t_5 = (__pyx_t_1 != 0); - if (unlikely(__pyx_t_5)) { + __pyx_t_9 = PyList_GET_SIZE(__pyx_v_unique_items); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 126, __pyx_L1_error) + __pyx_t_4 = ((__pyx_t_9 != 2) != 0); + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":271 - * if 0 >= len(unique_items) > 2: + /* "l0learn/interface.pyx":128 + * if len(unique_items) != 2: * raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " * f"but got {unique_items}") # <<<<<<<<<<<<<< * else: * a, *_ = unique_items # a is the lower value */ - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_unique_items, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 271, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_unique_items, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 128, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - /* "l0learn/interface.pyx":270 + /* "l0learn/interface.pyx":127 * unique_items = sorted(np.unique(y)) - * if 0 >= len(unique_items) > 2: + * if len(unique_items) != 2: * raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " # <<<<<<<<<<<<<< * f"but got {unique_items}") * else: */ - __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_y_vector_to_only_have_t, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 270, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_y_vector_to_only_have_t, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 127, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 270, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 127, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 270, __pyx_L1_error) + __PYX_ERR(0, 127, __pyx_L1_error) - /* "l0learn/interface.pyx":269 + /* "l0learn/interface.pyx":126 * if loss in CLASSIFICATION_LOSS: * unique_items = sorted(np.unique(y)) - * if 0 >= len(unique_items) > 2: # <<<<<<<<<<<<<< + * if len(unique_items) != 2: # <<<<<<<<<<<<<< * raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " * f"but got {unique_items}") */ } - /* "l0learn/interface.pyx":273 + /* "l0learn/interface.pyx":130 * f"but got {unique_items}") * else: * a, *_ = unique_items # a is the lower value # <<<<<<<<<<<<<< * y = np.copy(y) - * y[y==a] = -1 + * first_value = y==a */ /*else*/ { { Py_ssize_t index = -1; PyObject** temps[2] = {&__pyx_t_7}; - __pyx_t_8 = PyObject_GetIter(__pyx_v_unique_items); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 273, __pyx_L1_error) + __pyx_t_8 = PyObject_GetIter(__pyx_v_unique_items); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 130, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_11 = Py_TYPE(__pyx_t_8)->tp_iternext; for (index=0; index < 1; index++) { @@ -4886,10 +4763,10 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_11 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 273, __pyx_L1_error) + __PYX_ERR(0, 130, __pyx_L1_error) __pyx_L54_unpacking_done:; } - __pyx_t_3 = PySequence_List(__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 273, __pyx_L1_error) + __pyx_t_3 = PySequence_List(__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 130, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_a = __pyx_t_7; @@ -4897,16 +4774,16 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_v__ = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":274 + /* "l0learn/interface.pyx":131 * else: * a, *_ = unique_items # a is the lower value * y = np.copy(y) # <<<<<<<<<<<<<< - * y[y==a] = -1 - * y[y!=a] = 1 + * first_value = y==a + * second_value = y!=a */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 274, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 131, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_copy); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 274, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_copy); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 131, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; @@ -4921,103 +4798,178 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx } __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_7, __pyx_v_y) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_y); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 274, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 131, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF_SET(__pyx_v_y, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":275 + /* "l0learn/interface.pyx":132 * a, *_ = unique_items # a is the lower value * y = np.copy(y) - * y[y==a] = -1 # <<<<<<<<<<<<<< - * y[y!=a] = 1 + * first_value = y==a # <<<<<<<<<<<<<< + * second_value = y!=a + * y[first_value] = -1.0 + */ + __pyx_t_3 = PyObject_RichCompare(__pyx_v_y, __pyx_v_a, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 132, __pyx_L1_error) + __pyx_v_first_value = __pyx_t_3; + __pyx_t_3 = 0; + + /* "l0learn/interface.pyx":133 + * y = np.copy(y) + * first_value = y==a + * second_value = y!=a # <<<<<<<<<<<<<< + * y[first_value] = -1.0 + * y[second_value] = 1.0 + */ + __pyx_t_3 = PyObject_RichCompare(__pyx_v_y, __pyx_v_a, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 133, __pyx_L1_error) + __pyx_v_second_value = __pyx_t_3; + __pyx_t_3 = 0; + + /* "l0learn/interface.pyx":134 + * first_value = y==a + * second_value = y!=a + * y[first_value] = -1.0 # <<<<<<<<<<<<<< + * y[second_value] = 1.0 + * if y.dtype != np.float64: + */ + if (unlikely(PyObject_SetItem(__pyx_v_y, __pyx_v_first_value, __pyx_float_neg_1_0) < 0)) __PYX_ERR(0, 134, __pyx_L1_error) + + /* "l0learn/interface.pyx":135 + * second_value = y!=a + * y[first_value] = -1.0 + * y[second_value] = 1.0 # <<<<<<<<<<<<<< + * if y.dtype != np.float64: + * y = y.astype(float) + */ + if (unlikely(PyObject_SetItem(__pyx_v_y, __pyx_v_second_value, __pyx_float_1_0) < 0)) __PYX_ERR(0, 135, __pyx_L1_error) + + /* "l0learn/interface.pyx":136 + * y[first_value] = -1.0 + * y[second_value] = 1.0 + * if y.dtype != np.float64: # <<<<<<<<<<<<<< + * y = y.astype(float) * */ - __pyx_t_3 = PyObject_RichCompare(__pyx_v_y, __pyx_v_a, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 275, __pyx_L1_error) - if (unlikely(PyObject_SetItem(__pyx_v_y, __pyx_t_3, __pyx_int_neg_1) < 0)) __PYX_ERR(0, 275, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_y, __pyx_n_s_dtype); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_float64); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyObject_RichCompare(__pyx_t_3, __pyx_t_7, Py_NE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 136, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (__pyx_t_4) { - /* "l0learn/interface.pyx":276 - * y = np.copy(y) - * y[y==a] = -1 - * y[y!=a] = 1 # <<<<<<<<<<<<<< + /* "l0learn/interface.pyx":137 + * y[second_value] = 1.0 + * if y.dtype != np.float64: + * y = y.astype(float) # <<<<<<<<<<<<<< * * if penalty == "L0": */ - __pyx_t_3 = PyObject_RichCompare(__pyx_v_y, __pyx_v_a, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 276, __pyx_L1_error) - if (unlikely(PyObject_SetItem(__pyx_v_y, __pyx_t_3, __pyx_int_1) < 0)) __PYX_ERR(0, 276, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_y, __pyx_n_s_astype); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + __pyx_t_8 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_3, ((PyObject *)(&PyFloat_Type))) : __Pyx_PyObject_CallOneArg(__pyx_t_7, ((PyObject *)(&PyFloat_Type))); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF_SET(__pyx_v_y, __pyx_t_8); + __pyx_t_8 = 0; + + /* "l0learn/interface.pyx":136 + * y[first_value] = -1.0 + * y[second_value] = 1.0 + * if y.dtype != np.float64: # <<<<<<<<<<<<<< + * y = y.astype(float) + * + */ + } } - /* "l0learn/interface.pyx":278 - * y[y!=a] = 1 + /* "l0learn/interface.pyx":139 + * y = y.astype(float) * * if penalty == "L0": # <<<<<<<<<<<<<< * # Pure L0 is not supported for classification * # Below we add a small L2 component. */ - __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 278, __pyx_L1_error) - __pyx_t_1 = (__pyx_t_5 != 0); - if (__pyx_t_1) { + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 139, __pyx_L1_error) + __pyx_t_5 = (__pyx_t_4 != 0); + if (__pyx_t_5) { - /* "l0learn/interface.pyx":282 + /* "l0learn/interface.pyx":143 * # Below we add a small L2 component. * * if lambda_grid is not None and len(lambda_grid) != 1: # <<<<<<<<<<<<<< * # If this error checking was left to the lower section, it would confuse users as * # we are converting L0 to L0L2 with small L2 penalty. */ - __pyx_t_5 = (__pyx_v_lambda_grid != Py_None); - __pyx_t_4 = (__pyx_t_5 != 0); - if (__pyx_t_4) { + __pyx_t_4 = (__pyx_v_lambda_grid != Py_None); + __pyx_t_1 = (__pyx_t_4 != 0); + if (__pyx_t_1) { } else { - __pyx_t_1 = __pyx_t_4; - goto __pyx_L57_bool_binop_done; + __pyx_t_5 = __pyx_t_1; + goto __pyx_L58_bool_binop_done; } - __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 282, __pyx_L1_error) - __pyx_t_4 = ((__pyx_t_9 != 1) != 0); - __pyx_t_1 = __pyx_t_4; - __pyx_L57_bool_binop_done:; - if (unlikely(__pyx_t_1)) { + __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 143, __pyx_L1_error) + __pyx_t_1 = ((__pyx_t_9 != 1) != 0); + __pyx_t_5 = __pyx_t_1; + __pyx_L58_bool_binop_done:; + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":287 + /* "l0learn/interface.pyx":148 * # Here we must check if lambdaGrid is supplied (And thus use 'autolambda') * # If 'lambdaGrid' is supplied, we must only supply 1 list of lambda values * raise ValueError(f"L0 Penalty requires 'lambda_grid' to be a list of length 1, but got {lambda_grid}.") # <<<<<<<<<<<<<< * * penalty = "L0L2" */ - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 287, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_L0_Penalty_requires_lambda_grid); __pyx_t_9 += 68; __Pyx_GIVEREF(__pyx_kp_u_L0_Penalty_requires_lambda_grid); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_L0_Penalty_requires_lambda_grid); - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 287, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); - __Pyx_GIVEREF(__pyx_t_8); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_8); - __pyx_t_8 = 0; + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_u_L0_Penalty_requires_lambda_grid); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7); + __pyx_t_7 = 0; __Pyx_INCREF(__pyx_kp_u__5); __pyx_t_9 += 1; __Pyx_GIVEREF(__pyx_kp_u__5); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u__5); - __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 287, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__5); + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 148, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 287, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 287, __pyx_L1_error) + __PYX_ERR(0, 148, __pyx_L1_error) - /* "l0learn/interface.pyx":282 + /* "l0learn/interface.pyx":143 * # Below we add a small L2 component. * * if lambda_grid is not None and len(lambda_grid) != 1: # <<<<<<<<<<<<<< @@ -5026,8 +4978,8 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":278 - * y[y!=a] = 1 + /* "l0learn/interface.pyx":139 + * y = y.astype(float) * * if penalty == "L0": # <<<<<<<<<<<<<< * # Pure L0 is not supported for classification @@ -5035,7 +4987,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":289 + /* "l0learn/interface.pyx":150 * raise ValueError(f"L0 Penalty requires 'lambda_grid' to be a list of length 1, but got {lambda_grid}.") * * penalty = "L0L2" # <<<<<<<<<<<<<< @@ -5045,7 +4997,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_INCREF(__pyx_n_u_L0L2); __Pyx_DECREF_SET(__pyx_v_penalty, __pyx_n_u_L0L2); - /* "l0learn/interface.pyx":290 + /* "l0learn/interface.pyx":151 * * penalty = "L0L2" * gamma_max = 1e-7 # <<<<<<<<<<<<<< @@ -5054,7 +5006,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ __pyx_v_gamma_max = 1e-7; - /* "l0learn/interface.pyx":291 + /* "l0learn/interface.pyx":152 * penalty = "L0L2" * gamma_max = 1e-7 * gamma_min = 1e-7 # <<<<<<<<<<<<<< @@ -5063,103 +5015,103 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ __pyx_v_gamma_min = 1e-7; - /* "l0learn/interface.pyx":267 - * f"but got {intercept}") + /* "l0learn/interface.pyx":124 + * f"but got {intercept}") * * if loss in CLASSIFICATION_LOSS: # <<<<<<<<<<<<<< * unique_items = sorted(np.unique(y)) - * if 0 >= len(unique_items) > 2: + * if len(unique_items) != 2: */ goto __pyx_L51; } - /* "l0learn/interface.pyx":292 + /* "l0learn/interface.pyx":153 * gamma_max = 1e-7 * gamma_min = 1e-7 * elif penalty != "L0" and num_gamma == 1: # <<<<<<<<<<<<<< * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") * */ - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_NE)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 292, __pyx_L1_error) - __pyx_t_5 = (__pyx_t_4 != 0); - if (__pyx_t_5) { + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 153, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_1 != 0); + if (__pyx_t_4) { } else { - __pyx_t_1 = __pyx_t_5; - goto __pyx_L59_bool_binop_done; + __pyx_t_5 = __pyx_t_4; + goto __pyx_L60_bool_binop_done; } - __pyx_t_3 = __Pyx_PyInt_EqObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 292, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 292, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_1 = __pyx_t_5; - __pyx_L59_bool_binop_done:; - if (__pyx_t_1) { + __pyx_t_8 = __Pyx_PyInt_EqObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_5 = __pyx_t_4; + __pyx_L60_bool_binop_done:; + if (__pyx_t_5) { - /* "l0learn/interface.pyx":293 + /* "l0learn/interface.pyx":154 * gamma_min = 1e-7 * elif penalty != "L0" and num_gamma == 1: * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") # <<<<<<<<<<<<<< * - * if lambda_grid is None: + * if y.dtype != np.float64: */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_warn); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 293, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = PyTuple_New(5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 293, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_warn); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = PyTuple_New(5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_num_gamma_set_to_1_with); __pyx_t_9 += 24; __Pyx_GIVEREF(__pyx_kp_u_num_gamma_set_to_1_with); - PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_num_gamma_set_to_1_with); - __pyx_t_2 = __Pyx_PyUnicode_Unicode(__pyx_v_penalty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 293, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_num_gamma_set_to_1_with); + __pyx_t_2 = __Pyx_PyUnicode_Unicode(__pyx_v_penalty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); __pyx_t_2 = 0; __Pyx_INCREF(__pyx_kp_u_penalty_Only_one); __pyx_t_9 += 19; __Pyx_GIVEREF(__pyx_kp_u_penalty_Only_one); - PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_penalty_Only_one); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_penalty_Only_one); if (unlikely(__pyx_v_penalty == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(0, 293, __pyx_L1_error) + __PYX_ERR(0, 154, __pyx_L1_error) } - __pyx_t_2 = __Pyx_PyUnicode_Substring(__pyx_v_penalty, 2, PY_SSIZE_T_MAX); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 293, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyUnicode_Substring(__pyx_v_penalty, 2, PY_SSIZE_T_MAX); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_2); __pyx_t_2 = 0; __Pyx_INCREF(__pyx_kp_u_penalty_value_will_be_fit); __pyx_t_9 += 27; __Pyx_GIVEREF(__pyx_kp_u_penalty_value_will_be_fit); - PyTuple_SET_ITEM(__pyx_t_7, 4, __pyx_kp_u_penalty_value_will_be_fit); - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_7, 5, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 293, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_3, 4, __pyx_kp_u_penalty_value_will_be_fit); + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_3, 5, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); - if (likely(__pyx_t_7)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); - __Pyx_INCREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_8, function); + __Pyx_DECREF_SET(__pyx_t_7, function); } } - __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_7, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_2); - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_3, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 293, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":292 + /* "l0learn/interface.pyx":153 * gamma_max = 1e-7 * gamma_min = 1e-7 * elif penalty != "L0" and num_gamma == 1: # <<<<<<<<<<<<<< @@ -5169,38 +5121,120 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx } __pyx_L51:; - /* "l0learn/interface.pyx":295 + /* "l0learn/interface.pyx":156 + * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") + * + * if y.dtype != np.float64: # <<<<<<<<<<<<<< + * raise ValueError(f"expected y vector to have type {np.float64}, but got {y.dtype}") + * + */ + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_y, __pyx_n_s_dtype); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_float64); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyObject_RichCompare(__pyx_t_8, __pyx_t_2, Py_NE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 156, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 156, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(__pyx_t_5)) { + + /* "l0learn/interface.pyx":157 + * + * if y.dtype != np.float64: + * raise ValueError(f"expected y vector to have type {np.float64}, but got {y.dtype}") # <<<<<<<<<<<<<< + * + * if lambda_grid is None: + */ + __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = 0; + __pyx_t_10 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_y_vector_to_have_type); + __pyx_t_9 += 31; + __Pyx_GIVEREF(__pyx_kp_u_expected_y_vector_to_have_type); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_y_vector_to_have_type); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_float64); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_8, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_kp_u_but_got); + __pyx_t_9 += 10; + __Pyx_GIVEREF(__pyx_kp_u_but_got); + PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_but_got); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_y, __pyx_n_s_dtype); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(0, 157, __pyx_L1_error) + + /* "l0learn/interface.pyx":156 * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") * + * if y.dtype != np.float64: # <<<<<<<<<<<<<< + * raise ValueError(f"expected y vector to have type {np.float64}, but got {y.dtype}") + * + */ + } + + /* "l0learn/interface.pyx":159 + * raise ValueError(f"expected y vector to have type {np.float64}, but got {y.dtype}") + * * if lambda_grid is None: # <<<<<<<<<<<<<< * lambda_grid = [[0.]] * auto_lambda = True */ - __pyx_t_1 = (__pyx_v_lambda_grid == Py_None); - __pyx_t_5 = (__pyx_t_1 != 0); - if (__pyx_t_5) { + __pyx_t_5 = (__pyx_v_lambda_grid == Py_None); + __pyx_t_4 = (__pyx_t_5 != 0); + if (__pyx_t_4) { - /* "l0learn/interface.pyx":296 + /* "l0learn/interface.pyx":160 * * if lambda_grid is None: * lambda_grid = [[0.]] # <<<<<<<<<<<<<< * auto_lambda = True * if not isinstance(num_lambda, int) or num_lambda < 1: */ - __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 296, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = PyList_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 160, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); __Pyx_INCREF(__pyx_float_0_); __Pyx_GIVEREF(__pyx_float_0_); - PyList_SET_ITEM(__pyx_t_3, 0, __pyx_float_0_); - __pyx_t_8 = PyList_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 296, __pyx_L1_error) + PyList_SET_ITEM(__pyx_t_7, 0, __pyx_float_0_); + __pyx_t_8 = PyList_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 160, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_GIVEREF(__pyx_t_3); - PyList_SET_ITEM(__pyx_t_8, 0, __pyx_t_3); - __pyx_t_3 = 0; + __Pyx_GIVEREF(__pyx_t_7); + PyList_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); + __pyx_t_7 = 0; __Pyx_DECREF_SET(__pyx_v_lambda_grid, __pyx_t_8); __pyx_t_8 = 0; - /* "l0learn/interface.pyx":297 + /* "l0learn/interface.pyx":161 * if lambda_grid is None: * lambda_grid = [[0.]] * auto_lambda = True # <<<<<<<<<<<<<< @@ -5209,35 +5243,35 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ __pyx_v_auto_lambda = 1; - /* "l0learn/interface.pyx":298 + /* "l0learn/interface.pyx":162 * lambda_grid = [[0.]] * auto_lambda = True * if not isinstance(num_lambda, int) or num_lambda < 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") * if not isinstance(num_gamma, int) or num_gamma < 1: */ - __pyx_t_1 = PyInt_Check(__pyx_v_num_lambda); - __pyx_t_4 = ((!(__pyx_t_1 != 0)) != 0); - if (!__pyx_t_4) { + __pyx_t_5 = PyInt_Check(__pyx_v_num_lambda); + __pyx_t_1 = ((!(__pyx_t_5 != 0)) != 0); + if (!__pyx_t_1) { } else { - __pyx_t_5 = __pyx_t_4; - goto __pyx_L63_bool_binop_done; + __pyx_t_4 = __pyx_t_1; + goto __pyx_L65_bool_binop_done; } - __pyx_t_8 = PyObject_RichCompare(__pyx_v_num_lambda, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 298, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 298, __pyx_L1_error) + __pyx_t_8 = PyObject_RichCompare(__pyx_v_num_lambda, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 162, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 162, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_5 = __pyx_t_4; - __pyx_L63_bool_binop_done:; - if (unlikely(__pyx_t_5)) { + __pyx_t_4 = __pyx_t_1; + __pyx_L65_bool_binop_done:; + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":299 + /* "l0learn/interface.pyx":163 * auto_lambda = True * if not isinstance(num_lambda, int) or num_lambda < 1: * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") # <<<<<<<<<<<<<< * if not isinstance(num_gamma, int) or num_gamma < 1: * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") */ - __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 299, __pyx_L1_error) + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 163, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -5245,28 +5279,28 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_9 += 76; __Pyx_GIVEREF(__pyx_kp_u_expected_num_lambda_to_a_positiv); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_u_expected_num_lambda_to_a_positiv); - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 299, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_3); - __pyx_t_3 = 0; + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 163, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7); + __pyx_t_7 = 0; __Pyx_INCREF(__pyx_kp_u__5); __pyx_t_9 += 1; __Pyx_GIVEREF(__pyx_kp_u__5); PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__5); - __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 299, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 163, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 299, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 163, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 299, __pyx_L1_error) + __PYX_ERR(0, 163, __pyx_L1_error) - /* "l0learn/interface.pyx":298 + /* "l0learn/interface.pyx":162 * lambda_grid = [[0.]] * auto_lambda = True * if not isinstance(num_lambda, int) or num_lambda < 1: # <<<<<<<<<<<<<< @@ -5275,35 +5309,35 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":300 + /* "l0learn/interface.pyx":164 * if not isinstance(num_lambda, int) or num_lambda < 1: * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") * if not isinstance(num_gamma, int) or num_gamma < 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") * if penalty == "L0" and num_gamma != 1: */ - __pyx_t_4 = PyInt_Check(__pyx_v_num_gamma); - __pyx_t_1 = ((!(__pyx_t_4 != 0)) != 0); - if (!__pyx_t_1) { + __pyx_t_1 = PyInt_Check(__pyx_v_num_gamma); + __pyx_t_5 = ((!(__pyx_t_1 != 0)) != 0); + if (!__pyx_t_5) { } else { - __pyx_t_5 = __pyx_t_1; - goto __pyx_L66_bool_binop_done; + __pyx_t_4 = __pyx_t_5; + goto __pyx_L68_bool_binop_done; } - __pyx_t_8 = PyObject_RichCompare(__pyx_v_num_gamma, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 300, __pyx_L1_error) - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 300, __pyx_L1_error) + __pyx_t_8 = PyObject_RichCompare(__pyx_v_num_gamma, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 164, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 164, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_5 = __pyx_t_1; - __pyx_L66_bool_binop_done:; - if (unlikely(__pyx_t_5)) { + __pyx_t_4 = __pyx_t_5; + __pyx_L68_bool_binop_done:; + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":301 + /* "l0learn/interface.pyx":165 * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") * if not isinstance(num_gamma, int) or num_gamma < 1: * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") # <<<<<<<<<<<<<< * if penalty == "L0" and num_gamma != 1: * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") */ - __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 301, __pyx_L1_error) + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 165, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -5311,28 +5345,28 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_9 += 75; __Pyx_GIVEREF(__pyx_kp_u_expected_num_gamma_to_a_positive); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_u_expected_num_gamma_to_a_positive); - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 301, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_3); - __pyx_t_3 = 0; + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7); + __pyx_t_7 = 0; __Pyx_INCREF(__pyx_kp_u__5); __pyx_t_9 += 1; __Pyx_GIVEREF(__pyx_kp_u__5); PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__5); - __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 301, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 301, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 165, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 301, __pyx_L1_error) + __PYX_ERR(0, 165, __pyx_L1_error) - /* "l0learn/interface.pyx":300 + /* "l0learn/interface.pyx":164 * if not isinstance(num_lambda, int) or num_lambda < 1: * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") * if not isinstance(num_gamma, int) or num_gamma < 1: # <<<<<<<<<<<<<< @@ -5341,36 +5375,36 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":302 + /* "l0learn/interface.pyx":166 * if not isinstance(num_gamma, int) or num_gamma < 1: * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") * else: # lambda_grid should be a List[List[float]] */ - __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 302, __pyx_L1_error) - __pyx_t_4 = (__pyx_t_1 != 0); - if (__pyx_t_4) { + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 166, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_5 != 0); + if (__pyx_t_1) { } else { - __pyx_t_5 = __pyx_t_4; - goto __pyx_L69_bool_binop_done; + __pyx_t_4 = __pyx_t_1; + goto __pyx_L71_bool_binop_done; } - __pyx_t_8 = __Pyx_PyInt_NeObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 302, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_NeObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 166, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 302, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 166, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_5 = __pyx_t_4; - __pyx_L69_bool_binop_done:; - if (unlikely(__pyx_t_5)) { + __pyx_t_4 = __pyx_t_1; + __pyx_L71_bool_binop_done:; + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":303 + /* "l0learn/interface.pyx":167 * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") * if penalty == "L0" and num_gamma != 1: * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") # <<<<<<<<<<<<<< * else: # lambda_grid should be a List[List[float]] * if num_gamma is not None: */ - __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 303, __pyx_L1_error) + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 167, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = 0; __pyx_t_10 = 127; @@ -5378,28 +5412,28 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_9 += 53; __Pyx_GIVEREF(__pyx_kp_u_expected_num_gamma_to_1_when_pen); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_u_expected_num_gamma_to_1_when_pen); - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 303, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_3); - __pyx_t_3 = 0; + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; + __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7); + __pyx_t_7 = 0; __Pyx_INCREF(__pyx_kp_u__5); __pyx_t_9 += 1; __Pyx_GIVEREF(__pyx_kp_u__5); PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__5); - __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 303, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 303, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 167, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 303, __pyx_L1_error) + __PYX_ERR(0, 167, __pyx_L1_error) - /* "l0learn/interface.pyx":302 + /* "l0learn/interface.pyx":166 * if not isinstance(num_gamma, int) or num_gamma < 1: * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< @@ -5408,17 +5442,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":295 - * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") + /* "l0learn/interface.pyx":159 + * raise ValueError(f"expected y vector to have type {np.float64}, but got {y.dtype}") * * if lambda_grid is None: # <<<<<<<<<<<<<< * lambda_grid = [[0.]] * auto_lambda = True */ - goto __pyx_L61; + goto __pyx_L63; } - /* "l0learn/interface.pyx":305 + /* "l0learn/interface.pyx":169 * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") * else: # lambda_grid should be a List[List[float]] * if num_gamma is not None: # <<<<<<<<<<<<<< @@ -5426,38 +5460,38 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx * f"but got {num_gamma}") */ /*else*/ { - __pyx_t_5 = (__pyx_v_num_gamma != Py_None); - __pyx_t_4 = (__pyx_t_5 != 0); - if (unlikely(__pyx_t_4)) { + __pyx_t_4 = (__pyx_v_num_gamma != Py_None); + __pyx_t_1 = (__pyx_t_4 != 0); + if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":307 + /* "l0learn/interface.pyx":171 * if num_gamma is not None: * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " * f"but got {num_gamma}") # <<<<<<<<<<<<<< * num_gamma = len(lambda_grid) * */ - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 307, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 171, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - /* "l0learn/interface.pyx":306 + /* "l0learn/interface.pyx":170 * else: # lambda_grid should be a List[List[float]] * if num_gamma is not None: * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " # <<<<<<<<<<<<<< * f"but got {num_gamma}") * num_gamma = len(lambda_grid) */ - __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_gamma_to_be_None_if, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 306, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_gamma_to_be_None_if, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 306, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 306, __pyx_L1_error) + __PYX_ERR(0, 170, __pyx_L1_error) - /* "l0learn/interface.pyx":305 + /* "l0learn/interface.pyx":169 * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") * else: # lambda_grid should be a List[List[float]] * if num_gamma is not None: # <<<<<<<<<<<<<< @@ -5466,58 +5500,58 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":308 + /* "l0learn/interface.pyx":172 * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " * f"but got {num_gamma}") * num_gamma = len(lambda_grid) # <<<<<<<<<<<<<< * * if num_lambda is not None: */ - __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 308, __pyx_L1_error) - __pyx_t_8 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 308, __pyx_L1_error) + __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 172, __pyx_L1_error) + __pyx_t_8 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 172, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF_SET(__pyx_v_num_gamma, __pyx_t_8); __pyx_t_8 = 0; - /* "l0learn/interface.pyx":310 + /* "l0learn/interface.pyx":174 * num_gamma = len(lambda_grid) * * if num_lambda is not None: # <<<<<<<<<<<<<< * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " * f"but got {num_lambda}") */ - __pyx_t_4 = (__pyx_v_num_lambda != Py_None); - __pyx_t_5 = (__pyx_t_4 != 0); - if (unlikely(__pyx_t_5)) { + __pyx_t_1 = (__pyx_v_num_lambda != Py_None); + __pyx_t_4 = (__pyx_t_1 != 0); + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":312 + /* "l0learn/interface.pyx":176 * if num_lambda is not None: * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " * f"but got {num_lambda}") # <<<<<<<<<<<<<< * num_lambda = 0 # This value is ignored. * auto_lambda = False */ - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 312, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 176, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - /* "l0learn/interface.pyx":311 + /* "l0learn/interface.pyx":175 * * if num_lambda is not None: * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " # <<<<<<<<<<<<<< * f"but got {num_lambda}") * num_lambda = 0 # This value is ignored. */ - __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_lambda_to_be_None_i, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 311, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_lambda_to_be_None_i, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 175, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 311, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 175, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 311, __pyx_L1_error) + __PYX_ERR(0, 175, __pyx_L1_error) - /* "l0learn/interface.pyx":310 + /* "l0learn/interface.pyx":174 * num_gamma = len(lambda_grid) * * if num_lambda is not None: # <<<<<<<<<<<<<< @@ -5526,7 +5560,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":313 + /* "l0learn/interface.pyx":177 * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " * f"but got {num_lambda}") * num_lambda = 0 # This value is ignored. # <<<<<<<<<<<<<< @@ -5536,7 +5570,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_INCREF(__pyx_int_0); __Pyx_DECREF_SET(__pyx_v_num_lambda, __pyx_int_0); - /* "l0learn/interface.pyx":314 + /* "l0learn/interface.pyx":178 * f"but got {num_lambda}") * num_lambda = 0 # This value is ignored. * auto_lambda = False # <<<<<<<<<<<<<< @@ -5545,7 +5579,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ __pyx_v_auto_lambda = 0; - /* "l0learn/interface.pyx":315 + /* "l0learn/interface.pyx":179 * num_lambda = 0 # This value is ignored. * auto_lambda = False * bad_lambda_grid = False # <<<<<<<<<<<<<< @@ -5554,59 +5588,59 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ __pyx_v_bad_lambda_grid = 0; - /* "l0learn/interface.pyx":317 + /* "l0learn/interface.pyx":181 * bad_lambda_grid = False * * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< - * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") + * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") * */ - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 317, __pyx_L1_error) - __pyx_t_1 = (__pyx_t_4 != 0); - if (__pyx_t_1) { + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 181, __pyx_L1_error) + __pyx_t_5 = (__pyx_t_1 != 0); + if (__pyx_t_5) { } else { - __pyx_t_5 = __pyx_t_1; - goto __pyx_L74_bool_binop_done; + __pyx_t_4 = __pyx_t_5; + goto __pyx_L76_bool_binop_done; } - __pyx_t_8 = __Pyx_PyInt_NeObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 317, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_NeObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 181, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 317, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 181, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_5 = __pyx_t_1; - __pyx_L74_bool_binop_done:; - if (unlikely(__pyx_t_5)) { + __pyx_t_4 = __pyx_t_5; + __pyx_L76_bool_binop_done:; + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":318 + /* "l0learn/interface.pyx":182 * * if penalty == "L0" and num_gamma != 1: - * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") # <<<<<<<<<<<<<< + * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") # <<<<<<<<<<<<<< * * for i, sub_lambda_grid in enumerate(lambda_grid): */ - __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 318, __pyx_L1_error) - __pyx_t_8 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_9, 0, ' ', 'd'); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 318, __pyx_L1_error) + __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 182, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_9, 0, ' ', 'd'); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 182, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_of_lengt, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 318, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_of_lengt, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 182, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 318, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 182, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 318, __pyx_L1_error) + __PYX_ERR(0, 182, __pyx_L1_error) - /* "l0learn/interface.pyx":317 + /* "l0learn/interface.pyx":181 * bad_lambda_grid = False * * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< - * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") + * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") * */ } - /* "l0learn/interface.pyx":320 - * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") + /* "l0learn/interface.pyx":184 + * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") * * for i, sub_lambda_grid in enumerate(lambda_grid): # <<<<<<<<<<<<<< * current = float("inf") @@ -5615,39 +5649,39 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_INCREF(__pyx_int_0); __pyx_t_8 = __pyx_int_0; if (likely(PyList_CheckExact(__pyx_v_lambda_grid)) || PyTuple_CheckExact(__pyx_v_lambda_grid)) { - __pyx_t_3 = __pyx_v_lambda_grid; __Pyx_INCREF(__pyx_t_3); __pyx_t_9 = 0; + __pyx_t_7 = __pyx_v_lambda_grid; __Pyx_INCREF(__pyx_t_7); __pyx_t_9 = 0; __pyx_t_13 = NULL; } else { - __pyx_t_9 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_lambda_grid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 320, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_13 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 320, __pyx_L1_error) + __pyx_t_9 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_v_lambda_grid); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_13 = Py_TYPE(__pyx_t_7)->tp_iternext; if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 184, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_13)) { - if (likely(PyList_CheckExact(__pyx_t_3))) { - if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_3)) break; + if (likely(PyList_CheckExact(__pyx_t_7))) { + if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_7)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_2 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_9); __Pyx_INCREF(__pyx_t_2); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 320, __pyx_L1_error) + __pyx_t_2 = PyList_GET_ITEM(__pyx_t_7, __pyx_t_9); __Pyx_INCREF(__pyx_t_2); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 184, __pyx_L1_error) #else - __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 320, __pyx_L1_error) + __pyx_t_2 = PySequence_ITEM(__pyx_t_7, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 184, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #endif } else { - if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_3)) break; + if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_7)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_9); __Pyx_INCREF(__pyx_t_2); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 320, __pyx_L1_error) + __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_9); __Pyx_INCREF(__pyx_t_2); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 184, __pyx_L1_error) #else - __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 320, __pyx_L1_error) + __pyx_t_2 = PySequence_ITEM(__pyx_t_7, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 184, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #endif } } else { - __pyx_t_2 = __pyx_t_13(__pyx_t_3); + __pyx_t_2 = __pyx_t_13(__pyx_t_7); if (unlikely(!__pyx_t_2)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(0, 320, __pyx_L1_error) + else __PYX_ERR(0, 184, __pyx_L1_error) } break; } @@ -5657,90 +5691,90 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __pyx_t_2 = 0; __Pyx_INCREF(__pyx_t_8); __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_8); - __pyx_t_2 = __Pyx_PyInt_AddObjC(__pyx_t_8, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 320, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_AddObjC(__pyx_t_8, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 184, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = __pyx_t_2; __pyx_t_2 = 0; - /* "l0learn/interface.pyx":321 + /* "l0learn/interface.pyx":185 * * for i, sub_lambda_grid in enumerate(lambda_grid): * current = float("inf") # <<<<<<<<<<<<<< * if sub_lambda_grid[0] <= 0: * raise ValueError(f"Expected all values of lambda_grid to be positive, " */ - __pyx_t_14 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 321, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 185, __pyx_L1_error) __pyx_v_current = __pyx_t_14; - /* "l0learn/interface.pyx":322 + /* "l0learn/interface.pyx":186 * for i, sub_lambda_grid in enumerate(lambda_grid): * current = float("inf") * if sub_lambda_grid[0] <= 0: # <<<<<<<<<<<<<< * raise ValueError(f"Expected all values of lambda_grid to be positive, " * f"but got lambda_grid[{i}] containing a negative value") */ - __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_sub_lambda_grid, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 322, __pyx_L1_error) + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_sub_lambda_grid, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 186, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = PyObject_RichCompare(__pyx_t_2, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 322, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_t_2, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 186, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 322, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(__pyx_t_5)) { + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 186, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":323 + /* "l0learn/interface.pyx":187 * current = float("inf") * if sub_lambda_grid[0] <= 0: * raise ValueError(f"Expected all values of lambda_grid to be positive, " # <<<<<<<<<<<<<< * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): */ - __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 323, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 187, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __pyx_t_15 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_Expected_all_values_of_lambda_gr); __pyx_t_15 += 71; __Pyx_GIVEREF(__pyx_kp_u_Expected_all_values_of_lambda_gr); - PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_Expected_all_values_of_lambda_gr); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_Expected_all_values_of_lambda_gr); - /* "l0learn/interface.pyx":324 + /* "l0learn/interface.pyx":188 * if sub_lambda_grid[0] <= 0: * raise ValueError(f"Expected all values of lambda_grid to be positive, " * f"but got lambda_grid[{i}] containing a negative value") # <<<<<<<<<<<<<< * if any(np.diff(sub_lambda_grid) >= 0): * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " */ - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 324, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 188, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; __pyx_t_15 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); __pyx_t_2 = 0; __Pyx_INCREF(__pyx_kp_u_containing_a_negative_value); __pyx_t_15 += 29; __Pyx_GIVEREF(__pyx_kp_u_containing_a_negative_value); - PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_containing_a_negative_value); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_containing_a_negative_value); - /* "l0learn/interface.pyx":323 + /* "l0learn/interface.pyx":187 * current = float("inf") * if sub_lambda_grid[0] <= 0: * raise ValueError(f"Expected all values of lambda_grid to be positive, " # <<<<<<<<<<<<<< * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): */ - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 323, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 187, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 323, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 187, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_7, 0, 0, 0); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 323, __pyx_L1_error) + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 187, __pyx_L1_error) - /* "l0learn/interface.pyx":322 + /* "l0learn/interface.pyx":186 * for i, sub_lambda_grid in enumerate(lambda_grid): * current = float("inf") * if sub_lambda_grid[0] <= 0: # <<<<<<<<<<<<<< @@ -5749,16 +5783,16 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":325 + /* "l0learn/interface.pyx":189 * raise ValueError(f"Expected all values of lambda_grid to be positive, " * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): # <<<<<<<<<<<<<< * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " * f"but got lambda_grid[{i}] containing an increasing value.") */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 325, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 189, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_diff); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 325, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_diff); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 189, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; @@ -5771,73 +5805,73 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_DECREF_SET(__pyx_t_16, function); } } - __pyx_t_7 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_16, __pyx_t_2, __pyx_v_sub_lambda_grid) : __Pyx_PyObject_CallOneArg(__pyx_t_16, __pyx_v_sub_lambda_grid); + __pyx_t_3 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_16, __pyx_t_2, __pyx_v_sub_lambda_grid) : __Pyx_PyObject_CallOneArg(__pyx_t_16, __pyx_v_sub_lambda_grid); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 325, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_16 = PyObject_RichCompare(__pyx_t_7, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_16); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 325, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_16); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 325, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_16 = PyObject_RichCompare(__pyx_t_3, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_16); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_16); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 325, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(__pyx_t_5)) { + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":326 + /* "l0learn/interface.pyx":190 * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " # <<<<<<<<<<<<<< * f"but got lambda_grid[{i}] containing an increasing value.") * */ - __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 326, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __pyx_t_15 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_Expected_each_element_of_lambda); __pyx_t_15 += 91; __Pyx_GIVEREF(__pyx_kp_u_Expected_each_element_of_lambda); - PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_Expected_each_element_of_lambda); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_Expected_each_element_of_lambda); - /* "l0learn/interface.pyx":327 + /* "l0learn/interface.pyx":191 * if any(np.diff(sub_lambda_grid) >= 0): * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " * f"but got lambda_grid[{i}] containing an increasing value.") # <<<<<<<<<<<<<< * * n, p = X.shape */ - __pyx_t_16 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 327, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 191, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_16) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_16) : __pyx_t_10; __pyx_t_15 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_16); __Pyx_GIVEREF(__pyx_t_16); - PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_16); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_16); __pyx_t_16 = 0; __Pyx_INCREF(__pyx_kp_u_containing_an_increasing_value); __pyx_t_15 += 33; __Pyx_GIVEREF(__pyx_kp_u_containing_an_increasing_value); - PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_containing_an_increasing_value); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_containing_an_increasing_value); - /* "l0learn/interface.pyx":326 + /* "l0learn/interface.pyx":190 * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " # <<<<<<<<<<<<<< * f"but got lambda_grid[{i}] containing an increasing value.") * */ - __pyx_t_16 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 326, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 190, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_16); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 326, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_16); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __Pyx_Raise(__pyx_t_7, 0, 0, 0); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 326, __pyx_L1_error) + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 190, __pyx_L1_error) - /* "l0learn/interface.pyx":325 + /* "l0learn/interface.pyx":189 * raise ValueError(f"Expected all values of lambda_grid to be positive, " * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): # <<<<<<<<<<<<<< @@ -5846,27 +5880,27 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":320 - * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") + /* "l0learn/interface.pyx":184 + * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") * * for i, sub_lambda_grid in enumerate(lambda_grid): # <<<<<<<<<<<<<< * current = float("inf") * if sub_lambda_grid[0] <= 0: */ } - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } - __pyx_L61:; + __pyx_L63:; - /* "l0learn/interface.pyx":329 + /* "l0learn/interface.pyx":193 * f"but got lambda_grid[{i}] containing an increasing value.") * * n, p = X.shape # <<<<<<<<<<<<<< * with_bounds = False * */ - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 329, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 193, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if ((likely(PyTuple_CheckExact(__pyx_t_8))) || (PyList_CheckExact(__pyx_t_8))) { PyObject* sequence = __pyx_t_8; @@ -5874,52 +5908,52 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 329, __pyx_L1_error) + __PYX_ERR(0, 193, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_7 = PyTuple_GET_ITEM(sequence, 1); + __pyx_t_7 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); } else { - __pyx_t_3 = PyList_GET_ITEM(sequence, 0); - __pyx_t_7 = PyList_GET_ITEM(sequence, 1); + __pyx_t_7 = PyList_GET_ITEM(sequence, 0); + __pyx_t_3 = PyList_GET_ITEM(sequence, 1); } - __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx_t_3); #else - __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 329, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 329, __pyx_L1_error) + __pyx_t_7 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 193, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); #endif __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { Py_ssize_t index = -1; - __pyx_t_16 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 329, __pyx_L1_error) + __pyx_t_16 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 193, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_11 = Py_TYPE(__pyx_t_16)->tp_iternext; - index = 0; __pyx_t_3 = __pyx_t_11(__pyx_t_16); if (unlikely(!__pyx_t_3)) goto __pyx_L80_unpacking_failed; - __Pyx_GOTREF(__pyx_t_3); - index = 1; __pyx_t_7 = __pyx_t_11(__pyx_t_16); if (unlikely(!__pyx_t_7)) goto __pyx_L80_unpacking_failed; + index = 0; __pyx_t_7 = __pyx_t_11(__pyx_t_16); if (unlikely(!__pyx_t_7)) goto __pyx_L82_unpacking_failed; __Pyx_GOTREF(__pyx_t_7); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_16), 2) < 0) __PYX_ERR(0, 329, __pyx_L1_error) + index = 1; __pyx_t_3 = __pyx_t_11(__pyx_t_16); if (unlikely(!__pyx_t_3)) goto __pyx_L82_unpacking_failed; + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_16), 2) < 0) __PYX_ERR(0, 193, __pyx_L1_error) __pyx_t_11 = NULL; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - goto __pyx_L81_unpacking_done; - __pyx_L80_unpacking_failed:; + goto __pyx_L83_unpacking_done; + __pyx_L82_unpacking_failed:; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_11 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 329, __pyx_L1_error) - __pyx_L81_unpacking_done:; + __PYX_ERR(0, 193, __pyx_L1_error) + __pyx_L83_unpacking_done:; } - __Pyx_DECREF_SET(__pyx_v_n, __pyx_t_3); - __pyx_t_3 = 0; - __Pyx_DECREF_SET(__pyx_v_p, __pyx_t_7); + __Pyx_DECREF_SET(__pyx_v_n, __pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF_SET(__pyx_v_p, __pyx_t_3); + __pyx_t_3 = 0; - /* "l0learn/interface.pyx":330 + /* "l0learn/interface.pyx":194 * * n, p = X.shape * with_bounds = False # <<<<<<<<<<<<<< @@ -5928,49 +5962,49 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ __pyx_v_with_bounds = 0; - /* "l0learn/interface.pyx":332 + /* "l0learn/interface.pyx":196 * with_bounds = False * * if isinstance(lows, float): # <<<<<<<<<<<<<< * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") */ - __pyx_t_5 = PyFloat_Check(__pyx_v_lows); - __pyx_t_1 = (__pyx_t_5 != 0); - if (__pyx_t_1) { + __pyx_t_4 = PyFloat_Check(__pyx_v_lows); + __pyx_t_5 = (__pyx_t_4 != 0); + if (__pyx_t_5) { - /* "l0learn/interface.pyx":333 + /* "l0learn/interface.pyx":197 * * if isinstance(lows, float): * if lows > 0: # <<<<<<<<<<<<<< * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") * elif lows > -float('inf'): */ - __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_GT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 333, __pyx_L1_error) - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 333, __pyx_L1_error) + __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_GT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 197, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 197, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(__pyx_t_1)) { + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":334 + /* "l0learn/interface.pyx":198 * if isinstance(lows, float): * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") # <<<<<<<<<<<<<< * elif lows > -float('inf'): * with_bounds = True */ - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 334, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 198, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lows_to_be_a_non_positi, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 334, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lows_to_be_a_non_positi, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 334, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 198, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 334, __pyx_L1_error) + __PYX_ERR(0, 198, __pyx_L1_error) - /* "l0learn/interface.pyx":333 + /* "l0learn/interface.pyx":197 * * if isinstance(lows, float): * if lows > 0: # <<<<<<<<<<<<<< @@ -5979,23 +6013,23 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":335 + /* "l0learn/interface.pyx":199 * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") * elif lows > -float('inf'): # <<<<<<<<<<<<<< * with_bounds = True * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): */ - __pyx_t_14 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 335, __pyx_L1_error) - __pyx_t_8 = PyFloat_FromDouble((-__pyx_t_14)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 335, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 199, __pyx_L1_error) + __pyx_t_8 = PyFloat_FromDouble((-__pyx_t_14)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 199, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = PyObject_RichCompare(__pyx_v_lows, __pyx_t_8, Py_GT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 335, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_lows, __pyx_t_8, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 199, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 335, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (__pyx_t_1) { + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 199, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_5) { - /* "l0learn/interface.pyx":336 + /* "l0learn/interface.pyx":200 * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") * elif lows > -float('inf'): * with_bounds = True # <<<<<<<<<<<<<< @@ -6004,7 +6038,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ __pyx_v_with_bounds = 1; - /* "l0learn/interface.pyx":335 + /* "l0learn/interface.pyx":199 * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") * elif lows > -float('inf'): # <<<<<<<<<<<<<< @@ -6013,71 +6047,71 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":332 + /* "l0learn/interface.pyx":196 * with_bounds = False * * if isinstance(lows, float): # <<<<<<<<<<<<<< * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") */ - goto __pyx_L82; + goto __pyx_L84; } - /* "l0learn/interface.pyx":337 + /* "l0learn/interface.pyx":201 * elif lows > -float('inf'): * with_bounds = True * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): # <<<<<<<<<<<<<< * with_bounds = True * else: */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 337, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 337, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 201, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_5 = PyObject_IsInstance(__pyx_v_lows, __pyx_t_8); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 337, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = PyObject_IsInstance(__pyx_v_lows, __pyx_t_8); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 201, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_4 = (__pyx_t_5 != 0); - if (__pyx_t_4) { + __pyx_t_1 = (__pyx_t_4 != 0); + if (__pyx_t_1) { } else { - __pyx_t_1 = __pyx_t_4; - goto __pyx_L84_bool_binop_done; + __pyx_t_5 = __pyx_t_1; + goto __pyx_L86_bool_binop_done; } - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_lows, __pyx_n_s_ndim); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 337, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_lows, __pyx_n_s_ndim); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 201, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = __Pyx_PyInt_EqObjC(__pyx_t_8, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 337, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyInt_EqObjC(__pyx_t_8, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 337, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (__pyx_t_4) { + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_1) { } else { - __pyx_t_1 = __pyx_t_4; - goto __pyx_L84_bool_binop_done; + __pyx_t_5 = __pyx_t_1; + goto __pyx_L86_bool_binop_done; } - __pyx_t_9 = PyObject_Length(__pyx_v_lows); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 337, __pyx_L1_error) - __pyx_t_7 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 337, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = PyObject_RichCompare(__pyx_t_7, __pyx_v_p, Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 337, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 337, __pyx_L1_error) + __pyx_t_9 = PyObject_Length(__pyx_v_lows); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 201, __pyx_L1_error) + __pyx_t_3 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = PyObject_RichCompare(__pyx_t_3, __pyx_v_p, Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 201, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (__pyx_t_4) { + if (__pyx_t_1) { } else { - __pyx_t_1 = __pyx_t_4; - goto __pyx_L84_bool_binop_done; + __pyx_t_5 = __pyx_t_1; + goto __pyx_L86_bool_binop_done; } - __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 337, __pyx_L1_error) - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_all, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 337, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 201, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_all, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 337, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_1 = __pyx_t_4; - __pyx_L84_bool_binop_done:; - if (likely(__pyx_t_1)) { + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __pyx_t_1; + __pyx_L86_bool_binop_done:; + if (likely(__pyx_t_5)) { - /* "l0learn/interface.pyx":338 + /* "l0learn/interface.pyx":202 * with_bounds = True * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): * with_bounds = True # <<<<<<<<<<<<<< @@ -6086,17 +6120,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ __pyx_v_with_bounds = 1; - /* "l0learn/interface.pyx":337 + /* "l0learn/interface.pyx":201 * elif lows > -float('inf'): * with_bounds = True * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): # <<<<<<<<<<<<<< * with_bounds = True * else: */ - goto __pyx_L82; + goto __pyx_L84; } - /* "l0learn/interface.pyx":340 + /* "l0learn/interface.pyx":204 * with_bounds = True * else: * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " # <<<<<<<<<<<<<< @@ -6104,103 +6138,103 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx * */ /*else*/ { - __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 340, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 204, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_expected_lows_to_be_a_non_positi_2); __pyx_t_9 += 72; __Pyx_GIVEREF(__pyx_kp_u_expected_lows_to_be_a_non_positi_2); - PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_lows_to_be_a_non_positi_2); - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 340, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_lows_to_be_a_non_positi_2); + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 204, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); - PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_8); __pyx_t_8 = 0; __Pyx_INCREF(__pyx_kp_u_of_non_positives_floats_but_got); __pyx_t_9 += 34; __Pyx_GIVEREF(__pyx_kp_u_of_non_positives_floats_but_got); - PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_of_non_positives_floats_but_got); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_of_non_positives_floats_but_got); - /* "l0learn/interface.pyx":341 + /* "l0learn/interface.pyx":205 * else: * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " * f"floats, but got {lows}") # <<<<<<<<<<<<<< * * if isinstance(highs, float): */ - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 341, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 205, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); - PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_8); __pyx_t_8 = 0; - /* "l0learn/interface.pyx":340 + /* "l0learn/interface.pyx":204 * with_bounds = True * else: * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " # <<<<<<<<<<<<<< * f"floats, but got {lows}") * */ - __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 340, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 204, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 340, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 204, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_Raise(__pyx_t_7, 0, 0, 0); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 340, __pyx_L1_error) + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 204, __pyx_L1_error) } - __pyx_L82:; + __pyx_L84:; - /* "l0learn/interface.pyx":343 + /* "l0learn/interface.pyx":207 * f"floats, but got {lows}") * * if isinstance(highs, float): # <<<<<<<<<<<<<< * if highs < 0: * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") */ - __pyx_t_1 = PyFloat_Check(__pyx_v_highs); - __pyx_t_4 = (__pyx_t_1 != 0); - if (__pyx_t_4) { + __pyx_t_5 = PyFloat_Check(__pyx_v_highs); + __pyx_t_1 = (__pyx_t_5 != 0); + if (__pyx_t_1) { - /* "l0learn/interface.pyx":344 + /* "l0learn/interface.pyx":208 * * if isinstance(highs, float): * if highs < 0: # <<<<<<<<<<<<<< * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") * if highs < float('inf'): */ - __pyx_t_7 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 344, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 344, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(__pyx_t_4)) { + __pyx_t_3 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 208, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 208, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":345 + /* "l0learn/interface.pyx":209 * if isinstance(highs, float): * if highs < 0: * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") # <<<<<<<<<<<<<< * if highs < float('inf'): * with_bounds = True */ - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 345, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_highs_to_be_a_non_negat, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 345, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_highs_to_be_a_non_negat, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 209, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 345, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_Raise(__pyx_t_7, 0, 0, 0); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 345, __pyx_L1_error) + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 209, __pyx_L1_error) - /* "l0learn/interface.pyx":344 + /* "l0learn/interface.pyx":208 * * if isinstance(highs, float): * if highs < 0: # <<<<<<<<<<<<<< @@ -6209,22 +6243,22 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":346 + /* "l0learn/interface.pyx":210 * if highs < 0: * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") * if highs < float('inf'): # <<<<<<<<<<<<<< * with_bounds = True * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): */ - __pyx_t_7 = __Pyx_PyNumber_Float(__pyx_n_u_inf); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 346, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = PyObject_RichCompare(__pyx_v_highs, __pyx_t_7, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 346, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 346, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyNumber_Float(__pyx_n_u_inf); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = PyObject_RichCompare(__pyx_v_highs, __pyx_t_3, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 210, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 210, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (__pyx_t_4) { + if (__pyx_t_1) { - /* "l0learn/interface.pyx":347 + /* "l0learn/interface.pyx":211 * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") * if highs < float('inf'): * with_bounds = True # <<<<<<<<<<<<<< @@ -6233,7 +6267,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ __pyx_v_with_bounds = 1; - /* "l0learn/interface.pyx":346 + /* "l0learn/interface.pyx":210 * if highs < 0: * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") * if highs < float('inf'): # <<<<<<<<<<<<<< @@ -6242,68 +6276,68 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":343 + /* "l0learn/interface.pyx":207 * f"floats, but got {lows}") * * if isinstance(highs, float): # <<<<<<<<<<<<<< * if highs < 0: * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") */ - goto __pyx_L88; + goto __pyx_L90; } - /* "l0learn/interface.pyx":348 + /* "l0learn/interface.pyx":212 * if highs < float('inf'): * with_bounds = True * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): # <<<<<<<<<<<<<< * with_bounds = True * else: */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 348, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 212, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 348, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_1 = PyObject_IsInstance(__pyx_v_highs, __pyx_t_7); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 348, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_5 = (__pyx_t_1 != 0); - if (__pyx_t_5) { + __pyx_t_5 = PyObject_IsInstance(__pyx_v_highs, __pyx_t_3); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 212, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = (__pyx_t_5 != 0); + if (__pyx_t_4) { } else { - __pyx_t_4 = __pyx_t_5; - goto __pyx_L91_bool_binop_done; + __pyx_t_1 = __pyx_t_4; + goto __pyx_L93_bool_binop_done; } - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_highs, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 348, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyInt_EqObjC(__pyx_t_7, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 348, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_highs, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_PyInt_EqObjC(__pyx_t_3, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 212, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 348, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 212, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (__pyx_t_5) { + if (__pyx_t_4) { } else { - __pyx_t_4 = __pyx_t_5; - goto __pyx_L91_bool_binop_done; + __pyx_t_1 = __pyx_t_4; + goto __pyx_L93_bool_binop_done; } - __pyx_t_9 = PyObject_Length(__pyx_v_highs); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 348, __pyx_L1_error) - __pyx_t_8 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 348, __pyx_L1_error) + __pyx_t_9 = PyObject_Length(__pyx_v_highs); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 212, __pyx_L1_error) + __pyx_t_8 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 212, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = PyObject_RichCompare(__pyx_t_8, __pyx_v_p, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 348, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_t_8, __pyx_v_p, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 212, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 348, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (__pyx_t_5) { + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 212, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_4) { } else { - __pyx_t_4 = __pyx_t_5; - goto __pyx_L91_bool_binop_done; + __pyx_t_1 = __pyx_t_4; + goto __pyx_L93_bool_binop_done; } - __pyx_t_7 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 348, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 348, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = __pyx_t_5; - __pyx_L91_bool_binop_done:; - if (likely(__pyx_t_4)) { + __pyx_t_3 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 212, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 212, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __pyx_t_4; + __pyx_L93_bool_binop_done:; + if (likely(__pyx_t_1)) { - /* "l0learn/interface.pyx":349 + /* "l0learn/interface.pyx":213 * with_bounds = True * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): * with_bounds = True # <<<<<<<<<<<<<< @@ -6312,17 +6346,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ __pyx_v_with_bounds = 1; - /* "l0learn/interface.pyx":348 + /* "l0learn/interface.pyx":212 * if highs < float('inf'): * with_bounds = True * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): # <<<<<<<<<<<<<< * with_bounds = True * else: */ - goto __pyx_L88; + goto __pyx_L90; } - /* "l0learn/interface.pyx":351 + /* "l0learn/interface.pyx":215 * with_bounds = True * else: * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " # <<<<<<<<<<<<<< @@ -6330,115 +6364,115 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx * */ /*else*/ { - __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 351, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 215, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_expected_highs_to_be_a_non_negat_2); __pyx_t_9 += 73; __Pyx_GIVEREF(__pyx_kp_u_expected_highs_to_be_a_non_negat_2); - PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_highs_to_be_a_non_negat_2); - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 351, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_highs_to_be_a_non_negat_2); + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 215, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); - PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_8); __pyx_t_8 = 0; __Pyx_INCREF(__pyx_kp_u_of_non_negative_floats_but_got); __pyx_t_9 += 33; __Pyx_GIVEREF(__pyx_kp_u_of_non_negative_floats_but_got); - PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_of_non_negative_floats_but_got); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_of_non_negative_floats_but_got); - /* "l0learn/interface.pyx":352 + /* "l0learn/interface.pyx":216 * else: * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " * f"non-negative floats, but got {highs}") # <<<<<<<<<<<<<< * * if with_bounds: */ - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 352, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 216, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); - PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_8); __pyx_t_8 = 0; - /* "l0learn/interface.pyx":351 + /* "l0learn/interface.pyx":215 * with_bounds = True * else: * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " # <<<<<<<<<<<<<< * f"non-negative floats, but got {highs}") * */ - __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 351, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 215, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 351, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 215, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_Raise(__pyx_t_7, 0, 0, 0); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 351, __pyx_L1_error) + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 215, __pyx_L1_error) } - __pyx_L88:; + __pyx_L90:; - /* "l0learn/interface.pyx":354 + /* "l0learn/interface.pyx":218 * f"non-negative floats, but got {highs}") * * if with_bounds: # <<<<<<<<<<<<<< * if isinstance(lows, float): * lows = np.ones(p) * lows */ - __pyx_t_4 = (__pyx_v_with_bounds != 0); - if (__pyx_t_4) { + __pyx_t_1 = (__pyx_v_with_bounds != 0); + if (__pyx_t_1) { - /* "l0learn/interface.pyx":355 + /* "l0learn/interface.pyx":219 * * if with_bounds: * if isinstance(lows, float): # <<<<<<<<<<<<<< * lows = np.ones(p) * lows * if isinstance(highs, float): */ - __pyx_t_4 = PyFloat_Check(__pyx_v_lows); - __pyx_t_5 = (__pyx_t_4 != 0); - if (__pyx_t_5) { + __pyx_t_1 = PyFloat_Check(__pyx_v_lows); + __pyx_t_4 = (__pyx_t_1 != 0); + if (__pyx_t_4) { - /* "l0learn/interface.pyx":356 + /* "l0learn/interface.pyx":220 * if with_bounds: * if isinstance(lows, float): * lows = np.ones(p) * lows # <<<<<<<<<<<<<< * if isinstance(highs, float): * highs = np.ones(p) * highs */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 356, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_ones); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 356, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_ones); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3); + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); + __Pyx_DECREF_SET(__pyx_t_7, function); } } - __pyx_t_7 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_8, __pyx_v_p) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_p); + __pyx_t_3 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_v_p) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_p); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 356, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PyNumber_Multiply(__pyx_t_7, __pyx_v_lows); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 356, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_3); - __pyx_t_3 = 0; + __pyx_t_7 = PyNumber_Multiply(__pyx_t_3, __pyx_v_lows); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_7); + __pyx_t_7 = 0; - /* "l0learn/interface.pyx":355 + /* "l0learn/interface.pyx":219 * * if with_bounds: * if isinstance(lows, float): # <<<<<<<<<<<<<< @@ -6447,51 +6481,51 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":357 + /* "l0learn/interface.pyx":221 * if isinstance(lows, float): * lows = np.ones(p) * lows * if isinstance(highs, float): # <<<<<<<<<<<<<< * highs = np.ones(p) * highs * */ - __pyx_t_5 = PyFloat_Check(__pyx_v_highs); - __pyx_t_4 = (__pyx_t_5 != 0); - if (__pyx_t_4) { + __pyx_t_4 = PyFloat_Check(__pyx_v_highs); + __pyx_t_1 = (__pyx_t_4 != 0); + if (__pyx_t_1) { - /* "l0learn/interface.pyx":358 + /* "l0learn/interface.pyx":222 * lows = np.ones(p) * lows * if isinstance(highs, float): * highs = np.ones(p) * highs # <<<<<<<<<<<<<< * * if any(lows >= highs): */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 358, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ones); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 358, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_ones); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 222, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = NULL; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); - if (likely(__pyx_t_7)) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); - __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } - __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_7, __pyx_v_p) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_p); - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 358, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_3, __pyx_v_p) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_p); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = PyNumber_Multiply(__pyx_t_3, __pyx_v_highs); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 358, __pyx_L1_error) + __pyx_t_8 = PyNumber_Multiply(__pyx_t_7, __pyx_v_highs); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 222, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_8); __pyx_t_8 = 0; - /* "l0learn/interface.pyx":357 + /* "l0learn/interface.pyx":221 * if isinstance(lows, float): * lows = np.ones(p) * lows * if isinstance(highs, float): # <<<<<<<<<<<<<< @@ -6500,109 +6534,109 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":360 + /* "l0learn/interface.pyx":224 * highs = np.ones(p) * highs * * if any(lows >= highs): # <<<<<<<<<<<<<< * bad_bounds = np.argwhere(lows >= highs) * raise ValueError(f"expected to be high to be elementwise greater than lows, " */ - __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 360, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 360, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 224, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 360, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(__pyx_t_4)) { + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":361 + /* "l0learn/interface.pyx":225 * * if any(lows >= highs): * bad_bounds = np.argwhere(lows >= highs) # <<<<<<<<<<<<<< * raise ValueError(f"expected to be high to be elementwise greater than lows, " * f"but got indices {bad_bounds[0]} where that is not the case ") */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 361, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 225, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_argwhere); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 361, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_argwhere); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 225, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 361, __pyx_L1_error) + __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 225, __pyx_L1_error) __pyx_t_16 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { - __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_7); + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_16)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_16); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_7, function); + __Pyx_DECREF_SET(__pyx_t_3, function); } } - __pyx_t_3 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_16, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); + __pyx_t_7 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_16, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_8); __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 361, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_v_bad_bounds = __pyx_t_3; - __pyx_t_3 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 225, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_bad_bounds = __pyx_t_7; + __pyx_t_7 = 0; - /* "l0learn/interface.pyx":362 + /* "l0learn/interface.pyx":226 * if any(lows >= highs): * bad_bounds = np.argwhere(lows >= highs) * raise ValueError(f"expected to be high to be elementwise greater than lows, " # <<<<<<<<<<<<<< * f"but got indices {bad_bounds[0]} where that is not the case ") * else: */ - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 362, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = 0; __pyx_t_10 = 127; __Pyx_INCREF(__pyx_kp_u_expected_to_be_high_to_be_elemen); __pyx_t_9 += 73; __Pyx_GIVEREF(__pyx_kp_u_expected_to_be_high_to_be_elemen); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_to_be_high_to_be_elemen); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_to_be_high_to_be_elemen); - /* "l0learn/interface.pyx":363 + /* "l0learn/interface.pyx":227 * bad_bounds = np.argwhere(lows >= highs) * raise ValueError(f"expected to be high to be elementwise greater than lows, " * f"but got indices {bad_bounds[0]} where that is not the case ") # <<<<<<<<<<<<<< * else: * lows = np.array([0.]) */ - __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_bad_bounds, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 363, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 363, __pyx_L1_error) + __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_bad_bounds, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 227, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 227, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_8); + PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_8); __pyx_t_8 = 0; __Pyx_INCREF(__pyx_kp_u_where_that_is_not_the_case); __pyx_t_9 += 28; __Pyx_GIVEREF(__pyx_kp_u_where_that_is_not_the_case); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_where_that_is_not_the_case); + PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_where_that_is_not_the_case); - /* "l0learn/interface.pyx":362 + /* "l0learn/interface.pyx":226 * if any(lows >= highs): * bad_bounds = np.argwhere(lows >= highs) * raise ValueError(f"expected to be high to be elementwise greater than lows, " # <<<<<<<<<<<<<< * f"but got indices {bad_bounds[0]} where that is not the case ") * else: */ - __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 362, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 226, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 362, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 362, __pyx_L1_error) + __Pyx_Raise(__pyx_t_7, 0, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(0, 226, __pyx_L1_error) - /* "l0learn/interface.pyx":360 + /* "l0learn/interface.pyx":224 * highs = np.ones(p) * highs * * if any(lows >= highs): # <<<<<<<<<<<<<< @@ -6611,17 +6645,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ } - /* "l0learn/interface.pyx":354 + /* "l0learn/interface.pyx":218 * f"non-negative floats, but got {highs}") * * if with_bounds: # <<<<<<<<<<<<<< * if isinstance(lows, float): * lows = np.ones(p) * lows */ - goto __pyx_L95; + goto __pyx_L97; } - /* "l0learn/interface.pyx":365 + /* "l0learn/interface.pyx":229 * f"but got indices {bad_bounds[0]} where that is not the case ") * else: * lows = np.array([0.]) # <<<<<<<<<<<<<< @@ -6629,52 +6663,52 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx * */ /*else*/ { - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 365, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 229, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_array); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 365, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = PyList_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 365, __pyx_L1_error) + __pyx_t_8 = PyList_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 229, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_INCREF(__pyx_float_0_); __Pyx_GIVEREF(__pyx_float_0_); PyList_SET_ITEM(__pyx_t_8, 0, __pyx_float_0_); __pyx_t_16 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { - __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_7); + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_16)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_16); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_7, function); + __Pyx_DECREF_SET(__pyx_t_3, function); } } - __pyx_t_3 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_16, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); + __pyx_t_7 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_16, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_8); __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 365, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_3); - __pyx_t_3 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_7); + __pyx_t_7 = 0; - /* "l0learn/interface.pyx":366 + /* "l0learn/interface.pyx":230 * else: * lows = np.array([0.]) * highs = np.array(([0.])) # <<<<<<<<<<<<<< * - * cdef vector[vector[double]] c_lambda_grid + * return {"max_support_size": max_support_size, */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 366, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_array); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 366, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_array); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 230, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = PyList_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 366, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_float_0_); __Pyx_GIVEREF(__pyx_float_0_); - PyList_SET_ITEM(__pyx_t_7, 0, __pyx_float_0_); + PyList_SET_ITEM(__pyx_t_3, 0, __pyx_float_0_); __pyx_t_16 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_8); @@ -6685,745 +6719,293 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_DECREF_SET(__pyx_t_8, function); } } - __pyx_t_3 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_16, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); + __pyx_t_7 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_16, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_3); __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 366, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_3); - __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_7); + __pyx_t_7 = 0; } - __pyx_L95:; + __pyx_L97:; - /* "l0learn/interface.pyx":369 + /* "l0learn/interface.pyx":232 + * highs = np.array(([0.])) * - * cdef vector[vector[double]] c_lambda_grid - * try: # <<<<<<<<<<<<<< - * c_lambda_grid = lambda_grid - * except TypeError: + * return {"max_support_size": max_support_size, # <<<<<<<<<<<<<< + * "screen_size": screen_size, + * "y": y, */ - { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19); - __Pyx_XGOTREF(__pyx_t_17); - __Pyx_XGOTREF(__pyx_t_18); - __Pyx_XGOTREF(__pyx_t_19); - /*try:*/ { + __Pyx_XDECREF(__pyx_r); + __pyx_t_7 = __Pyx_PyDict_NewPresized(13); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_max_support_size, __pyx_v_max_support_size) < 0) __PYX_ERR(0, 232, __pyx_L1_error) - /* "l0learn/interface.pyx":370 - * cdef vector[vector[double]] c_lambda_grid - * try: - * c_lambda_grid = lambda_grid # <<<<<<<<<<<<<< - * except TypeError: - * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") + /* "l0learn/interface.pyx":233 + * + * return {"max_support_size": max_support_size, + * "screen_size": screen_size, # <<<<<<<<<<<<<< + * "y": y, + * "penalty":penalty, */ - __pyx_t_20 = __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_lambda_grid); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 370, __pyx_L99_error) - __pyx_v_c_lambda_grid = __pyx_t_20; + if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_screen_size, __pyx_v_screen_size) < 0) __PYX_ERR(0, 232, __pyx_L1_error) - /* "l0learn/interface.pyx":369 - * - * cdef vector[vector[double]] c_lambda_grid - * try: # <<<<<<<<<<<<<< - * c_lambda_grid = lambda_grid - * except TypeError: + /* "l0learn/interface.pyx":234 + * return {"max_support_size": max_support_size, + * "screen_size": screen_size, + * "y": y, # <<<<<<<<<<<<<< + * "penalty":penalty, + * "gamma_max":gamma_max, */ - } - __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; - __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; - __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; - goto __pyx_L104_try_end; - __pyx_L99_error:; - __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_y, __pyx_v_y) < 0) __PYX_ERR(0, 232, __pyx_L1_error) - /* "l0learn/interface.pyx":371 - * try: - * c_lambda_grid = lambda_grid - * except TypeError: # <<<<<<<<<<<<<< - * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") - * + /* "l0learn/interface.pyx":235 + * "screen_size": screen_size, + * "y": y, + * "penalty":penalty, # <<<<<<<<<<<<<< + * "gamma_max":gamma_max, + * "gamma_min": gamma_min, */ - __pyx_t_21 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); - if (__pyx_t_21) { - __Pyx_AddTraceback("l0learn.interface.fit", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_8, &__pyx_t_7) < 0) __PYX_ERR(0, 371, __pyx_L101_except_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GOTREF(__pyx_t_8); - __Pyx_GOTREF(__pyx_t_7); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 232, __pyx_L1_error) - /* "l0learn/interface.pyx":372 - * c_lambda_grid = lambda_grid - * except TypeError: - * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") # <<<<<<<<<<<<<< - * - * cdef string c_loss = loss.encode('UTF-8') + /* "l0learn/interface.pyx":236 + * "y": y, + * "penalty":penalty, + * "gamma_max":gamma_max, # <<<<<<<<<<<<<< + * "gamma_min": gamma_min, + * "lambda_grid": lambda_grid, */ - __pyx_t_16 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 372, __pyx_L101_except_error) - __Pyx_GOTREF(__pyx_t_16); - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_be_a_lis, __pyx_t_16); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 372, __pyx_L101_except_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_16 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 372, __pyx_L101_except_error) - __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_16, 0, 0, 0); - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __PYX_ERR(0, 372, __pyx_L101_except_error) - } - goto __pyx_L101_except_error; - __pyx_L101_except_error:; + __pyx_t_8 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_gamma_max, __pyx_t_8) < 0) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "l0learn/interface.pyx":369 - * - * cdef vector[vector[double]] c_lambda_grid - * try: # <<<<<<<<<<<<<< - * c_lambda_grid = lambda_grid - * except TypeError: + /* "l0learn/interface.pyx":237 + * "penalty":penalty, + * "gamma_max":gamma_max, + * "gamma_min": gamma_min, # <<<<<<<<<<<<<< + * "lambda_grid": lambda_grid, + * "num_gamma": num_gamma, */ - __Pyx_XGIVEREF(__pyx_t_17); - __Pyx_XGIVEREF(__pyx_t_18); - __Pyx_XGIVEREF(__pyx_t_19); - __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_18, __pyx_t_19); - goto __pyx_L1_error; - __pyx_L104_try_end:; - } + __pyx_t_8 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 237, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_gamma_min, __pyx_t_8) < 0) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "l0learn/interface.pyx":374 - * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") - * - * cdef string c_loss = loss.encode('UTF-8') # <<<<<<<<<<<<<< - * cdef string c_penalty = penalty.encode('UTF-8') - * cdef string c_algorithim = algorithm.encode('UTF-8') + /* "l0learn/interface.pyx":238 + * "gamma_max":gamma_max, + * "gamma_min": gamma_min, + * "lambda_grid": lambda_grid, # <<<<<<<<<<<<<< + * "num_gamma": num_gamma, + * "num_lambda":num_lambda, */ - if (unlikely(__pyx_v_loss == Py_None)) { - PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 374, __pyx_L1_error) - } - __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_loss); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 374, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 374, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_v_c_loss = __pyx_t_22; + if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_lambda_grid, __pyx_v_lambda_grid) < 0) __PYX_ERR(0, 232, __pyx_L1_error) - /* "l0learn/interface.pyx":375 - * - * cdef string c_loss = loss.encode('UTF-8') - * cdef string c_penalty = penalty.encode('UTF-8') # <<<<<<<<<<<<<< - * cdef string c_algorithim = algorithm.encode('UTF-8') - * + /* "l0learn/interface.pyx":239 + * "gamma_min": gamma_min, + * "lambda_grid": lambda_grid, + * "num_gamma": num_gamma, # <<<<<<<<<<<<<< + * "num_lambda":num_lambda, + * "auto_lambda": auto_lambda, */ - if (unlikely(__pyx_v_penalty == Py_None)) { - PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 375, __pyx_L1_error) - } - __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_penalty); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 375, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 375, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_v_c_penalty = __pyx_t_22; + if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_num_gamma, __pyx_v_num_gamma) < 0) __PYX_ERR(0, 232, __pyx_L1_error) - /* "l0learn/interface.pyx":376 - * cdef string c_loss = loss.encode('UTF-8') - * cdef string c_penalty = penalty.encode('UTF-8') - * cdef string c_algorithim = algorithm.encode('UTF-8') # <<<<<<<<<<<<<< - * - * cdef fitmodel c_results + /* "l0learn/interface.pyx":240 + * "lambda_grid": lambda_grid, + * "num_gamma": num_gamma, + * "num_lambda":num_lambda, # <<<<<<<<<<<<<< + * "auto_lambda": auto_lambda, + * "with_bounds": with_bounds, */ - if (unlikely(__pyx_v_algorithm == Py_None)) { - PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 376, __pyx_L1_error) - } - __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_algorithm); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 376, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 376, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_v_c_algorithim = __pyx_t_22; + if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_num_lambda, __pyx_v_num_lambda) < 0) __PYX_ERR(0, 232, __pyx_L1_error) - /* "l0learn/interface.pyx":379 - * - * cdef fitmodel c_results - * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< - * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), - * y=numpy_to_dvec_d(y), + /* "l0learn/interface.pyx":241 + * "num_gamma": num_gamma, + * "num_lambda":num_lambda, + * "auto_lambda": auto_lambda, # <<<<<<<<<<<<<< + * "with_bounds": with_bounds, + * "lows": lows, */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 379, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 379, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyBool_FromLong(__pyx_v_auto_lambda); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 241, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = PyObject_IsInstance(__pyx_v_X, __pyx_t_8); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 379, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_auto_lambda, __pyx_t_8) < 0) __PYX_ERR(0, 232, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_5 = (__pyx_t_4 != 0); - if (__pyx_t_5) { - /* "l0learn/interface.pyx":380 - * cdef fitmodel c_results - * if isinstance(X, np.ndarray): - * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< - * y=numpy_to_dvec_d(y), - * Loss=c_loss, + /* "l0learn/interface.pyx":242 + * "num_lambda":num_lambda, + * "auto_lambda": auto_lambda, + * "with_bounds": with_bounds, # <<<<<<<<<<<<<< + * "lows": lows, + * "highs":highs} */ - if (!(likely(((__pyx_v_X) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_X, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 380, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyBool_FromLong(__pyx_v_with_bounds); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_with_bounds, __pyx_t_8) < 0) __PYX_ERR(0, 232, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - /* "l0learn/interface.pyx":381 - * if isinstance(X, np.ndarray): - * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), - * y=numpy_to_dvec_d(y), # <<<<<<<<<<<<<< - * Loss=c_loss, - * Penalty=c_penalty, + /* "l0learn/interface.pyx":243 + * "auto_lambda": auto_lambda, + * "with_bounds": with_bounds, + * "lows": lows, # <<<<<<<<<<<<<< + * "highs":highs} + * */ - if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 381, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_lows, __pyx_v_lows) < 0) __PYX_ERR(0, 232, __pyx_L1_error) - /* "l0learn/interface.pyx":385 - * Penalty=c_penalty, - * Algorithm=c_algorithim, - * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< - * G_ncols=num_lambda, - * G_nrows=num_gamma, + /* "l0learn/interface.pyx":244 + * "with_bounds": with_bounds, + * "lows": lows, + * "highs":highs} # <<<<<<<<<<<<<< + * + * */ - __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 385, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_highs, __pyx_v_highs) < 0) __PYX_ERR(0, 232, __pyx_L1_error) + __pyx_r = __pyx_t_7; + __pyx_t_7 = 0; + goto __pyx_L0; - /* "l0learn/interface.pyx":386 - * Algorithm=c_algorithim, - * NnzStopNum=max_support_size, - * G_ncols=num_lambda, # <<<<<<<<<<<<<< - * G_nrows=num_gamma, - * Lambda2Max=gamma_max, + /* "l0learn/interface.pyx":52 + * + * + * def _fit_check(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< + * y: np.ndarray, + * loss: str, */ - __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 386, __pyx_L1_error) - /* "l0learn/interface.pyx":387 - * NnzStopNum=max_support_size, - * G_ncols=num_lambda, - * G_nrows=num_gamma, # <<<<<<<<<<<<<< - * Lambda2Max=gamma_max, - * Lambda2Min=gamma_min, + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_16); + __Pyx_AddTraceback("l0learn.interface._fit_check", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XDECREF(__pyx_v_p); + __Pyx_XDECREF(__pyx_v_unique_items); + __Pyx_XDECREF(__pyx_v_a); + __Pyx_XDECREF(__pyx_v__); + __Pyx_XDECREF(__pyx_v_first_value); + __Pyx_XDECREF(__pyx_v_second_value); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XDECREF(__pyx_v_sub_lambda_grid); + __Pyx_XDECREF(__pyx_v_bad_bounds); + __Pyx_XDECREF(__pyx_v_y); + __Pyx_XDECREF(__pyx_v_penalty); + __Pyx_XDECREF(__pyx_v_max_support_size); + __Pyx_XDECREF(__pyx_v_num_lambda); + __Pyx_XDECREF(__pyx_v_num_gamma); + __Pyx_XDECREF(__pyx_v_screen_size); + __Pyx_XDECREF(__pyx_v_lambda_grid); + __Pyx_XDECREF(__pyx_v_lows); + __Pyx_XDECREF(__pyx_v_highs); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/interface.pyx":247 + * + * + * def fit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< + * y: np.ndarray, + * loss: str = "SquaredError", */ - __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 387, __pyx_L1_error) - /* "l0learn/interface.pyx":390 - * Lambda2Max=gamma_max, - * Lambda2Min=gamma_min, - * PartialSort=partial_sort, # <<<<<<<<<<<<<< - * MaxIters=max_iter, - * rtol=rtol, - */ - __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 390, __pyx_L1_error) - - /* "l0learn/interface.pyx":391 - * Lambda2Min=gamma_min, - * PartialSort=partial_sort, - * MaxIters=max_iter, # <<<<<<<<<<<<<< - * rtol=rtol, - * atol=atol, - */ - __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 391, __pyx_L1_error) - - /* "l0learn/interface.pyx":394 - * rtol=rtol, - * atol=atol, - * ActiveSet=active_set, # <<<<<<<<<<<<<< - * ActiveSetNum=active_set_num, - * MaxNumSwaps=max_swaps, - */ - __pyx_t_28 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_28 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 394, __pyx_L1_error) - - /* "l0learn/interface.pyx":395 - * atol=atol, - * ActiveSet=active_set, - * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< - * MaxNumSwaps=max_swaps, - * ScaleDownFactor=scale_down_factor, - */ - __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 395, __pyx_L1_error) - - /* "l0learn/interface.pyx":396 - * ActiveSet=active_set, - * ActiveSetNum=active_set_num, - * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< - * ScaleDownFactor=scale_down_factor, - * ScreenSize=screen_size, - */ - __pyx_t_30 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_30 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 396, __pyx_L1_error) - - /* "l0learn/interface.pyx":398 - * MaxNumSwaps=max_swaps, - * ScaleDownFactor=scale_down_factor, - * ScreenSize=screen_size, # <<<<<<<<<<<<<< - * LambdaU=not auto_lambda, - * Lambdas=c_lambda_grid, - */ - __pyx_t_31 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_31 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 398, __pyx_L1_error) - - /* "l0learn/interface.pyx":401 - * LambdaU=not auto_lambda, - * Lambdas=c_lambda_grid, - * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< - * Intercept=intercept, - * withBounds=with_bounds, - */ - __pyx_t_32 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_32 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 401, __pyx_L1_error) - - /* "l0learn/interface.pyx":402 - * Lambdas=c_lambda_grid, - * ExcludeFirstK=exclude_first_k, - * Intercept=intercept, # <<<<<<<<<<<<<< - * withBounds=with_bounds, - * Lows=numpy_to_dvec_d(lows), - */ - __pyx_t_33 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_33 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 402, __pyx_L1_error) - - /* "l0learn/interface.pyx":404 - * Intercept=intercept, - * withBounds=with_bounds, - * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< - * Highs=numpy_to_dvec_d(highs)) - * else: # isinstance(X, csc_matrix) - */ - if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 404, __pyx_L1_error) - - /* "l0learn/interface.pyx":405 - * withBounds=with_bounds, - * Lows=numpy_to_dvec_d(lows), - * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< - * else: # isinstance(X, csc_matrix) - * c_results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), - */ - if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 405, __pyx_L1_error) - - /* "l0learn/interface.pyx":380 - * cdef fitmodel c_results - * if isinstance(X, np.ndarray): - * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< - * y=numpy_to_dvec_d(y), - * Loss=c_loss, - */ - __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnFit_dense(__pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_X)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_23, __pyx_t_24, __pyx_t_25, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_26, __pyx_t_27, __pyx_v_rtol, __pyx_v_atol, __pyx_t_28, __pyx_t_29, __pyx_t_30, __pyx_v_scale_down_factor, __pyx_t_31, (!(__pyx_v_auto_lambda != 0)), __pyx_v_c_lambda_grid, __pyx_t_32, __pyx_t_33, __pyx_v_with_bounds, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); - - /* "l0learn/interface.pyx":379 - * - * cdef fitmodel c_results - * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< - * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), - * y=numpy_to_dvec_d(y), - */ - goto __pyx_L107; - } - - /* "l0learn/interface.pyx":407 - * Highs=numpy_to_dvec_d(highs)) - * else: # isinstance(X, csc_matrix) - * c_results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< - * y=numpy_to_dvec_d(y), - * Loss=c_loss, - */ - /*else*/ { - - /* "l0learn/interface.pyx":408 - * else: # isinstance(X, csc_matrix) - * c_results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), - * y=numpy_to_dvec_d(y), # <<<<<<<<<<<<<< - * Loss=c_loss, - * Penalty=c_penalty, - */ - if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 408, __pyx_L1_error) - - /* "l0learn/interface.pyx":412 - * Penalty=c_penalty, - * Algorithm=c_algorithim, - * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< - * G_ncols=num_lambda, - * G_nrows=num_gamma, - */ - __pyx_t_32 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_32 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 412, __pyx_L1_error) - - /* "l0learn/interface.pyx":413 - * Algorithm=c_algorithim, - * NnzStopNum=max_support_size, - * G_ncols=num_lambda, # <<<<<<<<<<<<<< - * G_nrows=num_gamma, - * Lambda2Max=gamma_max, - */ - __pyx_t_31 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_31 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 413, __pyx_L1_error) - - /* "l0learn/interface.pyx":414 - * NnzStopNum=max_support_size, - * G_ncols=num_lambda, - * G_nrows=num_gamma, # <<<<<<<<<<<<<< - * Lambda2Max=gamma_max, - * Lambda2Min=gamma_min, - */ - __pyx_t_30 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_30 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 414, __pyx_L1_error) - - /* "l0learn/interface.pyx":417 - * Lambda2Max=gamma_max, - * Lambda2Min=gamma_min, - * PartialSort=partial_sort, # <<<<<<<<<<<<<< - * MaxIters=max_iter, - * rtol=rtol, - */ - __pyx_t_33 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_33 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 417, __pyx_L1_error) - - /* "l0learn/interface.pyx":418 - * Lambda2Min=gamma_min, - * PartialSort=partial_sort, - * MaxIters=max_iter, # <<<<<<<<<<<<<< - * rtol=rtol, - * atol=atol, - */ - __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 418, __pyx_L1_error) - - /* "l0learn/interface.pyx":421 - * rtol=rtol, - * atol=atol, - * ActiveSet=active_set, # <<<<<<<<<<<<<< - * ActiveSetNum=active_set_num, - * MaxNumSwaps=max_swaps, - */ - __pyx_t_28 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_28 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 421, __pyx_L1_error) - - /* "l0learn/interface.pyx":422 - * atol=atol, - * ActiveSet=active_set, - * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< - * MaxNumSwaps=max_swaps, - * ScaleDownFactor=scale_down_factor, - */ - __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 422, __pyx_L1_error) - - /* "l0learn/interface.pyx":423 - * ActiveSet=active_set, - * ActiveSetNum=active_set_num, - * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< - * ScaleDownFactor=scale_down_factor, - * ScreenSize=screen_size, - */ - __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 423, __pyx_L1_error) - - /* "l0learn/interface.pyx":425 - * MaxNumSwaps=max_swaps, - * ScaleDownFactor=scale_down_factor, - * ScreenSize=screen_size, # <<<<<<<<<<<<<< - * LambdaU=not auto_lambda, - * Lambdas=c_lambda_grid, - */ - __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 425, __pyx_L1_error) - - /* "l0learn/interface.pyx":428 - * LambdaU=not auto_lambda, - * Lambdas=c_lambda_grid, - * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< - * Intercept=intercept, - * withBounds=with_bounds, - */ - __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 428, __pyx_L1_error) +/* Python wrapper */ +static PyObject *__pyx_pw_7l0learn_9interface_5fit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_7l0learn_9interface_4fit[] = "fit(X: Union[np.ndarray, csc_matrix], y: np.ndarray, unicode loss: str = u'SquaredError', unicode penalty: str = u'L0', unicode algorithm: str = u'CD', max_support_size: int = 100, num_lambda: Optional[int] = 100, num_gamma: Optional[int] = 1, double gamma_max: float = 10., double gamma_min: float = .0001, partial_sort: bool = True, max_iter: int = 200, double rtol: float = 1e-6, double atol: float = 1e-9, active_set: bool = True, active_set_num: int = 3, max_swaps: int = 100, double scale_down_factor: float = 0.8, screen_size: int = 1000, lambda_grid: Optional[List[List[float]]] = None, exclude_first_k: int = 0, intercept: bool = True, lows: Union[np.ndarray, float] = -float(u'inf'), highs: Union[np.ndarray, float] = +float(u'inf')) -> l0learn.models.FitModel\n\n Computes the regularization path for the specified loss function and penalty function.\n\n Parameters\n ----------\n X : np.ndarray or csc_matrix of shape (N, P)\n Data Matrix where rows of X are observations and columns of X are features\n\n y : np.ndarray of shape (P)\n The response vector where y[i] corresponds to X[i, :]\n For classification, a binary vector (-1, 1) is requried .\n\n loss : str\n The loss function. Currently supports the choices:\n \"SquaredError\" (for regression),\n \"Logistic\" (for logistic regression), and\n \"SquaredHinge\" (for smooth SVM).\n\n penalty : str\n The type of regularization.\n This can take either one of the following choices:\n \"L0\",\n \"L0L2\", and\n \"L0L1\"\n\n algorithm : str\n The type of algorithm used to minimize the objective function. Currently \"CD\" and \"CDPSI\" are are supported.\n \"CD\" is a variant of cyclic coordinate descent and runs very fast. \"CDPSI\" performs local combinatorial search\n on top of CD and typically achieves higher quality solutions (at the expense of increased running time).""\n\n max_support_size : int\n Must be greater than 0.\n The maximum support size at which to terminate the regularization path. We recommend setting this to a small\n fraction of min(n,p) (e.g. 0.05 * min(n,p)) as L0 regularization typically selects a small portion of non-zeros.\n\n num_lambda : int, optional\n The number of lambda values to select in the regularization path.\n This value must be None if lambda_grid is supplied.When supplied, must be greater than 0.\n Note: lambda is the regularization parameter corresponding to the L0 norm.\n\n num_gamma: int, optional\n The number of gamma values to select in the regularization path.\n This value must be None if lambda_grid is supplied. When supplied, must be greater than 0.\n Note: gamma is the regularization parameter corresponding to L1 or L2, depending on the chosen penalty).\n\n gamma_max : float\n The maximum value of gamma when using the L0L2 penalty.\n This value must be greater than 0.\n\n Note: For the L0L1 penalty this is automatically selected.\n\n gamma_min : float\n The minimum value of Gamma when using the L0L2 penalty.\n This value must be greater than 0 but less than gamma_max.\n Note: For the L0L1 penalty, the minimum value of gamma in the grid is set to gammaMin * gammaMax.\n\n partial_sort : bool\n If TRUE partial sorting will be used for sorting the coordinates to do greedy cycling (see our paper for\n for details). Otherwise, full sorting is used. #TODO: Add link for paper\n\n max_iter : int\n The maximum number of iterations (full cycles) for CD per grid point. The algorithm may not use the full number\n of iteration per grid point if convergence is found (defined by rtol and atol parameter)\n Must be greater than 0\n\n rtol : float\n The relative tolerance which decides when to terminate optimization as based on the relat""ive change in the\n objective between iterations.\n Must be greater than 0 and less than 1.\n\n atol : float\n The absolute tolerance which decides when to terminate optimization as based on the absolute L2 norm of the\n residuals\n Must be greater than 0\n\n active_set : bool\n If TRUE, performs active set updates. (see our paper for for details). #TODO: Add link for paper\n\n active_set_num : int\n The number of consecutive times a support should appear before declaring support stabilization.\n (see our paper for for details). #TODO: Add link for paper\n\n Must be greater than 0.\n\n max_swaps : int\n The maximum number of swaps used by CDPSI for each grid point.\n Must be greater than 0. Ignored by CD algorithims.\n\n scale_down_factor : float\n Roughly amount each lambda value is scaled by between grid points. Larger values lead to closer lambdas and\n typically to smaller gaps between the support sizes.\n\n For details, see our paper - Section 5 on Adaptive Selection of Tuning Parameters). #TODO: Add link for paper\n\n Must be greater than 0 and less than 1 (strictly for both.)\n\n screen_size : int\n The number of coordinates to cycle over when performing initial correlation screening. #TODO: Add link for paper\n\n Must be greater than 0 and less than number of columns of X.\n\n lambda_grid : list of list of floats\n A grid of lambda values to use in computing the regularization path. This is by default an empty list\n and is ignored. When specified, lambda_grid should be a list of list of floats, where the ith element\n (corresponding to the ith gamma) should be a decreasing sequence of lambda values. The length of this sequence\n is directly the number of lambdas to be tried for that gamma.\n\n In the the \"L0\" penalty case, lambda_grid should be a list of 1.\n In the \"L0LX""\" penalty cases, lambda_grid can be a list of any length. The length of lambda_grid will be the\n number of gamma values tried.\n\n See the example notebook for more details.\n\n Note: When lambda_grid is supplied, num_gamma and num_lambda must be None.\n\n exclude_first_k : int\n The first exclude_first_k features in X will be excluded from variable selection. In other words, the first\n exclude_first_k variables will not be included in the L0-norm penalty however they will be included in the\n L1 or L2 norm penalties, if they are specified.\n\n Must be a positive integer less than the columns of X.\n\n intercept : bool\n If False, no intercept term is included or fit in the regularization path\n Intercept terms are not regularized by L0 or L1/L2.\n\n lows : np array or float\n Lower bounds for coefficients. Either a scalar for all coefficients to have the same bound or a vector of\n size p (number of columns of X) where lows[i] is the lower bound for coefficient i.\n\n Lower bounds can not be above 0 (i.e. we can not specify that all coefficients must be larger than a > 0).\n Lower bounds can be set to 0 iff the corresponding upper bound for that coefficient is also not 0.\n\n highs : np array or float\n Upper bounds for coefficients. Either a scalar for all coefficients to have the same bound or a vector of\n size p (number of columns of X) where highs[i] is the upper bound for coefficient i.\n\n Upper bounds can not be below 0 (i.e. we can not specify that all coefficients must be smaller than a < 0).\n Upper bounds can be set to 0 iff the corresponding lower bound for that coefficient is also not 0.\n\n Returns\n -------\n\n\n Examples\n --------\n "; +static PyMethodDef __pyx_mdef_7l0learn_9interface_5fit = {"fit", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7l0learn_9interface_5fit, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7l0learn_9interface_4fit}; +static PyObject *__pyx_pw_7l0learn_9interface_5fit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_X = 0; + PyObject *__pyx_v_y = 0; + PyObject *__pyx_v_loss = 0; + PyObject *__pyx_v_penalty = 0; + PyObject *__pyx_v_algorithm = 0; + PyObject *__pyx_v_max_support_size = 0; + PyObject *__pyx_v_num_lambda = 0; + PyObject *__pyx_v_num_gamma = 0; + double __pyx_v_gamma_max; + double __pyx_v_gamma_min; + PyObject *__pyx_v_partial_sort = 0; + PyObject *__pyx_v_max_iter = 0; + double __pyx_v_rtol; + double __pyx_v_atol; + PyObject *__pyx_v_active_set = 0; + PyObject *__pyx_v_active_set_num = 0; + PyObject *__pyx_v_max_swaps = 0; + double __pyx_v_scale_down_factor; + PyObject *__pyx_v_screen_size = 0; + PyObject *__pyx_v_lambda_grid = 0; + PyObject *__pyx_v_exclude_first_k = 0; + PyObject *__pyx_v_intercept = 0; + PyObject *__pyx_v_lows = 0; + PyObject *__pyx_v_highs = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("fit (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_X,&__pyx_n_s_y,&__pyx_n_s_loss,&__pyx_n_s_penalty,&__pyx_n_s_algorithm,&__pyx_n_s_max_support_size,&__pyx_n_s_num_lambda,&__pyx_n_s_num_gamma,&__pyx_n_s_gamma_max,&__pyx_n_s_gamma_min,&__pyx_n_s_partial_sort,&__pyx_n_s_max_iter,&__pyx_n_s_rtol,&__pyx_n_s_atol,&__pyx_n_s_active_set,&__pyx_n_s_active_set_num,&__pyx_n_s_max_swaps,&__pyx_n_s_scale_down_factor,&__pyx_n_s_screen_size,&__pyx_n_s_lambda_grid,&__pyx_n_s_exclude_first_k,&__pyx_n_s_intercept,&__pyx_n_s_lows,&__pyx_n_s_highs,0}; + PyObject* values[24] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + values[2] = ((PyObject*)__pyx_n_u_SquaredError); + values[3] = ((PyObject*)__pyx_n_u_L0); + values[4] = ((PyObject*)__pyx_n_u_CD); + values[5] = ((PyObject *)__pyx_int_100); + values[6] = ((PyObject *)__pyx_int_100); + values[7] = ((PyObject *)__pyx_int_1); - /* "l0learn/interface.pyx":429 - * Lambdas=c_lambda_grid, - * ExcludeFirstK=exclude_first_k, - * Intercept=intercept, # <<<<<<<<<<<<<< - * withBounds=with_bounds, - * Lows=numpy_to_dvec_d(lows), + /* "l0learn/interface.pyx":257 + * gamma_max: float = 10., + * gamma_min: float = .0001, + * partial_sort: bool = True, # <<<<<<<<<<<<<< + * max_iter: int = 200, + * rtol: float = 1e-6, */ - __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 429, __pyx_L1_error) + values[10] = ((PyObject *)Py_True); + values[11] = ((PyObject *)__pyx_int_200); - /* "l0learn/interface.pyx":431 - * Intercept=intercept, - * withBounds=with_bounds, - * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< - * Highs=numpy_to_dvec_d(highs)) - * + /* "l0learn/interface.pyx":261 + * rtol: float = 1e-6, + * atol: float = 1e-9, + * active_set: bool = True, # <<<<<<<<<<<<<< + * active_set_num: int = 3, + * max_swaps: int = 100, */ - if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 431, __pyx_L1_error) + values[14] = ((PyObject *)Py_True); + values[15] = ((PyObject *)__pyx_int_3); + values[16] = ((PyObject *)__pyx_int_100); + values[18] = ((PyObject *)__pyx_int_1000); - /* "l0learn/interface.pyx":432 - * withBounds=with_bounds, - * Lows=numpy_to_dvec_d(lows), - * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< - * - * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, + /* "l0learn/interface.pyx":266 + * scale_down_factor: float = 0.8, + * screen_size: int = 1000, + * lambda_grid: Optional[List[List[float]]] = None, # <<<<<<<<<<<<<< + * exclude_first_k: int = 0, + * intercept: bool = True, */ - if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 432, __pyx_L1_error) + values[19] = ((PyObject *)Py_None); + values[20] = ((PyObject *)__pyx_int_0); - /* "l0learn/interface.pyx":407 - * Highs=numpy_to_dvec_d(highs)) - * else: # isinstance(X, csc_matrix) - * c_results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< - * y=numpy_to_dvec_d(y), - * Loss=c_loss, + /* "l0learn/interface.pyx":268 + * lambda_grid: Optional[List[List[float]]] = None, + * exclude_first_k: int = 0, + * intercept: bool = True, # <<<<<<<<<<<<<< + * lows: Union[np.ndarray, float] = -float('inf'), + * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.FitModel: */ - __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnFit_sparse(__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(__pyx_v_X), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_32, __pyx_t_31, __pyx_t_30, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_33, __pyx_t_29, __pyx_v_rtol, __pyx_v_atol, __pyx_t_28, __pyx_t_27, __pyx_t_25, __pyx_v_scale_down_factor, __pyx_t_24, (!(__pyx_v_auto_lambda != 0)), __pyx_v_c_lambda_grid, __pyx_t_23, __pyx_t_26, __pyx_v_with_bounds, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); - } - __pyx_L107:; - - /* "l0learn/interface.pyx":434 - * Highs=numpy_to_dvec_d(highs)) - * - * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, # <<<<<<<<<<<<<< - * lambda_0=c_results.Lambda0, - * gamma=c_results.Lambda12, - */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_FitModel); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 434, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 434, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_3 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 434, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 434, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 434, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 434, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_settings, __pyx_t_3) < 0) __PYX_ERR(0, 434, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":435 - * - * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, - * lambda_0=c_results.Lambda0, # <<<<<<<<<<<<<< - * gamma=c_results.Lambda12, - * support_size=c_results.NnzCount, - */ - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Lambda0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 435, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_lambda_0, __pyx_t_3) < 0) __PYX_ERR(0, 434, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":436 - * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, - * lambda_0=c_results.Lambda0, - * gamma=c_results.Lambda12, # <<<<<<<<<<<<<< - * support_size=c_results.NnzCount, - * coeffs=sp_dmat_field_to_list(c_results.Beta), - */ - __pyx_t_3 = __pyx_convert_vector_to_py_double(__pyx_v_c_results.Lambda12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 436, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_gamma, __pyx_t_3) < 0) __PYX_ERR(0, 434, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":437 - * lambda_0=c_results.Lambda0, - * gamma=c_results.Lambda12, - * support_size=c_results.NnzCount, # <<<<<<<<<<<<<< - * coeffs=sp_dmat_field_to_list(c_results.Beta), - * intercepts=c_results.Intercept, - */ - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(__pyx_v_c_results.NnzCount); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 437, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_support_size, __pyx_t_3) < 0) __PYX_ERR(0, 434, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":438 - * gamma=c_results.Lambda12, - * support_size=c_results.NnzCount, - * coeffs=sp_dmat_field_to_list(c_results.Beta), # <<<<<<<<<<<<<< - * intercepts=c_results.Intercept, - * converged=c_results.Converged) - */ - __pyx_t_3 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_c_results.Beta); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 438, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_coeffs, __pyx_t_3) < 0) __PYX_ERR(0, 434, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":439 - * support_size=c_results.NnzCount, - * coeffs=sp_dmat_field_to_list(c_results.Beta), - * intercepts=c_results.Intercept, # <<<<<<<<<<<<<< - * converged=c_results.Converged) - * return results - */ - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Intercept); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 439, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_intercepts, __pyx_t_3) < 0) __PYX_ERR(0, 434, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":440 - * coeffs=sp_dmat_field_to_list(c_results.Beta), - * intercepts=c_results.Intercept, - * converged=c_results.Converged) # <<<<<<<<<<<<<< - * return results - * - */ - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(__pyx_v_c_results.Converged); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 440, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_converged, __pyx_t_3) < 0) __PYX_ERR(0, 434, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":434 - * Highs=numpy_to_dvec_d(highs)) - * - * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, # <<<<<<<<<<<<<< - * lambda_0=c_results.Lambda0, - * gamma=c_results.Lambda12, - */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_empty_tuple, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 434, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_v_results = __pyx_t_3; - __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":441 - * intercepts=c_results.Intercept, - * converged=c_results.Converged) - * return results # <<<<<<<<<<<<<< - * - * - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_results); - __pyx_r = __pyx_v_results; - goto __pyx_L0; - - /* "l0learn/interface.pyx":50 - * SUPPORTED_ALGORITHM = ("CD", "CDPSI") - * - * def fit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< - * y: np.ndarray, - * loss: str = "SquaredHinge", - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_XDECREF(__pyx_t_16); - __Pyx_AddTraceback("l0learn.interface.fit", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_n); - __Pyx_XDECREF(__pyx_v_p); - __Pyx_XDECREF(__pyx_v_unique_items); - __Pyx_XDECREF(__pyx_v_a); - __Pyx_XDECREF(__pyx_v__); - __Pyx_XDECREF(__pyx_v_i); - __Pyx_XDECREF(__pyx_v_sub_lambda_grid); - __Pyx_XDECREF(__pyx_v_bad_bounds); - __Pyx_XDECREF(__pyx_v_results); - __Pyx_XDECREF(__pyx_v_y); - __Pyx_XDECREF(__pyx_v_penalty); - __Pyx_XDECREF(__pyx_v_num_lambda); - __Pyx_XDECREF(__pyx_v_num_gamma); - __Pyx_XDECREF(__pyx_v_lambda_grid); - __Pyx_XDECREF(__pyx_v_lows); - __Pyx_XDECREF(__pyx_v_highs); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "l0learn/interface.pyx":444 - * - * - * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< - * y: np.ndarray, - * loss: str = "SquaredHinge", - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_7l0learn_9interface_4cvfit[] = "cvfit(X: Union[np.ndarray, csc_matrix], y: np.ndarray, unicode loss: str = u'SquaredHinge', unicode penalty: str = u'L0', unicode algorithm: str = u'CD', num_folds: int = 10, seed: int = 1, max_support_size: int = 100, num_lambda: Optional[int] = 100, num_gamma: Optional[int] = 1, double gamma_max: float = 10., double gamma_min: float = .0001, partial_sort: bool = True, max_iter: int = 200, double rtol: float = 1e-6, double atol: float = 1e-9, active_set: bool = True, active_set_num: int = 3, max_swaps: int = 100, double scale_down_factor: float = 0.8, screen_size: int = 1000, lambda_grid: Optional[List[List[float]]] = None, exclude_first_k: int = 0, intercept: bool = True, lows: Union[np.ndarray, float] = -float(u'inf'), highs: Union[np.ndarray, float] = +float(u'inf'))"; -static PyMethodDef __pyx_mdef_7l0learn_9interface_5cvfit = {"cvfit", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7l0learn_9interface_5cvfit, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7l0learn_9interface_4cvfit}; -static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v_X = 0; - PyObject *__pyx_v_y = 0; - PyObject *__pyx_v_loss = 0; - PyObject *__pyx_v_penalty = 0; - PyObject *__pyx_v_algorithm = 0; - PyObject *__pyx_v_num_folds = 0; - PyObject *__pyx_v_seed = 0; - PyObject *__pyx_v_max_support_size = 0; - PyObject *__pyx_v_num_lambda = 0; - PyObject *__pyx_v_num_gamma = 0; - double __pyx_v_gamma_max; - double __pyx_v_gamma_min; - PyObject *__pyx_v_partial_sort = 0; - PyObject *__pyx_v_max_iter = 0; - double __pyx_v_rtol; - double __pyx_v_atol; - PyObject *__pyx_v_active_set = 0; - PyObject *__pyx_v_active_set_num = 0; - PyObject *__pyx_v_max_swaps = 0; - double __pyx_v_scale_down_factor; - PyObject *__pyx_v_screen_size = 0; - PyObject *__pyx_v_lambda_grid = 0; - PyObject *__pyx_v_exclude_first_k = 0; - PyObject *__pyx_v_intercept = 0; - PyObject *__pyx_v_lows = 0; - PyObject *__pyx_v_highs = 0; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("cvfit (wrapper)", 0); - { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_X,&__pyx_n_s_y,&__pyx_n_s_loss,&__pyx_n_s_penalty,&__pyx_n_s_algorithm,&__pyx_n_s_num_folds,&__pyx_n_s_seed,&__pyx_n_s_max_support_size,&__pyx_n_s_num_lambda,&__pyx_n_s_num_gamma,&__pyx_n_s_gamma_max,&__pyx_n_s_gamma_min,&__pyx_n_s_partial_sort,&__pyx_n_s_max_iter,&__pyx_n_s_rtol,&__pyx_n_s_atol,&__pyx_n_s_active_set,&__pyx_n_s_active_set_num,&__pyx_n_s_max_swaps,&__pyx_n_s_scale_down_factor,&__pyx_n_s_screen_size,&__pyx_n_s_lambda_grid,&__pyx_n_s_exclude_first_k,&__pyx_n_s_intercept,&__pyx_n_s_lows,&__pyx_n_s_highs,0}; - PyObject* values[26] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; - values[2] = ((PyObject*)__pyx_n_u_SquaredHinge); - values[3] = ((PyObject*)__pyx_n_u_L0); - values[4] = ((PyObject*)__pyx_n_u_CD); - values[5] = ((PyObject *)__pyx_int_10); - values[6] = ((PyObject *)__pyx_int_1); - values[7] = ((PyObject *)__pyx_int_100); - values[8] = ((PyObject *)__pyx_int_100); - values[9] = ((PyObject *)__pyx_int_1); - - /* "l0learn/interface.pyx":456 - * gamma_max: float = 10., - * gamma_min: float = .0001, - * partial_sort: bool = True, # <<<<<<<<<<<<<< - * max_iter: int = 200, - * rtol: float = 1e-6, - */ - values[12] = ((PyObject *)Py_True); - values[13] = ((PyObject *)__pyx_int_200); - - /* "l0learn/interface.pyx":460 - * rtol: float = 1e-6, - * atol: float = 1e-9, - * active_set: bool = True, # <<<<<<<<<<<<<< - * active_set_num: int = 3, - * max_swaps: int = 100, - */ - values[16] = ((PyObject *)Py_True); - values[17] = ((PyObject *)__pyx_int_3); - values[18] = ((PyObject *)__pyx_int_100); - values[20] = ((PyObject *)__pyx_int_1000); - - /* "l0learn/interface.pyx":465 - * scale_down_factor: float = 0.8, - * screen_size: int = 1000, - * lambda_grid: Optional[List[List[float]]] = None, # <<<<<<<<<<<<<< - * exclude_first_k: int = 0, - * intercept: bool = True, - */ - values[21] = ((PyObject *)Py_None); - values[22] = ((PyObject *)__pyx_int_0); - - /* "l0learn/interface.pyx":467 - * lambda_grid: Optional[List[List[float]]] = None, - * exclude_first_k: int = 0, - * intercept: bool = True, # <<<<<<<<<<<<<< - * lows: Union[np.ndarray, float] = -float('inf'), - * highs: Union[np.ndarray, float] = +float('inf'),): - */ - values[23] = ((PyObject *)Py_True); - values[24] = __pyx_k__9; - values[25] = __pyx_k__10; + values[21] = ((PyObject *)Py_True); + values[22] = __pyx_k__7; + values[23] = __pyx_k__8; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { - case 26: values[25] = PyTuple_GET_ITEM(__pyx_args, 25); - CYTHON_FALLTHROUGH; - case 25: values[24] = PyTuple_GET_ITEM(__pyx_args, 24); - CYTHON_FALLTHROUGH; case 24: values[23] = PyTuple_GET_ITEM(__pyx_args, 23); CYTHON_FALLTHROUGH; case 23: values[22] = PyTuple_GET_ITEM(__pyx_args, 22); @@ -7484,7 +7066,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("cvfit", 0, 2, 26, 1); __PYX_ERR(0, 444, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("fit", 0, 2, 24, 1); __PYX_ERR(0, 247, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: @@ -7507,139 +7089,123 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj CYTHON_FALLTHROUGH; case 5: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_num_folds); + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_support_size); if (value) { values[5] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 6: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_seed); + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_num_lambda); if (value) { values[6] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 7: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_support_size); + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_num_gamma); if (value) { values[7] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 8: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_num_lambda); + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_gamma_max); if (value) { values[8] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 9: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_num_gamma); + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_gamma_min); if (value) { values[9] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 10: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_gamma_max); + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_partial_sort); if (value) { values[10] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 11: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_gamma_min); + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_iter); if (value) { values[11] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 12: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_partial_sort); + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rtol); if (value) { values[12] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 13: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_iter); + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_atol); if (value) { values[13] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 14: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rtol); + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_active_set); if (value) { values[14] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 15: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_atol); + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_active_set_num); if (value) { values[15] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 16: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_active_set); + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_swaps); if (value) { values[16] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 17: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_active_set_num); + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_scale_down_factor); if (value) { values[17] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 18: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_swaps); + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_screen_size); if (value) { values[18] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 19: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_scale_down_factor); + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_lambda_grid); if (value) { values[19] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 20: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_screen_size); + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_exclude_first_k); if (value) { values[20] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 21: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_lambda_grid); + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_intercept); if (value) { values[21] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 22: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_exclude_first_k); + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_lows); if (value) { values[22] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 23: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_intercept); - if (value) { values[23] = value; kw_args--; } - } - CYTHON_FALLTHROUGH; - case 24: - if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_lows); - if (value) { values[24] = value; kw_args--; } - } - CYTHON_FALLTHROUGH; - case 25: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_highs); - if (value) { values[25] = value; kw_args--; } + if (value) { values[23] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "cvfit") < 0)) __PYX_ERR(0, 444, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fit") < 0)) __PYX_ERR(0, 247, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { - case 26: values[25] = PyTuple_GET_ITEM(__pyx_args, 25); - CYTHON_FALLTHROUGH; - case 25: values[24] = PyTuple_GET_ITEM(__pyx_args, 24); - CYTHON_FALLTHROUGH; case 24: values[23] = PyTuple_GET_ITEM(__pyx_args, 23); CYTHON_FALLTHROUGH; case 23: values[22] = PyTuple_GET_ITEM(__pyx_args, 22); @@ -7695,67 +7261,65 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj __pyx_v_loss = ((PyObject*)values[2]); __pyx_v_penalty = ((PyObject*)values[3]); __pyx_v_algorithm = ((PyObject*)values[4]); - __pyx_v_num_folds = values[5]; - __pyx_v_seed = values[6]; - __pyx_v_max_support_size = values[7]; - __pyx_v_num_lambda = values[8]; - __pyx_v_num_gamma = values[9]; - if (values[10]) { - __pyx_v_gamma_max = __pyx_PyFloat_AsDouble(values[10]); if (unlikely((__pyx_v_gamma_max == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 454, __pyx_L3_error) + __pyx_v_max_support_size = values[5]; + __pyx_v_num_lambda = values[6]; + __pyx_v_num_gamma = values[7]; + if (values[8]) { + __pyx_v_gamma_max = __pyx_PyFloat_AsDouble(values[8]); if (unlikely((__pyx_v_gamma_max == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 255, __pyx_L3_error) } else { __pyx_v_gamma_max = ((double)10.); } - if (values[11]) { - __pyx_v_gamma_min = __pyx_PyFloat_AsDouble(values[11]); if (unlikely((__pyx_v_gamma_min == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 455, __pyx_L3_error) + if (values[9]) { + __pyx_v_gamma_min = __pyx_PyFloat_AsDouble(values[9]); if (unlikely((__pyx_v_gamma_min == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 256, __pyx_L3_error) } else { __pyx_v_gamma_min = ((double).0001); } - __pyx_v_partial_sort = values[12]; - __pyx_v_max_iter = values[13]; - if (values[14]) { - __pyx_v_rtol = __pyx_PyFloat_AsDouble(values[14]); if (unlikely((__pyx_v_rtol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 458, __pyx_L3_error) + __pyx_v_partial_sort = values[10]; + __pyx_v_max_iter = values[11]; + if (values[12]) { + __pyx_v_rtol = __pyx_PyFloat_AsDouble(values[12]); if (unlikely((__pyx_v_rtol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 259, __pyx_L3_error) } else { __pyx_v_rtol = ((double)1e-6); } - if (values[15]) { - __pyx_v_atol = __pyx_PyFloat_AsDouble(values[15]); if (unlikely((__pyx_v_atol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 459, __pyx_L3_error) + if (values[13]) { + __pyx_v_atol = __pyx_PyFloat_AsDouble(values[13]); if (unlikely((__pyx_v_atol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 260, __pyx_L3_error) } else { __pyx_v_atol = ((double)1e-9); } - __pyx_v_active_set = values[16]; - __pyx_v_active_set_num = values[17]; - __pyx_v_max_swaps = values[18]; - if (values[19]) { - __pyx_v_scale_down_factor = __pyx_PyFloat_AsDouble(values[19]); if (unlikely((__pyx_v_scale_down_factor == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 463, __pyx_L3_error) + __pyx_v_active_set = values[14]; + __pyx_v_active_set_num = values[15]; + __pyx_v_max_swaps = values[16]; + if (values[17]) { + __pyx_v_scale_down_factor = __pyx_PyFloat_AsDouble(values[17]); if (unlikely((__pyx_v_scale_down_factor == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 264, __pyx_L3_error) } else { __pyx_v_scale_down_factor = ((double)0.8); } - __pyx_v_screen_size = values[20]; - __pyx_v_lambda_grid = values[21]; - __pyx_v_exclude_first_k = values[22]; - __pyx_v_intercept = values[23]; - __pyx_v_lows = values[24]; - __pyx_v_highs = values[25]; + __pyx_v_screen_size = values[18]; + __pyx_v_lambda_grid = values[19]; + __pyx_v_exclude_first_k = values[20]; + __pyx_v_intercept = values[21]; + __pyx_v_lows = values[22]; + __pyx_v_highs = values[23]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("cvfit", 0, 2, 26, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 444, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("fit", 0, 2, 24, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 247, __pyx_L3_error) __pyx_L3_error:; - __Pyx_AddTraceback("l0learn.interface.cvfit", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_AddTraceback("l0learn.interface.fit", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loss), (&PyUnicode_Type), 1, "loss", 1))) __PYX_ERR(0, 446, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_penalty), (&PyUnicode_Type), 1, "penalty", 1))) __PYX_ERR(0, 447, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_algorithm), (&PyUnicode_Type), 1, "algorithm", 1))) __PYX_ERR(0, 448, __pyx_L1_error) - __pyx_r = __pyx_pf_7l0learn_9interface_4cvfit(__pyx_self, __pyx_v_X, __pyx_v_y, __pyx_v_loss, __pyx_v_penalty, __pyx_v_algorithm, __pyx_v_num_folds, __pyx_v_seed, __pyx_v_max_support_size, __pyx_v_num_lambda, __pyx_v_num_gamma, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_v_partial_sort, __pyx_v_max_iter, __pyx_v_rtol, __pyx_v_atol, __pyx_v_active_set, __pyx_v_active_set_num, __pyx_v_max_swaps, __pyx_v_scale_down_factor, __pyx_v_screen_size, __pyx_v_lambda_grid, __pyx_v_exclude_first_k, __pyx_v_intercept, __pyx_v_lows, __pyx_v_highs); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loss), (&PyUnicode_Type), 1, "loss", 1))) __PYX_ERR(0, 249, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_penalty), (&PyUnicode_Type), 1, "penalty", 1))) __PYX_ERR(0, 250, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_algorithm), (&PyUnicode_Type), 1, "algorithm", 1))) __PYX_ERR(0, 251, __pyx_L1_error) + __pyx_r = __pyx_pf_7l0learn_9interface_4fit(__pyx_self, __pyx_v_X, __pyx_v_y, __pyx_v_loss, __pyx_v_penalty, __pyx_v_algorithm, __pyx_v_max_support_size, __pyx_v_num_lambda, __pyx_v_num_gamma, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_v_partial_sort, __pyx_v_max_iter, __pyx_v_rtol, __pyx_v_atol, __pyx_v_active_set, __pyx_v_active_set_num, __pyx_v_max_swaps, __pyx_v_scale_down_factor, __pyx_v_screen_size, __pyx_v_lambda_grid, __pyx_v_exclude_first_k, __pyx_v_intercept, __pyx_v_lows, __pyx_v_highs); - /* "l0learn/interface.pyx":444 + /* "l0learn/interface.pyx":247 * * - * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< - * y: np.ndarray, - * loss: str = "SquaredHinge", + * def fit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< + * y: np.ndarray, + * loss: str = "SquaredError", */ /* function exit code */ @@ -7767,3383 +7331,2177 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj return __pyx_r; } -static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_num_folds, PyObject *__pyx_v_seed, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs) { - PyObject *__pyx_v_n = NULL; - PyObject *__pyx_v_p = NULL; - PyObject *__pyx_v_unique_items = NULL; - PyObject *__pyx_v_a = NULL; - CYTHON_UNUSED PyObject *__pyx_v__ = NULL; - int __pyx_v_auto_lambda; - CYTHON_UNUSED int __pyx_v_bad_lambda_grid; - PyObject *__pyx_v_i = NULL; - PyObject *__pyx_v_sub_lambda_grid = NULL; - CYTHON_UNUSED double __pyx_v_current; - int __pyx_v_with_bounds; - PyObject *__pyx_v_bad_bounds = NULL; +static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs) { + PyObject *__pyx_v_check = NULL; + PyObject *__pyx_v_auto_lambda = NULL; + PyObject *__pyx_v_with_bounds = NULL; std::vector > __pyx_v_c_lambda_grid; std::string __pyx_v_c_loss; std::string __pyx_v_c_penalty; std::string __pyx_v_c_algorithim; - cvfitmodel __pyx_v_c_results; + fitmodel __pyx_v_c_results; PyObject *__pyx_v_results = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - int __pyx_t_1; + PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - int __pyx_t_5; - int __pyx_t_6; + double __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - Py_ssize_t __pyx_t_9; - Py_UCS4 __pyx_t_10; - PyObject *(*__pyx_t_11)(PyObject *); - int __pyx_t_12; - PyObject *(*__pyx_t_13)(PyObject *); - double __pyx_t_14; - Py_ssize_t __pyx_t_15; - PyObject *__pyx_t_16 = NULL; - PyObject *__pyx_t_17 = NULL; - PyObject *__pyx_t_18 = NULL; - PyObject *__pyx_t_19 = NULL; - std::vector > __pyx_t_20; - int __pyx_t_21; - std::string __pyx_t_22; + std::vector > __pyx_t_8; + int __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + std::string __pyx_t_12; + int __pyx_t_13; + int __pyx_t_14; + size_t __pyx_t_15; + size_t __pyx_t_16; + size_t __pyx_t_17; + bool __pyx_t_18; + size_t __pyx_t_19; + bool __pyx_t_20; + size_t __pyx_t_21; + size_t __pyx_t_22; size_t __pyx_t_23; size_t __pyx_t_24; - size_t __pyx_t_25; + bool __pyx_t_25; bool __pyx_t_26; - size_t __pyx_t_27; - bool __pyx_t_28; - size_t __pyx_t_29; - size_t __pyx_t_30; - size_t __pyx_t_31; - unsigned int __pyx_t_32; - size_t __pyx_t_33; - bool __pyx_t_34; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("cvfit", 0); + __Pyx_RefNannySetupContext("fit", 0); __Pyx_INCREF(__pyx_v_y); __Pyx_INCREF(__pyx_v_penalty); + __Pyx_INCREF(__pyx_v_max_support_size); __Pyx_INCREF(__pyx_v_num_lambda); __Pyx_INCREF(__pyx_v_num_gamma); + __Pyx_INCREF(__pyx_v_screen_size); __Pyx_INCREF(__pyx_v_lambda_grid); __Pyx_INCREF(__pyx_v_lows); __Pyx_INCREF(__pyx_v_highs); - /* "l0learn/interface.pyx":470 - * lows: Union[np.ndarray, float] = -float('inf'), - * highs: Union[np.ndarray, float] = +float('inf'),): - * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): # <<<<<<<<<<<<<< - * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") - * + /* "l0learn/interface.pyx":418 + * -------- + * """ + * check = _fit_check(X=X, # <<<<<<<<<<<<<< + * y=y, + * loss=loss, */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 470, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_fit_check); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 418, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyDict_NewPresized(24); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 418, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 470, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_X, __pyx_v_X) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + + /* "l0learn/interface.pyx":419 + * """ + * check = _fit_check(X=X, + * y=y, # <<<<<<<<<<<<<< + * loss=loss, + * penalty=penalty, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_y, __pyx_v_y) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + + /* "l0learn/interface.pyx":420 + * check = _fit_check(X=X, + * y=y, + * loss=loss, # <<<<<<<<<<<<<< + * penalty=penalty, + * algorithm=algorithm, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + + /* "l0learn/interface.pyx":421 + * y=y, + * loss=loss, + * penalty=penalty, # <<<<<<<<<<<<<< + * algorithm=algorithm, + * max_support_size=max_support_size, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + + /* "l0learn/interface.pyx":422 + * loss=loss, + * penalty=penalty, + * algorithm=algorithm, # <<<<<<<<<<<<<< + * max_support_size=max_support_size, + * num_lambda=num_lambda, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_algorithm, __pyx_v_algorithm) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + + /* "l0learn/interface.pyx":423 + * penalty=penalty, + * algorithm=algorithm, + * max_support_size=max_support_size, # <<<<<<<<<<<<<< + * num_lambda=num_lambda, + * num_gamma=num_gamma, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_support_size, __pyx_v_max_support_size) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + + /* "l0learn/interface.pyx":424 + * algorithm=algorithm, + * max_support_size=max_support_size, + * num_lambda=num_lambda, # <<<<<<<<<<<<<< + * num_gamma=num_gamma, + * gamma_max=gamma_max, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_lambda, __pyx_v_num_lambda) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + + /* "l0learn/interface.pyx":425 + * max_support_size=max_support_size, + * num_lambda=num_lambda, + * num_gamma=num_gamma, # <<<<<<<<<<<<<< + * gamma_max=gamma_max, + * gamma_min=gamma_min, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_gamma, __pyx_v_num_gamma) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + + /* "l0learn/interface.pyx":426 + * num_lambda=num_lambda, + * num_gamma=num_gamma, + * gamma_max=gamma_max, # <<<<<<<<<<<<<< + * gamma_min=gamma_min, + * partial_sort=partial_sort, + */ + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 426, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 470, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_5 = PyObject_IsInstance(__pyx_v_X, __pyx_t_3); - __pyx_t_6 = (__pyx_t_5 != 0); - if (!__pyx_t_6) { - } else { - __pyx_t_4 = __pyx_t_6; - goto __pyx_L6_bool_binop_done; - } - __pyx_t_6 = PyObject_IsInstance(__pyx_v_X, __pyx_t_2); - __pyx_t_5 = (__pyx_t_6 != 0); - __pyx_t_4 = __pyx_t_5; - __pyx_L6_bool_binop_done:; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma_max, __pyx_t_3) < 0) __PYX_ERR(0, 418, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); - if (!__pyx_t_5) { - } else { - __pyx_t_1 = __pyx_t_5; - goto __pyx_L4_bool_binop_done; - } - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 470, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 470, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_7); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_7, function); - } - } - __pyx_t_3 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_2, __pyx_v_X) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_X); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 470, __pyx_L1_error) + + /* "l0learn/interface.pyx":427 + * num_gamma=num_gamma, + * gamma_max=gamma_max, + * gamma_min=gamma_min, # <<<<<<<<<<<<<< + * partial_sort=partial_sort, + * max_iter=max_iter, + */ + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 427, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 470, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma_min, __pyx_t_3) < 0) __PYX_ERR(0, 418, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_4 = ((!__pyx_t_5) != 0); - if (!__pyx_t_4) { - } else { - __pyx_t_1 = __pyx_t_4; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 470, __pyx_L1_error) + + /* "l0learn/interface.pyx":428 + * gamma_max=gamma_max, + * gamma_min=gamma_min, + * partial_sort=partial_sort, # <<<<<<<<<<<<<< + * max_iter=max_iter, + * rtol=rtol, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_partial_sort, __pyx_v_partial_sort) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + + /* "l0learn/interface.pyx":429 + * gamma_min=gamma_min, + * partial_sort=partial_sort, + * max_iter=max_iter, # <<<<<<<<<<<<<< + * rtol=rtol, + * atol=atol, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_iter, __pyx_v_max_iter) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + + /* "l0learn/interface.pyx":430 + * partial_sort=partial_sort, + * max_iter=max_iter, + * rtol=rtol, # <<<<<<<<<<<<<< + * atol=atol, + * active_set=active_set, + */ + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_rtol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 430, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyInt_NeObjC(__pyx_t_3, __pyx_int_2, 2, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 470, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_rtol, __pyx_t_3) < 0) __PYX_ERR(0, 418, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 470, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (!__pyx_t_4) { - } else { - __pyx_t_1 = __pyx_t_4; - goto __pyx_L4_bool_binop_done; - } - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 470, __pyx_L1_error) + + /* "l0learn/interface.pyx":431 + * max_iter=max_iter, + * rtol=rtol, + * atol=atol, # <<<<<<<<<<<<<< + * active_set=active_set, + * active_set_num=active_set_num, + */ + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_atol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 431, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_product); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 470, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_atol, __pyx_t_3) < 0) __PYX_ERR(0, 418, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 470, __pyx_L1_error) + + /* "l0learn/interface.pyx":432 + * rtol=rtol, + * atol=atol, + * active_set=active_set, # <<<<<<<<<<<<<< + * active_set_num=active_set_num, + * max_swaps=max_swaps, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_active_set, __pyx_v_active_set) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + + /* "l0learn/interface.pyx":433 + * atol=atol, + * active_set=active_set, + * active_set_num=active_set_num, # <<<<<<<<<<<<<< + * max_swaps=max_swaps, + * scale_down_factor=scale_down_factor, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_active_set_num, __pyx_v_active_set_num) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + + /* "l0learn/interface.pyx":434 + * active_set=active_set, + * active_set_num=active_set_num, + * max_swaps=max_swaps, # <<<<<<<<<<<<<< + * scale_down_factor=scale_down_factor, + * screen_size=screen_size, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_swaps, __pyx_v_max_swaps) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + + /* "l0learn/interface.pyx":435 + * active_set_num=active_set_num, + * max_swaps=max_swaps, + * scale_down_factor=scale_down_factor, # <<<<<<<<<<<<<< + * screen_size=screen_size, + * lambda_grid=lambda_grid, + */ + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_scale_down_factor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 435, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_8 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_8); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - } - } - __pyx_t_7 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_8, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_scale_down_factor, __pyx_t_3) < 0) __PYX_ERR(0, 418, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 470, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 470, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_5 = ((!__pyx_t_4) != 0); - __pyx_t_1 = __pyx_t_5; - __pyx_L4_bool_binop_done:; - if (unlikely(__pyx_t_1)) { - /* "l0learn/interface.pyx":471 - * highs: Union[np.ndarray, float] = +float('inf'),): - * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): - * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") # <<<<<<<<<<<<<< + /* "l0learn/interface.pyx":436 + * max_swaps=max_swaps, + * scale_down_factor=scale_down_factor, + * screen_size=screen_size, # <<<<<<<<<<<<<< + * lambda_grid=lambda_grid, + * exclude_first_k=exclude_first_k, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_screen_size, __pyx_v_screen_size) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + + /* "l0learn/interface.pyx":437 + * scale_down_factor=scale_down_factor, + * screen_size=screen_size, + * lambda_grid=lambda_grid, # <<<<<<<<<<<<<< + * exclude_first_k=exclude_first_k, + * intercept=intercept, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lambda_grid, __pyx_v_lambda_grid) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + + /* "l0learn/interface.pyx":438 + * screen_size=screen_size, + * lambda_grid=lambda_grid, + * exclude_first_k=exclude_first_k, # <<<<<<<<<<<<<< + * intercept=intercept, + * lows=lows, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_exclude_first_k, __pyx_v_exclude_first_k) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + + /* "l0learn/interface.pyx":439 + * lambda_grid=lambda_grid, + * exclude_first_k=exclude_first_k, + * intercept=intercept, # <<<<<<<<<<<<<< + * lows=lows, + * highs=highs) + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + + /* "l0learn/interface.pyx":440 + * exclude_first_k=exclude_first_k, + * intercept=intercept, + * lows=lows, # <<<<<<<<<<<<<< + * highs=highs) * - * n, p = X.shape */ - __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 471, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_9 = 0; - __pyx_t_10 = 127; - __Pyx_INCREF(__pyx_kp_u_expected_X_to_be_a_2D_non_degene); - __pyx_t_9 += 71; - __Pyx_GIVEREF(__pyx_kp_u_expected_X_to_be_a_2D_non_degene); - PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_X_to_be_a_2D_non_degene); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_X, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 471, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_2); - __pyx_t_2 = 0; - __Pyx_INCREF(__pyx_kp_u__5); - __pyx_t_9 += 1; - __Pyx_GIVEREF(__pyx_kp_u__5); - PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u__5); - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 471, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 471, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_7, 0, 0, 0); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 471, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lows, __pyx_v_lows) < 0) __PYX_ERR(0, 418, __pyx_L1_error) - /* "l0learn/interface.pyx":470 - * lows: Union[np.ndarray, float] = -float('inf'), - * highs: Union[np.ndarray, float] = +float('inf'),): - * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): # <<<<<<<<<<<<<< - * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") + /* "l0learn/interface.pyx":441 + * intercept=intercept, + * lows=lows, + * highs=highs) # <<<<<<<<<<<<<< * + * max_support_size = check["max_support_size"] */ - } + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_highs, __pyx_v_highs) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + + /* "l0learn/interface.pyx":418 + * -------- + * """ + * check = _fit_check(X=X, # <<<<<<<<<<<<<< + * y=y, + * loss=loss, + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 418, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_check = __pyx_t_3; + __pyx_t_3 = 0; - /* "l0learn/interface.pyx":473 - * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") + /* "l0learn/interface.pyx":443 + * highs=highs) * - * n, p = X.shape # <<<<<<<<<<<<<< - * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: - * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") + * max_support_size = check["max_support_size"] # <<<<<<<<<<<<<< + * screen_size = check["screen_size"] + * y = check['y'] */ - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 473, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if ((likely(PyTuple_CheckExact(__pyx_t_7))) || (PyList_CheckExact(__pyx_t_7))) { - PyObject* sequence = __pyx_t_7; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 473, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); - } else { - __pyx_t_2 = PyList_GET_ITEM(sequence, 0); - __pyx_t_3 = PyList_GET_ITEM(sequence, 1); - } - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - #else - __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 473, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 473, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - #endif - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - } else { - Py_ssize_t index = -1; - __pyx_t_8 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 473, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_11 = Py_TYPE(__pyx_t_8)->tp_iternext; - index = 0; __pyx_t_2 = __pyx_t_11(__pyx_t_8); if (unlikely(!__pyx_t_2)) goto __pyx_L10_unpacking_failed; - __Pyx_GOTREF(__pyx_t_2); - index = 1; __pyx_t_3 = __pyx_t_11(__pyx_t_8); if (unlikely(!__pyx_t_3)) goto __pyx_L10_unpacking_failed; - __Pyx_GOTREF(__pyx_t_3); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_8), 2) < 0) __PYX_ERR(0, 473, __pyx_L1_error) - __pyx_t_11 = NULL; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - goto __pyx_L11_unpacking_done; - __pyx_L10_unpacking_failed:; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_11 = NULL; - if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 473, __pyx_L1_error) - __pyx_L11_unpacking_done:; - } - __pyx_v_n = __pyx_t_2; - __pyx_t_2 = 0; - __pyx_v_p = __pyx_t_3; + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_max_support_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 443, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_max_support_size, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":474 - * - * n, p = X.shape - * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: # <<<<<<<<<<<<<< - * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") + /* "l0learn/interface.pyx":444 * + * max_support_size = check["max_support_size"] + * screen_size = check["screen_size"] # <<<<<<<<<<<<<< + * y = check['y'] + * penalty = check['penalty'] */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 474, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 474, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_screen_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 444, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_5 = PyObject_IsInstance(__pyx_v_y, __pyx_t_3); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 474, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_4 = ((!(__pyx_t_5 != 0)) != 0); - if (!__pyx_t_4) { - } else { - __pyx_t_1 = __pyx_t_4; - goto __pyx_L13_bool_binop_done; - } - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 474, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 474, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_7)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_7); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - } - } - __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_7, __pyx_v_y) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_y); - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 474, __pyx_L1_error) + __Pyx_DECREF_SET(__pyx_v_screen_size, __pyx_t_3); + __pyx_t_3 = 0; + + /* "l0learn/interface.pyx":445 + * max_support_size = check["max_support_size"] + * screen_size = check["screen_size"] + * y = check['y'] # <<<<<<<<<<<<<< + * penalty = check['penalty'] + * gamma_max = check['gamma_max'] + */ + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_y); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 445, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 474, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_5 = ((!__pyx_t_4) != 0); - if (!__pyx_t_5) { - } else { - __pyx_t_1 = __pyx_t_5; - goto __pyx_L13_bool_binop_done; - } - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_y, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 474, __pyx_L1_error) + __Pyx_DECREF_SET(__pyx_v_y, __pyx_t_3); + __pyx_t_3 = 0; + + /* "l0learn/interface.pyx":446 + * screen_size = check["screen_size"] + * y = check['y'] + * penalty = check['penalty'] # <<<<<<<<<<<<<< + * gamma_max = check['gamma_max'] + * gamma_min = check['gamma_min'] + */ + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_penalty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 446, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_PyInt_NeObjC(__pyx_t_3, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 474, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); + if (!(likely(PyUnicode_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(0, 446, __pyx_L1_error) + __Pyx_DECREF_SET(__pyx_v_penalty, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "l0learn/interface.pyx":447 + * y = check['y'] + * penalty = check['penalty'] + * gamma_max = check['gamma_max'] # <<<<<<<<<<<<<< + * gamma_min = check['gamma_min'] + * lambda_grid = check['lambda_grid'] + */ + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 447, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 447, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 474, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (!__pyx_t_5) { - } else { - __pyx_t_1 = __pyx_t_5; - goto __pyx_L13_bool_binop_done; - } - __pyx_t_9 = PyObject_Length(__pyx_v_y); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 474, __pyx_L1_error) - __pyx_t_2 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 474, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyObject_RichCompare(__pyx_t_2, __pyx_v_n, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 474, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 474, __pyx_L1_error) + __pyx_v_gamma_max = __pyx_t_4; + + /* "l0learn/interface.pyx":448 + * penalty = check['penalty'] + * gamma_max = check['gamma_max'] + * gamma_min = check['gamma_min'] # <<<<<<<<<<<<<< + * lambda_grid = check['lambda_grid'] + * num_gamma = check['num_gamma'] + */ + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_gamma_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 448, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 448, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_1 = __pyx_t_5; - __pyx_L13_bool_binop_done:; - if (unlikely(__pyx_t_1)) { + __pyx_v_gamma_min = __pyx_t_4; - /* "l0learn/interface.pyx":475 - * n, p = X.shape - * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: - * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") # <<<<<<<<<<<<<< - * - * if loss not in SUPPORTED_LOSS: + /* "l0learn/interface.pyx":449 + * gamma_max = check['gamma_max'] + * gamma_min = check['gamma_min'] + * lambda_grid = check['lambda_grid'] # <<<<<<<<<<<<<< + * num_gamma = check['num_gamma'] + * num_lambda = check['num_lambda'] */ - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 475, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_9 = 0; - __pyx_t_10 = 127; - __Pyx_INCREF(__pyx_kp_u_expected_y_to_be_a_1D_real_numpy); - __pyx_t_9 += 42; - __Pyx_GIVEREF(__pyx_kp_u_expected_y_to_be_a_1D_real_numpy); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_y_to_be_a_1D_real_numpy); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_y, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 475, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); - __pyx_t_2 = 0; - __Pyx_INCREF(__pyx_kp_u__5); - __pyx_t_9 += 1; - __Pyx_GIVEREF(__pyx_kp_u__5); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u__5); - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 475, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 475, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 475, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_lambda_grid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_lambda_grid, __pyx_t_3); + __pyx_t_3 = 0; - /* "l0learn/interface.pyx":474 - * - * n, p = X.shape - * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: # <<<<<<<<<<<<<< - * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") - * + /* "l0learn/interface.pyx":450 + * gamma_min = check['gamma_min'] + * lambda_grid = check['lambda_grid'] + * num_gamma = check['num_gamma'] # <<<<<<<<<<<<<< + * num_lambda = check['num_lambda'] + * auto_lambda = check['auto_lambda'] */ - } + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_num_gamma); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 450, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_num_gamma, __pyx_t_3); + __pyx_t_3 = 0; - /* "l0learn/interface.pyx":477 - * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") - * - * if loss not in SUPPORTED_LOSS: # <<<<<<<<<<<<<< - * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") - * + /* "l0learn/interface.pyx":451 + * lambda_grid = check['lambda_grid'] + * num_gamma = check['num_gamma'] + * num_lambda = check['num_lambda'] # <<<<<<<<<<<<<< + * auto_lambda = check['auto_lambda'] + * with_bounds = check['with_bounds'] */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 477, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_num_lambda); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 451, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_loss, __pyx_t_3, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 477, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_5 = (__pyx_t_1 != 0); - if (unlikely(__pyx_t_5)) { + __Pyx_DECREF_SET(__pyx_v_num_lambda, __pyx_t_3); + __pyx_t_3 = 0; - /* "l0learn/interface.pyx":478 - * - * if loss not in SUPPORTED_LOSS: - * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") # <<<<<<<<<<<<<< - * - * if penalty not in SUPPORTED_PENALTY: + /* "l0learn/interface.pyx":452 + * num_gamma = check['num_gamma'] + * num_lambda = check['num_lambda'] + * auto_lambda = check['auto_lambda'] # <<<<<<<<<<<<<< + * with_bounds = check['with_bounds'] + * lows = check['lows'] */ - __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 478, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_9 = 0; - __pyx_t_10 = 127; - __Pyx_INCREF(__pyx_kp_u_expected_loss_parameter_to_be_on); - __pyx_t_9 += 36; - __Pyx_GIVEREF(__pyx_kp_u_expected_loss_parameter_to_be_on); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_loss_parameter_to_be_on); - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 478, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 478, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7); - __pyx_t_7 = 0; - __Pyx_INCREF(__pyx_kp_u_but_got); - __pyx_t_9 += 10; - __Pyx_GIVEREF(__pyx_kp_u_but_got); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_but_got); - __pyx_t_7 = __Pyx_PyUnicode_Unicode(__pyx_v_loss); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 478, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_7); - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 478, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 478, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 478, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_auto_lambda); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 452, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_auto_lambda = __pyx_t_3; + __pyx_t_3 = 0; - /* "l0learn/interface.pyx":477 - * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") - * - * if loss not in SUPPORTED_LOSS: # <<<<<<<<<<<<<< - * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") - * + /* "l0learn/interface.pyx":453 + * num_lambda = check['num_lambda'] + * auto_lambda = check['auto_lambda'] + * with_bounds = check['with_bounds'] # <<<<<<<<<<<<<< + * lows = check['lows'] + * highs = check['highs'] */ - } + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_with_bounds); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 453, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_with_bounds = __pyx_t_3; + __pyx_t_3 = 0; - /* "l0learn/interface.pyx":480 - * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") + /* "l0learn/interface.pyx":454 + * auto_lambda = check['auto_lambda'] + * with_bounds = check['with_bounds'] + * lows = check['lows'] # <<<<<<<<<<<<<< + * highs = check['highs'] * - * if penalty not in SUPPORTED_PENALTY: # <<<<<<<<<<<<<< - * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") - * if algorithm not in SUPPORTED_ALGORITHM: */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SUPPORTED_PENALTY); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 480, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_lows); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 454, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_v_penalty, __pyx_t_3, Py_NE)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 480, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_1 = (__pyx_t_5 != 0); - if (unlikely(__pyx_t_1)) { + __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_3); + __pyx_t_3 = 0; - /* "l0learn/interface.pyx":481 + /* "l0learn/interface.pyx":455 + * with_bounds = check['with_bounds'] + * lows = check['lows'] + * highs = check['highs'] # <<<<<<<<<<<<<< * - * if penalty not in SUPPORTED_PENALTY: - * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") # <<<<<<<<<<<<<< - * if algorithm not in SUPPORTED_ALGORITHM: - * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") + * cdef vector[vector[double]] c_lambda_grid */ - __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 481, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_9 = 0; - __pyx_t_10 = 127; - __Pyx_INCREF(__pyx_kp_u_expected_penalty_parameter_to_be); - __pyx_t_9 += 39; - __Pyx_GIVEREF(__pyx_kp_u_expected_penalty_parameter_to_be); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_penalty_parameter_to_be); - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_SUPPORTED_PENALTY); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 481, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 481, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); - __pyx_t_2 = 0; - __Pyx_INCREF(__pyx_kp_u_but_got); - __pyx_t_9 += 10; - __Pyx_GIVEREF(__pyx_kp_u_but_got); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_but_got); - __pyx_t_2 = __Pyx_PyUnicode_Unicode(__pyx_v_penalty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 481, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_2); - __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 481, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 481, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 481, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_highs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 455, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_3); + __pyx_t_3 = 0; - /* "l0learn/interface.pyx":480 - * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") + /* "l0learn/interface.pyx":458 * - * if penalty not in SUPPORTED_PENALTY: # <<<<<<<<<<<<<< - * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") - * if algorithm not in SUPPORTED_ALGORITHM: + * cdef vector[vector[double]] c_lambda_grid + * try: # <<<<<<<<<<<<<< + * c_lambda_grid = lambda_grid + * except TypeError: */ - } + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_7); + /*try:*/ { - /* "l0learn/interface.pyx":482 - * if penalty not in SUPPORTED_PENALTY: - * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") - * if algorithm not in SUPPORTED_ALGORITHM: # <<<<<<<<<<<<<< - * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") - * if not isinstance(num_folds, int) or num_folds < 2: + /* "l0learn/interface.pyx":459 + * cdef vector[vector[double]] c_lambda_grid + * try: + * c_lambda_grid = lambda_grid # <<<<<<<<<<<<<< + * except TypeError: + * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SUPPORTED_ALGORITHM); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 482, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_algorithm, __pyx_t_3, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 482, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_5 = (__pyx_t_1 != 0); - if (unlikely(__pyx_t_5)) { + __pyx_t_8 = __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_lambda_grid); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 459, __pyx_L3_error) + __pyx_v_c_lambda_grid = __pyx_t_8; - /* "l0learn/interface.pyx":483 - * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") - * if algorithm not in SUPPORTED_ALGORITHM: - * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") # <<<<<<<<<<<<<< - * if not isinstance(num_folds, int) or num_folds < 2: - * raise ValueError(f"expected num_folds parameter to be a integer greater than 2, but got {num_folds}") + /* "l0learn/interface.pyx":458 + * + * cdef vector[vector[double]] c_lambda_grid + * try: # <<<<<<<<<<<<<< + * c_lambda_grid = lambda_grid + * except TypeError: */ - __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 483, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_9 = 0; - __pyx_t_10 = 127; - __Pyx_INCREF(__pyx_kp_u_expected_algorithm_parameter_to); - __pyx_t_9 += 41; - __Pyx_GIVEREF(__pyx_kp_u_expected_algorithm_parameter_to); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_algorithm_parameter_to); - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SUPPORTED_ALGORITHM); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 483, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 483, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7); - __pyx_t_7 = 0; - __Pyx_INCREF(__pyx_kp_u_but_got); - __pyx_t_9 += 10; - __Pyx_GIVEREF(__pyx_kp_u_but_got); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_but_got); - __pyx_t_7 = __Pyx_PyUnicode_Unicode(__pyx_v_algorithm); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 483, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_7); - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 483, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 483, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 483, __pyx_L1_error) + } + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":482 - * if penalty not in SUPPORTED_PENALTY: - * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") - * if algorithm not in SUPPORTED_ALGORITHM: # <<<<<<<<<<<<<< - * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") - * if not isinstance(num_folds, int) or num_folds < 2: + /* "l0learn/interface.pyx":460 + * try: + * c_lambda_grid = lambda_grid + * except TypeError: # <<<<<<<<<<<<<< + * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") + * */ - } + __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); + if (__pyx_t_9) { + __Pyx_AddTraceback("l0learn.interface.fit", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_2, &__pyx_t_1) < 0) __PYX_ERR(0, 460, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_t_1); - /* "l0learn/interface.pyx":484 - * if algorithm not in SUPPORTED_ALGORITHM: - * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") - * if not isinstance(num_folds, int) or num_folds < 2: # <<<<<<<<<<<<<< - * raise ValueError(f"expected num_folds parameter to be a integer greater than 2, but got {num_folds}") - * if not isinstance(seed, int): + /* "l0learn/interface.pyx":461 + * c_lambda_grid = lambda_grid + * except TypeError: + * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") # <<<<<<<<<<<<<< + * + * cdef string c_loss = loss.encode('UTF-8') */ - __pyx_t_1 = PyInt_Check(__pyx_v_num_folds); - __pyx_t_4 = ((!(__pyx_t_1 != 0)) != 0); - if (!__pyx_t_4) { - } else { - __pyx_t_5 = __pyx_t_4; - goto __pyx_L21_bool_binop_done; + __pyx_t_10 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 461, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_11 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_be_a_lis, __pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 461, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_11); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 461, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_Raise(__pyx_t_10, 0, 0, 0); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __PYX_ERR(0, 461, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "l0learn/interface.pyx":458 + * + * cdef vector[vector[double]] c_lambda_grid + * try: # <<<<<<<<<<<<<< + * c_lambda_grid = lambda_grid + * except TypeError: + */ + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_XGIVEREF(__pyx_t_6); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7); + goto __pyx_L1_error; + __pyx_L8_try_end:; } - __pyx_t_3 = PyObject_RichCompare(__pyx_v_num_folds, __pyx_int_2, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 484, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 484, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_5 = __pyx_t_4; - __pyx_L21_bool_binop_done:; - if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":485 - * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") - * if not isinstance(num_folds, int) or num_folds < 2: - * raise ValueError(f"expected num_folds parameter to be a integer greater than 2, but got {num_folds}") # <<<<<<<<<<<<<< - * if not isinstance(seed, int): - * raise ValueError(f"expected seed parameter to be an integer, but got {seed}") + /* "l0learn/interface.pyx":463 + * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") + * + * cdef string c_loss = loss.encode('UTF-8') # <<<<<<<<<<<<<< + * cdef string c_penalty = penalty.encode('UTF-8') + * cdef string c_algorithim = algorithm.encode('UTF-8') */ - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_num_folds, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 485, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_folds_parameter_to, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 485, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 485, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 485, __pyx_L1_error) + if (unlikely(__pyx_v_loss == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); + __PYX_ERR(0, 463, __pyx_L1_error) + } + __pyx_t_1 = PyUnicode_AsUTF8String(__pyx_v_loss); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 463, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_12 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 463, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_c_loss = __pyx_t_12; - /* "l0learn/interface.pyx":484 - * if algorithm not in SUPPORTED_ALGORITHM: - * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") - * if not isinstance(num_folds, int) or num_folds < 2: # <<<<<<<<<<<<<< - * raise ValueError(f"expected num_folds parameter to be a integer greater than 2, but got {num_folds}") - * if not isinstance(seed, int): + /* "l0learn/interface.pyx":464 + * + * cdef string c_loss = loss.encode('UTF-8') + * cdef string c_penalty = penalty.encode('UTF-8') # <<<<<<<<<<<<<< + * cdef string c_algorithim = algorithm.encode('UTF-8') + * */ + if (unlikely(__pyx_v_penalty == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); + __PYX_ERR(0, 464, __pyx_L1_error) } + __pyx_t_1 = PyUnicode_AsUTF8String(__pyx_v_penalty); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 464, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_12 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 464, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_c_penalty = __pyx_t_12; - /* "l0learn/interface.pyx":486 - * if not isinstance(num_folds, int) or num_folds < 2: - * raise ValueError(f"expected num_folds parameter to be a integer greater than 2, but got {num_folds}") - * if not isinstance(seed, int): # <<<<<<<<<<<<<< - * raise ValueError(f"expected seed parameter to be an integer, but got {seed}") - * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): + /* "l0learn/interface.pyx":465 + * cdef string c_loss = loss.encode('UTF-8') + * cdef string c_penalty = penalty.encode('UTF-8') + * cdef string c_algorithim = algorithm.encode('UTF-8') # <<<<<<<<<<<<<< + * + * cdef fitmodel c_results */ - __pyx_t_5 = PyInt_Check(__pyx_v_seed); - __pyx_t_4 = ((!(__pyx_t_5 != 0)) != 0); - if (unlikely(__pyx_t_4)) { + if (unlikely(__pyx_v_algorithm == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); + __PYX_ERR(0, 465, __pyx_L1_error) + } + __pyx_t_1 = PyUnicode_AsUTF8String(__pyx_v_algorithm); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 465, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_12 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 465, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_c_algorithim = __pyx_t_12; - /* "l0learn/interface.pyx":487 - * raise ValueError(f"expected num_folds parameter to be a integer greater than 2, but got {num_folds}") - * if not isinstance(seed, int): - * raise ValueError(f"expected seed parameter to be an integer, but got {seed}") # <<<<<<<<<<<<<< - * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): - * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," + /* "l0learn/interface.pyx":468 + * + * cdef fitmodel c_results + * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< + * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), + * y=numpy_to_dvec_d(y), */ - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_seed, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 487, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_seed_parameter_to_be_an, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 487, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 487, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 487, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 468, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 468, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_13 = PyObject_IsInstance(__pyx_v_X, __pyx_t_2); if (unlikely(__pyx_t_13 == ((int)-1))) __PYX_ERR(0, 468, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_14 = (__pyx_t_13 != 0); + if (__pyx_t_14) { - /* "l0learn/interface.pyx":486 - * if not isinstance(num_folds, int) or num_folds < 2: - * raise ValueError(f"expected num_folds parameter to be a integer greater than 2, but got {num_folds}") - * if not isinstance(seed, int): # <<<<<<<<<<<<<< - * raise ValueError(f"expected seed parameter to be an integer, but got {seed}") - * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): + /* "l0learn/interface.pyx":469 + * cdef fitmodel c_results + * if isinstance(X, np.ndarray): + * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< + * y=numpy_to_dvec_d(y), + * Loss=c_loss, */ - } + if (!(likely(((__pyx_v_X) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_X, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 469, __pyx_L1_error) - /* "l0learn/interface.pyx":488 - * if not isinstance(seed, int): - * raise ValueError(f"expected seed parameter to be an integer, but got {seed}") - * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): # <<<<<<<<<<<<<< - * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," - * f" but got {max_support_size}") + /* "l0learn/interface.pyx":470 + * if isinstance(X, np.ndarray): + * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), + * y=numpy_to_dvec_d(y), # <<<<<<<<<<<<<< + * Loss=c_loss, + * Penalty=c_penalty, */ - __pyx_t_5 = PyInt_Check(__pyx_v_max_support_size); - __pyx_t_1 = ((!(__pyx_t_5 != 0)) != 0); - if (!__pyx_t_1) { - } else { - __pyx_t_4 = __pyx_t_1; - goto __pyx_L25_bool_binop_done; - } - __pyx_t_3 = PyObject_RichCompare(__pyx_int_0, __pyx_v_max_support_size, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 488, __pyx_L1_error) - if (__Pyx_PyObject_IsTrue(__pyx_t_3)) { - __Pyx_DECREF(__pyx_t_3); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_max_support_size, __pyx_v_p, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 488, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 488, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_5 = ((!__pyx_t_1) != 0); - __pyx_t_4 = __pyx_t_5; - __pyx_L25_bool_binop_done:; - if (unlikely(__pyx_t_4)) { + if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 470, __pyx_L1_error) - /* "l0learn/interface.pyx":489 - * raise ValueError(f"expected seed parameter to be an integer, but got {seed}") - * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): - * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," # <<<<<<<<<<<<<< - * f" but got {max_support_size}") - * if gamma_max < 0: + /* "l0learn/interface.pyx":474 + * Penalty=c_penalty, + * Algorithm=c_algorithim, + * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< + * G_ncols=num_lambda, + * G_nrows=num_gamma, */ - __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 489, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_9 = 0; - __pyx_t_10 = 127; - __Pyx_INCREF(__pyx_kp_u_expected_max_support_size_parame); - __pyx_t_9 += 71; - __Pyx_GIVEREF(__pyx_kp_u_expected_max_support_size_parame); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_max_support_size_parame); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 489, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7); - __pyx_t_7 = 0; - __Pyx_INCREF(__pyx_kp_u_but_got); - __pyx_t_9 += 10; - __Pyx_GIVEREF(__pyx_kp_u_but_got); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_but_got); + __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 474, __pyx_L1_error) - /* "l0learn/interface.pyx":490 - * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): - * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," - * f" but got {max_support_size}") # <<<<<<<<<<<<<< - * if gamma_max < 0: - * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") + /* "l0learn/interface.pyx":475 + * Algorithm=c_algorithim, + * NnzStopNum=max_support_size, + * G_ncols=num_lambda, # <<<<<<<<<<<<<< + * G_nrows=num_gamma, + * Lambda2Max=gamma_max, */ - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_max_support_size, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 490, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_7); - __pyx_t_7 = 0; + __pyx_t_16 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_16 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 475, __pyx_L1_error) - /* "l0learn/interface.pyx":489 - * raise ValueError(f"expected seed parameter to be an integer, but got {seed}") - * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): - * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," # <<<<<<<<<<<<<< - * f" but got {max_support_size}") - * if gamma_max < 0: + /* "l0learn/interface.pyx":476 + * NnzStopNum=max_support_size, + * G_ncols=num_lambda, + * G_nrows=num_gamma, # <<<<<<<<<<<<<< + * Lambda2Max=gamma_max, + * Lambda2Min=gamma_min, */ - __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 489, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 489, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 489, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_17 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 476, __pyx_L1_error) - /* "l0learn/interface.pyx":488 - * if not isinstance(seed, int): - * raise ValueError(f"expected seed parameter to be an integer, but got {seed}") - * if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): # <<<<<<<<<<<<<< - * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," - * f" but got {max_support_size}") + /* "l0learn/interface.pyx":479 + * Lambda2Max=gamma_max, + * Lambda2Min=gamma_min, + * PartialSort=partial_sort, # <<<<<<<<<<<<<< + * MaxIters=max_iter, + * rtol=rtol, */ - } + __pyx_t_18 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_18 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 479, __pyx_L1_error) - /* "l0learn/interface.pyx":491 - * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," - * f" but got {max_support_size}") - * if gamma_max < 0: # <<<<<<<<<<<<<< - * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") - * if gamma_min < 0 or gamma_min > gamma_max: + /* "l0learn/interface.pyx":480 + * Lambda2Min=gamma_min, + * PartialSort=partial_sort, + * MaxIters=max_iter, # <<<<<<<<<<<<<< + * rtol=rtol, + * atol=atol, */ - __pyx_t_4 = ((__pyx_v_gamma_max < 0.0) != 0); - if (unlikely(__pyx_t_4)) { + __pyx_t_19 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_19 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 480, __pyx_L1_error) - /* "l0learn/interface.pyx":492 - * f" but got {max_support_size}") - * if gamma_max < 0: - * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") # <<<<<<<<<<<<<< - * if gamma_min < 0 or gamma_min > gamma_max: - * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," + /* "l0learn/interface.pyx":483 + * rtol=rtol, + * atol=atol, + * ActiveSet=active_set, # <<<<<<<<<<<<<< + * ActiveSetNum=active_set_num, + * MaxNumSwaps=max_swaps, */ - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 492, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 492, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_gamma_max_parameter_to, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 492, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 492, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_t_7, 0, 0, 0); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 492, __pyx_L1_error) + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_20 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 483, __pyx_L1_error) - /* "l0learn/interface.pyx":491 - * raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," - * f" but got {max_support_size}") - * if gamma_max < 0: # <<<<<<<<<<<<<< - * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") - * if gamma_min < 0 or gamma_min > gamma_max: + /* "l0learn/interface.pyx":484 + * atol=atol, + * ActiveSet=active_set, + * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< + * MaxNumSwaps=max_swaps, + * ScaleDownFactor=scale_down_factor, */ - } + __pyx_t_21 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_21 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 484, __pyx_L1_error) - /* "l0learn/interface.pyx":493 - * if gamma_max < 0: - * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") - * if gamma_min < 0 or gamma_min > gamma_max: # <<<<<<<<<<<<<< - * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," - * f" but got {gamma_min}") + /* "l0learn/interface.pyx":485 + * ActiveSet=active_set, + * ActiveSetNum=active_set_num, + * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< + * ScaleDownFactor=scale_down_factor, + * ScreenSize=screen_size, */ - __pyx_t_5 = ((__pyx_v_gamma_min < 0.0) != 0); - if (!__pyx_t_5) { - } else { - __pyx_t_4 = __pyx_t_5; - goto __pyx_L29_bool_binop_done; - } - __pyx_t_5 = ((__pyx_v_gamma_min > __pyx_v_gamma_max) != 0); - __pyx_t_4 = __pyx_t_5; - __pyx_L29_bool_binop_done:; - if (unlikely(__pyx_t_4)) { + __pyx_t_22 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_22 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 485, __pyx_L1_error) - /* "l0learn/interface.pyx":495 - * if gamma_min < 0 or gamma_min > gamma_max: - * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," - * f" but got {gamma_min}") # <<<<<<<<<<<<<< - * if not isinstance(partial_sort, bool): - * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") + /* "l0learn/interface.pyx":487 + * MaxNumSwaps=max_swaps, + * ScaleDownFactor=scale_down_factor, + * ScreenSize=screen_size, # <<<<<<<<<<<<<< + * LambdaU=not auto_lambda, + * Lambdas=c_lambda_grid, */ - __pyx_t_7 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 495, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 495, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 487, __pyx_L1_error) - /* "l0learn/interface.pyx":494 - * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") - * if gamma_min < 0 or gamma_min > gamma_max: - * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," # <<<<<<<<<<<<<< - * f" but got {gamma_min}") - * if not isinstance(partial_sort, bool): + /* "l0learn/interface.pyx":488 + * ScaleDownFactor=scale_down_factor, + * ScreenSize=screen_size, + * LambdaU=not auto_lambda, # <<<<<<<<<<<<<< + * Lambdas=c_lambda_grid, + * ExcludeFirstK=exclude_first_k, */ - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_gamma_max_parameter_to_2, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 494, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 494, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 494, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 488, __pyx_L1_error) - /* "l0learn/interface.pyx":493 - * if gamma_max < 0: - * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") - * if gamma_min < 0 or gamma_min > gamma_max: # <<<<<<<<<<<<<< - * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," - * f" but got {gamma_min}") + /* "l0learn/interface.pyx":490 + * LambdaU=not auto_lambda, + * Lambdas=c_lambda_grid, + * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< + * Intercept=intercept, + * withBounds=with_bounds, */ - } + __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 490, __pyx_L1_error) - /* "l0learn/interface.pyx":496 - * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," - * f" but got {gamma_min}") - * if not isinstance(partial_sort, bool): # <<<<<<<<<<<<<< - * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") - * if not isinstance(max_iter, int) or max_iter < 1: + /* "l0learn/interface.pyx":491 + * Lambdas=c_lambda_grid, + * ExcludeFirstK=exclude_first_k, + * Intercept=intercept, # <<<<<<<<<<<<<< + * withBounds=with_bounds, + * Lows=numpy_to_dvec_d(lows), */ - __pyx_t_3 = ((PyObject*)&PyBool_Type); - __Pyx_INCREF(__pyx_t_3); - __pyx_t_4 = PyObject_IsInstance(__pyx_v_partial_sort, __pyx_t_3); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 496, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); - if (unlikely(__pyx_t_5)) { + __pyx_t_25 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_25 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 491, __pyx_L1_error) - /* "l0learn/interface.pyx":497 - * f" but got {gamma_min}") - * if not isinstance(partial_sort, bool): - * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") # <<<<<<<<<<<<<< - * if not isinstance(max_iter, int) or max_iter < 1: - * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") + /* "l0learn/interface.pyx":492 + * ExcludeFirstK=exclude_first_k, + * Intercept=intercept, + * withBounds=with_bounds, # <<<<<<<<<<<<<< + * Lows=numpy_to_dvec_d(lows), + * Highs=numpy_to_dvec_d(highs)) */ - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_partial_sort, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 497, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_partial_sort_parameter, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 497, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 497, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 497, __pyx_L1_error) + __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 492, __pyx_L1_error) - /* "l0learn/interface.pyx":496 - * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," - * f" but got {gamma_min}") - * if not isinstance(partial_sort, bool): # <<<<<<<<<<<<<< - * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") - * if not isinstance(max_iter, int) or max_iter < 1: + /* "l0learn/interface.pyx":493 + * Intercept=intercept, + * withBounds=with_bounds, + * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< + * Highs=numpy_to_dvec_d(highs)) + * else: # isinstance(X, csc_matrix) */ - } + if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 493, __pyx_L1_error) - /* "l0learn/interface.pyx":498 - * if not isinstance(partial_sort, bool): - * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") - * if not isinstance(max_iter, int) or max_iter < 1: # <<<<<<<<<<<<<< - * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") - * if rtol < 0 or rtol >= 1: + /* "l0learn/interface.pyx":494 + * withBounds=with_bounds, + * Lows=numpy_to_dvec_d(lows), + * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< + * else: # isinstance(X, csc_matrix) + * c_results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), */ - __pyx_t_4 = PyInt_Check(__pyx_v_max_iter); - __pyx_t_1 = ((!(__pyx_t_4 != 0)) != 0); - if (!__pyx_t_1) { - } else { - __pyx_t_5 = __pyx_t_1; - goto __pyx_L33_bool_binop_done; - } - __pyx_t_3 = PyObject_RichCompare(__pyx_v_max_iter, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 498, __pyx_L1_error) - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 498, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_5 = __pyx_t_1; - __pyx_L33_bool_binop_done:; - if (unlikely(__pyx_t_5)) { + if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 494, __pyx_L1_error) - /* "l0learn/interface.pyx":499 - * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") - * if not isinstance(max_iter, int) or max_iter < 1: - * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") # <<<<<<<<<<<<<< - * if rtol < 0 or rtol >= 1: - * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") + /* "l0learn/interface.pyx":469 + * cdef fitmodel c_results + * if isinstance(X, np.ndarray): + * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< + * y=numpy_to_dvec_d(y), + * Loss=c_loss, */ - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_max_iter, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 499, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_iter_parameter_to_b, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 499, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 499, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 499, __pyx_L1_error) + __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnFit_dense(__pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_X)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_15, __pyx_t_16, __pyx_t_17, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_18, __pyx_t_19, __pyx_v_rtol, __pyx_v_atol, __pyx_t_20, __pyx_t_21, __pyx_t_22, __pyx_v_scale_down_factor, __pyx_t_23, (!__pyx_t_14), __pyx_v_c_lambda_grid, __pyx_t_24, __pyx_t_25, __pyx_t_26, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); - /* "l0learn/interface.pyx":498 - * if not isinstance(partial_sort, bool): - * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") - * if not isinstance(max_iter, int) or max_iter < 1: # <<<<<<<<<<<<<< - * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") - * if rtol < 0 or rtol >= 1: + /* "l0learn/interface.pyx":468 + * + * cdef fitmodel c_results + * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< + * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), + * y=numpy_to_dvec_d(y), */ + goto __pyx_L11; } - /* "l0learn/interface.pyx":500 - * if not isinstance(max_iter, int) or max_iter < 1: - * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") - * if rtol < 0 or rtol >= 1: # <<<<<<<<<<<<<< - * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") - * if atol < 0: + /* "l0learn/interface.pyx":496 + * Highs=numpy_to_dvec_d(highs)) + * else: # isinstance(X, csc_matrix) + * c_results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< + * y=numpy_to_dvec_d(y), + * Loss=c_loss, */ - __pyx_t_1 = ((__pyx_v_rtol < 0.0) != 0); - if (!__pyx_t_1) { - } else { - __pyx_t_5 = __pyx_t_1; - goto __pyx_L36_bool_binop_done; - } - __pyx_t_1 = ((__pyx_v_rtol >= 1.0) != 0); - __pyx_t_5 = __pyx_t_1; - __pyx_L36_bool_binop_done:; - if (unlikely(__pyx_t_5)) { + /*else*/ { - /* "l0learn/interface.pyx":501 - * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") - * if rtol < 0 or rtol >= 1: - * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") # <<<<<<<<<<<<<< - * if atol < 0: - * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") + /* "l0learn/interface.pyx":497 + * else: # isinstance(X, csc_matrix) + * c_results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), + * y=numpy_to_dvec_d(y), # <<<<<<<<<<<<<< + * Loss=c_loss, + * Penalty=c_penalty, */ - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_rtol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 501, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 501, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_rtol_parameter_to_exist, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 501, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 501, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_t_7, 0, 0, 0); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 501, __pyx_L1_error) + if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 497, __pyx_L1_error) - /* "l0learn/interface.pyx":500 - * if not isinstance(max_iter, int) or max_iter < 1: - * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") - * if rtol < 0 or rtol >= 1: # <<<<<<<<<<<<<< - * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") - * if atol < 0: + /* "l0learn/interface.pyx":501 + * Penalty=c_penalty, + * Algorithm=c_algorithim, + * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< + * G_ncols=num_lambda, + * G_nrows=num_gamma, */ - } + __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 501, __pyx_L1_error) - /* "l0learn/interface.pyx":502 - * if rtol < 0 or rtol >= 1: - * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") - * if atol < 0: # <<<<<<<<<<<<<< - * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") - * if not isinstance(active_set, bool): + /* "l0learn/interface.pyx":502 + * Algorithm=c_algorithim, + * NnzStopNum=max_support_size, + * G_ncols=num_lambda, # <<<<<<<<<<<<<< + * G_nrows=num_gamma, + * Lambda2Max=gamma_max, */ - __pyx_t_5 = ((__pyx_v_atol < 0.0) != 0); - if (unlikely(__pyx_t_5)) { + __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 502, __pyx_L1_error) /* "l0learn/interface.pyx":503 - * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") - * if atol < 0: - * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") # <<<<<<<<<<<<<< - * if not isinstance(active_set, bool): - * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") + * NnzStopNum=max_support_size, + * G_ncols=num_lambda, + * G_nrows=num_gamma, # <<<<<<<<<<<<<< + * Lambda2Max=gamma_max, + * Lambda2Min=gamma_min, */ - __pyx_t_7 = PyFloat_FromDouble(__pyx_v_atol); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 503, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 503, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_atol_parameter_to_exist, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 503, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 503, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 503, __pyx_L1_error) + __pyx_t_22 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_22 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 503, __pyx_L1_error) - /* "l0learn/interface.pyx":502 - * if rtol < 0 or rtol >= 1: - * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") - * if atol < 0: # <<<<<<<<<<<<<< - * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") - * if not isinstance(active_set, bool): + /* "l0learn/interface.pyx":506 + * Lambda2Max=gamma_max, + * Lambda2Min=gamma_min, + * PartialSort=partial_sort, # <<<<<<<<<<<<<< + * MaxIters=max_iter, + * rtol=rtol, */ - } + __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 506, __pyx_L1_error) - /* "l0learn/interface.pyx":504 - * if atol < 0: - * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") - * if not isinstance(active_set, bool): # <<<<<<<<<<<<<< - * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") - * if not isinstance(active_set_num, int) or active_set_num < 1: - */ - __pyx_t_3 = ((PyObject*)&PyBool_Type); - __Pyx_INCREF(__pyx_t_3); - __pyx_t_5 = PyObject_IsInstance(__pyx_v_active_set, __pyx_t_3); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 504, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_1 = ((!(__pyx_t_5 != 0)) != 0); - if (unlikely(__pyx_t_1)) { + /* "l0learn/interface.pyx":507 + * Lambda2Min=gamma_min, + * PartialSort=partial_sort, + * MaxIters=max_iter, # <<<<<<<<<<<<<< + * rtol=rtol, + * atol=atol, + */ + __pyx_t_21 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_21 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 507, __pyx_L1_error) - /* "l0learn/interface.pyx":505 - * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") - * if not isinstance(active_set, bool): - * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") # <<<<<<<<<<<<<< - * if not isinstance(active_set_num, int) or active_set_num < 1: - * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") + /* "l0learn/interface.pyx":510 + * rtol=rtol, + * atol=atol, + * ActiveSet=active_set, # <<<<<<<<<<<<<< + * ActiveSetNum=active_set_num, + * MaxNumSwaps=max_swaps, */ - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_active_set, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 505, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_active_set_parameter_to, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 505, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 505, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 505, __pyx_L1_error) + __pyx_t_25 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_25 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 510, __pyx_L1_error) - /* "l0learn/interface.pyx":504 - * if atol < 0: - * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") - * if not isinstance(active_set, bool): # <<<<<<<<<<<<<< - * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") - * if not isinstance(active_set_num, int) or active_set_num < 1: + /* "l0learn/interface.pyx":511 + * atol=atol, + * ActiveSet=active_set, + * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< + * MaxNumSwaps=max_swaps, + * ScaleDownFactor=scale_down_factor, */ - } + __pyx_t_19 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_19 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 511, __pyx_L1_error) - /* "l0learn/interface.pyx":506 - * if not isinstance(active_set, bool): - * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") - * if not isinstance(active_set_num, int) or active_set_num < 1: # <<<<<<<<<<<<<< - * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") - * if not isinstance(max_swaps, int) or max_swaps < 1: + /* "l0learn/interface.pyx":512 + * ActiveSet=active_set, + * ActiveSetNum=active_set_num, + * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< + * ScaleDownFactor=scale_down_factor, + * ScreenSize=screen_size, */ - __pyx_t_5 = PyInt_Check(__pyx_v_active_set_num); - __pyx_t_4 = ((!(__pyx_t_5 != 0)) != 0); - if (!__pyx_t_4) { - } else { - __pyx_t_1 = __pyx_t_4; - goto __pyx_L41_bool_binop_done; - } - __pyx_t_3 = PyObject_RichCompare(__pyx_v_active_set_num, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 506, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 506, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_1 = __pyx_t_4; - __pyx_L41_bool_binop_done:; - if (unlikely(__pyx_t_1)) { + __pyx_t_17 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_17 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 512, __pyx_L1_error) - /* "l0learn/interface.pyx":507 - * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") - * if not isinstance(active_set_num, int) or active_set_num < 1: - * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") # <<<<<<<<<<<<<< - * if not isinstance(max_swaps, int) or max_swaps < 1: - * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") + /* "l0learn/interface.pyx":514 + * MaxNumSwaps=max_swaps, + * ScaleDownFactor=scale_down_factor, + * ScreenSize=screen_size, # <<<<<<<<<<<<<< + * LambdaU=not auto_lambda, + * Lambdas=c_lambda_grid, */ - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_active_set_num, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 507, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_active_set_num_paramete, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 507, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 507, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 507, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_16 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 514, __pyx_L1_error) - /* "l0learn/interface.pyx":506 - * if not isinstance(active_set, bool): - * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") - * if not isinstance(active_set_num, int) or active_set_num < 1: # <<<<<<<<<<<<<< - * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") - * if not isinstance(max_swaps, int) or max_swaps < 1: + /* "l0learn/interface.pyx":515 + * ScaleDownFactor=scale_down_factor, + * ScreenSize=screen_size, + * LambdaU=not auto_lambda, # <<<<<<<<<<<<<< + * Lambdas=c_lambda_grid, + * ExcludeFirstK=exclude_first_k, */ - } + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 515, __pyx_L1_error) - /* "l0learn/interface.pyx":508 - * if not isinstance(active_set_num, int) or active_set_num < 1: - * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") - * if not isinstance(max_swaps, int) or max_swaps < 1: # <<<<<<<<<<<<<< - * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") - * if not (0 < scale_down_factor < 1): + /* "l0learn/interface.pyx":517 + * LambdaU=not auto_lambda, + * Lambdas=c_lambda_grid, + * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< + * Intercept=intercept, + * withBounds=with_bounds, */ - __pyx_t_4 = PyInt_Check(__pyx_v_max_swaps); - __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); - if (!__pyx_t_5) { - } else { - __pyx_t_1 = __pyx_t_5; - goto __pyx_L44_bool_binop_done; - } - __pyx_t_3 = PyObject_RichCompare(__pyx_v_max_swaps, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 508, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 508, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_1 = __pyx_t_5; - __pyx_L44_bool_binop_done:; - if (unlikely(__pyx_t_1)) { + __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 517, __pyx_L1_error) - /* "l0learn/interface.pyx":509 - * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") - * if not isinstance(max_swaps, int) or max_swaps < 1: - * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") # <<<<<<<<<<<<<< - * if not (0 < scale_down_factor < 1): - * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") + /* "l0learn/interface.pyx":518 + * Lambdas=c_lambda_grid, + * ExcludeFirstK=exclude_first_k, + * Intercept=intercept, # <<<<<<<<<<<<<< + * withBounds=with_bounds, + * Lows=numpy_to_dvec_d(lows), */ - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_max_swaps, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 509, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_swaps_parameter_to, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 509, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 509, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 509, __pyx_L1_error) + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_20 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 518, __pyx_L1_error) - /* "l0learn/interface.pyx":508 - * if not isinstance(active_set_num, int) or active_set_num < 1: - * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") - * if not isinstance(max_swaps, int) or max_swaps < 1: # <<<<<<<<<<<<<< - * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") - * if not (0 < scale_down_factor < 1): + /* "l0learn/interface.pyx":519 + * ExcludeFirstK=exclude_first_k, + * Intercept=intercept, + * withBounds=with_bounds, # <<<<<<<<<<<<<< + * Lows=numpy_to_dvec_d(lows), + * Highs=numpy_to_dvec_d(highs)) */ - } + __pyx_t_18 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_18 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 519, __pyx_L1_error) - /* "l0learn/interface.pyx":510 - * if not isinstance(max_swaps, int) or max_swaps < 1: - * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") - * if not (0 < scale_down_factor < 1): # <<<<<<<<<<<<<< - * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") - * if not isinstance(screen_size, int) or screen_size < 1: + /* "l0learn/interface.pyx":520 + * Intercept=intercept, + * withBounds=with_bounds, + * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< + * Highs=numpy_to_dvec_d(highs)) + * */ - __pyx_t_1 = (0.0 < __pyx_v_scale_down_factor); - if (__pyx_t_1) { - __pyx_t_1 = (__pyx_v_scale_down_factor < 1.0); - } - __pyx_t_5 = ((!(__pyx_t_1 != 0)) != 0); - if (unlikely(__pyx_t_5)) { + if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 520, __pyx_L1_error) - /* "l0learn/interface.pyx":511 - * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") - * if not (0 < scale_down_factor < 1): - * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") # <<<<<<<<<<<<<< - * if not isinstance(screen_size, int) or screen_size < 1: - * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") + /* "l0learn/interface.pyx":521 + * withBounds=with_bounds, + * Lows=numpy_to_dvec_d(lows), + * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< + * + * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, */ - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_scale_down_factor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 511, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 511, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_scale_down_factor_param, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 511, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 511, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_t_7, 0, 0, 0); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 511, __pyx_L1_error) + if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 521, __pyx_L1_error) - /* "l0learn/interface.pyx":510 - * if not isinstance(max_swaps, int) or max_swaps < 1: - * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") - * if not (0 < scale_down_factor < 1): # <<<<<<<<<<<<<< - * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") - * if not isinstance(screen_size, int) or screen_size < 1: + /* "l0learn/interface.pyx":496 + * Highs=numpy_to_dvec_d(highs)) + * else: # isinstance(X, csc_matrix) + * c_results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< + * y=numpy_to_dvec_d(y), + * Loss=c_loss, */ + __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnFit_sparse(__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(__pyx_v_X), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_24, __pyx_t_23, __pyx_t_22, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_26, __pyx_t_21, __pyx_v_rtol, __pyx_v_atol, __pyx_t_25, __pyx_t_19, __pyx_t_17, __pyx_v_scale_down_factor, __pyx_t_16, (!__pyx_t_14), __pyx_v_c_lambda_grid, __pyx_t_15, __pyx_t_20, __pyx_t_18, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); } + __pyx_L11:; - /* "l0learn/interface.pyx":512 - * if not (0 < scale_down_factor < 1): - * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") - * if not isinstance(screen_size, int) or screen_size < 1: # <<<<<<<<<<<<<< - * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") - * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): + /* "l0learn/interface.pyx":523 + * Highs=numpy_to_dvec_d(highs)) + * + * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, # <<<<<<<<<<<<<< + * lambda_0=c_results.Lambda0, + * gamma=c_results.Lambda12, */ - __pyx_t_1 = PyInt_Check(__pyx_v_screen_size); - __pyx_t_4 = ((!(__pyx_t_1 != 0)) != 0); - if (!__pyx_t_4) { - } else { - __pyx_t_5 = __pyx_t_4; - goto __pyx_L48_bool_binop_done; - } - __pyx_t_7 = PyObject_RichCompare(__pyx_v_screen_size, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 512, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 512, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_5 = __pyx_t_4; - __pyx_L48_bool_binop_done:; - if (unlikely(__pyx_t_5)) { + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_FitModel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 523, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 523, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 523, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_settings, __pyx_t_3) < 0) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":513 - * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") - * if not isinstance(screen_size, int) or screen_size < 1: - * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") # <<<<<<<<<<<<<< - * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): - * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " + /* "l0learn/interface.pyx":524 + * + * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, + * lambda_0=c_results.Lambda0, # <<<<<<<<<<<<<< + * gamma=c_results.Lambda12, + * support_size=c_results.NnzCount, */ - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_screen_size, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 513, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_screen_size_parameter_t_2, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 513, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 513, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_t_7, 0, 0, 0); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 513, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Lambda0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 524, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_lambda_0, __pyx_t_3) < 0) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":512 - * if not (0 < scale_down_factor < 1): - * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") - * if not isinstance(screen_size, int) or screen_size < 1: # <<<<<<<<<<<<<< - * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") - * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): + /* "l0learn/interface.pyx":525 + * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, + * lambda_0=c_results.Lambda0, + * gamma=c_results.Lambda12, # <<<<<<<<<<<<<< + * support_size=c_results.NnzCount, + * coeffs=sp_dmat_field_to_list(c_results.Beta), */ - } + __pyx_t_3 = __pyx_convert_vector_to_py_double(__pyx_v_c_results.Lambda12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 525, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_gamma, __pyx_t_3) < 0) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":514 - * if not isinstance(screen_size, int) or screen_size < 1: - * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") - * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): # <<<<<<<<<<<<<< - * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " - * f"but got {exclude_first_k}") + /* "l0learn/interface.pyx":526 + * lambda_0=c_results.Lambda0, + * gamma=c_results.Lambda12, + * support_size=c_results.NnzCount, # <<<<<<<<<<<<<< + * coeffs=sp_dmat_field_to_list(c_results.Beta), + * intercepts=c_results.Intercept, */ - __pyx_t_4 = PyInt_Check(__pyx_v_exclude_first_k); - __pyx_t_1 = ((!(__pyx_t_4 != 0)) != 0); - if (!__pyx_t_1) { - } else { - __pyx_t_5 = __pyx_t_1; - goto __pyx_L51_bool_binop_done; - } - __pyx_t_7 = PyObject_RichCompare(__pyx_int_0, __pyx_v_exclude_first_k, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 514, __pyx_L1_error) - if (__Pyx_PyObject_IsTrue(__pyx_t_7)) { - __Pyx_DECREF(__pyx_t_7); - __pyx_t_7 = PyObject_RichCompare(__pyx_v_exclude_first_k, __pyx_v_p, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 514, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 514, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = ((!__pyx_t_1) != 0); - __pyx_t_5 = __pyx_t_4; - __pyx_L51_bool_binop_done:; - if (unlikely(__pyx_t_5)) { + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(__pyx_v_c_results.NnzCount); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 526, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_support_size, __pyx_t_3) < 0) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":515 - * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") - * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): - * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " # <<<<<<<<<<<<<< - * f"but got {exclude_first_k}") - * if not isinstance(intercept, bool): + /* "l0learn/interface.pyx":527 + * gamma=c_results.Lambda12, + * support_size=c_results.NnzCount, + * coeffs=sp_dmat_field_to_list(c_results.Beta), # <<<<<<<<<<<<<< + * intercepts=c_results.Intercept, + * converged=c_results.Converged) */ - __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 515, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_9 = 0; - __pyx_t_10 = 127; - __Pyx_INCREF(__pyx_kp_u_expected_exclude_first_k_paramet); - __pyx_t_9 += 70; - __Pyx_GIVEREF(__pyx_kp_u_expected_exclude_first_k_paramet); - PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_exclude_first_k_paramet); - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 515, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_3); - __pyx_t_3 = 0; - __Pyx_INCREF(__pyx_kp_u_but_got); - __pyx_t_9 += 10; - __Pyx_GIVEREF(__pyx_kp_u_but_got); - PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_but_got); + __pyx_t_3 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_c_results.Beta); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 527, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_coeffs, __pyx_t_3) < 0) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":516 - * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): - * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " - * f"but got {exclude_first_k}") # <<<<<<<<<<<<<< - * if not isinstance(intercept, bool): - * raise ValueError(f"expected intercept parameter to be a bool, " + /* "l0learn/interface.pyx":528 + * support_size=c_results.NnzCount, + * coeffs=sp_dmat_field_to_list(c_results.Beta), + * intercepts=c_results.Intercept, # <<<<<<<<<<<<<< + * converged=c_results.Converged) + * return results */ - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_exclude_first_k, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 516, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_3); - __pyx_t_3 = 0; + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Intercept); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 528, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_intercepts, __pyx_t_3) < 0) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":515 - * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") - * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): - * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " # <<<<<<<<<<<<<< - * f"but got {exclude_first_k}") - * if not isinstance(intercept, bool): + /* "l0learn/interface.pyx":529 + * coeffs=sp_dmat_field_to_list(c_results.Beta), + * intercepts=c_results.Intercept, + * converged=c_results.Converged) # <<<<<<<<<<<<<< + * return results + * */ - __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 515, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 515, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_t_7, 0, 0, 0); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 515, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(__pyx_v_c_results.Converged); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 529, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_converged, __pyx_t_3) < 0) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":514 - * if not isinstance(screen_size, int) or screen_size < 1: - * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") - * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): # <<<<<<<<<<<<<< - * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " - * f"but got {exclude_first_k}") + /* "l0learn/interface.pyx":523 + * Highs=numpy_to_dvec_d(highs)) + * + * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, # <<<<<<<<<<<<<< + * lambda_0=c_results.Lambda0, + * gamma=c_results.Lambda12, */ - } + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_results = __pyx_t_3; + __pyx_t_3 = 0; - /* "l0learn/interface.pyx":517 - * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " - * f"but got {exclude_first_k}") - * if not isinstance(intercept, bool): # <<<<<<<<<<<<<< - * raise ValueError(f"expected intercept parameter to be a bool, " - * f"but got {intercept}") + /* "l0learn/interface.pyx":530 + * intercepts=c_results.Intercept, + * converged=c_results.Converged) + * return results # <<<<<<<<<<<<<< + * + * */ - __pyx_t_7 = ((PyObject*)&PyBool_Type); - __Pyx_INCREF(__pyx_t_7); - __pyx_t_5 = PyObject_IsInstance(__pyx_v_intercept, __pyx_t_7); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 517, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = ((!(__pyx_t_5 != 0)) != 0); - if (unlikely(__pyx_t_4)) { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_results); + __pyx_r = __pyx_v_results; + goto __pyx_L0; - /* "l0learn/interface.pyx":519 - * if not isinstance(intercept, bool): - * raise ValueError(f"expected intercept parameter to be a bool, " - * f"but got {intercept}") # <<<<<<<<<<<<<< + /* "l0learn/interface.pyx":247 * - * if loss in CLASSIFICATION_LOSS: + * + * def fit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< + * y: np.ndarray, + * loss: str = "SquaredError", */ - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_intercept, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 519, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - /* "l0learn/interface.pyx":518 - * f"but got {exclude_first_k}") - * if not isinstance(intercept, bool): - * raise ValueError(f"expected intercept parameter to be a bool, " # <<<<<<<<<<<<<< - * f"but got {intercept}") + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_AddTraceback("l0learn.interface.fit", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_check); + __Pyx_XDECREF(__pyx_v_auto_lambda); + __Pyx_XDECREF(__pyx_v_with_bounds); + __Pyx_XDECREF(__pyx_v_results); + __Pyx_XDECREF(__pyx_v_y); + __Pyx_XDECREF(__pyx_v_penalty); + __Pyx_XDECREF(__pyx_v_max_support_size); + __Pyx_XDECREF(__pyx_v_num_lambda); + __Pyx_XDECREF(__pyx_v_num_gamma); + __Pyx_XDECREF(__pyx_v_screen_size); + __Pyx_XDECREF(__pyx_v_lambda_grid); + __Pyx_XDECREF(__pyx_v_lows); + __Pyx_XDECREF(__pyx_v_highs); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "l0learn/interface.pyx":533 + * * + * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< + * y: np.ndarray, + * loss: str = "SquaredError", */ - __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_intercept_parameter_to, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 518, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 518, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_t_7, 0, 0, 0); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 518, __pyx_L1_error) - /* "l0learn/interface.pyx":517 - * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " - * f"but got {exclude_first_k}") - * if not isinstance(intercept, bool): # <<<<<<<<<<<<<< - * raise ValueError(f"expected intercept parameter to be a bool, " - * f"but got {intercept}") +/* Python wrapper */ +static PyObject *__pyx_pw_7l0learn_9interface_7cvfit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_7l0learn_9interface_6cvfit[] = "cvfit(X: Union[np.ndarray, csc_matrix], y: np.ndarray, unicode loss: str = u'SquaredError', unicode penalty: str = u'L0', unicode algorithm: str = u'CD', num_folds: int = 10, seed: int = 1, max_support_size: int = 100, num_lambda: Optional[int] = 100, num_gamma: Optional[int] = 1, double gamma_max: float = 10., double gamma_min: float = .0001, partial_sort: bool = True, max_iter: int = 200, double rtol: float = 1e-6, double atol: float = 1e-9, active_set: bool = True, active_set_num: int = 3, max_swaps: int = 100, double scale_down_factor: float = 0.8, screen_size: int = 1000, lambda_grid: Optional[List[List[float]]] = None, exclude_first_k: int = 0, intercept: bool = True, lows: Union[np.ndarray, float] = -float(u'inf'), highs: Union[np.ndarray, float] = +float(u'inf')) -> l0learn.models.CVFitModel"; +static PyMethodDef __pyx_mdef_7l0learn_9interface_7cvfit = {"cvfit", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7l0learn_9interface_7cvfit, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7l0learn_9interface_6cvfit}; +static PyObject *__pyx_pw_7l0learn_9interface_7cvfit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_X = 0; + PyObject *__pyx_v_y = 0; + PyObject *__pyx_v_loss = 0; + PyObject *__pyx_v_penalty = 0; + PyObject *__pyx_v_algorithm = 0; + PyObject *__pyx_v_num_folds = 0; + PyObject *__pyx_v_seed = 0; + PyObject *__pyx_v_max_support_size = 0; + PyObject *__pyx_v_num_lambda = 0; + PyObject *__pyx_v_num_gamma = 0; + double __pyx_v_gamma_max; + double __pyx_v_gamma_min; + PyObject *__pyx_v_partial_sort = 0; + PyObject *__pyx_v_max_iter = 0; + double __pyx_v_rtol; + double __pyx_v_atol; + PyObject *__pyx_v_active_set = 0; + PyObject *__pyx_v_active_set_num = 0; + PyObject *__pyx_v_max_swaps = 0; + double __pyx_v_scale_down_factor; + PyObject *__pyx_v_screen_size = 0; + PyObject *__pyx_v_lambda_grid = 0; + PyObject *__pyx_v_exclude_first_k = 0; + PyObject *__pyx_v_intercept = 0; + PyObject *__pyx_v_lows = 0; + PyObject *__pyx_v_highs = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("cvfit (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_X,&__pyx_n_s_y,&__pyx_n_s_loss,&__pyx_n_s_penalty,&__pyx_n_s_algorithm,&__pyx_n_s_num_folds,&__pyx_n_s_seed,&__pyx_n_s_max_support_size,&__pyx_n_s_num_lambda,&__pyx_n_s_num_gamma,&__pyx_n_s_gamma_max,&__pyx_n_s_gamma_min,&__pyx_n_s_partial_sort,&__pyx_n_s_max_iter,&__pyx_n_s_rtol,&__pyx_n_s_atol,&__pyx_n_s_active_set,&__pyx_n_s_active_set_num,&__pyx_n_s_max_swaps,&__pyx_n_s_scale_down_factor,&__pyx_n_s_screen_size,&__pyx_n_s_lambda_grid,&__pyx_n_s_exclude_first_k,&__pyx_n_s_intercept,&__pyx_n_s_lows,&__pyx_n_s_highs,0}; + PyObject* values[26] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + values[2] = ((PyObject*)__pyx_n_u_SquaredError); + values[3] = ((PyObject*)__pyx_n_u_L0); + values[4] = ((PyObject*)__pyx_n_u_CD); + values[5] = ((PyObject *)__pyx_int_10); + values[6] = ((PyObject *)__pyx_int_1); + values[7] = ((PyObject *)__pyx_int_100); + values[8] = ((PyObject *)__pyx_int_100); + values[9] = ((PyObject *)__pyx_int_1); + + /* "l0learn/interface.pyx":545 + * gamma_max: float = 10., + * gamma_min: float = .0001, + * partial_sort: bool = True, # <<<<<<<<<<<<<< + * max_iter: int = 200, + * rtol: float = 1e-6, */ - } + values[12] = ((PyObject *)Py_True); + values[13] = ((PyObject *)__pyx_int_200); - /* "l0learn/interface.pyx":521 - * f"but got {intercept}") - * - * if loss in CLASSIFICATION_LOSS: # <<<<<<<<<<<<<< - * unique_items = sorted(np.unique(y)) - * if 0 >= len(unique_items) > 2: + /* "l0learn/interface.pyx":549 + * rtol: float = 1e-6, + * atol: float = 1e-9, + * active_set: bool = True, # <<<<<<<<<<<<<< + * active_set_num: int = 3, + * max_swaps: int = 100, */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_CLASSIFICATION_LOSS); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 521, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_4 = (__Pyx_PySequence_ContainsTF(__pyx_v_loss, __pyx_t_7, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 521, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_5 = (__pyx_t_4 != 0); - if (__pyx_t_5) { + values[16] = ((PyObject *)Py_True); + values[17] = ((PyObject *)__pyx_int_3); + values[18] = ((PyObject *)__pyx_int_100); + values[20] = ((PyObject *)__pyx_int_1000); - /* "l0learn/interface.pyx":522 - * - * if loss in CLASSIFICATION_LOSS: - * unique_items = sorted(np.unique(y)) # <<<<<<<<<<<<<< - * if 0 >= len(unique_items) > 2: - * raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " + /* "l0learn/interface.pyx":554 + * scale_down_factor: float = 0.8, + * screen_size: int = 1000, + * lambda_grid: Optional[List[List[float]]] = None, # <<<<<<<<<<<<<< + * exclude_first_k: int = 0, + * intercept: bool = True, */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 522, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_unique); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 522, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_8); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_8, function); - } - } - __pyx_t_3 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_2, __pyx_v_y) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_y); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 522, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = PySequence_List(__pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 522, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_7 = ((PyObject*)__pyx_t_8); - __pyx_t_8 = 0; - __pyx_t_12 = PyList_Sort(__pyx_t_7); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 522, __pyx_L1_error) - __pyx_v_unique_items = ((PyObject*)__pyx_t_7); - __pyx_t_7 = 0; - - /* "l0learn/interface.pyx":523 - * if loss in CLASSIFICATION_LOSS: - * unique_items = sorted(np.unique(y)) - * if 0 >= len(unique_items) > 2: # <<<<<<<<<<<<<< - * raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " - * f"but got {unique_items}") - */ - if (unlikely(__pyx_v_unique_items == Py_None)) { - PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(0, 523, __pyx_L1_error) - } - __pyx_t_9 = PyList_GET_SIZE(__pyx_v_unique_items); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 523, __pyx_L1_error) - __pyx_t_5 = (0 >= __pyx_t_9); - if (__pyx_t_5) { - __pyx_t_5 = (__pyx_t_9 > 2); - } - __pyx_t_4 = (__pyx_t_5 != 0); - if (unlikely(__pyx_t_4)) { - - /* "l0learn/interface.pyx":525 - * if 0 >= len(unique_items) > 2: - * raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " - * f"but got {unique_items}") # <<<<<<<<<<<<<< - * else: - * a, *_ = unique_items # a is the lower value - */ - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_unique_items, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 525, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - - /* "l0learn/interface.pyx":524 - * unique_items = sorted(np.unique(y)) - * if 0 >= len(unique_items) > 2: - * raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " # <<<<<<<<<<<<<< - * f"but got {unique_items}") - * else: - */ - __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_y_vector_to_only_have_t, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 524, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 524, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_Raise(__pyx_t_7, 0, 0, 0); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 524, __pyx_L1_error) - - /* "l0learn/interface.pyx":523 - * if loss in CLASSIFICATION_LOSS: - * unique_items = sorted(np.unique(y)) - * if 0 >= len(unique_items) > 2: # <<<<<<<<<<<<<< - * raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " - * f"but got {unique_items}") - */ - } + values[21] = ((PyObject *)Py_None); + values[22] = ((PyObject *)__pyx_int_0); - /* "l0learn/interface.pyx":527 - * f"but got {unique_items}") - * else: - * a, *_ = unique_items # a is the lower value # <<<<<<<<<<<<<< - * y = np.copy(y) - * y[y==a] = -1 + /* "l0learn/interface.pyx":556 + * lambda_grid: Optional[List[List[float]]] = None, + * exclude_first_k: int = 0, + * intercept: bool = True, # <<<<<<<<<<<<<< + * lows: Union[np.ndarray, float] = -float('inf'), + * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.CVFitModel: */ - /*else*/ { - { - Py_ssize_t index = -1; - PyObject** temps[2] = {&__pyx_t_7}; - __pyx_t_8 = PyObject_GetIter(__pyx_v_unique_items); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 527, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_11 = Py_TYPE(__pyx_t_8)->tp_iternext; - for (index=0; index < 1; index++) { - PyObject* item = __pyx_t_11(__pyx_t_8); if (unlikely(!item)) goto __pyx_L56_unpacking_failed; - __Pyx_GOTREF(item); - *(temps[index]) = item; - } - goto __pyx_L57_unpacking_done; - __pyx_L56_unpacking_failed:; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_11 = NULL; - if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 527, __pyx_L1_error) - __pyx_L57_unpacking_done:; + values[23] = ((PyObject *)Py_True); + values[24] = __pyx_k__9; + values[25] = __pyx_k__10; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 26: values[25] = PyTuple_GET_ITEM(__pyx_args, 25); + CYTHON_FALLTHROUGH; + case 25: values[24] = PyTuple_GET_ITEM(__pyx_args, 24); + CYTHON_FALLTHROUGH; + case 24: values[23] = PyTuple_GET_ITEM(__pyx_args, 23); + CYTHON_FALLTHROUGH; + case 23: values[22] = PyTuple_GET_ITEM(__pyx_args, 22); + CYTHON_FALLTHROUGH; + case 22: values[21] = PyTuple_GET_ITEM(__pyx_args, 21); + CYTHON_FALLTHROUGH; + case 21: values[20] = PyTuple_GET_ITEM(__pyx_args, 20); + CYTHON_FALLTHROUGH; + case 20: values[19] = PyTuple_GET_ITEM(__pyx_args, 19); + CYTHON_FALLTHROUGH; + case 19: values[18] = PyTuple_GET_ITEM(__pyx_args, 18); + CYTHON_FALLTHROUGH; + case 18: values[17] = PyTuple_GET_ITEM(__pyx_args, 17); + CYTHON_FALLTHROUGH; + case 17: values[16] = PyTuple_GET_ITEM(__pyx_args, 16); + CYTHON_FALLTHROUGH; + case 16: values[15] = PyTuple_GET_ITEM(__pyx_args, 15); + CYTHON_FALLTHROUGH; + case 15: values[14] = PyTuple_GET_ITEM(__pyx_args, 14); + CYTHON_FALLTHROUGH; + case 14: values[13] = PyTuple_GET_ITEM(__pyx_args, 13); + CYTHON_FALLTHROUGH; + case 13: values[12] = PyTuple_GET_ITEM(__pyx_args, 12); + CYTHON_FALLTHROUGH; + case 12: values[11] = PyTuple_GET_ITEM(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; } - __pyx_t_3 = PySequence_List(__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 527, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_v_a = __pyx_t_7; - __pyx_t_7 = 0; - __pyx_v__ = ((PyObject*)__pyx_t_3); - __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":528 - * else: - * a, *_ = unique_items # a is the lower value - * y = np.copy(y) # <<<<<<<<<<<<<< - * y[y==a] = -1 - * y[y!=a] = 1 - */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 528, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_copy); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 528, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); - if (likely(__pyx_t_7)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); - __Pyx_INCREF(__pyx_t_7); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_8, function); + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_X)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("cvfit", 0, 2, 26, 1); __PYX_ERR(0, 533, __pyx_L3_error) } - } - __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_7, __pyx_v_y) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_y); - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 528, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF_SET(__pyx_v_y, __pyx_t_3); - __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":529 - * a, *_ = unique_items # a is the lower value - * y = np.copy(y) - * y[y==a] = -1 # <<<<<<<<<<<<<< - * y[y!=a] = 1 - * - */ - __pyx_t_3 = PyObject_RichCompare(__pyx_v_y, __pyx_v_a, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 529, __pyx_L1_error) - if (unlikely(PyObject_SetItem(__pyx_v_y, __pyx_t_3, __pyx_int_neg_1) < 0)) __PYX_ERR(0, 529, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":530 - * y = np.copy(y) - * y[y==a] = -1 - * y[y!=a] = 1 # <<<<<<<<<<<<<< - * - * if penalty == "L0": - */ - __pyx_t_3 = PyObject_RichCompare(__pyx_v_y, __pyx_v_a, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 530, __pyx_L1_error) - if (unlikely(PyObject_SetItem(__pyx_v_y, __pyx_t_3, __pyx_int_1) < 0)) __PYX_ERR(0, 530, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } - - /* "l0learn/interface.pyx":532 - * y[y!=a] = 1 - * - * if penalty == "L0": # <<<<<<<<<<<<<< - * # Pure L0 is not supported for classification - * # Below we add a small L2 component. - */ - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 532, __pyx_L1_error) - __pyx_t_5 = (__pyx_t_4 != 0); - if (__pyx_t_5) { - - /* "l0learn/interface.pyx":536 - * # Below we add a small L2 component. - * - * if lambda_grid is not None and len(lambda_grid) != 1: # <<<<<<<<<<<<<< - * # If this error checking was left to the lower section, it would confuse users as - * # we are converting L0 to L0L2 with small L2 penalty. - */ - __pyx_t_4 = (__pyx_v_lambda_grid != Py_None); - __pyx_t_1 = (__pyx_t_4 != 0); - if (__pyx_t_1) { - } else { - __pyx_t_5 = __pyx_t_1; - goto __pyx_L60_bool_binop_done; - } - __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 536, __pyx_L1_error) - __pyx_t_1 = ((__pyx_t_9 != 1) != 0); - __pyx_t_5 = __pyx_t_1; - __pyx_L60_bool_binop_done:; - if (unlikely(__pyx_t_5)) { - - /* "l0learn/interface.pyx":541 - * # Here we must check if lambdaGrid is supplied (And thus use 'autolambda') - * # If 'lambdaGrid' is supplied, we must only supply 1 list of lambda values - * raise ValueError(f"L0 Penalty requires 'lambda_grid' to be a list of length 1, but got {lambda_grid}.") # <<<<<<<<<<<<<< - * - * penalty = "L0L2" - */ - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 541, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_9 = 0; - __pyx_t_10 = 127; - __Pyx_INCREF(__pyx_kp_u_L0_Penalty_requires_lambda_grid); - __pyx_t_9 += 68; - __Pyx_GIVEREF(__pyx_kp_u_L0_Penalty_requires_lambda_grid); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_L0_Penalty_requires_lambda_grid); - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 541, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); - __Pyx_GIVEREF(__pyx_t_8); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_8); - __pyx_t_8 = 0; - __Pyx_INCREF(__pyx_kp_u__5); - __pyx_t_9 += 1; - __Pyx_GIVEREF(__pyx_kp_u__5); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u__5); - __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 541, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 541, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 541, __pyx_L1_error) - - /* "l0learn/interface.pyx":536 - * # Below we add a small L2 component. - * - * if lambda_grid is not None and len(lambda_grid) != 1: # <<<<<<<<<<<<<< - * # If this error checking was left to the lower section, it would confuse users as - * # we are converting L0 to L0L2 with small L2 penalty. - */ - } - - /* "l0learn/interface.pyx":532 - * y[y!=a] = 1 - * - * if penalty == "L0": # <<<<<<<<<<<<<< - * # Pure L0 is not supported for classification - * # Below we add a small L2 component. - */ - } - - /* "l0learn/interface.pyx":543 - * raise ValueError(f"L0 Penalty requires 'lambda_grid' to be a list of length 1, but got {lambda_grid}.") - * - * penalty = "L0L2" # <<<<<<<<<<<<<< - * gamma_max = 1e-7 - * gamma_min = 1e-7 - */ - __Pyx_INCREF(__pyx_n_u_L0L2); - __Pyx_DECREF_SET(__pyx_v_penalty, __pyx_n_u_L0L2); - - /* "l0learn/interface.pyx":544 - * - * penalty = "L0L2" - * gamma_max = 1e-7 # <<<<<<<<<<<<<< - * gamma_min = 1e-7 - * elif penalty != "L0" and num_gamma == 1: - */ - __pyx_v_gamma_max = 1e-7; - - /* "l0learn/interface.pyx":545 - * penalty = "L0L2" - * gamma_max = 1e-7 - * gamma_min = 1e-7 # <<<<<<<<<<<<<< - * elif penalty != "L0" and num_gamma == 1: - * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") - */ - __pyx_v_gamma_min = 1e-7; - - /* "l0learn/interface.pyx":521 - * f"but got {intercept}") - * - * if loss in CLASSIFICATION_LOSS: # <<<<<<<<<<<<<< - * unique_items = sorted(np.unique(y)) - * if 0 >= len(unique_items) > 2: - */ - goto __pyx_L54; - } - - /* "l0learn/interface.pyx":546 - * gamma_max = 1e-7 - * gamma_min = 1e-7 - * elif penalty != "L0" and num_gamma == 1: # <<<<<<<<<<<<<< - * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") - * - */ - __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 546, __pyx_L1_error) - __pyx_t_4 = (__pyx_t_1 != 0); - if (__pyx_t_4) { - } else { - __pyx_t_5 = __pyx_t_4; - goto __pyx_L62_bool_binop_done; - } - __pyx_t_3 = __Pyx_PyInt_EqObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 546, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 546, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_5 = __pyx_t_4; - __pyx_L62_bool_binop_done:; - if (__pyx_t_5) { - - /* "l0learn/interface.pyx":547 - * gamma_min = 1e-7 - * elif penalty != "L0" and num_gamma == 1: - * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") # <<<<<<<<<<<<<< - * - * if lambda_grid is None: - */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_warn); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 547, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = PyTuple_New(5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 547, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_9 = 0; - __pyx_t_10 = 127; - __Pyx_INCREF(__pyx_kp_u_num_gamma_set_to_1_with); - __pyx_t_9 += 24; - __Pyx_GIVEREF(__pyx_kp_u_num_gamma_set_to_1_with); - PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_num_gamma_set_to_1_with); - __pyx_t_2 = __Pyx_PyUnicode_Unicode(__pyx_v_penalty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 547, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_2); - __pyx_t_2 = 0; - __Pyx_INCREF(__pyx_kp_u_penalty_Only_one); - __pyx_t_9 += 19; - __Pyx_GIVEREF(__pyx_kp_u_penalty_Only_one); - PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_penalty_Only_one); - if (unlikely(__pyx_v_penalty == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(0, 547, __pyx_L1_error) - } - __pyx_t_2 = __Pyx_PyUnicode_Substring(__pyx_v_penalty, 2, PY_SSIZE_T_MAX); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 547, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_2); - __pyx_t_2 = 0; - __Pyx_INCREF(__pyx_kp_u_penalty_value_will_be_fit); - __pyx_t_9 += 27; - __Pyx_GIVEREF(__pyx_kp_u_penalty_value_will_be_fit); - PyTuple_SET_ITEM(__pyx_t_7, 4, __pyx_kp_u_penalty_value_will_be_fit); - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_7, 5, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 547, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); - if (likely(__pyx_t_7)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); - __Pyx_INCREF(__pyx_t_7); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_8, function); - } - } - __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_7, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_2); - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 547, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":546 - * gamma_max = 1e-7 - * gamma_min = 1e-7 - * elif penalty != "L0" and num_gamma == 1: # <<<<<<<<<<<<<< - * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") - * - */ - } - __pyx_L54:; - - /* "l0learn/interface.pyx":549 - * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") - * - * if lambda_grid is None: # <<<<<<<<<<<<<< - * lambda_grid = [[0.]] - * auto_lambda = True - */ - __pyx_t_5 = (__pyx_v_lambda_grid == Py_None); - __pyx_t_4 = (__pyx_t_5 != 0); - if (__pyx_t_4) { - - /* "l0learn/interface.pyx":550 - * - * if lambda_grid is None: - * lambda_grid = [[0.]] # <<<<<<<<<<<<<< - * auto_lambda = True - * if not isinstance(num_lambda, int) or num_lambda < 1: - */ - __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 550, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(__pyx_float_0_); - __Pyx_GIVEREF(__pyx_float_0_); - PyList_SET_ITEM(__pyx_t_3, 0, __pyx_float_0_); - __pyx_t_8 = PyList_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 550, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_GIVEREF(__pyx_t_3); - PyList_SET_ITEM(__pyx_t_8, 0, __pyx_t_3); - __pyx_t_3 = 0; - __Pyx_DECREF_SET(__pyx_v_lambda_grid, __pyx_t_8); - __pyx_t_8 = 0; - - /* "l0learn/interface.pyx":551 - * if lambda_grid is None: - * lambda_grid = [[0.]] - * auto_lambda = True # <<<<<<<<<<<<<< - * if not isinstance(num_lambda, int) or num_lambda < 1: - * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") - */ - __pyx_v_auto_lambda = 1; - - /* "l0learn/interface.pyx":552 - * lambda_grid = [[0.]] - * auto_lambda = True - * if not isinstance(num_lambda, int) or num_lambda < 1: # <<<<<<<<<<<<<< - * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") - * if not isinstance(num_gamma, int) or num_gamma < 1: - */ - __pyx_t_5 = PyInt_Check(__pyx_v_num_lambda); - __pyx_t_1 = ((!(__pyx_t_5 != 0)) != 0); - if (!__pyx_t_1) { - } else { - __pyx_t_4 = __pyx_t_1; - goto __pyx_L66_bool_binop_done; - } - __pyx_t_8 = PyObject_RichCompare(__pyx_v_num_lambda, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 552, __pyx_L1_error) - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 552, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_4 = __pyx_t_1; - __pyx_L66_bool_binop_done:; - if (unlikely(__pyx_t_4)) { - - /* "l0learn/interface.pyx":553 - * auto_lambda = True - * if not isinstance(num_lambda, int) or num_lambda < 1: - * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") # <<<<<<<<<<<<<< - * if not isinstance(num_gamma, int) or num_gamma < 1: - * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") - */ - __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 553, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_9 = 0; - __pyx_t_10 = 127; - __Pyx_INCREF(__pyx_kp_u_expected_num_lambda_to_a_positiv); - __pyx_t_9 += 76; - __Pyx_GIVEREF(__pyx_kp_u_expected_num_lambda_to_a_positiv); - PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_u_expected_num_lambda_to_a_positiv); - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 553, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_3); - __pyx_t_3 = 0; - __Pyx_INCREF(__pyx_kp_u__5); - __pyx_t_9 += 1; - __Pyx_GIVEREF(__pyx_kp_u__5); - PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__5); - __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 553, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 553, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 553, __pyx_L1_error) - - /* "l0learn/interface.pyx":552 - * lambda_grid = [[0.]] - * auto_lambda = True - * if not isinstance(num_lambda, int) or num_lambda < 1: # <<<<<<<<<<<<<< - * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") - * if not isinstance(num_gamma, int) or num_gamma < 1: - */ - } - - /* "l0learn/interface.pyx":554 - * if not isinstance(num_lambda, int) or num_lambda < 1: - * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") - * if not isinstance(num_gamma, int) or num_gamma < 1: # <<<<<<<<<<<<<< - * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") - * if penalty == "L0" and num_gamma != 1: - */ - __pyx_t_1 = PyInt_Check(__pyx_v_num_gamma); - __pyx_t_5 = ((!(__pyx_t_1 != 0)) != 0); - if (!__pyx_t_5) { - } else { - __pyx_t_4 = __pyx_t_5; - goto __pyx_L69_bool_binop_done; - } - __pyx_t_8 = PyObject_RichCompare(__pyx_v_num_gamma, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 554, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 554, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_4 = __pyx_t_5; - __pyx_L69_bool_binop_done:; - if (unlikely(__pyx_t_4)) { - - /* "l0learn/interface.pyx":555 - * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") - * if not isinstance(num_gamma, int) or num_gamma < 1: - * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") # <<<<<<<<<<<<<< - * if penalty == "L0" and num_gamma != 1: - * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") - */ - __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 555, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_9 = 0; - __pyx_t_10 = 127; - __Pyx_INCREF(__pyx_kp_u_expected_num_gamma_to_a_positive); - __pyx_t_9 += 75; - __Pyx_GIVEREF(__pyx_kp_u_expected_num_gamma_to_a_positive); - PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_u_expected_num_gamma_to_a_positive); - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 555, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_3); - __pyx_t_3 = 0; - __Pyx_INCREF(__pyx_kp_u__5); - __pyx_t_9 += 1; - __Pyx_GIVEREF(__pyx_kp_u__5); - PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__5); - __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 555, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 555, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 555, __pyx_L1_error) - - /* "l0learn/interface.pyx":554 - * if not isinstance(num_lambda, int) or num_lambda < 1: - * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") - * if not isinstance(num_gamma, int) or num_gamma < 1: # <<<<<<<<<<<<<< - * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") - * if penalty == "L0" and num_gamma != 1: - */ - } - - /* "l0learn/interface.pyx":556 - * if not isinstance(num_gamma, int) or num_gamma < 1: - * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") - * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< - * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") - * else: # lambda_grid should be a List[List[float]] - */ - __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 556, __pyx_L1_error) - __pyx_t_1 = (__pyx_t_5 != 0); - if (__pyx_t_1) { - } else { - __pyx_t_4 = __pyx_t_1; - goto __pyx_L72_bool_binop_done; - } - __pyx_t_8 = __Pyx_PyInt_NeObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 556, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 556, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_4 = __pyx_t_1; - __pyx_L72_bool_binop_done:; - if (unlikely(__pyx_t_4)) { - - /* "l0learn/interface.pyx":557 - * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") - * if penalty == "L0" and num_gamma != 1: - * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") # <<<<<<<<<<<<<< - * else: # lambda_grid should be a List[List[float]] - * if num_gamma is not None: - */ - __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 557, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_9 = 0; - __pyx_t_10 = 127; - __Pyx_INCREF(__pyx_kp_u_expected_num_gamma_to_1_when_pen); - __pyx_t_9 += 53; - __Pyx_GIVEREF(__pyx_kp_u_expected_num_gamma_to_1_when_pen); - PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_u_expected_num_gamma_to_1_when_pen); - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 557, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_3); - __pyx_t_3 = 0; - __Pyx_INCREF(__pyx_kp_u__5); - __pyx_t_9 += 1; - __Pyx_GIVEREF(__pyx_kp_u__5); - PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__5); - __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 557, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 557, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 557, __pyx_L1_error) - - /* "l0learn/interface.pyx":556 - * if not isinstance(num_gamma, int) or num_gamma < 1: - * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") - * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< - * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") - * else: # lambda_grid should be a List[List[float]] - */ - } - - /* "l0learn/interface.pyx":549 - * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") - * - * if lambda_grid is None: # <<<<<<<<<<<<<< - * lambda_grid = [[0.]] - * auto_lambda = True - */ - goto __pyx_L64; - } - - /* "l0learn/interface.pyx":559 - * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") - * else: # lambda_grid should be a List[List[float]] - * if num_gamma is not None: # <<<<<<<<<<<<<< - * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " - * f"but got {num_gamma}") - */ - /*else*/ { - __pyx_t_4 = (__pyx_v_num_gamma != Py_None); - __pyx_t_1 = (__pyx_t_4 != 0); - if (unlikely(__pyx_t_1)) { - - /* "l0learn/interface.pyx":561 - * if num_gamma is not None: - * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " - * f"but got {num_gamma}") # <<<<<<<<<<<<<< - * num_gamma = len(lambda_grid) - * - */ - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 561, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - - /* "l0learn/interface.pyx":560 - * else: # lambda_grid should be a List[List[float]] - * if num_gamma is not None: - * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " # <<<<<<<<<<<<<< - * f"but got {num_gamma}") - * num_gamma = len(lambda_grid) - */ - __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_gamma_to_be_None_if, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 560, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 560, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 560, __pyx_L1_error) - - /* "l0learn/interface.pyx":559 - * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") - * else: # lambda_grid should be a List[List[float]] - * if num_gamma is not None: # <<<<<<<<<<<<<< - * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " - * f"but got {num_gamma}") - */ - } - - /* "l0learn/interface.pyx":562 - * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " - * f"but got {num_gamma}") - * num_gamma = len(lambda_grid) # <<<<<<<<<<<<<< - * - * if num_lambda is not None: - */ - __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 562, __pyx_L1_error) - __pyx_t_8 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 562, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF_SET(__pyx_v_num_gamma, __pyx_t_8); - __pyx_t_8 = 0; - - /* "l0learn/interface.pyx":564 - * num_gamma = len(lambda_grid) - * - * if num_lambda is not None: # <<<<<<<<<<<<<< - * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " - * f"but got {num_lambda}") - */ - __pyx_t_1 = (__pyx_v_num_lambda != Py_None); - __pyx_t_4 = (__pyx_t_1 != 0); - if (unlikely(__pyx_t_4)) { - - /* "l0learn/interface.pyx":566 - * if num_lambda is not None: - * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " - * f"but got {num_lambda}") # <<<<<<<<<<<<<< - * num_lambda = 0 # This value is ignored. - * auto_lambda = False - */ - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 566, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - - /* "l0learn/interface.pyx":565 - * - * if num_lambda is not None: - * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " # <<<<<<<<<<<<<< - * f"but got {num_lambda}") - * num_lambda = 0 # This value is ignored. - */ - __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_lambda_to_be_None_i, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 565, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 565, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 565, __pyx_L1_error) - - /* "l0learn/interface.pyx":564 - * num_gamma = len(lambda_grid) - * - * if num_lambda is not None: # <<<<<<<<<<<<<< - * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " - * f"but got {num_lambda}") - */ - } - - /* "l0learn/interface.pyx":567 - * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " - * f"but got {num_lambda}") - * num_lambda = 0 # This value is ignored. # <<<<<<<<<<<<<< - * auto_lambda = False - * bad_lambda_grid = False - */ - __Pyx_INCREF(__pyx_int_0); - __Pyx_DECREF_SET(__pyx_v_num_lambda, __pyx_int_0); - - /* "l0learn/interface.pyx":568 - * f"but got {num_lambda}") - * num_lambda = 0 # This value is ignored. - * auto_lambda = False # <<<<<<<<<<<<<< - * bad_lambda_grid = False - * - */ - __pyx_v_auto_lambda = 0; - - /* "l0learn/interface.pyx":569 - * num_lambda = 0 # This value is ignored. - * auto_lambda = False - * bad_lambda_grid = False # <<<<<<<<<<<<<< - * - * if penalty == "L0" and num_gamma != 1: - */ - __pyx_v_bad_lambda_grid = 0; - - /* "l0learn/interface.pyx":571 - * bad_lambda_grid = False - * - * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< - * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") - * - */ - __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 571, __pyx_L1_error) - __pyx_t_5 = (__pyx_t_1 != 0); - if (__pyx_t_5) { - } else { - __pyx_t_4 = __pyx_t_5; - goto __pyx_L77_bool_binop_done; - } - __pyx_t_8 = __Pyx_PyInt_NeObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 571, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 571, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_4 = __pyx_t_5; - __pyx_L77_bool_binop_done:; - if (unlikely(__pyx_t_4)) { - - /* "l0learn/interface.pyx":572 - * - * if penalty == "L0" and num_gamma != 1: - * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") # <<<<<<<<<<<<<< - * - * for i, sub_lambda_grid in enumerate(lambda_grid): - */ - __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 572, __pyx_L1_error) - __pyx_t_8 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_9, 0, ' ', 'd'); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 572, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_of_lengt, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 572, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 572, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 572, __pyx_L1_error) - - /* "l0learn/interface.pyx":571 - * bad_lambda_grid = False - * - * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< - * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") - * - */ - } - - /* "l0learn/interface.pyx":574 - * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") - * - * for i, sub_lambda_grid in enumerate(lambda_grid): # <<<<<<<<<<<<<< - * current = float("inf") - * if sub_lambda_grid[0] <= 0: - */ - __Pyx_INCREF(__pyx_int_0); - __pyx_t_8 = __pyx_int_0; - if (likely(PyList_CheckExact(__pyx_v_lambda_grid)) || PyTuple_CheckExact(__pyx_v_lambda_grid)) { - __pyx_t_3 = __pyx_v_lambda_grid; __Pyx_INCREF(__pyx_t_3); __pyx_t_9 = 0; - __pyx_t_13 = NULL; - } else { - __pyx_t_9 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_lambda_grid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 574, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_13 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 574, __pyx_L1_error) - } - for (;;) { - if (likely(!__pyx_t_13)) { - if (likely(PyList_CheckExact(__pyx_t_3))) { - if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_3)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_2 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_9); __Pyx_INCREF(__pyx_t_2); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 574, __pyx_L1_error) - #else - __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 574, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - #endif - } else { - if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_3)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_9); __Pyx_INCREF(__pyx_t_2); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 574, __pyx_L1_error) - #else - __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 574, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - #endif + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_loss); + if (value) { values[2] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_penalty); + if (value) { values[3] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_algorithm); + if (value) { values[4] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_num_folds); + if (value) { values[5] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_seed); + if (value) { values[6] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 7: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_support_size); + if (value) { values[7] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 8: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_num_lambda); + if (value) { values[8] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 9: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_num_gamma); + if (value) { values[9] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 10: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_gamma_max); + if (value) { values[10] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 11: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_gamma_min); + if (value) { values[11] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 12: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_partial_sort); + if (value) { values[12] = value; kw_args--; } } - } else { - __pyx_t_2 = __pyx_t_13(__pyx_t_3); - if (unlikely(!__pyx_t_2)) { - PyObject* exc_type = PyErr_Occurred(); - if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(0, 574, __pyx_L1_error) - } - break; + CYTHON_FALLTHROUGH; + case 13: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_iter); + if (value) { values[13] = value; kw_args--; } } - __Pyx_GOTREF(__pyx_t_2); - } - __Pyx_XDECREF_SET(__pyx_v_sub_lambda_grid, __pyx_t_2); - __pyx_t_2 = 0; - __Pyx_INCREF(__pyx_t_8); - __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_8); - __pyx_t_2 = __Pyx_PyInt_AddObjC(__pyx_t_8, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 574, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_8); - __pyx_t_8 = __pyx_t_2; - __pyx_t_2 = 0; - - /* "l0learn/interface.pyx":575 - * - * for i, sub_lambda_grid in enumerate(lambda_grid): - * current = float("inf") # <<<<<<<<<<<<<< - * if sub_lambda_grid[0] <= 0: - * raise ValueError(f"Expected all values of lambda_grid to be positive, " - */ - __pyx_t_14 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 575, __pyx_L1_error) - __pyx_v_current = __pyx_t_14; - - /* "l0learn/interface.pyx":576 - * for i, sub_lambda_grid in enumerate(lambda_grid): - * current = float("inf") - * if sub_lambda_grid[0] <= 0: # <<<<<<<<<<<<<< - * raise ValueError(f"Expected all values of lambda_grid to be positive, " - * f"but got lambda_grid[{i}] containing a negative value") - */ - __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_sub_lambda_grid, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 576, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = PyObject_RichCompare(__pyx_t_2, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 576, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 576, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(__pyx_t_4)) { - - /* "l0learn/interface.pyx":577 - * current = float("inf") - * if sub_lambda_grid[0] <= 0: - * raise ValueError(f"Expected all values of lambda_grid to be positive, " # <<<<<<<<<<<<<< - * f"but got lambda_grid[{i}] containing a negative value") - * if any(np.diff(sub_lambda_grid) >= 0): - */ - __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 577, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_15 = 0; - __pyx_t_10 = 127; - __Pyx_INCREF(__pyx_kp_u_Expected_all_values_of_lambda_gr); - __pyx_t_15 += 71; - __Pyx_GIVEREF(__pyx_kp_u_Expected_all_values_of_lambda_gr); - PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_Expected_all_values_of_lambda_gr); - - /* "l0learn/interface.pyx":578 - * if sub_lambda_grid[0] <= 0: - * raise ValueError(f"Expected all values of lambda_grid to be positive, " - * f"but got lambda_grid[{i}] containing a negative value") # <<<<<<<<<<<<<< - * if any(np.diff(sub_lambda_grid) >= 0): - * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " - */ - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 578, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_15 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_2); - __pyx_t_2 = 0; - __Pyx_INCREF(__pyx_kp_u_containing_a_negative_value); - __pyx_t_15 += 29; - __Pyx_GIVEREF(__pyx_kp_u_containing_a_negative_value); - PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_containing_a_negative_value); - - /* "l0learn/interface.pyx":577 - * current = float("inf") - * if sub_lambda_grid[0] <= 0: - * raise ValueError(f"Expected all values of lambda_grid to be positive, " # <<<<<<<<<<<<<< - * f"but got lambda_grid[{i}] containing a negative value") - * if any(np.diff(sub_lambda_grid) >= 0): - */ - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 577, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 577, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_7, 0, 0, 0); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 577, __pyx_L1_error) - - /* "l0learn/interface.pyx":576 - * for i, sub_lambda_grid in enumerate(lambda_grid): - * current = float("inf") - * if sub_lambda_grid[0] <= 0: # <<<<<<<<<<<<<< - * raise ValueError(f"Expected all values of lambda_grid to be positive, " - * f"but got lambda_grid[{i}] containing a negative value") - */ - } - - /* "l0learn/interface.pyx":579 - * raise ValueError(f"Expected all values of lambda_grid to be positive, " - * f"but got lambda_grid[{i}] containing a negative value") - * if any(np.diff(sub_lambda_grid) >= 0): # <<<<<<<<<<<<<< - * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " - * f"but got lambda_grid[{i}] containing an increasing value.") - */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 579, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_diff); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 579, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_16))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_16); - if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_16); - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_16, function); + CYTHON_FALLTHROUGH; + case 14: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rtol); + if (value) { values[14] = value; kw_args--; } } - } - __pyx_t_7 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_16, __pyx_t_2, __pyx_v_sub_lambda_grid) : __Pyx_PyObject_CallOneArg(__pyx_t_16, __pyx_v_sub_lambda_grid); - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 579, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_16 = PyObject_RichCompare(__pyx_t_7, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_16); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 579, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_16); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 579, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 579, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(__pyx_t_4)) { - - /* "l0learn/interface.pyx":580 - * f"but got lambda_grid[{i}] containing a negative value") - * if any(np.diff(sub_lambda_grid) >= 0): - * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " # <<<<<<<<<<<<<< - * f"but got lambda_grid[{i}] containing an increasing value.") - * - */ - __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 580, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_15 = 0; - __pyx_t_10 = 127; - __Pyx_INCREF(__pyx_kp_u_Expected_each_element_of_lambda); - __pyx_t_15 += 91; - __Pyx_GIVEREF(__pyx_kp_u_Expected_each_element_of_lambda); - PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_Expected_each_element_of_lambda); - - /* "l0learn/interface.pyx":581 - * if any(np.diff(sub_lambda_grid) >= 0): - * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " - * f"but got lambda_grid[{i}] containing an increasing value.") # <<<<<<<<<<<<<< - * - * n, p = X.shape - */ - __pyx_t_16 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 581, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_16); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_16) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_16) : __pyx_t_10; - __pyx_t_15 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_16); - __Pyx_GIVEREF(__pyx_t_16); - PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_16); - __pyx_t_16 = 0; - __Pyx_INCREF(__pyx_kp_u_containing_an_increasing_value); - __pyx_t_15 += 33; - __Pyx_GIVEREF(__pyx_kp_u_containing_an_increasing_value); - PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_containing_an_increasing_value); - - /* "l0learn/interface.pyx":580 - * f"but got lambda_grid[{i}] containing a negative value") - * if any(np.diff(sub_lambda_grid) >= 0): - * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " # <<<<<<<<<<<<<< - * f"but got lambda_grid[{i}] containing an increasing value.") - * - */ - __pyx_t_16 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 580, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_16); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 580, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __Pyx_Raise(__pyx_t_7, 0, 0, 0); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 580, __pyx_L1_error) - - /* "l0learn/interface.pyx":579 - * raise ValueError(f"Expected all values of lambda_grid to be positive, " - * f"but got lambda_grid[{i}] containing a negative value") - * if any(np.diff(sub_lambda_grid) >= 0): # <<<<<<<<<<<<<< - * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " - * f"but got lambda_grid[{i}] containing an increasing value.") - */ - } - - /* "l0learn/interface.pyx":574 - * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") - * - * for i, sub_lambda_grid in enumerate(lambda_grid): # <<<<<<<<<<<<<< - * current = float("inf") - * if sub_lambda_grid[0] <= 0: - */ - } - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - } - __pyx_L64:; - - /* "l0learn/interface.pyx":583 - * f"but got lambda_grid[{i}] containing an increasing value.") - * - * n, p = X.shape # <<<<<<<<<<<<<< - * with_bounds = False - * - */ - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 583, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - if ((likely(PyTuple_CheckExact(__pyx_t_8))) || (PyList_CheckExact(__pyx_t_8))) { - PyObject* sequence = __pyx_t_8; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 583, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_7 = PyTuple_GET_ITEM(sequence, 1); + CYTHON_FALLTHROUGH; + case 15: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_atol); + if (value) { values[15] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 16: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_active_set); + if (value) { values[16] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 17: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_active_set_num); + if (value) { values[17] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 18: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_swaps); + if (value) { values[18] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 19: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_scale_down_factor); + if (value) { values[19] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 20: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_screen_size); + if (value) { values[20] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 21: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_lambda_grid); + if (value) { values[21] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 22: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_exclude_first_k); + if (value) { values[22] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 23: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_intercept); + if (value) { values[23] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 24: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_lows); + if (value) { values[24] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 25: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_highs); + if (value) { values[25] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "cvfit") < 0)) __PYX_ERR(0, 533, __pyx_L3_error) + } } else { - __pyx_t_3 = PyList_GET_ITEM(sequence, 0); - __pyx_t_7 = PyList_GET_ITEM(sequence, 1); - } - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(__pyx_t_7); - #else - __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 583, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 583, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - #endif - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - } else { - Py_ssize_t index = -1; - __pyx_t_16 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 583, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_11 = Py_TYPE(__pyx_t_16)->tp_iternext; - index = 0; __pyx_t_3 = __pyx_t_11(__pyx_t_16); if (unlikely(!__pyx_t_3)) goto __pyx_L83_unpacking_failed; - __Pyx_GOTREF(__pyx_t_3); - index = 1; __pyx_t_7 = __pyx_t_11(__pyx_t_16); if (unlikely(!__pyx_t_7)) goto __pyx_L83_unpacking_failed; - __Pyx_GOTREF(__pyx_t_7); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_16), 2) < 0) __PYX_ERR(0, 583, __pyx_L1_error) - __pyx_t_11 = NULL; - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - goto __pyx_L84_unpacking_done; - __pyx_L83_unpacking_failed:; - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_11 = NULL; - if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 583, __pyx_L1_error) - __pyx_L84_unpacking_done:; - } - __Pyx_DECREF_SET(__pyx_v_n, __pyx_t_3); - __pyx_t_3 = 0; - __Pyx_DECREF_SET(__pyx_v_p, __pyx_t_7); - __pyx_t_7 = 0; - - /* "l0learn/interface.pyx":584 - * - * n, p = X.shape - * with_bounds = False # <<<<<<<<<<<<<< - * - * if isinstance(lows, float): - */ - __pyx_v_with_bounds = 0; - - /* "l0learn/interface.pyx":586 - * with_bounds = False - * - * if isinstance(lows, float): # <<<<<<<<<<<<<< - * if lows > 0: - * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") - */ - __pyx_t_4 = PyFloat_Check(__pyx_v_lows); - __pyx_t_5 = (__pyx_t_4 != 0); - if (__pyx_t_5) { - - /* "l0learn/interface.pyx":587 - * - * if isinstance(lows, float): - * if lows > 0: # <<<<<<<<<<<<<< - * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") - * elif lows > -float('inf'): - */ - __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_GT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 587, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 587, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(__pyx_t_5)) { - - /* "l0learn/interface.pyx":588 - * if isinstance(lows, float): - * if lows > 0: - * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") # <<<<<<<<<<<<<< - * elif lows > -float('inf'): - * with_bounds = True - */ - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 588, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lows_to_be_a_non_positi, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 588, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 588, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 588, __pyx_L1_error) - - /* "l0learn/interface.pyx":587 - * - * if isinstance(lows, float): - * if lows > 0: # <<<<<<<<<<<<<< - * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") - * elif lows > -float('inf'): - */ - } - - /* "l0learn/interface.pyx":589 - * if lows > 0: - * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") - * elif lows > -float('inf'): # <<<<<<<<<<<<<< - * with_bounds = True - * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): - */ - __pyx_t_14 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 589, __pyx_L1_error) - __pyx_t_8 = PyFloat_FromDouble((-__pyx_t_14)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 589, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = PyObject_RichCompare(__pyx_v_lows, __pyx_t_8, Py_GT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 589, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 589, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (__pyx_t_5) { - - /* "l0learn/interface.pyx":590 - * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") - * elif lows > -float('inf'): - * with_bounds = True # <<<<<<<<<<<<<< - * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): - * with_bounds = True - */ - __pyx_v_with_bounds = 1; - - /* "l0learn/interface.pyx":589 - * if lows > 0: - * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") - * elif lows > -float('inf'): # <<<<<<<<<<<<<< - * with_bounds = True - * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): - */ - } - - /* "l0learn/interface.pyx":586 - * with_bounds = False - * - * if isinstance(lows, float): # <<<<<<<<<<<<<< - * if lows > 0: - * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") - */ - goto __pyx_L85; - } - - /* "l0learn/interface.pyx":591 - * elif lows > -float('inf'): - * with_bounds = True - * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): # <<<<<<<<<<<<<< - * with_bounds = True - * else: - */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 591, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 591, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = PyObject_IsInstance(__pyx_v_lows, __pyx_t_8); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 591, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_1 = (__pyx_t_4 != 0); - if (__pyx_t_1) { - } else { - __pyx_t_5 = __pyx_t_1; - goto __pyx_L87_bool_binop_done; - } - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_lows, __pyx_n_s_ndim); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 591, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = __Pyx_PyInt_EqObjC(__pyx_t_8, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 591, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 591, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (__pyx_t_1) { - } else { - __pyx_t_5 = __pyx_t_1; - goto __pyx_L87_bool_binop_done; - } - __pyx_t_9 = PyObject_Length(__pyx_v_lows); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 591, __pyx_L1_error) - __pyx_t_7 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 591, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = PyObject_RichCompare(__pyx_t_7, __pyx_v_p, Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 591, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 591, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (__pyx_t_1) { - } else { - __pyx_t_5 = __pyx_t_1; - goto __pyx_L87_bool_binop_done; - } - __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 591, __pyx_L1_error) - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_all, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 591, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 591, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_5 = __pyx_t_1; - __pyx_L87_bool_binop_done:; - if (likely(__pyx_t_5)) { - - /* "l0learn/interface.pyx":592 - * with_bounds = True - * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): - * with_bounds = True # <<<<<<<<<<<<<< - * else: - * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " - */ - __pyx_v_with_bounds = 1; - - /* "l0learn/interface.pyx":591 - * elif lows > -float('inf'): - * with_bounds = True - * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): # <<<<<<<<<<<<<< - * with_bounds = True - * else: - */ - goto __pyx_L85; - } - - /* "l0learn/interface.pyx":594 - * with_bounds = True - * else: - * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " # <<<<<<<<<<<<<< - * f"floats, but got {lows}") - * - */ - /*else*/ { - __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 594, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_9 = 0; - __pyx_t_10 = 127; - __Pyx_INCREF(__pyx_kp_u_expected_lows_to_be_a_non_positi_2); - __pyx_t_9 += 72; - __Pyx_GIVEREF(__pyx_kp_u_expected_lows_to_be_a_non_positi_2); - PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_lows_to_be_a_non_positi_2); - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 594, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); - __Pyx_GIVEREF(__pyx_t_8); - PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_8); - __pyx_t_8 = 0; - __Pyx_INCREF(__pyx_kp_u_of_non_positives_floats_but_got); - __pyx_t_9 += 34; - __Pyx_GIVEREF(__pyx_kp_u_of_non_positives_floats_but_got); - PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_of_non_positives_floats_but_got); - - /* "l0learn/interface.pyx":595 - * else: - * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " - * f"floats, but got {lows}") # <<<<<<<<<<<<<< - * - * if isinstance(highs, float): - */ - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 595, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); - __Pyx_GIVEREF(__pyx_t_8); - PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_8); - __pyx_t_8 = 0; - - /* "l0learn/interface.pyx":594 - * with_bounds = True - * else: - * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " # <<<<<<<<<<<<<< - * f"floats, but got {lows}") - * - */ - __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 594, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 594, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_Raise(__pyx_t_7, 0, 0, 0); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 594, __pyx_L1_error) + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 26: values[25] = PyTuple_GET_ITEM(__pyx_args, 25); + CYTHON_FALLTHROUGH; + case 25: values[24] = PyTuple_GET_ITEM(__pyx_args, 24); + CYTHON_FALLTHROUGH; + case 24: values[23] = PyTuple_GET_ITEM(__pyx_args, 23); + CYTHON_FALLTHROUGH; + case 23: values[22] = PyTuple_GET_ITEM(__pyx_args, 22); + CYTHON_FALLTHROUGH; + case 22: values[21] = PyTuple_GET_ITEM(__pyx_args, 21); + CYTHON_FALLTHROUGH; + case 21: values[20] = PyTuple_GET_ITEM(__pyx_args, 20); + CYTHON_FALLTHROUGH; + case 20: values[19] = PyTuple_GET_ITEM(__pyx_args, 19); + CYTHON_FALLTHROUGH; + case 19: values[18] = PyTuple_GET_ITEM(__pyx_args, 18); + CYTHON_FALLTHROUGH; + case 18: values[17] = PyTuple_GET_ITEM(__pyx_args, 17); + CYTHON_FALLTHROUGH; + case 17: values[16] = PyTuple_GET_ITEM(__pyx_args, 16); + CYTHON_FALLTHROUGH; + case 16: values[15] = PyTuple_GET_ITEM(__pyx_args, 15); + CYTHON_FALLTHROUGH; + case 15: values[14] = PyTuple_GET_ITEM(__pyx_args, 14); + CYTHON_FALLTHROUGH; + case 14: values[13] = PyTuple_GET_ITEM(__pyx_args, 13); + CYTHON_FALLTHROUGH; + case 13: values[12] = PyTuple_GET_ITEM(__pyx_args, 12); + CYTHON_FALLTHROUGH; + case 12: values[11] = PyTuple_GET_ITEM(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_X = values[0]; + __pyx_v_y = values[1]; + __pyx_v_loss = ((PyObject*)values[2]); + __pyx_v_penalty = ((PyObject*)values[3]); + __pyx_v_algorithm = ((PyObject*)values[4]); + __pyx_v_num_folds = values[5]; + __pyx_v_seed = values[6]; + __pyx_v_max_support_size = values[7]; + __pyx_v_num_lambda = values[8]; + __pyx_v_num_gamma = values[9]; + if (values[10]) { + __pyx_v_gamma_max = __pyx_PyFloat_AsDouble(values[10]); if (unlikely((__pyx_v_gamma_max == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 543, __pyx_L3_error) + } else { + __pyx_v_gamma_max = ((double)10.); + } + if (values[11]) { + __pyx_v_gamma_min = __pyx_PyFloat_AsDouble(values[11]); if (unlikely((__pyx_v_gamma_min == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 544, __pyx_L3_error) + } else { + __pyx_v_gamma_min = ((double).0001); + } + __pyx_v_partial_sort = values[12]; + __pyx_v_max_iter = values[13]; + if (values[14]) { + __pyx_v_rtol = __pyx_PyFloat_AsDouble(values[14]); if (unlikely((__pyx_v_rtol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 547, __pyx_L3_error) + } else { + __pyx_v_rtol = ((double)1e-6); + } + if (values[15]) { + __pyx_v_atol = __pyx_PyFloat_AsDouble(values[15]); if (unlikely((__pyx_v_atol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 548, __pyx_L3_error) + } else { + __pyx_v_atol = ((double)1e-9); + } + __pyx_v_active_set = values[16]; + __pyx_v_active_set_num = values[17]; + __pyx_v_max_swaps = values[18]; + if (values[19]) { + __pyx_v_scale_down_factor = __pyx_PyFloat_AsDouble(values[19]); if (unlikely((__pyx_v_scale_down_factor == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 552, __pyx_L3_error) + } else { + __pyx_v_scale_down_factor = ((double)0.8); + } + __pyx_v_screen_size = values[20]; + __pyx_v_lambda_grid = values[21]; + __pyx_v_exclude_first_k = values[22]; + __pyx_v_intercept = values[23]; + __pyx_v_lows = values[24]; + __pyx_v_highs = values[25]; } - __pyx_L85:; - - /* "l0learn/interface.pyx":597 - * f"floats, but got {lows}") - * - * if isinstance(highs, float): # <<<<<<<<<<<<<< - * if highs < 0: - * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") - */ - __pyx_t_5 = PyFloat_Check(__pyx_v_highs); - __pyx_t_1 = (__pyx_t_5 != 0); - if (__pyx_t_1) { + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("cvfit", 0, 2, 26, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 533, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("l0learn.interface.cvfit", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loss), (&PyUnicode_Type), 1, "loss", 1))) __PYX_ERR(0, 535, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_penalty), (&PyUnicode_Type), 1, "penalty", 1))) __PYX_ERR(0, 536, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_algorithm), (&PyUnicode_Type), 1, "algorithm", 1))) __PYX_ERR(0, 537, __pyx_L1_error) + __pyx_r = __pyx_pf_7l0learn_9interface_6cvfit(__pyx_self, __pyx_v_X, __pyx_v_y, __pyx_v_loss, __pyx_v_penalty, __pyx_v_algorithm, __pyx_v_num_folds, __pyx_v_seed, __pyx_v_max_support_size, __pyx_v_num_lambda, __pyx_v_num_gamma, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_v_partial_sort, __pyx_v_max_iter, __pyx_v_rtol, __pyx_v_atol, __pyx_v_active_set, __pyx_v_active_set_num, __pyx_v_max_swaps, __pyx_v_scale_down_factor, __pyx_v_screen_size, __pyx_v_lambda_grid, __pyx_v_exclude_first_k, __pyx_v_intercept, __pyx_v_lows, __pyx_v_highs); - /* "l0learn/interface.pyx":598 + /* "l0learn/interface.pyx":533 * - * if isinstance(highs, float): - * if highs < 0: # <<<<<<<<<<<<<< - * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") - * if highs < float('inf'): - */ - __pyx_t_7 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 598, __pyx_L1_error) - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 598, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(__pyx_t_1)) { - - /* "l0learn/interface.pyx":599 - * if isinstance(highs, float): - * if highs < 0: - * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") # <<<<<<<<<<<<<< - * if highs < float('inf'): - * with_bounds = True - */ - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 599, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_highs_to_be_a_non_negat, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 599, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 599, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_Raise(__pyx_t_7, 0, 0, 0); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 599, __pyx_L1_error) - - /* "l0learn/interface.pyx":598 * - * if isinstance(highs, float): - * if highs < 0: # <<<<<<<<<<<<<< - * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") - * if highs < float('inf'): - */ - } - - /* "l0learn/interface.pyx":600 - * if highs < 0: - * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") - * if highs < float('inf'): # <<<<<<<<<<<<<< - * with_bounds = True - * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): + * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< + * y: np.ndarray, + * loss: str = "SquaredError", */ - __pyx_t_7 = __Pyx_PyNumber_Float(__pyx_n_u_inf); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 600, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = PyObject_RichCompare(__pyx_v_highs, __pyx_t_7, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 600, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 600, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (__pyx_t_1) { - /* "l0learn/interface.pyx":601 - * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") - * if highs < float('inf'): - * with_bounds = True # <<<<<<<<<<<<<< - * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): - * with_bounds = True - */ - __pyx_v_with_bounds = 1; + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} - /* "l0learn/interface.pyx":600 - * if highs < 0: - * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") - * if highs < float('inf'): # <<<<<<<<<<<<<< - * with_bounds = True - * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): - */ - } +static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_num_folds, PyObject *__pyx_v_seed, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs) { + PyObject *__pyx_v_check = NULL; + PyObject *__pyx_v_auto_lambda = NULL; + PyObject *__pyx_v_with_bounds = NULL; + CYTHON_UNUSED PyObject *__pyx_v__ = NULL; + PyObject *__pyx_v_p = NULL; + std::vector > __pyx_v_c_lambda_grid; + std::string __pyx_v_c_loss; + std::string __pyx_v_c_penalty; + std::string __pyx_v_c_algorithim; + cvfitmodel __pyx_v_c_results; + PyObject *__pyx_v_results = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + double __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *(*__pyx_t_6)(PyObject *); + int __pyx_t_7; + int __pyx_t_8; + int __pyx_t_9; + Py_ssize_t __pyx_t_10; + Py_UCS4 __pyx_t_11; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + std::vector > __pyx_t_15; + int __pyx_t_16; + PyObject *__pyx_t_17 = NULL; + std::string __pyx_t_18; + size_t __pyx_t_19; + size_t __pyx_t_20; + size_t __pyx_t_21; + bool __pyx_t_22; + size_t __pyx_t_23; + bool __pyx_t_24; + size_t __pyx_t_25; + size_t __pyx_t_26; + size_t __pyx_t_27; + unsigned int __pyx_t_28; + size_t __pyx_t_29; + bool __pyx_t_30; + bool __pyx_t_31; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("cvfit", 0); + __Pyx_INCREF(__pyx_v_y); + __Pyx_INCREF(__pyx_v_penalty); + __Pyx_INCREF(__pyx_v_max_support_size); + __Pyx_INCREF(__pyx_v_num_lambda); + __Pyx_INCREF(__pyx_v_num_gamma); + __Pyx_INCREF(__pyx_v_screen_size); + __Pyx_INCREF(__pyx_v_lambda_grid); + __Pyx_INCREF(__pyx_v_lows); + __Pyx_INCREF(__pyx_v_highs); - /* "l0learn/interface.pyx":597 - * f"floats, but got {lows}") + /* "l0learn/interface.pyx":560 + * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.CVFitModel: * - * if isinstance(highs, float): # <<<<<<<<<<<<<< - * if highs < 0: - * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") + * check = _fit_check(X=X, # <<<<<<<<<<<<<< + * y=y, + * loss=loss, */ - goto __pyx_L91; - } + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_fit_check); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 560, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyDict_NewPresized(24); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 560, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_X, __pyx_v_X) < 0) __PYX_ERR(0, 560, __pyx_L1_error) + + /* "l0learn/interface.pyx":561 + * + * check = _fit_check(X=X, + * y=y, # <<<<<<<<<<<<<< + * loss=loss, + * penalty=penalty, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_y, __pyx_v_y) < 0) __PYX_ERR(0, 560, __pyx_L1_error) + + /* "l0learn/interface.pyx":562 + * check = _fit_check(X=X, + * y=y, + * loss=loss, # <<<<<<<<<<<<<< + * penalty=penalty, + * algorithm=algorithm, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 560, __pyx_L1_error) + + /* "l0learn/interface.pyx":563 + * y=y, + * loss=loss, + * penalty=penalty, # <<<<<<<<<<<<<< + * algorithm=algorithm, + * max_support_size=max_support_size, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 560, __pyx_L1_error) + + /* "l0learn/interface.pyx":564 + * loss=loss, + * penalty=penalty, + * algorithm=algorithm, # <<<<<<<<<<<<<< + * max_support_size=max_support_size, + * num_lambda=num_lambda, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_algorithm, __pyx_v_algorithm) < 0) __PYX_ERR(0, 560, __pyx_L1_error) + + /* "l0learn/interface.pyx":565 + * penalty=penalty, + * algorithm=algorithm, + * max_support_size=max_support_size, # <<<<<<<<<<<<<< + * num_lambda=num_lambda, + * num_gamma=num_gamma, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_support_size, __pyx_v_max_support_size) < 0) __PYX_ERR(0, 560, __pyx_L1_error) + + /* "l0learn/interface.pyx":566 + * algorithm=algorithm, + * max_support_size=max_support_size, + * num_lambda=num_lambda, # <<<<<<<<<<<<<< + * num_gamma=num_gamma, + * gamma_max=gamma_max, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_lambda, __pyx_v_num_lambda) < 0) __PYX_ERR(0, 560, __pyx_L1_error) + + /* "l0learn/interface.pyx":567 + * max_support_size=max_support_size, + * num_lambda=num_lambda, + * num_gamma=num_gamma, # <<<<<<<<<<<<<< + * gamma_max=gamma_max, + * gamma_min=gamma_min, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_gamma, __pyx_v_num_gamma) < 0) __PYX_ERR(0, 560, __pyx_L1_error) + + /* "l0learn/interface.pyx":568 + * num_lambda=num_lambda, + * num_gamma=num_gamma, + * gamma_max=gamma_max, # <<<<<<<<<<<<<< + * gamma_min=gamma_min, + * partial_sort=partial_sort, + */ + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 568, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma_max, __pyx_t_3) < 0) __PYX_ERR(0, 560, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":602 - * if highs < float('inf'): - * with_bounds = True - * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): # <<<<<<<<<<<<<< - * with_bounds = True - * else: + /* "l0learn/interface.pyx":569 + * num_gamma=num_gamma, + * gamma_max=gamma_max, + * gamma_min=gamma_min, # <<<<<<<<<<<<<< + * partial_sort=partial_sort, + * max_iter=max_iter, */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 602, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 602, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_5 = PyObject_IsInstance(__pyx_v_highs, __pyx_t_7); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 602, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = (__pyx_t_5 != 0); - if (__pyx_t_4) { - } else { - __pyx_t_1 = __pyx_t_4; - goto __pyx_L94_bool_binop_done; - } - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_highs, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 602, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyInt_EqObjC(__pyx_t_7, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 602, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 602, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (__pyx_t_4) { - } else { - __pyx_t_1 = __pyx_t_4; - goto __pyx_L94_bool_binop_done; - } - __pyx_t_9 = PyObject_Length(__pyx_v_highs); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 602, __pyx_L1_error) - __pyx_t_8 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 602, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = PyObject_RichCompare(__pyx_t_8, __pyx_v_p, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 602, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 602, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (__pyx_t_4) { - } else { - __pyx_t_1 = __pyx_t_4; - goto __pyx_L94_bool_binop_done; - } - __pyx_t_7 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 602, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 602, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_1 = __pyx_t_4; - __pyx_L94_bool_binop_done:; - if (likely(__pyx_t_1)) { + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 569, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma_min, __pyx_t_3) < 0) __PYX_ERR(0, 560, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":603 - * with_bounds = True - * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): - * with_bounds = True # <<<<<<<<<<<<<< - * else: - * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " + /* "l0learn/interface.pyx":570 + * gamma_max=gamma_max, + * gamma_min=gamma_min, + * partial_sort=partial_sort, # <<<<<<<<<<<<<< + * max_iter=max_iter, + * rtol=rtol, */ - __pyx_v_with_bounds = 1; + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_partial_sort, __pyx_v_partial_sort) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - /* "l0learn/interface.pyx":602 - * if highs < float('inf'): - * with_bounds = True - * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): # <<<<<<<<<<<<<< - * with_bounds = True - * else: + /* "l0learn/interface.pyx":571 + * gamma_min=gamma_min, + * partial_sort=partial_sort, + * max_iter=max_iter, # <<<<<<<<<<<<<< + * rtol=rtol, + * atol=atol, */ - goto __pyx_L91; - } + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_iter, __pyx_v_max_iter) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - /* "l0learn/interface.pyx":605 - * with_bounds = True - * else: - * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " # <<<<<<<<<<<<<< - * f"non-negative floats, but got {highs}") - * + /* "l0learn/interface.pyx":572 + * partial_sort=partial_sort, + * max_iter=max_iter, + * rtol=rtol, # <<<<<<<<<<<<<< + * atol=atol, + * active_set=active_set, */ - /*else*/ { - __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 605, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_9 = 0; - __pyx_t_10 = 127; - __Pyx_INCREF(__pyx_kp_u_expected_highs_to_be_a_non_negat_2); - __pyx_t_9 += 73; - __Pyx_GIVEREF(__pyx_kp_u_expected_highs_to_be_a_non_negat_2); - PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_highs_to_be_a_non_negat_2); - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 605, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); - __Pyx_GIVEREF(__pyx_t_8); - PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_8); - __pyx_t_8 = 0; - __Pyx_INCREF(__pyx_kp_u_of_non_negative_floats_but_got); - __pyx_t_9 += 33; - __Pyx_GIVEREF(__pyx_kp_u_of_non_negative_floats_but_got); - PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_of_non_negative_floats_but_got); + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_rtol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_rtol, __pyx_t_3) < 0) __PYX_ERR(0, 560, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":606 - * else: - * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " - * f"non-negative floats, but got {highs}") # <<<<<<<<<<<<<< - * - * if with_bounds: + /* "l0learn/interface.pyx":573 + * max_iter=max_iter, + * rtol=rtol, + * atol=atol, # <<<<<<<<<<<<<< + * active_set=active_set, + * active_set_num=active_set_num, */ - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 606, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); - __Pyx_GIVEREF(__pyx_t_8); - PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_8); - __pyx_t_8 = 0; + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_atol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_atol, __pyx_t_3) < 0) __PYX_ERR(0, 560, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":605 - * with_bounds = True - * else: - * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " # <<<<<<<<<<<<<< - * f"non-negative floats, but got {highs}") - * + /* "l0learn/interface.pyx":574 + * rtol=rtol, + * atol=atol, + * active_set=active_set, # <<<<<<<<<<<<<< + * active_set_num=active_set_num, + * max_swaps=max_swaps, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_active_set, __pyx_v_active_set) < 0) __PYX_ERR(0, 560, __pyx_L1_error) + + /* "l0learn/interface.pyx":575 + * atol=atol, + * active_set=active_set, + * active_set_num=active_set_num, # <<<<<<<<<<<<<< + * max_swaps=max_swaps, + * scale_down_factor=scale_down_factor, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_active_set_num, __pyx_v_active_set_num) < 0) __PYX_ERR(0, 560, __pyx_L1_error) + + /* "l0learn/interface.pyx":576 + * active_set=active_set, + * active_set_num=active_set_num, + * max_swaps=max_swaps, # <<<<<<<<<<<<<< + * scale_down_factor=scale_down_factor, + * screen_size=screen_size, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_swaps, __pyx_v_max_swaps) < 0) __PYX_ERR(0, 560, __pyx_L1_error) + + /* "l0learn/interface.pyx":577 + * active_set_num=active_set_num, + * max_swaps=max_swaps, + * scale_down_factor=scale_down_factor, # <<<<<<<<<<<<<< + * screen_size=screen_size, + * lambda_grid=lambda_grid, + */ + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_scale_down_factor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 577, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_scale_down_factor, __pyx_t_3) < 0) __PYX_ERR(0, 560, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "l0learn/interface.pyx":578 + * max_swaps=max_swaps, + * scale_down_factor=scale_down_factor, + * screen_size=screen_size, # <<<<<<<<<<<<<< + * lambda_grid=lambda_grid, + * exclude_first_k=exclude_first_k, */ - __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 605, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 605, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_Raise(__pyx_t_7, 0, 0, 0); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 605, __pyx_L1_error) - } - __pyx_L91:; + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_screen_size, __pyx_v_screen_size) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - /* "l0learn/interface.pyx":608 - * f"non-negative floats, but got {highs}") - * - * if with_bounds: # <<<<<<<<<<<<<< - * if isinstance(lows, float): - * lows = np.ones(p) * lows + /* "l0learn/interface.pyx":579 + * scale_down_factor=scale_down_factor, + * screen_size=screen_size, + * lambda_grid=lambda_grid, # <<<<<<<<<<<<<< + * exclude_first_k=exclude_first_k, + * intercept=intercept, */ - __pyx_t_1 = (__pyx_v_with_bounds != 0); - if (__pyx_t_1) { + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lambda_grid, __pyx_v_lambda_grid) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - /* "l0learn/interface.pyx":609 - * - * if with_bounds: - * if isinstance(lows, float): # <<<<<<<<<<<<<< - * lows = np.ones(p) * lows - * if isinstance(highs, float): + /* "l0learn/interface.pyx":580 + * screen_size=screen_size, + * lambda_grid=lambda_grid, + * exclude_first_k=exclude_first_k, # <<<<<<<<<<<<<< + * intercept=intercept, + * lows=lows, */ - __pyx_t_1 = PyFloat_Check(__pyx_v_lows); - __pyx_t_4 = (__pyx_t_1 != 0); - if (__pyx_t_4) { + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_exclude_first_k, __pyx_v_exclude_first_k) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - /* "l0learn/interface.pyx":610 - * if with_bounds: - * if isinstance(lows, float): - * lows = np.ones(p) * lows # <<<<<<<<<<<<<< - * if isinstance(highs, float): - * highs = np.ones(p) * highs + /* "l0learn/interface.pyx":581 + * lambda_grid=lambda_grid, + * exclude_first_k=exclude_first_k, + * intercept=intercept, # <<<<<<<<<<<<<< + * lows=lows, + * highs=highs) */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 610, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_ones); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 610, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_8); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - } - } - __pyx_t_7 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_8, __pyx_v_p) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_p); - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 610, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PyNumber_Multiply(__pyx_t_7, __pyx_v_lows); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 610, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_3); - __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - /* "l0learn/interface.pyx":609 + /* "l0learn/interface.pyx":582 + * exclude_first_k=exclude_first_k, + * intercept=intercept, + * lows=lows, # <<<<<<<<<<<<<< + * highs=highs) * - * if with_bounds: - * if isinstance(lows, float): # <<<<<<<<<<<<<< - * lows = np.ones(p) * lows - * if isinstance(highs, float): */ - } + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lows, __pyx_v_lows) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - /* "l0learn/interface.pyx":611 - * if isinstance(lows, float): - * lows = np.ones(p) * lows - * if isinstance(highs, float): # <<<<<<<<<<<<<< - * highs = np.ones(p) * highs + /* "l0learn/interface.pyx":583 + * intercept=intercept, + * lows=lows, + * highs=highs) # <<<<<<<<<<<<<< * + * max_support_size = check["max_support_size"] */ - __pyx_t_4 = PyFloat_Check(__pyx_v_highs); - __pyx_t_1 = (__pyx_t_4 != 0); - if (__pyx_t_1) { + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_highs, __pyx_v_highs) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - /* "l0learn/interface.pyx":612 - * lows = np.ones(p) * lows - * if isinstance(highs, float): - * highs = np.ones(p) * highs # <<<<<<<<<<<<<< + /* "l0learn/interface.pyx":560 + * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.CVFitModel: * - * if any(lows >= highs): + * check = _fit_check(X=X, # <<<<<<<<<<<<<< + * y=y, + * loss=loss, */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 612, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ones); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 612, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); - if (likely(__pyx_t_7)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); - __Pyx_INCREF(__pyx_t_7); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_8, function); - } - } - __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_7, __pyx_v_p) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_p); - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 612, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = PyNumber_Multiply(__pyx_t_3, __pyx_v_highs); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 612, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_8); - __pyx_t_8 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 560, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_check = __pyx_t_3; + __pyx_t_3 = 0; - /* "l0learn/interface.pyx":611 - * if isinstance(lows, float): - * lows = np.ones(p) * lows - * if isinstance(highs, float): # <<<<<<<<<<<<<< - * highs = np.ones(p) * highs + /* "l0learn/interface.pyx":585 + * highs=highs) * + * max_support_size = check["max_support_size"] # <<<<<<<<<<<<<< + * screen_size = check["screen_size"] + * y = check['y'] */ - } + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_max_support_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 585, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_max_support_size, __pyx_t_3); + __pyx_t_3 = 0; - /* "l0learn/interface.pyx":614 - * highs = np.ones(p) * highs + /* "l0learn/interface.pyx":586 * - * if any(lows >= highs): # <<<<<<<<<<<<<< - * bad_bounds = np.argwhere(lows >= highs) - * raise ValueError(f"expected to be high to be elementwise greater than lows, " + * max_support_size = check["max_support_size"] + * screen_size = check["screen_size"] # <<<<<<<<<<<<<< + * y = check['y'] + * penalty = check['penalty'] */ - __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 614, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 614, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 614, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(__pyx_t_1)) { + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_screen_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 586, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_screen_size, __pyx_t_3); + __pyx_t_3 = 0; - /* "l0learn/interface.pyx":615 - * - * if any(lows >= highs): - * bad_bounds = np.argwhere(lows >= highs) # <<<<<<<<<<<<<< - * raise ValueError(f"expected to be high to be elementwise greater than lows, " - * f"but got indices {bad_bounds[0]} where that is not the case ") + /* "l0learn/interface.pyx":587 + * max_support_size = check["max_support_size"] + * screen_size = check["screen_size"] + * y = check['y'] # <<<<<<<<<<<<<< + * penalty = check['penalty'] + * gamma_max = check['gamma_max'] */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 615, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_argwhere); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 615, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 615, __pyx_L1_error) - __pyx_t_16 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { - __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_7); - if (likely(__pyx_t_16)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); - __Pyx_INCREF(__pyx_t_16); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_7, function); - } - } - __pyx_t_3 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_16, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); - __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 615, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_v_bad_bounds = __pyx_t_3; - __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_y); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 587, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_y, __pyx_t_3); + __pyx_t_3 = 0; - /* "l0learn/interface.pyx":616 - * if any(lows >= highs): - * bad_bounds = np.argwhere(lows >= highs) - * raise ValueError(f"expected to be high to be elementwise greater than lows, " # <<<<<<<<<<<<<< - * f"but got indices {bad_bounds[0]} where that is not the case ") - * else: + /* "l0learn/interface.pyx":588 + * screen_size = check["screen_size"] + * y = check['y'] + * penalty = check['penalty'] # <<<<<<<<<<<<<< + * gamma_max = check['gamma_max'] + * gamma_min = check['gamma_min'] */ - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 616, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_9 = 0; - __pyx_t_10 = 127; - __Pyx_INCREF(__pyx_kp_u_expected_to_be_high_to_be_elemen); - __pyx_t_9 += 73; - __Pyx_GIVEREF(__pyx_kp_u_expected_to_be_high_to_be_elemen); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_to_be_high_to_be_elemen); + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_penalty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 588, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (!(likely(PyUnicode_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(0, 588, __pyx_L1_error) + __Pyx_DECREF_SET(__pyx_v_penalty, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; - /* "l0learn/interface.pyx":617 - * bad_bounds = np.argwhere(lows >= highs) - * raise ValueError(f"expected to be high to be elementwise greater than lows, " - * f"but got indices {bad_bounds[0]} where that is not the case ") # <<<<<<<<<<<<<< - * else: - * lows = np.array([0.]) + /* "l0learn/interface.pyx":589 + * y = check['y'] + * penalty = check['penalty'] + * gamma_max = check['gamma_max'] # <<<<<<<<<<<<<< + * gamma_min = check['gamma_min'] + * lambda_grid = check['lambda_grid'] */ - __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_bad_bounds, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 617, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 617, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); - __Pyx_GIVEREF(__pyx_t_8); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_8); - __pyx_t_8 = 0; - __Pyx_INCREF(__pyx_kp_u_where_that_is_not_the_case); - __pyx_t_9 += 28; - __Pyx_GIVEREF(__pyx_kp_u_where_that_is_not_the_case); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_where_that_is_not_the_case); + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 589, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 589, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_gamma_max = __pyx_t_4; - /* "l0learn/interface.pyx":616 - * if any(lows >= highs): - * bad_bounds = np.argwhere(lows >= highs) - * raise ValueError(f"expected to be high to be elementwise greater than lows, " # <<<<<<<<<<<<<< - * f"but got indices {bad_bounds[0]} where that is not the case ") - * else: + /* "l0learn/interface.pyx":590 + * penalty = check['penalty'] + * gamma_max = check['gamma_max'] + * gamma_min = check['gamma_min'] # <<<<<<<<<<<<<< + * lambda_grid = check['lambda_grid'] + * num_gamma = check['num_gamma'] */ - __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 616, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 616, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 616, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_gamma_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 590, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 590, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_gamma_min = __pyx_t_4; - /* "l0learn/interface.pyx":614 - * highs = np.ones(p) * highs + /* "l0learn/interface.pyx":591 + * gamma_max = check['gamma_max'] + * gamma_min = check['gamma_min'] + * lambda_grid = check['lambda_grid'] # <<<<<<<<<<<<<< + * num_gamma = check['num_gamma'] + * num_lambda = check['num_lambda'] + */ + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_lambda_grid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 591, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_lambda_grid, __pyx_t_3); + __pyx_t_3 = 0; + + /* "l0learn/interface.pyx":592 + * gamma_min = check['gamma_min'] + * lambda_grid = check['lambda_grid'] + * num_gamma = check['num_gamma'] # <<<<<<<<<<<<<< + * num_lambda = check['num_lambda'] + * auto_lambda = check['auto_lambda'] + */ + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_num_gamma); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 592, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_num_gamma, __pyx_t_3); + __pyx_t_3 = 0; + + /* "l0learn/interface.pyx":593 + * lambda_grid = check['lambda_grid'] + * num_gamma = check['num_gamma'] + * num_lambda = check['num_lambda'] # <<<<<<<<<<<<<< + * auto_lambda = check['auto_lambda'] + * with_bounds = check['with_bounds'] + */ + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_num_lambda); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 593, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_num_lambda, __pyx_t_3); + __pyx_t_3 = 0; + + /* "l0learn/interface.pyx":594 + * num_gamma = check['num_gamma'] + * num_lambda = check['num_lambda'] + * auto_lambda = check['auto_lambda'] # <<<<<<<<<<<<<< + * with_bounds = check['with_bounds'] + * lows = check['lows'] + */ + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_auto_lambda); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 594, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_auto_lambda = __pyx_t_3; + __pyx_t_3 = 0; + + /* "l0learn/interface.pyx":595 + * num_lambda = check['num_lambda'] + * auto_lambda = check['auto_lambda'] + * with_bounds = check['with_bounds'] # <<<<<<<<<<<<<< + * lows = check['lows'] + * highs = check['highs'] + */ + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_with_bounds); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 595, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_with_bounds = __pyx_t_3; + __pyx_t_3 = 0; + + /* "l0learn/interface.pyx":596 + * auto_lambda = check['auto_lambda'] + * with_bounds = check['with_bounds'] + * lows = check['lows'] # <<<<<<<<<<<<<< + * highs = check['highs'] * - * if any(lows >= highs): # <<<<<<<<<<<<<< - * bad_bounds = np.argwhere(lows >= highs) - * raise ValueError(f"expected to be high to be elementwise greater than lows, " */ + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_lows); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 596, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_3); + __pyx_t_3 = 0; + + /* "l0learn/interface.pyx":597 + * with_bounds = check['with_bounds'] + * lows = check['lows'] + * highs = check['highs'] # <<<<<<<<<<<<<< + * + * _, p = X.shape + */ + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_highs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 597, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_3); + __pyx_t_3 = 0; + + /* "l0learn/interface.pyx":599 + * highs = check['highs'] + * + * _, p = X.shape # <<<<<<<<<<<<<< + * + * if not isinstance(num_folds, int) or num_folds < 2 or num_folds > p: + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 599, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { + PyObject* sequence = __pyx_t_3; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 599, __pyx_L1_error) } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_1 = PyTuple_GET_ITEM(sequence, 1); + } else { + __pyx_t_2 = PyList_GET_ITEM(sequence, 0); + __pyx_t_1 = PyList_GET_ITEM(sequence, 1); + } + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + #else + __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 599, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 599, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_5 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 599, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext; + index = 0; __pyx_t_2 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed; + __Pyx_GOTREF(__pyx_t_2); + index = 1; __pyx_t_1 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_1)) goto __pyx_L3_unpacking_failed; + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 2) < 0) __PYX_ERR(0, 599, __pyx_L1_error) + __pyx_t_6 = NULL; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L4_unpacking_done; + __pyx_L3_unpacking_failed:; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_6 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 599, __pyx_L1_error) + __pyx_L4_unpacking_done:; + } + __pyx_v__ = __pyx_t_2; + __pyx_t_2 = 0; + __pyx_v_p = __pyx_t_1; + __pyx_t_1 = 0; - /* "l0learn/interface.pyx":608 - * f"non-negative floats, but got {highs}") + /* "l0learn/interface.pyx":601 + * _, p = X.shape + * + * if not isinstance(num_folds, int) or num_folds < 2 or num_folds > p: # <<<<<<<<<<<<<< + * raise ValueError(f"expected num_folds parameter to be a positive integer less than {p}, but got {num_folds}") * - * if with_bounds: # <<<<<<<<<<<<<< - * if isinstance(lows, float): - * lows = np.ones(p) * lows */ - goto __pyx_L98; + __pyx_t_8 = PyInt_Check(__pyx_v_num_folds); + __pyx_t_9 = ((!(__pyx_t_8 != 0)) != 0); + if (!__pyx_t_9) { + } else { + __pyx_t_7 = __pyx_t_9; + goto __pyx_L6_bool_binop_done; } + __pyx_t_3 = PyObject_RichCompare(__pyx_v_num_folds, __pyx_int_2, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 601, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 601, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!__pyx_t_9) { + } else { + __pyx_t_7 = __pyx_t_9; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_3 = PyObject_RichCompare(__pyx_v_num_folds, __pyx_v_p, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 601, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 601, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = __pyx_t_9; + __pyx_L6_bool_binop_done:; + if (unlikely(__pyx_t_7)) { - /* "l0learn/interface.pyx":619 - * f"but got indices {bad_bounds[0]} where that is not the case ") - * else: - * lows = np.array([0.]) # <<<<<<<<<<<<<< - * highs = np.array(([0.])) + /* "l0learn/interface.pyx":602 + * + * if not isinstance(num_folds, int) or num_folds < 2 or num_folds > p: + * raise ValueError(f"expected num_folds parameter to be a positive integer less than {p}, but got {num_folds}") # <<<<<<<<<<<<<< + * * */ - /*else*/ { - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 619, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_array); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 619, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = PyList_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 619, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_INCREF(__pyx_float_0_); - __Pyx_GIVEREF(__pyx_float_0_); - PyList_SET_ITEM(__pyx_t_8, 0, __pyx_float_0_); - __pyx_t_16 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { - __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_7); - if (likely(__pyx_t_16)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); - __Pyx_INCREF(__pyx_t_16); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_7, function); - } - } - __pyx_t_3 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_16, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); - __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 619, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 602, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_3); - __pyx_t_3 = 0; + __pyx_t_10 = 0; + __pyx_t_11 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_num_folds_parameter_to); + __pyx_t_10 += 64; + __Pyx_GIVEREF(__pyx_kp_u_expected_num_folds_parameter_to); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_num_folds_parameter_to); + __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 602, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_11 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) > __pyx_t_11) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) : __pyx_t_11; + __pyx_t_10 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); + __pyx_t_1 = 0; + __Pyx_INCREF(__pyx_kp_u_but_got); + __pyx_t_10 += 10; + __Pyx_GIVEREF(__pyx_kp_u_but_got); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_but_got); + __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_num_folds, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 602, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_11 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) > __pyx_t_11) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) : __pyx_t_11; + __pyx_t_10 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_10, __pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 602, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 602, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 602, __pyx_L1_error) - /* "l0learn/interface.pyx":620 - * else: - * lows = np.array([0.]) - * highs = np.array(([0.])) # <<<<<<<<<<<<<< + /* "l0learn/interface.pyx":601 + * _, p = X.shape + * + * if not isinstance(num_folds, int) or num_folds < 2 or num_folds > p: # <<<<<<<<<<<<<< + * raise ValueError(f"expected num_folds parameter to be a positive integer less than {p}, but got {num_folds}") * - * cdef vector[vector[double]] c_lambda_grid */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 620, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_array); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 620, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = PyList_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 620, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_INCREF(__pyx_float_0_); - __Pyx_GIVEREF(__pyx_float_0_); - PyList_SET_ITEM(__pyx_t_7, 0, __pyx_float_0_); - __pyx_t_16 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { - __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_8); - if (likely(__pyx_t_16)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); - __Pyx_INCREF(__pyx_t_16); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_8, function); - } - } - __pyx_t_3 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_16, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); - __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 620, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_3); - __pyx_t_3 = 0; } - __pyx_L98:; - /* "l0learn/interface.pyx":623 + /* "l0learn/interface.pyx":606 * * cdef vector[vector[double]] c_lambda_grid * try: # <<<<<<<<<<<<<< @@ -11153,23 +9511,23 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19); - __Pyx_XGOTREF(__pyx_t_17); - __Pyx_XGOTREF(__pyx_t_18); - __Pyx_XGOTREF(__pyx_t_19); + __Pyx_ExceptionSave(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14); + __Pyx_XGOTREF(__pyx_t_12); + __Pyx_XGOTREF(__pyx_t_13); + __Pyx_XGOTREF(__pyx_t_14); /*try:*/ { - /* "l0learn/interface.pyx":624 + /* "l0learn/interface.pyx":607 * cdef vector[vector[double]] c_lambda_grid * try: * c_lambda_grid = lambda_grid # <<<<<<<<<<<<<< * except TypeError: * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") */ - __pyx_t_20 = __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_lambda_grid); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 624, __pyx_L102_error) - __pyx_v_c_lambda_grid = __pyx_t_20; + __pyx_t_15 = __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_lambda_grid); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 607, __pyx_L9_error) + __pyx_v_c_lambda_grid = __pyx_t_15; - /* "l0learn/interface.pyx":623 + /* "l0learn/interface.pyx":606 * * cdef vector[vector[double]] c_lambda_grid * try: # <<<<<<<<<<<<<< @@ -11177,70 +9535,69 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p * except TypeError: */ } - __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; - __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; - __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; - goto __pyx_L107_try_end; - __pyx_L102_error:; - __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + goto __pyx_L14_try_end; + __pyx_L9_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "l0learn/interface.pyx":625 + /* "l0learn/interface.pyx":608 * try: * c_lambda_grid = lambda_grid * except TypeError: # <<<<<<<<<<<<<< * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") * */ - __pyx_t_21 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); - if (__pyx_t_21) { + __pyx_t_16 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); + if (__pyx_t_16) { __Pyx_AddTraceback("l0learn.interface.cvfit", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_8, &__pyx_t_7) < 0) __PYX_ERR(0, 625, __pyx_L104_except_error) + if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_1, &__pyx_t_2) < 0) __PYX_ERR(0, 608, __pyx_L11_except_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_GOTREF(__pyx_t_8); - __Pyx_GOTREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_t_2); - /* "l0learn/interface.pyx":626 + /* "l0learn/interface.pyx":609 * c_lambda_grid = lambda_grid * except TypeError: * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") # <<<<<<<<<<<<<< * * cdef string c_loss = loss.encode('UTF-8') */ - __pyx_t_16 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 626, __pyx_L104_except_error) - __Pyx_GOTREF(__pyx_t_16); - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_be_a_lis, __pyx_t_16); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 626, __pyx_L104_except_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_16 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 626, __pyx_L104_except_error) - __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_16, 0, 0, 0); - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __PYX_ERR(0, 626, __pyx_L104_except_error) + __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 609, __pyx_L11_except_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_17 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_be_a_lis, __pyx_t_5); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 609, __pyx_L11_except_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_17); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 609, __pyx_L11_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(0, 609, __pyx_L11_except_error) } - goto __pyx_L104_except_error; - __pyx_L104_except_error:; + goto __pyx_L11_except_error; + __pyx_L11_except_error:; - /* "l0learn/interface.pyx":623 + /* "l0learn/interface.pyx":606 * * cdef vector[vector[double]] c_lambda_grid * try: # <<<<<<<<<<<<<< * c_lambda_grid = lambda_grid * except TypeError: */ - __Pyx_XGIVEREF(__pyx_t_17); - __Pyx_XGIVEREF(__pyx_t_18); - __Pyx_XGIVEREF(__pyx_t_19); - __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_18, __pyx_t_19); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_XGIVEREF(__pyx_t_14); + __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14); goto __pyx_L1_error; - __pyx_L107_try_end:; + __pyx_L14_try_end:; } - /* "l0learn/interface.pyx":628 + /* "l0learn/interface.pyx":611 * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") * * cdef string c_loss = loss.encode('UTF-8') # <<<<<<<<<<<<<< @@ -11249,15 +9606,15 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ if (unlikely(__pyx_v_loss == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 628, __pyx_L1_error) + __PYX_ERR(0, 611, __pyx_L1_error) } - __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_loss); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 628, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 628, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_v_c_loss = __pyx_t_22; + __pyx_t_2 = PyUnicode_AsUTF8String(__pyx_v_loss); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 611, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_18 = __pyx_convert_string_from_py_std__in_string(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 611, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_c_loss = __pyx_t_18; - /* "l0learn/interface.pyx":629 + /* "l0learn/interface.pyx":612 * * cdef string c_loss = loss.encode('UTF-8') * cdef string c_penalty = penalty.encode('UTF-8') # <<<<<<<<<<<<<< @@ -11266,15 +9623,15 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ if (unlikely(__pyx_v_penalty == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 629, __pyx_L1_error) + __PYX_ERR(0, 612, __pyx_L1_error) } - __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_penalty); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 629, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 629, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_v_c_penalty = __pyx_t_22; + __pyx_t_2 = PyUnicode_AsUTF8String(__pyx_v_penalty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 612, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_18 = __pyx_convert_string_from_py_std__in_string(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 612, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_c_penalty = __pyx_t_18; - /* "l0learn/interface.pyx":630 + /* "l0learn/interface.pyx":613 * cdef string c_loss = loss.encode('UTF-8') * cdef string c_penalty = penalty.encode('UTF-8') * cdef string c_algorithim = algorithm.encode('UTF-8') # <<<<<<<<<<<<<< @@ -11283,204 +9640,222 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ if (unlikely(__pyx_v_algorithm == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 630, __pyx_L1_error) + __PYX_ERR(0, 613, __pyx_L1_error) } - __pyx_t_7 = PyUnicode_AsUTF8String(__pyx_v_algorithm); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 630, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_22 = __pyx_convert_string_from_py_std__in_string(__pyx_t_7); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 630, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_v_c_algorithim = __pyx_t_22; + __pyx_t_2 = PyUnicode_AsUTF8String(__pyx_v_algorithm); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 613, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_18 = __pyx_convert_string_from_py_std__in_string(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 613, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_c_algorithim = __pyx_t_18; - /* "l0learn/interface.pyx":633 + /* "l0learn/interface.pyx":616 * * cdef cvfitmodel c_results * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), * y=numpy_to_dvec_d(y), */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 633, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 633, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_1 = PyObject_IsInstance(__pyx_v_X, __pyx_t_8); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 633, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_4 = (__pyx_t_1 != 0); - if (__pyx_t_4) { + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_7 = PyObject_IsInstance(__pyx_v_X, __pyx_t_1); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 616, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_9 = (__pyx_t_7 != 0); + if (__pyx_t_9) { - /* "l0learn/interface.pyx":634 + /* "l0learn/interface.pyx":617 * cdef cvfitmodel c_results * if isinstance(X, np.ndarray): * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< * y=numpy_to_dvec_d(y), * Loss=c_loss, */ - if (!(likely(((__pyx_v_X) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_X, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 634, __pyx_L1_error) + if (!(likely(((__pyx_v_X) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_X, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 617, __pyx_L1_error) - /* "l0learn/interface.pyx":635 + /* "l0learn/interface.pyx":618 * if isinstance(X, np.ndarray): * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), * y=numpy_to_dvec_d(y), # <<<<<<<<<<<<<< * Loss=c_loss, * Penalty=c_penalty, */ - if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 635, __pyx_L1_error) + if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 618, __pyx_L1_error) - /* "l0learn/interface.pyx":639 + /* "l0learn/interface.pyx":622 * Penalty=c_penalty, * Algorithm=c_algorithim, * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< * G_ncols=num_lambda, * G_nrows=num_gamma, */ - __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 639, __pyx_L1_error) + __pyx_t_19 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_19 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 622, __pyx_L1_error) - /* "l0learn/interface.pyx":640 + /* "l0learn/interface.pyx":623 * Algorithm=c_algorithim, * NnzStopNum=max_support_size, * G_ncols=num_lambda, # <<<<<<<<<<<<<< * G_nrows=num_gamma, * Lambda2Max=gamma_max, */ - __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 640, __pyx_L1_error) + __pyx_t_20 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_20 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 623, __pyx_L1_error) - /* "l0learn/interface.pyx":641 + /* "l0learn/interface.pyx":624 * NnzStopNum=max_support_size, * G_ncols=num_lambda, * G_nrows=num_gamma, # <<<<<<<<<<<<<< * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, */ - __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 641, __pyx_L1_error) + __pyx_t_21 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_21 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 624, __pyx_L1_error) - /* "l0learn/interface.pyx":644 + /* "l0learn/interface.pyx":627 * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, * PartialSort=partial_sort, # <<<<<<<<<<<<<< * MaxIters=max_iter, * rtol=rtol, */ - __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 644, __pyx_L1_error) + __pyx_t_22 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_22 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 627, __pyx_L1_error) - /* "l0learn/interface.pyx":645 + /* "l0learn/interface.pyx":628 * Lambda2Min=gamma_min, * PartialSort=partial_sort, * MaxIters=max_iter, # <<<<<<<<<<<<<< * rtol=rtol, * atol=atol, */ - __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 645, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 628, __pyx_L1_error) - /* "l0learn/interface.pyx":648 + /* "l0learn/interface.pyx":631 * rtol=rtol, * atol=atol, * ActiveSet=active_set, # <<<<<<<<<<<<<< * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, */ - __pyx_t_28 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_28 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 648, __pyx_L1_error) + __pyx_t_24 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_24 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 631, __pyx_L1_error) - /* "l0learn/interface.pyx":649 + /* "l0learn/interface.pyx":632 * atol=atol, * ActiveSet=active_set, * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, */ - __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 649, __pyx_L1_error) + __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 632, __pyx_L1_error) - /* "l0learn/interface.pyx":650 + /* "l0learn/interface.pyx":633 * ActiveSet=active_set, * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, */ - __pyx_t_30 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_30 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 650, __pyx_L1_error) + __pyx_t_26 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_26 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 633, __pyx_L1_error) - /* "l0learn/interface.pyx":652 + /* "l0learn/interface.pyx":635 * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, # <<<<<<<<<<<<<< * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, */ - __pyx_t_31 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_31 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 652, __pyx_L1_error) + __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 635, __pyx_L1_error) + + /* "l0learn/interface.pyx":636 + * ScaleDownFactor=scale_down_factor, + * ScreenSize=screen_size, + * LambdaU=not auto_lambda, # <<<<<<<<<<<<<< + * Lambdas=c_lambda_grid, + * nfolds=num_folds, + */ + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 636, __pyx_L1_error) - /* "l0learn/interface.pyx":655 + /* "l0learn/interface.pyx":638 * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, * nfolds=num_folds, # <<<<<<<<<<<<<< * seed=seed, * ExcludeFirstK=exclude_first_k, */ - __pyx_t_32 = __Pyx_PyInt_As_unsigned_int(__pyx_v_num_folds); if (unlikely((__pyx_t_32 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 655, __pyx_L1_error) + __pyx_t_28 = __Pyx_PyInt_As_unsigned_int(__pyx_v_num_folds); if (unlikely((__pyx_t_28 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 638, __pyx_L1_error) - /* "l0learn/interface.pyx":656 + /* "l0learn/interface.pyx":639 * Lambdas=c_lambda_grid, * nfolds=num_folds, * seed=seed, # <<<<<<<<<<<<<< * ExcludeFirstK=exclude_first_k, * Intercept=intercept, */ - __pyx_t_14 = __pyx_PyFloat_AsDouble(__pyx_v_seed); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 656, __pyx_L1_error) + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_seed); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 639, __pyx_L1_error) - /* "l0learn/interface.pyx":657 + /* "l0learn/interface.pyx":640 * nfolds=num_folds, * seed=seed, * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< * Intercept=intercept, * withBounds=with_bounds, */ - __pyx_t_33 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_33 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 657, __pyx_L1_error) + __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 640, __pyx_L1_error) - /* "l0learn/interface.pyx":658 + /* "l0learn/interface.pyx":641 * seed=seed, * ExcludeFirstK=exclude_first_k, * Intercept=intercept, # <<<<<<<<<<<<<< * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), */ - __pyx_t_34 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_34 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 658, __pyx_L1_error) + __pyx_t_30 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_30 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 641, __pyx_L1_error) - /* "l0learn/interface.pyx":660 + /* "l0learn/interface.pyx":642 + * ExcludeFirstK=exclude_first_k, + * Intercept=intercept, + * withBounds=with_bounds, # <<<<<<<<<<<<<< + * Lows=numpy_to_dvec_d(lows), + * Highs=numpy_to_dvec_d(highs)) + */ + __pyx_t_31 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_31 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 642, __pyx_L1_error) + + /* "l0learn/interface.pyx":643 * Intercept=intercept, * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< * Highs=numpy_to_dvec_d(highs)) * else: # isinstance(X, csc_matrix) */ - if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 660, __pyx_L1_error) + if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 643, __pyx_L1_error) - /* "l0learn/interface.pyx":661 + /* "l0learn/interface.pyx":644 * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< * else: # isinstance(X, csc_matrix) * c_results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), */ - if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 661, __pyx_L1_error) + if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 644, __pyx_L1_error) - /* "l0learn/interface.pyx":634 + /* "l0learn/interface.pyx":617 * cdef cvfitmodel c_results * if isinstance(X, np.ndarray): * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< * y=numpy_to_dvec_d(y), * Loss=c_loss, */ - __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnCV_dense(__pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_X)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_23, __pyx_t_24, __pyx_t_25, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_26, __pyx_t_27, __pyx_v_rtol, __pyx_v_atol, __pyx_t_28, __pyx_t_29, __pyx_t_30, __pyx_v_scale_down_factor, __pyx_t_31, (!(__pyx_v_auto_lambda != 0)), __pyx_v_c_lambda_grid, __pyx_t_32, __pyx_t_14, __pyx_t_33, __pyx_t_34, __pyx_v_with_bounds, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); + __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnCV_dense(__pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_X)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_19, __pyx_t_20, __pyx_t_21, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_22, __pyx_t_23, __pyx_v_rtol, __pyx_v_atol, __pyx_t_24, __pyx_t_25, __pyx_t_26, __pyx_v_scale_down_factor, __pyx_t_27, (!__pyx_t_9), __pyx_v_c_lambda_grid, __pyx_t_28, __pyx_t_4, __pyx_t_29, __pyx_t_30, __pyx_t_31, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); - /* "l0learn/interface.pyx":633 + /* "l0learn/interface.pyx":616 * * cdef cvfitmodel c_results * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), * y=numpy_to_dvec_d(y), */ - goto __pyx_L110; + goto __pyx_L17; } - /* "l0learn/interface.pyx":663 + /* "l0learn/interface.pyx":646 * Highs=numpy_to_dvec_d(highs)) * else: # isinstance(X, csc_matrix) * c_results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< @@ -11489,291 +9864,309 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ /*else*/ { - /* "l0learn/interface.pyx":664 + /* "l0learn/interface.pyx":647 * else: # isinstance(X, csc_matrix) * c_results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), * y=numpy_to_dvec_d(y), # <<<<<<<<<<<<<< * Loss=c_loss, * Penalty=c_penalty, */ - if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 664, __pyx_L1_error) + if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 647, __pyx_L1_error) - /* "l0learn/interface.pyx":668 + /* "l0learn/interface.pyx":651 * Penalty=c_penalty, * Algorithm=c_algorithim, * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< * G_ncols=num_lambda, * G_nrows=num_gamma, */ - __pyx_t_33 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_33 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 668, __pyx_L1_error) + __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 651, __pyx_L1_error) - /* "l0learn/interface.pyx":669 + /* "l0learn/interface.pyx":652 * Algorithm=c_algorithim, * NnzStopNum=max_support_size, * G_ncols=num_lambda, # <<<<<<<<<<<<<< * G_nrows=num_gamma, * Lambda2Max=gamma_max, */ - __pyx_t_31 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_31 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 669, __pyx_L1_error) + __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 652, __pyx_L1_error) - /* "l0learn/interface.pyx":670 + /* "l0learn/interface.pyx":653 * NnzStopNum=max_support_size, * G_ncols=num_lambda, * G_nrows=num_gamma, # <<<<<<<<<<<<<< * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, */ - __pyx_t_30 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_30 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 670, __pyx_L1_error) + __pyx_t_26 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_26 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 653, __pyx_L1_error) - /* "l0learn/interface.pyx":673 + /* "l0learn/interface.pyx":656 * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, * PartialSort=partial_sort, # <<<<<<<<<<<<<< * MaxIters=max_iter, * rtol=rtol, */ - __pyx_t_34 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_34 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 673, __pyx_L1_error) + __pyx_t_31 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_31 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 656, __pyx_L1_error) - /* "l0learn/interface.pyx":674 + /* "l0learn/interface.pyx":657 * Lambda2Min=gamma_min, * PartialSort=partial_sort, * MaxIters=max_iter, # <<<<<<<<<<<<<< * rtol=rtol, * atol=atol, */ - __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 674, __pyx_L1_error) + __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 657, __pyx_L1_error) - /* "l0learn/interface.pyx":677 + /* "l0learn/interface.pyx":660 * rtol=rtol, * atol=atol, * ActiveSet=active_set, # <<<<<<<<<<<<<< * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, */ - __pyx_t_28 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_28 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 677, __pyx_L1_error) + __pyx_t_30 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_30 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 660, __pyx_L1_error) - /* "l0learn/interface.pyx":678 + /* "l0learn/interface.pyx":661 * atol=atol, * ActiveSet=active_set, * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, */ - __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 678, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 661, __pyx_L1_error) - /* "l0learn/interface.pyx":679 + /* "l0learn/interface.pyx":662 * ActiveSet=active_set, * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, */ - __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 679, __pyx_L1_error) + __pyx_t_21 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_21 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 662, __pyx_L1_error) - /* "l0learn/interface.pyx":681 + /* "l0learn/interface.pyx":664 * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, # <<<<<<<<<<<<<< * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, */ - __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 681, __pyx_L1_error) + __pyx_t_20 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_20 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 664, __pyx_L1_error) + + /* "l0learn/interface.pyx":665 + * ScaleDownFactor=scale_down_factor, + * ScreenSize=screen_size, + * LambdaU=not auto_lambda, # <<<<<<<<<<<<<< + * Lambdas=c_lambda_grid, + * nfolds=num_folds, + */ + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 665, __pyx_L1_error) - /* "l0learn/interface.pyx":684 + /* "l0learn/interface.pyx":667 * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, * nfolds=num_folds, # <<<<<<<<<<<<<< * seed=seed, * ExcludeFirstK=exclude_first_k, */ - __pyx_t_32 = __Pyx_PyInt_As_unsigned_int(__pyx_v_num_folds); if (unlikely((__pyx_t_32 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 684, __pyx_L1_error) + __pyx_t_28 = __Pyx_PyInt_As_unsigned_int(__pyx_v_num_folds); if (unlikely((__pyx_t_28 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 667, __pyx_L1_error) - /* "l0learn/interface.pyx":685 + /* "l0learn/interface.pyx":668 * Lambdas=c_lambda_grid, * nfolds=num_folds, * seed=seed, # <<<<<<<<<<<<<< * ExcludeFirstK=exclude_first_k, * Intercept=intercept, */ - __pyx_t_14 = __pyx_PyFloat_AsDouble(__pyx_v_seed); if (unlikely((__pyx_t_14 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 685, __pyx_L1_error) + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_seed); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 668, __pyx_L1_error) - /* "l0learn/interface.pyx":686 + /* "l0learn/interface.pyx":669 * nfolds=num_folds, * seed=seed, * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< * Intercept=intercept, * withBounds=with_bounds, */ - __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 686, __pyx_L1_error) + __pyx_t_19 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_19 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 669, __pyx_L1_error) - /* "l0learn/interface.pyx":687 + /* "l0learn/interface.pyx":670 * seed=seed, * ExcludeFirstK=exclude_first_k, * Intercept=intercept, # <<<<<<<<<<<<<< * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), */ - __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 687, __pyx_L1_error) + __pyx_t_24 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_24 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 670, __pyx_L1_error) + + /* "l0learn/interface.pyx":671 + * ExcludeFirstK=exclude_first_k, + * Intercept=intercept, + * withBounds=with_bounds, # <<<<<<<<<<<<<< + * Lows=numpy_to_dvec_d(lows), + * Highs=numpy_to_dvec_d(highs)) + */ + __pyx_t_22 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_22 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 671, __pyx_L1_error) - /* "l0learn/interface.pyx":689 + /* "l0learn/interface.pyx":672 * Intercept=intercept, * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< * Highs=numpy_to_dvec_d(highs)) * */ - if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 689, __pyx_L1_error) + if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 672, __pyx_L1_error) - /* "l0learn/interface.pyx":690 + /* "l0learn/interface.pyx":673 * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< * * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, */ - if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 690, __pyx_L1_error) + if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 673, __pyx_L1_error) - /* "l0learn/interface.pyx":663 + /* "l0learn/interface.pyx":646 * Highs=numpy_to_dvec_d(highs)) * else: # isinstance(X, csc_matrix) * c_results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< * y=numpy_to_dvec_d(y), * Loss=c_loss, */ - __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnCV_sparse(__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(__pyx_v_X), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_33, __pyx_t_31, __pyx_t_30, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_34, __pyx_t_29, __pyx_v_rtol, __pyx_v_atol, __pyx_t_28, __pyx_t_27, __pyx_t_25, __pyx_v_scale_down_factor, __pyx_t_24, (!(__pyx_v_auto_lambda != 0)), __pyx_v_c_lambda_grid, __pyx_t_32, __pyx_t_14, __pyx_t_23, __pyx_t_26, __pyx_v_with_bounds, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); + __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnCV_sparse(__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(__pyx_v_X), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_29, __pyx_t_27, __pyx_t_26, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_31, __pyx_t_25, __pyx_v_rtol, __pyx_v_atol, __pyx_t_30, __pyx_t_23, __pyx_t_21, __pyx_v_scale_down_factor, __pyx_t_20, (!__pyx_t_9), __pyx_v_c_lambda_grid, __pyx_t_28, __pyx_t_4, __pyx_t_19, __pyx_t_24, __pyx_t_22, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); } - __pyx_L110:; + __pyx_L17:; - /* "l0learn/interface.pyx":692 + /* "l0learn/interface.pyx":675 * Highs=numpy_to_dvec_d(highs)) * * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, # <<<<<<<<<<<<<< * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, */ - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_CVFitModel); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 692, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = __Pyx_PyDict_NewPresized(9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 692, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_3 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 692, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_CVFitModel); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 675, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyDict_NewPresized(9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 675, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 675, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 692, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 692, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 692, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_settings, __pyx_t_3) < 0) __PYX_ERR(0, 692, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 675, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 675, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 675, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_settings, __pyx_t_3) < 0) __PYX_ERR(0, 675, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":693 + /* "l0learn/interface.pyx":676 * * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, * lambda_0=c_results.Lambda0, # <<<<<<<<<<<<<< * gamma=c_results.Lambda12, * support_size=c_results.NnzCount, */ - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Lambda0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 693, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Lambda0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 676, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_lambda_0, __pyx_t_3) < 0) __PYX_ERR(0, 692, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lambda_0, __pyx_t_3) < 0) __PYX_ERR(0, 675, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":694 + /* "l0learn/interface.pyx":677 * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, # <<<<<<<<<<<<<< * support_size=c_results.NnzCount, * coeffs=sp_dmat_field_to_list(c_results.Beta), */ - __pyx_t_3 = __pyx_convert_vector_to_py_double(__pyx_v_c_results.Lambda12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 694, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_double(__pyx_v_c_results.Lambda12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 677, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_gamma, __pyx_t_3) < 0) __PYX_ERR(0, 692, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma, __pyx_t_3) < 0) __PYX_ERR(0, 675, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":695 + /* "l0learn/interface.pyx":678 * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, * support_size=c_results.NnzCount, # <<<<<<<<<<<<<< * coeffs=sp_dmat_field_to_list(c_results.Beta), * intercepts=c_results.Intercept, */ - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(__pyx_v_c_results.NnzCount); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 695, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(__pyx_v_c_results.NnzCount); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 678, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_support_size, __pyx_t_3) < 0) __PYX_ERR(0, 692, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_support_size, __pyx_t_3) < 0) __PYX_ERR(0, 675, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":696 + /* "l0learn/interface.pyx":679 * gamma=c_results.Lambda12, * support_size=c_results.NnzCount, * coeffs=sp_dmat_field_to_list(c_results.Beta), # <<<<<<<<<<<<<< * intercepts=c_results.Intercept, * converged=c_results.Converged, */ - __pyx_t_3 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_c_results.Beta); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 696, __pyx_L1_error) + __pyx_t_3 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_c_results.Beta); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 679, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_coeffs, __pyx_t_3) < 0) __PYX_ERR(0, 692, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_coeffs, __pyx_t_3) < 0) __PYX_ERR(0, 675, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":697 + /* "l0learn/interface.pyx":680 * support_size=c_results.NnzCount, * coeffs=sp_dmat_field_to_list(c_results.Beta), * intercepts=c_results.Intercept, # <<<<<<<<<<<<<< * converged=c_results.Converged, * cv_means=dvec_field_to_list(c_results.CVMeans), */ - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Intercept); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 697, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Intercept); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 680, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_intercepts, __pyx_t_3) < 0) __PYX_ERR(0, 692, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_intercepts, __pyx_t_3) < 0) __PYX_ERR(0, 675, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":698 + /* "l0learn/interface.pyx":681 * coeffs=sp_dmat_field_to_list(c_results.Beta), * intercepts=c_results.Intercept, * converged=c_results.Converged, # <<<<<<<<<<<<<< * cv_means=dvec_field_to_list(c_results.CVMeans), * cv_sds=dvec_field_to_list(c_results.CVSDs)) */ - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(__pyx_v_c_results.Converged); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 698, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(__pyx_v_c_results.Converged); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 681, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_converged, __pyx_t_3) < 0) __PYX_ERR(0, 692, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_converged, __pyx_t_3) < 0) __PYX_ERR(0, 675, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":699 + /* "l0learn/interface.pyx":682 * intercepts=c_results.Intercept, * converged=c_results.Converged, * cv_means=dvec_field_to_list(c_results.CVMeans), # <<<<<<<<<<<<<< * cv_sds=dvec_field_to_list(c_results.CVSDs)) * return results */ - __pyx_t_3 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_c_results.CVMeans); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 699, __pyx_L1_error) + __pyx_t_3 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_c_results.CVMeans); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 682, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_cv_means, __pyx_t_3) < 0) __PYX_ERR(0, 692, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_cv_means, __pyx_t_3) < 0) __PYX_ERR(0, 675, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":700 + /* "l0learn/interface.pyx":683 * converged=c_results.Converged, * cv_means=dvec_field_to_list(c_results.CVMeans), * cv_sds=dvec_field_to_list(c_results.CVSDs)) # <<<<<<<<<<<<<< * return results * */ - __pyx_t_3 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_c_results.CVSDs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 700, __pyx_L1_error) + __pyx_t_3 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_c_results.CVSDs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 683, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_cv_sds, __pyx_t_3) < 0) __PYX_ERR(0, 692, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_cv_sds, __pyx_t_3) < 0) __PYX_ERR(0, 675, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":692 + /* "l0learn/interface.pyx":675 * Highs=numpy_to_dvec_d(highs)) * * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, # <<<<<<<<<<<<<< * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_empty_tuple, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 692, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 675, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_results = __pyx_t_3; __pyx_t_3 = 0; - /* "l0learn/interface.pyx":701 + /* "l0learn/interface.pyx":684 * cv_means=dvec_field_to_list(c_results.CVMeans), * cv_sds=dvec_field_to_list(c_results.CVSDs)) * return results # <<<<<<<<<<<<<< @@ -11785,37 +10178,36 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_r = __pyx_v_results; goto __pyx_L0; - /* "l0learn/interface.pyx":444 + /* "l0learn/interface.pyx":533 * * * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< * y: np.ndarray, - * loss: str = "SquaredHinge", + * loss: str = "SquaredError", */ /* function exit code */ __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_XDECREF(__pyx_t_16); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_17); __Pyx_AddTraceback("l0learn.interface.cvfit", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF(__pyx_v_n); - __Pyx_XDECREF(__pyx_v_p); - __Pyx_XDECREF(__pyx_v_unique_items); - __Pyx_XDECREF(__pyx_v_a); + __Pyx_XDECREF(__pyx_v_check); + __Pyx_XDECREF(__pyx_v_auto_lambda); + __Pyx_XDECREF(__pyx_v_with_bounds); __Pyx_XDECREF(__pyx_v__); - __Pyx_XDECREF(__pyx_v_i); - __Pyx_XDECREF(__pyx_v_sub_lambda_grid); - __Pyx_XDECREF(__pyx_v_bad_bounds); + __Pyx_XDECREF(__pyx_v_p); __Pyx_XDECREF(__pyx_v_results); __Pyx_XDECREF(__pyx_v_y); __Pyx_XDECREF(__pyx_v_penalty); + __Pyx_XDECREF(__pyx_v_max_support_size); __Pyx_XDECREF(__pyx_v_num_lambda); __Pyx_XDECREF(__pyx_v_num_gamma); + __Pyx_XDECREF(__pyx_v_screen_size); __Pyx_XDECREF(__pyx_v_lambda_grid); __Pyx_XDECREF(__pyx_v_lows); __Pyx_XDECREF(__pyx_v_highs); @@ -11824,7 +10216,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p return __pyx_r; } -/* "l0learn/interface.pyx":704 +/* "l0learn/interface.pyx":687 * * * cdef fitmodel _L0LearnFit_dense(const dmat& X, # <<<<<<<<<<<<<< @@ -11837,7 +10229,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_dense(arma::dmat const & __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_L0LearnFit_dense", 0); - /* "l0learn/interface.pyx":730 + /* "l0learn/interface.pyx":713 * const dvec &Lows, * const dvec &Highs): * return L0LearnFit[dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< @@ -11847,7 +10239,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_dense(arma::dmat const & __pyx_r = L0LearnFit(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); goto __pyx_L0; - /* "l0learn/interface.pyx":704 + /* "l0learn/interface.pyx":687 * * * cdef fitmodel _L0LearnFit_dense(const dmat& X, # <<<<<<<<<<<<<< @@ -11861,7 +10253,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_dense(arma::dmat const & return __pyx_r; } -/* "l0learn/interface.pyx":735 +/* "l0learn/interface.pyx":718 * * * cdef fitmodel _L0LearnFit_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< @@ -11874,7 +10266,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_sparse(arma::sp_dmat con __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_L0LearnFit_sparse", 0); - /* "l0learn/interface.pyx":761 + /* "l0learn/interface.pyx":744 * const dvec &Lows, * const dvec &Highs): * return L0LearnFit[sp_dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< @@ -11884,7 +10276,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_sparse(arma::sp_dmat con __pyx_r = L0LearnFit(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); goto __pyx_L0; - /* "l0learn/interface.pyx":735 + /* "l0learn/interface.pyx":718 * * * cdef fitmodel _L0LearnFit_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< @@ -11898,7 +10290,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_sparse(arma::sp_dmat con return __pyx_r; } -/* "l0learn/interface.pyx":766 +/* "l0learn/interface.pyx":749 * * * cdef cvfitmodel _L0LearnCV_dense(const dmat& X, # <<<<<<<<<<<<<< @@ -11911,7 +10303,7 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_dense(arma::dmat const __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_L0LearnCV_dense", 0); - /* "l0learn/interface.pyx":794 + /* "l0learn/interface.pyx":777 * const dvec &Lows, * const dvec &Highs): * return L0LearnCV[dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< @@ -11921,7 +10313,7 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_dense(arma::dmat const __pyx_r = L0LearnCV(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_nfolds, __pyx_v_seed, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); goto __pyx_L0; - /* "l0learn/interface.pyx":766 + /* "l0learn/interface.pyx":749 * * * cdef cvfitmodel _L0LearnCV_dense(const dmat& X, # <<<<<<<<<<<<<< @@ -11935,7 +10327,7 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_dense(arma::dmat const return __pyx_r; } -/* "l0learn/interface.pyx":799 +/* "l0learn/interface.pyx":782 * * * cdef cvfitmodel _L0LearnCV_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< @@ -11948,7 +10340,7 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_sparse(arma::sp_dmat co __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_L0LearnCV_sparse", 0); - /* "l0learn/interface.pyx":827 + /* "l0learn/interface.pyx":810 * const dvec &Lows, * const dvec &Highs): * return L0LearnCV[sp_dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< @@ -11958,7 +10350,7 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_sparse(arma::sp_dmat co __pyx_r = L0LearnCV(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_nfolds, __pyx_v_seed, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); goto __pyx_L0; - /* "l0learn/interface.pyx":799 + /* "l0learn/interface.pyx":782 * * * cdef cvfitmodel _L0LearnCV_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< @@ -13686,10 +12078,12 @@ static struct PyModuleDef __pyx_moduledef = { #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_Any, __pyx_k_Any, sizeof(__pyx_k_Any), 0, 0, 1, 1}, {&__pyx_n_u_CD, __pyx_k_CD, sizeof(__pyx_k_CD), 0, 1, 0, 1}, {&__pyx_n_u_CDPSI, __pyx_k_CDPSI, sizeof(__pyx_k_CDPSI), 0, 1, 0, 1}, {&__pyx_n_s_CLASSIFICATION_LOSS, __pyx_k_CLASSIFICATION_LOSS, sizeof(__pyx_k_CLASSIFICATION_LOSS), 0, 0, 1, 1}, {&__pyx_n_s_CVFitModel, __pyx_k_CVFitModel, sizeof(__pyx_k_CVFitModel), 0, 0, 1, 1}, + {&__pyx_n_s_Dict, __pyx_k_Dict, sizeof(__pyx_k_Dict), 0, 0, 1, 1}, {&__pyx_kp_u_Expected_all_values_of_lambda_gr, __pyx_k_Expected_all_values_of_lambda_gr, sizeof(__pyx_k_Expected_all_values_of_lambda_gr), 0, 1, 0, 0}, {&__pyx_kp_u_Expected_each_element_of_lambda, __pyx_k_Expected_each_element_of_lambda, sizeof(__pyx_k_Expected_each_element_of_lambda), 0, 1, 0, 0}, {&__pyx_n_u_F_CONTIGUOUS, __pyx_k_F_CONTIGUOUS, sizeof(__pyx_k_F_CONTIGUOUS), 0, 1, 0, 1}, @@ -13725,8 +12119,10 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_argwhere, __pyx_k_argwhere, sizeof(__pyx_k_argwhere), 0, 0, 1, 1}, {&__pyx_n_s_arr, __pyx_k_arr, sizeof(__pyx_k_arr), 0, 0, 1, 1}, {&__pyx_n_s_array, __pyx_k_array, sizeof(__pyx_k_array), 0, 0, 1, 1}, + {&__pyx_n_s_astype, __pyx_k_astype, sizeof(__pyx_k_astype), 0, 0, 1, 1}, {&__pyx_n_s_atol, __pyx_k_atol, sizeof(__pyx_k_atol), 0, 0, 1, 1}, {&__pyx_n_s_auto_lambda, __pyx_k_auto_lambda, sizeof(__pyx_k_auto_lambda), 0, 0, 1, 1}, + {&__pyx_n_u_auto_lambda, __pyx_k_auto_lambda, sizeof(__pyx_k_auto_lambda), 0, 1, 0, 1}, {&__pyx_n_s_bad_bounds, __pyx_k_bad_bounds, sizeof(__pyx_k_bad_bounds), 0, 0, 1, 1}, {&__pyx_n_s_bad_lambda_grid, __pyx_k_bad_lambda_grid, sizeof(__pyx_k_bad_lambda_grid), 0, 0, 1, 1}, {&__pyx_kp_u_but_got, __pyx_k_but_got, sizeof(__pyx_k_but_got), 0, 1, 0, 0}, @@ -13735,10 +12131,12 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_c_loss, __pyx_k_c_loss, sizeof(__pyx_k_c_loss), 0, 0, 1, 1}, {&__pyx_n_s_c_penalty, __pyx_k_c_penalty, sizeof(__pyx_k_c_penalty), 0, 0, 1, 1}, {&__pyx_n_s_c_results, __pyx_k_c_results, sizeof(__pyx_k_c_results), 0, 0, 1, 1}, + {&__pyx_n_s_check, __pyx_k_check, sizeof(__pyx_k_check), 0, 0, 1, 1}, {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, {&__pyx_n_s_coeffs, __pyx_k_coeffs, sizeof(__pyx_k_coeffs), 0, 0, 1, 1}, {&__pyx_kp_u_containing_a_negative_value, __pyx_k_containing_a_negative_value, sizeof(__pyx_k_containing_a_negative_value), 0, 1, 0, 0}, {&__pyx_kp_u_containing_an_increasing_value, __pyx_k_containing_an_increasing_value, sizeof(__pyx_k_containing_an_increasing_value), 0, 1, 0, 0}, + {&__pyx_n_s_contiguous, __pyx_k_contiguous, sizeof(__pyx_k_contiguous), 0, 0, 1, 1}, {&__pyx_n_s_converged, __pyx_k_converged, sizeof(__pyx_k_converged), 0, 0, 1, 1}, {&__pyx_n_s_copy, __pyx_k_copy, sizeof(__pyx_k_copy), 0, 0, 1, 1}, {&__pyx_n_s_csc_matrix, __pyx_k_csc_matrix, sizeof(__pyx_k_csc_matrix), 0, 0, 1, 1}, @@ -13751,7 +12149,7 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1}, {&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1}, {&__pyx_n_s_exclude_first_k, __pyx_k_exclude_first_k, sizeof(__pyx_k_exclude_first_k), 0, 0, 1, 1}, - {&__pyx_kp_u_expected_X_to_be_a_2D_non_degene, __pyx_k_expected_X_to_be_a_2D_non_degene, sizeof(__pyx_k_expected_X_to_be_a_2D_non_degene), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_X_to_be_a_2D_continuous, __pyx_k_expected_X_to_be_a_2D_continuous, sizeof(__pyx_k_expected_X_to_be_a_2D_continuous), 0, 1, 0, 0}, {&__pyx_kp_u_expected_active_set_num_paramete, __pyx_k_expected_active_set_num_paramete, sizeof(__pyx_k_expected_active_set_num_paramete), 0, 1, 0, 0}, {&__pyx_kp_u_expected_active_set_parameter_to, __pyx_k_expected_active_set_parameter_to, sizeof(__pyx_k_expected_active_set_parameter_to), 0, 1, 0, 0}, {&__pyx_kp_u_expected_algorithm_parameter_to, __pyx_k_expected_algorithm_parameter_to, sizeof(__pyx_k_expected_algorithm_parameter_to), 0, 1, 0, 0}, @@ -13791,17 +12189,22 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_kp_u_expected_rtol_parameter_to_exist, __pyx_k_expected_rtol_parameter_to_exist, sizeof(__pyx_k_expected_rtol_parameter_to_exist), 0, 1, 0, 0}, {&__pyx_kp_u_expected_scale_down_factor_param, __pyx_k_expected_scale_down_factor_param, sizeof(__pyx_k_expected_scale_down_factor_param), 0, 1, 0, 0}, {&__pyx_kp_u_expected_screen_size_parameter_t, __pyx_k_expected_screen_size_parameter_t, sizeof(__pyx_k_expected_screen_size_parameter_t), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_screen_size_parameter_t_2, __pyx_k_expected_screen_size_parameter_t_2, sizeof(__pyx_k_expected_screen_size_parameter_t_2), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_seed_parameter_to_be_an, __pyx_k_expected_seed_parameter_to_be_an, sizeof(__pyx_k_expected_seed_parameter_to_be_an), 0, 1, 0, 0}, {&__pyx_kp_u_expected_to_be_high_to_be_elemen, __pyx_k_expected_to_be_high_to_be_elemen, sizeof(__pyx_k_expected_to_be_high_to_be_elemen), 0, 1, 0, 0}, {&__pyx_kp_u_expected_y_to_be_a_1D_real_numpy, __pyx_k_expected_y_to_be_a_1D_real_numpy, sizeof(__pyx_k_expected_y_to_be_a_1D_real_numpy), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_y_vector_to_have_type, __pyx_k_expected_y_vector_to_have_type, sizeof(__pyx_k_expected_y_vector_to_have_type), 0, 1, 0, 0}, {&__pyx_kp_u_expected_y_vector_to_only_have_t, __pyx_k_expected_y_vector_to_only_have_t, sizeof(__pyx_k_expected_y_vector_to_only_have_t), 0, 1, 0, 0}, + {&__pyx_n_s_first_value, __pyx_k_first_value, sizeof(__pyx_k_first_value), 0, 0, 1, 1}, {&__pyx_n_s_fit, __pyx_k_fit, sizeof(__pyx_k_fit), 0, 0, 1, 1}, + {&__pyx_n_s_fit_check, __pyx_k_fit_check, sizeof(__pyx_k_fit_check), 0, 0, 1, 1}, {&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 1}, + {&__pyx_n_s_float64, __pyx_k_float64, sizeof(__pyx_k_float64), 0, 0, 1, 1}, {&__pyx_n_s_gamma, __pyx_k_gamma, sizeof(__pyx_k_gamma), 0, 0, 1, 1}, {&__pyx_n_s_gamma_max, __pyx_k_gamma_max, sizeof(__pyx_k_gamma_max), 0, 0, 1, 1}, + {&__pyx_n_u_gamma_max, __pyx_k_gamma_max, sizeof(__pyx_k_gamma_max), 0, 1, 0, 1}, {&__pyx_n_s_gamma_min, __pyx_k_gamma_min, sizeof(__pyx_k_gamma_min), 0, 0, 1, 1}, + {&__pyx_n_u_gamma_min, __pyx_k_gamma_min, sizeof(__pyx_k_gamma_min), 0, 1, 0, 1}, {&__pyx_n_s_highs, __pyx_k_highs, sizeof(__pyx_k_highs), 0, 0, 1, 1}, + {&__pyx_n_u_highs, __pyx_k_highs, sizeof(__pyx_k_highs), 0, 1, 0, 1}, {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1}, {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, {&__pyx_n_s_indices, __pyx_k_indices, sizeof(__pyx_k_indices), 0, 0, 1, 1}, @@ -13812,17 +12215,21 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_intercepts, __pyx_k_intercepts, sizeof(__pyx_k_intercepts), 0, 0, 1, 1}, {&__pyx_n_s_isrealobj, __pyx_k_isrealobj, sizeof(__pyx_k_isrealobj), 0, 0, 1, 1}, {&__pyx_n_s_issubdtype, __pyx_k_issubdtype, sizeof(__pyx_k_issubdtype), 0, 0, 1, 1}, + {&__pyx_n_s_l0learn, __pyx_k_l0learn, sizeof(__pyx_k_l0learn), 0, 0, 1, 1}, {&__pyx_n_s_l0learn_interface, __pyx_k_l0learn_interface, sizeof(__pyx_k_l0learn_interface), 0, 0, 1, 1}, {&__pyx_kp_s_l0learn_interface_pyx, __pyx_k_l0learn_interface_pyx, sizeof(__pyx_k_l0learn_interface_pyx), 0, 0, 1, 0}, {&__pyx_n_s_l0learn_models, __pyx_k_l0learn_models, sizeof(__pyx_k_l0learn_models), 0, 0, 1, 1}, {&__pyx_n_s_lambda_0, __pyx_k_lambda_0, sizeof(__pyx_k_lambda_0), 0, 0, 1, 1}, {&__pyx_n_s_lambda_grid, __pyx_k_lambda_grid, sizeof(__pyx_k_lambda_grid), 0, 0, 1, 1}, + {&__pyx_n_u_lambda_grid, __pyx_k_lambda_grid, sizeof(__pyx_k_lambda_grid), 0, 1, 0, 1}, {&__pyx_n_s_loss, __pyx_k_loss, sizeof(__pyx_k_loss), 0, 0, 1, 1}, {&__pyx_n_u_loss, __pyx_k_loss, sizeof(__pyx_k_loss), 0, 1, 0, 1}, {&__pyx_n_s_lows, __pyx_k_lows, sizeof(__pyx_k_lows), 0, 0, 1, 1}, + {&__pyx_n_u_lows, __pyx_k_lows, sizeof(__pyx_k_lows), 0, 1, 0, 1}, {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, {&__pyx_n_s_max_iter, __pyx_k_max_iter, sizeof(__pyx_k_max_iter), 0, 0, 1, 1}, {&__pyx_n_s_max_support_size, __pyx_k_max_support_size, sizeof(__pyx_k_max_support_size), 0, 0, 1, 1}, + {&__pyx_n_u_max_support_size, __pyx_k_max_support_size, sizeof(__pyx_k_max_support_size), 0, 1, 0, 1}, {&__pyx_n_s_max_swaps, __pyx_k_max_swaps, sizeof(__pyx_k_max_swaps), 0, 0, 1, 1}, {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1}, {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, @@ -13832,8 +12239,10 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_np_to_arma_check, __pyx_k_np_to_arma_check, sizeof(__pyx_k_np_to_arma_check), 0, 0, 1, 1}, {&__pyx_n_s_num_folds, __pyx_k_num_folds, sizeof(__pyx_k_num_folds), 0, 0, 1, 1}, {&__pyx_n_s_num_gamma, __pyx_k_num_gamma, sizeof(__pyx_k_num_gamma), 0, 0, 1, 1}, + {&__pyx_n_u_num_gamma, __pyx_k_num_gamma, sizeof(__pyx_k_num_gamma), 0, 1, 0, 1}, {&__pyx_kp_u_num_gamma_set_to_1_with, __pyx_k_num_gamma_set_to_1_with, sizeof(__pyx_k_num_gamma_set_to_1_with), 0, 1, 0, 0}, {&__pyx_n_s_num_lambda, __pyx_k_num_lambda, sizeof(__pyx_k_num_lambda), 0, 0, 1, 1}, + {&__pyx_n_u_num_lambda, __pyx_k_num_lambda, sizeof(__pyx_k_num_lambda), 0, 1, 0, 1}, {&__pyx_n_s_number, __pyx_k_number, sizeof(__pyx_k_number), 0, 0, 1, 1}, {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, {&__pyx_kp_u_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 1, 0, 0}, @@ -13855,6 +12264,8 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_scale_down_factor, __pyx_k_scale_down_factor, sizeof(__pyx_k_scale_down_factor), 0, 0, 1, 1}, {&__pyx_n_s_scipy_sparse, __pyx_k_scipy_sparse, sizeof(__pyx_k_scipy_sparse), 0, 0, 1, 1}, {&__pyx_n_s_screen_size, __pyx_k_screen_size, sizeof(__pyx_k_screen_size), 0, 0, 1, 1}, + {&__pyx_n_u_screen_size, __pyx_k_screen_size, sizeof(__pyx_k_screen_size), 0, 1, 0, 1}, + {&__pyx_n_s_second_value, __pyx_k_second_value, sizeof(__pyx_k_second_value), 0, 0, 1, 1}, {&__pyx_n_s_seed, __pyx_k_seed, sizeof(__pyx_k_seed), 0, 0, 1, 1}, {&__pyx_n_s_settings, __pyx_k_settings, sizeof(__pyx_k_settings), 0, 0, 1, 1}, {&__pyx_n_s_shape, __pyx_k_shape, sizeof(__pyx_k_shape), 0, 0, 1, 1}, @@ -13868,16 +12279,18 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_warnings, __pyx_k_warnings, sizeof(__pyx_k_warnings), 0, 0, 1, 1}, {&__pyx_kp_u_where_that_is_not_the_case, __pyx_k_where_that_is_not_the_case, sizeof(__pyx_k_where_that_is_not_the_case), 0, 1, 0, 0}, {&__pyx_n_s_with_bounds, __pyx_k_with_bounds, sizeof(__pyx_k_with_bounds), 0, 0, 1, 1}, + {&__pyx_n_u_with_bounds, __pyx_k_with_bounds, sizeof(__pyx_k_with_bounds), 0, 1, 0, 1}, {&__pyx_n_s_y, __pyx_k_y, sizeof(__pyx_k_y), 0, 0, 1, 1}, + {&__pyx_n_u_y, __pyx_k_y, sizeof(__pyx_k_y), 0, 1, 0, 1}, {0, 0, 0, 0, 0, 0, 0} }; static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { - __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 19, __pyx_L1_error) - __pyx_builtin_NotImplementedError = __Pyx_GetBuiltinName(__pyx_n_s_NotImplementedError); if (!__pyx_builtin_NotImplementedError) __PYX_ERR(0, 28, __pyx_L1_error) - __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(0, 320, __pyx_L1_error) - __pyx_builtin_any = __Pyx_GetBuiltinName(__pyx_n_s_any); if (!__pyx_builtin_any) __PYX_ERR(0, 325, __pyx_L1_error) - __pyx_builtin_all = __Pyx_GetBuiltinName(__pyx_n_s_all); if (!__pyx_builtin_all) __PYX_ERR(0, 337, __pyx_L1_error) - __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 371, __pyx_L1_error) + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 20, __pyx_L1_error) + __pyx_builtin_NotImplementedError = __Pyx_GetBuiltinName(__pyx_n_s_NotImplementedError); if (!__pyx_builtin_NotImplementedError) __PYX_ERR(0, 29, __pyx_L1_error) + __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(0, 184, __pyx_L1_error) + __pyx_builtin_any = __Pyx_GetBuiltinName(__pyx_n_s_any); if (!__pyx_builtin_any) __PYX_ERR(0, 189, __pyx_L1_error) + __pyx_builtin_all = __Pyx_GetBuiltinName(__pyx_n_s_all); if (!__pyx_builtin_all) __PYX_ERR(0, 201, __pyx_L1_error) + __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 460, __pyx_L1_error) __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 945, __pyx_L1_error) __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(2, 61, __pyx_L1_error) return 0; @@ -13889,58 +12302,58 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - /* "l0learn/interface.pyx":19 + /* "l0learn/interface.pyx":20 * if isinstance(arr, np.ndarray): * if not arr.flags['F_CONTIGUOUS']: * raise ValueError("expected arr to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< * elif isinstance(arr, csc_matrix): * if not arr.data.flags['F_CONTIGUOUS']: */ - __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_expected_arr_to_be_F_CONTIGUOUS); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 19, __pyx_L1_error) + __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_expected_arr_to_be_F_CONTIGUOUS); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 20, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple_); __Pyx_GIVEREF(__pyx_tuple_); - /* "l0learn/interface.pyx":22 + /* "l0learn/interface.pyx":23 * elif isinstance(arr, csc_matrix): * if not arr.data.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.data to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< * if not arr.indices.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") */ - __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_data_to_be_F_CONTIG); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 22, __pyx_L1_error) + __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_data_to_be_F_CONTIG); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 23, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__2); __Pyx_GIVEREF(__pyx_tuple__2); - /* "l0learn/interface.pyx":24 + /* "l0learn/interface.pyx":25 * raise ValueError("expected arr.data to be F_CONTIGUOUS.") * if not arr.indices.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< * if not arr.indptr.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") */ - __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_indices_to_be_F_CON); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 24, __pyx_L1_error) + __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_indices_to_be_F_CON); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 25, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__3); __Pyx_GIVEREF(__pyx_tuple__3); - /* "l0learn/interface.pyx":26 + /* "l0learn/interface.pyx":27 * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") * if not arr.indptr.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< * else: * raise NotImplementedError(f"expected arr to be of type {np.ndarray} or {csc_matrix}, but got {type(arr)}.") */ - __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_indptr_to_be_F_CONT); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 26, __pyx_L1_error) + __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_indptr_to_be_F_CONT); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 27, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__4); __Pyx_GIVEREF(__pyx_tuple__4); - /* "l0learn/interface.pyx":31 + /* "l0learn/interface.pyx":32 * * if arr.ndim == 0: * raise ValueError("expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar") # <<<<<<<<<<<<<< * elif arr.ndim > 2: * raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") */ - __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_ndim_to_be_1_or_2_b); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 31, __pyx_L1_error) + __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_ndim_to_be_1_or_2_b); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 32, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__6); __Pyx_GIVEREF(__pyx_tuple__6); @@ -13966,74 +12379,86 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_GOTREF(__pyx_tuple__12); __Pyx_GIVEREF(__pyx_tuple__12); - /* "l0learn/interface.pyx":15 + /* "l0learn/interface.pyx":16 * from l0learn.models import FitModel, CVFitModel * * def np_to_arma_check(arr): # <<<<<<<<<<<<<< * # TODO: Add checks for Behaved and OwnsData * if isinstance(arr, np.ndarray): */ - __pyx_tuple__13 = PyTuple_Pack(1, __pyx_n_s_arr); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 15, __pyx_L1_error) + __pyx_tuple__13 = PyTuple_Pack(1, __pyx_n_s_arr); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 16, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__13); __Pyx_GIVEREF(__pyx_tuple__13); - __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_np_to_arma_check, 15, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(0, 15, __pyx_L1_error) + __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_np_to_arma_check, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(0, 16, __pyx_L1_error) - /* "l0learn/interface.pyx":45 + /* "l0learn/interface.pyx":46 * * * SUPPORTED_LOSS = ("SquaredError", "Logistic", "SquaredHinge") # <<<<<<<<<<<<<< * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") */ - __pyx_tuple__15 = PyTuple_Pack(3, __pyx_n_u_SquaredError, __pyx_n_u_Logistic, __pyx_n_u_SquaredHinge); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 45, __pyx_L1_error) + __pyx_tuple__15 = PyTuple_Pack(3, __pyx_n_u_SquaredError, __pyx_n_u_Logistic, __pyx_n_u_SquaredHinge); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 46, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__15); __Pyx_GIVEREF(__pyx_tuple__15); - /* "l0learn/interface.pyx":47 + /* "l0learn/interface.pyx":48 * SUPPORTED_LOSS = ("SquaredError", "Logistic", "SquaredHinge") * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") # <<<<<<<<<<<<<< * SUPPORTED_ALGORITHM = ("CD", "CDPSI") * */ - __pyx_tuple__16 = PyTuple_Pack(3, __pyx_n_u_L0, __pyx_n_u_L0L1, __pyx_n_u_L0L2); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 47, __pyx_L1_error) + __pyx_tuple__16 = PyTuple_Pack(3, __pyx_n_u_L0, __pyx_n_u_L0L1, __pyx_n_u_L0L2); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 48, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__16); __Pyx_GIVEREF(__pyx_tuple__16); - /* "l0learn/interface.pyx":48 + /* "l0learn/interface.pyx":49 * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") * SUPPORTED_ALGORITHM = ("CD", "CDPSI") # <<<<<<<<<<<<<< * - * def fit(X: Union[np.ndarray, csc_matrix], + * */ - __pyx_tuple__17 = PyTuple_Pack(2, __pyx_n_u_CD, __pyx_n_u_CDPSI); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(0, 48, __pyx_L1_error) + __pyx_tuple__17 = PyTuple_Pack(2, __pyx_n_u_CD, __pyx_n_u_CDPSI); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(0, 49, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__17); __Pyx_GIVEREF(__pyx_tuple__17); - /* "l0learn/interface.pyx":50 - * SUPPORTED_ALGORITHM = ("CD", "CDPSI") + /* "l0learn/interface.pyx":52 * - * def fit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< - * y: np.ndarray, - * loss: str = "SquaredHinge", + * + * def _fit_check(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< + * y: np.ndarray, + * loss: str, */ - __pyx_tuple__19 = PyTuple_Pack(42, __pyx_n_s_X, __pyx_n_s_y, __pyx_n_s_loss, __pyx_n_s_penalty, __pyx_n_s_algorithm, __pyx_n_s_max_support_size, __pyx_n_s_num_lambda, __pyx_n_s_num_gamma, __pyx_n_s_gamma_max, __pyx_n_s_gamma_min, __pyx_n_s_partial_sort, __pyx_n_s_max_iter, __pyx_n_s_rtol, __pyx_n_s_atol, __pyx_n_s_active_set, __pyx_n_s_active_set_num, __pyx_n_s_max_swaps, __pyx_n_s_scale_down_factor, __pyx_n_s_screen_size, __pyx_n_s_lambda_grid, __pyx_n_s_exclude_first_k, __pyx_n_s_intercept, __pyx_n_s_lows, __pyx_n_s_highs, __pyx_n_s_n, __pyx_n_s_p, __pyx_n_s_unique_items, __pyx_n_s_a, __pyx_n_s__18, __pyx_n_s_auto_lambda, __pyx_n_s_bad_lambda_grid, __pyx_n_s_i, __pyx_n_s_sub_lambda_grid, __pyx_n_s_current, __pyx_n_s_with_bounds, __pyx_n_s_bad_bounds, __pyx_n_s_c_lambda_grid, __pyx_n_s_c_loss, __pyx_n_s_c_penalty, __pyx_n_s_c_algorithim, __pyx_n_s_c_results, __pyx_n_s_results); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(0, 50, __pyx_L1_error) + __pyx_tuple__19 = PyTuple_Pack(38, __pyx_n_s_X, __pyx_n_s_y, __pyx_n_s_loss, __pyx_n_s_penalty, __pyx_n_s_algorithm, __pyx_n_s_max_support_size, __pyx_n_s_num_lambda, __pyx_n_s_num_gamma, __pyx_n_s_gamma_max, __pyx_n_s_gamma_min, __pyx_n_s_partial_sort, __pyx_n_s_max_iter, __pyx_n_s_rtol, __pyx_n_s_atol, __pyx_n_s_active_set, __pyx_n_s_active_set_num, __pyx_n_s_max_swaps, __pyx_n_s_scale_down_factor, __pyx_n_s_screen_size, __pyx_n_s_lambda_grid, __pyx_n_s_exclude_first_k, __pyx_n_s_intercept, __pyx_n_s_lows, __pyx_n_s_highs, __pyx_n_s_n, __pyx_n_s_p, __pyx_n_s_unique_items, __pyx_n_s_a, __pyx_n_s__18, __pyx_n_s_first_value, __pyx_n_s_second_value, __pyx_n_s_auto_lambda, __pyx_n_s_bad_lambda_grid, __pyx_n_s_i, __pyx_n_s_sub_lambda_grid, __pyx_n_s_current, __pyx_n_s_with_bounds, __pyx_n_s_bad_bounds); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(0, 52, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__19); __Pyx_GIVEREF(__pyx_tuple__19); - __pyx_codeobj__20 = (PyObject*)__Pyx_PyCode_New(24, 0, 42, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__19, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_fit, 50, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__20)) __PYX_ERR(0, 50, __pyx_L1_error) + __pyx_codeobj__20 = (PyObject*)__Pyx_PyCode_New(24, 0, 38, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__19, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_fit_check, 52, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__20)) __PYX_ERR(0, 52, __pyx_L1_error) - /* "l0learn/interface.pyx":444 + /* "l0learn/interface.pyx":247 * * - * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< - * y: np.ndarray, - * loss: str = "SquaredHinge", + * def fit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< + * y: np.ndarray, + * loss: str = "SquaredError", */ - __pyx_tuple__21 = PyTuple_Pack(44, __pyx_n_s_X, __pyx_n_s_y, __pyx_n_s_loss, __pyx_n_s_penalty, __pyx_n_s_algorithm, __pyx_n_s_num_folds, __pyx_n_s_seed, __pyx_n_s_max_support_size, __pyx_n_s_num_lambda, __pyx_n_s_num_gamma, __pyx_n_s_gamma_max, __pyx_n_s_gamma_min, __pyx_n_s_partial_sort, __pyx_n_s_max_iter, __pyx_n_s_rtol, __pyx_n_s_atol, __pyx_n_s_active_set, __pyx_n_s_active_set_num, __pyx_n_s_max_swaps, __pyx_n_s_scale_down_factor, __pyx_n_s_screen_size, __pyx_n_s_lambda_grid, __pyx_n_s_exclude_first_k, __pyx_n_s_intercept, __pyx_n_s_lows, __pyx_n_s_highs, __pyx_n_s_n, __pyx_n_s_p, __pyx_n_s_unique_items, __pyx_n_s_a, __pyx_n_s__18, __pyx_n_s_auto_lambda, __pyx_n_s_bad_lambda_grid, __pyx_n_s_i, __pyx_n_s_sub_lambda_grid, __pyx_n_s_current, __pyx_n_s_with_bounds, __pyx_n_s_bad_bounds, __pyx_n_s_c_lambda_grid, __pyx_n_s_c_loss, __pyx_n_s_c_penalty, __pyx_n_s_c_algorithim, __pyx_n_s_c_results, __pyx_n_s_results); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(0, 444, __pyx_L1_error) + __pyx_tuple__21 = PyTuple_Pack(33, __pyx_n_s_X, __pyx_n_s_y, __pyx_n_s_loss, __pyx_n_s_penalty, __pyx_n_s_algorithm, __pyx_n_s_max_support_size, __pyx_n_s_num_lambda, __pyx_n_s_num_gamma, __pyx_n_s_gamma_max, __pyx_n_s_gamma_min, __pyx_n_s_partial_sort, __pyx_n_s_max_iter, __pyx_n_s_rtol, __pyx_n_s_atol, __pyx_n_s_active_set, __pyx_n_s_active_set_num, __pyx_n_s_max_swaps, __pyx_n_s_scale_down_factor, __pyx_n_s_screen_size, __pyx_n_s_lambda_grid, __pyx_n_s_exclude_first_k, __pyx_n_s_intercept, __pyx_n_s_lows, __pyx_n_s_highs, __pyx_n_s_check, __pyx_n_s_auto_lambda, __pyx_n_s_with_bounds, __pyx_n_s_c_lambda_grid, __pyx_n_s_c_loss, __pyx_n_s_c_penalty, __pyx_n_s_c_algorithim, __pyx_n_s_c_results, __pyx_n_s_results); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(0, 247, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__21); __Pyx_GIVEREF(__pyx_tuple__21); - __pyx_codeobj__22 = (PyObject*)__Pyx_PyCode_New(26, 0, 44, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__21, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_cvfit, 444, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__22)) __PYX_ERR(0, 444, __pyx_L1_error) + __pyx_codeobj__22 = (PyObject*)__Pyx_PyCode_New(24, 0, 33, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__21, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_fit, 247, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__22)) __PYX_ERR(0, 247, __pyx_L1_error) + + /* "l0learn/interface.pyx":533 + * + * + * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< + * y: np.ndarray, + * loss: str = "SquaredError", + */ + __pyx_tuple__23 = PyTuple_Pack(37, __pyx_n_s_X, __pyx_n_s_y, __pyx_n_s_loss, __pyx_n_s_penalty, __pyx_n_s_algorithm, __pyx_n_s_num_folds, __pyx_n_s_seed, __pyx_n_s_max_support_size, __pyx_n_s_num_lambda, __pyx_n_s_num_gamma, __pyx_n_s_gamma_max, __pyx_n_s_gamma_min, __pyx_n_s_partial_sort, __pyx_n_s_max_iter, __pyx_n_s_rtol, __pyx_n_s_atol, __pyx_n_s_active_set, __pyx_n_s_active_set_num, __pyx_n_s_max_swaps, __pyx_n_s_scale_down_factor, __pyx_n_s_screen_size, __pyx_n_s_lambda_grid, __pyx_n_s_exclude_first_k, __pyx_n_s_intercept, __pyx_n_s_lows, __pyx_n_s_highs, __pyx_n_s_check, __pyx_n_s_auto_lambda, __pyx_n_s_with_bounds, __pyx_n_s__18, __pyx_n_s_p, __pyx_n_s_c_lambda_grid, __pyx_n_s_c_loss, __pyx_n_s_c_penalty, __pyx_n_s_c_algorithim, __pyx_n_s_c_results, __pyx_n_s_results); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(0, 533, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__23); + __Pyx_GIVEREF(__pyx_tuple__23); + __pyx_codeobj__24 = (PyObject*)__Pyx_PyCode_New(26, 0, 37, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__23, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_cvfit, 533, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__24)) __PYX_ERR(0, 533, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; @@ -14044,6 +12469,8 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); __pyx_float_0_ = PyFloat_FromDouble(0.); if (unlikely(!__pyx_float_0_)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_float_1_0 = PyFloat_FromDouble(1.0); if (unlikely(!__pyx_float_1_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_float_neg_1_0 = PyFloat_FromDouble(-1.0); if (unlikely(!__pyx_float_neg_1_0)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error) @@ -14052,7 +12479,6 @@ static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { __pyx_int_100 = PyInt_FromLong(100); if (unlikely(!__pyx_int_100)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_200 = PyInt_FromLong(200); if (unlikely(!__pyx_int_200)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_int_1000 = PyInt_FromLong(1000); if (unlikely(!__pyx_int_1000)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; @@ -14441,7 +12867,7 @@ if (!__Pyx_RefNanny) { * from scipy.sparse import csc_matrix * from warnings import warn # <<<<<<<<<<<<<< * - * from typing import Union, Optional, List + * from typing import Union, Optional, List, Dict, Any */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); @@ -14460,11 +12886,11 @@ if (!__Pyx_RefNanny) { /* "l0learn/interface.pyx":8 * from warnings import warn * - * from typing import Union, Optional, List # <<<<<<<<<<<<<< + * from typing import Union, Optional, List, Dict, Any # <<<<<<<<<<<<<< * * from l0learn.cyarma cimport dmat, sp_dmat, numpy_to_sp_dmat_d, numpy_to_dmat_d, dvec, numpy_to_dvec_d, \ */ - __pyx_t_1 = PyList_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) + __pyx_t_1 = PyList_New(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_Union); __Pyx_GIVEREF(__pyx_n_s_Union); @@ -14475,6 +12901,12 @@ if (!__Pyx_RefNanny) { __Pyx_INCREF(__pyx_n_s_List); __Pyx_GIVEREF(__pyx_n_s_List); PyList_SET_ITEM(__pyx_t_1, 2, __pyx_n_s_List); + __Pyx_INCREF(__pyx_n_s_Dict); + __Pyx_GIVEREF(__pyx_n_s_Dict); + PyList_SET_ITEM(__pyx_t_1, 3, __pyx_n_s_Dict); + __Pyx_INCREF(__pyx_n_s_Any); + __Pyx_GIVEREF(__pyx_n_s_Any); + PyList_SET_ITEM(__pyx_t_1, 4, __pyx_n_s_Any); __pyx_t_2 = __Pyx_Import(__pyx_n_s_typing, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -14490,16 +12922,36 @@ if (!__Pyx_RefNanny) { __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_List, __pyx_t_1) < 0) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Dict); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Dict, __pyx_t_1) < 0) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Any); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Any, __pyx_t_1) < 0) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "l0learn/interface.pyx":13 * sp_dmat_field_to_list, dvec_field_to_list * + * import l0learn.models # <<<<<<<<<<<<<< + * from l0learn.models import FitModel, CVFitModel + * + */ + __pyx_t_2 = __Pyx_Import(__pyx_n_s_l0learn_models, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_l0learn, __pyx_t_2) < 0) __PYX_ERR(0, 13, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "l0learn/interface.pyx":14 + * + * import l0learn.models * from l0learn.models import FitModel, CVFitModel # <<<<<<<<<<<<<< * * def np_to_arma_check(arr): */ - __pyx_t_2 = PyList_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 13, __pyx_L1_error) + __pyx_t_2 = PyList_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_FitModel); __Pyx_GIVEREF(__pyx_n_s_FitModel); @@ -14507,58 +12959,58 @@ if (!__Pyx_RefNanny) { __Pyx_INCREF(__pyx_n_s_CVFitModel); __Pyx_GIVEREF(__pyx_n_s_CVFitModel); PyList_SET_ITEM(__pyx_t_2, 1, __pyx_n_s_CVFitModel); - __pyx_t_1 = __Pyx_Import(__pyx_n_s_l0learn_models, __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error) + __pyx_t_1 = __Pyx_Import(__pyx_n_s_l0learn_models, __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_FitModel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 13, __pyx_L1_error) + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_FitModel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_FitModel, __pyx_t_2) < 0) __PYX_ERR(0, 13, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_FitModel, __pyx_t_2) < 0) __PYX_ERR(0, 14, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_CVFitModel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 13, __pyx_L1_error) + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_CVFitModel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_CVFitModel, __pyx_t_2) < 0) __PYX_ERR(0, 13, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_CVFitModel, __pyx_t_2) < 0) __PYX_ERR(0, 14, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":15 + /* "l0learn/interface.pyx":16 * from l0learn.models import FitModel, CVFitModel * * def np_to_arma_check(arr): # <<<<<<<<<<<<<< * # TODO: Add checks for Behaved and OwnsData * if isinstance(arr, np.ndarray): */ - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_1np_to_arma_check, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 15, __pyx_L1_error) + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_1np_to_arma_check, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 16, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_np_to_arma_check, __pyx_t_1) < 0) __PYX_ERR(0, 15, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_np_to_arma_check, __pyx_t_1) < 0) __PYX_ERR(0, 16, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":45 + /* "l0learn/interface.pyx":46 * * * SUPPORTED_LOSS = ("SquaredError", "Logistic", "SquaredHinge") # <<<<<<<<<<<<<< * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_SUPPORTED_LOSS, __pyx_tuple__15) < 0) __PYX_ERR(0, 45, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SUPPORTED_LOSS, __pyx_tuple__15) < 0) __PYX_ERR(0, 46, __pyx_L1_error) - /* "l0learn/interface.pyx":46 + /* "l0learn/interface.pyx":47 * * SUPPORTED_LOSS = ("SquaredError", "Logistic", "SquaredHinge") * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] # <<<<<<<<<<<<<< * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") * SUPPORTED_ALGORITHM = ("CD", "CDPSI") */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 47, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 46, __pyx_L1_error) + __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 47, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 47, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 46, __pyx_L1_error) + __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 47, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 46, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 47, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); @@ -14566,105 +13018,117 @@ if (!__Pyx_RefNanny) { PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3); __pyx_t_2 = 0; __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_CLASSIFICATION_LOSS, __pyx_t_1) < 0) __PYX_ERR(0, 46, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_CLASSIFICATION_LOSS, __pyx_t_1) < 0) __PYX_ERR(0, 47, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":47 + /* "l0learn/interface.pyx":48 * SUPPORTED_LOSS = ("SquaredError", "Logistic", "SquaredHinge") * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") # <<<<<<<<<<<<<< * SUPPORTED_ALGORITHM = ("CD", "CDPSI") * */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_SUPPORTED_PENALTY, __pyx_tuple__16) < 0) __PYX_ERR(0, 47, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SUPPORTED_PENALTY, __pyx_tuple__16) < 0) __PYX_ERR(0, 48, __pyx_L1_error) - /* "l0learn/interface.pyx":48 + /* "l0learn/interface.pyx":49 * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") * SUPPORTED_ALGORITHM = ("CD", "CDPSI") # <<<<<<<<<<<<<< * - * def fit(X: Union[np.ndarray, csc_matrix], + * + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SUPPORTED_ALGORITHM, __pyx_tuple__17) < 0) __PYX_ERR(0, 49, __pyx_L1_error) + + /* "l0learn/interface.pyx":52 + * + * + * def _fit_check(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< + * y: np.ndarray, + * loss: str, */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_SUPPORTED_ALGORITHM, __pyx_tuple__17) < 0) __PYX_ERR(0, 48, __pyx_L1_error) + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_3_fit_check, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_fit_check, __pyx_t_1) < 0) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":72 + /* "l0learn/interface.pyx":269 * exclude_first_k: int = 0, * intercept: bool = True, * lows: Union[np.ndarray, float] = -float('inf'), # <<<<<<<<<<<<<< - * highs: Union[np.ndarray, float] = +float('inf'),): + * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.FitModel: * """ */ - __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 72, __pyx_L1_error) - __pyx_t_1 = PyFloat_FromDouble((-__pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 72, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 269, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble((-__pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 269, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_k__7 = __pyx_t_1; __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":73 + /* "l0learn/interface.pyx":270 * intercept: bool = True, * lows: Union[np.ndarray, float] = -float('inf'), - * highs: Union[np.ndarray, float] = +float('inf'),): # <<<<<<<<<<<<<< + * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.FitModel: # <<<<<<<<<<<<<< * """ * Computes the regularization path for the specified loss function and penalty function. */ - __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 73, __pyx_L1_error) - __pyx_t_1 = PyFloat_FromDouble(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 73, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 270, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 270, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_k__8 = __pyx_t_1; __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":50 - * SUPPORTED_ALGORITHM = ("CD", "CDPSI") + /* "l0learn/interface.pyx":247 + * * * def fit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< * y: np.ndarray, - * loss: str = "SquaredHinge", + * loss: str = "SquaredError", */ - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_3fit, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 50, __pyx_L1_error) + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_5fit, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 247, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_fit, __pyx_t_1) < 0) __PYX_ERR(0, 50, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_fit, __pyx_t_1) < 0) __PYX_ERR(0, 247, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":468 + /* "l0learn/interface.pyx":557 * exclude_first_k: int = 0, * intercept: bool = True, * lows: Union[np.ndarray, float] = -float('inf'), # <<<<<<<<<<<<<< - * highs: Union[np.ndarray, float] = +float('inf'),): - * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): + * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.CVFitModel: + * */ - __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 468, __pyx_L1_error) - __pyx_t_1 = PyFloat_FromDouble((-__pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 468, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 557, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble((-__pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 557, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_k__9 = __pyx_t_1; __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":469 + /* "l0learn/interface.pyx":558 * intercept: bool = True, * lows: Union[np.ndarray, float] = -float('inf'), - * highs: Union[np.ndarray, float] = +float('inf'),): # <<<<<<<<<<<<<< - * if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): - * raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") + * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.CVFitModel: # <<<<<<<<<<<<<< + * + * check = _fit_check(X=X, */ - __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 469, __pyx_L1_error) - __pyx_t_1 = PyFloat_FromDouble(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 469, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 558, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 558, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_k__10 = __pyx_t_1; __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":444 + /* "l0learn/interface.pyx":533 * * * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< * y: np.ndarray, - * loss: str = "SquaredHinge", + * loss: str = "SquaredError", */ - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_5cvfit, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 444, __pyx_L1_error) + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_7cvfit, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 533, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_cvfit, __pyx_t_1) < 0) __PYX_ERR(0, 444, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_cvfit, __pyx_t_1) < 0) __PYX_ERR(0, 533, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "l0learn/interface.pyx":1 diff --git a/python/l0learn/interface.pyx b/python/l0learn/interface.pyx index a8049a3..b9554bb 100644 --- a/python/l0learn/interface.pyx +++ b/python/l0learn/interface.pyx @@ -5,11 +5,12 @@ import numpy as np from scipy.sparse import csc_matrix from warnings import warn -from typing import Union, Optional, List +from typing import Union, Optional, List, Dict, Any from l0learn.cyarma cimport dmat, sp_dmat, numpy_to_sp_dmat_d, numpy_to_dmat_d, dvec, numpy_to_dvec_d, \ sp_dmat_field_to_list, dvec_field_to_list +import l0learn.models from l0learn.models import FitModel, CVFitModel def np_to_arma_check(arr): @@ -47,9 +48,205 @@ CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") SUPPORTED_ALGORITHM = ("CD", "CDPSI") + +def _fit_check(X: Union[np.ndarray, csc_matrix], + y: np.ndarray, + loss: str, + penalty: str, + algorithm: str, + max_support_size: int, + num_lambda: Union[int, None], + num_gamma: Union[int, None], + gamma_max: float, + gamma_min: float, + partial_sort: bool, + max_iter: int, + rtol: float, + atol: float, + active_set: bool, + active_set_num: int, + max_swaps: int, + scale_down_factor: float, + screen_size: int, + lambda_grid: Union[List[List[float]], None], + exclude_first_k: int, + intercept: bool, + lows: Union[np.ndarray, float], + highs: Union[np.ndarray, float]) -> Dict[str, Any]: + + if not isinstance(X, (np.ndarray, csc_matrix)) or X.dtype != np.float64 or X.ndim != 2 or not np.product(X.shape) or not X.flags.contiguous: + raise ValueError(f"expected X to be a 2D continuous non-degenerate real numpy or csc_matrix, but got {X}.") + n, p = X.shape + if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: + raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") + if loss not in SUPPORTED_LOSS: + raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") + if penalty not in SUPPORTED_PENALTY: + raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") + if algorithm not in SUPPORTED_ALGORITHM: + raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") + if not isinstance(max_support_size, int) or 1 > max_support_size: + raise ValueError(f"expected max_support_size parameter to be a positive integer, but got {max_support_size}") + max_support_size = min(p, max_support_size) + + if gamma_max < 0: + raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") + if gamma_min < 0 or gamma_min > gamma_max: + raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," + f" but got {gamma_min}") + if not isinstance(partial_sort, bool): + raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") + if not isinstance(max_iter, int) or max_iter < 1: + raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") + if rtol < 0 or rtol >= 1: + raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") + if atol < 0: + raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") + if not isinstance(active_set, bool): + raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") + if not isinstance(active_set_num, int) or active_set_num < 1: + raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") + if not isinstance(max_swaps, int) or max_swaps < 1: + raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") + if not (0 < scale_down_factor < 1): + raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") + if not isinstance(screen_size, int) or screen_size < 1: + raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") + screen_size = min(screen_size, p) + + if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): + raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " + f"but got {exclude_first_k}") + if not isinstance(intercept, bool): + raise ValueError(f"expected intercept parameter to be a bool, " + f"but got {intercept}") + + if loss in CLASSIFICATION_LOSS: + unique_items = sorted(np.unique(y)) + if len(unique_items) != 2: + raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " + f"but got {unique_items}") + else: + a, *_ = unique_items # a is the lower value + y = np.copy(y) + first_value = y==a + second_value = y!=a + y[first_value] = -1.0 + y[second_value] = 1.0 + if y.dtype != np.float64: + y = y.astype(float) + + if penalty == "L0": + # Pure L0 is not supported for classification + # Below we add a small L2 component. + + if lambda_grid is not None and len(lambda_grid) != 1: + # If this error checking was left to the lower section, it would confuse users as + # we are converting L0 to L0L2 with small L2 penalty. + # Here we must check if lambdaGrid is supplied (And thus use 'autolambda') + # If 'lambdaGrid' is supplied, we must only supply 1 list of lambda values + raise ValueError(f"L0 Penalty requires 'lambda_grid' to be a list of length 1, but got {lambda_grid}.") + + penalty = "L0L2" + gamma_max = 1e-7 + gamma_min = 1e-7 + elif penalty != "L0" and num_gamma == 1: + warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") + + if y.dtype != np.float64: + raise ValueError(f"expected y vector to have type {np.float64}, but got {y.dtype}") + + if lambda_grid is None: + lambda_grid = [[0.]] + auto_lambda = True + if not isinstance(num_lambda, int) or num_lambda < 1: + raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") + if not isinstance(num_gamma, int) or num_gamma < 1: + raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") + if penalty == "L0" and num_gamma != 1: + raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") + else: # lambda_grid should be a List[List[float]] + if num_gamma is not None: + raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " + f"but got {num_gamma}") + num_gamma = len(lambda_grid) + + if num_lambda is not None: + raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " + f"but got {num_lambda}") + num_lambda = 0 # This value is ignored. + auto_lambda = False + bad_lambda_grid = False + + if penalty == "L0" and num_gamma != 1: + raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") + + for i, sub_lambda_grid in enumerate(lambda_grid): + current = float("inf") + if sub_lambda_grid[0] <= 0: + raise ValueError(f"Expected all values of lambda_grid to be positive, " + f"but got lambda_grid[{i}] containing a negative value") + if any(np.diff(sub_lambda_grid) >= 0): + raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " + f"but got lambda_grid[{i}] containing an increasing value.") + + n, p = X.shape + with_bounds = False + + if isinstance(lows, float): + if lows > 0: + raise ValueError(f"expected lows to be a non-positive float, but got {lows}") + elif lows > -float('inf'): + with_bounds = True + elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): + with_bounds = True + else: + raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " + f"floats, but got {lows}") + + if isinstance(highs, float): + if highs < 0: + raise ValueError(f"expected highs to be a non-negative float, but got {highs}") + if highs < float('inf'): + with_bounds = True + elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): + with_bounds = True + else: + raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " + f"non-negative floats, but got {highs}") + + if with_bounds: + if isinstance(lows, float): + lows = np.ones(p) * lows + if isinstance(highs, float): + highs = np.ones(p) * highs + + if any(lows >= highs): + bad_bounds = np.argwhere(lows >= highs) + raise ValueError(f"expected to be high to be elementwise greater than lows, " + f"but got indices {bad_bounds[0]} where that is not the case ") + else: + lows = np.array([0.]) + highs = np.array(([0.])) + + return {"max_support_size": max_support_size, + "screen_size": screen_size, + "y": y, + "penalty":penalty, + "gamma_max":gamma_max, + "gamma_min": gamma_min, + "lambda_grid": lambda_grid, + "num_gamma": num_gamma, + "num_lambda":num_lambda, + "auto_lambda": auto_lambda, + "with_bounds": with_bounds, + "lows": lows, + "highs":highs} + + def fit(X: Union[np.ndarray, csc_matrix], y: np.ndarray, - loss: str = "SquaredHinge", + loss: str = "SquaredError", penalty: str = "L0", algorithm: str = "CD", max_support_size: int = 100, @@ -70,7 +267,7 @@ def fit(X: Union[np.ndarray, csc_matrix], exclude_first_k: int = 0, intercept: bool = True, lows: Union[np.ndarray, float] = -float('inf'), - highs: Union[np.ndarray, float] = +float('inf'),): + highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.FitModel: """ Computes the regularization path for the specified loss function and penalty function. @@ -218,152 +415,44 @@ def fit(X: Union[np.ndarray, csc_matrix], Examples -------- """ - - if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): - raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") - n, p = X.shape - if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: - raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") - if loss not in SUPPORTED_LOSS: - raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") - if penalty not in SUPPORTED_PENALTY: - raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") - if algorithm not in SUPPORTED_ALGORITHM: - raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") - if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): - raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," - f" but got {max_support_size}") - if gamma_max < 0: - raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") - if gamma_min < 0 or gamma_min > gamma_max: - raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," - f" but got {gamma_min}") - if not isinstance(partial_sort, bool): - raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") - if not isinstance(max_iter, int) or max_iter < 1: - raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") - if rtol < 0 or rtol >= 1: - raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") - if atol < 0: - raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") - if not isinstance(active_set, bool): - raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") - if not isinstance(active_set_num, int) or active_set_num < 1: - raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") - if not isinstance(max_swaps, int) or max_swaps < 1: - raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") - if not (0 < scale_down_factor < 1): - raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") - if not isinstance(screen_size, int) or screen_size < 1 or screen_size > p: - raise ValueError(f"expected screen_size parameter to be a positive integer less than {p}," - f" but got {screen_size}") - if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): - raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " - f"but got {exclude_first_k}") - if not isinstance(intercept, bool): - raise ValueError(f"expected intercept parameter to be a bool, " - f"but got {intercept}") - - if loss in CLASSIFICATION_LOSS: - unique_items = sorted(np.unique(y)) - if 0 >= len(unique_items) > 2: - raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " - f"but got {unique_items}") - else: - a, *_ = unique_items # a is the lower value - y = np.copy(y) - y[y==a] = -1 - y[y!=a] = 1 - - if penalty == "L0": - # Pure L0 is not supported for classification - # Below we add a small L2 component. - - if lambda_grid is not None and len(lambda_grid) != 1: - # If this error checking was left to the lower section, it would confuse users as - # we are converting L0 to L0L2 with small L2 penalty. - # Here we must check if lambdaGrid is supplied (And thus use 'autolambda') - # If 'lambdaGrid' is supplied, we must only supply 1 list of lambda values - raise ValueError(f"L0 Penalty requires 'lambda_grid' to be a list of length 1, but got {lambda_grid}.") - - penalty = "L0L2" - gamma_max = 1e-7 - gamma_min = 1e-7 - elif penalty != "L0" and num_gamma == 1: - warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") - - if lambda_grid is None: - lambda_grid = [[0.]] - auto_lambda = True - if not isinstance(num_lambda, int) or num_lambda < 1: - raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") - if not isinstance(num_gamma, int) or num_gamma < 1: - raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") - if penalty == "L0" and num_gamma != 1: - raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") - else: # lambda_grid should be a List[List[float]] - if num_gamma is not None: - raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " - f"but got {num_gamma}") - num_gamma = len(lambda_grid) - - if num_lambda is not None: - raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " - f"but got {num_lambda}") - num_lambda = 0 # This value is ignored. - auto_lambda = False - bad_lambda_grid = False - - if penalty == "L0" and num_gamma != 1: - raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") - - for i, sub_lambda_grid in enumerate(lambda_grid): - current = float("inf") - if sub_lambda_grid[0] <= 0: - raise ValueError(f"Expected all values of lambda_grid to be positive, " - f"but got lambda_grid[{i}] containing a negative value") - if any(np.diff(sub_lambda_grid) >= 0): - raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " - f"but got lambda_grid[{i}] containing an increasing value.") - - n, p = X.shape - with_bounds = False - - if isinstance(lows, float): - if lows > 0: - raise ValueError(f"expected lows to be a non-positive float, but got {lows}") - elif lows > -float('inf'): - with_bounds = True - elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): - with_bounds = True - else: - raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " - f"floats, but got {lows}") - - if isinstance(highs, float): - if highs < 0: - raise ValueError(f"expected highs to be a non-negative float, but got {highs}") - if highs < float('inf'): - with_bounds = True - elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): - with_bounds = True - else: - raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " - f"non-negative floats, but got {highs}") - - if with_bounds: - if isinstance(lows, float): - lows = np.ones(p) * lows - if isinstance(highs, float): - highs = np.ones(p) * highs - - if any(lows >= highs): - bad_bounds = np.argwhere(lows >= highs) - raise ValueError(f"expected to be high to be elementwise greater than lows, " - f"but got indices {bad_bounds[0]} where that is not the case ") - else: - lows = np.array([0.]) - highs = np.array(([0.])) + check = _fit_check(X=X, + y=y, + loss=loss, + penalty=penalty, + algorithm=algorithm, + max_support_size=max_support_size, + num_lambda=num_lambda, + num_gamma=num_gamma, + gamma_max=gamma_max, + gamma_min=gamma_min, + partial_sort=partial_sort, + max_iter=max_iter, + rtol=rtol, + atol=atol, + active_set=active_set, + active_set_num=active_set_num, + max_swaps=max_swaps, + scale_down_factor=scale_down_factor, + screen_size=screen_size, + lambda_grid=lambda_grid, + exclude_first_k=exclude_first_k, + intercept=intercept, + lows=lows, + highs=highs) + + max_support_size = check["max_support_size"] + screen_size = check["screen_size"] + y = check['y'] + penalty = check['penalty'] + gamma_max = check['gamma_max'] + gamma_min = check['gamma_min'] + lambda_grid = check['lambda_grid'] + num_gamma = check['num_gamma'] + num_lambda = check['num_lambda'] + auto_lambda = check['auto_lambda'] + with_bounds = check['with_bounds'] + lows = check['lows'] + highs = check['highs'] cdef vector[vector[double]] c_lambda_grid try: @@ -443,7 +532,7 @@ def fit(X: Union[np.ndarray, csc_matrix], def cvfit(X: Union[np.ndarray, csc_matrix], y: np.ndarray, - loss: str = "SquaredHinge", + loss: str = "SquaredError", penalty: str = "L0", algorithm: str = "CD", num_folds: int = 10, @@ -466,158 +555,52 @@ def cvfit(X: Union[np.ndarray, csc_matrix], exclude_first_k: int = 0, intercept: bool = True, lows: Union[np.ndarray, float] = -float('inf'), - highs: Union[np.ndarray, float] = +float('inf'),): - if not isinstance(X, (np.ndarray, csc_matrix)) or not np.isrealobj(X) or X.ndim != 2 or not np.product(X.shape): - raise ValueError(f"expected X to be a 2D non-degenerate real numpy or csc_matrix, but got {X}.") + highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.CVFitModel: + + check = _fit_check(X=X, + y=y, + loss=loss, + penalty=penalty, + algorithm=algorithm, + max_support_size=max_support_size, + num_lambda=num_lambda, + num_gamma=num_gamma, + gamma_max=gamma_max, + gamma_min=gamma_min, + partial_sort=partial_sort, + max_iter=max_iter, + rtol=rtol, + atol=atol, + active_set=active_set, + active_set_num=active_set_num, + max_swaps=max_swaps, + scale_down_factor=scale_down_factor, + screen_size=screen_size, + lambda_grid=lambda_grid, + exclude_first_k=exclude_first_k, + intercept=intercept, + lows=lows, + highs=highs) + + max_support_size = check["max_support_size"] + screen_size = check["screen_size"] + y = check['y'] + penalty = check['penalty'] + gamma_max = check['gamma_max'] + gamma_min = check['gamma_min'] + lambda_grid = check['lambda_grid'] + num_gamma = check['num_gamma'] + num_lambda = check['num_lambda'] + auto_lambda = check['auto_lambda'] + with_bounds = check['with_bounds'] + lows = check['lows'] + highs = check['highs'] + + _, p = X.shape + + if not isinstance(num_folds, int) or num_folds < 2 or num_folds > p: + raise ValueError(f"expected num_folds parameter to be a positive integer less than {p}, but got {num_folds}") - n, p = X.shape - if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: - raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") - - if loss not in SUPPORTED_LOSS: - raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") - - if penalty not in SUPPORTED_PENALTY: - raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") - if algorithm not in SUPPORTED_ALGORITHM: - raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") - if not isinstance(num_folds, int) or num_folds < 2: - raise ValueError(f"expected num_folds parameter to be a integer greater than 2, but got {num_folds}") - if not isinstance(seed, int): - raise ValueError(f"expected seed parameter to be an integer, but got {seed}") - if not isinstance(max_support_size, int) or not (0 < max_support_size <= p): - raise ValueError(f"expected max_support_size parameter to be a positive integer less than {p}," - f" but got {max_support_size}") - if gamma_max < 0: - raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") - if gamma_min < 0 or gamma_min > gamma_max: - raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," - f" but got {gamma_min}") - if not isinstance(partial_sort, bool): - raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") - if not isinstance(max_iter, int) or max_iter < 1: - raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") - if rtol < 0 or rtol >= 1: - raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") - if atol < 0: - raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") - if not isinstance(active_set, bool): - raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") - if not isinstance(active_set_num, int) or active_set_num < 1: - raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") - if not isinstance(max_swaps, int) or max_swaps < 1: - raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") - if not (0 < scale_down_factor < 1): - raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") - if not isinstance(screen_size, int) or screen_size < 1: - raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") - if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): - raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " - f"but got {exclude_first_k}") - if not isinstance(intercept, bool): - raise ValueError(f"expected intercept parameter to be a bool, " - f"but got {intercept}") - - if loss in CLASSIFICATION_LOSS: - unique_items = sorted(np.unique(y)) - if 0 >= len(unique_items) > 2: - raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " - f"but got {unique_items}") - else: - a, *_ = unique_items # a is the lower value - y = np.copy(y) - y[y==a] = -1 - y[y!=a] = 1 - - if penalty == "L0": - # Pure L0 is not supported for classification - # Below we add a small L2 component. - - if lambda_grid is not None and len(lambda_grid) != 1: - # If this error checking was left to the lower section, it would confuse users as - # we are converting L0 to L0L2 with small L2 penalty. - # Here we must check if lambdaGrid is supplied (And thus use 'autolambda') - # If 'lambdaGrid' is supplied, we must only supply 1 list of lambda values - raise ValueError(f"L0 Penalty requires 'lambda_grid' to be a list of length 1, but got {lambda_grid}.") - - penalty = "L0L2" - gamma_max = 1e-7 - gamma_min = 1e-7 - elif penalty != "L0" and num_gamma == 1: - warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") - - if lambda_grid is None: - lambda_grid = [[0.]] - auto_lambda = True - if not isinstance(num_lambda, int) or num_lambda < 1: - raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") - if not isinstance(num_gamma, int) or num_gamma < 1: - raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") - if penalty == "L0" and num_gamma != 1: - raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") - else: # lambda_grid should be a List[List[float]] - if num_gamma is not None: - raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " - f"but got {num_gamma}") - num_gamma = len(lambda_grid) - - if num_lambda is not None: - raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " - f"but got {num_lambda}") - num_lambda = 0 # This value is ignored. - auto_lambda = False - bad_lambda_grid = False - - if penalty == "L0" and num_gamma != 1: - raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") - - for i, sub_lambda_grid in enumerate(lambda_grid): - current = float("inf") - if sub_lambda_grid[0] <= 0: - raise ValueError(f"Expected all values of lambda_grid to be positive, " - f"but got lambda_grid[{i}] containing a negative value") - if any(np.diff(sub_lambda_grid) >= 0): - raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " - f"but got lambda_grid[{i}] containing an increasing value.") - - n, p = X.shape - with_bounds = False - - if isinstance(lows, float): - if lows > 0: - raise ValueError(f"expected lows to be a non-positive float, but got {lows}") - elif lows > -float('inf'): - with_bounds = True - elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): - with_bounds = True - else: - raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " - f"floats, but got {lows}") - - if isinstance(highs, float): - if highs < 0: - raise ValueError(f"expected highs to be a non-negative float, but got {highs}") - if highs < float('inf'): - with_bounds = True - elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): - with_bounds = True - else: - raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " - f"non-negative floats, but got {highs}") - - if with_bounds: - if isinstance(lows, float): - lows = np.ones(p) * lows - if isinstance(highs, float): - highs = np.ones(p) * highs - - if any(lows >= highs): - bad_bounds = np.argwhere(lows >= highs) - raise ValueError(f"expected to be high to be elementwise greater than lows, " - f"but got indices {bad_bounds[0]} where that is not the case ") - else: - lows = np.array([0.]) - highs = np.array(([0.])) cdef vector[vector[double]] c_lambda_grid try: diff --git a/python/tests/test_fit.py b/python/tests/test_fit.py index de734aa..a135dca 100644 --- a/python/tests/test_fit.py +++ b/python/tests/test_fit.py @@ -1,9 +1,371 @@ -import pytest +import warnings +import pytest +import numpy as np import l0learn +N = 50 + +@pytest.mark.parametrize("x", [np.random.random(size=(N, N, N)), # Wrong Size + "A String", # Wrong Type + np.random.random(size=(N, N)).astype(complex), # Wrong dtype + np.random.random(size=(N, N)).astype(int), # Wrong dtype + np.random.random(size=(0, N))]) # degenerate 2D array +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_X_bad_checks(f, x): + # Check size of matrix X + y = np.random.random(size=(N,)) + with pytest.raises(ValueError): + f(x, y) + +@pytest.mark.parametrize("y", [np.random.random(size=(N, N, N)), # wrong dimensions + "A String", # wrong type + np.random.random(size=(N,)).astype(complex), # wrong dtype + np.random.random(size=(N+1))]) # wrong size +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_y_bad_checks(f, y): + # Check size of matrix X + x = np.random.random(size=(N, N)) + with pytest.raises(ValueError): + f(x, y) + + +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_loss_bad_checks(f): + # Check size of matrix X + x = np.random.random(size=(N, N)) + y = np.random.random(size=(N,)) + with pytest.raises(ValueError): + f(x, y, loss="NOT A LOSS") + + +@pytest.mark.parametrize("loss", l0learn.interface.SUPPORTED_LOSS) +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_loss_good_checks(f, loss): + # Check size of matrix X + x = np.random.random(size=(N, N)) + y = np.random.randint(low=0, high=2, size=(N,)).astype(float) + _ = f(x, y, loss=loss) + + +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_penalty_bad_checks(f): + # Check size of matrix X + x = np.random.random(size=(N, N)) + y = np.random.random(size=(N,)) + with pytest.raises(ValueError): + f(x, y, penalty="L0LX") + + +@pytest.mark.parametrize("penalty", l0learn.interface.SUPPORTED_PENALTY) +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_penalty_good_checks(f, penalty): + # Check size of matrix X + x = np.random.random(size=(N, N)) + y = np.random.random(size=(N,)) + _ = f(x, y, penalty=penalty) + + +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_algorithm_bad_checks(f): + # Check size of matrix X + x = np.random.random(size=(N, N)) + y = np.random.random(size=(N,)) + with pytest.raises(ValueError): + f(x, y, algorithm="NOT CD or CDPSI") + + +@pytest.mark.parametrize("algorithm", l0learn.interface.SUPPORTED_ALGORITHM) +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_algorithm_good_checks(f, algorithm): + # Check size of matrix X + x = np.random.random(size=(N, N)) + y = np.random.random(size=(N,)) + _ = f(x, y, algorithm=algorithm) + + +@pytest.mark.parametrize("max_support_size", [-1, 2.0]) +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_max_support_size_bad_checks(f, max_support_size): + # Check size of matrix X + x = np.random.random(size=(N, N)) + y = np.random.random(size=(N,)) + + with pytest.raises(ValueError): + _ = f(x, y, max_support_size=max_support_size) + + +@pytest.mark.parametrize("max_support_size", [N, N-1, N+1]) +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_max_support_size_good_checks(f, max_support_size): + # Check size of matrix X + x = np.random.random(size=(N, N)) + y = np.random.random(size=(N,)) + _ = f(x, y, max_support_size=max_support_size) + + +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_gamma_max_bad_checks(f): + # Check size of matrix X + x = np.random.random(size=(N, N)) + y = np.random.random(size=(N,)) + + with pytest.raises(ValueError): + _ = f(x, y, gamma_max=-1) + + +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_gamma_min_bad_checks(f): + # Check size of matrix X + x = np.random.random(size=(N, N)) + y = np.random.random(size=(N,)) + + with pytest.raises(ValueError): + _ = f(x, y, gamma_min=1, gamma_max=.5) + + with pytest.raises(ValueError): + _ = f(x, y, gamma_min=-1) + + +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_paritial_sort_bad_checks(f): + # Check size of matrix X + x = np.random.random(size=(N, N)) + y = np.random.random(size=(N,)) + + with pytest.raises(ValueError): + _ = f(x, y, partial_sort='NOT A BOOL') + + +@pytest.mark.parametrize("max_iter", [1.0, 0]) +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_max_iter_bad_checks(f, max_iter): + # Check size of matrix X + x = np.random.random(size=(N, N)) + y = np.random.random(size=(N,)) + + with pytest.raises(ValueError): + _ = f(x, y, max_iter=max_iter) + + +@pytest.mark.parametrize("rtol", [1.0, -0.1]) +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_max_iter_bad_checks(f, rtol): + # Check size of matrix X + x = np.random.random(size=(N, N)) + y = np.random.random(size=(N,)) + + with pytest.raises(ValueError): + _ = f(x, y, rtol=rtol) + + +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_max_iter_bad_checks(f): + # Check size of matrix X + x = np.random.random(size=(N, N)) + y = np.random.random(size=(N,)) + + with pytest.raises(ValueError): + _ = f(x, y, atol=-1) + + +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_active_set_sort_bad_checks(f): + # Check size of matrix X + x = np.random.random(size=(N, N)) + y = np.random.random(size=(N,)) + + with pytest.raises(ValueError): + _ = f(x, y, active_set='NOT A BOOL') + + +@pytest.mark.parametrize("active_set_num", [1.3, 0]) +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_active_set_num_bad_checks(f, active_set_num): + # Check size of matrix X + x = np.random.random(size=(N, N)) + y = np.random.random(size=(N,)) + + with pytest.raises(ValueError): + _ = f(x, y, active_set_num=active_set_num) + + +@pytest.mark.parametrize("max_swaps", [0, 4.5]) +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_max_swaps_bad_checks(f, max_swaps): + # Check size of matrix X + x = np.random.random(size=(N, N)) + y = np.random.random(size=(N,)) + + with pytest.raises(ValueError): + _ = f(x, y, max_swaps=max_swaps) + + +@pytest.mark.parametrize("scale_down_factor", [-1, 2]) +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_scale_down_factor_bad_checks(f, scale_down_factor): + # Check size of matrix X + x = np.random.random(size=(N, N)) + y = np.random.random(size=(N,)) + + with pytest.raises(ValueError): + _ = f(x, y, scale_down_factor=scale_down_factor) + + +@pytest.mark.parametrize("screen_size", [-1, 2.0]) +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_scale_down_factor_bad_checks(f, screen_size): + # Check size of matrix X + x = np.random.random(size=(N, N)) + y = np.random.random(size=(N,)) + + with pytest.raises(ValueError): + _ = f(x, y, screen_size=screen_size) + + +@pytest.mark.parametrize("exclude_first_k", [-1, 2.0, N+1]) +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_exclude_first_k_bad_checks(f, exclude_first_k): + # Check size of matrix X + x = np.random.random(size=(N, N)) + y = np.random.random(size=(N,)) + + with pytest.raises(ValueError): + _ = f(x, y, exclude_first_k=exclude_first_k) + + +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_intercept_bad_checks(f): + # Check size of matrix X + x = np.random.random(size=(N, N)) + y = np.random.random(size=(N,)) + + with pytest.raises(ValueError): + _ = f(x, y, intercept='NOT A BOOL') + + +@pytest.mark.parametrize("loss", l0learn.interface.CLASSIFICATION_LOSS) +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_classification_loss_bad_y_checks(f, loss): + # Check size of matrix X + x = np.random.random(size=(N, N)) + y = np.zeros(N) + y[0] = 1 + y[1] = 2 + + with pytest.raises(ValueError): + _ = f(x, y, loss=loss) + + +@pytest.mark.parametrize("loss", l0learn.interface.CLASSIFICATION_LOSS) +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_classification_loss_bad_lambda_grid_L0_checks(f, loss): + # Check size of matrix X + x = np.random.random(size=(N, N)) + y = np.random.randint(0, 2, size=N) + lambda_grid = [[10], [10]] + + with pytest.raises(ValueError): + _ = f(x, y, loss=loss, penalty="L0", lambda_grid=lambda_grid, num_gamma=None, num_lambda=None) + + _ = f(x, y, loss=loss, penalty="L0", lambda_grid=[[10]], num_gamma=None, num_lambda=None) + + +@pytest.mark.parametrize("penalty", ["L0L1", "L0L2"]) +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_regression_loss_bad_num_gamma_L0_checks(f, penalty): + x = np.random.random(size=(N, N)) + y = np.random.random(size=N) + + with pytest.warns(None) as wrn: + _ = f(x, y, loss="SquaredError", penalty=penalty, num_gamma=1, num_lambda=10) + + assert len(wrn) == 1 + + with pytest.warns(None) as wrn: + _ = f(x, y, loss="SquaredError", penalty=penalty, num_gamma=2, num_lambda=10) + + assert len(wrn) == 0 + + +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_auto_lambda_bad_checks(f): + x = np.random.random(size=(N, N)) + y = np.random.random(size=N) + + with pytest.raises(ValueError): + _ = f(x, y, penalty="L0L1", num_gamma=3.0, num_lambda=5) + + with pytest.raises(ValueError): + _ = f(x, y, penalty="L0L1", num_gamma=-2, num_lambda=5) + + with pytest.raises(ValueError): + _ = f(x, y, penalty="L0L1", num_gamma=5, num_lambda=5.0) + + with pytest.raises(ValueError): + _ = f(x, y, penalty="L0L1", num_gamma=5, num_lambda=-2) + + with pytest.raises(ValueError): + _ = f(x, y, penalty="L0", num_gamma=2, num_lambda=10) + + _ = f(x, y, penalty="L0", num_gamma=1, num_lambda=10) + +@pytest.mark.parametrize("penalty", ["L0L1", "L0L2"]) @pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) -def test_X_checks(f): +def test_lambda_grid_bad_over_defined_checks(f, penalty): + x = np.random.random(size=(N, N)) + y = np.random.random(size=N) + + with pytest.raises(ValueError): + _ = f(x, y, penalty=penalty, lambda_grid=[[10], [10]], num_lambda=1, num_gamma=None) + + with pytest.raises(ValueError): + _ = f(x, y, penalty=penalty, lambda_grid=[[10], [10]], num_lambda=None, num_gamma=2) + + _ = f(x, y, penalty=penalty, lambda_grid=[[10], [10]], num_lambda=None, num_gamma=None) + + +@pytest.mark.parametrize("penalty_lambda_grid", [("L0", [[10], [10]]), + ("L0", [[-1]]), + ("L0", [[10, 11]]),]) +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_lambda_grid_bad_checks(f, penalty_lambda_grid): + penalty, lambda_grid = penalty_lambda_grid + x = np.random.random(size=(N, N)) + y = np.random.randint(0, 2, size=N) + + with pytest.raises(ValueError): + _ = f(x, y, penalty=penalty, lambda_grid=lambda_grid, num_gamma=None, num_lambda=None) + + +@pytest.mark.parametrize("bounds", [("NOT A FLOAT", 1.0), + (1.0, "NOT A FLOAT"), + (1.0, 1.0), + (-np.ones((N, 2)), 1.0), + (-np.ones(N+1), 1.0), + (np.ones(N), 1.0), + (-1.0, -1.0), + (-1.0, np.ones((N,2))), + (-1.0, np.ones(N+1)), + (-1.0, -1.0*np.ones(N)), + (0.0, 0.0), + (np.zeros(N), np.zeros(N))]) +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_with_bounds_bad_checks(f, bounds): + lows, highs = bounds + + x = np.random.random(size=(N, N)) + y = np.random.randint(0, 2, size=N) + + with pytest.raises(ValueError): + _ = f(x, y, lows=lows, highs=highs) + + +@pytest.mark.parametrize("num_folds", [-1, 0, 1, N, 2.0]) +def test_cvfit_num_folds_bad_check(num_folds): + x = np.random.random(size=(N, N)) + y = np.random.randint(0, 2, size=N) + with pytest.raises(ValueError): - f() \ No newline at end of file + _ = l0learn.cvfit(x, y, num_folds=num_folds) \ No newline at end of file From eb2e5c86f5dfe3c391e0d48455e9b95ba8f68431 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Sun, 21 Nov 2021 08:01:09 -0600 Subject: [PATCH 054/125] Create LICENSE --- R/LICENSE | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 R/LICENSE diff --git a/R/LICENSE b/R/LICENSE new file mode 100644 index 0000000..25dd6a4 --- /dev/null +++ b/R/LICENSE @@ -0,0 +1,2 @@ +YEAR: 2021 +COPYRIGHT HOLDER: Hussein Hazimeh \ No newline at end of file From 87f99e1fdf2b9a2c802ccafd3dbccefa09ed2e2e Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Sun, 21 Nov 2021 08:05:33 -0600 Subject: [PATCH 055/125] Update pyproject.toml to direct pytest to not test coverage on C++ code --- python/pyproject.toml | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/python/pyproject.toml b/python/pyproject.toml index 062da13..9291b21 100644 --- a/python/pyproject.toml +++ b/python/pyproject.toml @@ -6,4 +6,10 @@ requires = [ "numpy", "h5py", ] -build-backend = "setuptools.build_meta" \ No newline at end of file +build-backend = "setuptools.build_meta" + +[tool.coverage.run] +omit = [ + "l0learn/src/*", + "src/*", +] \ No newline at end of file From 5396eba732af533a8ddc3631d9e02237d968a454 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Sun, 21 Nov 2021 15:49:14 -0600 Subject: [PATCH 056/125] Update setup.py to recompile for coverage analysis --- python/l0learn/cyarma.cpp | 1025 +++++++++++++++++-- python/l0learn/interface.cpp | 1607 ++++++++++++++++++++++++++---- python/l0learn/testing_utils.cpp | 1005 +++++++++++++++++-- python/pyproject.toml | 13 +- python/setup.py | 27 +- 5 files changed, 3335 insertions(+), 342 deletions(-) diff --git a/python/l0learn/cyarma.cpp b/python/l0learn/cyarma.cpp index a55d874..459ce89 100644 --- a/python/l0learn/cyarma.cpp +++ b/python/l0learn/cyarma.cpp @@ -3,6 +3,12 @@ /* BEGIN: Cython Metadata { "distutils": { + "define_macros": [ + [ + "CYTHON_TRACE_NOGIL", + "1" + ] + ], "depends": [ "/Users/tnonet/opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/core/include/numpy/arrayobject.h", "/Users/tnonet/opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/core/include/numpy/arrayscalars.h", @@ -1271,6 +1277,255 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() PyErr_Occurred() +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +#else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + +/* Profile.proto */ +#ifndef CYTHON_PROFILE +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON + #define CYTHON_PROFILE 0 +#else + #define CYTHON_PROFILE 1 +#endif +#endif +#ifndef CYTHON_TRACE_NOGIL + #define CYTHON_TRACE_NOGIL 0 +#else + #if CYTHON_TRACE_NOGIL && !defined(CYTHON_TRACE) + #define CYTHON_TRACE 1 + #endif +#endif +#ifndef CYTHON_TRACE + #define CYTHON_TRACE 0 +#endif +#if CYTHON_TRACE + #undef CYTHON_PROFILE_REUSE_FRAME +#endif +#ifndef CYTHON_PROFILE_REUSE_FRAME + #define CYTHON_PROFILE_REUSE_FRAME 0 +#endif +#if CYTHON_PROFILE || CYTHON_TRACE + #include "compile.h" + #include "frameobject.h" + #include "traceback.h" + #if CYTHON_PROFILE_REUSE_FRAME + #define CYTHON_FRAME_MODIFIER static + #define CYTHON_FRAME_DEL(frame) + #else + #define CYTHON_FRAME_MODIFIER + #define CYTHON_FRAME_DEL(frame) Py_CLEAR(frame) + #endif + #define __Pyx_TraceDeclarations\ + static PyCodeObject *__pyx_frame_code = NULL;\ + CYTHON_FRAME_MODIFIER PyFrameObject *__pyx_frame = NULL;\ + int __Pyx_use_tracing = 0; + #define __Pyx_TraceFrameInit(codeobj)\ + if (codeobj) __pyx_frame_code = (PyCodeObject*) codeobj; +#if PY_VERSION_HEX >= 0x030a00b1 + #define __Pyx_IsTracing(tstate, check_tracing, check_funcs)\ + (unlikely((tstate)->cframe->use_tracing) &&\ + (!(check_tracing) || !(tstate)->tracing) &&\ + (!(check_funcs) || (tstate)->c_profilefunc || (CYTHON_TRACE && (tstate)->c_tracefunc))) + #define __Pyx_SetTracing(tstate, enable)\ + (tstate)->cframe->use_tracing = (enable) +#else + #define __Pyx_IsTracing(tstate, check_tracing, check_funcs)\ + (unlikely((tstate)->use_tracing) &&\ + (!(check_tracing) || !(tstate)->tracing) &&\ + (!(check_funcs) || (tstate)->c_profilefunc || (CYTHON_TRACE && (tstate)->c_tracefunc))) + #define __Pyx_SetTracing(tstate, enable)\ + (tstate)->use_tracing = (enable) +#endif + #ifdef WITH_THREAD + #define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error)\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + PyThreadState *tstate;\ + PyGILState_STATE state = PyGILState_Ensure();\ + tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 1, 1)) {\ + __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ + }\ + PyGILState_Release(state);\ + if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ + }\ + } else {\ + PyThreadState* tstate = PyThreadState_GET();\ + if (__Pyx_IsTracing(tstate, 1, 1)) {\ + __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ + if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ + }\ + } + #else + #define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error)\ + { PyThreadState* tstate = PyThreadState_GET();\ + if (__Pyx_IsTracing(tstate, 1, 1)) {\ + __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ + if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ + }\ + } + #endif + #define __Pyx_TraceException()\ + if (likely(!__Pyx_use_tracing)); else {\ + PyThreadState* tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 1)) {\ + tstate->tracing++;\ + __Pyx_SetTracing(tstate, 0);\ + PyObject *exc_info = __Pyx_GetExceptionTuple(tstate);\ + if (exc_info) {\ + if (CYTHON_TRACE && tstate->c_tracefunc)\ + tstate->c_tracefunc(\ + tstate->c_traceobj, __pyx_frame, PyTrace_EXCEPTION, exc_info);\ + tstate->c_profilefunc(\ + tstate->c_profileobj, __pyx_frame, PyTrace_EXCEPTION, exc_info);\ + Py_DECREF(exc_info);\ + }\ + __Pyx_SetTracing(tstate, 1);\ + tstate->tracing--;\ + }\ + } + static void __Pyx_call_return_trace_func(PyThreadState *tstate, PyFrameObject *frame, PyObject *result) { + PyObject *type, *value, *traceback; + __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); + tstate->tracing++; + __Pyx_SetTracing(tstate, 0); + if (CYTHON_TRACE && tstate->c_tracefunc) + tstate->c_tracefunc(tstate->c_traceobj, frame, PyTrace_RETURN, result); + if (tstate->c_profilefunc) + tstate->c_profilefunc(tstate->c_profileobj, frame, PyTrace_RETURN, result); + CYTHON_FRAME_DEL(frame); + __Pyx_SetTracing(tstate, 1); + tstate->tracing--; + __Pyx_ErrRestoreInState(tstate, type, value, traceback); + } + #ifdef WITH_THREAD + #define __Pyx_TraceReturn(result, nogil)\ + if (likely(!__Pyx_use_tracing)); else {\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + PyThreadState *tstate;\ + PyGILState_STATE state = PyGILState_Ensure();\ + tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ + }\ + PyGILState_Release(state);\ + }\ + } else {\ + PyThreadState* tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ + }\ + }\ + } + #else + #define __Pyx_TraceReturn(result, nogil)\ + if (likely(!__Pyx_use_tracing)); else {\ + PyThreadState* tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ + }\ + } + #endif + static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno); + static int __Pyx_TraceSetupAndCall(PyCodeObject** code, PyFrameObject** frame, PyThreadState* tstate, const char *funcname, const char *srcfile, int firstlineno); +#else + #define __Pyx_TraceDeclarations + #define __Pyx_TraceFrameInit(codeobj) + #define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error) if ((1)); else goto_error; + #define __Pyx_TraceException() + #define __Pyx_TraceReturn(result, nogil) +#endif +#if CYTHON_TRACE + static int __Pyx_call_line_trace_func(PyThreadState *tstate, PyFrameObject *frame, int lineno) { + int ret; + PyObject *type, *value, *traceback; + __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); + __Pyx_PyFrame_SetLineNumber(frame, lineno); + tstate->tracing++; + __Pyx_SetTracing(tstate, 0); + ret = tstate->c_tracefunc(tstate->c_traceobj, frame, PyTrace_LINE, NULL); + __Pyx_SetTracing(tstate, 1); + tstate->tracing--; + if (likely(!ret)) { + __Pyx_ErrRestoreInState(tstate, type, value, traceback); + } else { + Py_XDECREF(type); + Py_XDECREF(value); + Py_XDECREF(traceback); + } + return ret; + } + #ifdef WITH_THREAD + #define __Pyx_TraceLine(lineno, nogil, goto_error)\ + if (likely(!__Pyx_use_tracing)); else {\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + int ret = 0;\ + PyThreadState *tstate;\ + PyGILState_STATE state = PyGILState_Ensure();\ + tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && __pyx_frame->f_trace) {\ + ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ + }\ + PyGILState_Release(state);\ + if (unlikely(ret)) goto_error;\ + }\ + } else {\ + PyThreadState* tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && __pyx_frame->f_trace) {\ + int ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ + if (unlikely(ret)) goto_error;\ + }\ + }\ + } + #else + #define __Pyx_TraceLine(lineno, nogil, goto_error)\ + if (likely(!__Pyx_use_tracing)); else {\ + PyThreadState* tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && __pyx_frame->f_trace) {\ + int ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ + if (unlikely(ret)) goto_error;\ + }\ + } + #endif +#else + #define __Pyx_TraceLine(lineno, nogil, goto_error) if ((1)); else goto_error; +#endif + /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS #define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) @@ -1391,42 +1646,6 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObjec PyObject_Format(s, f)) #endif -/* PyThreadStateGet.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; -#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; -#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type -#else -#define __Pyx_PyThreadState_declare -#define __Pyx_PyThreadState_assign -#define __Pyx_PyErr_Occurred() PyErr_Occurred() -#endif - -/* PyErrFetchRestore.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) -#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) -#else -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) -#endif -#else -#define __Pyx_PyErr_Clear() PyErr_Clear() -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) -#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) -#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) -#endif - /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); @@ -1909,6 +2128,7 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_fiel Py_ssize_t __pyx_v_i; PyObject *__pyx_v_value = NULL; arma::field __pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; PyObject *__pyx_t_2 = NULL; @@ -1923,6 +2143,7 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_fiel const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("list_to_sp_dmat_field", 0); + __Pyx_TraceCall("list_to_sp_dmat_field", __pyx_f[0], 87, 0, __PYX_ERR(0, 87, __pyx_L1_error)); /* "l0learn/cyarma.pyx":88 * @cython.boundscheck(False) @@ -1931,6 +2152,7 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_fiel * for i, value in enumerate(values): * if not isinstance(value, csc_matrix) or value.ndim != 2 or not np.isrealobj(value): */ + __Pyx_TraceLine(88,0,__PYX_ERR(0, 88, __pyx_L1_error)) if (unlikely(__pyx_v_values == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(0, 88, __pyx_L1_error) @@ -1945,6 +2167,7 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_fiel * if not isinstance(value, csc_matrix) or value.ndim != 2 or not np.isrealobj(value): * raise TypeError(f"expected each value in values to be a 2D real csc_matrix, but got {value}") */ + __Pyx_TraceLine(89,0,__PYX_ERR(0, 89, __pyx_L1_error)) __pyx_t_1 = 0; __pyx_t_2 = __pyx_v_values; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; for (;;) { @@ -1967,6 +2190,7 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_fiel * raise TypeError(f"expected each value in values to be a 2D real csc_matrix, but got {value}") * f[i] = numpy_to_sp_dmat_d(value) */ + __Pyx_TraceLine(90,0,__PYX_ERR(0, 90, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 90, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = PyObject_IsInstance(__pyx_v_value, __pyx_t_4); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 90, __pyx_L1_error) @@ -2023,6 +2247,7 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_fiel * f[i] = numpy_to_sp_dmat_d(value) * return f */ + __Pyx_TraceLine(91,0,__PYX_ERR(0, 91, __pyx_L1_error)) __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_value, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 91, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_each_value_in_values_to, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 91, __pyx_L1_error) @@ -2051,6 +2276,7 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_fiel * return f * */ + __Pyx_TraceLine(92,0,__PYX_ERR(0, 92, __pyx_L1_error)) (__pyx_v_f[__pyx_v_i]) = __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(__pyx_v_value); /* "l0learn/cyarma.pyx":89 @@ -2060,6 +2286,7 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_fiel * if not isinstance(value, csc_matrix) or value.ndim != 2 or not np.isrealobj(value): * raise TypeError(f"expected each value in values to be a 2D real csc_matrix, but got {value}") */ + __Pyx_TraceLine(89,0,__PYX_ERR(0, 89, __pyx_L1_error)) } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -2070,6 +2297,7 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_fiel * * */ + __Pyx_TraceLine(93,0,__PYX_ERR(0, 93, __pyx_L1_error)) __pyx_r = __pyx_v_f; goto __pyx_L0; @@ -2091,6 +2319,7 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_fiel __Pyx_pretend_to_initialize(&__pyx_r); __pyx_L0:; __Pyx_XDECREF(__pyx_v_value); + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2108,6 +2337,7 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_dvec_field(PyOb Py_ssize_t __pyx_v_i; PyObject *__pyx_v_value = NULL; arma::field __pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; PyObject *__pyx_t_2 = NULL; @@ -2122,6 +2352,7 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_dvec_field(PyOb const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("list_to_dvec_field", 0); + __Pyx_TraceCall("list_to_dvec_field", __pyx_f[0], 97, 0, __PYX_ERR(0, 97, __pyx_L1_error)); /* "l0learn/cyarma.pyx":98 * @cython.boundscheck(False) @@ -2130,6 +2361,7 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_dvec_field(PyOb * for i, value in enumerate(values): * if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isrealobj(value): */ + __Pyx_TraceLine(98,0,__PYX_ERR(0, 98, __pyx_L1_error)) if (unlikely(__pyx_v_values == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(0, 98, __pyx_L1_error) @@ -2144,6 +2376,7 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_dvec_field(PyOb * if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isrealobj(value): * raise TypeError(f"expected each value in values to be a 1D real numpy matrix, but got {value}") */ + __Pyx_TraceLine(99,0,__PYX_ERR(0, 99, __pyx_L1_error)) __pyx_t_1 = 0; __pyx_t_2 = __pyx_v_values; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; for (;;) { @@ -2166,6 +2399,7 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_dvec_field(PyOb * raise TypeError(f"expected each value in values to be a 1D real numpy matrix, but got {value}") * f[i] = numpy_to_dvec_d(value) */ + __Pyx_TraceLine(100,0,__PYX_ERR(0, 100, __pyx_L1_error)) __pyx_t_6 = __Pyx_TypeCheck(__pyx_v_value, __pyx_ptype_5numpy_ndarray); __pyx_t_7 = ((!(__pyx_t_6 != 0)) != 0); if (!__pyx_t_7) { @@ -2219,6 +2453,7 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_dvec_field(PyOb * f[i] = numpy_to_dvec_d(value) * return f */ + __Pyx_TraceLine(101,0,__PYX_ERR(0, 101, __pyx_L1_error)) __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_value, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 101, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_each_value_in_values_to_2, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 101, __pyx_L1_error) @@ -2247,6 +2482,7 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_dvec_field(PyOb * return f * */ + __Pyx_TraceLine(102,0,__PYX_ERR(0, 102, __pyx_L1_error)) if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 102, __pyx_L1_error) (__pyx_v_f[__pyx_v_i]) = __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_value)); @@ -2257,6 +2493,7 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_dvec_field(PyOb * if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isrealobj(value): * raise TypeError(f"expected each value in values to be a 1D real numpy matrix, but got {value}") */ + __Pyx_TraceLine(99,0,__PYX_ERR(0, 99, __pyx_L1_error)) } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -2267,6 +2504,7 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_dvec_field(PyOb * * */ + __Pyx_TraceLine(103,0,__PYX_ERR(0, 103, __pyx_L1_error)) __pyx_r = __pyx_v_f; goto __pyx_L0; @@ -2288,6 +2526,7 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_dvec_field(PyOb __Pyx_pretend_to_initialize(&__pyx_r); __pyx_L0:; __Pyx_XDECREF(__pyx_v_value); + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2305,6 +2544,7 @@ static arma::dmat *__pyx_f_7l0learn_6cyarma_numpy_to_dmat(PyArrayObject *__pyx_v __Pyx_LocalBuf_ND __pyx_pybuffernd_X; __Pyx_Buffer __pyx_pybuffer_X; arma::dmat *__pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; @@ -2320,6 +2560,7 @@ static arma::dmat *__pyx_f_7l0learn_6cyarma_numpy_to_dmat(PyArrayObject *__pyx_v const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("numpy_to_dmat", 0); + __Pyx_TraceCall("numpy_to_dmat", __pyx_f[0], 106, 0, __PYX_ERR(0, 106, __pyx_L1_error)); __Pyx_INCREF((PyObject *)__pyx_v_X); __pyx_pybuffer_X.pybuffer.buf = NULL; __pyx_pybuffer_X.refcount = 0; @@ -2338,6 +2579,7 @@ static arma::dmat *__pyx_f_7l0learn_6cyarma_numpy_to_dmat(PyArrayObject *__pyx_v * X = X.copy(order="F") * cdef dmat *aR_p = new dmat( X.data, X.shape[0], X.shape[1], False, True) */ + __Pyx_TraceLine(111,0,__PYX_ERR(0, 111, __pyx_L1_error)) __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_X), __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 111, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_f_contiguous); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 111, __pyx_L1_error) @@ -2369,6 +2611,7 @@ static arma::dmat *__pyx_f_7l0learn_6cyarma_numpy_to_dmat(PyArrayObject *__pyx_v * cdef dmat *aR_p = new dmat( X.data, X.shape[0], X.shape[1], False, True) * return aR_p */ + __Pyx_TraceLine(112,0,__PYX_ERR(0, 112, __pyx_L1_error)) __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_X), __pyx_n_s_copy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 112, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 112, __pyx_L1_error) @@ -2417,6 +2660,7 @@ static arma::dmat *__pyx_f_7l0learn_6cyarma_numpy_to_dmat(PyArrayObject *__pyx_v * return aR_p * */ + __Pyx_TraceLine(113,0,__PYX_ERR(0, 113, __pyx_L1_error)) __pyx_v_aR_p = new arma::dmat(((double *)__pyx_v_X->data), (__pyx_v_X->dimensions[0]), (__pyx_v_X->dimensions[1]), 0, 1); /* "l0learn/cyarma.pyx":114 @@ -2426,6 +2670,7 @@ static arma::dmat *__pyx_f_7l0learn_6cyarma_numpy_to_dmat(PyArrayObject *__pyx_v * * cdef dmat numpy_to_dmat_d(np.ndarray[np.double_t, ndim=2] X): */ + __Pyx_TraceLine(114,0,__PYX_ERR(0, 114, __pyx_L1_error)) __pyx_r = __pyx_v_aR_p; goto __pyx_L0; @@ -2455,6 +2700,7 @@ static arma::dmat *__pyx_f_7l0learn_6cyarma_numpy_to_dmat(PyArrayObject *__pyx_v __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_X.rcbuffer->pybuffer); __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_X); + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2473,11 +2719,13 @@ static arma::dmat __pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(PyArrayObject *__pyx_ __Pyx_LocalBuf_ND __pyx_pybuffernd_X; __Pyx_Buffer __pyx_pybuffer_X; arma::dmat __pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("numpy_to_dmat_d", 0); + __Pyx_TraceCall("numpy_to_dmat_d", __pyx_f[0], 116, 0, __PYX_ERR(0, 116, __pyx_L1_error)); __pyx_pybuffer_X.pybuffer.buf = NULL; __pyx_pybuffer_X.refcount = 0; __pyx_pybuffernd_X.data = NULL; @@ -2495,6 +2743,7 @@ static arma::dmat __pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(PyArrayObject *__pyx_ * cdef dmat aR = deref(aR_p) * del aR_p */ + __Pyx_TraceLine(117,0,__PYX_ERR(0, 117, __pyx_L1_error)) __pyx_v_aR_p = __pyx_f_7l0learn_6cyarma_numpy_to_dmat(((PyArrayObject *)__pyx_v_X)); /* "l0learn/cyarma.pyx":118 @@ -2504,6 +2753,7 @@ static arma::dmat __pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(PyArrayObject *__pyx_ * del aR_p * return aR */ + __Pyx_TraceLine(118,0,__PYX_ERR(0, 118, __pyx_L1_error)) __pyx_v_aR = (*__pyx_v_aR_p); /* "l0learn/cyarma.pyx":119 @@ -2513,6 +2763,7 @@ static arma::dmat __pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(PyArrayObject *__pyx_ * return aR * */ + __Pyx_TraceLine(119,0,__PYX_ERR(0, 119, __pyx_L1_error)) delete __pyx_v_aR_p; /* "l0learn/cyarma.pyx":120 @@ -2522,6 +2773,7 @@ static arma::dmat __pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(PyArrayObject *__pyx_ * * cdef dvec * numpy_to_dvec(np.ndarray[np.double_t, ndim=1] x): */ + __Pyx_TraceLine(120,0,__PYX_ERR(0, 120, __pyx_L1_error)) __pyx_r = __pyx_v_aR; goto __pyx_L0; @@ -2547,6 +2799,7 @@ static arma::dmat __pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(PyArrayObject *__pyx_ __pyx_L0:; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_X.rcbuffer->pybuffer); __pyx_L2:; + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2564,6 +2817,7 @@ static arma::dvec *__pyx_f_7l0learn_6cyarma_numpy_to_dvec(PyArrayObject *__pyx_v __Pyx_LocalBuf_ND __pyx_pybuffernd_x; __Pyx_Buffer __pyx_pybuffer_x; arma::dvec *__pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; @@ -2579,6 +2833,7 @@ static arma::dvec *__pyx_f_7l0learn_6cyarma_numpy_to_dvec(PyArrayObject *__pyx_v const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("numpy_to_dvec", 0); + __Pyx_TraceCall("numpy_to_dvec", __pyx_f[0], 122, 0, __PYX_ERR(0, 122, __pyx_L1_error)); __Pyx_INCREF((PyObject *)__pyx_v_x); __pyx_pybuffer_x.pybuffer.buf = NULL; __pyx_pybuffer_x.refcount = 0; @@ -2597,6 +2852,7 @@ static arma::dvec *__pyx_f_7l0learn_6cyarma_numpy_to_dvec(PyArrayObject *__pyx_v * x = x.copy() * cdef dvec *ar_p = new dvec( x.data, x.shape[0], False, True) */ + __Pyx_TraceLine(123,0,__PYX_ERR(0, 123, __pyx_L1_error)) __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_x), __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_f_contiguous); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 123, __pyx_L1_error) @@ -2628,6 +2884,7 @@ static arma::dvec *__pyx_f_7l0learn_6cyarma_numpy_to_dvec(PyArrayObject *__pyx_v * cdef dvec *ar_p = new dvec( x.data, x.shape[0], False, True) * return ar_p */ + __Pyx_TraceLine(124,0,__PYX_ERR(0, 124, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_x), __pyx_n_s_copy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 124, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = NULL; @@ -2684,6 +2941,7 @@ static arma::dvec *__pyx_f_7l0learn_6cyarma_numpy_to_dvec(PyArrayObject *__pyx_v * return ar_p * */ + __Pyx_TraceLine(125,0,__PYX_ERR(0, 125, __pyx_L1_error)) __pyx_v_ar_p = new arma::dvec(((double *)__pyx_v_x->data), (__pyx_v_x->dimensions[0]), 0, 1); /* "l0learn/cyarma.pyx":126 @@ -2693,6 +2951,7 @@ static arma::dvec *__pyx_f_7l0learn_6cyarma_numpy_to_dvec(PyArrayObject *__pyx_v * * cdef dvec numpy_to_dvec_d(np.ndarray[np.double_t, ndim=1] x): */ + __Pyx_TraceLine(126,0,__PYX_ERR(0, 126, __pyx_L1_error)) __pyx_r = __pyx_v_ar_p; goto __pyx_L0; @@ -2722,6 +2981,7 @@ static arma::dvec *__pyx_f_7l0learn_6cyarma_numpy_to_dvec(PyArrayObject *__pyx_v __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_x); + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2740,11 +3000,13 @@ static arma::dvec __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(PyArrayObject *__pyx_ __Pyx_LocalBuf_ND __pyx_pybuffernd_x; __Pyx_Buffer __pyx_pybuffer_x; arma::dvec __pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("numpy_to_dvec_d", 0); + __Pyx_TraceCall("numpy_to_dvec_d", __pyx_f[0], 128, 0, __PYX_ERR(0, 128, __pyx_L1_error)); __pyx_pybuffer_x.pybuffer.buf = NULL; __pyx_pybuffer_x.refcount = 0; __pyx_pybuffernd_x.data = NULL; @@ -2762,6 +3024,7 @@ static arma::dvec __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(PyArrayObject *__pyx_ * cdef dvec ar = deref(ar_p) * del ar_p */ + __Pyx_TraceLine(129,0,__PYX_ERR(0, 129, __pyx_L1_error)) __pyx_v_ar_p = __pyx_f_7l0learn_6cyarma_numpy_to_dvec(((PyArrayObject *)__pyx_v_x)); /* "l0learn/cyarma.pyx":130 @@ -2771,6 +3034,7 @@ static arma::dvec __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(PyArrayObject *__pyx_ * del ar_p * return ar */ + __Pyx_TraceLine(130,0,__PYX_ERR(0, 130, __pyx_L1_error)) __pyx_v_ar = (*__pyx_v_ar_p); /* "l0learn/cyarma.pyx":131 @@ -2780,6 +3044,7 @@ static arma::dvec __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(PyArrayObject *__pyx_ * return ar * */ + __Pyx_TraceLine(131,0,__PYX_ERR(0, 131, __pyx_L1_error)) delete __pyx_v_ar_p; /* "l0learn/cyarma.pyx":132 @@ -2789,6 +3054,7 @@ static arma::dvec __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(PyArrayObject *__pyx_ * * cdef uvec * numpy_to_uvec(np.ndarray[np.uint64_t, ndim=1] x): */ + __Pyx_TraceLine(132,0,__PYX_ERR(0, 132, __pyx_L1_error)) __pyx_r = __pyx_v_ar; goto __pyx_L0; @@ -2814,6 +3080,7 @@ static arma::dvec __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(PyArrayObject *__pyx_ __pyx_L0:; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); __pyx_L2:; + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2831,6 +3098,7 @@ static arma::uvec *__pyx_f_7l0learn_6cyarma_numpy_to_uvec(PyArrayObject *__pyx_v __Pyx_LocalBuf_ND __pyx_pybuffernd_x; __Pyx_Buffer __pyx_pybuffer_x; arma::uvec *__pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; @@ -2846,6 +3114,7 @@ static arma::uvec *__pyx_f_7l0learn_6cyarma_numpy_to_uvec(PyArrayObject *__pyx_v const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("numpy_to_uvec", 0); + __Pyx_TraceCall("numpy_to_uvec", __pyx_f[0], 134, 0, __PYX_ERR(0, 134, __pyx_L1_error)); __Pyx_INCREF((PyObject *)__pyx_v_x); __pyx_pybuffer_x.pybuffer.buf = NULL; __pyx_pybuffer_x.refcount = 0; @@ -2864,6 +3133,7 @@ static arma::uvec *__pyx_f_7l0learn_6cyarma_numpy_to_uvec(PyArrayObject *__pyx_v * x = x.copy() * cdef uvec *ar_p = new uvec( x.data, x.shape[0], False, True) */ + __Pyx_TraceLine(135,0,__PYX_ERR(0, 135, __pyx_L1_error)) __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_x), __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 135, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_f_contiguous); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 135, __pyx_L1_error) @@ -2895,6 +3165,7 @@ static arma::uvec *__pyx_f_7l0learn_6cyarma_numpy_to_uvec(PyArrayObject *__pyx_v * cdef uvec *ar_p = new uvec( x.data, x.shape[0], False, True) * return ar_p */ + __Pyx_TraceLine(136,0,__PYX_ERR(0, 136, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_x), __pyx_n_s_copy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 136, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = NULL; @@ -2951,6 +3222,7 @@ static arma::uvec *__pyx_f_7l0learn_6cyarma_numpy_to_uvec(PyArrayObject *__pyx_v * return ar_p * */ + __Pyx_TraceLine(137,0,__PYX_ERR(0, 137, __pyx_L1_error)) __pyx_v_ar_p = new arma::uvec(((unsigned PY_LONG_LONG *)__pyx_v_x->data), (__pyx_v_x->dimensions[0]), 0, 1); /* "l0learn/cyarma.pyx":138 @@ -2960,6 +3232,7 @@ static arma::uvec *__pyx_f_7l0learn_6cyarma_numpy_to_uvec(PyArrayObject *__pyx_v * * cdef uvec numpy_to_uvec_d(np.ndarray[np.uint64_t, ndim=1] x): */ + __Pyx_TraceLine(138,0,__PYX_ERR(0, 138, __pyx_L1_error)) __pyx_r = __pyx_v_ar_p; goto __pyx_L0; @@ -2989,6 +3262,7 @@ static arma::uvec *__pyx_f_7l0learn_6cyarma_numpy_to_uvec(PyArrayObject *__pyx_v __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_x); + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3007,11 +3281,13 @@ static arma::uvec __pyx_f_7l0learn_6cyarma_numpy_to_uvec_d(PyArrayObject *__pyx_ __Pyx_LocalBuf_ND __pyx_pybuffernd_x; __Pyx_Buffer __pyx_pybuffer_x; arma::uvec __pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("numpy_to_uvec_d", 0); + __Pyx_TraceCall("numpy_to_uvec_d", __pyx_f[0], 140, 0, __PYX_ERR(0, 140, __pyx_L1_error)); __pyx_pybuffer_x.pybuffer.buf = NULL; __pyx_pybuffer_x.refcount = 0; __pyx_pybuffernd_x.data = NULL; @@ -3029,6 +3305,7 @@ static arma::uvec __pyx_f_7l0learn_6cyarma_numpy_to_uvec_d(PyArrayObject *__pyx_ * cdef uvec ar = deref(ar_p) * del ar_p */ + __Pyx_TraceLine(141,0,__PYX_ERR(0, 141, __pyx_L1_error)) __pyx_v_ar_p = __pyx_f_7l0learn_6cyarma_numpy_to_uvec(((PyArrayObject *)__pyx_v_x)); /* "l0learn/cyarma.pyx":142 @@ -3038,6 +3315,7 @@ static arma::uvec __pyx_f_7l0learn_6cyarma_numpy_to_uvec_d(PyArrayObject *__pyx_ * del ar_p * return ar */ + __Pyx_TraceLine(142,0,__PYX_ERR(0, 142, __pyx_L1_error)) __pyx_v_ar = (*__pyx_v_ar_p); /* "l0learn/cyarma.pyx":143 @@ -3047,6 +3325,7 @@ static arma::uvec __pyx_f_7l0learn_6cyarma_numpy_to_uvec_d(PyArrayObject *__pyx_ * return ar * */ + __Pyx_TraceLine(143,0,__PYX_ERR(0, 143, __pyx_L1_error)) delete __pyx_v_ar_p; /* "l0learn/cyarma.pyx":144 @@ -3056,6 +3335,7 @@ static arma::uvec __pyx_f_7l0learn_6cyarma_numpy_to_uvec_d(PyArrayObject *__pyx_ * * */ + __Pyx_TraceLine(144,0,__PYX_ERR(0, 144, __pyx_L1_error)) __pyx_r = __pyx_v_ar; goto __pyx_L0; @@ -3081,6 +3361,7 @@ static arma::uvec __pyx_f_7l0learn_6cyarma_numpy_to_uvec_d(PyArrayObject *__pyx_ __pyx_L0:; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); __pyx_L2:; + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3108,6 +3389,7 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ __Pyx_LocalBuf_ND __pyx_pybuffernd_indptr; __Pyx_Buffer __pyx_pybuffer_indptr; arma::sp_dmat *__pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; @@ -3126,6 +3408,7 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("numpy_to_sp_dmat", 0); + __Pyx_TraceCall("numpy_to_sp_dmat", __pyx_f[0], 147, 0, __PYX_ERR(0, 147, __pyx_L1_error)); __pyx_pybuffer_data.pybuffer.buf = NULL; __pyx_pybuffer_data.refcount = 0; __pyx_pybuffernd_data.data = NULL; @@ -3146,6 +3429,7 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ * raise ValueError(f"expected x to be of type {csc_matrix}, but got {type(x)}") * */ + __Pyx_TraceLine(148,0,__PYX_ERR(0, 148, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 148, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyObject_IsInstance(__pyx_v_x, __pyx_t_1); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 148, __pyx_L1_error) @@ -3160,6 +3444,7 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ * * cdef np.ndarray[np.double_t, ndim=1] data = x.data */ + __Pyx_TraceLine(149,0,__PYX_ERR(0, 149, __pyx_L1_error)) __pyx_t_1 = PyTuple_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 149, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = 0; @@ -3215,6 +3500,7 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ * cdef dvec values = numpy_to_dvec_d(data) * */ + __Pyx_TraceLine(151,0,__PYX_ERR(0, 151, __pyx_L1_error)) __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 151, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 151, __pyx_L1_error) @@ -3238,6 +3524,7 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ * * cdef np.ndarray[np.uint64_t, ndim=1] indptr = x.indptr.astype(np.uint64) */ + __Pyx_TraceLine(152,0,__PYX_ERR(0, 152, __pyx_L1_error)) __pyx_v_values = __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_data)); /* "l0learn/cyarma.pyx":154 @@ -3247,6 +3534,7 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ * cdef uvec colptr = numpy_to_uvec_d(indptr) * */ + __Pyx_TraceLine(154,0,__PYX_ERR(0, 154, __pyx_L1_error)) __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_indptr); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_astype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 154, __pyx_L1_error) @@ -3294,6 +3582,7 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ * * cdef np.ndarray[np.uint64_t, ndim=1] indices = x.indices.astype(np.uint64) */ + __Pyx_TraceLine(155,0,__PYX_ERR(0, 155, __pyx_L1_error)) __pyx_v_colptr = __pyx_f_7l0learn_6cyarma_numpy_to_uvec_d(((PyArrayObject *)__pyx_v_indptr)); /* "l0learn/cyarma.pyx":157 @@ -3303,6 +3592,7 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ * cdef uvec rowind = numpy_to_uvec_d(indices) * */ + __Pyx_TraceLine(157,0,__PYX_ERR(0, 157, __pyx_L1_error)) __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_indices); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 157, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_astype); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 157, __pyx_L1_error) @@ -3350,6 +3640,7 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ * * cdef sp_dmat * ar = new sp_dmat(rowind, colptr, values, x.shape[0], x.shape[1]) */ + __Pyx_TraceLine(158,0,__PYX_ERR(0, 158, __pyx_L1_error)) __pyx_v_rowind = __pyx_f_7l0learn_6cyarma_numpy_to_uvec_d(((PyArrayObject *)__pyx_v_indices)); /* "l0learn/cyarma.pyx":160 @@ -3359,6 +3650,7 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ * * return ar */ + __Pyx_TraceLine(160,0,__PYX_ERR(0, 160, __pyx_L1_error)) __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 160, __pyx_L1_error) @@ -3382,6 +3674,7 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ * * */ + __Pyx_TraceLine(162,0,__PYX_ERR(0, 162, __pyx_L1_error)) __pyx_r = __pyx_v_ar; goto __pyx_L0; @@ -3418,6 +3711,7 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ __Pyx_XDECREF((PyObject *)__pyx_v_data); __Pyx_XDECREF((PyObject *)__pyx_v_indptr); __Pyx_XDECREF((PyObject *)__pyx_v_indices); + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3434,8 +3728,13 @@ static arma::sp_dmat __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(PyObject *__pyx arma::sp_dmat *__pyx_v_ar_p; arma::sp_dmat __pyx_v_ar; arma::sp_dmat __pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("numpy_to_sp_dmat_d", 0); + __Pyx_TraceCall("numpy_to_sp_dmat_d", __pyx_f[0], 165, 0, __PYX_ERR(0, 165, __pyx_L1_error)); /* "l0learn/cyarma.pyx":166 * @@ -3444,6 +3743,7 @@ static arma::sp_dmat __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(PyObject *__pyx * cdef sp_dmat ar = deref(ar_p) * del ar_p */ + __Pyx_TraceLine(166,0,__PYX_ERR(0, 166, __pyx_L1_error)) __pyx_v_ar_p = __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(__pyx_v_x); /* "l0learn/cyarma.pyx":167 @@ -3453,6 +3753,7 @@ static arma::sp_dmat __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(PyObject *__pyx * del ar_p * return ar */ + __Pyx_TraceLine(167,0,__PYX_ERR(0, 167, __pyx_L1_error)) __pyx_v_ar = (*__pyx_v_ar_p); /* "l0learn/cyarma.pyx":168 @@ -3462,6 +3763,7 @@ static arma::sp_dmat __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(PyObject *__pyx * return ar * */ + __Pyx_TraceLine(168,0,__PYX_ERR(0, 168, __pyx_L1_error)) delete __pyx_v_ar_p; /* "l0learn/cyarma.pyx":169 @@ -3471,6 +3773,7 @@ static arma::sp_dmat __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(PyObject *__pyx * * ##### Converting back to l0learn arrays, must pass preallocated memory or None */ + __Pyx_TraceLine(169,0,__PYX_ERR(0, 169, __pyx_L1_error)) __pyx_r = __pyx_v_ar; goto __pyx_L0; @@ -3483,7 +3786,11 @@ static arma::sp_dmat __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(PyObject *__pyx */ /* function exit code */ + __pyx_L1_error:; + __Pyx_WriteUnraisable("l0learn.cyarma.numpy_to_sp_dmat_d", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __Pyx_pretend_to_initialize(&__pyx_r); __pyx_L0:; + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3500,6 +3807,7 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(arma::field D.data */ + __Pyx_TraceLine(196,0,__PYX_ERR(0, 196, __pyx_L1_error)) __pyx_t_1 = (((PyObject *)__pyx_v_D) == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { @@ -3744,6 +4069,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dmat_to_numpy(arma::dmat const &_ * cdef double * Dptr = D.data * for i in range(X.n_rows*X.n_cols): */ + __Pyx_TraceLine(197,0,__PYX_ERR(0, 197, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 197, __pyx_L1_error) @@ -3820,6 +4146,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dmat_to_numpy(arma::dmat const &_ * for i in range(X.n_rows*X.n_cols): * Dptr[i] = Xptr[i] */ + __Pyx_TraceLine(198,0,__PYX_ERR(0, 198, __pyx_L1_error)) __pyx_v_Dptr = ((double *)__pyx_v_D->data); /* "l0learn/cyarma.pyx":199 @@ -3829,6 +4156,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dmat_to_numpy(arma::dmat const &_ * Dptr[i] = Xptr[i] * return D */ + __Pyx_TraceLine(199,0,__PYX_ERR(0, 199, __pyx_L1_error)) __pyx_t_9 = (__pyx_v_X.n_rows * __pyx_v_X.n_cols); __pyx_t_13 = __pyx_t_9; for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { @@ -3841,6 +4169,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dmat_to_numpy(arma::dmat const &_ * return D * */ + __Pyx_TraceLine(200,0,__PYX_ERR(0, 200, __pyx_L1_error)) (__pyx_v_Dptr[__pyx_v_i]) = (__pyx_v_Xptr[__pyx_v_i]); } @@ -3851,6 +4180,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dmat_to_numpy(arma::dmat const &_ * * @cython.boundscheck(False) */ + __Pyx_TraceLine(201,0,__PYX_ERR(0, 201, __pyx_L1_error)) __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v_D)); __pyx_r = ((PyArrayObject *)__pyx_v_D); @@ -3885,6 +4215,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dmat_to_numpy(arma::dmat const &_ __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_D); __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3904,6 +4235,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &_ __Pyx_LocalBuf_ND __pyx_pybuffernd_D; __Pyx_Buffer __pyx_pybuffer_D; PyArrayObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; @@ -3923,6 +4255,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &_ const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("dvec_to_numpy", 0); + __Pyx_TraceCall("dvec_to_numpy", __pyx_f[0], 204, 0, __PYX_ERR(0, 204, __pyx_L1_error)); __Pyx_INCREF((PyObject *)__pyx_v_D); __pyx_pybuffer_D.pybuffer.buf = NULL; __pyx_pybuffer_D.refcount = 0; @@ -3941,6 +4274,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &_ * * if D is None: */ + __Pyx_TraceLine(205,0,__PYX_ERR(0, 205, __pyx_L1_error)) __pyx_v_Xptr = __pyx_v_X.memptr(); /* "l0learn/cyarma.pyx":207 @@ -3950,6 +4284,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &_ * D = np.empty(X.n_elem, dtype=np.double) * cdef double * Dptr = D.data */ + __Pyx_TraceLine(207,0,__PYX_ERR(0, 207, __pyx_L1_error)) __pyx_t_1 = (((PyObject *)__pyx_v_D) == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { @@ -3961,6 +4296,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &_ * cdef double * Dptr = D.data * for i in range(X.n_elem): */ + __Pyx_TraceLine(208,0,__PYX_ERR(0, 208, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 208, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 208, __pyx_L1_error) @@ -4026,6 +4362,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &_ * for i in range(X.n_elem): * Dptr[i] = Xptr[i] */ + __Pyx_TraceLine(209,0,__PYX_ERR(0, 209, __pyx_L1_error)) __pyx_v_Dptr = ((double *)__pyx_v_D->data); /* "l0learn/cyarma.pyx":210 @@ -4035,6 +4372,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &_ * Dptr[i] = Xptr[i] * return D */ + __Pyx_TraceLine(210,0,__PYX_ERR(0, 210, __pyx_L1_error)) __pyx_t_9 = __pyx_v_X.n_elem; __pyx_t_13 = __pyx_t_9; for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { @@ -4047,6 +4385,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &_ * return D * */ + __Pyx_TraceLine(211,0,__PYX_ERR(0, 211, __pyx_L1_error)) (__pyx_v_Dptr[__pyx_v_i]) = (__pyx_v_Xptr[__pyx_v_i]); } @@ -4057,6 +4396,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &_ * * */ + __Pyx_TraceLine(212,0,__PYX_ERR(0, 212, __pyx_L1_error)) __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v_D)); __pyx_r = ((PyArrayObject *)__pyx_v_D); @@ -4091,6 +4431,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &_ __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_D); __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -4110,6 +4451,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &_ __Pyx_LocalBuf_ND __pyx_pybuffernd_D; __Pyx_Buffer __pyx_pybuffer_D; PyArrayObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; @@ -4129,6 +4471,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &_ const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("uvec_to_numpy", 0); + __Pyx_TraceCall("uvec_to_numpy", __pyx_f[0], 216, 0, __PYX_ERR(0, 216, __pyx_L1_error)); __Pyx_INCREF((PyObject *)__pyx_v_D); __pyx_pybuffer_D.pybuffer.buf = NULL; __pyx_pybuffer_D.refcount = 0; @@ -4147,6 +4490,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &_ * * if D is None: */ + __Pyx_TraceLine(217,0,__PYX_ERR(0, 217, __pyx_L1_error)) __pyx_v_Xptr = __pyx_v_X.memptr(); /* "l0learn/cyarma.pyx":219 @@ -4156,6 +4500,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &_ * D = np.empty(X.n_elem, dtype=np.uint64) * cdef unsigned long long * Dptr = D.data */ + __Pyx_TraceLine(219,0,__PYX_ERR(0, 219, __pyx_L1_error)) __pyx_t_1 = (((PyObject *)__pyx_v_D) == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { @@ -4167,6 +4512,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &_ * cdef unsigned long long * Dptr = D.data * for i in range(X.n_elem): */ + __Pyx_TraceLine(220,0,__PYX_ERR(0, 220, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 220, __pyx_L1_error) @@ -4232,6 +4578,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &_ * for i in range(X.n_elem): * Dptr[i] = Xptr[i] */ + __Pyx_TraceLine(221,0,__PYX_ERR(0, 221, __pyx_L1_error)) __pyx_v_Dptr = ((unsigned PY_LONG_LONG *)__pyx_v_D->data); /* "l0learn/cyarma.pyx":222 @@ -4241,6 +4588,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &_ * Dptr[i] = Xptr[i] * return D */ + __Pyx_TraceLine(222,0,__PYX_ERR(0, 222, __pyx_L1_error)) __pyx_t_9 = __pyx_v_X.n_elem; __pyx_t_13 = __pyx_t_9; for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { @@ -4253,6 +4601,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &_ * return D * */ + __Pyx_TraceLine(223,0,__PYX_ERR(0, 223, __pyx_L1_error)) (__pyx_v_Dptr[__pyx_v_i]) = (__pyx_v_Xptr[__pyx_v_i]); } @@ -4263,6 +4612,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &_ * * */ + __Pyx_TraceLine(224,0,__PYX_ERR(0, 224, __pyx_L1_error)) __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v_D)); __pyx_r = ((PyArrayObject *)__pyx_v_D); @@ -4297,6 +4647,7 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &_ __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_D); __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -4319,6 +4670,7 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & __Pyx_LocalBuf_ND __pyx_pybuffernd_values; __Pyx_Buffer __pyx_pybuffer_values; PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; @@ -4342,6 +4694,7 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("sp_dmat_to_numpy", 0); + __Pyx_TraceCall("sp_dmat_to_numpy", __pyx_f[0], 228, 0, __PYX_ERR(0, 228, __pyx_L1_error)); __Pyx_INCREF((PyObject *)__pyx_v_rowind); __Pyx_INCREF((PyObject *)__pyx_v_colind); __Pyx_INCREF((PyObject *)__pyx_v_values); @@ -4380,6 +4733,7 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & * rowind = np.empty(X.n_nonzero, dtype=np.uint64) * if colind is None: */ + __Pyx_TraceLine(231,0,__PYX_ERR(0, 231, __pyx_L1_error)) __pyx_t_1 = (((PyObject *)__pyx_v_rowind) == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { @@ -4391,6 +4745,7 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & * if colind is None: * colind = np.empty(X.n_nonzero, dtype=np.uint64) */ + __Pyx_TraceLine(232,0,__PYX_ERR(0, 232, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 232, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 232, __pyx_L1_error) @@ -4456,6 +4811,7 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & * colind = np.empty(X.n_nonzero, dtype=np.uint64) * if values is None: */ + __Pyx_TraceLine(233,0,__PYX_ERR(0, 233, __pyx_L1_error)) __pyx_t_2 = (((PyObject *)__pyx_v_colind) == Py_None); __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { @@ -4467,6 +4823,7 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & * if values is None: * values = np.empty(X.n_nonzero, dtype=np.double) */ + __Pyx_TraceLine(234,0,__PYX_ERR(0, 234, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_empty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 234, __pyx_L1_error) @@ -4532,6 +4889,7 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & * values = np.empty(X.n_nonzero, dtype=np.double) * */ + __Pyx_TraceLine(235,0,__PYX_ERR(0, 235, __pyx_L1_error)) __pyx_t_1 = (((PyObject *)__pyx_v_values) == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { @@ -4543,6 +4901,7 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & * * cdef sp_dmat.const_iterator it = X.begin() */ + __Pyx_TraceLine(236,0,__PYX_ERR(0, 236, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 236, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_empty); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 236, __pyx_L1_error) @@ -4608,6 +4967,7 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & * * for i in range(X.n_nonzero): */ + __Pyx_TraceLine(238,0,__PYX_ERR(0, 238, __pyx_L1_error)) __pyx_v_it = __pyx_v_X.begin(); /* "l0learn/cyarma.pyx":240 @@ -4617,6 +4977,7 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & * # TODO: Double check the following comment... * # Arma is column major so rows are columns and columns are rows when converting back to l0learn (row major) */ + __Pyx_TraceLine(240,0,__PYX_ERR(0, 240, __pyx_L1_error)) __pyx_t_9 = __pyx_v_X.n_nonzero; __pyx_t_15 = __pyx_t_9; for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_15; __pyx_t_16+=1) { @@ -4629,6 +4990,7 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & * colind[i] = it.row() * values[i] = deref(it) */ + __Pyx_TraceLine(243,0,__PYX_ERR(0, 243, __pyx_L1_error)) __pyx_t_17 = __pyx_v_i; if (__pyx_t_17 < 0) __pyx_t_17 += __pyx_pybuffernd_rowind.diminfo[0].shape; *__Pyx_BufPtrStrided1d(__pyx_t_5numpy_uint64_t *, __pyx_pybuffernd_rowind.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_rowind.diminfo[0].strides) = __pyx_v_it.col(); @@ -4640,6 +5002,7 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & * values[i] = deref(it) * inc(it) */ + __Pyx_TraceLine(244,0,__PYX_ERR(0, 244, __pyx_L1_error)) __pyx_t_17 = __pyx_v_i; if (__pyx_t_17 < 0) __pyx_t_17 += __pyx_pybuffernd_colind.diminfo[0].shape; *__Pyx_BufPtrStrided1d(__pyx_t_5numpy_uint64_t *, __pyx_pybuffernd_colind.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_colind.diminfo[0].strides) = __pyx_v_it.row(); @@ -4651,6 +5014,7 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & * inc(it) * */ + __Pyx_TraceLine(245,0,__PYX_ERR(0, 245, __pyx_L1_error)) __pyx_t_17 = __pyx_v_i; if (__pyx_t_17 < 0) __pyx_t_17 += __pyx_pybuffernd_values.diminfo[0].shape; *__Pyx_BufPtrStrided1d(__pyx_t_5numpy_double_t *, __pyx_pybuffernd_values.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_values.diminfo[0].strides) = (*__pyx_v_it); @@ -4662,6 +5026,7 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & * * return csc_matrix((values, (colind, rowind)), shape=(X.n_rows, X.n_cols)) */ + __Pyx_TraceLine(246,0,__PYX_ERR(0, 246, __pyx_L1_error)) (void)((++__pyx_v_it)); } @@ -4670,6 +5035,7 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & * * return csc_matrix((values, (colind, rowind)), shape=(X.n_rows, X.n_cols)) # <<<<<<<<<<<<<< */ + __Pyx_TraceLine(248,0,__PYX_ERR(0, 248, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 248, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); @@ -4755,6 +5121,7 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & __Pyx_XDECREF((PyObject *)__pyx_v_colind); __Pyx_XDECREF((PyObject *)__pyx_v_values); __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -4769,12 +5136,14 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); + __Pyx_TraceCall("PyArray_MultiIterNew1", __pyx_f[1], 735, 0, __PYX_ERR(1, 735, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":736 * @@ -4783,6 +5152,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ * * cdef inline object PyArray_MultiIterNew2(a, b): */ + __Pyx_TraceLine(736,0,__PYX_ERR(1, 736, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 736, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -4805,6 +5175,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -4819,12 +5190,14 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); + __Pyx_TraceCall("PyArray_MultiIterNew2", __pyx_f[1], 738, 0, __PYX_ERR(1, 738, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":739 * @@ -4833,6 +5206,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ * * cdef inline object PyArray_MultiIterNew3(a, b, c): */ + __Pyx_TraceLine(739,0,__PYX_ERR(1, 739, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 739, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -4855,6 +5229,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -4869,12 +5244,14 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); + __Pyx_TraceCall("PyArray_MultiIterNew3", __pyx_f[1], 741, 0, __PYX_ERR(1, 741, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":742 * @@ -4883,6 +5260,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): */ + __Pyx_TraceLine(742,0,__PYX_ERR(1, 742, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 742, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -4905,6 +5283,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -4919,12 +5298,14 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); + __Pyx_TraceCall("PyArray_MultiIterNew4", __pyx_f[1], 744, 0, __PYX_ERR(1, 744, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":745 * @@ -4933,6 +5314,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): */ + __Pyx_TraceLine(745,0,__PYX_ERR(1, 745, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 745, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -4955,6 +5337,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -4969,12 +5352,14 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); + __Pyx_TraceCall("PyArray_MultiIterNew5", __pyx_f[1], 747, 0, __PYX_ERR(1, 747, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":748 * @@ -4983,6 +5368,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ * * cdef inline tuple PyDataType_SHAPE(dtype d): */ + __Pyx_TraceLine(748,0,__PYX_ERR(1, 748, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 748, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -5005,6 +5391,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5019,9 +5406,14 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); + __Pyx_TraceCall("PyDataType_SHAPE", __pyx_f[1], 750, 0, __PYX_ERR(1, 750, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":751 * @@ -5030,6 +5422,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ * return d.subarray.shape * else: */ + __Pyx_TraceLine(751,0,__PYX_ERR(1, 751, __pyx_L1_error)) __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); if (__pyx_t_1) { @@ -5040,6 +5433,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ * else: * return () */ + __Pyx_TraceLine(752,0,__PYX_ERR(1, 752, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); @@ -5061,6 +5455,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ * * */ + __Pyx_TraceLine(754,0,__PYX_ERR(1, 754, __pyx_L1_error)) /*else*/ { __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_empty_tuple); @@ -5077,8 +5472,12 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ */ /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("numpy.PyDataType_SHAPE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5092,8 +5491,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ */ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("set_array_base", 0); + __Pyx_TraceCall("set_array_base", __pyx_f[1], 929, 0, __PYX_ERR(1, 929, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":930 * @@ -5102,6 +5506,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a * PyArray_SetBaseObject(arr, base) * */ + __Pyx_TraceLine(930,0,__PYX_ERR(1, 930, __pyx_L1_error)) Py_INCREF(__pyx_v_base); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":931 @@ -5111,6 +5516,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a * * cdef inline object get_array_base(ndarray arr): */ + __Pyx_TraceLine(931,0,__PYX_ERR(1, 931, __pyx_L1_error)) (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":929 @@ -5122,6 +5528,11 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a */ /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_WriteUnraisable("numpy.set_array_base", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_L0:; + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); } @@ -5136,9 +5547,14 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { PyObject *__pyx_v_base; PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_array_base", 0); + __Pyx_TraceCall("get_array_base", __pyx_f[1], 933, 0, __PYX_ERR(1, 933, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":934 * @@ -5147,6 +5563,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py * if base is NULL: * return None */ + __Pyx_TraceLine(934,0,__PYX_ERR(1, 934, __pyx_L1_error)) __pyx_v_base = PyArray_BASE(__pyx_v_arr); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":935 @@ -5156,6 +5573,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py * return None * return base */ + __Pyx_TraceLine(935,0,__PYX_ERR(1, 935, __pyx_L1_error)) __pyx_t_1 = ((__pyx_v_base == NULL) != 0); if (__pyx_t_1) { @@ -5166,6 +5584,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py * return base * */ + __Pyx_TraceLine(936,0,__PYX_ERR(1, 936, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; @@ -5186,6 +5605,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py * * # Versions of the import_* functions which are more suitable for */ + __Pyx_TraceLine(937,0,__PYX_ERR(1, 937, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_base)); __pyx_r = ((PyObject *)__pyx_v_base); @@ -5200,8 +5620,12 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py */ /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("numpy.get_array_base", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5216,6 +5640,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { int __pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; @@ -5229,6 +5654,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_array", 0); + __Pyx_TraceCall("import_array", __pyx_f[1], 941, 0, __PYX_ERR(1, 941, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":942 * # Cython code. @@ -5237,6 +5663,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { * __pyx_import_array() * except Exception: */ + __Pyx_TraceLine(942,0,__PYX_ERR(1, 942, __pyx_L1_error)) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign @@ -5253,6 +5680,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { * except Exception: * raise ImportError("numpy.core.multiarray failed to import") */ + __Pyx_TraceLine(943,0,__PYX_ERR(1, 943, __pyx_L3_error)) __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 943, __pyx_L3_error) /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":942 @@ -5276,6 +5704,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { * raise ImportError("numpy.core.multiarray failed to import") * */ + __Pyx_TraceLine(944,0,__PYX_ERR(1, 944, __pyx_L5_except_error)) __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); @@ -5291,6 +5720,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { * * cdef inline int import_umath() except -1: */ + __Pyx_TraceLine(945,0,__PYX_ERR(1, 945, __pyx_L5_except_error)) __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 945, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); @@ -5334,6 +5764,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5348,6 +5779,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { int __pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; @@ -5361,6 +5793,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_umath", 0); + __Pyx_TraceCall("import_umath", __pyx_f[1], 947, 0, __PYX_ERR(1, 947, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":948 * @@ -5369,6 +5802,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { * _import_umath() * except Exception: */ + __Pyx_TraceLine(948,0,__PYX_ERR(1, 948, __pyx_L1_error)) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign @@ -5385,6 +5819,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { * except Exception: * raise ImportError("numpy.core.umath failed to import") */ + __Pyx_TraceLine(949,0,__PYX_ERR(1, 949, __pyx_L3_error)) __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 949, __pyx_L3_error) /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":948 @@ -5408,6 +5843,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { * raise ImportError("numpy.core.umath failed to import") * */ + __Pyx_TraceLine(950,0,__PYX_ERR(1, 950, __pyx_L5_except_error)) __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); @@ -5423,6 +5859,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { * * cdef inline int import_ufunc() except -1: */ + __Pyx_TraceLine(951,0,__PYX_ERR(1, 951, __pyx_L5_except_error)) __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 951, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); @@ -5466,6 +5903,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5480,6 +5918,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { int __pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; @@ -5493,6 +5932,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_ufunc", 0); + __Pyx_TraceCall("import_ufunc", __pyx_f[1], 953, 0, __PYX_ERR(1, 953, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":954 * @@ -5501,6 +5941,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { * _import_umath() * except Exception: */ + __Pyx_TraceLine(954,0,__PYX_ERR(1, 954, __pyx_L1_error)) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign @@ -5517,6 +5958,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { * except Exception: * raise ImportError("numpy.core.umath failed to import") */ + __Pyx_TraceLine(955,0,__PYX_ERR(1, 955, __pyx_L3_error)) __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 955, __pyx_L3_error) /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":954 @@ -5540,6 +5982,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { * raise ImportError("numpy.core.umath failed to import") * */ + __Pyx_TraceLine(956,0,__PYX_ERR(1, 956, __pyx_L5_except_error)) __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); @@ -5555,6 +5998,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { * * cdef extern from *: */ + __Pyx_TraceLine(957,0,__PYX_ERR(1, 957, __pyx_L5_except_error)) __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 957, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); @@ -5598,6 +6042,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5612,8 +6057,13 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_obj) { int __pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("is_timedelta64_object", 0); + __Pyx_TraceCall("is_timedelta64_object", __pyx_f[1], 967, 0, __PYX_ERR(1, 967, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":979 * bool @@ -5622,6 +6072,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_ * * */ + __Pyx_TraceLine(979,0,__PYX_ERR(1, 979, __pyx_L1_error)) __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyTimedeltaArrType_Type)); goto __pyx_L0; @@ -5634,7 +6085,11 @@ static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_ */ /* function exit code */ + __pyx_L1_error:; + __Pyx_WriteUnraisable("numpy.is_timedelta64_object", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; __pyx_L0:; + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5649,8 +6104,13 @@ static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_ static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_obj) { int __pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("is_datetime64_object", 0); + __Pyx_TraceCall("is_datetime64_object", __pyx_f[1], 982, 0, __PYX_ERR(1, 982, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":994 * bool @@ -5659,6 +6119,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_o * * */ + __Pyx_TraceLine(994,0,__PYX_ERR(1, 994, __pyx_L1_error)) __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyDatetimeArrType_Type)); goto __pyx_L0; @@ -5671,7 +6132,11 @@ static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_o */ /* function exit code */ + __pyx_L1_error:; + __Pyx_WriteUnraisable("numpy.is_datetime64_object", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; __pyx_L0:; + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5686,6 +6151,11 @@ static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_o static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject *__pyx_v_obj) { npy_datetime __pyx_r; + __Pyx_TraceDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceCall("get_datetime64_value", __pyx_f[1], 997, 1, __PYX_ERR(1, 997, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1004 * also needed. That can be found using `get_datetime64_unit`. @@ -5694,6 +6164,7 @@ static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject * * * */ + __Pyx_TraceLine(1004,1,__PYX_ERR(1, 1004, __pyx_L1_error)) __pyx_r = ((PyDatetimeScalarObject *)__pyx_v_obj)->obval; goto __pyx_L0; @@ -5706,7 +6177,11 @@ static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject * */ /* function exit code */ + __pyx_L1_error:; + __Pyx_WriteUnraisable("numpy.get_datetime64_value", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1); + __pyx_r = 0; __pyx_L0:; + __Pyx_TraceReturn(Py_None, 1); return __pyx_r; } @@ -5720,6 +6195,11 @@ static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject * static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject *__pyx_v_obj) { npy_timedelta __pyx_r; + __Pyx_TraceDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceCall("get_timedelta64_value", __pyx_f[1], 1007, 1, __PYX_ERR(1, 1007, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1011 * returns the int64 value underlying scalar numpy timedelta64 object @@ -5728,6 +6208,7 @@ static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject * * */ + __Pyx_TraceLine(1011,1,__PYX_ERR(1, 1011, __pyx_L1_error)) __pyx_r = ((PyTimedeltaScalarObject *)__pyx_v_obj)->obval; goto __pyx_L0; @@ -5740,7 +6221,11 @@ static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject */ /* function exit code */ + __pyx_L1_error:; + __Pyx_WriteUnraisable("numpy.get_timedelta64_value", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1); + __pyx_r = 0; __pyx_L0:; + __Pyx_TraceReturn(Py_None, 1); return __pyx_r; } @@ -5754,12 +6239,18 @@ static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject static CYTHON_INLINE NPY_DATETIMEUNIT __pyx_f_5numpy_get_datetime64_unit(PyObject *__pyx_v_obj) { NPY_DATETIMEUNIT __pyx_r; + __Pyx_TraceDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceCall("get_datetime64_unit", __pyx_f[1], 1014, 1, __PYX_ERR(1, 1014, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1018 * returns the unit part of the dtype for a numpy datetime64 object. * """ * return (obj).obmeta.base # <<<<<<<<<<<<<< */ + __Pyx_TraceLine(1018,1,__PYX_ERR(1, 1018, __pyx_L1_error)) __pyx_r = ((NPY_DATETIMEUNIT)((PyDatetimeScalarObject *)__pyx_v_obj)->obmeta.base); goto __pyx_L0; @@ -5772,7 +6263,11 @@ static CYTHON_INLINE NPY_DATETIMEUNIT __pyx_f_5numpy_get_datetime64_unit(PyObjec */ /* function exit code */ + __pyx_L1_error:; + __Pyx_WriteUnraisable("numpy.get_datetime64_unit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1); + __pyx_r = (NPY_DATETIMEUNIT) 0; __pyx_L0:; + __Pyx_TraceReturn(Py_None, 1); return __pyx_r; } @@ -6145,6 +6640,7 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_cyarma(PyObject *__pyx_pyinit_modu #endif #endif { + __Pyx_TraceDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; @@ -6251,6 +6747,7 @@ if (!__Pyx_RefNanny) { #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif + __Pyx_TraceCall("__Pyx_PyMODINIT_FUNC PyInit_cyarma(void)", __pyx_f[0], 1, 0, __PYX_ERR(0, 1, __pyx_L1_error)); /* "l0learn/cyarma.pyx":2 * cimport cython @@ -6258,6 +6755,7 @@ if (!__Pyx_RefNanny) { * cimport numpy as np * */ + __Pyx_TraceLine(2,0,__PYX_ERR(0, 2, __pyx_L1_error)) __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 2, __pyx_L1_error) @@ -6270,6 +6768,7 @@ if (!__Pyx_RefNanny) { * from cython.operator cimport dereference as deref, preincrement as inc * */ + __Pyx_TraceLine(5,0,__PYX_ERR(0, 5, __pyx_L1_error)) __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_csc_matrix); @@ -6284,16 +6783,327 @@ if (!__Pyx_RefNanny) { __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + /* "l0learn/cyarma.pyx":87 + * ##### Tools to convert numpy arrays to armadillo arrays ###### + * @cython.boundscheck(False) + * cdef field[sp_dmat] list_to_sp_dmat_field(list values): # <<<<<<<<<<<<<< + * cdef field[sp_dmat] f = field[sp_dmat](len(values)) + * for i, value in enumerate(values): + */ + __Pyx_TraceLine(87,0,__PYX_ERR(0, 87, __pyx_L1_error)) + + + /* "l0learn/cyarma.pyx":97 + * + * @cython.boundscheck(False) + * cdef field[dvec] list_to_dvec_field(list values): # <<<<<<<<<<<<<< + * cdef field[dvec] f = field[dvec](len(values)) + * for i, value in enumerate(values): + */ + __Pyx_TraceLine(97,0,__PYX_ERR(0, 97, __pyx_L1_error)) + + + /* "l0learn/cyarma.pyx":106 + * + * + * cdef dmat * numpy_to_dmat(np.ndarray[np.double_t, ndim=2] X): # <<<<<<<<<<<<<< + * # TODO: Add checks on X (Size, ...) + * # TODO: Add flags for new dmat. See: Advanced constructors in http://arma.sourceforge.net/docs.html#Mat + */ + __Pyx_TraceLine(106,0,__PYX_ERR(0, 106, __pyx_L1_error)) + + + /* "l0learn/cyarma.pyx":116 + * return aR_p + * + * cdef dmat numpy_to_dmat_d(np.ndarray[np.double_t, ndim=2] X): # <<<<<<<<<<<<<< + * cdef dmat * aR_p = numpy_to_dmat(X) + * cdef dmat aR = deref(aR_p) + */ + __Pyx_TraceLine(116,0,__PYX_ERR(0, 116, __pyx_L1_error)) + + + /* "l0learn/cyarma.pyx":122 + * return aR + * + * cdef dvec * numpy_to_dvec(np.ndarray[np.double_t, ndim=1] x): # <<<<<<<<<<<<<< + * if not (x.flags.f_contiguous or x.flags.owndata): + * x = x.copy() + */ + __Pyx_TraceLine(122,0,__PYX_ERR(0, 122, __pyx_L1_error)) + + + /* "l0learn/cyarma.pyx":128 + * return ar_p + * + * cdef dvec numpy_to_dvec_d(np.ndarray[np.double_t, ndim=1] x): # <<<<<<<<<<<<<< + * cdef dvec *ar_p = numpy_to_dvec(x) + * cdef dvec ar = deref(ar_p) + */ + __Pyx_TraceLine(128,0,__PYX_ERR(0, 128, __pyx_L1_error)) + + + /* "l0learn/cyarma.pyx":134 + * return ar + * + * cdef uvec * numpy_to_uvec(np.ndarray[np.uint64_t, ndim=1] x): # <<<<<<<<<<<<<< + * if not (x.flags.f_contiguous or x.flags.owndata): + * x = x.copy() + */ + __Pyx_TraceLine(134,0,__PYX_ERR(0, 134, __pyx_L1_error)) + + + /* "l0learn/cyarma.pyx":140 + * return ar_p + * + * cdef uvec numpy_to_uvec_d(np.ndarray[np.uint64_t, ndim=1] x): # <<<<<<<<<<<<<< + * cdef uvec *ar_p = numpy_to_uvec(x) + * cdef uvec ar = deref(ar_p) + */ + __Pyx_TraceLine(140,0,__PYX_ERR(0, 140, __pyx_L1_error)) + + + /* "l0learn/cyarma.pyx":147 + * + * + * cdef sp_dmat * numpy_to_sp_dmat(x): # <<<<<<<<<<<<<< + * if not isinstance(x, csc_matrix): + * raise ValueError(f"expected x to be of type {csc_matrix}, but got {type(x)}") + */ + __Pyx_TraceLine(147,0,__PYX_ERR(0, 147, __pyx_L1_error)) + + + /* "l0learn/cyarma.pyx":165 + * + * + * cdef sp_dmat numpy_to_sp_dmat_d(x): # <<<<<<<<<<<<<< + * cdef sp_dmat *ar_p = numpy_to_sp_dmat(x) + * cdef sp_dmat ar = deref(ar_p) + */ + __Pyx_TraceLine(165,0,__PYX_ERR(0, 165, __pyx_L1_error)) + + + /* "l0learn/cyarma.pyx":177 + * + * @cython.boundscheck(False) + * cdef list sp_dmat_field_to_list(field[sp_dmat] f): # <<<<<<<<<<<<<< + * cdef list lst = [] + * for i in range(f.n_elem): + */ + __Pyx_TraceLine(177,0,__PYX_ERR(0, 177, __pyx_L1_error)) + + + /* "l0learn/cyarma.pyx":185 + * + * @cython.boundscheck(False) + * cdef list dvec_field_to_list(field[dvec] f): # <<<<<<<<<<<<<< + * cdef list lst = [] + * for i in range(f.n_elem): + */ + __Pyx_TraceLine(185,0,__PYX_ERR(0, 185, __pyx_L1_error)) + + + /* "l0learn/cyarma.pyx":192 + * + * @cython.boundscheck(False) + * cdef np.ndarray[np.double_t, ndim=2] dmat_to_numpy(const dmat & X, np.ndarray[np.double_t, ndim=2] D): # <<<<<<<<<<<<<< + * # TODO: Check order of X and D + * cdef const double * Xptr = X.memptr() + */ + __Pyx_TraceLine(192,0,__PYX_ERR(0, 192, __pyx_L1_error)) + + + /* "l0learn/cyarma.pyx":204 + * + * @cython.boundscheck(False) + * cdef np.ndarray[np.double_t, ndim=1] dvec_to_numpy(const dvec & X, np.ndarray[np.double_t, ndim=1] D): # <<<<<<<<<<<<<< + * cdef const double * Xptr = X.memptr() + * + */ + __Pyx_TraceLine(204,0,__PYX_ERR(0, 204, __pyx_L1_error)) + + + /* "l0learn/cyarma.pyx":216 + * + * @cython.boundscheck(False) + * cdef np.ndarray[np.uint64_t, ndim=1] uvec_to_numpy(const uvec & X, np.ndarray[np.uint64_t, ndim=1] D): # <<<<<<<<<<<<<< + * cdef const unsigned long long * Xptr = X.memptr() + * + */ + __Pyx_TraceLine(216,0,__PYX_ERR(0, 216, __pyx_L1_error)) + + + /* "l0learn/cyarma.pyx":228 + * + * @cython.boundscheck(False) + * cdef sp_dmat_to_numpy(const sp_dmat & X, np.ndarray[np.uint64_t, ndim=1] rowind, # <<<<<<<<<<<<<< + * np.ndarray[np.uint64_t, ndim=1] colind, np.ndarray[np.double_t, ndim=1] values): + * # TODO: Check order of X and D + */ + __Pyx_TraceLine(228,0,__PYX_ERR(0, 228, __pyx_L1_error)) + + /* "l0learn/cyarma.pyx":1 * cimport cython # <<<<<<<<<<<<<< * import numpy as np * cimport numpy as np */ + __Pyx_TraceLine(1,0,__PYX_ERR(0, 1, __pyx_L1_error)) __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":735 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + __Pyx_TraceLine(735,0,__PYX_ERR(1, 735, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":738 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + __Pyx_TraceLine(738,0,__PYX_ERR(1, 738, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":741 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + __Pyx_TraceLine(741,0,__PYX_ERR(1, 741, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":744 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + __Pyx_TraceLine(744,0,__PYX_ERR(1, 744, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":747 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + __Pyx_TraceLine(747,0,__PYX_ERR(1, 747, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":750 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape + */ + __Pyx_TraceLine(750,0,__PYX_ERR(1, 750, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":929 + * int _import_umath() except -1 + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) + */ + __Pyx_TraceLine(929,0,__PYX_ERR(1, 929, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":933 + * PyArray_SetBaseObject(arr, base) + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) + * if base is NULL: + */ + __Pyx_TraceLine(933,0,__PYX_ERR(1, 933, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":941 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * __pyx_import_array() + */ + __Pyx_TraceLine(941,0,__PYX_ERR(1, 941, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":947 + * raise ImportError("numpy.core.multiarray failed to import") + * + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + __Pyx_TraceLine(947,0,__PYX_ERR(1, 947, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":953 + * raise ImportError("numpy.core.umath failed to import") + * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + __Pyx_TraceLine(953,0,__PYX_ERR(1, 953, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":967 + * + * + * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.timedelta64)` + */ + __Pyx_TraceLine(967,0,__PYX_ERR(1, 967, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":982 + * + * + * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.datetime64)` + */ + __Pyx_TraceLine(982,0,__PYX_ERR(1, 982, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":997 + * + * + * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy datetime64 object + */ + __Pyx_TraceLine(997,0,__PYX_ERR(1, 997, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1007 + * + * + * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy timedelta64 object + */ + __Pyx_TraceLine(1007,0,__PYX_ERR(1, 1007, __pyx_L1_error)) + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1014 * * @@ -6301,6 +7111,9 @@ if (!__Pyx_RefNanny) { * """ * returns the unit part of the dtype for a numpy datetime64 object. */ + __Pyx_TraceLine(1014,0,__PYX_ERR(1, 1014, __pyx_L1_error)) + + __Pyx_TraceReturn(Py_None, 0); /*--- Wrapped vars code ---*/ @@ -6373,6 +7186,122 @@ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { return result; } +/* PyErrFetchRestore */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +} +#endif + +/* Profile */ +#if CYTHON_PROFILE +static int __Pyx_TraceSetupAndCall(PyCodeObject** code, + PyFrameObject** frame, + PyThreadState* tstate, + const char *funcname, + const char *srcfile, + int firstlineno) { + PyObject *type, *value, *traceback; + int retval; + if (*frame == NULL || !CYTHON_PROFILE_REUSE_FRAME) { + if (*code == NULL) { + *code = __Pyx_createFrameCodeObject(funcname, srcfile, firstlineno); + if (*code == NULL) return 0; + } + *frame = PyFrame_New( + tstate, /*PyThreadState *tstate*/ + *code, /*PyCodeObject *code*/ + __pyx_d, /*PyObject *globals*/ + 0 /*PyObject *locals*/ + ); + if (*frame == NULL) return 0; + if (CYTHON_TRACE && (*frame)->f_trace == NULL) { + Py_INCREF(Py_None); + (*frame)->f_trace = Py_None; + } +#if PY_VERSION_HEX < 0x030400B1 + } else { + (*frame)->f_tstate = tstate; +#endif + } + __Pyx_PyFrame_SetLineNumber(*frame, firstlineno); + retval = 1; + tstate->tracing++; + __Pyx_SetTracing(tstate, 0); + __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); + #if CYTHON_TRACE + if (tstate->c_tracefunc) + retval = tstate->c_tracefunc(tstate->c_traceobj, *frame, PyTrace_CALL, NULL) == 0; + if (retval && tstate->c_profilefunc) + #endif + retval = tstate->c_profilefunc(tstate->c_profileobj, *frame, PyTrace_CALL, NULL) == 0; + __Pyx_SetTracing(tstate, (tstate->c_profilefunc || (CYTHON_TRACE && tstate->c_tracefunc))); + tstate->tracing--; + if (retval) { + __Pyx_ErrRestoreInState(tstate, type, value, traceback); + return __Pyx_IsTracing(tstate, 0, 0) && retval; + } else { + Py_XDECREF(type); + Py_XDECREF(value); + Py_XDECREF(traceback); + return -1; + } +} +static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno) { + PyCodeObject *py_code = 0; +#if PY_MAJOR_VERSION >= 3 + py_code = PyCode_NewEmpty(srcfile, funcname, firstlineno); + if (likely(py_code)) { + py_code->co_flags |= CO_OPTIMIZED | CO_NEWLOCALS; + } +#else + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + py_funcname = PyString_FromString(funcname); + if (unlikely(!py_funcname)) goto bad; + py_srcfile = PyString_FromString(srcfile); + if (unlikely(!py_srcfile)) goto bad; + py_code = PyCode_New( + 0, + 0, + 0, + CO_OPTIMIZED | CO_NEWLOCALS, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + firstlineno, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); +#endif + return py_code; +} +#endif + /* PyDictVersioning */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { @@ -6752,30 +7681,6 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObjec } #endif -/* PyErrFetchRestore */ -#if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { - PyObject *tmp_type, *tmp_value, *tmp_tb; - tmp_type = tstate->curexc_type; - tmp_value = tstate->curexc_value; - tmp_tb = tstate->curexc_traceback; - tstate->curexc_type = type; - tstate->curexc_value = value; - tstate->curexc_traceback = tb; - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); -} -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { - *type = tstate->curexc_type; - *value = tstate->curexc_value; - *tb = tstate->curexc_traceback; - tstate->curexc_type = 0; - tstate->curexc_value = 0; - tstate->curexc_traceback = 0; -} -#endif - /* RaiseException */ #if PY_MAJOR_VERSION < 3 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, diff --git a/python/l0learn/interface.cpp b/python/l0learn/interface.cpp index f389a9e..5ffd469 100644 --- a/python/l0learn/interface.cpp +++ b/python/l0learn/interface.cpp @@ -3,6 +3,12 @@ /* BEGIN: Cython Metadata { "distutils": { + "define_macros": [ + [ + "CYTHON_TRACE_NOGIL", + "1" + ] + ], "depends": [ "/Users/tnonet/opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/core/include/numpy/arrayobject.h", "/Users/tnonet/opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/core/include/numpy/arrayscalars.h", @@ -1253,6 +1259,255 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() PyErr_Occurred() +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +#else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + +/* Profile.proto */ +#ifndef CYTHON_PROFILE +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON + #define CYTHON_PROFILE 0 +#else + #define CYTHON_PROFILE 1 +#endif +#endif +#ifndef CYTHON_TRACE_NOGIL + #define CYTHON_TRACE_NOGIL 0 +#else + #if CYTHON_TRACE_NOGIL && !defined(CYTHON_TRACE) + #define CYTHON_TRACE 1 + #endif +#endif +#ifndef CYTHON_TRACE + #define CYTHON_TRACE 0 +#endif +#if CYTHON_TRACE + #undef CYTHON_PROFILE_REUSE_FRAME +#endif +#ifndef CYTHON_PROFILE_REUSE_FRAME + #define CYTHON_PROFILE_REUSE_FRAME 0 +#endif +#if CYTHON_PROFILE || CYTHON_TRACE + #include "compile.h" + #include "frameobject.h" + #include "traceback.h" + #if CYTHON_PROFILE_REUSE_FRAME + #define CYTHON_FRAME_MODIFIER static + #define CYTHON_FRAME_DEL(frame) + #else + #define CYTHON_FRAME_MODIFIER + #define CYTHON_FRAME_DEL(frame) Py_CLEAR(frame) + #endif + #define __Pyx_TraceDeclarations\ + static PyCodeObject *__pyx_frame_code = NULL;\ + CYTHON_FRAME_MODIFIER PyFrameObject *__pyx_frame = NULL;\ + int __Pyx_use_tracing = 0; + #define __Pyx_TraceFrameInit(codeobj)\ + if (codeobj) __pyx_frame_code = (PyCodeObject*) codeobj; +#if PY_VERSION_HEX >= 0x030a00b1 + #define __Pyx_IsTracing(tstate, check_tracing, check_funcs)\ + (unlikely((tstate)->cframe->use_tracing) &&\ + (!(check_tracing) || !(tstate)->tracing) &&\ + (!(check_funcs) || (tstate)->c_profilefunc || (CYTHON_TRACE && (tstate)->c_tracefunc))) + #define __Pyx_SetTracing(tstate, enable)\ + (tstate)->cframe->use_tracing = (enable) +#else + #define __Pyx_IsTracing(tstate, check_tracing, check_funcs)\ + (unlikely((tstate)->use_tracing) &&\ + (!(check_tracing) || !(tstate)->tracing) &&\ + (!(check_funcs) || (tstate)->c_profilefunc || (CYTHON_TRACE && (tstate)->c_tracefunc))) + #define __Pyx_SetTracing(tstate, enable)\ + (tstate)->use_tracing = (enable) +#endif + #ifdef WITH_THREAD + #define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error)\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + PyThreadState *tstate;\ + PyGILState_STATE state = PyGILState_Ensure();\ + tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 1, 1)) {\ + __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ + }\ + PyGILState_Release(state);\ + if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ + }\ + } else {\ + PyThreadState* tstate = PyThreadState_GET();\ + if (__Pyx_IsTracing(tstate, 1, 1)) {\ + __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ + if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ + }\ + } + #else + #define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error)\ + { PyThreadState* tstate = PyThreadState_GET();\ + if (__Pyx_IsTracing(tstate, 1, 1)) {\ + __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ + if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ + }\ + } + #endif + #define __Pyx_TraceException()\ + if (likely(!__Pyx_use_tracing)); else {\ + PyThreadState* tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 1)) {\ + tstate->tracing++;\ + __Pyx_SetTracing(tstate, 0);\ + PyObject *exc_info = __Pyx_GetExceptionTuple(tstate);\ + if (exc_info) {\ + if (CYTHON_TRACE && tstate->c_tracefunc)\ + tstate->c_tracefunc(\ + tstate->c_traceobj, __pyx_frame, PyTrace_EXCEPTION, exc_info);\ + tstate->c_profilefunc(\ + tstate->c_profileobj, __pyx_frame, PyTrace_EXCEPTION, exc_info);\ + Py_DECREF(exc_info);\ + }\ + __Pyx_SetTracing(tstate, 1);\ + tstate->tracing--;\ + }\ + } + static void __Pyx_call_return_trace_func(PyThreadState *tstate, PyFrameObject *frame, PyObject *result) { + PyObject *type, *value, *traceback; + __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); + tstate->tracing++; + __Pyx_SetTracing(tstate, 0); + if (CYTHON_TRACE && tstate->c_tracefunc) + tstate->c_tracefunc(tstate->c_traceobj, frame, PyTrace_RETURN, result); + if (tstate->c_profilefunc) + tstate->c_profilefunc(tstate->c_profileobj, frame, PyTrace_RETURN, result); + CYTHON_FRAME_DEL(frame); + __Pyx_SetTracing(tstate, 1); + tstate->tracing--; + __Pyx_ErrRestoreInState(tstate, type, value, traceback); + } + #ifdef WITH_THREAD + #define __Pyx_TraceReturn(result, nogil)\ + if (likely(!__Pyx_use_tracing)); else {\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + PyThreadState *tstate;\ + PyGILState_STATE state = PyGILState_Ensure();\ + tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ + }\ + PyGILState_Release(state);\ + }\ + } else {\ + PyThreadState* tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ + }\ + }\ + } + #else + #define __Pyx_TraceReturn(result, nogil)\ + if (likely(!__Pyx_use_tracing)); else {\ + PyThreadState* tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ + }\ + } + #endif + static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno); + static int __Pyx_TraceSetupAndCall(PyCodeObject** code, PyFrameObject** frame, PyThreadState* tstate, const char *funcname, const char *srcfile, int firstlineno); +#else + #define __Pyx_TraceDeclarations + #define __Pyx_TraceFrameInit(codeobj) + #define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error) if ((1)); else goto_error; + #define __Pyx_TraceException() + #define __Pyx_TraceReturn(result, nogil) +#endif +#if CYTHON_TRACE + static int __Pyx_call_line_trace_func(PyThreadState *tstate, PyFrameObject *frame, int lineno) { + int ret; + PyObject *type, *value, *traceback; + __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); + __Pyx_PyFrame_SetLineNumber(frame, lineno); + tstate->tracing++; + __Pyx_SetTracing(tstate, 0); + ret = tstate->c_tracefunc(tstate->c_traceobj, frame, PyTrace_LINE, NULL); + __Pyx_SetTracing(tstate, 1); + tstate->tracing--; + if (likely(!ret)) { + __Pyx_ErrRestoreInState(tstate, type, value, traceback); + } else { + Py_XDECREF(type); + Py_XDECREF(value); + Py_XDECREF(traceback); + } + return ret; + } + #ifdef WITH_THREAD + #define __Pyx_TraceLine(lineno, nogil, goto_error)\ + if (likely(!__Pyx_use_tracing)); else {\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + int ret = 0;\ + PyThreadState *tstate;\ + PyGILState_STATE state = PyGILState_Ensure();\ + tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && __pyx_frame->f_trace) {\ + ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ + }\ + PyGILState_Release(state);\ + if (unlikely(ret)) goto_error;\ + }\ + } else {\ + PyThreadState* tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && __pyx_frame->f_trace) {\ + int ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ + if (unlikely(ret)) goto_error;\ + }\ + }\ + } + #else + #define __Pyx_TraceLine(lineno, nogil, goto_error)\ + if (likely(!__Pyx_use_tracing)); else {\ + PyThreadState* tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && __pyx_frame->f_trace) {\ + int ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ + if (unlikely(ret)) goto_error;\ + }\ + } + #endif +#else + #define __Pyx_TraceLine(lineno, nogil, goto_error) if ((1)); else goto_error; +#endif + /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS #define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) @@ -1318,42 +1573,6 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg #define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) #endif -/* PyThreadStateGet.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; -#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; -#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type -#else -#define __Pyx_PyThreadState_declare -#define __Pyx_PyThreadState_assign -#define __Pyx_PyErr_Occurred() PyErr_Occurred() -#endif - -/* PyErrFetchRestore.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) -#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) -#else -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) -#endif -#else -#define __Pyx_PyErr_Clear() PyErr_Clear() -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) -#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) -#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) -#endif - /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); @@ -1572,6 +1791,11 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); /* ExtTypeTest.proto */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); +/* WriteUnraisableException.proto */ +static void __Pyx_WriteUnraisable(const char *name, int clineno, + int lineno, const char *filename, + int full_traceback, int nogil); + /* ListCompAppend.proto */ #if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { @@ -1857,11 +2081,11 @@ static const char __pyx_k_p[] = "p"; static const char __pyx_k_y[] = "y"; static const char __pyx_k_CD[] = "CD"; static const char __pyx_k_L0[] = "L0"; -static const char __pyx_k__5[] = "."; +static const char __pyx_k__6[] = "."; static const char __pyx_k_np[] = "np"; static const char __pyx_k_or[] = " or "; static const char __pyx_k_Any[] = "Any"; -static const char __pyx_k__18[] = "_"; +static const char __pyx_k__21[] = "_"; static const char __pyx_k_all[] = "all"; static const char __pyx_k_any[] = "any"; static const char __pyx_k_arr[] = "arr"; @@ -2068,8 +2292,8 @@ static PyObject *__pyx_n_s_TypeError; static PyObject *__pyx_n_s_Union; static PyObject *__pyx_n_s_ValueError; static PyObject *__pyx_n_s_X; -static PyObject *__pyx_n_s__18; -static PyObject *__pyx_kp_u__5; +static PyObject *__pyx_n_s__21; +static PyObject *__pyx_kp_u__6; static PyObject *__pyx_n_s_a; static PyObject *__pyx_n_s_active_set; static PyObject *__pyx_n_s_active_set_num; @@ -2257,28 +2481,28 @@ static PyObject *__pyx_int_10; static PyObject *__pyx_int_100; static PyObject *__pyx_int_200; static PyObject *__pyx_int_1000; -static PyObject *__pyx_k__7; -static PyObject *__pyx_k__8; static PyObject *__pyx_k__9; static PyObject *__pyx_k__10; -static PyObject *__pyx_tuple_; +static PyObject *__pyx_k__12; +static PyObject *__pyx_k__13; +static PyObject *__pyx_codeobj_; static PyObject *__pyx_tuple__2; static PyObject *__pyx_tuple__3; static PyObject *__pyx_tuple__4; -static PyObject *__pyx_tuple__6; -static PyObject *__pyx_tuple__11; -static PyObject *__pyx_tuple__12; -static PyObject *__pyx_tuple__13; +static PyObject *__pyx_tuple__5; +static PyObject *__pyx_tuple__7; static PyObject *__pyx_tuple__15; static PyObject *__pyx_tuple__16; static PyObject *__pyx_tuple__17; +static PyObject *__pyx_tuple__18; static PyObject *__pyx_tuple__19; -static PyObject *__pyx_tuple__21; +static PyObject *__pyx_tuple__20; +static PyObject *__pyx_tuple__22; static PyObject *__pyx_tuple__23; +static PyObject *__pyx_tuple__24; +static PyObject *__pyx_codeobj__8; +static PyObject *__pyx_codeobj__11; static PyObject *__pyx_codeobj__14; -static PyObject *__pyx_codeobj__20; -static PyObject *__pyx_codeobj__22; -static PyObject *__pyx_codeobj__24; /* Late includes */ /* "l0learn/interface.pyx":16 @@ -2306,6 +2530,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_1np_to_arma_check(PyObject *__pyx_ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_arr) { PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; @@ -2321,7 +2546,9 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj_) __Pyx_RefNannySetupContext("np_to_arma_check", 0); + __Pyx_TraceCall("np_to_arma_check", __pyx_f[0], 16, 0, __PYX_ERR(0, 16, __pyx_L1_error)); /* "l0learn/interface.pyx":18 * def np_to_arma_check(arr): @@ -2330,6 +2557,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO * if not arr.flags['F_CONTIGUOUS']: * raise ValueError("expected arr to be F_CONTIGUOUS.") */ + __Pyx_TraceLine(18,0,__PYX_ERR(0, 18, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 18, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error) @@ -2347,6 +2575,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO * raise ValueError("expected arr to be F_CONTIGUOUS.") * elif isinstance(arr, csc_matrix): */ + __Pyx_TraceLine(19,0,__PYX_ERR(0, 19, __pyx_L1_error)) __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 19, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_n_u_F_CONTIGUOUS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) @@ -2364,7 +2593,8 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO * elif isinstance(arr, csc_matrix): * if not arr.data.flags['F_CONTIGUOUS']: */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_TraceLine(20,0,__PYX_ERR(0, 20, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 20, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -2396,6 +2626,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO * if not arr.data.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.data to be F_CONTIGUOUS.") */ + __Pyx_TraceLine(21,0,__PYX_ERR(0, 21, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = PyObject_IsInstance(__pyx_v_arr, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 21, __pyx_L1_error) @@ -2410,6 +2641,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO * raise ValueError("expected arr.data to be F_CONTIGUOUS.") * if not arr.indices.flags['F_CONTIGUOUS']: */ + __Pyx_TraceLine(22,0,__PYX_ERR(0, 22, __pyx_L1_error)) __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error) @@ -2430,7 +2662,8 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO * if not arr.indices.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_TraceLine(23,0,__PYX_ERR(0, 23, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 23, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -2452,6 +2685,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") * if not arr.indptr.flags['F_CONTIGUOUS']: */ + __Pyx_TraceLine(24,0,__PYX_ERR(0, 24, __pyx_L1_error)) __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_indices); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 24, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 24, __pyx_L1_error) @@ -2472,7 +2706,8 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO * if not arr.indptr.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 25, __pyx_L1_error) + __Pyx_TraceLine(25,0,__PYX_ERR(0, 25, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 25, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -2494,6 +2729,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO * raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") * else: */ + __Pyx_TraceLine(26,0,__PYX_ERR(0, 26, __pyx_L1_error)) __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_indptr); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 26, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 26, __pyx_L1_error) @@ -2514,7 +2750,8 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO * else: * raise NotImplementedError(f"expected arr to be of type {np.ndarray} or {csc_matrix}, but got {type(arr)}.") */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 27, __pyx_L1_error) + __Pyx_TraceLine(27,0,__PYX_ERR(0, 27, __pyx_L1_error)) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 27, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -2546,6 +2783,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO * * if arr.ndim == 0: */ + __Pyx_TraceLine(29,0,__PYX_ERR(0, 29, __pyx_L1_error)) /*else*/ { __pyx_t_1 = PyTuple_New(7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 29, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -2593,10 +2831,10 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_1, 5, __pyx_t_7); __pyx_t_7 = 0; - __Pyx_INCREF(__pyx_kp_u__5); + __Pyx_INCREF(__pyx_kp_u__6); __pyx_t_5 += 1; - __Pyx_GIVEREF(__pyx_kp_u__5); - PyTuple_SET_ITEM(__pyx_t_1, 6, __pyx_kp_u__5); + __Pyx_GIVEREF(__pyx_kp_u__6); + PyTuple_SET_ITEM(__pyx_t_1, 6, __pyx_kp_u__6); __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_1, 7, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 29, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -2616,6 +2854,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO * raise ValueError("expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar") * elif arr.ndim > 2: */ + __Pyx_TraceLine(31,0,__PYX_ERR(0, 31, __pyx_L1_error)) __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 31, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = __Pyx_PyInt_EqObjC(__pyx_t_1, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 31, __pyx_L1_error) @@ -2632,7 +2871,8 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO * elif arr.ndim > 2: * raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") */ - __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_TraceLine(32,0,__PYX_ERR(0, 32, __pyx_L1_error)) + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 32, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; @@ -2654,6 +2894,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO * raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") * */ + __Pyx_TraceLine(33,0,__PYX_ERR(0, 33, __pyx_L1_error)) __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 33, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_1 = PyObject_RichCompare(__pyx_t_7, __pyx_int_2, Py_GT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error) @@ -2669,6 +2910,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO * * if np.product(arr.shape) == 0: */ + __Pyx_TraceLine(34,0,__PYX_ERR(0, 34, __pyx_L1_error)) __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 34, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = 0; @@ -2717,6 +2959,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO * raise ValueError(f"expected non-degenerate dimensions of arr, but got {arr.ndim}") * */ + __Pyx_TraceLine(36,0,__PYX_ERR(0, 36, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 36, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_product); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 36, __pyx_L1_error) @@ -2754,6 +2997,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO * * if not np.issubdtype(arr.dtype, np.number): */ + __Pyx_TraceLine(37,0,__PYX_ERR(0, 37, __pyx_L1_error)) __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 37, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 37, __pyx_L1_error) @@ -2785,6 +3029,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO * raise ValueError(f"expected numerical dtype, but got {arr.dtype}") * */ + __Pyx_TraceLine(39,0,__PYX_ERR(0, 39, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 39, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_issubdtype); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 39, __pyx_L1_error) @@ -2858,6 +3103,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO * * if not np.isrealobj(arr): */ + __Pyx_TraceLine(40,0,__PYX_ERR(0, 40, __pyx_L1_error)) __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 40, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_1, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 40, __pyx_L1_error) @@ -2889,6 +3135,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO * raise ValueError(f"expected non-complex dtype, but got {arr.dtype}") * */ + __Pyx_TraceLine(42,0,__PYX_ERR(0, 42, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 42, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 42, __pyx_L1_error) @@ -2921,6 +3168,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO * * */ + __Pyx_TraceLine(43,0,__PYX_ERR(0, 43, __pyx_L1_error)) __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_dtype); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 43, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_11 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 43, __pyx_L1_error) @@ -2967,6 +3215,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyO __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3310,6 +3559,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject int __pyx_v_with_bounds; PyObject *__pyx_v_bad_bounds = NULL; PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; @@ -3330,7 +3580,9 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__8) __Pyx_RefNannySetupContext("_fit_check", 0); + __Pyx_TraceCall("_fit_check", __pyx_f[0], 52, 0, __PYX_ERR(0, 52, __pyx_L1_error)); __Pyx_INCREF(__pyx_v_y); __Pyx_INCREF(__pyx_v_penalty); __Pyx_INCREF(__pyx_v_max_support_size); @@ -3348,6 +3600,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected X to be a 2D continuous non-degenerate real numpy or csc_matrix, but got {X}.") * n, p = X.shape */ + __Pyx_TraceLine(77,0,__PYX_ERR(0, 77, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 77, __pyx_L1_error) @@ -3453,6 +3706,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * n, p = X.shape * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: */ + __Pyx_TraceLine(78,0,__PYX_ERR(0, 78, __pyx_L1_error)) __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 78, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = 0; @@ -3468,10 +3722,10 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7); __pyx_t_7 = 0; - __Pyx_INCREF(__pyx_kp_u__5); + __Pyx_INCREF(__pyx_kp_u__6); __pyx_t_9 += 1; - __Pyx_GIVEREF(__pyx_kp_u__5); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u__5); + __Pyx_GIVEREF(__pyx_kp_u__6); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u__6); __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 78, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -3498,6 +3752,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") */ + __Pyx_TraceLine(79,0,__PYX_ERR(0, 79, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 79, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { @@ -3558,6 +3813,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") * if loss not in SUPPORTED_LOSS: */ + __Pyx_TraceLine(80,0,__PYX_ERR(0, 80, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 80, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 80, __pyx_L1_error) @@ -3629,6 +3885,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * if loss not in SUPPORTED_LOSS: * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") */ + __Pyx_TraceLine(81,0,__PYX_ERR(0, 81, __pyx_L1_error)) __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 81, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_9 = 0; @@ -3644,10 +3901,10 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_7); __pyx_t_7 = 0; - __Pyx_INCREF(__pyx_kp_u__5); + __Pyx_INCREF(__pyx_kp_u__6); __pyx_t_9 += 1; - __Pyx_GIVEREF(__pyx_kp_u__5); - PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_kp_u__5); + __Pyx_GIVEREF(__pyx_kp_u__6); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_kp_u__6); __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_2, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 81, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -3674,6 +3931,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") * if penalty not in SUPPORTED_PENALTY: */ + __Pyx_TraceLine(82,0,__PYX_ERR(0, 82, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_loss, __pyx_t_2, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 82, __pyx_L1_error) @@ -3688,6 +3946,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * if penalty not in SUPPORTED_PENALTY: * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") */ + __Pyx_TraceLine(83,0,__PYX_ERR(0, 83, __pyx_L1_error)) __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 83, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_9 = 0; @@ -3743,6 +4002,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") * if algorithm not in SUPPORTED_ALGORITHM: */ + __Pyx_TraceLine(84,0,__PYX_ERR(0, 84, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SUPPORTED_PENALTY); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 84, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_v_penalty, __pyx_t_2, Py_NE)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 84, __pyx_L1_error) @@ -3757,6 +4017,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * if algorithm not in SUPPORTED_ALGORITHM: * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") */ + __Pyx_TraceLine(85,0,__PYX_ERR(0, 85, __pyx_L1_error)) __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 85, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_9 = 0; @@ -3812,6 +4073,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") * if not isinstance(max_support_size, int) or 1 > max_support_size: */ + __Pyx_TraceLine(86,0,__PYX_ERR(0, 86, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SUPPORTED_ALGORITHM); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 86, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_algorithm, __pyx_t_2, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 86, __pyx_L1_error) @@ -3826,6 +4088,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * if not isinstance(max_support_size, int) or 1 > max_support_size: * raise ValueError(f"expected max_support_size parameter to be a positive integer, but got {max_support_size}") */ + __Pyx_TraceLine(87,0,__PYX_ERR(0, 87, __pyx_L1_error)) __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 87, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_9 = 0; @@ -3881,6 +4144,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected max_support_size parameter to be a positive integer, but got {max_support_size}") * max_support_size = min(p, max_support_size) */ + __Pyx_TraceLine(88,0,__PYX_ERR(0, 88, __pyx_L1_error)) __pyx_t_1 = PyInt_Check(__pyx_v_max_support_size); __pyx_t_4 = ((!(__pyx_t_1 != 0)) != 0); if (!__pyx_t_4) { @@ -3902,6 +4166,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * max_support_size = min(p, max_support_size) * */ + __Pyx_TraceLine(89,0,__PYX_ERR(0, 89, __pyx_L1_error)) __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_max_support_size, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 89, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_support_size_parame, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 89, __pyx_L1_error) @@ -3930,6 +4195,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * * if gamma_max < 0: */ + __Pyx_TraceLine(90,0,__PYX_ERR(0, 90, __pyx_L1_error)) __Pyx_INCREF(__pyx_v_max_support_size); __pyx_t_2 = __pyx_v_max_support_size; __Pyx_INCREF(__pyx_v_p); @@ -3959,6 +4225,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") * if gamma_min < 0 or gamma_min > gamma_max: */ + __Pyx_TraceLine(92,0,__PYX_ERR(0, 92, __pyx_L1_error)) __pyx_t_5 = ((__pyx_v_gamma_max < 0.0) != 0); if (unlikely(__pyx_t_5)) { @@ -3969,6 +4236,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * if gamma_min < 0 or gamma_min > gamma_max: * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," */ + __Pyx_TraceLine(93,0,__PYX_ERR(0, 93, __pyx_L1_error)) __pyx_t_2 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 93, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 93, __pyx_L1_error) @@ -4000,6 +4268,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," * f" but got {gamma_min}") */ + __Pyx_TraceLine(94,0,__PYX_ERR(0, 94, __pyx_L1_error)) __pyx_t_4 = ((__pyx_v_gamma_min < 0.0) != 0); if (!__pyx_t_4) { } else { @@ -4018,6 +4287,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * if not isinstance(partial_sort, bool): * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") */ + __Pyx_TraceLine(96,0,__PYX_ERR(0, 96, __pyx_L1_error)) __pyx_t_7 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 96, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 96, __pyx_L1_error) @@ -4031,6 +4301,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * f" but got {gamma_min}") * if not isinstance(partial_sort, bool): */ + __Pyx_TraceLine(95,0,__PYX_ERR(0, 95, __pyx_L1_error)) __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_gamma_max_parameter_to_2, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 95, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -4057,6 +4328,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") * if not isinstance(max_iter, int) or max_iter < 1: */ + __Pyx_TraceLine(97,0,__PYX_ERR(0, 97, __pyx_L1_error)) __pyx_t_2 = ((PyObject*)&PyBool_Type); __Pyx_INCREF(__pyx_t_2); __pyx_t_5 = PyObject_IsInstance(__pyx_v_partial_sort, __pyx_t_2); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 97, __pyx_L1_error) @@ -4071,6 +4343,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * if not isinstance(max_iter, int) or max_iter < 1: * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") */ + __Pyx_TraceLine(98,0,__PYX_ERR(0, 98, __pyx_L1_error)) __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_partial_sort, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_partial_sort_parameter, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 98, __pyx_L1_error) @@ -4099,6 +4372,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") * if rtol < 0 or rtol >= 1: */ + __Pyx_TraceLine(99,0,__PYX_ERR(0, 99, __pyx_L1_error)) __pyx_t_5 = PyInt_Check(__pyx_v_max_iter); __pyx_t_1 = ((!(__pyx_t_5 != 0)) != 0); if (!__pyx_t_1) { @@ -4120,6 +4394,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * if rtol < 0 or rtol >= 1: * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") */ + __Pyx_TraceLine(100,0,__PYX_ERR(0, 100, __pyx_L1_error)) __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_max_iter, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 100, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_iter_parameter_to_b, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 100, __pyx_L1_error) @@ -4148,6 +4423,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") * if atol < 0: */ + __Pyx_TraceLine(101,0,__PYX_ERR(0, 101, __pyx_L1_error)) __pyx_t_1 = ((__pyx_v_rtol < 0.0) != 0); if (!__pyx_t_1) { } else { @@ -4166,6 +4442,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * if atol < 0: * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") */ + __Pyx_TraceLine(102,0,__PYX_ERR(0, 102, __pyx_L1_error)) __pyx_t_2 = PyFloat_FromDouble(__pyx_v_rtol); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 102, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 102, __pyx_L1_error) @@ -4197,6 +4474,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") * if not isinstance(active_set, bool): */ + __Pyx_TraceLine(103,0,__PYX_ERR(0, 103, __pyx_L1_error)) __pyx_t_4 = ((__pyx_v_atol < 0.0) != 0); if (unlikely(__pyx_t_4)) { @@ -4207,6 +4485,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * if not isinstance(active_set, bool): * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") */ + __Pyx_TraceLine(104,0,__PYX_ERR(0, 104, __pyx_L1_error)) __pyx_t_7 = PyFloat_FromDouble(__pyx_v_atol); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 104, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 104, __pyx_L1_error) @@ -4238,6 +4517,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") * if not isinstance(active_set_num, int) or active_set_num < 1: */ + __Pyx_TraceLine(105,0,__PYX_ERR(0, 105, __pyx_L1_error)) __pyx_t_2 = ((PyObject*)&PyBool_Type); __Pyx_INCREF(__pyx_t_2); __pyx_t_4 = PyObject_IsInstance(__pyx_v_active_set, __pyx_t_2); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 105, __pyx_L1_error) @@ -4252,6 +4532,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * if not isinstance(active_set_num, int) or active_set_num < 1: * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") */ + __Pyx_TraceLine(106,0,__PYX_ERR(0, 106, __pyx_L1_error)) __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_active_set, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 106, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_active_set_parameter_to, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 106, __pyx_L1_error) @@ -4280,6 +4561,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") * if not isinstance(max_swaps, int) or max_swaps < 1: */ + __Pyx_TraceLine(107,0,__PYX_ERR(0, 107, __pyx_L1_error)) __pyx_t_4 = PyInt_Check(__pyx_v_active_set_num); __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); if (!__pyx_t_5) { @@ -4301,6 +4583,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * if not isinstance(max_swaps, int) or max_swaps < 1: * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") */ + __Pyx_TraceLine(108,0,__PYX_ERR(0, 108, __pyx_L1_error)) __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_active_set_num, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 108, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_active_set_num_paramete, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 108, __pyx_L1_error) @@ -4329,6 +4612,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") * if not (0 < scale_down_factor < 1): */ + __Pyx_TraceLine(109,0,__PYX_ERR(0, 109, __pyx_L1_error)) __pyx_t_5 = PyInt_Check(__pyx_v_max_swaps); __pyx_t_4 = ((!(__pyx_t_5 != 0)) != 0); if (!__pyx_t_4) { @@ -4350,6 +4634,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * if not (0 < scale_down_factor < 1): * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") */ + __Pyx_TraceLine(110,0,__PYX_ERR(0, 110, __pyx_L1_error)) __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_max_swaps, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 110, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_swaps_parameter_to, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 110, __pyx_L1_error) @@ -4378,6 +4663,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") * if not isinstance(screen_size, int) or screen_size < 1: */ + __Pyx_TraceLine(111,0,__PYX_ERR(0, 111, __pyx_L1_error)) __pyx_t_1 = (0.0 < __pyx_v_scale_down_factor); if (__pyx_t_1) { __pyx_t_1 = (__pyx_v_scale_down_factor < 1.0); @@ -4392,6 +4678,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * if not isinstance(screen_size, int) or screen_size < 1: * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") */ + __Pyx_TraceLine(112,0,__PYX_ERR(0, 112, __pyx_L1_error)) __pyx_t_2 = PyFloat_FromDouble(__pyx_v_scale_down_factor); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 112, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 112, __pyx_L1_error) @@ -4423,6 +4710,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") * screen_size = min(screen_size, p) */ + __Pyx_TraceLine(113,0,__PYX_ERR(0, 113, __pyx_L1_error)) __pyx_t_1 = PyInt_Check(__pyx_v_screen_size); __pyx_t_5 = ((!(__pyx_t_1 != 0)) != 0); if (!__pyx_t_5) { @@ -4444,6 +4732,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * screen_size = min(screen_size, p) * */ + __Pyx_TraceLine(114,0,__PYX_ERR(0, 114, __pyx_L1_error)) __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_screen_size, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 114, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_screen_size_parameter_t, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 114, __pyx_L1_error) @@ -4472,6 +4761,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): */ + __Pyx_TraceLine(115,0,__PYX_ERR(0, 115, __pyx_L1_error)) __Pyx_INCREF(__pyx_v_p); __pyx_t_7 = __pyx_v_p; __Pyx_INCREF(__pyx_v_screen_size); @@ -4501,6 +4791,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " * f"but got {exclude_first_k}") */ + __Pyx_TraceLine(117,0,__PYX_ERR(0, 117, __pyx_L1_error)) __pyx_t_5 = PyInt_Check(__pyx_v_exclude_first_k); __pyx_t_1 = ((!(__pyx_t_5 != 0)) != 0); if (!__pyx_t_1) { @@ -4527,6 +4818,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * f"but got {exclude_first_k}") * if not isinstance(intercept, bool): */ + __Pyx_TraceLine(118,0,__PYX_ERR(0, 118, __pyx_L1_error)) __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 118, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = 0; @@ -4554,6 +4846,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * if not isinstance(intercept, bool): * raise ValueError(f"expected intercept parameter to be a bool, " */ + __Pyx_TraceLine(119,0,__PYX_ERR(0, 119, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_exclude_first_k, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 119, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; @@ -4569,6 +4862,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * f"but got {exclude_first_k}") * if not isinstance(intercept, bool): */ + __Pyx_TraceLine(118,0,__PYX_ERR(0, 118, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 118, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; @@ -4595,6 +4889,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected intercept parameter to be a bool, " * f"but got {intercept}") */ + __Pyx_TraceLine(120,0,__PYX_ERR(0, 120, __pyx_L1_error)) __pyx_t_7 = ((PyObject*)&PyBool_Type); __Pyx_INCREF(__pyx_t_7); __pyx_t_4 = PyObject_IsInstance(__pyx_v_intercept, __pyx_t_7); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 120, __pyx_L1_error) @@ -4609,6 +4904,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * * if loss in CLASSIFICATION_LOSS: */ + __Pyx_TraceLine(122,0,__PYX_ERR(0, 122, __pyx_L1_error)) __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_intercept, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 122, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); @@ -4619,6 +4915,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * f"but got {intercept}") * */ + __Pyx_TraceLine(121,0,__PYX_ERR(0, 121, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_intercept_parameter_to, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 121, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; @@ -4645,6 +4942,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * unique_items = sorted(np.unique(y)) * if len(unique_items) != 2: */ + __Pyx_TraceLine(124,0,__PYX_ERR(0, 124, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_CLASSIFICATION_LOSS); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 124, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_v_loss, __pyx_t_7, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 124, __pyx_L1_error) @@ -4659,6 +4957,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * if len(unique_items) != 2: * raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " */ + __Pyx_TraceLine(125,0,__PYX_ERR(0, 125, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 125, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_unique); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 125, __pyx_L1_error) @@ -4695,6 +4994,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " * f"but got {unique_items}") */ + __Pyx_TraceLine(126,0,__PYX_ERR(0, 126, __pyx_L1_error)) if (unlikely(__pyx_v_unique_items == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(0, 126, __pyx_L1_error) @@ -4710,6 +5010,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * else: * a, *_ = unique_items # a is the lower value */ + __Pyx_TraceLine(128,0,__PYX_ERR(0, 128, __pyx_L1_error)) __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_unique_items, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 128, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); @@ -4720,6 +5021,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * f"but got {unique_items}") * else: */ + __Pyx_TraceLine(127,0,__PYX_ERR(0, 127, __pyx_L1_error)) __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_y_vector_to_only_have_t, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 127, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; @@ -4746,6 +5048,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * y = np.copy(y) * first_value = y==a */ + __Pyx_TraceLine(130,0,__PYX_ERR(0, 130, __pyx_L1_error)) /*else*/ { { Py_ssize_t index = -1; @@ -4781,6 +5084,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * first_value = y==a * second_value = y!=a */ + __Pyx_TraceLine(131,0,__PYX_ERR(0, 131, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 131, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_copy); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 131, __pyx_L1_error) @@ -4811,6 +5115,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * second_value = y!=a * y[first_value] = -1.0 */ + __Pyx_TraceLine(132,0,__PYX_ERR(0, 132, __pyx_L1_error)) __pyx_t_3 = PyObject_RichCompare(__pyx_v_y, __pyx_v_a, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 132, __pyx_L1_error) __pyx_v_first_value = __pyx_t_3; __pyx_t_3 = 0; @@ -4822,6 +5127,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * y[first_value] = -1.0 * y[second_value] = 1.0 */ + __Pyx_TraceLine(133,0,__PYX_ERR(0, 133, __pyx_L1_error)) __pyx_t_3 = PyObject_RichCompare(__pyx_v_y, __pyx_v_a, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 133, __pyx_L1_error) __pyx_v_second_value = __pyx_t_3; __pyx_t_3 = 0; @@ -4833,6 +5139,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * y[second_value] = 1.0 * if y.dtype != np.float64: */ + __Pyx_TraceLine(134,0,__PYX_ERR(0, 134, __pyx_L1_error)) if (unlikely(PyObject_SetItem(__pyx_v_y, __pyx_v_first_value, __pyx_float_neg_1_0) < 0)) __PYX_ERR(0, 134, __pyx_L1_error) /* "l0learn/interface.pyx":135 @@ -4842,6 +5149,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * if y.dtype != np.float64: * y = y.astype(float) */ + __Pyx_TraceLine(135,0,__PYX_ERR(0, 135, __pyx_L1_error)) if (unlikely(PyObject_SetItem(__pyx_v_y, __pyx_v_second_value, __pyx_float_1_0) < 0)) __PYX_ERR(0, 135, __pyx_L1_error) /* "l0learn/interface.pyx":136 @@ -4851,6 +5159,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * y = y.astype(float) * */ + __Pyx_TraceLine(136,0,__PYX_ERR(0, 136, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_y, __pyx_n_s_dtype); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 136, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 136, __pyx_L1_error) @@ -4872,6 +5181,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * * if penalty == "L0": */ + __Pyx_TraceLine(137,0,__PYX_ERR(0, 137, __pyx_L1_error)) __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_y, __pyx_n_s_astype); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 137, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_3 = NULL; @@ -4909,6 +5219,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * # Pure L0 is not supported for classification * # Below we add a small L2 component. */ + __Pyx_TraceLine(139,0,__PYX_ERR(0, 139, __pyx_L1_error)) __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 139, __pyx_L1_error) __pyx_t_5 = (__pyx_t_4 != 0); if (__pyx_t_5) { @@ -4920,6 +5231,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * # If this error checking was left to the lower section, it would confuse users as * # we are converting L0 to L0L2 with small L2 penalty. */ + __Pyx_TraceLine(143,0,__PYX_ERR(0, 143, __pyx_L1_error)) __pyx_t_4 = (__pyx_v_lambda_grid != Py_None); __pyx_t_1 = (__pyx_t_4 != 0); if (__pyx_t_1) { @@ -4940,6 +5252,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * * penalty = "L0L2" */ + __Pyx_TraceLine(148,0,__PYX_ERR(0, 148, __pyx_L1_error)) __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 148, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = 0; @@ -4955,10 +5268,10 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7); __pyx_t_7 = 0; - __Pyx_INCREF(__pyx_kp_u__5); + __Pyx_INCREF(__pyx_kp_u__6); __pyx_t_9 += 1; - __Pyx_GIVEREF(__pyx_kp_u__5); - PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__5); + __Pyx_GIVEREF(__pyx_kp_u__6); + PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__6); __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 148, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; @@ -4994,6 +5307,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * gamma_max = 1e-7 * gamma_min = 1e-7 */ + __Pyx_TraceLine(150,0,__PYX_ERR(0, 150, __pyx_L1_error)) __Pyx_INCREF(__pyx_n_u_L0L2); __Pyx_DECREF_SET(__pyx_v_penalty, __pyx_n_u_L0L2); @@ -5004,6 +5318,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * gamma_min = 1e-7 * elif penalty != "L0" and num_gamma == 1: */ + __Pyx_TraceLine(151,0,__PYX_ERR(0, 151, __pyx_L1_error)) __pyx_v_gamma_max = 1e-7; /* "l0learn/interface.pyx":152 @@ -5013,6 +5328,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * elif penalty != "L0" and num_gamma == 1: * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") */ + __Pyx_TraceLine(152,0,__PYX_ERR(0, 152, __pyx_L1_error)) __pyx_v_gamma_min = 1e-7; /* "l0learn/interface.pyx":124 @@ -5032,6 +5348,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") * */ + __Pyx_TraceLine(153,0,__PYX_ERR(0, 153, __pyx_L1_error)) __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 153, __pyx_L1_error) __pyx_t_4 = (__pyx_t_1 != 0); if (__pyx_t_4) { @@ -5054,6 +5371,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * * if y.dtype != np.float64: */ + __Pyx_TraceLine(154,0,__PYX_ERR(0, 154, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_warn); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_3 = PyTuple_New(5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 154, __pyx_L1_error) @@ -5128,6 +5446,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected y vector to have type {np.float64}, but got {y.dtype}") * */ + __Pyx_TraceLine(156,0,__PYX_ERR(0, 156, __pyx_L1_error)) __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_y, __pyx_n_s_dtype); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 156, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 156, __pyx_L1_error) @@ -5149,6 +5468,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * * if lambda_grid is None: */ + __Pyx_TraceLine(157,0,__PYX_ERR(0, 157, __pyx_L1_error)) __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 157, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = 0; @@ -5210,6 +5530,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * lambda_grid = [[0.]] * auto_lambda = True */ + __Pyx_TraceLine(159,0,__PYX_ERR(0, 159, __pyx_L1_error)) __pyx_t_5 = (__pyx_v_lambda_grid == Py_None); __pyx_t_4 = (__pyx_t_5 != 0); if (__pyx_t_4) { @@ -5221,6 +5542,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * auto_lambda = True * if not isinstance(num_lambda, int) or num_lambda < 1: */ + __Pyx_TraceLine(160,0,__PYX_ERR(0, 160, __pyx_L1_error)) __pyx_t_7 = PyList_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 160, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_INCREF(__pyx_float_0_); @@ -5241,6 +5563,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * if not isinstance(num_lambda, int) or num_lambda < 1: * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") */ + __Pyx_TraceLine(161,0,__PYX_ERR(0, 161, __pyx_L1_error)) __pyx_v_auto_lambda = 1; /* "l0learn/interface.pyx":162 @@ -5250,6 +5573,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") * if not isinstance(num_gamma, int) or num_gamma < 1: */ + __Pyx_TraceLine(162,0,__PYX_ERR(0, 162, __pyx_L1_error)) __pyx_t_5 = PyInt_Check(__pyx_v_num_lambda); __pyx_t_1 = ((!(__pyx_t_5 != 0)) != 0); if (!__pyx_t_1) { @@ -5271,6 +5595,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * if not isinstance(num_gamma, int) or num_gamma < 1: * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") */ + __Pyx_TraceLine(163,0,__PYX_ERR(0, 163, __pyx_L1_error)) __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 163, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = 0; @@ -5286,10 +5611,10 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7); __pyx_t_7 = 0; - __Pyx_INCREF(__pyx_kp_u__5); + __Pyx_INCREF(__pyx_kp_u__6); __pyx_t_9 += 1; - __Pyx_GIVEREF(__pyx_kp_u__5); - PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__5); + __Pyx_GIVEREF(__pyx_kp_u__6); + PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__6); __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 163, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; @@ -5316,6 +5641,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") * if penalty == "L0" and num_gamma != 1: */ + __Pyx_TraceLine(164,0,__PYX_ERR(0, 164, __pyx_L1_error)) __pyx_t_1 = PyInt_Check(__pyx_v_num_gamma); __pyx_t_5 = ((!(__pyx_t_1 != 0)) != 0); if (!__pyx_t_5) { @@ -5337,6 +5663,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * if penalty == "L0" and num_gamma != 1: * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") */ + __Pyx_TraceLine(165,0,__PYX_ERR(0, 165, __pyx_L1_error)) __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 165, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = 0; @@ -5352,10 +5679,10 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7); __pyx_t_7 = 0; - __Pyx_INCREF(__pyx_kp_u__5); + __Pyx_INCREF(__pyx_kp_u__6); __pyx_t_9 += 1; - __Pyx_GIVEREF(__pyx_kp_u__5); - PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__5); + __Pyx_GIVEREF(__pyx_kp_u__6); + PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__6); __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 165, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; @@ -5382,6 +5709,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") * else: # lambda_grid should be a List[List[float]] */ + __Pyx_TraceLine(166,0,__PYX_ERR(0, 166, __pyx_L1_error)) __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 166, __pyx_L1_error) __pyx_t_1 = (__pyx_t_5 != 0); if (__pyx_t_1) { @@ -5404,6 +5732,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * else: # lambda_grid should be a List[List[float]] * if num_gamma is not None: */ + __Pyx_TraceLine(167,0,__PYX_ERR(0, 167, __pyx_L1_error)) __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 167, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = 0; @@ -5419,10 +5748,10 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7); __pyx_t_7 = 0; - __Pyx_INCREF(__pyx_kp_u__5); + __Pyx_INCREF(__pyx_kp_u__6); __pyx_t_9 += 1; - __Pyx_GIVEREF(__pyx_kp_u__5); - PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__5); + __Pyx_GIVEREF(__pyx_kp_u__6); + PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__6); __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 167, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; @@ -5459,6 +5788,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " * f"but got {num_gamma}") */ + __Pyx_TraceLine(169,0,__PYX_ERR(0, 169, __pyx_L1_error)) /*else*/ { __pyx_t_4 = (__pyx_v_num_gamma != Py_None); __pyx_t_1 = (__pyx_t_4 != 0); @@ -5471,6 +5801,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * num_gamma = len(lambda_grid) * */ + __Pyx_TraceLine(171,0,__PYX_ERR(0, 171, __pyx_L1_error)) __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 171, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); @@ -5481,6 +5812,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * f"but got {num_gamma}") * num_gamma = len(lambda_grid) */ + __Pyx_TraceLine(170,0,__PYX_ERR(0, 170, __pyx_L1_error)) __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_gamma_to_be_None_if, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; @@ -5507,6 +5839,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * * if num_lambda is not None: */ + __Pyx_TraceLine(172,0,__PYX_ERR(0, 172, __pyx_L1_error)) __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 172, __pyx_L1_error) __pyx_t_8 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 172, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); @@ -5520,6 +5853,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " * f"but got {num_lambda}") */ + __Pyx_TraceLine(174,0,__PYX_ERR(0, 174, __pyx_L1_error)) __pyx_t_1 = (__pyx_v_num_lambda != Py_None); __pyx_t_4 = (__pyx_t_1 != 0); if (unlikely(__pyx_t_4)) { @@ -5531,6 +5865,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * num_lambda = 0 # This value is ignored. * auto_lambda = False */ + __Pyx_TraceLine(176,0,__PYX_ERR(0, 176, __pyx_L1_error)) __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 176, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); @@ -5541,6 +5876,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * f"but got {num_lambda}") * num_lambda = 0 # This value is ignored. */ + __Pyx_TraceLine(175,0,__PYX_ERR(0, 175, __pyx_L1_error)) __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_lambda_to_be_None_i, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 175, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; @@ -5567,6 +5903,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * auto_lambda = False * bad_lambda_grid = False */ + __Pyx_TraceLine(177,0,__PYX_ERR(0, 177, __pyx_L1_error)) __Pyx_INCREF(__pyx_int_0); __Pyx_DECREF_SET(__pyx_v_num_lambda, __pyx_int_0); @@ -5577,6 +5914,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * bad_lambda_grid = False * */ + __Pyx_TraceLine(178,0,__PYX_ERR(0, 178, __pyx_L1_error)) __pyx_v_auto_lambda = 0; /* "l0learn/interface.pyx":179 @@ -5586,6 +5924,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * * if penalty == "L0" and num_gamma != 1: */ + __Pyx_TraceLine(179,0,__PYX_ERR(0, 179, __pyx_L1_error)) __pyx_v_bad_lambda_grid = 0; /* "l0learn/interface.pyx":181 @@ -5595,6 +5934,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") * */ + __Pyx_TraceLine(181,0,__PYX_ERR(0, 181, __pyx_L1_error)) __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 181, __pyx_L1_error) __pyx_t_5 = (__pyx_t_1 != 0); if (__pyx_t_5) { @@ -5617,6 +5957,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * * for i, sub_lambda_grid in enumerate(lambda_grid): */ + __Pyx_TraceLine(182,0,__PYX_ERR(0, 182, __pyx_L1_error)) __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 182, __pyx_L1_error) __pyx_t_8 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_9, 0, ' ', 'd'); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 182, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); @@ -5646,6 +5987,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * current = float("inf") * if sub_lambda_grid[0] <= 0: */ + __Pyx_TraceLine(184,0,__PYX_ERR(0, 184, __pyx_L1_error)) __Pyx_INCREF(__pyx_int_0); __pyx_t_8 = __pyx_int_0; if (likely(PyList_CheckExact(__pyx_v_lambda_grid)) || PyTuple_CheckExact(__pyx_v_lambda_grid)) { @@ -5704,6 +6046,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * if sub_lambda_grid[0] <= 0: * raise ValueError(f"Expected all values of lambda_grid to be positive, " */ + __Pyx_TraceLine(185,0,__PYX_ERR(0, 185, __pyx_L1_error)) __pyx_t_14 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 185, __pyx_L1_error) __pyx_v_current = __pyx_t_14; @@ -5714,6 +6057,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"Expected all values of lambda_grid to be positive, " * f"but got lambda_grid[{i}] containing a negative value") */ + __Pyx_TraceLine(186,0,__PYX_ERR(0, 186, __pyx_L1_error)) __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_sub_lambda_grid, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 186, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyObject_RichCompare(__pyx_t_2, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 186, __pyx_L1_error) @@ -5729,6 +6073,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): */ + __Pyx_TraceLine(187,0,__PYX_ERR(0, 187, __pyx_L1_error)) __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 187, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_15 = 0; @@ -5745,6 +6090,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * if any(np.diff(sub_lambda_grid) >= 0): * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " */ + __Pyx_TraceLine(188,0,__PYX_ERR(0, 188, __pyx_L1_error)) __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 188, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; @@ -5764,6 +6110,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): */ + __Pyx_TraceLine(187,0,__PYX_ERR(0, 187, __pyx_L1_error)) __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 187, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -5790,6 +6137,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " * f"but got lambda_grid[{i}] containing an increasing value.") */ + __Pyx_TraceLine(189,0,__PYX_ERR(0, 189, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 189, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_diff); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 189, __pyx_L1_error) @@ -5826,6 +6174,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * f"but got lambda_grid[{i}] containing an increasing value.") * */ + __Pyx_TraceLine(190,0,__PYX_ERR(0, 190, __pyx_L1_error)) __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 190, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_15 = 0; @@ -5842,6 +6191,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * * n, p = X.shape */ + __Pyx_TraceLine(191,0,__PYX_ERR(0, 191, __pyx_L1_error)) __pyx_t_16 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 191, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_16) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_16) : __pyx_t_10; @@ -5861,6 +6211,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * f"but got lambda_grid[{i}] containing an increasing value.") * */ + __Pyx_TraceLine(190,0,__PYX_ERR(0, 190, __pyx_L1_error)) __pyx_t_16 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 190, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -5887,6 +6238,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * current = float("inf") * if sub_lambda_grid[0] <= 0: */ + __Pyx_TraceLine(184,0,__PYX_ERR(0, 184, __pyx_L1_error)) } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; @@ -5900,6 +6252,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * with_bounds = False * */ + __Pyx_TraceLine(193,0,__PYX_ERR(0, 193, __pyx_L1_error)) __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 193, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if ((likely(PyTuple_CheckExact(__pyx_t_8))) || (PyList_CheckExact(__pyx_t_8))) { @@ -5960,6 +6313,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * * if isinstance(lows, float): */ + __Pyx_TraceLine(194,0,__PYX_ERR(0, 194, __pyx_L1_error)) __pyx_v_with_bounds = 0; /* "l0learn/interface.pyx":196 @@ -5969,6 +6323,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") */ + __Pyx_TraceLine(196,0,__PYX_ERR(0, 196, __pyx_L1_error)) __pyx_t_4 = PyFloat_Check(__pyx_v_lows); __pyx_t_5 = (__pyx_t_4 != 0); if (__pyx_t_5) { @@ -5980,6 +6335,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") * elif lows > -float('inf'): */ + __Pyx_TraceLine(197,0,__PYX_ERR(0, 197, __pyx_L1_error)) __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_GT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 197, __pyx_L1_error) __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 197, __pyx_L1_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; @@ -5992,6 +6348,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * elif lows > -float('inf'): * with_bounds = True */ + __Pyx_TraceLine(198,0,__PYX_ERR(0, 198, __pyx_L1_error)) __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 198, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lows_to_be_a_non_positi, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 198, __pyx_L1_error) @@ -6020,6 +6377,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * with_bounds = True * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): */ + __Pyx_TraceLine(199,0,__PYX_ERR(0, 199, __pyx_L1_error)) __pyx_t_14 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 199, __pyx_L1_error) __pyx_t_8 = PyFloat_FromDouble((-__pyx_t_14)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 199, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); @@ -6036,6 +6394,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): * with_bounds = True */ + __Pyx_TraceLine(200,0,__PYX_ERR(0, 200, __pyx_L1_error)) __pyx_v_with_bounds = 1; /* "l0learn/interface.pyx":199 @@ -6064,6 +6423,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * with_bounds = True * else: */ + __Pyx_TraceLine(201,0,__PYX_ERR(0, 201, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 201, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 201, __pyx_L1_error) @@ -6118,6 +6478,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * else: * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " */ + __Pyx_TraceLine(202,0,__PYX_ERR(0, 202, __pyx_L1_error)) __pyx_v_with_bounds = 1; /* "l0learn/interface.pyx":201 @@ -6137,6 +6498,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * f"floats, but got {lows}") * */ + __Pyx_TraceLine(204,0,__PYX_ERR(0, 204, __pyx_L1_error)) /*else*/ { __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 204, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); @@ -6165,6 +6527,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * * if isinstance(highs, float): */ + __Pyx_TraceLine(205,0,__PYX_ERR(0, 205, __pyx_L1_error)) __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 205, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; @@ -6180,6 +6543,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * f"floats, but got {lows}") * */ + __Pyx_TraceLine(204,0,__PYX_ERR(0, 204, __pyx_L1_error)) __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 204, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -6199,6 +6563,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * if highs < 0: * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") */ + __Pyx_TraceLine(207,0,__PYX_ERR(0, 207, __pyx_L1_error)) __pyx_t_5 = PyFloat_Check(__pyx_v_highs); __pyx_t_1 = (__pyx_t_5 != 0); if (__pyx_t_1) { @@ -6210,6 +6575,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") * if highs < float('inf'): */ + __Pyx_TraceLine(208,0,__PYX_ERR(0, 208, __pyx_L1_error)) __pyx_t_3 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 208, __pyx_L1_error) __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 208, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -6222,6 +6588,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * if highs < float('inf'): * with_bounds = True */ + __Pyx_TraceLine(209,0,__PYX_ERR(0, 209, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 209, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_highs_to_be_a_non_negat, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 209, __pyx_L1_error) @@ -6250,6 +6617,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * with_bounds = True * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): */ + __Pyx_TraceLine(210,0,__PYX_ERR(0, 210, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyNumber_Float(__pyx_n_u_inf); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 210, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_8 = PyObject_RichCompare(__pyx_v_highs, __pyx_t_3, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 210, __pyx_L1_error) @@ -6265,6 +6633,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): * with_bounds = True */ + __Pyx_TraceLine(211,0,__PYX_ERR(0, 211, __pyx_L1_error)) __pyx_v_with_bounds = 1; /* "l0learn/interface.pyx":210 @@ -6293,6 +6662,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * with_bounds = True * else: */ + __Pyx_TraceLine(212,0,__PYX_ERR(0, 212, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 212, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 212, __pyx_L1_error) @@ -6344,6 +6714,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * else: * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " */ + __Pyx_TraceLine(213,0,__PYX_ERR(0, 213, __pyx_L1_error)) __pyx_v_with_bounds = 1; /* "l0learn/interface.pyx":212 @@ -6363,6 +6734,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * f"non-negative floats, but got {highs}") * */ + __Pyx_TraceLine(215,0,__PYX_ERR(0, 215, __pyx_L1_error)) /*else*/ { __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 215, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); @@ -6391,6 +6763,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * * if with_bounds: */ + __Pyx_TraceLine(216,0,__PYX_ERR(0, 216, __pyx_L1_error)) __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 216, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; @@ -6406,6 +6779,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * f"non-negative floats, but got {highs}") * */ + __Pyx_TraceLine(215,0,__PYX_ERR(0, 215, __pyx_L1_error)) __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 215, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -6425,6 +6799,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * if isinstance(lows, float): * lows = np.ones(p) * lows */ + __Pyx_TraceLine(218,0,__PYX_ERR(0, 218, __pyx_L1_error)) __pyx_t_1 = (__pyx_v_with_bounds != 0); if (__pyx_t_1) { @@ -6435,6 +6810,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * lows = np.ones(p) * lows * if isinstance(highs, float): */ + __Pyx_TraceLine(219,0,__PYX_ERR(0, 219, __pyx_L1_error)) __pyx_t_1 = PyFloat_Check(__pyx_v_lows); __pyx_t_4 = (__pyx_t_1 != 0); if (__pyx_t_4) { @@ -6446,6 +6822,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * if isinstance(highs, float): * highs = np.ones(p) * highs */ + __Pyx_TraceLine(220,0,__PYX_ERR(0, 220, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_ones); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 220, __pyx_L1_error) @@ -6488,6 +6865,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * highs = np.ones(p) * highs * */ + __Pyx_TraceLine(221,0,__PYX_ERR(0, 221, __pyx_L1_error)) __pyx_t_4 = PyFloat_Check(__pyx_v_highs); __pyx_t_1 = (__pyx_t_4 != 0); if (__pyx_t_1) { @@ -6499,6 +6877,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * * if any(lows >= highs): */ + __Pyx_TraceLine(222,0,__PYX_ERR(0, 222, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 222, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_ones); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 222, __pyx_L1_error) @@ -6541,6 +6920,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * bad_bounds = np.argwhere(lows >= highs) * raise ValueError(f"expected to be high to be elementwise greater than lows, " */ + __Pyx_TraceLine(224,0,__PYX_ERR(0, 224, __pyx_L1_error)) __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 224, __pyx_L1_error) __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 224, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); @@ -6556,6 +6936,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected to be high to be elementwise greater than lows, " * f"but got indices {bad_bounds[0]} where that is not the case ") */ + __Pyx_TraceLine(225,0,__PYX_ERR(0, 225, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 225, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_argwhere); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 225, __pyx_L1_error) @@ -6588,6 +6969,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * f"but got indices {bad_bounds[0]} where that is not the case ") * else: */ + __Pyx_TraceLine(226,0,__PYX_ERR(0, 226, __pyx_L1_error)) __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 226, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = 0; @@ -6604,6 +6986,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * else: * lows = np.array([0.]) */ + __Pyx_TraceLine(227,0,__PYX_ERR(0, 227, __pyx_L1_error)) __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_bad_bounds, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 227, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 227, __pyx_L1_error) @@ -6626,6 +7009,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * f"but got indices {bad_bounds[0]} where that is not the case ") * else: */ + __Pyx_TraceLine(226,0,__PYX_ERR(0, 226, __pyx_L1_error)) __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 226, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; @@ -6662,6 +7046,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * highs = np.array(([0.])) * */ + __Pyx_TraceLine(229,0,__PYX_ERR(0, 229, __pyx_L1_error)) /*else*/ { __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 229, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); @@ -6699,6 +7084,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * * return {"max_support_size": max_support_size, */ + __Pyx_TraceLine(230,0,__PYX_ERR(0, 230, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 230, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_array); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 230, __pyx_L1_error) @@ -6737,6 +7123,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * "screen_size": screen_size, * "y": y, */ + __Pyx_TraceLine(232,0,__PYX_ERR(0, 232, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_t_7 = __Pyx_PyDict_NewPresized(13); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 232, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); @@ -6749,6 +7136,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * "y": y, * "penalty":penalty, */ + __Pyx_TraceLine(233,0,__PYX_ERR(0, 233, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_screen_size, __pyx_v_screen_size) < 0) __PYX_ERR(0, 232, __pyx_L1_error) /* "l0learn/interface.pyx":234 @@ -6758,6 +7146,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * "penalty":penalty, * "gamma_max":gamma_max, */ + __Pyx_TraceLine(234,0,__PYX_ERR(0, 234, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_y, __pyx_v_y) < 0) __PYX_ERR(0, 232, __pyx_L1_error) /* "l0learn/interface.pyx":235 @@ -6767,6 +7156,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * "gamma_max":gamma_max, * "gamma_min": gamma_min, */ + __Pyx_TraceLine(235,0,__PYX_ERR(0, 235, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 232, __pyx_L1_error) /* "l0learn/interface.pyx":236 @@ -6776,6 +7166,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * "gamma_min": gamma_min, * "lambda_grid": lambda_grid, */ + __Pyx_TraceLine(236,0,__PYX_ERR(0, 236, __pyx_L1_error)) __pyx_t_8 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 236, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_gamma_max, __pyx_t_8) < 0) __PYX_ERR(0, 232, __pyx_L1_error) @@ -6788,6 +7179,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * "lambda_grid": lambda_grid, * "num_gamma": num_gamma, */ + __Pyx_TraceLine(237,0,__PYX_ERR(0, 237, __pyx_L1_error)) __pyx_t_8 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 237, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_gamma_min, __pyx_t_8) < 0) __PYX_ERR(0, 232, __pyx_L1_error) @@ -6800,6 +7192,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * "num_gamma": num_gamma, * "num_lambda":num_lambda, */ + __Pyx_TraceLine(238,0,__PYX_ERR(0, 238, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_lambda_grid, __pyx_v_lambda_grid) < 0) __PYX_ERR(0, 232, __pyx_L1_error) /* "l0learn/interface.pyx":239 @@ -6809,6 +7202,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * "num_lambda":num_lambda, * "auto_lambda": auto_lambda, */ + __Pyx_TraceLine(239,0,__PYX_ERR(0, 239, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_num_gamma, __pyx_v_num_gamma) < 0) __PYX_ERR(0, 232, __pyx_L1_error) /* "l0learn/interface.pyx":240 @@ -6818,6 +7212,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * "auto_lambda": auto_lambda, * "with_bounds": with_bounds, */ + __Pyx_TraceLine(240,0,__PYX_ERR(0, 240, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_num_lambda, __pyx_v_num_lambda) < 0) __PYX_ERR(0, 232, __pyx_L1_error) /* "l0learn/interface.pyx":241 @@ -6827,6 +7222,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * "with_bounds": with_bounds, * "lows": lows, */ + __Pyx_TraceLine(241,0,__PYX_ERR(0, 241, __pyx_L1_error)) __pyx_t_8 = __Pyx_PyBool_FromLong(__pyx_v_auto_lambda); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 241, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_auto_lambda, __pyx_t_8) < 0) __PYX_ERR(0, 232, __pyx_L1_error) @@ -6839,6 +7235,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * "lows": lows, * "highs":highs} */ + __Pyx_TraceLine(242,0,__PYX_ERR(0, 242, __pyx_L1_error)) __pyx_t_8 = __Pyx_PyBool_FromLong(__pyx_v_with_bounds); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 242, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_with_bounds, __pyx_t_8) < 0) __PYX_ERR(0, 232, __pyx_L1_error) @@ -6851,6 +7248,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * "highs":highs} * */ + __Pyx_TraceLine(243,0,__PYX_ERR(0, 243, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_lows, __pyx_v_lows) < 0) __PYX_ERR(0, 232, __pyx_L1_error) /* "l0learn/interface.pyx":244 @@ -6860,6 +7258,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * * */ + __Pyx_TraceLine(244,0,__PYX_ERR(0, 244, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_highs, __pyx_v_highs) < 0) __PYX_ERR(0, 232, __pyx_L1_error) __pyx_r = __pyx_t_7; __pyx_t_7 = 0; @@ -6903,6 +7302,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject __Pyx_XDECREF(__pyx_v_lows); __Pyx_XDECREF(__pyx_v_highs); __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -7000,8 +7400,8 @@ static PyObject *__pyx_pw_7l0learn_9interface_5fit(PyObject *__pyx_self, PyObjec * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.FitModel: */ values[21] = ((PyObject *)Py_True); - values[22] = __pyx_k__7; - values[23] = __pyx_k__8; + values[22] = __pyx_k__9; + values[23] = __pyx_k__10; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); @@ -7342,6 +7742,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx fitmodel __pyx_v_c_results; PyObject *__pyx_v_results = NULL; PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; @@ -7372,7 +7773,9 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__11) __Pyx_RefNannySetupContext("fit", 0); + __Pyx_TraceCall("fit", __pyx_f[0], 247, 0, __PYX_ERR(0, 247, __pyx_L1_error)); __Pyx_INCREF(__pyx_v_y); __Pyx_INCREF(__pyx_v_penalty); __Pyx_INCREF(__pyx_v_max_support_size); @@ -7390,6 +7793,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * y=y, * loss=loss, */ + __Pyx_TraceLine(418,0,__PYX_ERR(0, 418, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_fit_check); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 418, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyDict_NewPresized(24); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 418, __pyx_L1_error) @@ -7403,6 +7807,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * loss=loss, * penalty=penalty, */ + __Pyx_TraceLine(419,0,__PYX_ERR(0, 419, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_y, __pyx_v_y) < 0) __PYX_ERR(0, 418, __pyx_L1_error) /* "l0learn/interface.pyx":420 @@ -7412,6 +7817,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * penalty=penalty, * algorithm=algorithm, */ + __Pyx_TraceLine(420,0,__PYX_ERR(0, 420, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 418, __pyx_L1_error) /* "l0learn/interface.pyx":421 @@ -7421,6 +7827,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * algorithm=algorithm, * max_support_size=max_support_size, */ + __Pyx_TraceLine(421,0,__PYX_ERR(0, 421, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 418, __pyx_L1_error) /* "l0learn/interface.pyx":422 @@ -7430,6 +7837,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * max_support_size=max_support_size, * num_lambda=num_lambda, */ + __Pyx_TraceLine(422,0,__PYX_ERR(0, 422, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_algorithm, __pyx_v_algorithm) < 0) __PYX_ERR(0, 418, __pyx_L1_error) /* "l0learn/interface.pyx":423 @@ -7439,6 +7847,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * num_lambda=num_lambda, * num_gamma=num_gamma, */ + __Pyx_TraceLine(423,0,__PYX_ERR(0, 423, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_support_size, __pyx_v_max_support_size) < 0) __PYX_ERR(0, 418, __pyx_L1_error) /* "l0learn/interface.pyx":424 @@ -7448,6 +7857,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * num_gamma=num_gamma, * gamma_max=gamma_max, */ + __Pyx_TraceLine(424,0,__PYX_ERR(0, 424, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_lambda, __pyx_v_num_lambda) < 0) __PYX_ERR(0, 418, __pyx_L1_error) /* "l0learn/interface.pyx":425 @@ -7457,6 +7867,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * gamma_max=gamma_max, * gamma_min=gamma_min, */ + __Pyx_TraceLine(425,0,__PYX_ERR(0, 425, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_gamma, __pyx_v_num_gamma) < 0) __PYX_ERR(0, 418, __pyx_L1_error) /* "l0learn/interface.pyx":426 @@ -7466,6 +7877,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * gamma_min=gamma_min, * partial_sort=partial_sort, */ + __Pyx_TraceLine(426,0,__PYX_ERR(0, 426, __pyx_L1_error)) __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 426, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma_max, __pyx_t_3) < 0) __PYX_ERR(0, 418, __pyx_L1_error) @@ -7478,6 +7890,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * partial_sort=partial_sort, * max_iter=max_iter, */ + __Pyx_TraceLine(427,0,__PYX_ERR(0, 427, __pyx_L1_error)) __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 427, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma_min, __pyx_t_3) < 0) __PYX_ERR(0, 418, __pyx_L1_error) @@ -7490,6 +7903,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * max_iter=max_iter, * rtol=rtol, */ + __Pyx_TraceLine(428,0,__PYX_ERR(0, 428, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_partial_sort, __pyx_v_partial_sort) < 0) __PYX_ERR(0, 418, __pyx_L1_error) /* "l0learn/interface.pyx":429 @@ -7499,6 +7913,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * rtol=rtol, * atol=atol, */ + __Pyx_TraceLine(429,0,__PYX_ERR(0, 429, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_iter, __pyx_v_max_iter) < 0) __PYX_ERR(0, 418, __pyx_L1_error) /* "l0learn/interface.pyx":430 @@ -7508,6 +7923,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * atol=atol, * active_set=active_set, */ + __Pyx_TraceLine(430,0,__PYX_ERR(0, 430, __pyx_L1_error)) __pyx_t_3 = PyFloat_FromDouble(__pyx_v_rtol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 430, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_rtol, __pyx_t_3) < 0) __PYX_ERR(0, 418, __pyx_L1_error) @@ -7520,6 +7936,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * active_set=active_set, * active_set_num=active_set_num, */ + __Pyx_TraceLine(431,0,__PYX_ERR(0, 431, __pyx_L1_error)) __pyx_t_3 = PyFloat_FromDouble(__pyx_v_atol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 431, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_atol, __pyx_t_3) < 0) __PYX_ERR(0, 418, __pyx_L1_error) @@ -7532,6 +7949,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * active_set_num=active_set_num, * max_swaps=max_swaps, */ + __Pyx_TraceLine(432,0,__PYX_ERR(0, 432, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_active_set, __pyx_v_active_set) < 0) __PYX_ERR(0, 418, __pyx_L1_error) /* "l0learn/interface.pyx":433 @@ -7541,6 +7959,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * max_swaps=max_swaps, * scale_down_factor=scale_down_factor, */ + __Pyx_TraceLine(433,0,__PYX_ERR(0, 433, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_active_set_num, __pyx_v_active_set_num) < 0) __PYX_ERR(0, 418, __pyx_L1_error) /* "l0learn/interface.pyx":434 @@ -7550,6 +7969,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * scale_down_factor=scale_down_factor, * screen_size=screen_size, */ + __Pyx_TraceLine(434,0,__PYX_ERR(0, 434, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_swaps, __pyx_v_max_swaps) < 0) __PYX_ERR(0, 418, __pyx_L1_error) /* "l0learn/interface.pyx":435 @@ -7559,6 +7979,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * screen_size=screen_size, * lambda_grid=lambda_grid, */ + __Pyx_TraceLine(435,0,__PYX_ERR(0, 435, __pyx_L1_error)) __pyx_t_3 = PyFloat_FromDouble(__pyx_v_scale_down_factor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 435, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_scale_down_factor, __pyx_t_3) < 0) __PYX_ERR(0, 418, __pyx_L1_error) @@ -7571,6 +7992,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * lambda_grid=lambda_grid, * exclude_first_k=exclude_first_k, */ + __Pyx_TraceLine(436,0,__PYX_ERR(0, 436, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_screen_size, __pyx_v_screen_size) < 0) __PYX_ERR(0, 418, __pyx_L1_error) /* "l0learn/interface.pyx":437 @@ -7580,6 +8002,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * exclude_first_k=exclude_first_k, * intercept=intercept, */ + __Pyx_TraceLine(437,0,__PYX_ERR(0, 437, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lambda_grid, __pyx_v_lambda_grid) < 0) __PYX_ERR(0, 418, __pyx_L1_error) /* "l0learn/interface.pyx":438 @@ -7589,6 +8012,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * intercept=intercept, * lows=lows, */ + __Pyx_TraceLine(438,0,__PYX_ERR(0, 438, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_exclude_first_k, __pyx_v_exclude_first_k) < 0) __PYX_ERR(0, 418, __pyx_L1_error) /* "l0learn/interface.pyx":439 @@ -7598,6 +8022,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * lows=lows, * highs=highs) */ + __Pyx_TraceLine(439,0,__PYX_ERR(0, 439, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 418, __pyx_L1_error) /* "l0learn/interface.pyx":440 @@ -7607,6 +8032,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * highs=highs) * */ + __Pyx_TraceLine(440,0,__PYX_ERR(0, 440, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lows, __pyx_v_lows) < 0) __PYX_ERR(0, 418, __pyx_L1_error) /* "l0learn/interface.pyx":441 @@ -7616,6 +8042,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * * max_support_size = check["max_support_size"] */ + __Pyx_TraceLine(441,0,__PYX_ERR(0, 441, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_highs, __pyx_v_highs) < 0) __PYX_ERR(0, 418, __pyx_L1_error) /* "l0learn/interface.pyx":418 @@ -7625,6 +8052,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * y=y, * loss=loss, */ + __Pyx_TraceLine(418,0,__PYX_ERR(0, 418, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 418, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -7639,6 +8067,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * screen_size = check["screen_size"] * y = check['y'] */ + __Pyx_TraceLine(443,0,__PYX_ERR(0, 443, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_max_support_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 443, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_max_support_size, __pyx_t_3); @@ -7651,6 +8080,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * y = check['y'] * penalty = check['penalty'] */ + __Pyx_TraceLine(444,0,__PYX_ERR(0, 444, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_screen_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 444, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_screen_size, __pyx_t_3); @@ -7663,6 +8093,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * penalty = check['penalty'] * gamma_max = check['gamma_max'] */ + __Pyx_TraceLine(445,0,__PYX_ERR(0, 445, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_y); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 445, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_y, __pyx_t_3); @@ -7675,6 +8106,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * gamma_max = check['gamma_max'] * gamma_min = check['gamma_min'] */ + __Pyx_TraceLine(446,0,__PYX_ERR(0, 446, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_penalty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 446, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (!(likely(PyUnicode_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(0, 446, __pyx_L1_error) @@ -7688,6 +8120,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * gamma_min = check['gamma_min'] * lambda_grid = check['lambda_grid'] */ + __Pyx_TraceLine(447,0,__PYX_ERR(0, 447, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 447, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 447, __pyx_L1_error) @@ -7701,6 +8134,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * lambda_grid = check['lambda_grid'] * num_gamma = check['num_gamma'] */ + __Pyx_TraceLine(448,0,__PYX_ERR(0, 448, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_gamma_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 448, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 448, __pyx_L1_error) @@ -7714,6 +8148,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * num_gamma = check['num_gamma'] * num_lambda = check['num_lambda'] */ + __Pyx_TraceLine(449,0,__PYX_ERR(0, 449, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_lambda_grid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 449, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_lambda_grid, __pyx_t_3); @@ -7726,6 +8161,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * num_lambda = check['num_lambda'] * auto_lambda = check['auto_lambda'] */ + __Pyx_TraceLine(450,0,__PYX_ERR(0, 450, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_num_gamma); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 450, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_num_gamma, __pyx_t_3); @@ -7738,6 +8174,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * auto_lambda = check['auto_lambda'] * with_bounds = check['with_bounds'] */ + __Pyx_TraceLine(451,0,__PYX_ERR(0, 451, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_num_lambda); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 451, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_num_lambda, __pyx_t_3); @@ -7750,6 +8187,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * with_bounds = check['with_bounds'] * lows = check['lows'] */ + __Pyx_TraceLine(452,0,__PYX_ERR(0, 452, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_auto_lambda); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 452, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_auto_lambda = __pyx_t_3; @@ -7762,6 +8200,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * lows = check['lows'] * highs = check['highs'] */ + __Pyx_TraceLine(453,0,__PYX_ERR(0, 453, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_with_bounds); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 453, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_with_bounds = __pyx_t_3; @@ -7774,6 +8213,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * highs = check['highs'] * */ + __Pyx_TraceLine(454,0,__PYX_ERR(0, 454, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_lows); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 454, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_3); @@ -7786,6 +8226,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * * cdef vector[vector[double]] c_lambda_grid */ + __Pyx_TraceLine(455,0,__PYX_ERR(0, 455, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_highs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 455, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_3); @@ -7798,6 +8239,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * c_lambda_grid = lambda_grid * except TypeError: */ + __Pyx_TraceLine(458,0,__PYX_ERR(0, 458, __pyx_L1_error)) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign @@ -7814,6 +8256,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * except TypeError: * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") */ + __Pyx_TraceLine(459,0,__PYX_ERR(0, 459, __pyx_L3_error)) __pyx_t_8 = __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_lambda_grid); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 459, __pyx_L3_error) __pyx_v_c_lambda_grid = __pyx_t_8; @@ -7841,6 +8284,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") * */ + __Pyx_TraceLine(460,0,__PYX_ERR(0, 460, __pyx_L5_except_error)) __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); if (__pyx_t_9) { __Pyx_AddTraceback("l0learn.interface.fit", __pyx_clineno, __pyx_lineno, __pyx_filename); @@ -7856,6 +8300,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * * cdef string c_loss = loss.encode('UTF-8') */ + __Pyx_TraceLine(461,0,__PYX_ERR(0, 461, __pyx_L5_except_error)) __pyx_t_10 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 461, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_11 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_be_a_lis, __pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 461, __pyx_L5_except_error) @@ -7893,6 +8338,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * cdef string c_penalty = penalty.encode('UTF-8') * cdef string c_algorithim = algorithm.encode('UTF-8') */ + __Pyx_TraceLine(463,0,__PYX_ERR(0, 463, __pyx_L1_error)) if (unlikely(__pyx_v_loss == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); __PYX_ERR(0, 463, __pyx_L1_error) @@ -7910,6 +8356,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * cdef string c_algorithim = algorithm.encode('UTF-8') * */ + __Pyx_TraceLine(464,0,__PYX_ERR(0, 464, __pyx_L1_error)) if (unlikely(__pyx_v_penalty == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); __PYX_ERR(0, 464, __pyx_L1_error) @@ -7927,6 +8374,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * * cdef fitmodel c_results */ + __Pyx_TraceLine(465,0,__PYX_ERR(0, 465, __pyx_L1_error)) if (unlikely(__pyx_v_algorithm == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); __PYX_ERR(0, 465, __pyx_L1_error) @@ -7944,6 +8392,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), * y=numpy_to_dvec_d(y), */ + __Pyx_TraceLine(468,0,__PYX_ERR(0, 468, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 468, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 468, __pyx_L1_error) @@ -7961,6 +8410,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * y=numpy_to_dvec_d(y), * Loss=c_loss, */ + __Pyx_TraceLine(469,0,__PYX_ERR(0, 469, __pyx_L1_error)) if (!(likely(((__pyx_v_X) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_X, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 469, __pyx_L1_error) /* "l0learn/interface.pyx":470 @@ -7970,6 +8420,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * Loss=c_loss, * Penalty=c_penalty, */ + __Pyx_TraceLine(470,0,__PYX_ERR(0, 470, __pyx_L1_error)) if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 470, __pyx_L1_error) /* "l0learn/interface.pyx":474 @@ -7979,6 +8430,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * G_ncols=num_lambda, * G_nrows=num_gamma, */ + __Pyx_TraceLine(474,0,__PYX_ERR(0, 474, __pyx_L1_error)) __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 474, __pyx_L1_error) /* "l0learn/interface.pyx":475 @@ -7988,6 +8440,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * G_nrows=num_gamma, * Lambda2Max=gamma_max, */ + __Pyx_TraceLine(475,0,__PYX_ERR(0, 475, __pyx_L1_error)) __pyx_t_16 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_16 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 475, __pyx_L1_error) /* "l0learn/interface.pyx":476 @@ -7997,6 +8450,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, */ + __Pyx_TraceLine(476,0,__PYX_ERR(0, 476, __pyx_L1_error)) __pyx_t_17 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_17 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 476, __pyx_L1_error) /* "l0learn/interface.pyx":479 @@ -8006,6 +8460,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * MaxIters=max_iter, * rtol=rtol, */ + __Pyx_TraceLine(479,0,__PYX_ERR(0, 479, __pyx_L1_error)) __pyx_t_18 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_18 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 479, __pyx_L1_error) /* "l0learn/interface.pyx":480 @@ -8015,6 +8470,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * rtol=rtol, * atol=atol, */ + __Pyx_TraceLine(480,0,__PYX_ERR(0, 480, __pyx_L1_error)) __pyx_t_19 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_19 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 480, __pyx_L1_error) /* "l0learn/interface.pyx":483 @@ -8024,6 +8480,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, */ + __Pyx_TraceLine(483,0,__PYX_ERR(0, 483, __pyx_L1_error)) __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_20 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 483, __pyx_L1_error) /* "l0learn/interface.pyx":484 @@ -8033,6 +8490,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, */ + __Pyx_TraceLine(484,0,__PYX_ERR(0, 484, __pyx_L1_error)) __pyx_t_21 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_21 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 484, __pyx_L1_error) /* "l0learn/interface.pyx":485 @@ -8042,6 +8500,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, */ + __Pyx_TraceLine(485,0,__PYX_ERR(0, 485, __pyx_L1_error)) __pyx_t_22 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_22 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 485, __pyx_L1_error) /* "l0learn/interface.pyx":487 @@ -8051,6 +8510,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, */ + __Pyx_TraceLine(487,0,__PYX_ERR(0, 487, __pyx_L1_error)) __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 487, __pyx_L1_error) /* "l0learn/interface.pyx":488 @@ -8060,6 +8520,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * Lambdas=c_lambda_grid, * ExcludeFirstK=exclude_first_k, */ + __Pyx_TraceLine(488,0,__PYX_ERR(0, 488, __pyx_L1_error)) __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 488, __pyx_L1_error) /* "l0learn/interface.pyx":490 @@ -8069,6 +8530,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * Intercept=intercept, * withBounds=with_bounds, */ + __Pyx_TraceLine(490,0,__PYX_ERR(0, 490, __pyx_L1_error)) __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 490, __pyx_L1_error) /* "l0learn/interface.pyx":491 @@ -8078,6 +8540,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), */ + __Pyx_TraceLine(491,0,__PYX_ERR(0, 491, __pyx_L1_error)) __pyx_t_25 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_25 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 491, __pyx_L1_error) /* "l0learn/interface.pyx":492 @@ -8087,6 +8550,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) */ + __Pyx_TraceLine(492,0,__PYX_ERR(0, 492, __pyx_L1_error)) __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 492, __pyx_L1_error) /* "l0learn/interface.pyx":493 @@ -8096,6 +8560,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * Highs=numpy_to_dvec_d(highs)) * else: # isinstance(X, csc_matrix) */ + __Pyx_TraceLine(493,0,__PYX_ERR(0, 493, __pyx_L1_error)) if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 493, __pyx_L1_error) /* "l0learn/interface.pyx":494 @@ -8105,6 +8570,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * else: # isinstance(X, csc_matrix) * c_results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), */ + __Pyx_TraceLine(494,0,__PYX_ERR(0, 494, __pyx_L1_error)) if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 494, __pyx_L1_error) /* "l0learn/interface.pyx":469 @@ -8114,6 +8580,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * y=numpy_to_dvec_d(y), * Loss=c_loss, */ + __Pyx_TraceLine(469,0,__PYX_ERR(0, 469, __pyx_L1_error)) __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnFit_dense(__pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_X)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_15, __pyx_t_16, __pyx_t_17, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_18, __pyx_t_19, __pyx_v_rtol, __pyx_v_atol, __pyx_t_20, __pyx_t_21, __pyx_t_22, __pyx_v_scale_down_factor, __pyx_t_23, (!__pyx_t_14), __pyx_v_c_lambda_grid, __pyx_t_24, __pyx_t_25, __pyx_t_26, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); /* "l0learn/interface.pyx":468 @@ -8133,6 +8600,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * y=numpy_to_dvec_d(y), * Loss=c_loss, */ + __Pyx_TraceLine(496,0,__PYX_ERR(0, 496, __pyx_L1_error)) /*else*/ { /* "l0learn/interface.pyx":497 @@ -8142,6 +8610,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * Loss=c_loss, * Penalty=c_penalty, */ + __Pyx_TraceLine(497,0,__PYX_ERR(0, 497, __pyx_L1_error)) if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 497, __pyx_L1_error) /* "l0learn/interface.pyx":501 @@ -8151,6 +8620,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * G_ncols=num_lambda, * G_nrows=num_gamma, */ + __Pyx_TraceLine(501,0,__PYX_ERR(0, 501, __pyx_L1_error)) __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 501, __pyx_L1_error) /* "l0learn/interface.pyx":502 @@ -8160,6 +8630,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * G_nrows=num_gamma, * Lambda2Max=gamma_max, */ + __Pyx_TraceLine(502,0,__PYX_ERR(0, 502, __pyx_L1_error)) __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 502, __pyx_L1_error) /* "l0learn/interface.pyx":503 @@ -8169,6 +8640,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, */ + __Pyx_TraceLine(503,0,__PYX_ERR(0, 503, __pyx_L1_error)) __pyx_t_22 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_22 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 503, __pyx_L1_error) /* "l0learn/interface.pyx":506 @@ -8178,6 +8650,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * MaxIters=max_iter, * rtol=rtol, */ + __Pyx_TraceLine(506,0,__PYX_ERR(0, 506, __pyx_L1_error)) __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 506, __pyx_L1_error) /* "l0learn/interface.pyx":507 @@ -8187,6 +8660,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * rtol=rtol, * atol=atol, */ + __Pyx_TraceLine(507,0,__PYX_ERR(0, 507, __pyx_L1_error)) __pyx_t_21 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_21 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 507, __pyx_L1_error) /* "l0learn/interface.pyx":510 @@ -8196,6 +8670,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, */ + __Pyx_TraceLine(510,0,__PYX_ERR(0, 510, __pyx_L1_error)) __pyx_t_25 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_25 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 510, __pyx_L1_error) /* "l0learn/interface.pyx":511 @@ -8205,6 +8680,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, */ + __Pyx_TraceLine(511,0,__PYX_ERR(0, 511, __pyx_L1_error)) __pyx_t_19 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_19 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 511, __pyx_L1_error) /* "l0learn/interface.pyx":512 @@ -8214,6 +8690,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, */ + __Pyx_TraceLine(512,0,__PYX_ERR(0, 512, __pyx_L1_error)) __pyx_t_17 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_17 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 512, __pyx_L1_error) /* "l0learn/interface.pyx":514 @@ -8223,6 +8700,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, */ + __Pyx_TraceLine(514,0,__PYX_ERR(0, 514, __pyx_L1_error)) __pyx_t_16 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_16 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 514, __pyx_L1_error) /* "l0learn/interface.pyx":515 @@ -8232,6 +8710,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * Lambdas=c_lambda_grid, * ExcludeFirstK=exclude_first_k, */ + __Pyx_TraceLine(515,0,__PYX_ERR(0, 515, __pyx_L1_error)) __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 515, __pyx_L1_error) /* "l0learn/interface.pyx":517 @@ -8241,6 +8720,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * Intercept=intercept, * withBounds=with_bounds, */ + __Pyx_TraceLine(517,0,__PYX_ERR(0, 517, __pyx_L1_error)) __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 517, __pyx_L1_error) /* "l0learn/interface.pyx":518 @@ -8250,6 +8730,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), */ + __Pyx_TraceLine(518,0,__PYX_ERR(0, 518, __pyx_L1_error)) __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_20 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 518, __pyx_L1_error) /* "l0learn/interface.pyx":519 @@ -8259,6 +8740,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) */ + __Pyx_TraceLine(519,0,__PYX_ERR(0, 519, __pyx_L1_error)) __pyx_t_18 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_18 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 519, __pyx_L1_error) /* "l0learn/interface.pyx":520 @@ -8268,6 +8750,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * Highs=numpy_to_dvec_d(highs)) * */ + __Pyx_TraceLine(520,0,__PYX_ERR(0, 520, __pyx_L1_error)) if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 520, __pyx_L1_error) /* "l0learn/interface.pyx":521 @@ -8277,6 +8760,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, */ + __Pyx_TraceLine(521,0,__PYX_ERR(0, 521, __pyx_L1_error)) if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 521, __pyx_L1_error) /* "l0learn/interface.pyx":496 @@ -8286,6 +8770,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * y=numpy_to_dvec_d(y), * Loss=c_loss, */ + __Pyx_TraceLine(496,0,__PYX_ERR(0, 496, __pyx_L1_error)) __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnFit_sparse(__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(__pyx_v_X), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_24, __pyx_t_23, __pyx_t_22, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_26, __pyx_t_21, __pyx_v_rtol, __pyx_v_atol, __pyx_t_25, __pyx_t_19, __pyx_t_17, __pyx_v_scale_down_factor, __pyx_t_16, (!__pyx_t_14), __pyx_v_c_lambda_grid, __pyx_t_15, __pyx_t_20, __pyx_t_18, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); } __pyx_L11:; @@ -8297,6 +8782,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, */ + __Pyx_TraceLine(523,0,__PYX_ERR(0, 523, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_FitModel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 523, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 523, __pyx_L1_error) @@ -8316,6 +8802,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * gamma=c_results.Lambda12, * support_size=c_results.NnzCount, */ + __Pyx_TraceLine(524,0,__PYX_ERR(0, 524, __pyx_L1_error)) __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Lambda0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 524, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_lambda_0, __pyx_t_3) < 0) __PYX_ERR(0, 523, __pyx_L1_error) @@ -8328,6 +8815,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * support_size=c_results.NnzCount, * coeffs=sp_dmat_field_to_list(c_results.Beta), */ + __Pyx_TraceLine(525,0,__PYX_ERR(0, 525, __pyx_L1_error)) __pyx_t_3 = __pyx_convert_vector_to_py_double(__pyx_v_c_results.Lambda12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 525, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_gamma, __pyx_t_3) < 0) __PYX_ERR(0, 523, __pyx_L1_error) @@ -8340,6 +8828,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * coeffs=sp_dmat_field_to_list(c_results.Beta), * intercepts=c_results.Intercept, */ + __Pyx_TraceLine(526,0,__PYX_ERR(0, 526, __pyx_L1_error)) __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(__pyx_v_c_results.NnzCount); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 526, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_support_size, __pyx_t_3) < 0) __PYX_ERR(0, 523, __pyx_L1_error) @@ -8352,6 +8841,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * intercepts=c_results.Intercept, * converged=c_results.Converged) */ + __Pyx_TraceLine(527,0,__PYX_ERR(0, 527, __pyx_L1_error)) __pyx_t_3 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_c_results.Beta); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 527, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_coeffs, __pyx_t_3) < 0) __PYX_ERR(0, 523, __pyx_L1_error) @@ -8364,6 +8854,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * converged=c_results.Converged) * return results */ + __Pyx_TraceLine(528,0,__PYX_ERR(0, 528, __pyx_L1_error)) __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Intercept); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 528, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_intercepts, __pyx_t_3) < 0) __PYX_ERR(0, 523, __pyx_L1_error) @@ -8376,6 +8867,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * return results * */ + __Pyx_TraceLine(529,0,__PYX_ERR(0, 529, __pyx_L1_error)) __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(__pyx_v_c_results.Converged); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 529, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_converged, __pyx_t_3) < 0) __PYX_ERR(0, 523, __pyx_L1_error) @@ -8388,6 +8880,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, */ + __Pyx_TraceLine(523,0,__PYX_ERR(0, 523, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 523, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -8402,6 +8895,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx * * */ + __Pyx_TraceLine(530,0,__PYX_ERR(0, 530, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_results); __pyx_r = __pyx_v_results; @@ -8439,6 +8933,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx __Pyx_XDECREF(__pyx_v_lows); __Pyx_XDECREF(__pyx_v_highs); __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -8540,8 +9035,8 @@ static PyObject *__pyx_pw_7l0learn_9interface_7cvfit(PyObject *__pyx_self, PyObj * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.CVFitModel: */ values[23] = ((PyObject *)Py_True); - values[24] = __pyx_k__9; - values[25] = __pyx_k__10; + values[24] = __pyx_k__12; + values[25] = __pyx_k__13; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); @@ -8906,6 +9401,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p cvfitmodel __pyx_v_c_results; PyObject *__pyx_v_results = NULL; PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; @@ -8941,7 +9437,9 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__14) __Pyx_RefNannySetupContext("cvfit", 0); + __Pyx_TraceCall("cvfit", __pyx_f[0], 533, 0, __PYX_ERR(0, 533, __pyx_L1_error)); __Pyx_INCREF(__pyx_v_y); __Pyx_INCREF(__pyx_v_penalty); __Pyx_INCREF(__pyx_v_max_support_size); @@ -8959,6 +9457,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * y=y, * loss=loss, */ + __Pyx_TraceLine(560,0,__PYX_ERR(0, 560, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_fit_check); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 560, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyDict_NewPresized(24); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 560, __pyx_L1_error) @@ -8972,6 +9471,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * loss=loss, * penalty=penalty, */ + __Pyx_TraceLine(561,0,__PYX_ERR(0, 561, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_y, __pyx_v_y) < 0) __PYX_ERR(0, 560, __pyx_L1_error) /* "l0learn/interface.pyx":562 @@ -8981,6 +9481,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * penalty=penalty, * algorithm=algorithm, */ + __Pyx_TraceLine(562,0,__PYX_ERR(0, 562, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 560, __pyx_L1_error) /* "l0learn/interface.pyx":563 @@ -8990,6 +9491,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * algorithm=algorithm, * max_support_size=max_support_size, */ + __Pyx_TraceLine(563,0,__PYX_ERR(0, 563, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 560, __pyx_L1_error) /* "l0learn/interface.pyx":564 @@ -8999,6 +9501,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * max_support_size=max_support_size, * num_lambda=num_lambda, */ + __Pyx_TraceLine(564,0,__PYX_ERR(0, 564, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_algorithm, __pyx_v_algorithm) < 0) __PYX_ERR(0, 560, __pyx_L1_error) /* "l0learn/interface.pyx":565 @@ -9008,6 +9511,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * num_lambda=num_lambda, * num_gamma=num_gamma, */ + __Pyx_TraceLine(565,0,__PYX_ERR(0, 565, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_support_size, __pyx_v_max_support_size) < 0) __PYX_ERR(0, 560, __pyx_L1_error) /* "l0learn/interface.pyx":566 @@ -9017,6 +9521,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * num_gamma=num_gamma, * gamma_max=gamma_max, */ + __Pyx_TraceLine(566,0,__PYX_ERR(0, 566, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_lambda, __pyx_v_num_lambda) < 0) __PYX_ERR(0, 560, __pyx_L1_error) /* "l0learn/interface.pyx":567 @@ -9026,6 +9531,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * gamma_max=gamma_max, * gamma_min=gamma_min, */ + __Pyx_TraceLine(567,0,__PYX_ERR(0, 567, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_gamma, __pyx_v_num_gamma) < 0) __PYX_ERR(0, 560, __pyx_L1_error) /* "l0learn/interface.pyx":568 @@ -9035,6 +9541,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * gamma_min=gamma_min, * partial_sort=partial_sort, */ + __Pyx_TraceLine(568,0,__PYX_ERR(0, 568, __pyx_L1_error)) __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 568, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma_max, __pyx_t_3) < 0) __PYX_ERR(0, 560, __pyx_L1_error) @@ -9047,6 +9554,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * partial_sort=partial_sort, * max_iter=max_iter, */ + __Pyx_TraceLine(569,0,__PYX_ERR(0, 569, __pyx_L1_error)) __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 569, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma_min, __pyx_t_3) < 0) __PYX_ERR(0, 560, __pyx_L1_error) @@ -9059,6 +9567,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * max_iter=max_iter, * rtol=rtol, */ + __Pyx_TraceLine(570,0,__PYX_ERR(0, 570, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_partial_sort, __pyx_v_partial_sort) < 0) __PYX_ERR(0, 560, __pyx_L1_error) /* "l0learn/interface.pyx":571 @@ -9068,6 +9577,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * rtol=rtol, * atol=atol, */ + __Pyx_TraceLine(571,0,__PYX_ERR(0, 571, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_iter, __pyx_v_max_iter) < 0) __PYX_ERR(0, 560, __pyx_L1_error) /* "l0learn/interface.pyx":572 @@ -9077,6 +9587,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * atol=atol, * active_set=active_set, */ + __Pyx_TraceLine(572,0,__PYX_ERR(0, 572, __pyx_L1_error)) __pyx_t_3 = PyFloat_FromDouble(__pyx_v_rtol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 572, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_rtol, __pyx_t_3) < 0) __PYX_ERR(0, 560, __pyx_L1_error) @@ -9089,6 +9600,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * active_set=active_set, * active_set_num=active_set_num, */ + __Pyx_TraceLine(573,0,__PYX_ERR(0, 573, __pyx_L1_error)) __pyx_t_3 = PyFloat_FromDouble(__pyx_v_atol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 573, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_atol, __pyx_t_3) < 0) __PYX_ERR(0, 560, __pyx_L1_error) @@ -9101,6 +9613,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * active_set_num=active_set_num, * max_swaps=max_swaps, */ + __Pyx_TraceLine(574,0,__PYX_ERR(0, 574, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_active_set, __pyx_v_active_set) < 0) __PYX_ERR(0, 560, __pyx_L1_error) /* "l0learn/interface.pyx":575 @@ -9110,6 +9623,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * max_swaps=max_swaps, * scale_down_factor=scale_down_factor, */ + __Pyx_TraceLine(575,0,__PYX_ERR(0, 575, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_active_set_num, __pyx_v_active_set_num) < 0) __PYX_ERR(0, 560, __pyx_L1_error) /* "l0learn/interface.pyx":576 @@ -9119,6 +9633,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * scale_down_factor=scale_down_factor, * screen_size=screen_size, */ + __Pyx_TraceLine(576,0,__PYX_ERR(0, 576, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_swaps, __pyx_v_max_swaps) < 0) __PYX_ERR(0, 560, __pyx_L1_error) /* "l0learn/interface.pyx":577 @@ -9128,6 +9643,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * screen_size=screen_size, * lambda_grid=lambda_grid, */ + __Pyx_TraceLine(577,0,__PYX_ERR(0, 577, __pyx_L1_error)) __pyx_t_3 = PyFloat_FromDouble(__pyx_v_scale_down_factor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 577, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_scale_down_factor, __pyx_t_3) < 0) __PYX_ERR(0, 560, __pyx_L1_error) @@ -9140,6 +9656,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * lambda_grid=lambda_grid, * exclude_first_k=exclude_first_k, */ + __Pyx_TraceLine(578,0,__PYX_ERR(0, 578, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_screen_size, __pyx_v_screen_size) < 0) __PYX_ERR(0, 560, __pyx_L1_error) /* "l0learn/interface.pyx":579 @@ -9149,6 +9666,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * exclude_first_k=exclude_first_k, * intercept=intercept, */ + __Pyx_TraceLine(579,0,__PYX_ERR(0, 579, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lambda_grid, __pyx_v_lambda_grid) < 0) __PYX_ERR(0, 560, __pyx_L1_error) /* "l0learn/interface.pyx":580 @@ -9158,6 +9676,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * intercept=intercept, * lows=lows, */ + __Pyx_TraceLine(580,0,__PYX_ERR(0, 580, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_exclude_first_k, __pyx_v_exclude_first_k) < 0) __PYX_ERR(0, 560, __pyx_L1_error) /* "l0learn/interface.pyx":581 @@ -9167,6 +9686,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * lows=lows, * highs=highs) */ + __Pyx_TraceLine(581,0,__PYX_ERR(0, 581, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 560, __pyx_L1_error) /* "l0learn/interface.pyx":582 @@ -9176,6 +9696,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * highs=highs) * */ + __Pyx_TraceLine(582,0,__PYX_ERR(0, 582, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lows, __pyx_v_lows) < 0) __PYX_ERR(0, 560, __pyx_L1_error) /* "l0learn/interface.pyx":583 @@ -9185,6 +9706,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * * max_support_size = check["max_support_size"] */ + __Pyx_TraceLine(583,0,__PYX_ERR(0, 583, __pyx_L1_error)) if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_highs, __pyx_v_highs) < 0) __PYX_ERR(0, 560, __pyx_L1_error) /* "l0learn/interface.pyx":560 @@ -9194,6 +9716,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * y=y, * loss=loss, */ + __Pyx_TraceLine(560,0,__PYX_ERR(0, 560, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 560, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -9208,6 +9731,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * screen_size = check["screen_size"] * y = check['y'] */ + __Pyx_TraceLine(585,0,__PYX_ERR(0, 585, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_max_support_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 585, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_max_support_size, __pyx_t_3); @@ -9220,6 +9744,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * y = check['y'] * penalty = check['penalty'] */ + __Pyx_TraceLine(586,0,__PYX_ERR(0, 586, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_screen_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 586, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_screen_size, __pyx_t_3); @@ -9232,6 +9757,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * penalty = check['penalty'] * gamma_max = check['gamma_max'] */ + __Pyx_TraceLine(587,0,__PYX_ERR(0, 587, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_y); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 587, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_y, __pyx_t_3); @@ -9244,6 +9770,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * gamma_max = check['gamma_max'] * gamma_min = check['gamma_min'] */ + __Pyx_TraceLine(588,0,__PYX_ERR(0, 588, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_penalty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 588, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (!(likely(PyUnicode_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(0, 588, __pyx_L1_error) @@ -9257,6 +9784,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * gamma_min = check['gamma_min'] * lambda_grid = check['lambda_grid'] */ + __Pyx_TraceLine(589,0,__PYX_ERR(0, 589, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 589, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 589, __pyx_L1_error) @@ -9270,6 +9798,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * lambda_grid = check['lambda_grid'] * num_gamma = check['num_gamma'] */ + __Pyx_TraceLine(590,0,__PYX_ERR(0, 590, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_gamma_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 590, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 590, __pyx_L1_error) @@ -9283,6 +9812,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * num_gamma = check['num_gamma'] * num_lambda = check['num_lambda'] */ + __Pyx_TraceLine(591,0,__PYX_ERR(0, 591, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_lambda_grid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 591, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_lambda_grid, __pyx_t_3); @@ -9295,6 +9825,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * num_lambda = check['num_lambda'] * auto_lambda = check['auto_lambda'] */ + __Pyx_TraceLine(592,0,__PYX_ERR(0, 592, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_num_gamma); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 592, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_num_gamma, __pyx_t_3); @@ -9307,6 +9838,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * auto_lambda = check['auto_lambda'] * with_bounds = check['with_bounds'] */ + __Pyx_TraceLine(593,0,__PYX_ERR(0, 593, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_num_lambda); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 593, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_num_lambda, __pyx_t_3); @@ -9319,6 +9851,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * with_bounds = check['with_bounds'] * lows = check['lows'] */ + __Pyx_TraceLine(594,0,__PYX_ERR(0, 594, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_auto_lambda); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 594, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_auto_lambda = __pyx_t_3; @@ -9331,6 +9864,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * lows = check['lows'] * highs = check['highs'] */ + __Pyx_TraceLine(595,0,__PYX_ERR(0, 595, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_with_bounds); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 595, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_with_bounds = __pyx_t_3; @@ -9343,6 +9877,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * highs = check['highs'] * */ + __Pyx_TraceLine(596,0,__PYX_ERR(0, 596, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_lows); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 596, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_3); @@ -9355,6 +9890,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * * _, p = X.shape */ + __Pyx_TraceLine(597,0,__PYX_ERR(0, 597, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_highs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 597, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_3); @@ -9367,6 +9903,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * * if not isinstance(num_folds, int) or num_folds < 2 or num_folds > p: */ + __Pyx_TraceLine(599,0,__PYX_ERR(0, 599, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 599, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { @@ -9427,6 +9964,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * raise ValueError(f"expected num_folds parameter to be a positive integer less than {p}, but got {num_folds}") * */ + __Pyx_TraceLine(601,0,__PYX_ERR(0, 601, __pyx_L1_error)) __pyx_t_8 = PyInt_Check(__pyx_v_num_folds); __pyx_t_9 = ((!(__pyx_t_8 != 0)) != 0); if (!__pyx_t_9) { @@ -9456,6 +9994,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * * */ + __Pyx_TraceLine(602,0,__PYX_ERR(0, 602, __pyx_L1_error)) __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 602, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_10 = 0; @@ -9508,6 +10047,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * c_lambda_grid = lambda_grid * except TypeError: */ + __Pyx_TraceLine(606,0,__PYX_ERR(0, 606, __pyx_L1_error)) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign @@ -9524,6 +10064,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * except TypeError: * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") */ + __Pyx_TraceLine(607,0,__PYX_ERR(0, 607, __pyx_L9_error)) __pyx_t_15 = __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_lambda_grid); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 607, __pyx_L9_error) __pyx_v_c_lambda_grid = __pyx_t_15; @@ -9552,6 +10093,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") * */ + __Pyx_TraceLine(608,0,__PYX_ERR(0, 608, __pyx_L11_except_error)) __pyx_t_16 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); if (__pyx_t_16) { __Pyx_AddTraceback("l0learn.interface.cvfit", __pyx_clineno, __pyx_lineno, __pyx_filename); @@ -9567,6 +10109,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * * cdef string c_loss = loss.encode('UTF-8') */ + __Pyx_TraceLine(609,0,__PYX_ERR(0, 609, __pyx_L11_except_error)) __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 609, __pyx_L11_except_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_17 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_be_a_lis, __pyx_t_5); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 609, __pyx_L11_except_error) @@ -9604,6 +10147,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * cdef string c_penalty = penalty.encode('UTF-8') * cdef string c_algorithim = algorithm.encode('UTF-8') */ + __Pyx_TraceLine(611,0,__PYX_ERR(0, 611, __pyx_L1_error)) if (unlikely(__pyx_v_loss == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); __PYX_ERR(0, 611, __pyx_L1_error) @@ -9621,6 +10165,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * cdef string c_algorithim = algorithm.encode('UTF-8') * */ + __Pyx_TraceLine(612,0,__PYX_ERR(0, 612, __pyx_L1_error)) if (unlikely(__pyx_v_penalty == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); __PYX_ERR(0, 612, __pyx_L1_error) @@ -9638,6 +10183,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * * cdef cvfitmodel c_results */ + __Pyx_TraceLine(613,0,__PYX_ERR(0, 613, __pyx_L1_error)) if (unlikely(__pyx_v_algorithm == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); __PYX_ERR(0, 613, __pyx_L1_error) @@ -9655,6 +10201,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), * y=numpy_to_dvec_d(y), */ + __Pyx_TraceLine(616,0,__PYX_ERR(0, 616, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 616, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 616, __pyx_L1_error) @@ -9672,6 +10219,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * y=numpy_to_dvec_d(y), * Loss=c_loss, */ + __Pyx_TraceLine(617,0,__PYX_ERR(0, 617, __pyx_L1_error)) if (!(likely(((__pyx_v_X) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_X, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 617, __pyx_L1_error) /* "l0learn/interface.pyx":618 @@ -9681,6 +10229,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * Loss=c_loss, * Penalty=c_penalty, */ + __Pyx_TraceLine(618,0,__PYX_ERR(0, 618, __pyx_L1_error)) if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 618, __pyx_L1_error) /* "l0learn/interface.pyx":622 @@ -9690,6 +10239,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * G_ncols=num_lambda, * G_nrows=num_gamma, */ + __Pyx_TraceLine(622,0,__PYX_ERR(0, 622, __pyx_L1_error)) __pyx_t_19 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_19 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 622, __pyx_L1_error) /* "l0learn/interface.pyx":623 @@ -9699,6 +10249,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * G_nrows=num_gamma, * Lambda2Max=gamma_max, */ + __Pyx_TraceLine(623,0,__PYX_ERR(0, 623, __pyx_L1_error)) __pyx_t_20 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_20 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 623, __pyx_L1_error) /* "l0learn/interface.pyx":624 @@ -9708,6 +10259,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, */ + __Pyx_TraceLine(624,0,__PYX_ERR(0, 624, __pyx_L1_error)) __pyx_t_21 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_21 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 624, __pyx_L1_error) /* "l0learn/interface.pyx":627 @@ -9717,6 +10269,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * MaxIters=max_iter, * rtol=rtol, */ + __Pyx_TraceLine(627,0,__PYX_ERR(0, 627, __pyx_L1_error)) __pyx_t_22 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_22 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 627, __pyx_L1_error) /* "l0learn/interface.pyx":628 @@ -9726,6 +10279,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * rtol=rtol, * atol=atol, */ + __Pyx_TraceLine(628,0,__PYX_ERR(0, 628, __pyx_L1_error)) __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 628, __pyx_L1_error) /* "l0learn/interface.pyx":631 @@ -9735,6 +10289,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, */ + __Pyx_TraceLine(631,0,__PYX_ERR(0, 631, __pyx_L1_error)) __pyx_t_24 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_24 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 631, __pyx_L1_error) /* "l0learn/interface.pyx":632 @@ -9744,6 +10299,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, */ + __Pyx_TraceLine(632,0,__PYX_ERR(0, 632, __pyx_L1_error)) __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 632, __pyx_L1_error) /* "l0learn/interface.pyx":633 @@ -9753,6 +10309,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, */ + __Pyx_TraceLine(633,0,__PYX_ERR(0, 633, __pyx_L1_error)) __pyx_t_26 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_26 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 633, __pyx_L1_error) /* "l0learn/interface.pyx":635 @@ -9762,6 +10319,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, */ + __Pyx_TraceLine(635,0,__PYX_ERR(0, 635, __pyx_L1_error)) __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 635, __pyx_L1_error) /* "l0learn/interface.pyx":636 @@ -9771,6 +10329,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * Lambdas=c_lambda_grid, * nfolds=num_folds, */ + __Pyx_TraceLine(636,0,__PYX_ERR(0, 636, __pyx_L1_error)) __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 636, __pyx_L1_error) /* "l0learn/interface.pyx":638 @@ -9780,6 +10339,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * seed=seed, * ExcludeFirstK=exclude_first_k, */ + __Pyx_TraceLine(638,0,__PYX_ERR(0, 638, __pyx_L1_error)) __pyx_t_28 = __Pyx_PyInt_As_unsigned_int(__pyx_v_num_folds); if (unlikely((__pyx_t_28 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 638, __pyx_L1_error) /* "l0learn/interface.pyx":639 @@ -9789,6 +10349,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * ExcludeFirstK=exclude_first_k, * Intercept=intercept, */ + __Pyx_TraceLine(639,0,__PYX_ERR(0, 639, __pyx_L1_error)) __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_seed); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 639, __pyx_L1_error) /* "l0learn/interface.pyx":640 @@ -9798,6 +10359,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * Intercept=intercept, * withBounds=with_bounds, */ + __Pyx_TraceLine(640,0,__PYX_ERR(0, 640, __pyx_L1_error)) __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 640, __pyx_L1_error) /* "l0learn/interface.pyx":641 @@ -9807,6 +10369,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), */ + __Pyx_TraceLine(641,0,__PYX_ERR(0, 641, __pyx_L1_error)) __pyx_t_30 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_30 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 641, __pyx_L1_error) /* "l0learn/interface.pyx":642 @@ -9816,6 +10379,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) */ + __Pyx_TraceLine(642,0,__PYX_ERR(0, 642, __pyx_L1_error)) __pyx_t_31 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_31 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 642, __pyx_L1_error) /* "l0learn/interface.pyx":643 @@ -9825,6 +10389,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * Highs=numpy_to_dvec_d(highs)) * else: # isinstance(X, csc_matrix) */ + __Pyx_TraceLine(643,0,__PYX_ERR(0, 643, __pyx_L1_error)) if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 643, __pyx_L1_error) /* "l0learn/interface.pyx":644 @@ -9834,6 +10399,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * else: # isinstance(X, csc_matrix) * c_results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), */ + __Pyx_TraceLine(644,0,__PYX_ERR(0, 644, __pyx_L1_error)) if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 644, __pyx_L1_error) /* "l0learn/interface.pyx":617 @@ -9843,6 +10409,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * y=numpy_to_dvec_d(y), * Loss=c_loss, */ + __Pyx_TraceLine(617,0,__PYX_ERR(0, 617, __pyx_L1_error)) __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnCV_dense(__pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_X)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_19, __pyx_t_20, __pyx_t_21, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_22, __pyx_t_23, __pyx_v_rtol, __pyx_v_atol, __pyx_t_24, __pyx_t_25, __pyx_t_26, __pyx_v_scale_down_factor, __pyx_t_27, (!__pyx_t_9), __pyx_v_c_lambda_grid, __pyx_t_28, __pyx_t_4, __pyx_t_29, __pyx_t_30, __pyx_t_31, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); /* "l0learn/interface.pyx":616 @@ -9862,6 +10429,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * y=numpy_to_dvec_d(y), * Loss=c_loss, */ + __Pyx_TraceLine(646,0,__PYX_ERR(0, 646, __pyx_L1_error)) /*else*/ { /* "l0learn/interface.pyx":647 @@ -9871,6 +10439,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * Loss=c_loss, * Penalty=c_penalty, */ + __Pyx_TraceLine(647,0,__PYX_ERR(0, 647, __pyx_L1_error)) if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 647, __pyx_L1_error) /* "l0learn/interface.pyx":651 @@ -9880,6 +10449,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * G_ncols=num_lambda, * G_nrows=num_gamma, */ + __Pyx_TraceLine(651,0,__PYX_ERR(0, 651, __pyx_L1_error)) __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 651, __pyx_L1_error) /* "l0learn/interface.pyx":652 @@ -9889,6 +10459,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * G_nrows=num_gamma, * Lambda2Max=gamma_max, */ + __Pyx_TraceLine(652,0,__PYX_ERR(0, 652, __pyx_L1_error)) __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 652, __pyx_L1_error) /* "l0learn/interface.pyx":653 @@ -9898,6 +10469,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, */ + __Pyx_TraceLine(653,0,__PYX_ERR(0, 653, __pyx_L1_error)) __pyx_t_26 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_26 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 653, __pyx_L1_error) /* "l0learn/interface.pyx":656 @@ -9907,6 +10479,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * MaxIters=max_iter, * rtol=rtol, */ + __Pyx_TraceLine(656,0,__PYX_ERR(0, 656, __pyx_L1_error)) __pyx_t_31 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_31 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 656, __pyx_L1_error) /* "l0learn/interface.pyx":657 @@ -9916,6 +10489,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * rtol=rtol, * atol=atol, */ + __Pyx_TraceLine(657,0,__PYX_ERR(0, 657, __pyx_L1_error)) __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 657, __pyx_L1_error) /* "l0learn/interface.pyx":660 @@ -9925,6 +10499,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, */ + __Pyx_TraceLine(660,0,__PYX_ERR(0, 660, __pyx_L1_error)) __pyx_t_30 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_30 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 660, __pyx_L1_error) /* "l0learn/interface.pyx":661 @@ -9934,6 +10509,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, */ + __Pyx_TraceLine(661,0,__PYX_ERR(0, 661, __pyx_L1_error)) __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 661, __pyx_L1_error) /* "l0learn/interface.pyx":662 @@ -9943,6 +10519,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, */ + __Pyx_TraceLine(662,0,__PYX_ERR(0, 662, __pyx_L1_error)) __pyx_t_21 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_21 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 662, __pyx_L1_error) /* "l0learn/interface.pyx":664 @@ -9952,6 +10529,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, */ + __Pyx_TraceLine(664,0,__PYX_ERR(0, 664, __pyx_L1_error)) __pyx_t_20 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_20 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 664, __pyx_L1_error) /* "l0learn/interface.pyx":665 @@ -9961,6 +10539,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * Lambdas=c_lambda_grid, * nfolds=num_folds, */ + __Pyx_TraceLine(665,0,__PYX_ERR(0, 665, __pyx_L1_error)) __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 665, __pyx_L1_error) /* "l0learn/interface.pyx":667 @@ -9970,6 +10549,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * seed=seed, * ExcludeFirstK=exclude_first_k, */ + __Pyx_TraceLine(667,0,__PYX_ERR(0, 667, __pyx_L1_error)) __pyx_t_28 = __Pyx_PyInt_As_unsigned_int(__pyx_v_num_folds); if (unlikely((__pyx_t_28 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 667, __pyx_L1_error) /* "l0learn/interface.pyx":668 @@ -9979,6 +10559,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * ExcludeFirstK=exclude_first_k, * Intercept=intercept, */ + __Pyx_TraceLine(668,0,__PYX_ERR(0, 668, __pyx_L1_error)) __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_seed); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 668, __pyx_L1_error) /* "l0learn/interface.pyx":669 @@ -9988,6 +10569,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * Intercept=intercept, * withBounds=with_bounds, */ + __Pyx_TraceLine(669,0,__PYX_ERR(0, 669, __pyx_L1_error)) __pyx_t_19 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_19 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 669, __pyx_L1_error) /* "l0learn/interface.pyx":670 @@ -9997,6 +10579,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), */ + __Pyx_TraceLine(670,0,__PYX_ERR(0, 670, __pyx_L1_error)) __pyx_t_24 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_24 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 670, __pyx_L1_error) /* "l0learn/interface.pyx":671 @@ -10006,6 +10589,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) */ + __Pyx_TraceLine(671,0,__PYX_ERR(0, 671, __pyx_L1_error)) __pyx_t_22 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_22 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 671, __pyx_L1_error) /* "l0learn/interface.pyx":672 @@ -10015,6 +10599,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * Highs=numpy_to_dvec_d(highs)) * */ + __Pyx_TraceLine(672,0,__PYX_ERR(0, 672, __pyx_L1_error)) if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 672, __pyx_L1_error) /* "l0learn/interface.pyx":673 @@ -10024,6 +10609,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, */ + __Pyx_TraceLine(673,0,__PYX_ERR(0, 673, __pyx_L1_error)) if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 673, __pyx_L1_error) /* "l0learn/interface.pyx":646 @@ -10033,6 +10619,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * y=numpy_to_dvec_d(y), * Loss=c_loss, */ + __Pyx_TraceLine(646,0,__PYX_ERR(0, 646, __pyx_L1_error)) __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnCV_sparse(__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(__pyx_v_X), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_29, __pyx_t_27, __pyx_t_26, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_31, __pyx_t_25, __pyx_v_rtol, __pyx_v_atol, __pyx_t_30, __pyx_t_23, __pyx_t_21, __pyx_v_scale_down_factor, __pyx_t_20, (!__pyx_t_9), __pyx_v_c_lambda_grid, __pyx_t_28, __pyx_t_4, __pyx_t_19, __pyx_t_24, __pyx_t_22, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); } __pyx_L17:; @@ -10044,6 +10631,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, */ + __Pyx_TraceLine(675,0,__PYX_ERR(0, 675, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_CVFitModel); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 675, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyDict_NewPresized(9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 675, __pyx_L1_error) @@ -10063,6 +10651,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * gamma=c_results.Lambda12, * support_size=c_results.NnzCount, */ + __Pyx_TraceLine(676,0,__PYX_ERR(0, 676, __pyx_L1_error)) __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Lambda0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 676, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lambda_0, __pyx_t_3) < 0) __PYX_ERR(0, 675, __pyx_L1_error) @@ -10075,6 +10664,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * support_size=c_results.NnzCount, * coeffs=sp_dmat_field_to_list(c_results.Beta), */ + __Pyx_TraceLine(677,0,__PYX_ERR(0, 677, __pyx_L1_error)) __pyx_t_3 = __pyx_convert_vector_to_py_double(__pyx_v_c_results.Lambda12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 677, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma, __pyx_t_3) < 0) __PYX_ERR(0, 675, __pyx_L1_error) @@ -10087,6 +10677,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * coeffs=sp_dmat_field_to_list(c_results.Beta), * intercepts=c_results.Intercept, */ + __Pyx_TraceLine(678,0,__PYX_ERR(0, 678, __pyx_L1_error)) __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(__pyx_v_c_results.NnzCount); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 678, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_support_size, __pyx_t_3) < 0) __PYX_ERR(0, 675, __pyx_L1_error) @@ -10099,6 +10690,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * intercepts=c_results.Intercept, * converged=c_results.Converged, */ + __Pyx_TraceLine(679,0,__PYX_ERR(0, 679, __pyx_L1_error)) __pyx_t_3 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_c_results.Beta); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 679, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_coeffs, __pyx_t_3) < 0) __PYX_ERR(0, 675, __pyx_L1_error) @@ -10111,6 +10703,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * converged=c_results.Converged, * cv_means=dvec_field_to_list(c_results.CVMeans), */ + __Pyx_TraceLine(680,0,__PYX_ERR(0, 680, __pyx_L1_error)) __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Intercept); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 680, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_intercepts, __pyx_t_3) < 0) __PYX_ERR(0, 675, __pyx_L1_error) @@ -10123,6 +10716,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * cv_means=dvec_field_to_list(c_results.CVMeans), * cv_sds=dvec_field_to_list(c_results.CVSDs)) */ + __Pyx_TraceLine(681,0,__PYX_ERR(0, 681, __pyx_L1_error)) __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(__pyx_v_c_results.Converged); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 681, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_converged, __pyx_t_3) < 0) __PYX_ERR(0, 675, __pyx_L1_error) @@ -10135,6 +10729,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * cv_sds=dvec_field_to_list(c_results.CVSDs)) * return results */ + __Pyx_TraceLine(682,0,__PYX_ERR(0, 682, __pyx_L1_error)) __pyx_t_3 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_c_results.CVMeans); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 682, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_cv_means, __pyx_t_3) < 0) __PYX_ERR(0, 675, __pyx_L1_error) @@ -10147,6 +10742,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * return results * */ + __Pyx_TraceLine(683,0,__PYX_ERR(0, 683, __pyx_L1_error)) __pyx_t_3 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_c_results.CVSDs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 683, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_cv_sds, __pyx_t_3) < 0) __PYX_ERR(0, 675, __pyx_L1_error) @@ -10159,6 +10755,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, */ + __Pyx_TraceLine(675,0,__PYX_ERR(0, 675, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 675, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -10173,6 +10770,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p * * */ + __Pyx_TraceLine(684,0,__PYX_ERR(0, 684, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_results); __pyx_r = __pyx_v_results; @@ -10212,6 +10810,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p __Pyx_XDECREF(__pyx_v_lows); __Pyx_XDECREF(__pyx_v_highs); __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -10226,8 +10825,13 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_dense(arma::dmat const &__pyx_v_X, arma::dvec const &__pyx_v_y, std::string const __pyx_v_Loss, std::string const __pyx_v_Penalty, std::string const __pyx_v_Algorithm, size_t const __pyx_v_NnzStopNum, size_t const __pyx_v_G_ncols, size_t const __pyx_v_G_nrows, double const __pyx_v_Lambda2Max, double const __pyx_v_Lambda2Min, bool const __pyx_v_PartialSort, size_t const __pyx_v_MaxIters, double const __pyx_v_rtol, double const __pyx_v_atol, bool const __pyx_v_ActiveSet, size_t const __pyx_v_ActiveSetNum, size_t const __pyx_v_MaxNumSwaps, double const __pyx_v_ScaleDownFactor, size_t const __pyx_v_ScreenSize, bool const __pyx_v_LambdaU, std::vector > const &__pyx_v_Lambdas, size_t const __pyx_v_ExcludeFirstK, bool const __pyx_v_Intercept, bool const __pyx_v_withBounds, arma::dvec const &__pyx_v_Lows, arma::dvec const &__pyx_v_Highs) { fitmodel __pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_L0LearnFit_dense", 0); + __Pyx_TraceCall("_L0LearnFit_dense", __pyx_f[0], 687, 0, __PYX_ERR(0, 687, __pyx_L1_error)); /* "l0learn/interface.pyx":713 * const dvec &Lows, @@ -10236,6 +10840,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_dense(arma::dmat const & * MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, * Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs) */ + __Pyx_TraceLine(713,0,__PYX_ERR(0, 713, __pyx_L1_error)) __pyx_r = L0LearnFit(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); goto __pyx_L0; @@ -10248,7 +10853,11 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_dense(arma::dmat const & */ /* function exit code */ + __pyx_L1_error:; + __Pyx_WriteUnraisable("l0learn.interface._L0LearnFit_dense", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __Pyx_pretend_to_initialize(&__pyx_r); __pyx_L0:; + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -10263,8 +10872,13 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_dense(arma::dmat const & static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_sparse(arma::sp_dmat const &__pyx_v_X, arma::dvec const &__pyx_v_y, std::string const __pyx_v_Loss, std::string const __pyx_v_Penalty, std::string const __pyx_v_Algorithm, size_t const __pyx_v_NnzStopNum, size_t const __pyx_v_G_ncols, size_t const __pyx_v_G_nrows, double const __pyx_v_Lambda2Max, double const __pyx_v_Lambda2Min, bool const __pyx_v_PartialSort, size_t const __pyx_v_MaxIters, double const __pyx_v_rtol, double const __pyx_v_atol, bool const __pyx_v_ActiveSet, size_t const __pyx_v_ActiveSetNum, size_t const __pyx_v_MaxNumSwaps, double const __pyx_v_ScaleDownFactor, size_t const __pyx_v_ScreenSize, bool const __pyx_v_LambdaU, std::vector > const &__pyx_v_Lambdas, size_t const __pyx_v_ExcludeFirstK, bool const __pyx_v_Intercept, bool const __pyx_v_withBounds, arma::dvec const &__pyx_v_Lows, arma::dvec const &__pyx_v_Highs) { fitmodel __pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_L0LearnFit_sparse", 0); + __Pyx_TraceCall("_L0LearnFit_sparse", __pyx_f[0], 718, 0, __PYX_ERR(0, 718, __pyx_L1_error)); /* "l0learn/interface.pyx":744 * const dvec &Lows, @@ -10273,6 +10887,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_sparse(arma::sp_dmat con * MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, * Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs) */ + __Pyx_TraceLine(744,0,__PYX_ERR(0, 744, __pyx_L1_error)) __pyx_r = L0LearnFit(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); goto __pyx_L0; @@ -10285,7 +10900,11 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_sparse(arma::sp_dmat con */ /* function exit code */ + __pyx_L1_error:; + __Pyx_WriteUnraisable("l0learn.interface._L0LearnFit_sparse", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __Pyx_pretend_to_initialize(&__pyx_r); __pyx_L0:; + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -10300,8 +10919,13 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_sparse(arma::sp_dmat con static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_dense(arma::dmat const &__pyx_v_X, arma::dvec const &__pyx_v_y, std::string const __pyx_v_Loss, std::string const __pyx_v_Penalty, std::string const __pyx_v_Algorithm, size_t const __pyx_v_NnzStopNum, size_t const __pyx_v_G_ncols, size_t const __pyx_v_G_nrows, double const __pyx_v_Lambda2Max, double const __pyx_v_Lambda2Min, bool const __pyx_v_PartialSort, size_t const __pyx_v_MaxIters, double const __pyx_v_rtol, double const __pyx_v_atol, bool const __pyx_v_ActiveSet, size_t const __pyx_v_ActiveSetNum, size_t const __pyx_v_MaxNumSwaps, double const __pyx_v_ScaleDownFactor, size_t const __pyx_v_ScreenSize, bool const __pyx_v_LambdaU, std::vector > const &__pyx_v_Lambdas, unsigned int const __pyx_v_nfolds, double const __pyx_v_seed, size_t const __pyx_v_ExcludeFirstK, bool const __pyx_v_Intercept, bool const __pyx_v_withBounds, arma::dvec const &__pyx_v_Lows, arma::dvec const &__pyx_v_Highs) { cvfitmodel __pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_L0LearnCV_dense", 0); + __Pyx_TraceCall("_L0LearnCV_dense", __pyx_f[0], 749, 0, __PYX_ERR(0, 749, __pyx_L1_error)); /* "l0learn/interface.pyx":777 * const dvec &Lows, @@ -10310,6 +10934,7 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_dense(arma::dmat const * MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, * Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs) */ + __Pyx_TraceLine(777,0,__PYX_ERR(0, 777, __pyx_L1_error)) __pyx_r = L0LearnCV(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_nfolds, __pyx_v_seed, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); goto __pyx_L0; @@ -10322,7 +10947,11 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_dense(arma::dmat const */ /* function exit code */ + __pyx_L1_error:; + __Pyx_WriteUnraisable("l0learn.interface._L0LearnCV_dense", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __Pyx_pretend_to_initialize(&__pyx_r); __pyx_L0:; + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -10337,8 +10966,13 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_dense(arma::dmat const static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_sparse(arma::sp_dmat const &__pyx_v_X, arma::dvec const &__pyx_v_y, std::string const __pyx_v_Loss, std::string const __pyx_v_Penalty, std::string const __pyx_v_Algorithm, size_t const __pyx_v_NnzStopNum, size_t const __pyx_v_G_ncols, size_t const __pyx_v_G_nrows, double const __pyx_v_Lambda2Max, double const __pyx_v_Lambda2Min, bool const __pyx_v_PartialSort, size_t const __pyx_v_MaxIters, double const __pyx_v_rtol, double const __pyx_v_atol, bool const __pyx_v_ActiveSet, size_t const __pyx_v_ActiveSetNum, size_t const __pyx_v_MaxNumSwaps, double const __pyx_v_ScaleDownFactor, size_t const __pyx_v_ScreenSize, bool const __pyx_v_LambdaU, std::vector > const &__pyx_v_Lambdas, unsigned int const __pyx_v_nfolds, double const __pyx_v_seed, size_t const __pyx_v_ExcludeFirstK, bool const __pyx_v_Intercept, bool const __pyx_v_withBounds, arma::dvec const &__pyx_v_Lows, arma::dvec const &__pyx_v_Highs) { cvfitmodel __pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_L0LearnCV_sparse", 0); + __Pyx_TraceCall("_L0LearnCV_sparse", __pyx_f[0], 782, 0, __PYX_ERR(0, 782, __pyx_L1_error)); /* "l0learn/interface.pyx":810 * const dvec &Lows, @@ -10347,6 +10981,7 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_sparse(arma::sp_dmat co * MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, * Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs) */ + __Pyx_TraceLine(810,0,__PYX_ERR(0, 810, __pyx_L1_error)) __pyx_r = L0LearnCV(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_nfolds, __pyx_v_seed, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); goto __pyx_L0; @@ -10359,7 +10994,11 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_sparse(arma::sp_dmat co */ /* function exit code */ + __pyx_L1_error:; + __Pyx_WriteUnraisable("l0learn.interface._L0LearnCV_sparse", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __Pyx_pretend_to_initialize(&__pyx_r); __pyx_L0:; + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -10374,12 +11013,14 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_sparse(arma::sp_dmat co static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); + __Pyx_TraceCall("PyArray_MultiIterNew1", __pyx_f[1], 735, 0, __PYX_ERR(1, 735, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":736 * @@ -10388,6 +11029,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ * * cdef inline object PyArray_MultiIterNew2(a, b): */ + __Pyx_TraceLine(736,0,__PYX_ERR(1, 736, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 736, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -10410,6 +11052,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -10424,12 +11067,14 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); + __Pyx_TraceCall("PyArray_MultiIterNew2", __pyx_f[1], 738, 0, __PYX_ERR(1, 738, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":739 * @@ -10438,6 +11083,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ * * cdef inline object PyArray_MultiIterNew3(a, b, c): */ + __Pyx_TraceLine(739,0,__PYX_ERR(1, 739, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 739, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -10460,6 +11106,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -10474,12 +11121,14 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); + __Pyx_TraceCall("PyArray_MultiIterNew3", __pyx_f[1], 741, 0, __PYX_ERR(1, 741, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":742 * @@ -10488,6 +11137,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): */ + __Pyx_TraceLine(742,0,__PYX_ERR(1, 742, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 742, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -10510,6 +11160,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -10524,12 +11175,14 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); + __Pyx_TraceCall("PyArray_MultiIterNew4", __pyx_f[1], 744, 0, __PYX_ERR(1, 744, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":745 * @@ -10538,6 +11191,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): */ + __Pyx_TraceLine(745,0,__PYX_ERR(1, 745, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 745, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -10560,6 +11214,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -10574,12 +11229,14 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); + __Pyx_TraceCall("PyArray_MultiIterNew5", __pyx_f[1], 747, 0, __PYX_ERR(1, 747, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":748 * @@ -10588,6 +11245,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ * * cdef inline tuple PyDataType_SHAPE(dtype d): */ + __Pyx_TraceLine(748,0,__PYX_ERR(1, 748, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 748, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -10610,6 +11268,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -10624,9 +11283,14 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); + __Pyx_TraceCall("PyDataType_SHAPE", __pyx_f[1], 750, 0, __PYX_ERR(1, 750, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":751 * @@ -10635,6 +11299,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ * return d.subarray.shape * else: */ + __Pyx_TraceLine(751,0,__PYX_ERR(1, 751, __pyx_L1_error)) __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); if (__pyx_t_1) { @@ -10645,6 +11310,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ * else: * return () */ + __Pyx_TraceLine(752,0,__PYX_ERR(1, 752, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); @@ -10666,6 +11332,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ * * */ + __Pyx_TraceLine(754,0,__PYX_ERR(1, 754, __pyx_L1_error)) /*else*/ { __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_empty_tuple); @@ -10682,8 +11349,12 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ */ /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("numpy.PyDataType_SHAPE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -10697,8 +11368,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ */ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("set_array_base", 0); + __Pyx_TraceCall("set_array_base", __pyx_f[1], 929, 0, __PYX_ERR(1, 929, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":930 * @@ -10707,6 +11383,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a * PyArray_SetBaseObject(arr, base) * */ + __Pyx_TraceLine(930,0,__PYX_ERR(1, 930, __pyx_L1_error)) Py_INCREF(__pyx_v_base); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":931 @@ -10716,6 +11393,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a * * cdef inline object get_array_base(ndarray arr): */ + __Pyx_TraceLine(931,0,__PYX_ERR(1, 931, __pyx_L1_error)) (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":929 @@ -10727,6 +11405,11 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a */ /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_WriteUnraisable("numpy.set_array_base", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_L0:; + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); } @@ -10741,9 +11424,14 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { PyObject *__pyx_v_base; PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_array_base", 0); + __Pyx_TraceCall("get_array_base", __pyx_f[1], 933, 0, __PYX_ERR(1, 933, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":934 * @@ -10752,6 +11440,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py * if base is NULL: * return None */ + __Pyx_TraceLine(934,0,__PYX_ERR(1, 934, __pyx_L1_error)) __pyx_v_base = PyArray_BASE(__pyx_v_arr); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":935 @@ -10761,6 +11450,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py * return None * return base */ + __Pyx_TraceLine(935,0,__PYX_ERR(1, 935, __pyx_L1_error)) __pyx_t_1 = ((__pyx_v_base == NULL) != 0); if (__pyx_t_1) { @@ -10771,6 +11461,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py * return base * */ + __Pyx_TraceLine(936,0,__PYX_ERR(1, 936, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; @@ -10791,6 +11482,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py * * # Versions of the import_* functions which are more suitable for */ + __Pyx_TraceLine(937,0,__PYX_ERR(1, 937, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_base)); __pyx_r = ((PyObject *)__pyx_v_base); @@ -10805,8 +11497,12 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py */ /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("numpy.get_array_base", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -10821,6 +11517,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { int __pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; @@ -10834,6 +11531,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_array", 0); + __Pyx_TraceCall("import_array", __pyx_f[1], 941, 0, __PYX_ERR(1, 941, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":942 * # Cython code. @@ -10842,6 +11540,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { * __pyx_import_array() * except Exception: */ + __Pyx_TraceLine(942,0,__PYX_ERR(1, 942, __pyx_L1_error)) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign @@ -10858,6 +11557,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { * except Exception: * raise ImportError("numpy.core.multiarray failed to import") */ + __Pyx_TraceLine(943,0,__PYX_ERR(1, 943, __pyx_L3_error)) __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 943, __pyx_L3_error) /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":942 @@ -10881,6 +11581,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { * raise ImportError("numpy.core.multiarray failed to import") * */ + __Pyx_TraceLine(944,0,__PYX_ERR(1, 944, __pyx_L5_except_error)) __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); @@ -10896,7 +11597,8 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { * * cdef inline int import_umath() except -1: */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 945, __pyx_L5_except_error) + __Pyx_TraceLine(945,0,__PYX_ERR(1, 945, __pyx_L5_except_error)) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 945, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; @@ -10939,6 +11641,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -10953,6 +11656,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { int __pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; @@ -10966,6 +11670,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_umath", 0); + __Pyx_TraceCall("import_umath", __pyx_f[1], 947, 0, __PYX_ERR(1, 947, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":948 * @@ -10974,6 +11679,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { * _import_umath() * except Exception: */ + __Pyx_TraceLine(948,0,__PYX_ERR(1, 948, __pyx_L1_error)) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign @@ -10990,6 +11696,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { * except Exception: * raise ImportError("numpy.core.umath failed to import") */ + __Pyx_TraceLine(949,0,__PYX_ERR(1, 949, __pyx_L3_error)) __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 949, __pyx_L3_error) /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":948 @@ -11013,6 +11720,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { * raise ImportError("numpy.core.umath failed to import") * */ + __Pyx_TraceLine(950,0,__PYX_ERR(1, 950, __pyx_L5_except_error)) __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); @@ -11028,7 +11736,8 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { * * cdef inline int import_ufunc() except -1: */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 951, __pyx_L5_except_error) + __Pyx_TraceLine(951,0,__PYX_ERR(1, 951, __pyx_L5_except_error)) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 951, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; @@ -11071,6 +11780,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -11085,6 +11795,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { int __pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; @@ -11098,6 +11809,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_ufunc", 0); + __Pyx_TraceCall("import_ufunc", __pyx_f[1], 953, 0, __PYX_ERR(1, 953, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":954 * @@ -11106,6 +11818,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { * _import_umath() * except Exception: */ + __Pyx_TraceLine(954,0,__PYX_ERR(1, 954, __pyx_L1_error)) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign @@ -11122,6 +11835,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { * except Exception: * raise ImportError("numpy.core.umath failed to import") */ + __Pyx_TraceLine(955,0,__PYX_ERR(1, 955, __pyx_L3_error)) __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 955, __pyx_L3_error) /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":954 @@ -11145,6 +11859,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { * raise ImportError("numpy.core.umath failed to import") * */ + __Pyx_TraceLine(956,0,__PYX_ERR(1, 956, __pyx_L5_except_error)) __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); @@ -11160,7 +11875,8 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { * * cdef extern from *: */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 957, __pyx_L5_except_error) + __Pyx_TraceLine(957,0,__PYX_ERR(1, 957, __pyx_L5_except_error)) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 957, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; @@ -11203,6 +11919,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -11217,8 +11934,13 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_obj) { int __pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("is_timedelta64_object", 0); + __Pyx_TraceCall("is_timedelta64_object", __pyx_f[1], 967, 0, __PYX_ERR(1, 967, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":979 * bool @@ -11227,6 +11949,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_ * * */ + __Pyx_TraceLine(979,0,__PYX_ERR(1, 979, __pyx_L1_error)) __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyTimedeltaArrType_Type)); goto __pyx_L0; @@ -11239,7 +11962,11 @@ static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_ */ /* function exit code */ + __pyx_L1_error:; + __Pyx_WriteUnraisable("numpy.is_timedelta64_object", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; __pyx_L0:; + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -11254,8 +11981,13 @@ static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_ static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_obj) { int __pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("is_datetime64_object", 0); + __Pyx_TraceCall("is_datetime64_object", __pyx_f[1], 982, 0, __PYX_ERR(1, 982, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":994 * bool @@ -11264,6 +11996,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_o * * */ + __Pyx_TraceLine(994,0,__PYX_ERR(1, 994, __pyx_L1_error)) __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyDatetimeArrType_Type)); goto __pyx_L0; @@ -11276,7 +12009,11 @@ static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_o */ /* function exit code */ + __pyx_L1_error:; + __Pyx_WriteUnraisable("numpy.is_datetime64_object", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; __pyx_L0:; + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -11291,6 +12028,11 @@ static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_o static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject *__pyx_v_obj) { npy_datetime __pyx_r; + __Pyx_TraceDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceCall("get_datetime64_value", __pyx_f[1], 997, 1, __PYX_ERR(1, 997, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1004 * also needed. That can be found using `get_datetime64_unit`. @@ -11299,6 +12041,7 @@ static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject * * * */ + __Pyx_TraceLine(1004,1,__PYX_ERR(1, 1004, __pyx_L1_error)) __pyx_r = ((PyDatetimeScalarObject *)__pyx_v_obj)->obval; goto __pyx_L0; @@ -11311,7 +12054,11 @@ static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject * */ /* function exit code */ + __pyx_L1_error:; + __Pyx_WriteUnraisable("numpy.get_datetime64_value", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1); + __pyx_r = 0; __pyx_L0:; + __Pyx_TraceReturn(Py_None, 1); return __pyx_r; } @@ -11325,6 +12072,11 @@ static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject * static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject *__pyx_v_obj) { npy_timedelta __pyx_r; + __Pyx_TraceDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceCall("get_timedelta64_value", __pyx_f[1], 1007, 1, __PYX_ERR(1, 1007, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1011 * returns the int64 value underlying scalar numpy timedelta64 object @@ -11333,6 +12085,7 @@ static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject * * */ + __Pyx_TraceLine(1011,1,__PYX_ERR(1, 1011, __pyx_L1_error)) __pyx_r = ((PyTimedeltaScalarObject *)__pyx_v_obj)->obval; goto __pyx_L0; @@ -11345,7 +12098,11 @@ static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject */ /* function exit code */ + __pyx_L1_error:; + __Pyx_WriteUnraisable("numpy.get_timedelta64_value", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1); + __pyx_r = 0; __pyx_L0:; + __Pyx_TraceReturn(Py_None, 1); return __pyx_r; } @@ -11359,12 +12116,18 @@ static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject static CYTHON_INLINE NPY_DATETIMEUNIT __pyx_f_5numpy_get_datetime64_unit(PyObject *__pyx_v_obj) { NPY_DATETIMEUNIT __pyx_r; + __Pyx_TraceDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceCall("get_datetime64_unit", __pyx_f[1], 1014, 1, __PYX_ERR(1, 1014, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1018 * returns the unit part of the dtype for a numpy datetime64 object. * """ * return (obj).obmeta.base # <<<<<<<<<<<<<< */ + __Pyx_TraceLine(1018,1,__PYX_ERR(1, 1018, __pyx_L1_error)) __pyx_r = ((NPY_DATETIMEUNIT)((PyDatetimeScalarObject *)__pyx_v_obj)->obmeta.base); goto __pyx_L0; @@ -11377,7 +12140,11 @@ static CYTHON_INLINE NPY_DATETIMEUNIT __pyx_f_5numpy_get_datetime64_unit(PyObjec */ /* function exit code */ + __pyx_L1_error:; + __Pyx_WriteUnraisable("numpy.get_datetime64_unit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1); + __pyx_r = (NPY_DATETIMEUNIT) 0; __pyx_L0:; + __Pyx_TraceReturn(Py_None, 1); return __pyx_r; } @@ -11393,6 +12160,7 @@ static std::vector __pyx_convert_vector_from_py_double(PyObject *__pyx_ std::vector __pyx_v_v; PyObject *__pyx_v_item = NULL; std::vector __pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; @@ -11403,6 +12171,7 @@ static std::vector __pyx_convert_vector_from_py_double(PyObject *__pyx_ const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_convert_vector_from_py_double", 0); + __Pyx_TraceCall("__pyx_convert_vector_from_py_double", __pyx_f[2], 45, 0, __PYX_ERR(2, 45, __pyx_L1_error)); /* "vector.from_py":47 * cdef vector[X] __pyx_convert_vector_from_py_double(object o) except *: @@ -11411,6 +12180,7 @@ static std::vector __pyx_convert_vector_from_py_double(PyObject *__pyx_ * v.push_back(item) * return v */ + __Pyx_TraceLine(47,0,__PYX_ERR(2, 47, __pyx_L1_error)) if (likely(PyList_CheckExact(__pyx_v_o)) || PyTuple_CheckExact(__pyx_v_o)) { __pyx_t_1 = __pyx_v_o; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; __pyx_t_3 = NULL; @@ -11460,6 +12230,7 @@ static std::vector __pyx_convert_vector_from_py_double(PyObject *__pyx_ * return v * */ + __Pyx_TraceLine(48,0,__PYX_ERR(2, 48, __pyx_L1_error)) __pyx_t_5 = __pyx_PyFloat_AsDouble(__pyx_v_item); if (unlikely((__pyx_t_5 == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 48, __pyx_L1_error) __pyx_v_v.push_back(((double)__pyx_t_5)); @@ -11470,6 +12241,7 @@ static std::vector __pyx_convert_vector_from_py_double(PyObject *__pyx_ * v.push_back(item) * return v */ + __Pyx_TraceLine(47,0,__PYX_ERR(2, 47, __pyx_L1_error)) } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -11480,6 +12252,7 @@ static std::vector __pyx_convert_vector_from_py_double(PyObject *__pyx_ * * */ + __Pyx_TraceLine(49,0,__PYX_ERR(2, 49, __pyx_L1_error)) __pyx_r = __pyx_v_v; goto __pyx_L0; @@ -11499,6 +12272,7 @@ static std::vector __pyx_convert_vector_from_py_double(PyObject *__pyx_ __Pyx_pretend_to_initialize(&__pyx_r); __pyx_L0:; __Pyx_XDECREF(__pyx_v_item); + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -11507,6 +12281,7 @@ static std::vector > __pyx_convert_vector_from_py_std_3a__3 std::vector > __pyx_v_v; PyObject *__pyx_v_item = NULL; std::vector > __pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; @@ -11517,6 +12292,7 @@ static std::vector > __pyx_convert_vector_from_py_std_3a__3 const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___", 0); + __Pyx_TraceCall("__pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___", __pyx_f[2], 45, 0, __PYX_ERR(2, 45, __pyx_L1_error)); /* "vector.from_py":47 * cdef vector[X] __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(object o) except *: @@ -11525,6 +12301,7 @@ static std::vector > __pyx_convert_vector_from_py_std_3a__3 * v.push_back(item) * return v */ + __Pyx_TraceLine(47,0,__PYX_ERR(2, 47, __pyx_L1_error)) if (likely(PyList_CheckExact(__pyx_v_o)) || PyTuple_CheckExact(__pyx_v_o)) { __pyx_t_1 = __pyx_v_o; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; __pyx_t_3 = NULL; @@ -11574,6 +12351,7 @@ static std::vector > __pyx_convert_vector_from_py_std_3a__3 * return v * */ + __Pyx_TraceLine(48,0,__PYX_ERR(2, 48, __pyx_L1_error)) __pyx_t_5 = __pyx_convert_vector_from_py_double(__pyx_v_item); if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 48, __pyx_L1_error) __pyx_v_v.push_back(((std::vector )__pyx_t_5)); @@ -11584,6 +12362,7 @@ static std::vector > __pyx_convert_vector_from_py_std_3a__3 * v.push_back(item) * return v */ + __Pyx_TraceLine(47,0,__PYX_ERR(2, 47, __pyx_L1_error)) } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -11594,6 +12373,7 @@ static std::vector > __pyx_convert_vector_from_py_std_3a__3 * * */ + __Pyx_TraceLine(49,0,__PYX_ERR(2, 49, __pyx_L1_error)) __pyx_r = __pyx_v_v; goto __pyx_L0; @@ -11613,6 +12393,7 @@ static std::vector > __pyx_convert_vector_from_py_std_3a__3 __Pyx_pretend_to_initialize(&__pyx_r); __pyx_L0:; __Pyx_XDECREF(__pyx_v_item); + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -11629,12 +12410,14 @@ static std::string __pyx_convert_string_from_py_std__in_string(PyObject *__pyx_v Py_ssize_t __pyx_v_length; char const *__pyx_v_data; std::string __pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations char const *__pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_convert_string_from_py_std__in_string", 0); + __Pyx_TraceCall("__pyx_convert_string_from_py_std__in_string", __pyx_f[2], 13, 0, __PYX_ERR(2, 13, __pyx_L1_error)); /* "string.from_py":14 * @cname("__pyx_convert_string_from_py_std__in_string") @@ -11643,6 +12426,7 @@ static std::string __pyx_convert_string_from_py_std__in_string(PyObject *__pyx_v * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) * return string(data, length) */ + __Pyx_TraceLine(14,0,__PYX_ERR(2, 14, __pyx_L1_error)) __pyx_v_length = 0; /* "string.from_py":15 @@ -11652,6 +12436,7 @@ static std::string __pyx_convert_string_from_py_std__in_string(PyObject *__pyx_v * return string(data, length) * */ + __Pyx_TraceLine(15,0,__PYX_ERR(2, 15, __pyx_L1_error)) __pyx_t_1 = __Pyx_PyObject_AsStringAndSize(__pyx_v_o, (&__pyx_v_length)); if (unlikely(__pyx_t_1 == ((char const *)NULL))) __PYX_ERR(2, 15, __pyx_L1_error) __pyx_v_data = __pyx_t_1; @@ -11662,6 +12447,7 @@ static std::string __pyx_convert_string_from_py_std__in_string(PyObject *__pyx_v * * */ + __Pyx_TraceLine(16,0,__PYX_ERR(2, 16, __pyx_L1_error)) __pyx_r = std::string(__pyx_v_data, __pyx_v_length); goto __pyx_L0; @@ -11678,6 +12464,7 @@ static std::string __pyx_convert_string_from_py_std__in_string(PyObject *__pyx_v __Pyx_AddTraceback("string.from_py.__pyx_convert_string_from_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_pretend_to_initialize(&__pyx_r); __pyx_L0:; + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -11693,6 +12480,7 @@ static std::string __pyx_convert_string_from_py_std__in_string(PyObject *__pyx_v static PyObject *__pyx_convert_vector_to_py_double(const std::vector &__pyx_v_v) { size_t __pyx_v_i; PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; size_t __pyx_t_2; @@ -11703,6 +12491,7 @@ static PyObject *__pyx_convert_vector_to_py_double(const std::vector &_ const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_double", 0); + __Pyx_TraceCall("__pyx_convert_vector_to_py_double", __pyx_f[2], 60, 0, __PYX_ERR(2, 60, __pyx_L1_error)); /* "vector.to_py":61 * @cname("__pyx_convert_vector_to_py_double") @@ -11711,6 +12500,7 @@ static PyObject *__pyx_convert_vector_to_py_double(const std::vector &_ * * */ + __Pyx_TraceLine(61,0,__PYX_ERR(2, 61, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 61, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -11743,6 +12533,7 @@ static PyObject *__pyx_convert_vector_to_py_double(const std::vector &_ __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -11750,6 +12541,7 @@ static PyObject *__pyx_convert_vector_to_py_double(const std::vector &_ static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(const std::vector > &__pyx_v_v) { size_t __pyx_v_i; PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; size_t __pyx_t_2; @@ -11760,6 +12552,7 @@ static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(co const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___", 0); + __Pyx_TraceCall("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___", __pyx_f[2], 60, 0, __PYX_ERR(2, 60, __pyx_L1_error)); /* "vector.to_py":61 * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___") @@ -11768,6 +12561,7 @@ static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(co * * */ + __Pyx_TraceLine(61,0,__PYX_ERR(2, 61, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 61, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -11800,6 +12594,7 @@ static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(co __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -11807,6 +12602,7 @@ static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(co static PyObject *__pyx_convert_vector_to_py_size_t(const std::vector &__pyx_v_v) { size_t __pyx_v_i; PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; size_t __pyx_t_2; @@ -11817,6 +12613,7 @@ static PyObject *__pyx_convert_vector_to_py_size_t(const std::vector &_ const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_size_t", 0); + __Pyx_TraceCall("__pyx_convert_vector_to_py_size_t", __pyx_f[2], 60, 0, __PYX_ERR(2, 60, __pyx_L1_error)); /* "vector.to_py":61 * @cname("__pyx_convert_vector_to_py_size_t") @@ -11825,6 +12622,7 @@ static PyObject *__pyx_convert_vector_to_py_size_t(const std::vector &_ * * */ + __Pyx_TraceLine(61,0,__PYX_ERR(2, 61, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 61, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -11857,6 +12655,7 @@ static PyObject *__pyx_convert_vector_to_py_size_t(const std::vector &_ __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -11864,6 +12663,7 @@ static PyObject *__pyx_convert_vector_to_py_size_t(const std::vector &_ static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(const std::vector > &__pyx_v_v) { size_t __pyx_v_i; PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; size_t __pyx_t_2; @@ -11874,6 +12674,7 @@ static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(co const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___", 0); + __Pyx_TraceCall("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___", __pyx_f[2], 60, 0, __PYX_ERR(2, 60, __pyx_L1_error)); /* "vector.to_py":61 * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___") @@ -11882,6 +12683,7 @@ static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(co * * */ + __Pyx_TraceLine(61,0,__PYX_ERR(2, 61, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 61, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -11914,6 +12716,7 @@ static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(co __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -11921,6 +12724,7 @@ static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(co static PyObject *__pyx_convert_vector_to_py_bool(const std::vector &__pyx_v_v) { size_t __pyx_v_i; PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; size_t __pyx_t_2; @@ -11931,6 +12735,7 @@ static PyObject *__pyx_convert_vector_to_py_bool(const std::vector &__pyx const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_bool", 0); + __Pyx_TraceCall("__pyx_convert_vector_to_py_bool", __pyx_f[2], 60, 0, __PYX_ERR(2, 60, __pyx_L1_error)); /* "vector.to_py":61 * @cname("__pyx_convert_vector_to_py_bool") @@ -11939,6 +12744,7 @@ static PyObject *__pyx_convert_vector_to_py_bool(const std::vector &__pyx * * */ + __Pyx_TraceLine(61,0,__PYX_ERR(2, 61, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 61, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -11971,6 +12777,7 @@ static PyObject *__pyx_convert_vector_to_py_bool(const std::vector &__pyx __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -11978,6 +12785,7 @@ static PyObject *__pyx_convert_vector_to_py_bool(const std::vector &__pyx static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(const std::vector > &__pyx_v_v) { size_t __pyx_v_i; PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; size_t __pyx_t_2; @@ -11988,6 +12796,7 @@ static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(cons const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___", 0); + __Pyx_TraceCall("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___", __pyx_f[2], 60, 0, __PYX_ERR(2, 60, __pyx_L1_error)); /* "vector.to_py":61 * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___") @@ -11996,6 +12805,7 @@ static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(cons * * */ + __Pyx_TraceLine(61,0,__PYX_ERR(2, 61, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 61, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -12028,6 +12838,7 @@ static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(cons __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -12108,8 +12919,8 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_Union, __pyx_k_Union, sizeof(__pyx_k_Union), 0, 0, 1, 1}, {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, {&__pyx_n_s_X, __pyx_k_X, sizeof(__pyx_k_X), 0, 0, 1, 1}, - {&__pyx_n_s__18, __pyx_k__18, sizeof(__pyx_k__18), 0, 0, 1, 1}, - {&__pyx_kp_u__5, __pyx_k__5, sizeof(__pyx_k__5), 0, 1, 0, 0}, + {&__pyx_n_s__21, __pyx_k__21, sizeof(__pyx_k__21), 0, 0, 1, 1}, + {&__pyx_kp_u__6, __pyx_k__6, sizeof(__pyx_k__6), 0, 1, 0, 0}, {&__pyx_n_s_a, __pyx_k_a, sizeof(__pyx_k_a), 0, 0, 1, 1}, {&__pyx_n_s_active_set, __pyx_k_active_set, sizeof(__pyx_k_active_set), 0, 0, 1, 1}, {&__pyx_n_s_active_set_num, __pyx_k_active_set_num, sizeof(__pyx_k_active_set_num), 0, 0, 1, 1}, @@ -12309,9 +13120,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * elif isinstance(arr, csc_matrix): * if not arr.data.flags['F_CONTIGUOUS']: */ - __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_expected_arr_to_be_F_CONTIGUOUS); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 20, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple_); - __Pyx_GIVEREF(__pyx_tuple_); + __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_to_be_F_CONTIGUOUS); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 20, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); /* "l0learn/interface.pyx":23 * elif isinstance(arr, csc_matrix): @@ -12320,9 +13131,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * if not arr.indices.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") */ - __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_data_to_be_F_CONTIG); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 23, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__2); - __Pyx_GIVEREF(__pyx_tuple__2); + __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_data_to_be_F_CONTIG); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); /* "l0learn/interface.pyx":25 * raise ValueError("expected arr.data to be F_CONTIGUOUS.") @@ -12331,9 +13142,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * if not arr.indptr.flags['F_CONTIGUOUS']: * raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") */ - __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_indices_to_be_F_CON); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 25, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__3); - __Pyx_GIVEREF(__pyx_tuple__3); + __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_indices_to_be_F_CON); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 25, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); /* "l0learn/interface.pyx":27 * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") @@ -12342,9 +13153,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * else: * raise NotImplementedError(f"expected arr to be of type {np.ndarray} or {csc_matrix}, but got {type(arr)}.") */ - __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_indptr_to_be_F_CONT); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 27, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__4); - __Pyx_GIVEREF(__pyx_tuple__4); + __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_indptr_to_be_F_CONT); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 27, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); /* "l0learn/interface.pyx":32 * @@ -12353,9 +13164,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * elif arr.ndim > 2: * raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") */ - __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_ndim_to_be_1_or_2_b); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 32, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__6); - __Pyx_GIVEREF(__pyx_tuple__6); + __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_ndim_to_be_1_or_2_b); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__7); + __Pyx_GIVEREF(__pyx_tuple__7); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":945 * __pyx_import_array() @@ -12364,9 +13175,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * * cdef inline int import_umath() except -1: */ - __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 945, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__11); - __Pyx_GIVEREF(__pyx_tuple__11); + __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(1, 945, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__15); + __Pyx_GIVEREF(__pyx_tuple__15); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":951 * _import_umath() @@ -12375,9 +13186,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * * cdef inline int import_ufunc() except -1: */ - __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 951, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__12); - __Pyx_GIVEREF(__pyx_tuple__12); + __pyx_tuple__16 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(1, 951, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__16); + __Pyx_GIVEREF(__pyx_tuple__16); /* "l0learn/interface.pyx":16 * from l0learn.models import FitModel, CVFitModel @@ -12386,10 +13197,10 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * # TODO: Add checks for Behaved and OwnsData * if isinstance(arr, np.ndarray): */ - __pyx_tuple__13 = PyTuple_Pack(1, __pyx_n_s_arr); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 16, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__13); - __Pyx_GIVEREF(__pyx_tuple__13); - __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_np_to_arma_check, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(0, 16, __pyx_L1_error) + __pyx_tuple__17 = PyTuple_Pack(1, __pyx_n_s_arr); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(0, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__17); + __Pyx_GIVEREF(__pyx_tuple__17); + __pyx_codeobj_ = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__17, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_np_to_arma_check, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj_)) __PYX_ERR(0, 16, __pyx_L1_error) /* "l0learn/interface.pyx":46 * @@ -12398,9 +13209,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") */ - __pyx_tuple__15 = PyTuple_Pack(3, __pyx_n_u_SquaredError, __pyx_n_u_Logistic, __pyx_n_u_SquaredHinge); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 46, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__15); - __Pyx_GIVEREF(__pyx_tuple__15); + __pyx_tuple__18 = PyTuple_Pack(3, __pyx_n_u_SquaredError, __pyx_n_u_Logistic, __pyx_n_u_SquaredHinge); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__18); + __Pyx_GIVEREF(__pyx_tuple__18); /* "l0learn/interface.pyx":48 * SUPPORTED_LOSS = ("SquaredError", "Logistic", "SquaredHinge") @@ -12409,9 +13220,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * SUPPORTED_ALGORITHM = ("CD", "CDPSI") * */ - __pyx_tuple__16 = PyTuple_Pack(3, __pyx_n_u_L0, __pyx_n_u_L0L1, __pyx_n_u_L0L2); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 48, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__16); - __Pyx_GIVEREF(__pyx_tuple__16); + __pyx_tuple__19 = PyTuple_Pack(3, __pyx_n_u_L0, __pyx_n_u_L0L1, __pyx_n_u_L0L2); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(0, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__19); + __Pyx_GIVEREF(__pyx_tuple__19); /* "l0learn/interface.pyx":49 * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] @@ -12420,9 +13231,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * * */ - __pyx_tuple__17 = PyTuple_Pack(2, __pyx_n_u_CD, __pyx_n_u_CDPSI); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(0, 49, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__17); - __Pyx_GIVEREF(__pyx_tuple__17); + __pyx_tuple__20 = PyTuple_Pack(2, __pyx_n_u_CD, __pyx_n_u_CDPSI); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__20); + __Pyx_GIVEREF(__pyx_tuple__20); /* "l0learn/interface.pyx":52 * @@ -12431,10 +13242,10 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * y: np.ndarray, * loss: str, */ - __pyx_tuple__19 = PyTuple_Pack(38, __pyx_n_s_X, __pyx_n_s_y, __pyx_n_s_loss, __pyx_n_s_penalty, __pyx_n_s_algorithm, __pyx_n_s_max_support_size, __pyx_n_s_num_lambda, __pyx_n_s_num_gamma, __pyx_n_s_gamma_max, __pyx_n_s_gamma_min, __pyx_n_s_partial_sort, __pyx_n_s_max_iter, __pyx_n_s_rtol, __pyx_n_s_atol, __pyx_n_s_active_set, __pyx_n_s_active_set_num, __pyx_n_s_max_swaps, __pyx_n_s_scale_down_factor, __pyx_n_s_screen_size, __pyx_n_s_lambda_grid, __pyx_n_s_exclude_first_k, __pyx_n_s_intercept, __pyx_n_s_lows, __pyx_n_s_highs, __pyx_n_s_n, __pyx_n_s_p, __pyx_n_s_unique_items, __pyx_n_s_a, __pyx_n_s__18, __pyx_n_s_first_value, __pyx_n_s_second_value, __pyx_n_s_auto_lambda, __pyx_n_s_bad_lambda_grid, __pyx_n_s_i, __pyx_n_s_sub_lambda_grid, __pyx_n_s_current, __pyx_n_s_with_bounds, __pyx_n_s_bad_bounds); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(0, 52, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__19); - __Pyx_GIVEREF(__pyx_tuple__19); - __pyx_codeobj__20 = (PyObject*)__Pyx_PyCode_New(24, 0, 38, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__19, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_fit_check, 52, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__20)) __PYX_ERR(0, 52, __pyx_L1_error) + __pyx_tuple__22 = PyTuple_Pack(38, __pyx_n_s_X, __pyx_n_s_y, __pyx_n_s_loss, __pyx_n_s_penalty, __pyx_n_s_algorithm, __pyx_n_s_max_support_size, __pyx_n_s_num_lambda, __pyx_n_s_num_gamma, __pyx_n_s_gamma_max, __pyx_n_s_gamma_min, __pyx_n_s_partial_sort, __pyx_n_s_max_iter, __pyx_n_s_rtol, __pyx_n_s_atol, __pyx_n_s_active_set, __pyx_n_s_active_set_num, __pyx_n_s_max_swaps, __pyx_n_s_scale_down_factor, __pyx_n_s_screen_size, __pyx_n_s_lambda_grid, __pyx_n_s_exclude_first_k, __pyx_n_s_intercept, __pyx_n_s_lows, __pyx_n_s_highs, __pyx_n_s_n, __pyx_n_s_p, __pyx_n_s_unique_items, __pyx_n_s_a, __pyx_n_s__21, __pyx_n_s_first_value, __pyx_n_s_second_value, __pyx_n_s_auto_lambda, __pyx_n_s_bad_lambda_grid, __pyx_n_s_i, __pyx_n_s_sub_lambda_grid, __pyx_n_s_current, __pyx_n_s_with_bounds, __pyx_n_s_bad_bounds); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__22); + __Pyx_GIVEREF(__pyx_tuple__22); + __pyx_codeobj__8 = (PyObject*)__Pyx_PyCode_New(24, 0, 38, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__22, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_fit_check, 52, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__8)) __PYX_ERR(0, 52, __pyx_L1_error) /* "l0learn/interface.pyx":247 * @@ -12443,10 +13254,10 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * y: np.ndarray, * loss: str = "SquaredError", */ - __pyx_tuple__21 = PyTuple_Pack(33, __pyx_n_s_X, __pyx_n_s_y, __pyx_n_s_loss, __pyx_n_s_penalty, __pyx_n_s_algorithm, __pyx_n_s_max_support_size, __pyx_n_s_num_lambda, __pyx_n_s_num_gamma, __pyx_n_s_gamma_max, __pyx_n_s_gamma_min, __pyx_n_s_partial_sort, __pyx_n_s_max_iter, __pyx_n_s_rtol, __pyx_n_s_atol, __pyx_n_s_active_set, __pyx_n_s_active_set_num, __pyx_n_s_max_swaps, __pyx_n_s_scale_down_factor, __pyx_n_s_screen_size, __pyx_n_s_lambda_grid, __pyx_n_s_exclude_first_k, __pyx_n_s_intercept, __pyx_n_s_lows, __pyx_n_s_highs, __pyx_n_s_check, __pyx_n_s_auto_lambda, __pyx_n_s_with_bounds, __pyx_n_s_c_lambda_grid, __pyx_n_s_c_loss, __pyx_n_s_c_penalty, __pyx_n_s_c_algorithim, __pyx_n_s_c_results, __pyx_n_s_results); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(0, 247, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__21); - __Pyx_GIVEREF(__pyx_tuple__21); - __pyx_codeobj__22 = (PyObject*)__Pyx_PyCode_New(24, 0, 33, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__21, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_fit, 247, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__22)) __PYX_ERR(0, 247, __pyx_L1_error) + __pyx_tuple__23 = PyTuple_Pack(33, __pyx_n_s_X, __pyx_n_s_y, __pyx_n_s_loss, __pyx_n_s_penalty, __pyx_n_s_algorithm, __pyx_n_s_max_support_size, __pyx_n_s_num_lambda, __pyx_n_s_num_gamma, __pyx_n_s_gamma_max, __pyx_n_s_gamma_min, __pyx_n_s_partial_sort, __pyx_n_s_max_iter, __pyx_n_s_rtol, __pyx_n_s_atol, __pyx_n_s_active_set, __pyx_n_s_active_set_num, __pyx_n_s_max_swaps, __pyx_n_s_scale_down_factor, __pyx_n_s_screen_size, __pyx_n_s_lambda_grid, __pyx_n_s_exclude_first_k, __pyx_n_s_intercept, __pyx_n_s_lows, __pyx_n_s_highs, __pyx_n_s_check, __pyx_n_s_auto_lambda, __pyx_n_s_with_bounds, __pyx_n_s_c_lambda_grid, __pyx_n_s_c_loss, __pyx_n_s_c_penalty, __pyx_n_s_c_algorithim, __pyx_n_s_c_results, __pyx_n_s_results); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(0, 247, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__23); + __Pyx_GIVEREF(__pyx_tuple__23); + __pyx_codeobj__11 = (PyObject*)__Pyx_PyCode_New(24, 0, 33, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__23, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_fit, 247, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__11)) __PYX_ERR(0, 247, __pyx_L1_error) /* "l0learn/interface.pyx":533 * @@ -12455,10 +13266,10 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * y: np.ndarray, * loss: str = "SquaredError", */ - __pyx_tuple__23 = PyTuple_Pack(37, __pyx_n_s_X, __pyx_n_s_y, __pyx_n_s_loss, __pyx_n_s_penalty, __pyx_n_s_algorithm, __pyx_n_s_num_folds, __pyx_n_s_seed, __pyx_n_s_max_support_size, __pyx_n_s_num_lambda, __pyx_n_s_num_gamma, __pyx_n_s_gamma_max, __pyx_n_s_gamma_min, __pyx_n_s_partial_sort, __pyx_n_s_max_iter, __pyx_n_s_rtol, __pyx_n_s_atol, __pyx_n_s_active_set, __pyx_n_s_active_set_num, __pyx_n_s_max_swaps, __pyx_n_s_scale_down_factor, __pyx_n_s_screen_size, __pyx_n_s_lambda_grid, __pyx_n_s_exclude_first_k, __pyx_n_s_intercept, __pyx_n_s_lows, __pyx_n_s_highs, __pyx_n_s_check, __pyx_n_s_auto_lambda, __pyx_n_s_with_bounds, __pyx_n_s__18, __pyx_n_s_p, __pyx_n_s_c_lambda_grid, __pyx_n_s_c_loss, __pyx_n_s_c_penalty, __pyx_n_s_c_algorithim, __pyx_n_s_c_results, __pyx_n_s_results); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(0, 533, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__23); - __Pyx_GIVEREF(__pyx_tuple__23); - __pyx_codeobj__24 = (PyObject*)__Pyx_PyCode_New(26, 0, 37, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__23, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_cvfit, 533, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__24)) __PYX_ERR(0, 533, __pyx_L1_error) + __pyx_tuple__24 = PyTuple_Pack(37, __pyx_n_s_X, __pyx_n_s_y, __pyx_n_s_loss, __pyx_n_s_penalty, __pyx_n_s_algorithm, __pyx_n_s_num_folds, __pyx_n_s_seed, __pyx_n_s_max_support_size, __pyx_n_s_num_lambda, __pyx_n_s_num_gamma, __pyx_n_s_gamma_max, __pyx_n_s_gamma_min, __pyx_n_s_partial_sort, __pyx_n_s_max_iter, __pyx_n_s_rtol, __pyx_n_s_atol, __pyx_n_s_active_set, __pyx_n_s_active_set_num, __pyx_n_s_max_swaps, __pyx_n_s_scale_down_factor, __pyx_n_s_screen_size, __pyx_n_s_lambda_grid, __pyx_n_s_exclude_first_k, __pyx_n_s_intercept, __pyx_n_s_lows, __pyx_n_s_highs, __pyx_n_s_check, __pyx_n_s_auto_lambda, __pyx_n_s_with_bounds, __pyx_n_s__21, __pyx_n_s_p, __pyx_n_s_c_lambda_grid, __pyx_n_s_c_loss, __pyx_n_s_c_penalty, __pyx_n_s_c_algorithim, __pyx_n_s_c_results, __pyx_n_s_results); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(0, 533, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__24); + __Pyx_GIVEREF(__pyx_tuple__24); + __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(26, 0, 37, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__24, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_cvfit, 533, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(0, 533, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; @@ -12720,6 +13531,7 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_interface(PyObject *__pyx_pyinit_m #endif #endif { + __Pyx_TraceDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; @@ -12828,6 +13640,7 @@ if (!__Pyx_RefNanny) { #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif + __Pyx_TraceCall("__Pyx_PyMODINIT_FUNC PyInit_interface(void)", __pyx_f[0], 1, 0, __PYX_ERR(0, 1, __pyx_L1_error)); /* "l0learn/interface.pyx":4 * from libcpp.string cimport string @@ -12836,6 +13649,7 @@ if (!__Pyx_RefNanny) { * from scipy.sparse import csc_matrix * from warnings import warn */ + __Pyx_TraceLine(4,0,__PYX_ERR(0, 4, __pyx_L1_error)) __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error) @@ -12848,6 +13662,7 @@ if (!__Pyx_RefNanny) { * from warnings import warn * */ + __Pyx_TraceLine(5,0,__PYX_ERR(0, 5, __pyx_L1_error)) __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_csc_matrix); @@ -12869,6 +13684,7 @@ if (!__Pyx_RefNanny) { * * from typing import Union, Optional, List, Dict, Any */ + __Pyx_TraceLine(6,0,__PYX_ERR(0, 6, __pyx_L1_error)) __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_warn); @@ -12890,6 +13706,7 @@ if (!__Pyx_RefNanny) { * * from l0learn.cyarma cimport dmat, sp_dmat, numpy_to_sp_dmat_d, numpy_to_dmat_d, dvec, numpy_to_dvec_d, \ */ + __Pyx_TraceLine(8,0,__PYX_ERR(0, 8, __pyx_L1_error)) __pyx_t_1 = PyList_New(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_Union); @@ -12939,6 +13756,7 @@ if (!__Pyx_RefNanny) { * from l0learn.models import FitModel, CVFitModel * */ + __Pyx_TraceLine(13,0,__PYX_ERR(0, 13, __pyx_L1_error)) __pyx_t_2 = __Pyx_Import(__pyx_n_s_l0learn_models, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_l0learn, __pyx_t_2) < 0) __PYX_ERR(0, 13, __pyx_L1_error) @@ -12951,6 +13769,7 @@ if (!__Pyx_RefNanny) { * * def np_to_arma_check(arr): */ + __Pyx_TraceLine(14,0,__PYX_ERR(0, 14, __pyx_L1_error)) __pyx_t_2 = PyList_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_FitModel); @@ -12979,6 +13798,7 @@ if (!__Pyx_RefNanny) { * # TODO: Add checks for Behaved and OwnsData * if isinstance(arr, np.ndarray): */ + __Pyx_TraceLine(16,0,__PYX_ERR(0, 16, __pyx_L1_error)) __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_1np_to_arma_check, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 16, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_np_to_arma_check, __pyx_t_1) < 0) __PYX_ERR(0, 16, __pyx_L1_error) @@ -12991,7 +13811,8 @@ if (!__Pyx_RefNanny) { * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_SUPPORTED_LOSS, __pyx_tuple__15) < 0) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_TraceLine(46,0,__PYX_ERR(0, 46, __pyx_L1_error)) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SUPPORTED_LOSS, __pyx_tuple__18) < 0) __PYX_ERR(0, 46, __pyx_L1_error) /* "l0learn/interface.pyx":47 * @@ -13000,6 +13821,7 @@ if (!__Pyx_RefNanny) { * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") * SUPPORTED_ALGORITHM = ("CD", "CDPSI") */ + __Pyx_TraceLine(47,0,__PYX_ERR(0, 47, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 47, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 47, __pyx_L1_error) @@ -13028,7 +13850,8 @@ if (!__Pyx_RefNanny) { * SUPPORTED_ALGORITHM = ("CD", "CDPSI") * */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_SUPPORTED_PENALTY, __pyx_tuple__16) < 0) __PYX_ERR(0, 48, __pyx_L1_error) + __Pyx_TraceLine(48,0,__PYX_ERR(0, 48, __pyx_L1_error)) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SUPPORTED_PENALTY, __pyx_tuple__19) < 0) __PYX_ERR(0, 48, __pyx_L1_error) /* "l0learn/interface.pyx":49 * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] @@ -13037,7 +13860,8 @@ if (!__Pyx_RefNanny) { * * */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_SUPPORTED_ALGORITHM, __pyx_tuple__17) < 0) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_TraceLine(49,0,__PYX_ERR(0, 49, __pyx_L1_error)) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SUPPORTED_ALGORITHM, __pyx_tuple__20) < 0) __PYX_ERR(0, 49, __pyx_L1_error) /* "l0learn/interface.pyx":52 * @@ -13046,6 +13870,7 @@ if (!__Pyx_RefNanny) { * y: np.ndarray, * loss: str, */ + __Pyx_TraceLine(52,0,__PYX_ERR(0, 52, __pyx_L1_error)) __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_3_fit_check, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 52, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fit_check, __pyx_t_1) < 0) __PYX_ERR(0, 52, __pyx_L1_error) @@ -13058,10 +13883,11 @@ if (!__Pyx_RefNanny) { * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.FitModel: * """ */ + __Pyx_TraceLine(269,0,__PYX_ERR(0, 269, __pyx_L1_error)) __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 269, __pyx_L1_error) __pyx_t_1 = PyFloat_FromDouble((-__pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 269, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_k__7 = __pyx_t_1; + __pyx_k__9 = __pyx_t_1; __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; @@ -13072,10 +13898,11 @@ if (!__Pyx_RefNanny) { * """ * Computes the regularization path for the specified loss function and penalty function. */ + __Pyx_TraceLine(270,0,__PYX_ERR(0, 270, __pyx_L1_error)) __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 270, __pyx_L1_error) __pyx_t_1 = PyFloat_FromDouble(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 270, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_k__8 = __pyx_t_1; + __pyx_k__10 = __pyx_t_1; __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; @@ -13086,6 +13913,7 @@ if (!__Pyx_RefNanny) { * y: np.ndarray, * loss: str = "SquaredError", */ + __Pyx_TraceLine(247,0,__PYX_ERR(0, 247, __pyx_L1_error)) __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_5fit, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 247, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fit, __pyx_t_1) < 0) __PYX_ERR(0, 247, __pyx_L1_error) @@ -13098,10 +13926,11 @@ if (!__Pyx_RefNanny) { * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.CVFitModel: * */ + __Pyx_TraceLine(557,0,__PYX_ERR(0, 557, __pyx_L1_error)) __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 557, __pyx_L1_error) __pyx_t_1 = PyFloat_FromDouble((-__pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 557, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_k__9 = __pyx_t_1; + __pyx_k__12 = __pyx_t_1; __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; @@ -13112,10 +13941,11 @@ if (!__Pyx_RefNanny) { * * check = _fit_check(X=X, */ + __Pyx_TraceLine(558,0,__PYX_ERR(0, 558, __pyx_L1_error)) __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 558, __pyx_L1_error) __pyx_t_1 = PyFloat_FromDouble(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 558, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_k__10 = __pyx_t_1; + __pyx_k__13 = __pyx_t_1; __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; @@ -13126,38 +13956,331 @@ if (!__Pyx_RefNanny) { * y: np.ndarray, * loss: str = "SquaredError", */ + __Pyx_TraceLine(533,0,__PYX_ERR(0, 533, __pyx_L1_error)) __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_7cvfit, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 533, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_cvfit, __pyx_t_1) < 0) __PYX_ERR(0, 533, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /* "l0learn/interface.pyx":687 + * + * + * cdef fitmodel _L0LearnFit_dense(const dmat& X, # <<<<<<<<<<<<<< + * const dvec& y, + * const string Loss, + */ + __Pyx_TraceLine(687,0,__PYX_ERR(0, 687, __pyx_L1_error)) + + + /* "l0learn/interface.pyx":718 + * + * + * cdef fitmodel _L0LearnFit_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< + * const dvec& y, + * const string Loss, + */ + __Pyx_TraceLine(718,0,__PYX_ERR(0, 718, __pyx_L1_error)) + + + /* "l0learn/interface.pyx":749 + * + * + * cdef cvfitmodel _L0LearnCV_dense(const dmat& X, # <<<<<<<<<<<<<< + * const dvec& y, + * const string Loss, + */ + __Pyx_TraceLine(749,0,__PYX_ERR(0, 749, __pyx_L1_error)) + + + /* "l0learn/interface.pyx":782 + * + * + * cdef cvfitmodel _L0LearnCV_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< + * const dvec& y, + * const string Loss, + */ + __Pyx_TraceLine(782,0,__PYX_ERR(0, 782, __pyx_L1_error)) + + /* "l0learn/interface.pyx":1 * from libcpp.vector cimport vector # <<<<<<<<<<<<<< * from libcpp.string cimport string * from libcpp cimport bool as cppbool */ + __Pyx_TraceLine(1,0,__PYX_ERR(0, 1, __pyx_L1_error)) __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "vector.to_py":60 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":735 + * ctypedef npy_cdouble complex_t * - * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___") - * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(vector[X]& v): # <<<<<<<<<<<<<< - * return [v[i] for i in range(v.size())] + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) * */ + __Pyx_TraceLine(735,0,__PYX_ERR(1, 735, __pyx_L1_error)) - /*--- Wrapped vars code ---*/ - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - if (__pyx_m) { - if (__pyx_d) { + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":738 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + __Pyx_TraceLine(738,0,__PYX_ERR(1, 738, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":741 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + __Pyx_TraceLine(741,0,__PYX_ERR(1, 741, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":744 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + __Pyx_TraceLine(744,0,__PYX_ERR(1, 744, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":747 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + __Pyx_TraceLine(747,0,__PYX_ERR(1, 747, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":750 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape + */ + __Pyx_TraceLine(750,0,__PYX_ERR(1, 750, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":929 + * int _import_umath() except -1 + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) + */ + __Pyx_TraceLine(929,0,__PYX_ERR(1, 929, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":933 + * PyArray_SetBaseObject(arr, base) + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) + * if base is NULL: + */ + __Pyx_TraceLine(933,0,__PYX_ERR(1, 933, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":941 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * __pyx_import_array() + */ + __Pyx_TraceLine(941,0,__PYX_ERR(1, 941, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":947 + * raise ImportError("numpy.core.multiarray failed to import") + * + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + __Pyx_TraceLine(947,0,__PYX_ERR(1, 947, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":953 + * raise ImportError("numpy.core.umath failed to import") + * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + __Pyx_TraceLine(953,0,__PYX_ERR(1, 953, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":967 + * + * + * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.timedelta64)` + */ + __Pyx_TraceLine(967,0,__PYX_ERR(1, 967, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":982 + * + * + * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.datetime64)` + */ + __Pyx_TraceLine(982,0,__PYX_ERR(1, 982, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":997 + * + * + * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy datetime64 object + */ + __Pyx_TraceLine(997,0,__PYX_ERR(1, 997, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1007 + * + * + * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy timedelta64 object + */ + __Pyx_TraceLine(1007,0,__PYX_ERR(1, 1007, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1014 + * + * + * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the unit part of the dtype for a numpy datetime64 object. + */ + __Pyx_TraceLine(1014,0,__PYX_ERR(1, 1014, __pyx_L1_error)) + + + /* "vector.from_py":45 + * + * @cname("__pyx_convert_vector_from_py_double") + * cdef vector[X] __pyx_convert_vector_from_py_double(object o) except *: # <<<<<<<<<<<<<< + * cdef vector[X] v + * for item in o: + */ + __Pyx_TraceLine(45,0,__PYX_ERR(2, 45, __pyx_L1_error)) + + + /* "vector.from_py":40 + * + * + * cdef extern from *: # <<<<<<<<<<<<<< + * cdef cppclass vector "std::vector" [T]: + * void push_back(T&) + */ + __Pyx_TraceLine(40,0,__PYX_ERR(2, 40, __pyx_L1_error)) + + + /* "string.from_py":13 + * + * @cname("__pyx_convert_string_from_py_std__in_string") + * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: # <<<<<<<<<<<<<< + * cdef Py_ssize_t length = 0 + * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) + */ + __Pyx_TraceLine(13,0,__PYX_ERR(2, 13, __pyx_L1_error)) + + + /* "vector.to_py":60 + * + * @cname("__pyx_convert_vector_to_py_double") + * cdef object __pyx_convert_vector_to_py_double(vector[X]& v): # <<<<<<<<<<<<<< + * return [v[i] for i in range(v.size())] + * + */ + __Pyx_TraceLine(60,0,__PYX_ERR(2, 60, __pyx_L1_error)) + + + /* "vector.to_py":54 + * + * + * cdef extern from *: # <<<<<<<<<<<<<< + * cdef cppclass vector "const std::vector" [T]: + * size_t size() + */ + __Pyx_TraceLine(54,0,__PYX_ERR(2, 54, __pyx_L1_error)) + + + /* "vector.to_py":60 + * + * @cname("__pyx_convert_vector_to_py_size_t") + * cdef object __pyx_convert_vector_to_py_size_t(vector[X]& v): # <<<<<<<<<<<<<< + * return [v[i] for i in range(v.size())] + * + */ + __Pyx_TraceLine(60,0,__PYX_ERR(2, 60, __pyx_L1_error)) + + + /* "vector.to_py":54 + * + * + * cdef extern from *: # <<<<<<<<<<<<<< + * cdef cppclass vector "const std::vector" [T]: + * size_t size() + */ + __Pyx_TraceLine(54,0,__PYX_ERR(2, 54, __pyx_L1_error)) + + + /* "vector.to_py":60 + * + * @cname("__pyx_convert_vector_to_py_bool") + * cdef object __pyx_convert_vector_to_py_bool(vector[X]& v): # <<<<<<<<<<<<<< + * return [v[i] for i in range(v.size())] + * + */ + __Pyx_TraceLine(60,0,__PYX_ERR(2, 60, __pyx_L1_error)) + + + /* "vector.to_py":54 + * + * + * cdef extern from *: # <<<<<<<<<<<<<< + * cdef cppclass vector "const std::vector" [T]: + * size_t size() + */ + __Pyx_TraceLine(54,0,__PYX_ERR(2, 54, __pyx_L1_error)) + + + /* "vector.to_py":60 + * + * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___") + * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(vector[X]& v): # <<<<<<<<<<<<<< + * return [v[i] for i in range(v.size())] + * + */ + __Pyx_TraceReturn(Py_None, 0); + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + if (__pyx_m) { + if (__pyx_d) { __Pyx_AddTraceback("init l0learn.interface", __pyx_clineno, __pyx_lineno, __pyx_filename); } Py_CLEAR(__pyx_m); @@ -13221,6 +14344,122 @@ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { return result; } +/* PyErrFetchRestore */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +} +#endif + +/* Profile */ +#if CYTHON_PROFILE +static int __Pyx_TraceSetupAndCall(PyCodeObject** code, + PyFrameObject** frame, + PyThreadState* tstate, + const char *funcname, + const char *srcfile, + int firstlineno) { + PyObject *type, *value, *traceback; + int retval; + if (*frame == NULL || !CYTHON_PROFILE_REUSE_FRAME) { + if (*code == NULL) { + *code = __Pyx_createFrameCodeObject(funcname, srcfile, firstlineno); + if (*code == NULL) return 0; + } + *frame = PyFrame_New( + tstate, /*PyThreadState *tstate*/ + *code, /*PyCodeObject *code*/ + __pyx_d, /*PyObject *globals*/ + 0 /*PyObject *locals*/ + ); + if (*frame == NULL) return 0; + if (CYTHON_TRACE && (*frame)->f_trace == NULL) { + Py_INCREF(Py_None); + (*frame)->f_trace = Py_None; + } +#if PY_VERSION_HEX < 0x030400B1 + } else { + (*frame)->f_tstate = tstate; +#endif + } + __Pyx_PyFrame_SetLineNumber(*frame, firstlineno); + retval = 1; + tstate->tracing++; + __Pyx_SetTracing(tstate, 0); + __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); + #if CYTHON_TRACE + if (tstate->c_tracefunc) + retval = tstate->c_tracefunc(tstate->c_traceobj, *frame, PyTrace_CALL, NULL) == 0; + if (retval && tstate->c_profilefunc) + #endif + retval = tstate->c_profilefunc(tstate->c_profileobj, *frame, PyTrace_CALL, NULL) == 0; + __Pyx_SetTracing(tstate, (tstate->c_profilefunc || (CYTHON_TRACE && tstate->c_tracefunc))); + tstate->tracing--; + if (retval) { + __Pyx_ErrRestoreInState(tstate, type, value, traceback); + return __Pyx_IsTracing(tstate, 0, 0) && retval; + } else { + Py_XDECREF(type); + Py_XDECREF(value); + Py_XDECREF(traceback); + return -1; + } +} +static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno) { + PyCodeObject *py_code = 0; +#if PY_MAJOR_VERSION >= 3 + py_code = PyCode_NewEmpty(srcfile, funcname, firstlineno); + if (likely(py_code)) { + py_code->co_flags |= CO_OPTIMIZED | CO_NEWLOCALS; + } +#else + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + py_funcname = PyString_FromString(funcname); + if (unlikely(!py_funcname)) goto bad; + py_srcfile = PyString_FromString(srcfile); + if (unlikely(!py_srcfile)) goto bad; + py_code = PyCode_New( + 0, + 0, + 0, + CO_OPTIMIZED | CO_NEWLOCALS, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + firstlineno, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); +#endif + return py_code; +} +#endif + /* PyDictVersioning */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { @@ -13326,30 +14565,6 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg } #endif -/* PyErrFetchRestore */ -#if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { - PyObject *tmp_type, *tmp_value, *tmp_tb; - tmp_type = tstate->curexc_type; - tmp_value = tstate->curexc_value; - tmp_tb = tstate->curexc_traceback; - tstate->curexc_type = type; - tstate->curexc_value = value; - tstate->curexc_traceback = tb; - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); -} -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { - *type = tstate->curexc_type; - *value = tstate->curexc_value; - *tb = tstate->curexc_traceback; - tstate->curexc_type = 0; - tstate->curexc_value = 0; - tstate->curexc_traceback = 0; -} -#endif - /* RaiseException */ #if PY_MAJOR_VERSION < 3 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, @@ -14947,6 +16162,48 @@ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { return 0; } +/* WriteUnraisableException */ +static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, + CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, + int full_traceback, CYTHON_UNUSED int nogil) { + PyObject *old_exc, *old_val, *old_tb; + PyObject *ctx; + __Pyx_PyThreadState_declare +#ifdef WITH_THREAD + PyGILState_STATE state; + if (nogil) + state = PyGILState_Ensure(); +#ifdef _MSC_VER + else state = (PyGILState_STATE)-1; +#endif +#endif + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); + if (full_traceback) { + Py_XINCREF(old_exc); + Py_XINCREF(old_val); + Py_XINCREF(old_tb); + __Pyx_ErrRestore(old_exc, old_val, old_tb); + PyErr_PrintEx(1); + } + #if PY_MAJOR_VERSION < 3 + ctx = PyString_FromString(name); + #else + ctx = PyUnicode_FromString(name); + #endif + __Pyx_ErrRestore(old_exc, old_val, old_tb); + if (!ctx) { + PyErr_WriteUnraisable(Py_None); + } else { + PyErr_WriteUnraisable(ctx); + Py_DECREF(ctx); + } +#ifdef WITH_THREAD + if (nogil) + PyGILState_Release(state); +#endif +} + /* TypeImport */ #ifndef __PYX_HAVE_RT_ImportType #define __PYX_HAVE_RT_ImportType diff --git a/python/l0learn/testing_utils.cpp b/python/l0learn/testing_utils.cpp index 69dcb8a..9c1c8d5 100644 --- a/python/l0learn/testing_utils.cpp +++ b/python/l0learn/testing_utils.cpp @@ -3,6 +3,12 @@ /* BEGIN: Cython Metadata { "distutils": { + "define_macros": [ + [ + "CYTHON_TRACE_NOGIL", + "1" + ] + ], "depends": [ "/Users/tnonet/opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/core/include/numpy/arrayobject.h", "/Users/tnonet/opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/core/include/numpy/arrayscalars.h", @@ -1261,33 +1267,6 @@ typedef npy_cdouble __pyx_t_5numpy_complex_t; #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) -/* ExtTypeTest.proto */ -static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); - -/* IsLittleEndian.proto */ -static CYTHON_INLINE int __Pyx_Is_Little_Endian(void); - -/* BufferFormatCheck.proto */ -static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts); -static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, - __Pyx_BufFmt_StackElem* stack, - __Pyx_TypeInfo* type); - -/* BufferGetAndValidate.proto */ -#define __Pyx_GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)\ - ((obj == Py_None || obj == NULL) ?\ - (__Pyx_ZeroBuffer(buf), 0) :\ - __Pyx__GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)) -static int __Pyx__GetBufferAndValidate(Py_buffer* buf, PyObject* obj, - __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack); -static void __Pyx_ZeroBuffer(Py_buffer* buf); -static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info); -static Py_ssize_t __Pyx_minusones[] = { -1, -1, -1, -1, -1, -1, -1, -1 }; -static Py_ssize_t __Pyx_zeros[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; - -/* BufferFallbackError.proto */ -static void __Pyx_RaiseBufferFallbackError(void); - /* PyThreadStateGet.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; @@ -1324,6 +1303,246 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif +/* Profile.proto */ +#ifndef CYTHON_PROFILE +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON + #define CYTHON_PROFILE 0 +#else + #define CYTHON_PROFILE 1 +#endif +#endif +#ifndef CYTHON_TRACE_NOGIL + #define CYTHON_TRACE_NOGIL 0 +#else + #if CYTHON_TRACE_NOGIL && !defined(CYTHON_TRACE) + #define CYTHON_TRACE 1 + #endif +#endif +#ifndef CYTHON_TRACE + #define CYTHON_TRACE 0 +#endif +#if CYTHON_TRACE + #undef CYTHON_PROFILE_REUSE_FRAME +#endif +#ifndef CYTHON_PROFILE_REUSE_FRAME + #define CYTHON_PROFILE_REUSE_FRAME 0 +#endif +#if CYTHON_PROFILE || CYTHON_TRACE + #include "compile.h" + #include "frameobject.h" + #include "traceback.h" + #if CYTHON_PROFILE_REUSE_FRAME + #define CYTHON_FRAME_MODIFIER static + #define CYTHON_FRAME_DEL(frame) + #else + #define CYTHON_FRAME_MODIFIER + #define CYTHON_FRAME_DEL(frame) Py_CLEAR(frame) + #endif + #define __Pyx_TraceDeclarations\ + static PyCodeObject *__pyx_frame_code = NULL;\ + CYTHON_FRAME_MODIFIER PyFrameObject *__pyx_frame = NULL;\ + int __Pyx_use_tracing = 0; + #define __Pyx_TraceFrameInit(codeobj)\ + if (codeobj) __pyx_frame_code = (PyCodeObject*) codeobj; +#if PY_VERSION_HEX >= 0x030a00b1 + #define __Pyx_IsTracing(tstate, check_tracing, check_funcs)\ + (unlikely((tstate)->cframe->use_tracing) &&\ + (!(check_tracing) || !(tstate)->tracing) &&\ + (!(check_funcs) || (tstate)->c_profilefunc || (CYTHON_TRACE && (tstate)->c_tracefunc))) + #define __Pyx_SetTracing(tstate, enable)\ + (tstate)->cframe->use_tracing = (enable) +#else + #define __Pyx_IsTracing(tstate, check_tracing, check_funcs)\ + (unlikely((tstate)->use_tracing) &&\ + (!(check_tracing) || !(tstate)->tracing) &&\ + (!(check_funcs) || (tstate)->c_profilefunc || (CYTHON_TRACE && (tstate)->c_tracefunc))) + #define __Pyx_SetTracing(tstate, enable)\ + (tstate)->use_tracing = (enable) +#endif + #ifdef WITH_THREAD + #define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error)\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + PyThreadState *tstate;\ + PyGILState_STATE state = PyGILState_Ensure();\ + tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 1, 1)) {\ + __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ + }\ + PyGILState_Release(state);\ + if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ + }\ + } else {\ + PyThreadState* tstate = PyThreadState_GET();\ + if (__Pyx_IsTracing(tstate, 1, 1)) {\ + __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ + if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ + }\ + } + #else + #define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error)\ + { PyThreadState* tstate = PyThreadState_GET();\ + if (__Pyx_IsTracing(tstate, 1, 1)) {\ + __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ + if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ + }\ + } + #endif + #define __Pyx_TraceException()\ + if (likely(!__Pyx_use_tracing)); else {\ + PyThreadState* tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 1)) {\ + tstate->tracing++;\ + __Pyx_SetTracing(tstate, 0);\ + PyObject *exc_info = __Pyx_GetExceptionTuple(tstate);\ + if (exc_info) {\ + if (CYTHON_TRACE && tstate->c_tracefunc)\ + tstate->c_tracefunc(\ + tstate->c_traceobj, __pyx_frame, PyTrace_EXCEPTION, exc_info);\ + tstate->c_profilefunc(\ + tstate->c_profileobj, __pyx_frame, PyTrace_EXCEPTION, exc_info);\ + Py_DECREF(exc_info);\ + }\ + __Pyx_SetTracing(tstate, 1);\ + tstate->tracing--;\ + }\ + } + static void __Pyx_call_return_trace_func(PyThreadState *tstate, PyFrameObject *frame, PyObject *result) { + PyObject *type, *value, *traceback; + __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); + tstate->tracing++; + __Pyx_SetTracing(tstate, 0); + if (CYTHON_TRACE && tstate->c_tracefunc) + tstate->c_tracefunc(tstate->c_traceobj, frame, PyTrace_RETURN, result); + if (tstate->c_profilefunc) + tstate->c_profilefunc(tstate->c_profileobj, frame, PyTrace_RETURN, result); + CYTHON_FRAME_DEL(frame); + __Pyx_SetTracing(tstate, 1); + tstate->tracing--; + __Pyx_ErrRestoreInState(tstate, type, value, traceback); + } + #ifdef WITH_THREAD + #define __Pyx_TraceReturn(result, nogil)\ + if (likely(!__Pyx_use_tracing)); else {\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + PyThreadState *tstate;\ + PyGILState_STATE state = PyGILState_Ensure();\ + tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ + }\ + PyGILState_Release(state);\ + }\ + } else {\ + PyThreadState* tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ + }\ + }\ + } + #else + #define __Pyx_TraceReturn(result, nogil)\ + if (likely(!__Pyx_use_tracing)); else {\ + PyThreadState* tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 0)) {\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ + }\ + } + #endif + static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno); + static int __Pyx_TraceSetupAndCall(PyCodeObject** code, PyFrameObject** frame, PyThreadState* tstate, const char *funcname, const char *srcfile, int firstlineno); +#else + #define __Pyx_TraceDeclarations + #define __Pyx_TraceFrameInit(codeobj) + #define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error) if ((1)); else goto_error; + #define __Pyx_TraceException() + #define __Pyx_TraceReturn(result, nogil) +#endif +#if CYTHON_TRACE + static int __Pyx_call_line_trace_func(PyThreadState *tstate, PyFrameObject *frame, int lineno) { + int ret; + PyObject *type, *value, *traceback; + __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); + __Pyx_PyFrame_SetLineNumber(frame, lineno); + tstate->tracing++; + __Pyx_SetTracing(tstate, 0); + ret = tstate->c_tracefunc(tstate->c_traceobj, frame, PyTrace_LINE, NULL); + __Pyx_SetTracing(tstate, 1); + tstate->tracing--; + if (likely(!ret)) { + __Pyx_ErrRestoreInState(tstate, type, value, traceback); + } else { + Py_XDECREF(type); + Py_XDECREF(value); + Py_XDECREF(traceback); + } + return ret; + } + #ifdef WITH_THREAD + #define __Pyx_TraceLine(lineno, nogil, goto_error)\ + if (likely(!__Pyx_use_tracing)); else {\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + int ret = 0;\ + PyThreadState *tstate;\ + PyGILState_STATE state = PyGILState_Ensure();\ + tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && __pyx_frame->f_trace) {\ + ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ + }\ + PyGILState_Release(state);\ + if (unlikely(ret)) goto_error;\ + }\ + } else {\ + PyThreadState* tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && __pyx_frame->f_trace) {\ + int ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ + if (unlikely(ret)) goto_error;\ + }\ + }\ + } + #else + #define __Pyx_TraceLine(lineno, nogil, goto_error)\ + if (likely(!__Pyx_use_tracing)); else {\ + PyThreadState* tstate = __Pyx_PyThreadState_Current;\ + if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && __pyx_frame->f_trace) {\ + int ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ + if (unlikely(ret)) goto_error;\ + }\ + } + #endif +#else + #define __Pyx_TraceLine(lineno, nogil, goto_error) if ((1)); else goto_error; +#endif + +/* ExtTypeTest.proto */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + +/* IsLittleEndian.proto */ +static CYTHON_INLINE int __Pyx_Is_Little_Endian(void); + +/* BufferFormatCheck.proto */ +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts); +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + __Pyx_TypeInfo* type); + +/* BufferGetAndValidate.proto */ +#define __Pyx_GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)\ + ((obj == Py_None || obj == NULL) ?\ + (__Pyx_ZeroBuffer(buf), 0) :\ + __Pyx__GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)) +static int __Pyx__GetBufferAndValidate(Py_buffer* buf, PyObject* obj, + __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack); +static void __Pyx_ZeroBuffer(Py_buffer* buf); +static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info); +static Py_ssize_t __Pyx_minusones[] = { -1, -1, -1, -1, -1, -1, -1, -1 }; +static Py_ssize_t __Pyx_zeros[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; + +/* BufferFallbackError.proto */ +static void __Pyx_RaiseBufferFallbackError(void); + /* RaiseArgTupleInvalid.proto */ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); @@ -1336,6 +1555,11 @@ static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ const char* function_name); +/* WriteUnraisableException.proto */ +static void __Pyx_WriteUnraisable(const char *name, int clineno, + int lineno, const char *filename, + int full_traceback, int nogil); + /* PyObjectGetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); @@ -1746,22 +1970,22 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_6uvec_np_to_arma_to_np(CYTHON static PyObject *__pyx_pf_7l0learn_13testing_utils_8dvec_np_to_arma_to_np(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x); /* proto */ static PyObject *__pyx_pf_7l0learn_13testing_utils_10sp_dmat_np_to_arma_to_np(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x); /* proto */ static PyObject *__pyx_pf_7l0learn_13testing_utils_12dmat_dot_dmat(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x, PyObject *__pyx_v_y); /* proto */ -static PyObject *__pyx_tuple_; -static PyObject *__pyx_tuple__2; -static PyObject *__pyx_tuple__3; -static PyObject *__pyx_tuple__5; -static PyObject *__pyx_tuple__7; +static PyObject *__pyx_codeobj_; +static PyObject *__pyx_tuple__8; static PyObject *__pyx_tuple__9; +static PyObject *__pyx_tuple__10; static PyObject *__pyx_tuple__11; +static PyObject *__pyx_tuple__12; static PyObject *__pyx_tuple__13; +static PyObject *__pyx_tuple__14; static PyObject *__pyx_tuple__15; +static PyObject *__pyx_tuple__16; +static PyObject *__pyx_codeobj__2; +static PyObject *__pyx_codeobj__3; static PyObject *__pyx_codeobj__4; +static PyObject *__pyx_codeobj__5; static PyObject *__pyx_codeobj__6; -static PyObject *__pyx_codeobj__8; -static PyObject *__pyx_codeobj__10; -static PyObject *__pyx_codeobj__12; -static PyObject *__pyx_codeobj__14; -static PyObject *__pyx_codeobj__16; +static PyObject *__pyx_codeobj__7; /* Late includes */ /* "l0learn/testing_utils.pyx":11 @@ -1789,12 +2013,15 @@ static PyObject *__pyx_pw_7l0learn_13testing_utils_1list_csc_to_arma_csc_to_list static PyObject *__pyx_pf_7l0learn_13testing_utils_list_csc_to_arma_csc_to_list(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x) { PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj_) __Pyx_RefNannySetupContext("list_csc_to_arma_csc_to_list", 0); + __Pyx_TraceCall("list_csc_to_arma_csc_to_list", __pyx_f[0], 11, 0, __PYX_ERR(0, 11, __pyx_L1_error)); /* "l0learn/testing_utils.pyx":12 * @@ -1803,6 +2030,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_list_csc_to_arma_csc_to_list( * * */ + __Pyx_TraceLine(12,0,__PYX_ERR(0, 12, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); if (!(likely(PyList_CheckExact(__pyx_v_x))||((__pyx_v_x) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_x)->tp_name), 0))) __PYX_ERR(0, 12, __pyx_L1_error) __pyx_t_1 = __pyx_f_7l0learn_13testing_utils_c_list_csc_to_arma_csc_to_list(((PyObject*)__pyx_v_x)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error) @@ -1826,6 +2054,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_list_csc_to_arma_csc_to_list( __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -1842,12 +2071,14 @@ static PyObject *__pyx_f_7l0learn_13testing_utils_c_list_csc_to_arma_csc_to_list arma::field __pyx_v_f; PyObject *__pyx_v_lst = 0; PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("c_list_csc_to_arma_csc_to_list", 0); + __Pyx_TraceCall("c_list_csc_to_arma_csc_to_list", __pyx_f[0], 15, 0, __PYX_ERR(0, 15, __pyx_L1_error)); /* "l0learn/testing_utils.pyx":16 * @@ -1856,6 +2087,7 @@ static PyObject *__pyx_f_7l0learn_13testing_utils_c_list_csc_to_arma_csc_to_list * cdef lst = sp_dmat_field_to_list(f) * return lst */ + __Pyx_TraceLine(16,0,__PYX_ERR(0, 16, __pyx_L1_error)) __pyx_v_f = __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_field(__pyx_v_x); /* "l0learn/testing_utils.pyx":17 @@ -1865,6 +2097,7 @@ static PyObject *__pyx_f_7l0learn_13testing_utils_c_list_csc_to_arma_csc_to_list * return lst * */ + __Pyx_TraceLine(17,0,__PYX_ERR(0, 17, __pyx_L1_error)) __pyx_t_1 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_f); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_lst = __pyx_t_1; @@ -1877,6 +2110,7 @@ static PyObject *__pyx_f_7l0learn_13testing_utils_c_list_csc_to_arma_csc_to_list * * */ + __Pyx_TraceLine(18,0,__PYX_ERR(0, 18, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); if (!(likely(PyList_CheckExact(__pyx_v_lst))||((__pyx_v_lst) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_lst)->tp_name), 0))) __PYX_ERR(0, 18, __pyx_L1_error) __Pyx_INCREF(__pyx_v_lst); @@ -1899,6 +2133,7 @@ static PyObject *__pyx_f_7l0learn_13testing_utils_c_list_csc_to_arma_csc_to_list __pyx_L0:; __Pyx_XDECREF(__pyx_v_lst); __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -1928,12 +2163,15 @@ static PyObject *__pyx_pw_7l0learn_13testing_utils_3list_dvec_to_arma_dvec_to_li static PyObject *__pyx_pf_7l0learn_13testing_utils_2list_dvec_to_arma_dvec_to_list(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x) { PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__2) __Pyx_RefNannySetupContext("list_dvec_to_arma_dvec_to_list", 0); + __Pyx_TraceCall("list_dvec_to_arma_dvec_to_list", __pyx_f[0], 21, 0, __PYX_ERR(0, 21, __pyx_L1_error)); /* "l0learn/testing_utils.pyx":22 * @@ -1942,6 +2180,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_2list_dvec_to_arma_dvec_to_li * * */ + __Pyx_TraceLine(22,0,__PYX_ERR(0, 22, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); if (!(likely(PyList_CheckExact(__pyx_v_x))||((__pyx_v_x) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_x)->tp_name), 0))) __PYX_ERR(0, 22, __pyx_L1_error) __pyx_t_1 = __pyx_f_7l0learn_13testing_utils_c_list_dvec_to_arma_dvec_to_list(((PyObject*)__pyx_v_x)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error) @@ -1965,6 +2204,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_2list_dvec_to_arma_dvec_to_li __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -1981,12 +2221,14 @@ static PyObject *__pyx_f_7l0learn_13testing_utils_c_list_dvec_to_arma_dvec_to_li arma::field __pyx_v_f; PyObject *__pyx_v_lst = 0; PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("c_list_dvec_to_arma_dvec_to_list", 0); + __Pyx_TraceCall("c_list_dvec_to_arma_dvec_to_list", __pyx_f[0], 25, 0, __PYX_ERR(0, 25, __pyx_L1_error)); /* "l0learn/testing_utils.pyx":26 * @@ -1995,6 +2237,7 @@ static PyObject *__pyx_f_7l0learn_13testing_utils_c_list_dvec_to_arma_dvec_to_li * cdef lst = dvec_field_to_list(f) * return lst */ + __Pyx_TraceLine(26,0,__PYX_ERR(0, 26, __pyx_L1_error)) __pyx_v_f = __pyx_f_7l0learn_6cyarma_list_to_dvec_field(__pyx_v_x); /* "l0learn/testing_utils.pyx":27 @@ -2004,6 +2247,7 @@ static PyObject *__pyx_f_7l0learn_13testing_utils_c_list_dvec_to_arma_dvec_to_li * return lst * */ + __Pyx_TraceLine(27,0,__PYX_ERR(0, 27, __pyx_L1_error)) __pyx_t_1 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_f); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 27, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_lst = __pyx_t_1; @@ -2016,6 +2260,7 @@ static PyObject *__pyx_f_7l0learn_13testing_utils_c_list_dvec_to_arma_dvec_to_li * * */ + __Pyx_TraceLine(28,0,__PYX_ERR(0, 28, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); if (!(likely(PyList_CheckExact(__pyx_v_lst))||((__pyx_v_lst) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_v_lst)->tp_name), 0))) __PYX_ERR(0, 28, __pyx_L1_error) __Pyx_INCREF(__pyx_v_lst); @@ -2038,6 +2283,7 @@ static PyObject *__pyx_f_7l0learn_13testing_utils_c_list_dvec_to_arma_dvec_to_li __pyx_L0:; __Pyx_XDECREF(__pyx_v_lst); __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2070,6 +2316,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_4dmat_np_to_arma_to_np(CYTHON __Pyx_LocalBuf_ND __pyx_pybuffernd_x_pass; __Pyx_Buffer __pyx_pybuffer_x_pass; PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; @@ -2079,7 +2326,9 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_4dmat_np_to_arma_to_np(CYTHON int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__3) __Pyx_RefNannySetupContext("dmat_np_to_arma_to_np", 0); + __Pyx_TraceCall("dmat_np_to_arma_to_np", __pyx_f[0], 31, 0, __PYX_ERR(0, 31, __pyx_L1_error)); __pyx_pybuffer_x_pass.pybuffer.buf = NULL; __pyx_pybuffer_x_pass.refcount = 0; __pyx_pybuffernd_x_pass.data = NULL; @@ -2092,6 +2341,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_4dmat_np_to_arma_to_np(CYTHON * * return x_pass */ + __Pyx_TraceLine(33,0,__PYX_ERR(0, 33, __pyx_L1_error)) if (!(likely(((__pyx_v_x) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_x, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 33, __pyx_L1_error) __pyx_t_1 = ((PyObject *)__pyx_f_7l0learn_13testing_utils_c_dmat_np_to_arma_to_np(((PyArrayObject *)__pyx_v_x))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -2122,6 +2372,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_4dmat_np_to_arma_to_np(CYTHON * * */ + __Pyx_TraceLine(35,0,__PYX_ERR(0, 35, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_x_pass)); __pyx_r = ((PyObject *)__pyx_v_x_pass); @@ -2152,6 +2403,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_4dmat_np_to_arma_to_np(CYTHON __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_x_pass); __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2172,12 +2424,14 @@ static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_dmat_np_to_arma_to_np(P __Pyx_LocalBuf_ND __pyx_pybuffernd_x; __Pyx_Buffer __pyx_pybuffer_x; PyArrayObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("c_dmat_np_to_arma_to_np", 0); + __Pyx_TraceCall("c_dmat_np_to_arma_to_np", __pyx_f[0], 38, 0, __PYX_ERR(0, 38, __pyx_L1_error)); __pyx_pybuffer_np_x.pybuffer.buf = NULL; __pyx_pybuffer_np_x.refcount = 0; __pyx_pybuffernd_np_x.data = NULL; @@ -2199,6 +2453,7 @@ static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_dmat_np_to_arma_to_np(P * * cdef np.ndarray[np.double_t, ndim=2] np_x = dmat_to_numpy(arma_x, None) */ + __Pyx_TraceLine(39,0,__PYX_ERR(0, 39, __pyx_L1_error)) __pyx_v_arma_x = __pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_x)); /* "l0learn/testing_utils.pyx":41 @@ -2208,6 +2463,7 @@ static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_dmat_np_to_arma_to_np(P * * return np_x */ + __Pyx_TraceLine(41,0,__PYX_ERR(0, 41, __pyx_L1_error)) __pyx_t_1 = ((PyObject *)__pyx_f_7l0learn_6cyarma_dmat_to_numpy(__pyx_v_arma_x, ((PyArrayObject *)Py_None))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 41, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); { @@ -2228,6 +2484,7 @@ static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_dmat_np_to_arma_to_np(P * * */ + __Pyx_TraceLine(43,0,__PYX_ERR(0, 43, __pyx_L1_error)) __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v_np_x)); __pyx_r = ((PyArrayObject *)__pyx_v_np_x); @@ -2260,6 +2517,7 @@ static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_dmat_np_to_arma_to_np(P __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_np_x); __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2292,6 +2550,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_6uvec_np_to_arma_to_np(CYTHON __Pyx_LocalBuf_ND __pyx_pybuffernd_x_pass; __Pyx_Buffer __pyx_pybuffer_x_pass; PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; @@ -2301,7 +2560,9 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_6uvec_np_to_arma_to_np(CYTHON int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__4) __Pyx_RefNannySetupContext("uvec_np_to_arma_to_np", 0); + __Pyx_TraceCall("uvec_np_to_arma_to_np", __pyx_f[0], 46, 0, __PYX_ERR(0, 46, __pyx_L1_error)); __pyx_pybuffer_x_pass.pybuffer.buf = NULL; __pyx_pybuffer_x_pass.refcount = 0; __pyx_pybuffernd_x_pass.data = NULL; @@ -2314,6 +2575,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_6uvec_np_to_arma_to_np(CYTHON * * return x_pass */ + __Pyx_TraceLine(48,0,__PYX_ERR(0, 48, __pyx_L1_error)) if (!(likely(((__pyx_v_x) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_x, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 48, __pyx_L1_error) __pyx_t_1 = ((PyObject *)__pyx_f_7l0learn_13testing_utils_c_uvec_np_to_arma_to_np(((PyArrayObject *)__pyx_v_x))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 48, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -2344,6 +2606,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_6uvec_np_to_arma_to_np(CYTHON * * */ + __Pyx_TraceLine(50,0,__PYX_ERR(0, 50, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_x_pass)); __pyx_r = ((PyObject *)__pyx_v_x_pass); @@ -2374,6 +2637,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_6uvec_np_to_arma_to_np(CYTHON __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_x_pass); __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2394,12 +2658,14 @@ static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_uvec_np_to_arma_to_np(P __Pyx_LocalBuf_ND __pyx_pybuffernd_x; __Pyx_Buffer __pyx_pybuffer_x; PyArrayObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("c_uvec_np_to_arma_to_np", 0); + __Pyx_TraceCall("c_uvec_np_to_arma_to_np", __pyx_f[0], 53, 0, __PYX_ERR(0, 53, __pyx_L1_error)); __pyx_pybuffer_np_x.pybuffer.buf = NULL; __pyx_pybuffer_np_x.refcount = 0; __pyx_pybuffernd_np_x.data = NULL; @@ -2421,6 +2687,7 @@ static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_uvec_np_to_arma_to_np(P * * cdef np.ndarray[np.uint64_t, ndim=1] np_x = uvec_to_numpy(arma_x, None) */ + __Pyx_TraceLine(54,0,__PYX_ERR(0, 54, __pyx_L1_error)) __pyx_v_arma_x = __pyx_f_7l0learn_6cyarma_numpy_to_uvec_d(((PyArrayObject *)__pyx_v_x)); /* "l0learn/testing_utils.pyx":56 @@ -2430,6 +2697,7 @@ static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_uvec_np_to_arma_to_np(P * * return np_x */ + __Pyx_TraceLine(56,0,__PYX_ERR(0, 56, __pyx_L1_error)) __pyx_t_1 = ((PyObject *)__pyx_f_7l0learn_6cyarma_uvec_to_numpy(__pyx_v_arma_x, ((PyArrayObject *)Py_None))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 56, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); { @@ -2450,6 +2718,7 @@ static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_uvec_np_to_arma_to_np(P * * */ + __Pyx_TraceLine(58,0,__PYX_ERR(0, 58, __pyx_L1_error)) __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v_np_x)); __pyx_r = ((PyArrayObject *)__pyx_v_np_x); @@ -2482,6 +2751,7 @@ static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_uvec_np_to_arma_to_np(P __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_np_x); __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2514,6 +2784,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_8dvec_np_to_arma_to_np(CYTHON __Pyx_LocalBuf_ND __pyx_pybuffernd_x_pass; __Pyx_Buffer __pyx_pybuffer_x_pass; PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; @@ -2523,7 +2794,9 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_8dvec_np_to_arma_to_np(CYTHON int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__5) __Pyx_RefNannySetupContext("dvec_np_to_arma_to_np", 0); + __Pyx_TraceCall("dvec_np_to_arma_to_np", __pyx_f[0], 61, 0, __PYX_ERR(0, 61, __pyx_L1_error)); __pyx_pybuffer_x_pass.pybuffer.buf = NULL; __pyx_pybuffer_x_pass.refcount = 0; __pyx_pybuffernd_x_pass.data = NULL; @@ -2536,6 +2809,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_8dvec_np_to_arma_to_np(CYTHON * * return x_pass */ + __Pyx_TraceLine(63,0,__PYX_ERR(0, 63, __pyx_L1_error)) if (!(likely(((__pyx_v_x) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_x, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 63, __pyx_L1_error) __pyx_t_1 = ((PyObject *)__pyx_f_7l0learn_13testing_utils_c_dvec_np_to_arma_to_np(((PyArrayObject *)__pyx_v_x))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 63, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -2566,6 +2840,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_8dvec_np_to_arma_to_np(CYTHON * * */ + __Pyx_TraceLine(65,0,__PYX_ERR(0, 65, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_x_pass)); __pyx_r = ((PyObject *)__pyx_v_x_pass); @@ -2596,6 +2871,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_8dvec_np_to_arma_to_np(CYTHON __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_x_pass); __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2616,12 +2892,14 @@ static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_dvec_np_to_arma_to_np(P __Pyx_LocalBuf_ND __pyx_pybuffernd_x; __Pyx_Buffer __pyx_pybuffer_x; PyArrayObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("c_dvec_np_to_arma_to_np", 0); + __Pyx_TraceCall("c_dvec_np_to_arma_to_np", __pyx_f[0], 68, 0, __PYX_ERR(0, 68, __pyx_L1_error)); __pyx_pybuffer_np_x.pybuffer.buf = NULL; __pyx_pybuffer_np_x.refcount = 0; __pyx_pybuffernd_np_x.data = NULL; @@ -2643,6 +2921,7 @@ static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_dvec_np_to_arma_to_np(P * * cdef np.ndarray[np.double_t, ndim=1] np_x = dvec_to_numpy(arma_x, None) */ + __Pyx_TraceLine(69,0,__PYX_ERR(0, 69, __pyx_L1_error)) __pyx_v_arma_x = __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_x)); /* "l0learn/testing_utils.pyx":71 @@ -2652,6 +2931,7 @@ static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_dvec_np_to_arma_to_np(P * * return np_x */ + __Pyx_TraceLine(71,0,__PYX_ERR(0, 71, __pyx_L1_error)) __pyx_t_1 = ((PyObject *)__pyx_f_7l0learn_6cyarma_dvec_to_numpy(__pyx_v_arma_x, ((PyArrayObject *)Py_None))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 71, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); { @@ -2672,6 +2952,7 @@ static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_dvec_np_to_arma_to_np(P * * */ + __Pyx_TraceLine(73,0,__PYX_ERR(0, 73, __pyx_L1_error)) __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v_np_x)); __pyx_r = ((PyArrayObject *)__pyx_v_np_x); @@ -2704,6 +2985,7 @@ static PyArrayObject *__pyx_f_7l0learn_13testing_utils_c_dvec_np_to_arma_to_np(P __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_np_x); __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2733,12 +3015,15 @@ static PyObject *__pyx_pw_7l0learn_13testing_utils_11sp_dmat_np_to_arma_to_np(Py static PyObject *__pyx_pf_7l0learn_13testing_utils_10sp_dmat_np_to_arma_to_np(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x) { PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__6) __Pyx_RefNannySetupContext("sp_dmat_np_to_arma_to_np", 0); + __Pyx_TraceCall("sp_dmat_np_to_arma_to_np", __pyx_f[0], 76, 0, __PYX_ERR(0, 76, __pyx_L1_error)); /* "l0learn/testing_utils.pyx":77 * @@ -2747,6 +3032,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_10sp_dmat_np_to_arma_to_np(CY * * */ + __Pyx_TraceLine(77,0,__PYX_ERR(0, 77, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_f_7l0learn_13testing_utils_c_sp_dmat_np_to_arma_to_np(__pyx_v_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -2769,6 +3055,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_10sp_dmat_np_to_arma_to_np(CY __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2785,12 +3072,14 @@ static PyObject *__pyx_f_7l0learn_13testing_utils_c_sp_dmat_np_to_arma_to_np(PyO arma::sp_dmat __pyx_v_arma_x; PyObject *__pyx_v_np_x = NULL; PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("c_sp_dmat_np_to_arma_to_np", 0); + __Pyx_TraceCall("c_sp_dmat_np_to_arma_to_np", __pyx_f[0], 80, 0, __PYX_ERR(0, 80, __pyx_L1_error)); /* "l0learn/testing_utils.pyx":81 * @@ -2799,6 +3088,7 @@ static PyObject *__pyx_f_7l0learn_13testing_utils_c_sp_dmat_np_to_arma_to_np(PyO * * np_x = sp_dmat_to_numpy(arma_x, None, None, None) */ + __Pyx_TraceLine(81,0,__PYX_ERR(0, 81, __pyx_L1_error)) __pyx_v_arma_x = __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(__pyx_v_x); /* "l0learn/testing_utils.pyx":83 @@ -2808,6 +3098,7 @@ static PyObject *__pyx_f_7l0learn_13testing_utils_c_sp_dmat_np_to_arma_to_np(PyO * return np_x * */ + __Pyx_TraceLine(83,0,__PYX_ERR(0, 83, __pyx_L1_error)) __pyx_t_1 = __pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(__pyx_v_arma_x, ((PyArrayObject *)Py_None), ((PyArrayObject *)Py_None), ((PyArrayObject *)Py_None)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 83, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_np_x = __pyx_t_1; @@ -2820,6 +3111,7 @@ static PyObject *__pyx_f_7l0learn_13testing_utils_c_sp_dmat_np_to_arma_to_np(PyO * * */ + __Pyx_TraceLine(84,0,__PYX_ERR(0, 84, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_np_x); __pyx_r = __pyx_v_np_x; @@ -2841,6 +3133,7 @@ static PyObject *__pyx_f_7l0learn_13testing_utils_c_sp_dmat_np_to_arma_to_np(PyO __pyx_L0:; __Pyx_XDECREF(__pyx_v_np_x); __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2927,12 +3220,15 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_12dmat_dot_dmat(CYTHON_UNUSED __Pyx_LocalBuf_ND __pyx_pybuffernd_np_xy; __Pyx_Buffer __pyx_pybuffer_np_xy; PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; + __Pyx_TraceFrameInit(__pyx_codeobj__7) __Pyx_RefNannySetupContext("dmat_dot_dmat", 0); + __Pyx_TraceCall("dmat_dot_dmat", __pyx_f[0], 87, 0, __PYX_ERR(0, 87, __pyx_L1_error)); __pyx_pybuffer_np_xy.pybuffer.buf = NULL; __pyx_pybuffer_np_xy.refcount = 0; __pyx_pybuffernd_np_xy.data = NULL; @@ -2945,6 +3241,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_12dmat_dot_dmat(CYTHON_UNUSED * cdef dmat arma_y = numpy_to_dmat_d(y) * */ + __Pyx_TraceLine(88,0,__PYX_ERR(0, 88, __pyx_L1_error)) if (!(likely(((__pyx_v_x) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_x, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 88, __pyx_L1_error) __pyx_v_arma_x = __pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_x)); @@ -2955,6 +3252,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_12dmat_dot_dmat(CYTHON_UNUSED * * cdef dmat arma_xy = c_dmat_dot_dmat(arma_x, arma_y) */ + __Pyx_TraceLine(89,0,__PYX_ERR(0, 89, __pyx_L1_error)) if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 89, __pyx_L1_error) __pyx_v_arma_y = __pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_y)); @@ -2965,6 +3263,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_12dmat_dot_dmat(CYTHON_UNUSED * * cdef np.ndarray[np.double_t, ndim=2] np_xy = dmat_to_numpy(arma_xy, None) */ + __Pyx_TraceLine(91,0,__PYX_ERR(0, 91, __pyx_L1_error)) __pyx_v_arma_xy = __pyx_f_7l0learn_13testing_utils_c_dmat_dot_dmat(__pyx_v_arma_x, __pyx_v_arma_y); /* "l0learn/testing_utils.pyx":93 @@ -2974,6 +3273,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_12dmat_dot_dmat(CYTHON_UNUSED * * return np_xy */ + __Pyx_TraceLine(93,0,__PYX_ERR(0, 93, __pyx_L1_error)) __pyx_t_1 = ((PyObject *)__pyx_f_7l0learn_6cyarma_dmat_to_numpy(__pyx_v_arma_xy, ((PyArrayObject *)Py_None))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 93, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); { @@ -2994,6 +3294,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_12dmat_dot_dmat(CYTHON_UNUSED * * */ + __Pyx_TraceLine(95,0,__PYX_ERR(0, 95, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_np_xy)); __pyx_r = ((PyObject *)__pyx_v_np_xy); @@ -3024,6 +3325,7 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_12dmat_dot_dmat(CYTHON_UNUSED __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_np_xy); __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3039,8 +3341,13 @@ static PyObject *__pyx_pf_7l0learn_13testing_utils_12dmat_dot_dmat(CYTHON_UNUSED static arma::dmat __pyx_f_7l0learn_13testing_utils_c_dmat_dot_dmat(arma::dmat __pyx_v_arma_x, arma::dmat __pyx_v_arma_y) { arma::dmat __pyx_v_arma_xy; arma::dmat __pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("c_dmat_dot_dmat", 0); + __Pyx_TraceCall("c_dmat_dot_dmat", __pyx_f[0], 98, 0, __PYX_ERR(0, 98, __pyx_L1_error)); /* "l0learn/testing_utils.pyx":99 * @@ -3049,6 +3356,7 @@ static arma::dmat __pyx_f_7l0learn_13testing_utils_c_dmat_dot_dmat(arma::dmat __ * * return arma_xy */ + __Pyx_TraceLine(99,0,__PYX_ERR(0, 99, __pyx_L1_error)) __pyx_v_arma_xy = (__pyx_v_arma_x * __pyx_v_arma_y); /* "l0learn/testing_utils.pyx":101 @@ -3056,6 +3364,7 @@ static arma::dmat __pyx_f_7l0learn_13testing_utils_c_dmat_dot_dmat(arma::dmat __ * * return arma_xy # <<<<<<<<<<<<<< */ + __Pyx_TraceLine(101,0,__PYX_ERR(0, 101, __pyx_L1_error)) __pyx_r = __pyx_v_arma_xy; goto __pyx_L0; @@ -3068,7 +3377,11 @@ static arma::dmat __pyx_f_7l0learn_13testing_utils_c_dmat_dot_dmat(arma::dmat __ */ /* function exit code */ + __pyx_L1_error:; + __Pyx_WriteUnraisable("l0learn.testing_utils.c_dmat_dot_dmat", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __Pyx_pretend_to_initialize(&__pyx_r); __pyx_L0:; + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3083,12 +3396,14 @@ static arma::dmat __pyx_f_7l0learn_13testing_utils_c_dmat_dot_dmat(arma::dmat __ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); + __Pyx_TraceCall("PyArray_MultiIterNew1", __pyx_f[1], 735, 0, __PYX_ERR(1, 735, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":736 * @@ -3097,6 +3412,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ * * cdef inline object PyArray_MultiIterNew2(a, b): */ + __Pyx_TraceLine(736,0,__PYX_ERR(1, 736, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 736, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -3119,6 +3435,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3133,12 +3450,14 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); + __Pyx_TraceCall("PyArray_MultiIterNew2", __pyx_f[1], 738, 0, __PYX_ERR(1, 738, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":739 * @@ -3147,6 +3466,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ * * cdef inline object PyArray_MultiIterNew3(a, b, c): */ + __Pyx_TraceLine(739,0,__PYX_ERR(1, 739, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 739, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -3169,6 +3489,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3183,12 +3504,14 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); + __Pyx_TraceCall("PyArray_MultiIterNew3", __pyx_f[1], 741, 0, __PYX_ERR(1, 741, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":742 * @@ -3197,6 +3520,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): */ + __Pyx_TraceLine(742,0,__PYX_ERR(1, 742, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 742, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -3219,6 +3543,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3233,12 +3558,14 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); + __Pyx_TraceCall("PyArray_MultiIterNew4", __pyx_f[1], 744, 0, __PYX_ERR(1, 744, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":745 * @@ -3247,6 +3574,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): */ + __Pyx_TraceLine(745,0,__PYX_ERR(1, 745, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 745, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -3269,6 +3597,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3283,12 +3612,14 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); + __Pyx_TraceCall("PyArray_MultiIterNew5", __pyx_f[1], 747, 0, __PYX_ERR(1, 747, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":748 * @@ -3297,6 +3628,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ * * cdef inline tuple PyDataType_SHAPE(dtype d): */ + __Pyx_TraceLine(748,0,__PYX_ERR(1, 748, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 748, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -3319,6 +3651,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3333,9 +3666,14 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); + __Pyx_TraceCall("PyDataType_SHAPE", __pyx_f[1], 750, 0, __PYX_ERR(1, 750, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":751 * @@ -3344,6 +3682,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ * return d.subarray.shape * else: */ + __Pyx_TraceLine(751,0,__PYX_ERR(1, 751, __pyx_L1_error)) __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); if (__pyx_t_1) { @@ -3354,6 +3693,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ * else: * return () */ + __Pyx_TraceLine(752,0,__PYX_ERR(1, 752, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); @@ -3375,6 +3715,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ * * */ + __Pyx_TraceLine(754,0,__PYX_ERR(1, 754, __pyx_L1_error)) /*else*/ { __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_empty_tuple); @@ -3391,8 +3732,12 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ */ /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("numpy.PyDataType_SHAPE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3406,8 +3751,13 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ */ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("set_array_base", 0); + __Pyx_TraceCall("set_array_base", __pyx_f[1], 929, 0, __PYX_ERR(1, 929, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":930 * @@ -3416,6 +3766,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a * PyArray_SetBaseObject(arr, base) * */ + __Pyx_TraceLine(930,0,__PYX_ERR(1, 930, __pyx_L1_error)) Py_INCREF(__pyx_v_base); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":931 @@ -3425,6 +3776,7 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a * * cdef inline object get_array_base(ndarray arr): */ + __Pyx_TraceLine(931,0,__PYX_ERR(1, 931, __pyx_L1_error)) (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":929 @@ -3436,6 +3788,11 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a */ /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_WriteUnraisable("numpy.set_array_base", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_L0:; + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); } @@ -3450,9 +3807,14 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { PyObject *__pyx_v_base; PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_array_base", 0); + __Pyx_TraceCall("get_array_base", __pyx_f[1], 933, 0, __PYX_ERR(1, 933, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":934 * @@ -3461,6 +3823,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py * if base is NULL: * return None */ + __Pyx_TraceLine(934,0,__PYX_ERR(1, 934, __pyx_L1_error)) __pyx_v_base = PyArray_BASE(__pyx_v_arr); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":935 @@ -3470,6 +3833,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py * return None * return base */ + __Pyx_TraceLine(935,0,__PYX_ERR(1, 935, __pyx_L1_error)) __pyx_t_1 = ((__pyx_v_base == NULL) != 0); if (__pyx_t_1) { @@ -3480,6 +3844,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py * return base * */ + __Pyx_TraceLine(936,0,__PYX_ERR(1, 936, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; @@ -3500,6 +3865,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py * * # Versions of the import_* functions which are more suitable for */ + __Pyx_TraceLine(937,0,__PYX_ERR(1, 937, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_base)); __pyx_r = ((PyObject *)__pyx_v_base); @@ -3514,8 +3880,12 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py */ /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("numpy.get_array_base", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3530,6 +3900,7 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { int __pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; @@ -3543,6 +3914,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_array", 0); + __Pyx_TraceCall("import_array", __pyx_f[1], 941, 0, __PYX_ERR(1, 941, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":942 * # Cython code. @@ -3551,6 +3923,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { * __pyx_import_array() * except Exception: */ + __Pyx_TraceLine(942,0,__PYX_ERR(1, 942, __pyx_L1_error)) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign @@ -3567,6 +3940,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { * except Exception: * raise ImportError("numpy.core.multiarray failed to import") */ + __Pyx_TraceLine(943,0,__PYX_ERR(1, 943, __pyx_L3_error)) __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 943, __pyx_L3_error) /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":942 @@ -3590,6 +3964,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { * raise ImportError("numpy.core.multiarray failed to import") * */ + __Pyx_TraceLine(944,0,__PYX_ERR(1, 944, __pyx_L5_except_error)) __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); @@ -3605,7 +3980,8 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { * * cdef inline int import_umath() except -1: */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 945, __pyx_L5_except_error) + __Pyx_TraceLine(945,0,__PYX_ERR(1, 945, __pyx_L5_except_error)) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 945, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; @@ -3648,6 +4024,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3662,6 +4039,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { int __pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; @@ -3675,6 +4053,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_umath", 0); + __Pyx_TraceCall("import_umath", __pyx_f[1], 947, 0, __PYX_ERR(1, 947, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":948 * @@ -3683,6 +4062,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { * _import_umath() * except Exception: */ + __Pyx_TraceLine(948,0,__PYX_ERR(1, 948, __pyx_L1_error)) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign @@ -3699,6 +4079,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { * except Exception: * raise ImportError("numpy.core.umath failed to import") */ + __Pyx_TraceLine(949,0,__PYX_ERR(1, 949, __pyx_L3_error)) __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 949, __pyx_L3_error) /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":948 @@ -3722,6 +4103,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { * raise ImportError("numpy.core.umath failed to import") * */ + __Pyx_TraceLine(950,0,__PYX_ERR(1, 950, __pyx_L5_except_error)) __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); @@ -3737,7 +4119,8 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { * * cdef inline int import_ufunc() except -1: */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 951, __pyx_L5_except_error) + __Pyx_TraceLine(951,0,__PYX_ERR(1, 951, __pyx_L5_except_error)) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 951, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; @@ -3780,6 +4163,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3794,6 +4178,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { int __pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; @@ -3807,6 +4192,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_ufunc", 0); + __Pyx_TraceCall("import_ufunc", __pyx_f[1], 953, 0, __PYX_ERR(1, 953, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":954 * @@ -3815,6 +4201,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { * _import_umath() * except Exception: */ + __Pyx_TraceLine(954,0,__PYX_ERR(1, 954, __pyx_L1_error)) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign @@ -3831,6 +4218,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { * except Exception: * raise ImportError("numpy.core.umath failed to import") */ + __Pyx_TraceLine(955,0,__PYX_ERR(1, 955, __pyx_L3_error)) __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 955, __pyx_L3_error) /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":954 @@ -3854,6 +4242,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { * raise ImportError("numpy.core.umath failed to import") * */ + __Pyx_TraceLine(956,0,__PYX_ERR(1, 956, __pyx_L5_except_error)) __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); @@ -3869,7 +4258,8 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { * * cdef extern from *: */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 957, __pyx_L5_except_error) + __Pyx_TraceLine(957,0,__PYX_ERR(1, 957, __pyx_L5_except_error)) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 957, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; @@ -3912,6 +4302,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3926,8 +4317,13 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_obj) { int __pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("is_timedelta64_object", 0); + __Pyx_TraceCall("is_timedelta64_object", __pyx_f[1], 967, 0, __PYX_ERR(1, 967, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":979 * bool @@ -3936,6 +4332,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_ * * */ + __Pyx_TraceLine(979,0,__PYX_ERR(1, 979, __pyx_L1_error)) __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyTimedeltaArrType_Type)); goto __pyx_L0; @@ -3948,7 +4345,11 @@ static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_ */ /* function exit code */ + __pyx_L1_error:; + __Pyx_WriteUnraisable("numpy.is_timedelta64_object", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; __pyx_L0:; + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3963,8 +4364,13 @@ static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_ static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_obj) { int __pyx_r; + __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; __Pyx_RefNannySetupContext("is_datetime64_object", 0); + __Pyx_TraceCall("is_datetime64_object", __pyx_f[1], 982, 0, __PYX_ERR(1, 982, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":994 * bool @@ -3973,6 +4379,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_o * * */ + __Pyx_TraceLine(994,0,__PYX_ERR(1, 994, __pyx_L1_error)) __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyDatetimeArrType_Type)); goto __pyx_L0; @@ -3985,7 +4392,11 @@ static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_o */ /* function exit code */ + __pyx_L1_error:; + __Pyx_WriteUnraisable("numpy.is_datetime64_object", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; __pyx_L0:; + __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -4000,6 +4411,11 @@ static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_o static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject *__pyx_v_obj) { npy_datetime __pyx_r; + __Pyx_TraceDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceCall("get_datetime64_value", __pyx_f[1], 997, 1, __PYX_ERR(1, 997, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1004 * also needed. That can be found using `get_datetime64_unit`. @@ -4008,6 +4424,7 @@ static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject * * * */ + __Pyx_TraceLine(1004,1,__PYX_ERR(1, 1004, __pyx_L1_error)) __pyx_r = ((PyDatetimeScalarObject *)__pyx_v_obj)->obval; goto __pyx_L0; @@ -4020,7 +4437,11 @@ static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject * */ /* function exit code */ + __pyx_L1_error:; + __Pyx_WriteUnraisable("numpy.get_datetime64_value", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1); + __pyx_r = 0; __pyx_L0:; + __Pyx_TraceReturn(Py_None, 1); return __pyx_r; } @@ -4034,6 +4455,11 @@ static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject * static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject *__pyx_v_obj) { npy_timedelta __pyx_r; + __Pyx_TraceDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceCall("get_timedelta64_value", __pyx_f[1], 1007, 1, __PYX_ERR(1, 1007, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1011 * returns the int64 value underlying scalar numpy timedelta64 object @@ -4042,6 +4468,7 @@ static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject * * */ + __Pyx_TraceLine(1011,1,__PYX_ERR(1, 1011, __pyx_L1_error)) __pyx_r = ((PyTimedeltaScalarObject *)__pyx_v_obj)->obval; goto __pyx_L0; @@ -4054,7 +4481,11 @@ static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject */ /* function exit code */ + __pyx_L1_error:; + __Pyx_WriteUnraisable("numpy.get_timedelta64_value", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1); + __pyx_r = 0; __pyx_L0:; + __Pyx_TraceReturn(Py_None, 1); return __pyx_r; } @@ -4068,12 +4499,18 @@ static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject static CYTHON_INLINE NPY_DATETIMEUNIT __pyx_f_5numpy_get_datetime64_unit(PyObject *__pyx_v_obj) { NPY_DATETIMEUNIT __pyx_r; + __Pyx_TraceDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_TraceCall("get_datetime64_unit", __pyx_f[1], 1014, 1, __PYX_ERR(1, 1014, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1018 * returns the unit part of the dtype for a numpy datetime64 object. * """ * return (obj).obmeta.base # <<<<<<<<<<<<<< */ + __Pyx_TraceLine(1018,1,__PYX_ERR(1, 1018, __pyx_L1_error)) __pyx_r = ((NPY_DATETIMEUNIT)((PyDatetimeScalarObject *)__pyx_v_obj)->obmeta.base); goto __pyx_L0; @@ -4086,7 +4523,11 @@ static CYTHON_INLINE NPY_DATETIMEUNIT __pyx_f_5numpy_get_datetime64_unit(PyObjec */ /* function exit code */ + __pyx_L1_error:; + __Pyx_WriteUnraisable("numpy.get_datetime64_unit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1); + __pyx_r = (NPY_DATETIMEUNIT) 0; __pyx_L0:; + __Pyx_TraceReturn(Py_None, 1); return __pyx_r; } @@ -4182,9 +4623,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * * cdef inline int import_umath() except -1: */ - __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 945, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple_); - __Pyx_GIVEREF(__pyx_tuple_); + __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 945, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":951 * _import_umath() @@ -4193,9 +4634,9 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * * cdef inline int import_ufunc() except -1: */ - __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 951, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__2); - __Pyx_GIVEREF(__pyx_tuple__2); + __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 951, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__9); + __Pyx_GIVEREF(__pyx_tuple__9); /* "l0learn/testing_utils.pyx":11 * @@ -4204,10 +4645,10 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * return c_list_csc_to_arma_csc_to_list(x) * */ - __pyx_tuple__3 = PyTuple_Pack(1, __pyx_n_s_x); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 11, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__3); - __Pyx_GIVEREF(__pyx_tuple__3); - __pyx_codeobj__4 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_list_csc_to_arma_csc_to_list, 11, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__4)) __PYX_ERR(0, 11, __pyx_L1_error) + __pyx_tuple__10 = PyTuple_Pack(1, __pyx_n_s_x); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 11, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + __pyx_codeobj_ = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_list_csc_to_arma_csc_to_list, 11, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj_)) __PYX_ERR(0, 11, __pyx_L1_error) /* "l0learn/testing_utils.pyx":21 * @@ -4216,10 +4657,10 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * return c_list_dvec_to_arma_dvec_to_list(x) * */ - __pyx_tuple__5 = PyTuple_Pack(1, __pyx_n_s_x); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 21, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__5); - __Pyx_GIVEREF(__pyx_tuple__5); - __pyx_codeobj__6 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__5, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_list_dvec_to_arma_dvec_to_list, 21, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__6)) __PYX_ERR(0, 21, __pyx_L1_error) + __pyx_tuple__11 = PyTuple_Pack(1, __pyx_n_s_x); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 21, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__11); + __Pyx_GIVEREF(__pyx_tuple__11); + __pyx_codeobj__2 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__11, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_list_dvec_to_arma_dvec_to_list, 21, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__2)) __PYX_ERR(0, 21, __pyx_L1_error) /* "l0learn/testing_utils.pyx":31 * @@ -4228,10 +4669,10 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * cdef np.ndarray[np.double_t, ndim=2] x_pass * x_pass = c_dmat_np_to_arma_to_np(x) */ - __pyx_tuple__7 = PyTuple_Pack(2, __pyx_n_s_x, __pyx_n_s_x_pass); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 31, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__7); - __Pyx_GIVEREF(__pyx_tuple__7); - __pyx_codeobj__8 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__7, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_dmat_np_to_arma_to_np, 31, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__8)) __PYX_ERR(0, 31, __pyx_L1_error) + __pyx_tuple__12 = PyTuple_Pack(2, __pyx_n_s_x, __pyx_n_s_x_pass); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(0, 31, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__12); + __Pyx_GIVEREF(__pyx_tuple__12); + __pyx_codeobj__3 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_dmat_np_to_arma_to_np, 31, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__3)) __PYX_ERR(0, 31, __pyx_L1_error) /* "l0learn/testing_utils.pyx":46 * @@ -4240,10 +4681,10 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * cdef np.ndarray[np.uint64_t, ndim=1] x_pass * x_pass = c_uvec_np_to_arma_to_np(x) */ - __pyx_tuple__9 = PyTuple_Pack(2, __pyx_n_s_x, __pyx_n_s_x_pass); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 46, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__9); - __Pyx_GIVEREF(__pyx_tuple__9); - __pyx_codeobj__10 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__9, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_uvec_np_to_arma_to_np, 46, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__10)) __PYX_ERR(0, 46, __pyx_L1_error) + __pyx_tuple__13 = PyTuple_Pack(2, __pyx_n_s_x, __pyx_n_s_x_pass); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__13); + __Pyx_GIVEREF(__pyx_tuple__13); + __pyx_codeobj__4 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_uvec_np_to_arma_to_np, 46, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__4)) __PYX_ERR(0, 46, __pyx_L1_error) /* "l0learn/testing_utils.pyx":61 * @@ -4252,10 +4693,10 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * cdef np.ndarray[np.double_t, ndim=1] x_pass * x_pass = c_dvec_np_to_arma_to_np(x) */ - __pyx_tuple__11 = PyTuple_Pack(2, __pyx_n_s_x, __pyx_n_s_x_pass); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(0, 61, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__11); - __Pyx_GIVEREF(__pyx_tuple__11); - __pyx_codeobj__12 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__11, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_dvec_np_to_arma_to_np, 61, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__12)) __PYX_ERR(0, 61, __pyx_L1_error) + __pyx_tuple__14 = PyTuple_Pack(2, __pyx_n_s_x, __pyx_n_s_x_pass); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(0, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__14); + __Pyx_GIVEREF(__pyx_tuple__14); + __pyx_codeobj__5 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__14, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_dvec_np_to_arma_to_np, 61, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__5)) __PYX_ERR(0, 61, __pyx_L1_error) /* "l0learn/testing_utils.pyx":76 * @@ -4264,10 +4705,10 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * return c_sp_dmat_np_to_arma_to_np(x) * */ - __pyx_tuple__13 = PyTuple_Pack(1, __pyx_n_s_x); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(0, 76, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__13); - __Pyx_GIVEREF(__pyx_tuple__13); - __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_sp_dmat_np_to_arma_to_np, 76, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(0, 76, __pyx_L1_error) + __pyx_tuple__15 = PyTuple_Pack(1, __pyx_n_s_x); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__15); + __Pyx_GIVEREF(__pyx_tuple__15); + __pyx_codeobj__6 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__15, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_sp_dmat_np_to_arma_to_np, 76, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__6)) __PYX_ERR(0, 76, __pyx_L1_error) /* "l0learn/testing_utils.pyx":87 * @@ -4276,10 +4717,10 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * cdef dmat arma_x = numpy_to_dmat_d(x) * cdef dmat arma_y = numpy_to_dmat_d(y) */ - __pyx_tuple__15 = PyTuple_Pack(6, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_arma_x, __pyx_n_s_arma_y, __pyx_n_s_arma_xy, __pyx_n_s_np_xy); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__15); - __Pyx_GIVEREF(__pyx_tuple__15); - __pyx_codeobj__16 = (PyObject*)__Pyx_PyCode_New(2, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__15, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_dmat_dot_dmat, 87, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__16)) __PYX_ERR(0, 87, __pyx_L1_error) + __pyx_tuple__16 = PyTuple_Pack(6, __pyx_n_s_x, __pyx_n_s_y, __pyx_n_s_arma_x, __pyx_n_s_arma_y, __pyx_n_s_arma_xy, __pyx_n_s_np_xy); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__16); + __Pyx_GIVEREF(__pyx_tuple__16); + __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(2, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_testing_utils_pyx, __pyx_n_s_dmat_dot_dmat, 87, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) __PYX_ERR(0, 87, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; @@ -4539,6 +4980,7 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_testing_utils(PyObject *__pyx_pyin #endif #endif { + __Pyx_TraceDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; @@ -4644,6 +5086,7 @@ if (!__Pyx_RefNanny) { #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif + __Pyx_TraceCall("__Pyx_PyMODINIT_FUNC PyInit_testing_utils(void)", __pyx_f[0], 1, 0, __PYX_ERR(0, 1, __pyx_L1_error)); /* "l0learn/testing_utils.pyx":2 * cimport cython @@ -4651,6 +5094,7 @@ if (!__Pyx_RefNanny) { * cimport numpy as np * */ + __Pyx_TraceLine(2,0,__PYX_ERR(0, 2, __pyx_L1_error)) __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 2, __pyx_L1_error) @@ -4663,11 +5107,22 @@ if (!__Pyx_RefNanny) { * return c_list_csc_to_arma_csc_to_list(x) * */ + __Pyx_TraceLine(11,0,__PYX_ERR(0, 11, __pyx_L1_error)) __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_13testing_utils_1list_csc_to_arma_csc_to_list, NULL, __pyx_n_s_l0learn_testing_utils); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 11, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_list_csc_to_arma_csc_to_list, __pyx_t_1) < 0) __PYX_ERR(0, 11, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /* "l0learn/testing_utils.pyx":15 + * + * + * cdef list c_list_csc_to_arma_csc_to_list(list x): # <<<<<<<<<<<<<< + * cdef field[sp_dmat] f = list_to_sp_dmat_field(x) + * cdef lst = sp_dmat_field_to_list(f) + */ + __Pyx_TraceLine(15,0,__PYX_ERR(0, 15, __pyx_L1_error)) + + /* "l0learn/testing_utils.pyx":21 * * @@ -4675,11 +5130,22 @@ if (!__Pyx_RefNanny) { * return c_list_dvec_to_arma_dvec_to_list(x) * */ + __Pyx_TraceLine(21,0,__PYX_ERR(0, 21, __pyx_L1_error)) __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_13testing_utils_3list_dvec_to_arma_dvec_to_list, NULL, __pyx_n_s_l0learn_testing_utils); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_list_dvec_to_arma_dvec_to_list, __pyx_t_1) < 0) __PYX_ERR(0, 21, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /* "l0learn/testing_utils.pyx":25 + * + * + * cdef list c_list_dvec_to_arma_dvec_to_list(list x): # <<<<<<<<<<<<<< + * cdef field[dvec] f = list_to_dvec_field(x) + * cdef lst = dvec_field_to_list(f) + */ + __Pyx_TraceLine(25,0,__PYX_ERR(0, 25, __pyx_L1_error)) + + /* "l0learn/testing_utils.pyx":31 * * @@ -4687,11 +5153,22 @@ if (!__Pyx_RefNanny) { * cdef np.ndarray[np.double_t, ndim=2] x_pass * x_pass = c_dmat_np_to_arma_to_np(x) */ + __Pyx_TraceLine(31,0,__PYX_ERR(0, 31, __pyx_L1_error)) __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_13testing_utils_5dmat_np_to_arma_to_np, NULL, __pyx_n_s_l0learn_testing_utils); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 31, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_dmat_np_to_arma_to_np, __pyx_t_1) < 0) __PYX_ERR(0, 31, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /* "l0learn/testing_utils.pyx":38 + * + * + * cdef np.ndarray[np.double_t, ndim=2] c_dmat_np_to_arma_to_np(np.ndarray[np.double_t, ndim=2] x): # <<<<<<<<<<<<<< + * cdef dmat arma_x = numpy_to_dmat_d(x) + * + */ + __Pyx_TraceLine(38,0,__PYX_ERR(0, 38, __pyx_L1_error)) + + /* "l0learn/testing_utils.pyx":46 * * @@ -4699,11 +5176,22 @@ if (!__Pyx_RefNanny) { * cdef np.ndarray[np.uint64_t, ndim=1] x_pass * x_pass = c_uvec_np_to_arma_to_np(x) */ + __Pyx_TraceLine(46,0,__PYX_ERR(0, 46, __pyx_L1_error)) __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_13testing_utils_7uvec_np_to_arma_to_np, NULL, __pyx_n_s_l0learn_testing_utils); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 46, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_uvec_np_to_arma_to_np, __pyx_t_1) < 0) __PYX_ERR(0, 46, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /* "l0learn/testing_utils.pyx":53 + * + * + * cdef np.ndarray[np.uint64_t, ndim=1] c_uvec_np_to_arma_to_np(np.ndarray[np.uint64_t, ndim=1] x): # <<<<<<<<<<<<<< + * cdef uvec arma_x = numpy_to_uvec_d(x) + * + */ + __Pyx_TraceLine(53,0,__PYX_ERR(0, 53, __pyx_L1_error)) + + /* "l0learn/testing_utils.pyx":61 * * @@ -4711,11 +5199,22 @@ if (!__Pyx_RefNanny) { * cdef np.ndarray[np.double_t, ndim=1] x_pass * x_pass = c_dvec_np_to_arma_to_np(x) */ + __Pyx_TraceLine(61,0,__PYX_ERR(0, 61, __pyx_L1_error)) __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_13testing_utils_9dvec_np_to_arma_to_np, NULL, __pyx_n_s_l0learn_testing_utils); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 61, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_dvec_np_to_arma_to_np, __pyx_t_1) < 0) __PYX_ERR(0, 61, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /* "l0learn/testing_utils.pyx":68 + * + * + * cdef np.ndarray[np.uint64_t, ndim=1] c_dvec_np_to_arma_to_np(np.ndarray[np.double_t, ndim=1] x): # <<<<<<<<<<<<<< + * cdef dvec arma_x = numpy_to_dvec_d(x) + * + */ + __Pyx_TraceLine(68,0,__PYX_ERR(0, 68, __pyx_L1_error)) + + /* "l0learn/testing_utils.pyx":76 * * @@ -4723,11 +5222,22 @@ if (!__Pyx_RefNanny) { * return c_sp_dmat_np_to_arma_to_np(x) * */ + __Pyx_TraceLine(76,0,__PYX_ERR(0, 76, __pyx_L1_error)) __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_13testing_utils_11sp_dmat_np_to_arma_to_np, NULL, __pyx_n_s_l0learn_testing_utils); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 76, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_sp_dmat_np_to_arma_to_np, __pyx_t_1) < 0) __PYX_ERR(0, 76, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /* "l0learn/testing_utils.pyx":80 + * + * + * cdef c_sp_dmat_np_to_arma_to_np(x): # <<<<<<<<<<<<<< + * cdef sp_dmat arma_x = numpy_to_sp_dmat_d(x) + * + */ + __Pyx_TraceLine(80,0,__PYX_ERR(0, 80, __pyx_L1_error)) + + /* "l0learn/testing_utils.pyx":87 * * @@ -4735,21 +5245,183 @@ if (!__Pyx_RefNanny) { * cdef dmat arma_x = numpy_to_dmat_d(x) * cdef dmat arma_y = numpy_to_dmat_d(y) */ + __Pyx_TraceLine(87,0,__PYX_ERR(0, 87, __pyx_L1_error)) __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_13testing_utils_13dmat_dot_dmat, NULL, __pyx_n_s_l0learn_testing_utils); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 87, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_dmat_dot_dmat, __pyx_t_1) < 0) __PYX_ERR(0, 87, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /* "l0learn/testing_utils.pyx":98 + * + * + * cdef dmat c_dmat_dot_dmat(dmat arma_x, dmat arma_y): # <<<<<<<<<<<<<< + * cdef dmat arma_xy = arma_x*arma_y + * + */ + __Pyx_TraceLine(98,0,__PYX_ERR(0, 98, __pyx_L1_error)) + + /* "l0learn/testing_utils.pyx":1 * cimport cython # <<<<<<<<<<<<<< * import numpy as np * cimport numpy as np */ + __Pyx_TraceLine(1,0,__PYX_ERR(0, 1, __pyx_L1_error)) __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":735 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + __Pyx_TraceLine(735,0,__PYX_ERR(1, 735, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":738 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + __Pyx_TraceLine(738,0,__PYX_ERR(1, 738, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":741 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + __Pyx_TraceLine(741,0,__PYX_ERR(1, 741, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":744 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + __Pyx_TraceLine(744,0,__PYX_ERR(1, 744, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":747 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + __Pyx_TraceLine(747,0,__PYX_ERR(1, 747, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":750 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape + */ + __Pyx_TraceLine(750,0,__PYX_ERR(1, 750, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":929 + * int _import_umath() except -1 + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) + */ + __Pyx_TraceLine(929,0,__PYX_ERR(1, 929, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":933 + * PyArray_SetBaseObject(arr, base) + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) + * if base is NULL: + */ + __Pyx_TraceLine(933,0,__PYX_ERR(1, 933, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":941 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * __pyx_import_array() + */ + __Pyx_TraceLine(941,0,__PYX_ERR(1, 941, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":947 + * raise ImportError("numpy.core.multiarray failed to import") + * + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + __Pyx_TraceLine(947,0,__PYX_ERR(1, 947, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":953 + * raise ImportError("numpy.core.umath failed to import") + * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + __Pyx_TraceLine(953,0,__PYX_ERR(1, 953, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":967 + * + * + * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.timedelta64)` + */ + __Pyx_TraceLine(967,0,__PYX_ERR(1, 967, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":982 + * + * + * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.datetime64)` + */ + __Pyx_TraceLine(982,0,__PYX_ERR(1, 982, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":997 + * + * + * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy datetime64 object + */ + __Pyx_TraceLine(997,0,__PYX_ERR(1, 997, __pyx_L1_error)) + + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1007 + * + * + * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy timedelta64 object + */ + __Pyx_TraceLine(1007,0,__PYX_ERR(1, 1007, __pyx_L1_error)) + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1014 * * @@ -4757,6 +5429,9 @@ if (!__Pyx_RefNanny) { * """ * returns the unit part of the dtype for a numpy datetime64 object. */ + __Pyx_TraceLine(1014,0,__PYX_ERR(1, 1014, __pyx_L1_error)) + + __Pyx_TraceReturn(Py_None, 0); /*--- Wrapped vars code ---*/ @@ -4800,6 +5475,122 @@ static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { } #endif +/* PyErrFetchRestore */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +} +#endif + +/* Profile */ +#if CYTHON_PROFILE +static int __Pyx_TraceSetupAndCall(PyCodeObject** code, + PyFrameObject** frame, + PyThreadState* tstate, + const char *funcname, + const char *srcfile, + int firstlineno) { + PyObject *type, *value, *traceback; + int retval; + if (*frame == NULL || !CYTHON_PROFILE_REUSE_FRAME) { + if (*code == NULL) { + *code = __Pyx_createFrameCodeObject(funcname, srcfile, firstlineno); + if (*code == NULL) return 0; + } + *frame = PyFrame_New( + tstate, /*PyThreadState *tstate*/ + *code, /*PyCodeObject *code*/ + __pyx_d, /*PyObject *globals*/ + 0 /*PyObject *locals*/ + ); + if (*frame == NULL) return 0; + if (CYTHON_TRACE && (*frame)->f_trace == NULL) { + Py_INCREF(Py_None); + (*frame)->f_trace = Py_None; + } +#if PY_VERSION_HEX < 0x030400B1 + } else { + (*frame)->f_tstate = tstate; +#endif + } + __Pyx_PyFrame_SetLineNumber(*frame, firstlineno); + retval = 1; + tstate->tracing++; + __Pyx_SetTracing(tstate, 0); + __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); + #if CYTHON_TRACE + if (tstate->c_tracefunc) + retval = tstate->c_tracefunc(tstate->c_traceobj, *frame, PyTrace_CALL, NULL) == 0; + if (retval && tstate->c_profilefunc) + #endif + retval = tstate->c_profilefunc(tstate->c_profileobj, *frame, PyTrace_CALL, NULL) == 0; + __Pyx_SetTracing(tstate, (tstate->c_profilefunc || (CYTHON_TRACE && tstate->c_tracefunc))); + tstate->tracing--; + if (retval) { + __Pyx_ErrRestoreInState(tstate, type, value, traceback); + return __Pyx_IsTracing(tstate, 0, 0) && retval; + } else { + Py_XDECREF(type); + Py_XDECREF(value); + Py_XDECREF(traceback); + return -1; + } +} +static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno) { + PyCodeObject *py_code = 0; +#if PY_MAJOR_VERSION >= 3 + py_code = PyCode_NewEmpty(srcfile, funcname, firstlineno); + if (likely(py_code)) { + py_code->co_flags |= CO_OPTIMIZED | CO_NEWLOCALS; + } +#else + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + py_funcname = PyString_FromString(funcname); + if (unlikely(!py_funcname)) goto bad; + py_srcfile = PyString_FromString(srcfile); + if (unlikely(!py_srcfile)) goto bad; + py_code = PyCode_New( + 0, + 0, + 0, + CO_OPTIMIZED | CO_NEWLOCALS, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + firstlineno, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); +#endif + return py_code; +} +#endif + /* ExtTypeTest */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { if (unlikely(!type)) { @@ -5379,30 +6170,6 @@ fail:; "Buffer acquisition failed on assignment; and then reacquiring the old buffer failed too!"); } -/* PyErrFetchRestore */ - #if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { - PyObject *tmp_type, *tmp_value, *tmp_tb; - tmp_type = tstate->curexc_type; - tmp_value = tstate->curexc_value; - tmp_tb = tstate->curexc_traceback; - tstate->curexc_type = type; - tstate->curexc_value = value; - tstate->curexc_traceback = tb; - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); -} -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { - *type = tstate->curexc_type; - *value = tstate->curexc_value; - *tb = tstate->curexc_traceback; - tstate->curexc_type = 0; - tstate->curexc_value = 0; - tstate->curexc_traceback = 0; -} -#endif - /* RaiseArgTupleInvalid */ static void __Pyx_RaiseArgtupleInvalid( const char* func_name, @@ -5545,6 +6312,48 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject return -1; } +/* WriteUnraisableException */ + static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, + CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, + int full_traceback, CYTHON_UNUSED int nogil) { + PyObject *old_exc, *old_val, *old_tb; + PyObject *ctx; + __Pyx_PyThreadState_declare +#ifdef WITH_THREAD + PyGILState_STATE state; + if (nogil) + state = PyGILState_Ensure(); +#ifdef _MSC_VER + else state = (PyGILState_STATE)-1; +#endif +#endif + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); + if (full_traceback) { + Py_XINCREF(old_exc); + Py_XINCREF(old_val); + Py_XINCREF(old_tb); + __Pyx_ErrRestore(old_exc, old_val, old_tb); + PyErr_PrintEx(1); + } + #if PY_MAJOR_VERSION < 3 + ctx = PyString_FromString(name); + #else + ctx = PyUnicode_FromString(name); + #endif + __Pyx_ErrRestore(old_exc, old_val, old_tb); + if (!ctx) { + PyErr_WriteUnraisable(Py_None); + } else { + PyErr_WriteUnraisable(ctx); + Py_DECREF(ctx); + } +#ifdef WITH_THREAD + if (nogil) + PyGILState_Release(state); +#endif +} + /* PyObjectGetAttrStr */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { diff --git a/python/pyproject.toml b/python/pyproject.toml index 9291b21..4258078 100644 --- a/python/pyproject.toml +++ b/python/pyproject.toml @@ -9,7 +9,12 @@ requires = [ build-backend = "setuptools.build_meta" [tool.coverage.run] -omit = [ - "l0learn/src/*", - "src/*", -] \ No newline at end of file +plugins = ["Cython.Coverage"] +source=[ + "l0learn/cyarma.pyx", + "l0learn/cyarma.pxd", + "l0learn/init.py", + "l0learn/interface.pxd", + "l0learn/interface.pyx", + "l0learn/models.py", +] diff --git a/python/setup.py b/python/setup.py index da8de41..60a44a6 100644 --- a/python/setup.py +++ b/python/setup.py @@ -1,9 +1,11 @@ #!/usr/bin/python3 import os -from setuptools import setup, Extension, find_packages + +from setuptools import setup, Extension import numpy as np + try: from Cython.Build import cythonize except ImportError: @@ -18,6 +20,11 @@ from Cython.Distutils import build_ext +CYTHONIZE = bool(int(os.getenv("CYTHONIZE", 0))) and cythonize is not None +CYTHONIZE = True +print(f"CYTHONIZE = {CYTHONIZE}") +COVERAGE_MODE = bool(os.getenv("L0LEARN_COVERAGE_MODE", 0)) and CYTHONIZE +print(f"COVERAGE_MODE = {COVERAGE_MODE}") # https://cython.readthedocs.io/en/latest/src/userguide/source_files_and_compilation.html#distributing-cython-modules def no_cythonize(extensions, **_ignore): @@ -35,10 +42,14 @@ def no_cythonize(extensions, **_ignore): extension.sources[:] = sources return extensions - if psutil_found: os.environ["CMAKE_BUILD_PARALLEL_LEVEL"] = str(cpu_count(logical=False)) +if COVERAGE_MODE: + macros = [("CYTHON_TRACE_NOGIL", "1")] +else: + macros = [] + extensions = [ Extension(name='l0learn.cyarma', sources=["l0learn/cyarma.pyx"], @@ -47,6 +58,7 @@ def no_cythonize(extensions, **_ignore): libraries=["armadillo", "lapack", "blas"], extra_compile_args=["-std=c++11"], extra_link_args=["-std=c++11"], + define_macros=macros, ), Extension(name='l0learn.testing_utils', sources=["l0learn/testing_utils.pyx"], @@ -55,6 +67,7 @@ def no_cythonize(extensions, **_ignore): libraries=["armadillo", "lapack", "blas"], extra_compile_args=["-std=c++11"], extra_link_args=["-std=c++11"], + define_macros=macros, ), Extension(name="l0learn.interface", sources=["l0learn/interface.pyx", @@ -70,14 +83,18 @@ def no_cythonize(extensions, **_ignore): language="c++", libraries=["armadillo", "lapack", "blas"], extra_compile_args=["-std=c++11"], - extra_link_args=["-std=c++11"]), + extra_link_args=["-std=c++11"], + define_macros=macros, + ), ] -CYTHONIZE = bool(int(os.getenv("CYTHONIZE", 0))) and cythonize is not None -if True: +if CYTHONIZE: compiler_directives = {"language_level": 3, "embedsignature": True} + if COVERAGE_MODE: + compiler_directives['linetrace'] = True extensions = cythonize(extensions, compiler_directives=compiler_directives) else: + COVERAGE_MODE = False extensions = no_cythonize(extensions) """ From b9e9babacb3f50cba83735674255cf33d3ced91b Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Sun, 21 Nov 2021 15:53:03 -0600 Subject: [PATCH 057/125] Update python.yml --- .github/workflows/python.yml | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/.github/workflows/python.yml b/.github/workflows/python.yml index 2bb932a..bc4860b 100644 --- a/.github/workflows/python.yml +++ b/.github/workflows/python.yml @@ -44,11 +44,14 @@ jobs: python-version: ${{ matrix.python-version }} - name: Install dependencies run: | + import os python -m pip install --upgrade pip pip install wheel pip install pytest-cov pip install coveralls - pip install -e ".[test]" + os.environ["L0LEARN_COVERAGE_MODE"] = "1" + python setup.py build_ext --force --inplace # force to recompile with COVERAGE_MODE + pip install -e ".[test]" - name: Run Tests and Coverage run: python -m pytest --cov=l0learn - name: Coveralls From 0ab4f28f748a52b38cb47068edaee5501e30cf41 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Sun, 21 Nov 2021 15:57:38 -0600 Subject: [PATCH 058/125] Update python.yml --- .github/workflows/python.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/python.yml b/.github/workflows/python.yml index bc4860b..7fd850a 100644 --- a/.github/workflows/python.yml +++ b/.github/workflows/python.yml @@ -43,13 +43,13 @@ jobs: with: python-version: ${{ matrix.python-version }} - name: Install dependencies + env: + L0LEARN_COVERAGE_MODE: 1 run: | - import os python -m pip install --upgrade pip pip install wheel pip install pytest-cov pip install coveralls - os.environ["L0LEARN_COVERAGE_MODE"] = "1" python setup.py build_ext --force --inplace # force to recompile with COVERAGE_MODE pip install -e ".[test]" - name: Run Tests and Coverage From ac839136c2ae0d49e86513f8fe5e988a907cddfb Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Sun, 21 Nov 2021 16:04:12 -0600 Subject: [PATCH 059/125] Update python.yml --- .github/workflows/python.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/python.yml b/.github/workflows/python.yml index 7fd850a..37beeb0 100644 --- a/.github/workflows/python.yml +++ b/.github/workflows/python.yml @@ -50,8 +50,8 @@ jobs: pip install wheel pip install pytest-cov pip install coveralls - python setup.py build_ext --force --inplace # force to recompile with COVERAGE_MODE pip install -e ".[test]" + python setup.py build_ext --force --inplace # force to recompile with COVERAGE_MODE - name: Run Tests and Coverage run: python -m pytest --cov=l0learn - name: Coveralls From 89f020b3a5e20e53f8e86883e38c7e126c09a748 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Sun, 21 Nov 2021 16:18:24 -0600 Subject: [PATCH 060/125] Update python.yml --- .github/workflows/python.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/python.yml b/.github/workflows/python.yml index 37beeb0..fb687bc 100644 --- a/.github/workflows/python.yml +++ b/.github/workflows/python.yml @@ -48,6 +48,7 @@ jobs: run: | python -m pip install --upgrade pip pip install wheel + pip install Cython # this should not be needed, but somehow is... pyproject.toml should have this in [build.system] pip install pytest-cov pip install coveralls pip install -e ".[test]" From bd3d3d281761db24f08d9f225a46ff99f26ac3fe Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Sun, 21 Nov 2021 17:48:40 -0600 Subject: [PATCH 061/125] update test_check R with reporter --- R/tests/testthat.R | 2 +- R/tests/testthat/test_L0Learn_intercept.R | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/R/tests/testthat.R b/R/tests/testthat.R index 98c98c5..96ccdf5 100644 --- a/R/tests/testthat.R +++ b/R/tests/testthat.R @@ -1,4 +1,4 @@ library(testthat) library(L0Learn) -test_check("L0Learn") +test_check("L0Learn", reporter = ParallelProgressReporter) diff --git a/R/tests/testthat/test_L0Learn_intercept.R b/R/tests/testthat/test_L0Learn_intercept.R index 68766cb..8901a4f 100644 --- a/R/tests/testthat/test_L0Learn_intercept.R +++ b/R/tests/testthat/test_L0Learn_intercept.R @@ -207,7 +207,7 @@ test_that("Intercepts are learned close to real values", { for (i in 1:length(x1$suppSize[[1]])){ if (x1$suppSize[[j]][i] == k){ expect_lt(abs(x1$a0[[j]][i] - b0), abs(2*(abs(b0) - abs(y2_mean)))) - print(paste(abs(x1$a0[[j]][i] - b0), abs(2*(abs(b0) - abs(y2_mean))))) + # print(paste(abs(x1$a0[[j]][i] - b0), abs(2*(abs(b0) - abs(y2_mean))))) } } } From 8f7430337d0b8c7ed794bcdd5c461fada4c5fd75 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Mon, 22 Nov 2021 07:56:47 -0600 Subject: [PATCH 062/125] Update r.yml --- .github/workflows/r.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/r.yml b/.github/workflows/r.yml index 936632f..f030840 100644 --- a/.github/workflows/r.yml +++ b/.github/workflows/r.yml @@ -44,5 +44,5 @@ jobs: working-directory: R - name: Test coverage - run: covr::codecov(quiet = FALSE) + run: covr::package_coverage() shell: Rscript {0} From 8b7470278c0ccf8decb4f67fee11d368a74f6da3 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Mon, 22 Nov 2021 12:19:12 -0600 Subject: [PATCH 063/125] Update R_L0Learn_Interface.cpp for covr issue. --- R/src/R_L0Learn_Interface.cpp | 2 +- R/tests/testthat.R | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/R/src/R_L0Learn_Interface.cpp b/R/src/R_L0Learn_Interface.cpp index dc55490..0b01d4f 100644 --- a/R/src/R_L0Learn_Interface.cpp +++ b/R/src/R_L0Learn_Interface.cpp @@ -9,4 +9,4 @@ Rcpp::NumericMatrix cor_matrix(const int p, const double base_cor) { } } return cor; -} \ No newline at end of file +} diff --git a/R/tests/testthat.R b/R/tests/testthat.R index 96ccdf5..98c98c5 100644 --- a/R/tests/testthat.R +++ b/R/tests/testthat.R @@ -1,4 +1,4 @@ library(testthat) library(L0Learn) -test_check("L0Learn", reporter = ParallelProgressReporter) +test_check("L0Learn") From c2155fff3ca70861152aa3e9997a03b026466424 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Mon, 22 Nov 2021 14:12:33 -0600 Subject: [PATCH 064/125] Update r.yml --- .github/workflows/r.yml | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/.github/workflows/r.yml b/.github/workflows/r.yml index f030840..34616df 100644 --- a/.github/workflows/r.yml +++ b/.github/workflows/r.yml @@ -44,5 +44,8 @@ jobs: working-directory: R - name: Test coverage - run: covr::package_coverage() + run: | + covr::package_coverage( + type = "none", + code = "testthat::test_package('L0Learn', reporter = testthat::JunitReporter$new(file = 'test-results.xml'))") shell: Rscript {0} From 81fe1deecc62bac67b303a0436cc6cb6621a5d4c Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Mon, 22 Nov 2021 14:40:30 -0600 Subject: [PATCH 065/125] Update r.yml --- .github/workflows/r.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.github/workflows/r.yml b/.github/workflows/r.yml index 34616df..e8f6a60 100644 --- a/.github/workflows/r.yml +++ b/.github/workflows/r.yml @@ -40,7 +40,9 @@ jobs: - uses: TNonet/actions/setup-r-dependencies@master with: cache-version: 1 - extra-packages: covr + extra-packages: | + covr + xml2 working-directory: R - name: Test coverage From a1fbd7e7456690df1932572c3856b617cb1aca7f Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Mon, 22 Nov 2021 16:17:27 -0600 Subject: [PATCH 066/125] Update r.yml --- .github/workflows/r.yml | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/.github/workflows/r.yml b/.github/workflows/r.yml index e8f6a60..e52175c 100644 --- a/.github/workflows/r.yml +++ b/.github/workflows/r.yml @@ -31,12 +31,15 @@ jobs: pandoc-version: '2.7.3' - name: Install dependencies run: | - install.packages(c("remotes", "rcmdcheck")) + install.packages(c("remotes", "rcmdcheck", "devtools")) remotes::install_deps(dependencies = TRUE) shell: Rscript {0} - name: Check run: rcmdcheck::rcmdcheck("R", args = "--no-manual", error_on = "error", check_dir = "check") shell: Rscript {0} + - name: Run Tests + run: devtools::test() + shell: Rscript {0} - uses: TNonet/actions/setup-r-dependencies@master with: cache-version: 1 From d6d356651331672df6702c216acdbec60a38a7f7 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Tue, 23 Nov 2021 10:54:30 -0600 Subject: [PATCH 067/125] Add check on excludeFirstK parameter value --- R/R/cvfit.R | 4 ++++ R/R/fit.R | 4 ++++ R/tests/testthat/test_L0Learn.R | 6 +++--- 3 files changed, 11 insertions(+), 3 deletions(-) diff --git a/R/R/cvfit.R b/R/R/cvfit.R index 0b6b173..ccb198e 100644 --- a/R/R/cvfit.R +++ b/R/R/cvfit.R @@ -159,6 +159,10 @@ L0Learn.cvfit <- function(x,y, loss="SquaredError", penalty="L0", algorithm="CD" p = dim(x)[[2]] + if ((excludeFirstK < 0) || (excludeFirstK >= p)){ + stop("The specified excludeFirstK parameter must be an integer between 0 and p-1") + } + withBounds = FALSE if ((!identical(lows, -Inf)) || (!identical(highs, Inf))){ withBounds=TRUE diff --git a/R/R/fit.R b/R/R/fit.R index c728298..8dd8758 100644 --- a/R/R/fit.R +++ b/R/R/fit.R @@ -227,6 +227,10 @@ L0Learn.fit <- function(x, y, loss="SquaredError", penalty="L0", algorithm="CD", p = dim(x)[[2]] + if ((excludeFirstK < 0) || (excludeFirstK >= p)){ + stop("The specified excludeFirstK parameter must be an integer between 0 and p-1") + } + withBounds = FALSE if ((!identical(lows, -Inf)) || (!identical(highs, Inf))){ diff --git a/R/tests/testthat/test_L0Learn.R b/R/tests/testthat/test_L0Learn.R index 94c6bab..fef882e 100644 --- a/R/tests/testthat/test_L0Learn.R +++ b/R/tests/testthat/test_L0Learn.R @@ -120,10 +120,10 @@ test_that("L0Learn excludeFirstK is still subject to L1 norms", { # Therefore, as L1 grows we can expect that the columns go to 0. - x1 <- L0Learn.fit(X_real, y_fake, penalty = "L0", excludeFirstK = K, maxSuppSize = p) + x1 <- L0Learn.fit(X_real, y_fake, penalty = "L0", excludeFirstK = K-1, maxSuppSize = p) - expect_equal(length(x1$suppSize[[1]]), 1) - expect_equal(x1$suppSize[[1]][1], 10) + expect_equal(length(x1$suppSize[[1]]), 2) + expect_equal(x1$suppSize[[1]][2], 10) # TODO: Fix Crash when excludeFirstK >= p # x2 <- L0Learn.fit(X_real, y_fake, penalty = "L0L1", excludeFirstK = K, maxSuppSize = 10) From 077729c1ff59651a7353940e2a1e37d59a8af05b Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Tue, 23 Nov 2021 14:37:09 -0600 Subject: [PATCH 068/125] Update r.yml --- .github/workflows/r.yml | 3 --- 1 file changed, 3 deletions(-) diff --git a/.github/workflows/r.yml b/.github/workflows/r.yml index e52175c..dc82496 100644 --- a/.github/workflows/r.yml +++ b/.github/workflows/r.yml @@ -37,9 +37,6 @@ jobs: - name: Check run: rcmdcheck::rcmdcheck("R", args = "--no-manual", error_on = "error", check_dir = "check") shell: Rscript {0} - - name: Run Tests - run: devtools::test() - shell: Rscript {0} - uses: TNonet/actions/setup-r-dependencies@master with: cache-version: 1 From 11c6947dba156d5930a58544c43f03c08efbea3b Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Wed, 24 Nov 2021 09:21:51 -0500 Subject: [PATCH 069/125] Update README.md --- README.md | 24 ++++++++++++++++++++---- 1 file changed, 20 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 3b445ab..2b267e0 100644 --- a/README.md +++ b/README.md @@ -13,7 +13,7 @@ L0Learn is a highly efficient framework for solving L0-regularized learning prob We support both regression (using squared error loss) and classification (using logistic or squared hinge loss). Optimization is done using coordinate descent and local combinatorial search over a grid of regularization parameter(s) values. Several computational tricks and heuristics are used to speed up the algorithms and improve the solution quality. These heuristics include warm starts, active set convergence, correlation screening, greedy cycling order, and efficient methods for updating the residuals through exploiting sparsity and problem dimensions. Moreover, we employed a new computationally efficient method for dynamically selecting the regularization parameter λ in the path. We describe the details of the algorithms in our paper: *Fast Best Subset Selection: Coordinate Descent and Local Combinatorial Optimization Algorithms* ([link](https://pubsonline.informs.org/doi/10.1287/opre.2019.1919)). -The toolkit is implemented in C++11 and can often run faster than popular sparse learning toolkits (see our experiments in the paper above). We also provide an easy-to-use R interface; see the section below for installation and usage of the R package. +The toolkit is implemented in C++11 and can often run faster than popular sparse learning toolkits (see our experiments in the paper above). We also provide an easy-to-use R and Pythoninterface; see the section below for installation and usage of the package. **NEW: Version 2 (03/2021) adds support for sparse matrices and box constraints on the coefficients.** @@ -29,15 +29,31 @@ install_github("hazimehh/L0Learn") ``` L0Learn's changelog can be accessed from [here](https://github.com/hazimehh/L0Learn/blob/master/ChangeLog). +## Python Package Installation +The latest version #### can be installed from PIP as follows: +```{python} +pip install l0learn +``` +Alternative, L0learn can also be built from source as follows: +```{bash} +git clone https://github.com/hazimehh/L0Learn.git +cd L0Learn +pip install . +``` + + ## Usage -For a tutorial, please refer to [L0Learn's Vignette](https://cran.r-project.org/web/packages/L0Learn/vignettes/L0Learn-vignette.html). For a detailed description of the API, check the [Reference Manual](https://cran.r-project.org/web/packages/L0Learn/L0Learn.pdf). +### R Usage +For an tutorial, please refer to [L0Learn's Vignette](https://cran.r-project.org/web/packages/L0Learn/vignettes/L0Learn-vignette.html). For a detailed description of the API, check the [Reference Manual](https://cran.r-project.org/web/packages/L0Learn/L0Learn.pdf). +### Python Usage +[TO ADD] ## FAQ #### Which penalty to use? -Pure L0 regularization can overfit when the signal strength in the data is relatively low. Adding L2 regularization can alleviate this problem and lead to competitive models (see the experiments in our paper). Thus, in practice, **we strongly recommend using the L0L2 penalty**. Ideally, the parameter gamma (for L2 regularization) should be tuned over a sufficiently large interval, and this can be performed using L0Learn's built-in [cross-validation method](https://cran.r-project.org/web/packages/L0Learn/vignettes/L0Learn-vignette.html#cross-validation). +Pure L0 regularization can overfit when the signal strength in the data is relatively low. Adding L2 regularization can alleviate this problem and lead to competitive models (see the experiments in our paper). Thus, in practice, **we strongly recommend using the L0L2 penalty**. Ideally, the parameter gamma (for L2 regularization) should be tuned over a sufficiently large interval, and this can be performed using L0Learn's built-in [R cross-validation method)](https://cran.r-project.org/web/packages/L0Learn/vignettes/L0Learn-vignette.html#cross-validation) or [Python cross-validation method](MISSING). #### Which algorithm to use? -By default, L0Learn uses a coordinate descent-based algorithm, which achieves competitive run times compared to popular sparse learning toolkits. This can work well for many applications. We also offer a local search algorithm which is guarantteed to return higher quality solutions, at the expense of an increase in the run time. We recommend using the local search algorithm if your problem has highly correlated features or the number of samples is much smaller than the number of features---see the [local search section of the Vignette](https://cran.r-project.org/web/packages/L0Learn/vignettes/L0Learn-vignette.html#higher-quality_solutions_using_local_search) for how to use this algorithm. +By default, L0Learn uses a coordinate descent-based algorithm, which achieves competitive run times compared to popular sparse learning toolkits. This can work well for many applications. We also offer a local search algorithm which is guarantteed to return higher quality solutions, at the expense of an increase in the run time. We recommend using the local search algorithm if your problem has highly correlated features or the number of samples is much smaller than the number of features---see the [R local search section of the Vignette](https://cran.r-project.org/web/packages/L0Learn/vignettes/L0Learn-vignette.html#higher-quality_solutions_using_local_search) or [Python local search section of the Vignette](https://cran.r-project.org/web/packages/L0Learn/vignettes/L0Learn-vignette.html#higher-quality_solutions_using_local_search)for how to use this algorithm. #### How to certify optimality? While for many challenging statistical instances L0Learn leads to optimal solutions, it cannot provide certificates of optimality. Such certificates can be provided via Integer Programming. Our toolkit [L0BnB](https://github.com/alisaab/l0bnb) is a scalable integer programming framework for L0-regularized regression, which can provide such certificates and potentially improve upon the solutions of L0Learn (if they are sub-optimal). We recommend using L0Learn first to obtain a candidtate solution (or a pool of solutions) and then checking optimality using L0BnB. From 006f4864ed6cfc57b480e21c5811b48f1e79d6de Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Wed, 24 Nov 2021 09:31:32 -0500 Subject: [PATCH 070/125] Remove unnecessary np_to_arma_check --- python/l0learn/interface.pyx | 56 ++++++++++++++++++------------------ 1 file changed, 28 insertions(+), 28 deletions(-) diff --git a/python/l0learn/interface.pyx b/python/l0learn/interface.pyx index b9554bb..94d0bd2 100644 --- a/python/l0learn/interface.pyx +++ b/python/l0learn/interface.pyx @@ -13,34 +13,34 @@ from l0learn.cyarma cimport dmat, sp_dmat, numpy_to_sp_dmat_d, numpy_to_dmat_d, import l0learn.models from l0learn.models import FitModel, CVFitModel -def np_to_arma_check(arr): - # TODO: Add checks for Behaved and OwnsData - if isinstance(arr, np.ndarray): - if not arr.flags['F_CONTIGUOUS']: - raise ValueError("expected arr to be F_CONTIGUOUS.") - elif isinstance(arr, csc_matrix): - if not arr.data.flags['F_CONTIGUOUS']: - raise ValueError("expected arr.data to be F_CONTIGUOUS.") - if not arr.indices.flags['F_CONTIGUOUS']: - raise ValueError("expected arr.indices to be F_CONTIGUOUS.") - if not arr.indptr.flags['F_CONTIGUOUS']: - raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") - else: - raise NotImplementedError(f"expected arr to be of type {np.ndarray} or {csc_matrix}, but got {type(arr)}.") - - if arr.ndim == 0: - raise ValueError("expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar") - elif arr.ndim > 2: - raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") - - if np.product(arr.shape) == 0: - raise ValueError(f"expected non-degenerate dimensions of arr, but got {arr.ndim}") - - if not np.issubdtype(arr.dtype, np.number): - raise ValueError(f"expected numerical dtype, but got {arr.dtype}") - - if not np.isrealobj(arr): - raise ValueError(f"expected non-complex dtype, but got {arr.dtype}") +# def np_to_arma_check(arr): +# # TODO: Add checks for Behaved and OwnsData +# if isinstance(arr, np.ndarray): +# if not arr.flags['F_CONTIGUOUS']: +# raise ValueError("expected arr to be F_CONTIGUOUS.") +# elif isinstance(arr, csc_matrix): +# if not arr.data.flags['F_CONTIGUOUS']: +# raise ValueError("expected arr.data to be F_CONTIGUOUS.") +# if not arr.indices.flags['F_CONTIGUOUS']: +# raise ValueError("expected arr.indices to be F_CONTIGUOUS.") +# if not arr.indptr.flags['F_CONTIGUOUS']: +# raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") +# else: +# raise NotImplementedError(f"expected arr to be of type {np.ndarray} or {csc_matrix}, but got {type(arr)}.") +# +# if arr.ndim == 0: +# raise ValueError("expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar") +# elif arr.ndim > 2: +# raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") +# +# if np.product(arr.shape) == 0: +# raise ValueError(f"expected non-degenerate dimensions of arr, but got {arr.ndim}") +# +# if not np.issubdtype(arr.dtype, np.number): +# raise ValueError(f"expected numerical dtype, but got {arr.dtype}") +# +# if not np.isrealobj(arr): +# raise ValueError(f"expected non-complex dtype, but got {arr.dtype}") SUPPORTED_LOSS = ("SquaredError", "Logistic", "SquaredHinge") From dbf335bd9635b29ef73440fb527f399dbb18755d Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Wed, 24 Nov 2021 09:32:04 -0500 Subject: [PATCH 071/125] Remove name conflict of test_max_iter_* interfering with test coverage --- python/tests/test_fit.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/python/tests/test_fit.py b/python/tests/test_fit.py index a135dca..754ce6e 100644 --- a/python/tests/test_fit.py +++ b/python/tests/test_fit.py @@ -150,7 +150,7 @@ def test_max_iter_bad_checks(f, max_iter): @pytest.mark.parametrize("rtol", [1.0, -0.1]) @pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) -def test_max_iter_bad_checks(f, rtol): +def test_rtol_bad_checks(f, rtol): # Check size of matrix X x = np.random.random(size=(N, N)) y = np.random.random(size=(N,)) @@ -160,7 +160,7 @@ def test_max_iter_bad_checks(f, rtol): @pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) -def test_max_iter_bad_checks(f): +def test_atol_bad_checks(f): # Check size of matrix X x = np.random.random(size=(N, N)) y = np.random.random(size=(N,)) From 84eac694d58555163aec16161d679654517d8ae0 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Wed, 24 Nov 2021 10:46:06 -0500 Subject: [PATCH 072/125] Update test_fit.py to properly test the correct parameter configurations --- python/tests/test_fit.py | 25 ++++++++++++++++++------- 1 file changed, 18 insertions(+), 7 deletions(-) diff --git a/python/tests/test_fit.py b/python/tests/test_fit.py index 754ce6e..93ac80e 100644 --- a/python/tests/test_fit.py +++ b/python/tests/test_fit.py @@ -1,5 +1,3 @@ -import warnings - import pytest import numpy as np import l0learn @@ -214,7 +212,7 @@ def test_scale_down_factor_bad_checks(f, scale_down_factor): @pytest.mark.parametrize("screen_size", [-1, 2.0]) @pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) -def test_scale_down_factor_bad_checks(f, screen_size): +def test_screen_size_bad_checks(f, screen_size): # Check size of matrix X x = np.random.random(size=(N, N)) y = np.random.random(size=(N,)) @@ -271,6 +269,20 @@ def test_classification_loss_bad_lambda_grid_L0_checks(f, loss): _ = f(x, y, loss=loss, penalty="L0", lambda_grid=[[10]], num_gamma=None, num_lambda=None) +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_bad_lambda_grid_L0_checks(f): + # Check size of matrix X + x = np.random.random(size=(N, N)) + y = np.random.random(size=N) + lambda_grid = [[10], [10]] + + with pytest.raises(ValueError): + _ = f(x, y, penalty="L0", lambda_grid=lambda_grid, num_gamma=None, num_lambda=None) + + _ = f(x, y, penalty="L0", lambda_grid=[[10]], num_gamma=None, num_lambda=None) + + + @pytest.mark.parametrize("penalty", ["L0L1", "L0L2"]) @pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) def test_regression_loss_bad_num_gamma_L0_checks(f, penalty): @@ -326,14 +338,13 @@ def test_lambda_grid_bad_over_defined_checks(f, penalty): _ = f(x, y, penalty=penalty, lambda_grid=[[10], [10]], num_lambda=None, num_gamma=None) -@pytest.mark.parametrize("penalty_lambda_grid", [("L0", [[10], [10]]), - ("L0", [[-1]]), +@pytest.mark.parametrize("penalty_lambda_grid", [("L0L1", [[-1]]), ("L0", [[10, 11]]),]) @pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) def test_lambda_grid_bad_checks(f, penalty_lambda_grid): penalty, lambda_grid = penalty_lambda_grid x = np.random.random(size=(N, N)) - y = np.random.randint(0, 2, size=N) + y = np.random.random(size=N) with pytest.raises(ValueError): _ = f(x, y, penalty=penalty, lambda_grid=lambda_grid, num_gamma=None, num_lambda=None) @@ -356,7 +367,7 @@ def test_with_bounds_bad_checks(f, bounds): lows, highs = bounds x = np.random.random(size=(N, N)) - y = np.random.randint(0, 2, size=N) + y = np.random.random(size=N) with pytest.raises(ValueError): _ = f(x, y, lows=lows, highs=highs) From 4935e194f827c57ef8e706bd880474ada47a127d Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Wed, 24 Nov 2021 11:15:14 -0500 Subject: [PATCH 073/125] Update X matrix checks and sparse X handling --- python/l0learn/interface.cpp | 14719 ++++++++++++++------------------- python/l0learn/interface.pyx | 18 +- python/tests/test_fit.py | 10 +- 3 files changed, 6425 insertions(+), 8322 deletions(-) diff --git a/python/l0learn/interface.cpp b/python/l0learn/interface.cpp index 5ffd469..00629ab 100644 --- a/python/l0learn/interface.cpp +++ b/python/l0learn/interface.cpp @@ -3,12 +3,6 @@ /* BEGIN: Cython Metadata { "distutils": { - "define_macros": [ - [ - "CYTHON_TRACE_NOGIL", - "1" - ] - ], "depends": [ "/Users/tnonet/opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/core/include/numpy/arrayobject.h", "/Users/tnonet/opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/core/include/numpy/arrayscalars.h", @@ -1259,254 +1253,23 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); -/* PyThreadStateGet.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; -#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; -#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type -#else -#define __Pyx_PyThreadState_declare -#define __Pyx_PyThreadState_assign -#define __Pyx_PyErr_Occurred() PyErr_Occurred() -#endif +/* RaiseArgTupleInvalid.proto */ +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); -/* PyErrFetchRestore.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) -#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) -#else -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) -#endif -#else -#define __Pyx_PyErr_Clear() PyErr_Clear() -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) -#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) -#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) -#endif +/* RaiseDoubleKeywords.proto */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); -/* Profile.proto */ -#ifndef CYTHON_PROFILE -#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON - #define CYTHON_PROFILE 0 -#else - #define CYTHON_PROFILE 1 -#endif -#endif -#ifndef CYTHON_TRACE_NOGIL - #define CYTHON_TRACE_NOGIL 0 -#else - #if CYTHON_TRACE_NOGIL && !defined(CYTHON_TRACE) - #define CYTHON_TRACE 1 - #endif -#endif -#ifndef CYTHON_TRACE - #define CYTHON_TRACE 0 -#endif -#if CYTHON_TRACE - #undef CYTHON_PROFILE_REUSE_FRAME -#endif -#ifndef CYTHON_PROFILE_REUSE_FRAME - #define CYTHON_PROFILE_REUSE_FRAME 0 -#endif -#if CYTHON_PROFILE || CYTHON_TRACE - #include "compile.h" - #include "frameobject.h" - #include "traceback.h" - #if CYTHON_PROFILE_REUSE_FRAME - #define CYTHON_FRAME_MODIFIER static - #define CYTHON_FRAME_DEL(frame) - #else - #define CYTHON_FRAME_MODIFIER - #define CYTHON_FRAME_DEL(frame) Py_CLEAR(frame) - #endif - #define __Pyx_TraceDeclarations\ - static PyCodeObject *__pyx_frame_code = NULL;\ - CYTHON_FRAME_MODIFIER PyFrameObject *__pyx_frame = NULL;\ - int __Pyx_use_tracing = 0; - #define __Pyx_TraceFrameInit(codeobj)\ - if (codeobj) __pyx_frame_code = (PyCodeObject*) codeobj; -#if PY_VERSION_HEX >= 0x030a00b1 - #define __Pyx_IsTracing(tstate, check_tracing, check_funcs)\ - (unlikely((tstate)->cframe->use_tracing) &&\ - (!(check_tracing) || !(tstate)->tracing) &&\ - (!(check_funcs) || (tstate)->c_profilefunc || (CYTHON_TRACE && (tstate)->c_tracefunc))) - #define __Pyx_SetTracing(tstate, enable)\ - (tstate)->cframe->use_tracing = (enable) -#else - #define __Pyx_IsTracing(tstate, check_tracing, check_funcs)\ - (unlikely((tstate)->use_tracing) &&\ - (!(check_tracing) || !(tstate)->tracing) &&\ - (!(check_funcs) || (tstate)->c_profilefunc || (CYTHON_TRACE && (tstate)->c_tracefunc))) - #define __Pyx_SetTracing(tstate, enable)\ - (tstate)->use_tracing = (enable) -#endif - #ifdef WITH_THREAD - #define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error)\ - if (nogil) {\ - if (CYTHON_TRACE_NOGIL) {\ - PyThreadState *tstate;\ - PyGILState_STATE state = PyGILState_Ensure();\ - tstate = __Pyx_PyThreadState_Current;\ - if (__Pyx_IsTracing(tstate, 1, 1)) {\ - __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ - }\ - PyGILState_Release(state);\ - if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ - }\ - } else {\ - PyThreadState* tstate = PyThreadState_GET();\ - if (__Pyx_IsTracing(tstate, 1, 1)) {\ - __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ - if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ - }\ - } - #else - #define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error)\ - { PyThreadState* tstate = PyThreadState_GET();\ - if (__Pyx_IsTracing(tstate, 1, 1)) {\ - __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ - if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ - }\ - } - #endif - #define __Pyx_TraceException()\ - if (likely(!__Pyx_use_tracing)); else {\ - PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (__Pyx_IsTracing(tstate, 0, 1)) {\ - tstate->tracing++;\ - __Pyx_SetTracing(tstate, 0);\ - PyObject *exc_info = __Pyx_GetExceptionTuple(tstate);\ - if (exc_info) {\ - if (CYTHON_TRACE && tstate->c_tracefunc)\ - tstate->c_tracefunc(\ - tstate->c_traceobj, __pyx_frame, PyTrace_EXCEPTION, exc_info);\ - tstate->c_profilefunc(\ - tstate->c_profileobj, __pyx_frame, PyTrace_EXCEPTION, exc_info);\ - Py_DECREF(exc_info);\ - }\ - __Pyx_SetTracing(tstate, 1);\ - tstate->tracing--;\ - }\ - } - static void __Pyx_call_return_trace_func(PyThreadState *tstate, PyFrameObject *frame, PyObject *result) { - PyObject *type, *value, *traceback; - __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); - tstate->tracing++; - __Pyx_SetTracing(tstate, 0); - if (CYTHON_TRACE && tstate->c_tracefunc) - tstate->c_tracefunc(tstate->c_traceobj, frame, PyTrace_RETURN, result); - if (tstate->c_profilefunc) - tstate->c_profilefunc(tstate->c_profileobj, frame, PyTrace_RETURN, result); - CYTHON_FRAME_DEL(frame); - __Pyx_SetTracing(tstate, 1); - tstate->tracing--; - __Pyx_ErrRestoreInState(tstate, type, value, traceback); - } - #ifdef WITH_THREAD - #define __Pyx_TraceReturn(result, nogil)\ - if (likely(!__Pyx_use_tracing)); else {\ - if (nogil) {\ - if (CYTHON_TRACE_NOGIL) {\ - PyThreadState *tstate;\ - PyGILState_STATE state = PyGILState_Ensure();\ - tstate = __Pyx_PyThreadState_Current;\ - if (__Pyx_IsTracing(tstate, 0, 0)) {\ - __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ - }\ - PyGILState_Release(state);\ - }\ - } else {\ - PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (__Pyx_IsTracing(tstate, 0, 0)) {\ - __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ - }\ - }\ - } - #else - #define __Pyx_TraceReturn(result, nogil)\ - if (likely(!__Pyx_use_tracing)); else {\ - PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (__Pyx_IsTracing(tstate, 0, 0)) {\ - __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ - }\ - } - #endif - static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno); - static int __Pyx_TraceSetupAndCall(PyCodeObject** code, PyFrameObject** frame, PyThreadState* tstate, const char *funcname, const char *srcfile, int firstlineno); -#else - #define __Pyx_TraceDeclarations - #define __Pyx_TraceFrameInit(codeobj) - #define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error) if ((1)); else goto_error; - #define __Pyx_TraceException() - #define __Pyx_TraceReturn(result, nogil) -#endif -#if CYTHON_TRACE - static int __Pyx_call_line_trace_func(PyThreadState *tstate, PyFrameObject *frame, int lineno) { - int ret; - PyObject *type, *value, *traceback; - __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); - __Pyx_PyFrame_SetLineNumber(frame, lineno); - tstate->tracing++; - __Pyx_SetTracing(tstate, 0); - ret = tstate->c_tracefunc(tstate->c_traceobj, frame, PyTrace_LINE, NULL); - __Pyx_SetTracing(tstate, 1); - tstate->tracing--; - if (likely(!ret)) { - __Pyx_ErrRestoreInState(tstate, type, value, traceback); - } else { - Py_XDECREF(type); - Py_XDECREF(value); - Py_XDECREF(traceback); - } - return ret; - } - #ifdef WITH_THREAD - #define __Pyx_TraceLine(lineno, nogil, goto_error)\ - if (likely(!__Pyx_use_tracing)); else {\ - if (nogil) {\ - if (CYTHON_TRACE_NOGIL) {\ - int ret = 0;\ - PyThreadState *tstate;\ - PyGILState_STATE state = PyGILState_Ensure();\ - tstate = __Pyx_PyThreadState_Current;\ - if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && __pyx_frame->f_trace) {\ - ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ - }\ - PyGILState_Release(state);\ - if (unlikely(ret)) goto_error;\ - }\ - } else {\ - PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && __pyx_frame->f_trace) {\ - int ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ - if (unlikely(ret)) goto_error;\ - }\ - }\ - } - #else - #define __Pyx_TraceLine(lineno, nogil, goto_error)\ - if (likely(!__Pyx_use_tracing)); else {\ - PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && __pyx_frame->f_trace) {\ - int ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ - if (unlikely(ret)) goto_error;\ - }\ - } - #endif -#else - #define __Pyx_TraceLine(lineno, nogil, goto_error) if ((1)); else goto_error; -#endif +/* ParseKeywords.proto */ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ + const char* function_name); + +/* ArgTypeTest.proto */ +#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ + ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ + __Pyx__ArgTypeTest(obj, type, name, exact)) +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS @@ -1555,27 +1318,6 @@ static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_ve static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); #endif -/* DictGetItem.proto */ -#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY -static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); -#define __Pyx_PyObject_Dict_GetItem(obj, name)\ - (likely(PyDict_CheckExact(obj)) ?\ - __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name)) -#else -#define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) -#define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) -#endif - -/* PyObjectCall.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); -#else -#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) -#endif - -/* RaiseException.proto */ -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); - /* PyObjectFormatSimple.proto */ #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyObject_FormatSimple(s, f) (\ @@ -1635,6 +1377,13 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) #endif +/* PyObjectCall.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + /* PyObjectCallMethO.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); @@ -1643,33 +1392,51 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject /* PyObjectCallOneArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); -/* PyIntCompare.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, long intval, long inplace); - -/* PyObjectCall2Args.proto */ -static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); - -/* RaiseArgTupleInvalid.proto */ -static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, - Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); - -/* RaiseDoubleKeywords.proto */ -static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() PyErr_Occurred() +#endif -/* ParseKeywords.proto */ -static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ - PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ - const char* function_name); +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +#else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif -/* ArgTypeTest.proto */ -#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ - ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ - __Pyx__ArgTypeTest(obj, type, name, exact)) -static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /* PyIntCompare.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_NeObjC(PyObject *op1, PyObject *op2, long intval, long inplace); +/* PyObjectCall2Args.proto */ +static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); + /* RaiseTooManyValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); @@ -1697,6 +1464,9 @@ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int eq /* UnicodeEquals.proto */ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); +/* PyIntCompare.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, long intval, long inplace); + /* PyUnicode_Substring.proto */ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_Substring( PyObject* text, Py_ssize_t start, Py_ssize_t stop); @@ -1756,6 +1526,17 @@ static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, int wraparound, int boundscheck); +/* DictGetItem.proto */ +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); +#define __Pyx_PyObject_Dict_GetItem(obj, name)\ + (likely(PyDict_CheckExact(obj)) ?\ + __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name)) +#else +#define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) +#define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) +#endif + /* GetTopmostException.proto */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); @@ -1791,11 +1572,6 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); /* ExtTypeTest.proto */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); -/* WriteUnraisableException.proto */ -static void __Pyx_WriteUnraisable(const char *name, int clineno, - int lineno, const char *filename, - int full_traceback, int nogil); - /* ListCompAppend.proto */ #if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { @@ -2066,13 +1842,14 @@ int __pyx_module_is_main_l0learn__interface = 0; /* Implementation of 'l0learn.interface' */ static PyObject *__pyx_builtin_ValueError; -static PyObject *__pyx_builtin_NotImplementedError; static PyObject *__pyx_builtin_enumerate; static PyObject *__pyx_builtin_any; static PyObject *__pyx_builtin_all; static PyObject *__pyx_builtin_TypeError; static PyObject *__pyx_builtin_ImportError; static PyObject *__pyx_builtin_range; +static const char __pyx_k_[] = "."; +static const char __pyx_k_D[] = "D"; static const char __pyx_k_X[] = "X"; static const char __pyx_k_a[] = "a"; static const char __pyx_k_i[] = "i"; @@ -2081,14 +1858,11 @@ static const char __pyx_k_p[] = "p"; static const char __pyx_k_y[] = "y"; static const char __pyx_k_CD[] = "CD"; static const char __pyx_k_L0[] = "L0"; -static const char __pyx_k__6[] = "."; static const char __pyx_k_np[] = "np"; -static const char __pyx_k_or[] = " or "; static const char __pyx_k_Any[] = "Any"; -static const char __pyx_k__21[] = "_"; +static const char __pyx_k__11[] = "_"; static const char __pyx_k_all[] = "all"; static const char __pyx_k_any[] = "any"; -static const char __pyx_k_arr[] = "arr"; static const char __pyx_k_fit[] = "fit"; static const char __pyx_k_inf[] = "inf"; static const char __pyx_k_Dict[] = "Dict"; @@ -2098,7 +1872,6 @@ static const char __pyx_k_List[] = "List"; static const char __pyx_k_None[] = "None"; static const char __pyx_k_atol[] = "atol"; static const char __pyx_k_copy[] = "copy"; -static const char __pyx_k_data[] = "data"; static const char __pyx_k_diff[] = "diff"; static const char __pyx_k_loss[] = "loss"; static const char __pyx_k_lows[] = "lows"; @@ -2106,6 +1879,7 @@ static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_name[] = "__name__"; static const char __pyx_k_ndim[] = "ndim"; static const char __pyx_k_ones[] = "ones"; +static const char __pyx_k_or_a[] = " or a "; static const char __pyx_k_rtol[] = "rtol"; static const char __pyx_k_seed[] = "seed"; static const char __pyx_k_test[] = "__test__"; @@ -2116,7 +1890,6 @@ static const char __pyx_k_array[] = "array"; static const char __pyx_k_check[] = "check"; static const char __pyx_k_cvfit[] = "cvfit"; static const char __pyx_k_dtype[] = "dtype"; -static const char __pyx_k_flags[] = "flags"; static const char __pyx_k_gamma[] = "gamma"; static const char __pyx_k_highs[] = "highs"; static const char __pyx_k_numpy[] = "numpy"; @@ -2127,14 +1900,11 @@ static const char __pyx_k_c_loss[] = "c_loss"; static const char __pyx_k_coeffs[] = "coeffs"; static const char __pyx_k_cv_sds[] = "cv_sds"; static const char __pyx_k_import[] = "__import__"; -static const char __pyx_k_indptr[] = "indptr"; -static const char __pyx_k_number[] = "number"; static const char __pyx_k_typing[] = "typing"; static const char __pyx_k_unique[] = "unique"; static const char __pyx_k_but_got[] = ", but got "; static const char __pyx_k_current[] = "current"; static const char __pyx_k_float64[] = "float64"; -static const char __pyx_k_indices[] = "indices"; static const char __pyx_k_l0learn[] = "l0learn"; static const char __pyx_k_ndarray[] = "ndarray"; static const char __pyx_k_penalty[] = "penalty"; @@ -2167,10 +1937,8 @@ static const char __pyx_k_CVFitModel[] = "CVFitModel"; static const char __pyx_k_ValueError[] = "ValueError"; static const char __pyx_k_active_set[] = "active_set"; static const char __pyx_k_bad_bounds[] = "bad_bounds"; -static const char __pyx_k_contiguous[] = "contiguous"; static const char __pyx_k_csc_matrix[] = "csc_matrix"; static const char __pyx_k_intercepts[] = "intercepts"; -static const char __pyx_k_issubdtype[] = "issubdtype"; static const char __pyx_k_num_lambda[] = "num_lambda"; static const char __pyx_k_ImportError[] = "ImportError"; static const char __pyx_k_auto_lambda[] = "auto_lambda"; @@ -2178,7 +1946,6 @@ static const char __pyx_k_first_value[] = "first_value"; static const char __pyx_k_lambda_grid[] = "lambda_grid"; static const char __pyx_k_screen_size[] = "screen_size"; static const char __pyx_k_with_bounds[] = "with_bounds"; -static const char __pyx_k_F_CONTIGUOUS[] = "F_CONTIGUOUS"; static const char __pyx_k_SquaredError[] = "SquaredError"; static const char __pyx_k_SquaredHinge[] = "SquaredHinge"; static const char __pyx_k_c_algorithim[] = "c_algorithim"; @@ -2187,7 +1954,6 @@ static const char __pyx_k_scipy_sparse[] = "scipy.sparse"; static const char __pyx_k_second_value[] = "second_value"; static const char __pyx_k_support_size[] = "support_size"; static const char __pyx_k_unique_items[] = "unique_items"; -static const char __pyx_k_Not_supported[] = ". Not supported"; static const char __pyx_k_c_lambda_grid[] = "c_lambda_grid"; static const char __pyx_k_SUPPORTED_LOSS[] = "SUPPORTED_LOSS"; static const char __pyx_k_active_set_num[] = "active_set_num"; @@ -2196,28 +1962,27 @@ static const char __pyx_k_bad_lambda_grid[] = "bad_lambda_grid"; static const char __pyx_k_exclude_first_k[] = "exclude_first_k"; static const char __pyx_k_sub_lambda_grid[] = "sub_lambda_grid"; static const char __pyx_k_max_support_size[] = "max_support_size"; -static const char __pyx_k_np_to_arma_check[] = "np_to_arma_check"; static const char __pyx_k_penalty_Only_one[] = " penalty. Only one "; static const char __pyx_k_SUPPORTED_PENALTY[] = "SUPPORTED_PENALTY"; static const char __pyx_k_l0learn_interface[] = "l0learn.interface"; static const char __pyx_k_scale_down_factor[] = "scale_down_factor"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; +static const char __pyx_k_expected_X_to_be_a[] = "expected X to be a "; static const char __pyx_k_CLASSIFICATION_LOSS[] = "CLASSIFICATION_LOSS"; -static const char __pyx_k_NotImplementedError[] = "NotImplementedError"; static const char __pyx_k_SUPPORTED_ALGORITHM[] = "SUPPORTED_ALGORITHM"; static const char __pyx_k_l0learn_interface_pyx[] = "l0learn/interface.pyx"; static const char __pyx_k_num_gamma_set_to_1_with[] = "num_gamma set to 1 with "; +static const char __pyx_k_expected_X_to_have_dtype[] = "expected X to have dtype "; static const char __pyx_k_penalty_value_will_be_fit[] = " penalty value will be fit."; -static const char __pyx_k_expected_arr_to_be_of_type[] = "expected arr to be of type "; static const char __pyx_k_where_that_is_not_the_case[] = " where that is not the case "; static const char __pyx_k_containing_a_negative_value[] = "] containing a negative value"; +static const char __pyx_k_expected_X_to_be_2D_but_got[] = "expected X to be 2D, but got "; static const char __pyx_k_containing_an_increasing_value[] = "] containing an increasing value."; static const char __pyx_k_expected_y_vector_to_have_type[] = "expected y vector to have type "; static const char __pyx_k_of_non_negative_floats_but_got[] = " of non-negative floats, but got "; static const char __pyx_k_Expected_each_element_of_lambda[] = "Expected each element of lambda_grid to be a list of decreasing value, but got lambda_grid["; static const char __pyx_k_L0_Penalty_requires_lambda_grid[] = "L0 Penalty requires 'lambda_grid' to be a list of length 1, but got "; static const char __pyx_k_expected_algorithm_parameter_to[] = "expected algorithm parameter to be on of "; -static const char __pyx_k_expected_arr_to_be_F_CONTIGUOUS[] = "expected arr to be F_CONTIGUOUS."; static const char __pyx_k_expected_gamma_max_parameter_to[] = "expected gamma_max parameter to be a positive float, but got "; static const char __pyx_k_expected_intercept_parameter_to[] = "expected intercept parameter to be a bool, but got "; static const char __pyx_k_expected_max_swaps_parameter_to[] = "expected max_swaps parameter to be a positive integer, but got "; @@ -2226,13 +1991,9 @@ static const char __pyx_k_expected_partial_sort_parameter[] = "expected partial_ static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import"; static const char __pyx_k_of_non_positives_floats_but_got[] = " of non-positives floats, but got "; static const char __pyx_k_Expected_all_values_of_lambda_gr[] = "Expected all values of lambda_grid to be positive, but got lambda_grid["; -static const char __pyx_k_expected_X_to_be_a_2D_continuous[] = "expected X to be a 2D continuous non-degenerate real numpy or csc_matrix, but got "; +static const char __pyx_k_expected_X_to_have_non_degenerat[] = "expected X to have non-degenerate axis, but got "; static const char __pyx_k_expected_active_set_num_paramete[] = "expected active_set_num parameter to be a positive integer, but got "; static const char __pyx_k_expected_active_set_parameter_to[] = "expected active_set parameter to be a bool, but got "; -static const char __pyx_k_expected_arr_data_to_be_F_CONTIG[] = "expected arr.data to be F_CONTIGUOUS."; -static const char __pyx_k_expected_arr_indices_to_be_F_CON[] = "expected arr.indices to be F_CONTIGUOUS."; -static const char __pyx_k_expected_arr_indptr_to_be_F_CONT[] = "expected arr.indptr to be F_CONTIGUOUS."; -static const char __pyx_k_expected_arr_ndim_to_be_1_or_2_b[] = "expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar"; static const char __pyx_k_expected_atol_parameter_to_exist[] = "expected atol parameter to exist in [0, INF), but got "; static const char __pyx_k_expected_exclude_first_k_paramet[] = "expected exclude_first_k parameter to be a positive integer less than "; static const char __pyx_k_expected_highs_to_be_a_non_negat[] = "expected highs to be a non-negative float, but got "; @@ -2242,14 +2003,11 @@ static const char __pyx_k_expected_loss_parameter_to_be_on[] = "expected loss pa static const char __pyx_k_expected_lows_to_be_a_non_positi[] = "expected lows to be a non-positive float, but got "; static const char __pyx_k_expected_max_iter_parameter_to_b[] = "expected max_iter parameter to be a positive integer, but got "; static const char __pyx_k_expected_max_support_size_parame[] = "expected max_support_size parameter to be a positive integer, but got "; -static const char __pyx_k_expected_non_complex_dtype_but_g[] = "expected non-complex dtype, but got "; -static const char __pyx_k_expected_non_degenerate_dimensio[] = "expected non-degenerate dimensions of arr, but got "; static const char __pyx_k_expected_num_gamma_to_1_when_pen[] = "expected num_gamma to 1 when penalty = 'L0', but got "; static const char __pyx_k_expected_num_gamma_to_a_positive[] = "expected num_gamma to a positive integer when lambda_grid is None, but got "; static const char __pyx_k_expected_num_gamma_to_be_None_if[] = "expected num_gamma to be None if lambda_grid is specified by the user, but got "; static const char __pyx_k_expected_num_lambda_to_a_positiv[] = "expected num_lambda to a positive integer when lambda_grid is None, but got "; static const char __pyx_k_expected_num_lambda_to_be_None_i[] = "expected num_lambda to be None if lambda_grid is specified by the user, but got "; -static const char __pyx_k_expected_numerical_dtype_but_got[] = "expected numerical dtype, but got "; static const char __pyx_k_expected_penalty_parameter_to_be[] = "expected penalty parameter to be on of "; static const char __pyx_k_expected_rtol_parameter_to_exist[] = "expected rtol parameter to exist in [0, 1), but got "; static const char __pyx_k_expected_scale_down_factor_param[] = "expected scale_down_factor parameter to exist in (0, 1), but got "; @@ -2259,18 +2017,18 @@ static const char __pyx_k_expected_y_to_be_a_1D_real_numpy[] = "expected y to be static const char __pyx_k_expected_y_vector_to_only_have_t[] = "expected y vector to only have two unique values (Binary Classification), but got "; static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import"; static const char __pyx_k_expected_gamma_max_parameter_to_2[] = "expected gamma_max parameter to be a positive float less than gamma_max, but got "; -static const char __pyx_k_expected_arr_ndim_to_be_1_or_2_b_2[] = "expected 'arr.ndim' to be 1 or 2, but got "; static const char __pyx_k_expected_highs_to_be_a_non_negat_2[] = "expected highs to be a non-negative float, or a 1D numpy array of length "; static const char __pyx_k_expected_lows_to_be_a_non_positi_2[] = "expected lows to be a non-positive float, or a 1D numpy array of length "; +static PyObject *__pyx_kp_u_; static PyObject *__pyx_n_s_Any; static PyObject *__pyx_n_u_CD; static PyObject *__pyx_n_u_CDPSI; static PyObject *__pyx_n_s_CLASSIFICATION_LOSS; static PyObject *__pyx_n_s_CVFitModel; +static PyObject *__pyx_n_u_D; static PyObject *__pyx_n_s_Dict; static PyObject *__pyx_kp_u_Expected_all_values_of_lambda_gr; static PyObject *__pyx_kp_u_Expected_each_element_of_lambda; -static PyObject *__pyx_n_u_F_CONTIGUOUS; static PyObject *__pyx_n_s_FitModel; static PyObject *__pyx_n_s_ImportError; static PyObject *__pyx_n_u_L0; @@ -2280,8 +2038,6 @@ static PyObject *__pyx_kp_u_L0_Penalty_requires_lambda_grid; static PyObject *__pyx_n_s_List; static PyObject *__pyx_n_u_Logistic; static PyObject *__pyx_kp_u_None; -static PyObject *__pyx_n_s_NotImplementedError; -static PyObject *__pyx_kp_u_Not_supported; static PyObject *__pyx_n_s_Optional; static PyObject *__pyx_n_s_SUPPORTED_ALGORITHM; static PyObject *__pyx_n_s_SUPPORTED_LOSS; @@ -2292,8 +2048,7 @@ static PyObject *__pyx_n_s_TypeError; static PyObject *__pyx_n_s_Union; static PyObject *__pyx_n_s_ValueError; static PyObject *__pyx_n_s_X; -static PyObject *__pyx_n_s__21; -static PyObject *__pyx_kp_u__6; +static PyObject *__pyx_n_s__11; static PyObject *__pyx_n_s_a; static PyObject *__pyx_n_s_active_set; static PyObject *__pyx_n_s_active_set_num; @@ -2301,7 +2056,6 @@ static PyObject *__pyx_n_s_algorithm; static PyObject *__pyx_n_s_all; static PyObject *__pyx_n_s_any; static PyObject *__pyx_n_s_argwhere; -static PyObject *__pyx_n_s_arr; static PyObject *__pyx_n_s_array; static PyObject *__pyx_n_s_astype; static PyObject *__pyx_n_s_atol; @@ -2320,7 +2074,6 @@ static PyObject *__pyx_n_s_cline_in_traceback; static PyObject *__pyx_n_s_coeffs; static PyObject *__pyx_kp_u_containing_a_negative_value; static PyObject *__pyx_kp_u_containing_an_increasing_value; -static PyObject *__pyx_n_s_contiguous; static PyObject *__pyx_n_s_converged; static PyObject *__pyx_n_s_copy; static PyObject *__pyx_n_s_csc_matrix; @@ -2328,22 +2081,17 @@ static PyObject *__pyx_n_s_current; static PyObject *__pyx_n_s_cv_means; static PyObject *__pyx_n_s_cv_sds; static PyObject *__pyx_n_s_cvfit; -static PyObject *__pyx_n_s_data; static PyObject *__pyx_n_s_diff; static PyObject *__pyx_n_s_dtype; static PyObject *__pyx_n_s_enumerate; static PyObject *__pyx_n_s_exclude_first_k; -static PyObject *__pyx_kp_u_expected_X_to_be_a_2D_continuous; +static PyObject *__pyx_kp_u_expected_X_to_be_2D_but_got; +static PyObject *__pyx_kp_u_expected_X_to_be_a; +static PyObject *__pyx_kp_u_expected_X_to_have_dtype; +static PyObject *__pyx_kp_u_expected_X_to_have_non_degenerat; static PyObject *__pyx_kp_u_expected_active_set_num_paramete; static PyObject *__pyx_kp_u_expected_active_set_parameter_to; static PyObject *__pyx_kp_u_expected_algorithm_parameter_to; -static PyObject *__pyx_kp_u_expected_arr_data_to_be_F_CONTIG; -static PyObject *__pyx_kp_u_expected_arr_indices_to_be_F_CON; -static PyObject *__pyx_kp_u_expected_arr_indptr_to_be_F_CONT; -static PyObject *__pyx_kp_u_expected_arr_ndim_to_be_1_or_2_b; -static PyObject *__pyx_kp_u_expected_arr_ndim_to_be_1_or_2_b_2; -static PyObject *__pyx_kp_u_expected_arr_to_be_F_CONTIGUOUS; -static PyObject *__pyx_kp_u_expected_arr_to_be_of_type; static PyObject *__pyx_kp_u_expected_atol_parameter_to_exist; static PyObject *__pyx_kp_u_expected_exclude_first_k_paramet; static PyObject *__pyx_kp_u_expected_gamma_max_parameter_to; @@ -2359,15 +2107,12 @@ static PyObject *__pyx_kp_u_expected_lows_to_be_a_non_positi_2; static PyObject *__pyx_kp_u_expected_max_iter_parameter_to_b; static PyObject *__pyx_kp_u_expected_max_support_size_parame; static PyObject *__pyx_kp_u_expected_max_swaps_parameter_to; -static PyObject *__pyx_kp_u_expected_non_complex_dtype_but_g; -static PyObject *__pyx_kp_u_expected_non_degenerate_dimensio; static PyObject *__pyx_kp_u_expected_num_folds_parameter_to; static PyObject *__pyx_kp_u_expected_num_gamma_to_1_when_pen; static PyObject *__pyx_kp_u_expected_num_gamma_to_a_positive; static PyObject *__pyx_kp_u_expected_num_gamma_to_be_None_if; static PyObject *__pyx_kp_u_expected_num_lambda_to_a_positiv; static PyObject *__pyx_kp_u_expected_num_lambda_to_be_None_i; -static PyObject *__pyx_kp_u_expected_numerical_dtype_but_got; static PyObject *__pyx_kp_u_expected_partial_sort_parameter; static PyObject *__pyx_kp_u_expected_penalty_parameter_to_be; static PyObject *__pyx_kp_u_expected_rtol_parameter_to_exist; @@ -2380,7 +2125,6 @@ static PyObject *__pyx_kp_u_expected_y_vector_to_only_have_t; static PyObject *__pyx_n_s_first_value; static PyObject *__pyx_n_s_fit; static PyObject *__pyx_n_s_fit_check; -static PyObject *__pyx_n_s_flags; static PyObject *__pyx_n_s_float64; static PyObject *__pyx_n_s_gamma; static PyObject *__pyx_n_s_gamma_max; @@ -2391,14 +2135,11 @@ static PyObject *__pyx_n_s_highs; static PyObject *__pyx_n_u_highs; static PyObject *__pyx_n_s_i; static PyObject *__pyx_n_s_import; -static PyObject *__pyx_n_s_indices; -static PyObject *__pyx_n_s_indptr; static PyObject *__pyx_n_u_inf; static PyObject *__pyx_n_s_intercept; static PyObject *__pyx_n_u_intercept; static PyObject *__pyx_n_s_intercepts; static PyObject *__pyx_n_s_isrealobj; -static PyObject *__pyx_n_s_issubdtype; static PyObject *__pyx_n_s_l0learn; static PyObject *__pyx_n_s_l0learn_interface; static PyObject *__pyx_kp_s_l0learn_interface_pyx; @@ -2420,21 +2161,19 @@ static PyObject *__pyx_n_s_name; static PyObject *__pyx_n_s_ndarray; static PyObject *__pyx_n_s_ndim; static PyObject *__pyx_n_s_np; -static PyObject *__pyx_n_s_np_to_arma_check; static PyObject *__pyx_n_s_num_folds; static PyObject *__pyx_n_s_num_gamma; static PyObject *__pyx_n_u_num_gamma; static PyObject *__pyx_kp_u_num_gamma_set_to_1_with; static PyObject *__pyx_n_s_num_lambda; static PyObject *__pyx_n_u_num_lambda; -static PyObject *__pyx_n_s_number; static PyObject *__pyx_n_s_numpy; static PyObject *__pyx_kp_u_numpy_core_multiarray_failed_to; static PyObject *__pyx_kp_u_numpy_core_umath_failed_to_impor; static PyObject *__pyx_kp_u_of_non_negative_floats_but_got; static PyObject *__pyx_kp_u_of_non_positives_floats_but_got; static PyObject *__pyx_n_s_ones; -static PyObject *__pyx_kp_u_or; +static PyObject *__pyx_kp_u_or_a; static PyObject *__pyx_n_s_p; static PyObject *__pyx_n_s_partial_sort; static PyObject *__pyx_n_s_penalty; @@ -2466,10 +2205,9 @@ static PyObject *__pyx_n_s_with_bounds; static PyObject *__pyx_n_u_with_bounds; static PyObject *__pyx_n_s_y; static PyObject *__pyx_n_u_y; -static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_arr); /* proto */ -static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs); /* proto */ -static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs); /* proto */ -static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_num_folds, PyObject *__pyx_v_seed, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs); /* proto */ +static PyObject *__pyx_pf_7l0learn_9interface__fit_check(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs); /* proto */ +static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs); /* proto */ +static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_num_folds, PyObject *__pyx_v_seed, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs); /* proto */ static PyObject *__pyx_float_0_; static PyObject *__pyx_float_1_0; static PyObject *__pyx_float_neg_1_0; @@ -2481,788 +2219,66 @@ static PyObject *__pyx_int_10; static PyObject *__pyx_int_100; static PyObject *__pyx_int_200; static PyObject *__pyx_int_1000; -static PyObject *__pyx_k__9; -static PyObject *__pyx_k__10; -static PyObject *__pyx_k__12; -static PyObject *__pyx_k__13; -static PyObject *__pyx_codeobj_; -static PyObject *__pyx_tuple__2; -static PyObject *__pyx_tuple__3; -static PyObject *__pyx_tuple__4; -static PyObject *__pyx_tuple__5; +static PyObject *__pyx_k__2; +static PyObject *__pyx_k__3; +static PyObject *__pyx_k__4; +static PyObject *__pyx_k__5; +static PyObject *__pyx_tuple__6; static PyObject *__pyx_tuple__7; -static PyObject *__pyx_tuple__15; +static PyObject *__pyx_tuple__8; +static PyObject *__pyx_tuple__9; +static PyObject *__pyx_tuple__10; +static PyObject *__pyx_tuple__12; +static PyObject *__pyx_tuple__14; static PyObject *__pyx_tuple__16; -static PyObject *__pyx_tuple__17; -static PyObject *__pyx_tuple__18; -static PyObject *__pyx_tuple__19; -static PyObject *__pyx_tuple__20; -static PyObject *__pyx_tuple__22; -static PyObject *__pyx_tuple__23; -static PyObject *__pyx_tuple__24; -static PyObject *__pyx_codeobj__8; -static PyObject *__pyx_codeobj__11; -static PyObject *__pyx_codeobj__14; +static PyObject *__pyx_codeobj__13; +static PyObject *__pyx_codeobj__15; +static PyObject *__pyx_codeobj__17; /* Late includes */ -/* "l0learn/interface.pyx":16 - * from l0learn.models import FitModel, CVFitModel +/* "l0learn/interface.pyx":52 * - * def np_to_arma_check(arr): # <<<<<<<<<<<<<< - * # TODO: Add checks for Behaved and OwnsData - * if isinstance(arr, np.ndarray): + * + * def _fit_check(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< + * y: np.ndarray, + * loss: str, */ /* Python wrapper */ -static PyObject *__pyx_pw_7l0learn_9interface_1np_to_arma_check(PyObject *__pyx_self, PyObject *__pyx_v_arr); /*proto*/ -static char __pyx_doc_7l0learn_9interface_np_to_arma_check[] = "np_to_arma_check(arr)"; -static PyMethodDef __pyx_mdef_7l0learn_9interface_1np_to_arma_check = {"np_to_arma_check", (PyCFunction)__pyx_pw_7l0learn_9interface_1np_to_arma_check, METH_O, __pyx_doc_7l0learn_9interface_np_to_arma_check}; -static PyObject *__pyx_pw_7l0learn_9interface_1np_to_arma_check(PyObject *__pyx_self, PyObject *__pyx_v_arr) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("np_to_arma_check (wrapper)", 0); - __pyx_r = __pyx_pf_7l0learn_9interface_np_to_arma_check(__pyx_self, ((PyObject *)__pyx_v_arr)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_7l0learn_9interface_np_to_arma_check(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_arr) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - int __pyx_t_3; - int __pyx_t_4; - Py_ssize_t __pyx_t_5; - Py_UCS4 __pyx_t_6; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - PyObject *__pyx_t_9 = NULL; - int __pyx_t_10; - PyObject *__pyx_t_11 = NULL; +static PyObject *__pyx_pw_7l0learn_9interface_1_fit_check(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_7l0learn_9interface__fit_check[] = "_fit_check(X: Union[np.ndarray, csc_matrix], y: np.ndarray, unicode loss: str, unicode penalty: str, unicode algorithm: str, max_support_size: int, num_lambda: Union[int, None], num_gamma: Union[int, None], double gamma_max: float, double gamma_min: float, partial_sort: bool, max_iter: int, double rtol: float, double atol: float, active_set: bool, active_set_num: int, max_swaps: int, double scale_down_factor: float, screen_size: int, lambda_grid: Union[List[List[float]], None], exclude_first_k: int, intercept: bool, lows: Union[np.ndarray, float], highs: Union[np.ndarray, float]) -> Dict[str, Any]"; +static PyMethodDef __pyx_mdef_7l0learn_9interface_1_fit_check = {"_fit_check", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7l0learn_9interface_1_fit_check, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7l0learn_9interface__fit_check}; +static PyObject *__pyx_pw_7l0learn_9interface_1_fit_check(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_X = 0; + PyObject *__pyx_v_y = 0; + PyObject *__pyx_v_loss = 0; + PyObject *__pyx_v_penalty = 0; + PyObject *__pyx_v_algorithm = 0; + PyObject *__pyx_v_max_support_size = 0; + PyObject *__pyx_v_num_lambda = 0; + PyObject *__pyx_v_num_gamma = 0; + double __pyx_v_gamma_max; + double __pyx_v_gamma_min; + PyObject *__pyx_v_partial_sort = 0; + PyObject *__pyx_v_max_iter = 0; + double __pyx_v_rtol; + double __pyx_v_atol; + PyObject *__pyx_v_active_set = 0; + PyObject *__pyx_v_active_set_num = 0; + PyObject *__pyx_v_max_swaps = 0; + double __pyx_v_scale_down_factor; + PyObject *__pyx_v_screen_size = 0; + PyObject *__pyx_v_lambda_grid = 0; + PyObject *__pyx_v_exclude_first_k = 0; + PyObject *__pyx_v_intercept = 0; + PyObject *__pyx_v_lows = 0; + PyObject *__pyx_v_highs = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_TraceFrameInit(__pyx_codeobj_) - __Pyx_RefNannySetupContext("np_to_arma_check", 0); - __Pyx_TraceCall("np_to_arma_check", __pyx_f[0], 16, 0, __PYX_ERR(0, 16, __pyx_L1_error)); - - /* "l0learn/interface.pyx":18 - * def np_to_arma_check(arr): - * # TODO: Add checks for Behaved and OwnsData - * if isinstance(arr, np.ndarray): # <<<<<<<<<<<<<< - * if not arr.flags['F_CONTIGUOUS']: - * raise ValueError("expected arr to be F_CONTIGUOUS.") - */ - __Pyx_TraceLine(18,0,__PYX_ERR(0, 18, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 18, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = PyObject_IsInstance(__pyx_v_arr, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 18, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = (__pyx_t_3 != 0); - if (__pyx_t_4) { - - /* "l0learn/interface.pyx":19 - * # TODO: Add checks for Behaved and OwnsData - * if isinstance(arr, np.ndarray): - * if not arr.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< - * raise ValueError("expected arr to be F_CONTIGUOUS.") - * elif isinstance(arr, csc_matrix): - */ - __Pyx_TraceLine(19,0,__PYX_ERR(0, 19, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 19, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_n_u_F_CONTIGUOUS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 19, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 19, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = ((!__pyx_t_4) != 0); - if (unlikely(__pyx_t_3)) { - - /* "l0learn/interface.pyx":20 - * if isinstance(arr, np.ndarray): - * if not arr.flags['F_CONTIGUOUS']: - * raise ValueError("expected arr to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< - * elif isinstance(arr, csc_matrix): - * if not arr.data.flags['F_CONTIGUOUS']: - */ - __Pyx_TraceLine(20,0,__PYX_ERR(0, 20, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 20, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(0, 20, __pyx_L1_error) - - /* "l0learn/interface.pyx":19 - * # TODO: Add checks for Behaved and OwnsData - * if isinstance(arr, np.ndarray): - * if not arr.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< - * raise ValueError("expected arr to be F_CONTIGUOUS.") - * elif isinstance(arr, csc_matrix): - */ - } - - /* "l0learn/interface.pyx":18 - * def np_to_arma_check(arr): - * # TODO: Add checks for Behaved and OwnsData - * if isinstance(arr, np.ndarray): # <<<<<<<<<<<<<< - * if not arr.flags['F_CONTIGUOUS']: - * raise ValueError("expected arr to be F_CONTIGUOUS.") - */ - goto __pyx_L3; - } - - /* "l0learn/interface.pyx":21 - * if not arr.flags['F_CONTIGUOUS']: - * raise ValueError("expected arr to be F_CONTIGUOUS.") - * elif isinstance(arr, csc_matrix): # <<<<<<<<<<<<<< - * if not arr.data.flags['F_CONTIGUOUS']: - * raise ValueError("expected arr.data to be F_CONTIGUOUS.") - */ - __Pyx_TraceLine(21,0,__PYX_ERR(0, 21, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = PyObject_IsInstance(__pyx_v_arr, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 21, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_4 = (__pyx_t_3 != 0); - if (likely(__pyx_t_4)) { - - /* "l0learn/interface.pyx":22 - * raise ValueError("expected arr to be F_CONTIGUOUS.") - * elif isinstance(arr, csc_matrix): - * if not arr.data.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< - * raise ValueError("expected arr.data to be F_CONTIGUOUS.") - * if not arr.indices.flags['F_CONTIGUOUS']: - */ - __Pyx_TraceLine(22,0,__PYX_ERR(0, 22, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_n_u_F_CONTIGUOUS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 22, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 22, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = ((!__pyx_t_4) != 0); - if (unlikely(__pyx_t_3)) { - - /* "l0learn/interface.pyx":23 - * elif isinstance(arr, csc_matrix): - * if not arr.data.flags['F_CONTIGUOUS']: - * raise ValueError("expected arr.data to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< - * if not arr.indices.flags['F_CONTIGUOUS']: - * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") - */ - __Pyx_TraceLine(23,0,__PYX_ERR(0, 23, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 23, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(0, 23, __pyx_L1_error) - - /* "l0learn/interface.pyx":22 - * raise ValueError("expected arr to be F_CONTIGUOUS.") - * elif isinstance(arr, csc_matrix): - * if not arr.data.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< - * raise ValueError("expected arr.data to be F_CONTIGUOUS.") - * if not arr.indices.flags['F_CONTIGUOUS']: - */ - } - - /* "l0learn/interface.pyx":24 - * if not arr.data.flags['F_CONTIGUOUS']: - * raise ValueError("expected arr.data to be F_CONTIGUOUS.") - * if not arr.indices.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< - * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") - * if not arr.indptr.flags['F_CONTIGUOUS']: - */ - __Pyx_TraceLine(24,0,__PYX_ERR(0, 24, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_indices); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 24, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 24, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_n_u_F_CONTIGUOUS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 24, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 24, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_4 = ((!__pyx_t_3) != 0); - if (unlikely(__pyx_t_4)) { - - /* "l0learn/interface.pyx":25 - * raise ValueError("expected arr.data to be F_CONTIGUOUS.") - * if not arr.indices.flags['F_CONTIGUOUS']: - * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< - * if not arr.indptr.flags['F_CONTIGUOUS']: - * raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") - */ - __Pyx_TraceLine(25,0,__PYX_ERR(0, 25, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 25, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(0, 25, __pyx_L1_error) - - /* "l0learn/interface.pyx":24 - * if not arr.data.flags['F_CONTIGUOUS']: - * raise ValueError("expected arr.data to be F_CONTIGUOUS.") - * if not arr.indices.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< - * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") - * if not arr.indptr.flags['F_CONTIGUOUS']: - */ - } - - /* "l0learn/interface.pyx":26 - * if not arr.indices.flags['F_CONTIGUOUS']: - * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") - * if not arr.indptr.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< - * raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") - * else: - */ - __Pyx_TraceLine(26,0,__PYX_ERR(0, 26, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_indptr); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 26, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 26, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_t_2, __pyx_n_u_F_CONTIGUOUS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 26, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 26, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = ((!__pyx_t_4) != 0); - if (unlikely(__pyx_t_3)) { - - /* "l0learn/interface.pyx":27 - * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") - * if not arr.indptr.flags['F_CONTIGUOUS']: - * raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< - * else: - * raise NotImplementedError(f"expected arr to be of type {np.ndarray} or {csc_matrix}, but got {type(arr)}.") - */ - __Pyx_TraceLine(27,0,__PYX_ERR(0, 27, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 27, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(0, 27, __pyx_L1_error) - - /* "l0learn/interface.pyx":26 - * if not arr.indices.flags['F_CONTIGUOUS']: - * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") - * if not arr.indptr.flags['F_CONTIGUOUS']: # <<<<<<<<<<<<<< - * raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") - * else: - */ - } - - /* "l0learn/interface.pyx":21 - * if not arr.flags['F_CONTIGUOUS']: - * raise ValueError("expected arr to be F_CONTIGUOUS.") - * elif isinstance(arr, csc_matrix): # <<<<<<<<<<<<<< - * if not arr.data.flags['F_CONTIGUOUS']: - * raise ValueError("expected arr.data to be F_CONTIGUOUS.") - */ - goto __pyx_L3; - } - - /* "l0learn/interface.pyx":29 - * raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") - * else: - * raise NotImplementedError(f"expected arr to be of type {np.ndarray} or {csc_matrix}, but got {type(arr)}.") # <<<<<<<<<<<<<< - * - * if arr.ndim == 0: - */ - __Pyx_TraceLine(29,0,__PYX_ERR(0, 29, __pyx_L1_error)) - /*else*/ { - __pyx_t_1 = PyTuple_New(7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 29, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = 0; - __pyx_t_6 = 127; - __Pyx_INCREF(__pyx_kp_u_expected_arr_to_be_of_type); - __pyx_t_5 += 27; - __Pyx_GIVEREF(__pyx_kp_u_expected_arr_to_be_of_type); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_expected_arr_to_be_of_type); - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 29, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 29, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 29, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_6 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_6) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_6; - __pyx_t_5 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_2); - __pyx_t_2 = 0; - __Pyx_INCREF(__pyx_kp_u_or); - __pyx_t_5 += 4; - __Pyx_GIVEREF(__pyx_kp_u_or); - PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_or); - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 29, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 29, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_6 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_6) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_6; - __pyx_t_5 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_t_7); - __pyx_t_7 = 0; - __Pyx_INCREF(__pyx_kp_u_but_got); - __pyx_t_5 += 10; - __Pyx_GIVEREF(__pyx_kp_u_but_got); - PyTuple_SET_ITEM(__pyx_t_1, 4, __pyx_kp_u_but_got); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(((PyObject *)Py_TYPE(__pyx_v_arr)), __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 29, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_6) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_6; - __pyx_t_5 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_1, 5, __pyx_t_7); - __pyx_t_7 = 0; - __Pyx_INCREF(__pyx_kp_u__6); - __pyx_t_5 += 1; - __Pyx_GIVEREF(__pyx_kp_u__6); - PyTuple_SET_ITEM(__pyx_t_1, 6, __pyx_kp_u__6); - __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_1, 7, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 29, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_NotImplementedError, __pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 29, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(0, 29, __pyx_L1_error) - } - __pyx_L3:; - - /* "l0learn/interface.pyx":31 - * raise NotImplementedError(f"expected arr to be of type {np.ndarray} or {csc_matrix}, but got {type(arr)}.") - * - * if arr.ndim == 0: # <<<<<<<<<<<<<< - * raise ValueError("expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar") - * elif arr.ndim > 2: - */ - __Pyx_TraceLine(31,0,__PYX_ERR(0, 31, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 31, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_7 = __Pyx_PyInt_EqObjC(__pyx_t_1, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 31, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 31, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(__pyx_t_3)) { - - /* "l0learn/interface.pyx":32 - * - * if arr.ndim == 0: - * raise ValueError("expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar") # <<<<<<<<<<<<<< - * elif arr.ndim > 2: - * raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") - */ - __Pyx_TraceLine(32,0,__PYX_ERR(0, 32, __pyx_L1_error)) - __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 32, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_Raise(__pyx_t_7, 0, 0, 0); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 32, __pyx_L1_error) - - /* "l0learn/interface.pyx":31 - * raise NotImplementedError(f"expected arr to be of type {np.ndarray} or {csc_matrix}, but got {type(arr)}.") - * - * if arr.ndim == 0: # <<<<<<<<<<<<<< - * raise ValueError("expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar") - * elif arr.ndim > 2: - */ - } - - /* "l0learn/interface.pyx":33 - * if arr.ndim == 0: - * raise ValueError("expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar") - * elif arr.ndim > 2: # <<<<<<<<<<<<<< - * raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") - * - */ - __Pyx_TraceLine(33,0,__PYX_ERR(0, 33, __pyx_L1_error)) - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 33, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_1 = PyObject_RichCompare(__pyx_t_7, __pyx_int_2, Py_GT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 33, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(__pyx_t_3)) { - - /* "l0learn/interface.pyx":34 - * raise ValueError("expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar") - * elif arr.ndim > 2: - * raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") # <<<<<<<<<<<<<< - * - * if np.product(arr.shape) == 0: - */ - __Pyx_TraceLine(34,0,__PYX_ERR(0, 34, __pyx_L1_error)) - __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 34, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = 0; - __pyx_t_6 = 127; - __Pyx_INCREF(__pyx_kp_u_expected_arr_ndim_to_be_1_or_2_b_2); - __pyx_t_5 += 42; - __Pyx_GIVEREF(__pyx_kp_u_expected_arr_ndim_to_be_1_or_2_b_2); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_expected_arr_ndim_to_be_1_or_2_b_2); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 34, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 34, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_6 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_6) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_6; - __pyx_t_5 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_2); - __pyx_t_2 = 0; - __Pyx_INCREF(__pyx_kp_u_Not_supported); - __pyx_t_5 += 15; - __Pyx_GIVEREF(__pyx_kp_u_Not_supported); - PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_Not_supported); - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_1, 3, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 34, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_NotImplementedError, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 34, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(0, 34, __pyx_L1_error) - - /* "l0learn/interface.pyx":33 - * if arr.ndim == 0: - * raise ValueError("expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar") - * elif arr.ndim > 2: # <<<<<<<<<<<<<< - * raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") - * - */ - } - - /* "l0learn/interface.pyx":36 - * raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") - * - * if np.product(arr.shape) == 0: # <<<<<<<<<<<<<< - * raise ValueError(f"expected non-degenerate dimensions of arr, but got {arr.ndim}") - * - */ - __Pyx_TraceLine(36,0,__PYX_ERR(0, 36, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 36, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_product); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 36, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 36, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_8 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); - if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); - __Pyx_INCREF(__pyx_t_8); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_7, function); - } - } - __pyx_t_1 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_2); - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 36, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyInt_EqObjC(__pyx_t_1, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 36, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 36, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(__pyx_t_3)) { - - /* "l0learn/interface.pyx":37 - * - * if np.product(arr.shape) == 0: - * raise ValueError(f"expected non-degenerate dimensions of arr, but got {arr.ndim}") # <<<<<<<<<<<<<< - * - * if not np.issubdtype(arr.dtype, np.number): - */ - __Pyx_TraceLine(37,0,__PYX_ERR(0, 37, __pyx_L1_error)) - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_ndim); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 37, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 37, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_non_degenerate_dimensio, __pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 37, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 37, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_1, 0, 0, 0); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(0, 37, __pyx_L1_error) - - /* "l0learn/interface.pyx":36 - * raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") - * - * if np.product(arr.shape) == 0: # <<<<<<<<<<<<<< - * raise ValueError(f"expected non-degenerate dimensions of arr, but got {arr.ndim}") - * - */ - } - - /* "l0learn/interface.pyx":39 - * raise ValueError(f"expected non-degenerate dimensions of arr, but got {arr.ndim}") - * - * if not np.issubdtype(arr.dtype, np.number): # <<<<<<<<<<<<<< - * raise ValueError(f"expected numerical dtype, but got {arr.dtype}") - * - */ - __Pyx_TraceLine(39,0,__PYX_ERR(0, 39, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 39, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_issubdtype); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 39, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_dtype); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 39, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 39, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_number); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 39, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = NULL; - __pyx_t_10 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_8); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_10 = 1; - } - } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_2)) { - PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_7, __pyx_t_9}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 39, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - } else - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { - PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_7, __pyx_t_9}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 39, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - } else - #endif - { - __pyx_t_11 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 39, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_11); - if (__pyx_t_8) { - __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_8); __pyx_t_8 = NULL; - } - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_10, __pyx_t_7); - __Pyx_GIVEREF(__pyx_t_9); - PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_10, __pyx_t_9); - __pyx_t_7 = 0; - __pyx_t_9 = 0; - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 39, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - } - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 39, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_4 = ((!__pyx_t_3) != 0); - if (unlikely(__pyx_t_4)) { - - /* "l0learn/interface.pyx":40 - * - * if not np.issubdtype(arr.dtype, np.number): - * raise ValueError(f"expected numerical dtype, but got {arr.dtype}") # <<<<<<<<<<<<<< - * - * if not np.isrealobj(arr): - */ - __Pyx_TraceLine(40,0,__PYX_ERR(0, 40, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 40, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_1, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 40, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_numerical_dtype_but_got, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 40, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 40, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_Raise(__pyx_t_2, 0, 0, 0); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 40, __pyx_L1_error) - - /* "l0learn/interface.pyx":39 - * raise ValueError(f"expected non-degenerate dimensions of arr, but got {arr.ndim}") - * - * if not np.issubdtype(arr.dtype, np.number): # <<<<<<<<<<<<<< - * raise ValueError(f"expected numerical dtype, but got {arr.dtype}") - * - */ - } - - /* "l0learn/interface.pyx":42 - * raise ValueError(f"expected numerical dtype, but got {arr.dtype}") - * - * if not np.isrealobj(arr): # <<<<<<<<<<<<<< - * raise ValueError(f"expected non-complex dtype, but got {arr.dtype}") - * - */ - __Pyx_TraceLine(42,0,__PYX_ERR(0, 42, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 42, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 42, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_11); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_11))) { - __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_11); - if (likely(__pyx_t_1)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11); - __Pyx_INCREF(__pyx_t_1); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_11, function); - } - } - __pyx_t_2 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_1, __pyx_v_arr) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_v_arr); - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 42, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 42, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = ((!__pyx_t_4) != 0); - if (unlikely(__pyx_t_3)) { - - /* "l0learn/interface.pyx":43 - * - * if not np.isrealobj(arr): - * raise ValueError(f"expected non-complex dtype, but got {arr.dtype}") # <<<<<<<<<<<<<< - * - * - */ - __Pyx_TraceLine(43,0,__PYX_ERR(0, 43, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_arr, __pyx_n_s_dtype); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 43, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_11 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 43, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_11); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_non_complex_dtype_but_g, __pyx_t_11); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 43, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __pyx_t_11 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 43, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_11); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_11, 0, 0, 0); - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __PYX_ERR(0, 43, __pyx_L1_error) - - /* "l0learn/interface.pyx":42 - * raise ValueError(f"expected numerical dtype, but got {arr.dtype}") - * - * if not np.isrealobj(arr): # <<<<<<<<<<<<<< - * raise ValueError(f"expected non-complex dtype, but got {arr.dtype}") - * - */ - } - - /* "l0learn/interface.pyx":16 - * from l0learn.models import FitModel, CVFitModel - * - * def np_to_arma_check(arr): # <<<<<<<<<<<<<< - * # TODO: Add checks for Behaved and OwnsData - * if isinstance(arr, np.ndarray): - */ - - /* function exit code */ - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_XDECREF(__pyx_t_9); - __Pyx_XDECREF(__pyx_t_11); - __Pyx_AddTraceback("l0learn.interface.np_to_arma_check", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "l0learn/interface.pyx":52 - * - * - * def _fit_check(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< - * y: np.ndarray, - * loss: str, - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_7l0learn_9interface_3_fit_check(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_7l0learn_9interface_2_fit_check[] = "_fit_check(X: Union[np.ndarray, csc_matrix], y: np.ndarray, unicode loss: str, unicode penalty: str, unicode algorithm: str, max_support_size: int, num_lambda: Union[int, None], num_gamma: Union[int, None], double gamma_max: float, double gamma_min: float, partial_sort: bool, max_iter: int, double rtol: float, double atol: float, active_set: bool, active_set_num: int, max_swaps: int, double scale_down_factor: float, screen_size: int, lambda_grid: Union[List[List[float]], None], exclude_first_k: int, intercept: bool, lows: Union[np.ndarray, float], highs: Union[np.ndarray, float]) -> Dict[str, Any]"; -static PyMethodDef __pyx_mdef_7l0learn_9interface_3_fit_check = {"_fit_check", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7l0learn_9interface_3_fit_check, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7l0learn_9interface_2_fit_check}; -static PyObject *__pyx_pw_7l0learn_9interface_3_fit_check(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v_X = 0; - PyObject *__pyx_v_y = 0; - PyObject *__pyx_v_loss = 0; - PyObject *__pyx_v_penalty = 0; - PyObject *__pyx_v_algorithm = 0; - PyObject *__pyx_v_max_support_size = 0; - PyObject *__pyx_v_num_lambda = 0; - PyObject *__pyx_v_num_gamma = 0; - double __pyx_v_gamma_max; - double __pyx_v_gamma_min; - PyObject *__pyx_v_partial_sort = 0; - PyObject *__pyx_v_max_iter = 0; - double __pyx_v_rtol; - double __pyx_v_atol; - PyObject *__pyx_v_active_set = 0; - PyObject *__pyx_v_active_set_num = 0; - PyObject *__pyx_v_max_swaps = 0; - double __pyx_v_scale_down_factor; - PyObject *__pyx_v_screen_size = 0; - PyObject *__pyx_v_lambda_grid = 0; - PyObject *__pyx_v_exclude_first_k = 0; - PyObject *__pyx_v_intercept = 0; - PyObject *__pyx_v_lows = 0; - PyObject *__pyx_v_highs = 0; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("_fit_check (wrapper)", 0); + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_fit_check (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_X,&__pyx_n_s_y,&__pyx_n_s_loss,&__pyx_n_s_penalty,&__pyx_n_s_algorithm,&__pyx_n_s_max_support_size,&__pyx_n_s_num_lambda,&__pyx_n_s_num_gamma,&__pyx_n_s_gamma_max,&__pyx_n_s_gamma_min,&__pyx_n_s_partial_sort,&__pyx_n_s_max_iter,&__pyx_n_s_rtol,&__pyx_n_s_atol,&__pyx_n_s_active_set,&__pyx_n_s_active_set_num,&__pyx_n_s_max_swaps,&__pyx_n_s_scale_down_factor,&__pyx_n_s_screen_size,&__pyx_n_s_lambda_grid,&__pyx_n_s_exclude_first_k,&__pyx_n_s_intercept,&__pyx_n_s_lows,&__pyx_n_s_highs,0}; PyObject* values[24] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; @@ -3532,7 +2548,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_3_fit_check(PyObject *__pyx_self, if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loss), (&PyUnicode_Type), 1, "loss", 1))) __PYX_ERR(0, 54, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_penalty), (&PyUnicode_Type), 1, "penalty", 1))) __PYX_ERR(0, 55, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_algorithm), (&PyUnicode_Type), 1, "algorithm", 1))) __PYX_ERR(0, 56, __pyx_L1_error) - __pyx_r = __pyx_pf_7l0learn_9interface_2_fit_check(__pyx_self, __pyx_v_X, __pyx_v_y, __pyx_v_loss, __pyx_v_penalty, __pyx_v_algorithm, __pyx_v_max_support_size, __pyx_v_num_lambda, __pyx_v_num_gamma, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_v_partial_sort, __pyx_v_max_iter, __pyx_v_rtol, __pyx_v_atol, __pyx_v_active_set, __pyx_v_active_set_num, __pyx_v_max_swaps, __pyx_v_scale_down_factor, __pyx_v_screen_size, __pyx_v_lambda_grid, __pyx_v_exclude_first_k, __pyx_v_intercept, __pyx_v_lows, __pyx_v_highs); + __pyx_r = __pyx_pf_7l0learn_9interface__fit_check(__pyx_self, __pyx_v_X, __pyx_v_y, __pyx_v_loss, __pyx_v_penalty, __pyx_v_algorithm, __pyx_v_max_support_size, __pyx_v_num_lambda, __pyx_v_num_gamma, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_v_partial_sort, __pyx_v_max_iter, __pyx_v_rtol, __pyx_v_atol, __pyx_v_active_set, __pyx_v_active_set_num, __pyx_v_max_swaps, __pyx_v_scale_down_factor, __pyx_v_screen_size, __pyx_v_lambda_grid, __pyx_v_exclude_first_k, __pyx_v_intercept, __pyx_v_lows, __pyx_v_highs); /* function exit code */ goto __pyx_L0; @@ -3543,7 +2559,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_3_fit_check(PyObject *__pyx_self, return __pyx_r; } -static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs) { +static PyObject *__pyx_pf_7l0learn_9interface__fit_check(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs) { PyObject *__pyx_v_n = NULL; PyObject *__pyx_v_p = NULL; PyObject *__pyx_v_unique_items = NULL; @@ -3559,30 +2575,26 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject int __pyx_v_with_bounds; PyObject *__pyx_v_bad_bounds = NULL; PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations - int __pyx_t_1; + PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; + int __pyx_t_3; int __pyx_t_4; int __pyx_t_5; - int __pyx_t_6; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - Py_ssize_t __pyx_t_9; - Py_UCS4 __pyx_t_10; - PyObject *(*__pyx_t_11)(PyObject *); - int __pyx_t_12; - PyObject *(*__pyx_t_13)(PyObject *); - double __pyx_t_14; - Py_ssize_t __pyx_t_15; - PyObject *__pyx_t_16 = NULL; + PyObject *__pyx_t_6 = NULL; + Py_ssize_t __pyx_t_7; + Py_UCS4 __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + PyObject *(*__pyx_t_10)(PyObject *); + int __pyx_t_11; + PyObject *(*__pyx_t_12)(PyObject *); + double __pyx_t_13; + Py_ssize_t __pyx_t_14; + PyObject *__pyx_t_15 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_TraceFrameInit(__pyx_codeobj__8) __Pyx_RefNannySetupContext("_fit_check", 0); - __Pyx_TraceCall("_fit_check", __pyx_f[0], 52, 0, __PYX_ERR(0, 52, __pyx_L1_error)); __Pyx_INCREF(__pyx_v_y); __Pyx_INCREF(__pyx_v_penalty); __Pyx_INCREF(__pyx_v_max_support_size); @@ -3596,327 +2608,494 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject /* "l0learn/interface.pyx":77 * highs: Union[np.ndarray, float]) -> Dict[str, Any]: * - * if not isinstance(X, (np.ndarray, csc_matrix)) or X.dtype != np.float64 or X.ndim != 2 or not np.product(X.shape) or not X.flags.contiguous: # <<<<<<<<<<<<<< - * raise ValueError(f"expected X to be a 2D continuous non-degenerate real numpy or csc_matrix, but got {X}.") - * n, p = X.shape + * if isinstance(X, (np.ndarray, csc_matrix)): # <<<<<<<<<<<<<< + * if X.dtype != np.float64: + * raise ValueError(f"expected X to have dtype {np.float64}, but got {X.dtype}") */ - __Pyx_TraceLine(77,0,__PYX_ERR(0, 77, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_5 = PyObject_IsInstance(__pyx_v_X, __pyx_t_3); - __pyx_t_6 = (__pyx_t_5 != 0); - if (!__pyx_t_6) { - } else { - __pyx_t_4 = __pyx_t_6; - goto __pyx_L6_bool_binop_done; - } - __pyx_t_6 = PyObject_IsInstance(__pyx_v_X, __pyx_t_2); - __pyx_t_5 = (__pyx_t_6 != 0); - __pyx_t_4 = __pyx_t_5; - __pyx_L6_bool_binop_done:; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); - if (!__pyx_t_5) { - } else { - __pyx_t_1 = __pyx_t_5; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_dtype); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_float64); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = PyObject_RichCompare(__pyx_t_3, __pyx_t_7, Py_NE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (!__pyx_t_5) { - } else { - __pyx_t_1 = __pyx_t_5; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyInt_NeObjC(__pyx_t_2, __pyx_int_2, 2, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 77, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = PyObject_IsInstance(__pyx_v_X, __pyx_t_2); + __pyx_t_5 = (__pyx_t_4 != 0); if (!__pyx_t_5) { } else { - __pyx_t_1 = __pyx_t_5; - goto __pyx_L4_bool_binop_done; - } - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_product); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_8 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_8); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - } - } - __pyx_t_7 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_8, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = ((!__pyx_t_5) != 0); - if (!__pyx_t_4) { - } else { - __pyx_t_1 = __pyx_t_4; + __pyx_t_3 = __pyx_t_5; goto __pyx_L4_bool_binop_done; } - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_flags); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_contiguous); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 77, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_5 = ((!__pyx_t_4) != 0); - __pyx_t_1 = __pyx_t_5; + __pyx_t_5 = PyObject_IsInstance(__pyx_v_X, __pyx_t_1); + __pyx_t_4 = (__pyx_t_5 != 0); + __pyx_t_3 = __pyx_t_4; __pyx_L4_bool_binop_done:; - if (unlikely(__pyx_t_1)) { + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = (__pyx_t_3 != 0); + if (likely(__pyx_t_4)) { /* "l0learn/interface.pyx":78 * - * if not isinstance(X, (np.ndarray, csc_matrix)) or X.dtype != np.float64 or X.ndim != 2 or not np.product(X.shape) or not X.flags.contiguous: - * raise ValueError(f"expected X to be a 2D continuous non-degenerate real numpy or csc_matrix, but got {X}.") # <<<<<<<<<<<<<< - * n, p = X.shape - * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: + * if isinstance(X, (np.ndarray, csc_matrix)): + * if X.dtype != np.float64: # <<<<<<<<<<<<<< + * raise ValueError(f"expected X to have dtype {np.float64}, but got {X.dtype}") + * if X.ndim != 2: */ - __Pyx_TraceLine(78,0,__PYX_ERR(0, 78, __pyx_L1_error)) - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 78, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_9 = 0; - __pyx_t_10 = 127; - __Pyx_INCREF(__pyx_kp_u_expected_X_to_be_a_2D_continuous); - __pyx_t_9 += 82; - __Pyx_GIVEREF(__pyx_kp_u_expected_X_to_be_a_2D_continuous); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_X_to_be_a_2D_continuous); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_X, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 78, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7); - __pyx_t_7 = 0; - __Pyx_INCREF(__pyx_kp_u__6); - __pyx_t_9 += 1; - __Pyx_GIVEREF(__pyx_kp_u__6); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u__6); - __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 78, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 78, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 78, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_dtype); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 78, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 78, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float64); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 78, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyObject_RichCompare(__pyx_t_2, __pyx_t_6, Py_NE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 78, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 78, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(__pyx_t_4)) { + + /* "l0learn/interface.pyx":79 + * if isinstance(X, (np.ndarray, csc_matrix)): + * if X.dtype != np.float64: + * raise ValueError(f"expected X to have dtype {np.float64}, but got {X.dtype}") # <<<<<<<<<<<<<< + * if X.ndim != 2: + * raise ValueError(f"expected X to be 2D, but got {X.ndim}D") + */ + __pyx_t_1 = PyTuple_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = 0; + __pyx_t_8 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_X_to_have_dtype); + __pyx_t_7 += 25; + __Pyx_GIVEREF(__pyx_kp_u_expected_X_to_have_dtype); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_expected_X_to_have_dtype); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_float64); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_kp_u_but_got); + __pyx_t_7 += 10; + __Pyx_GIVEREF(__pyx_kp_u_but_got); + PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_but_got); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_dtype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_6, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_1, 4, __pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 79, __pyx_L1_error) + + /* "l0learn/interface.pyx":78 + * + * if isinstance(X, (np.ndarray, csc_matrix)): + * if X.dtype != np.float64: # <<<<<<<<<<<<<< + * raise ValueError(f"expected X to have dtype {np.float64}, but got {X.dtype}") + * if X.ndim != 2: + */ + } + + /* "l0learn/interface.pyx":80 + * if X.dtype != np.float64: + * raise ValueError(f"expected X to have dtype {np.float64}, but got {X.dtype}") + * if X.ndim != 2: # <<<<<<<<<<<<<< + * raise ValueError(f"expected X to be 2D, but got {X.ndim}D") + * if not np.product(X.shape): + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_NeObjC(__pyx_t_1, __pyx_int_2, 2, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(__pyx_t_4)) { + + /* "l0learn/interface.pyx":81 + * raise ValueError(f"expected X to have dtype {np.float64}, but got {X.dtype}") + * if X.ndim != 2: + * raise ValueError(f"expected X to be 2D, but got {X.ndim}D") # <<<<<<<<<<<<<< + * if not np.product(X.shape): + * raise ValueError(f"expected X to have non-degenerate axis, but got {X.shape}") + */ + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = 0; + __pyx_t_8 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_X_to_be_2D_but_got); + __pyx_t_7 += 29; + __Pyx_GIVEREF(__pyx_kp_u_expected_X_to_be_2D_but_got); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_u_expected_X_to_be_2D_but_got); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_1, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_n_u_D); + __pyx_t_7 += 1; + __Pyx_GIVEREF(__pyx_n_u_D); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_n_u_D); + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_2, 3, __pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 81, __pyx_L1_error) + + /* "l0learn/interface.pyx":80 + * if X.dtype != np.float64: + * raise ValueError(f"expected X to have dtype {np.float64}, but got {X.dtype}") + * if X.ndim != 2: # <<<<<<<<<<<<<< + * raise ValueError(f"expected X to be 2D, but got {X.ndim}D") + * if not np.product(X.shape): + */ + } + + /* "l0learn/interface.pyx":82 + * if X.ndim != 2: + * raise ValueError(f"expected X to be 2D, but got {X.ndim}D") + * if not np.product(X.shape): # <<<<<<<<<<<<<< + * raise ValueError(f"expected X to have non-degenerate axis, but got {X.shape}") + * # if isinstance(X, np.ndarray): + */ + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_product); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_2 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_9, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_6); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = ((!__pyx_t_4) != 0); + if (unlikely(__pyx_t_3)) { + + /* "l0learn/interface.pyx":83 + * raise ValueError(f"expected X to be 2D, but got {X.ndim}D") + * if not np.product(X.shape): + * raise ValueError(f"expected X to have non-degenerate axis, but got {X.shape}") # <<<<<<<<<<<<<< + * # if isinstance(X, np.ndarray): + * # if not X.flags.contiguous: + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 83, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 83, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_X_to_have_non_degenerat, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 83, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 83, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 83, __pyx_L1_error) + + /* "l0learn/interface.pyx":82 + * if X.ndim != 2: + * raise ValueError(f"expected X to be 2D, but got {X.ndim}D") + * if not np.product(X.shape): # <<<<<<<<<<<<<< + * raise ValueError(f"expected X to have non-degenerate axis, but got {X.shape}") + * # if isinstance(X, np.ndarray): + */ + } /* "l0learn/interface.pyx":77 * highs: Union[np.ndarray, float]) -> Dict[str, Any]: * - * if not isinstance(X, (np.ndarray, csc_matrix)) or X.dtype != np.float64 or X.ndim != 2 or not np.product(X.shape) or not X.flags.contiguous: # <<<<<<<<<<<<<< - * raise ValueError(f"expected X to be a 2D continuous non-degenerate real numpy or csc_matrix, but got {X}.") + * if isinstance(X, (np.ndarray, csc_matrix)): # <<<<<<<<<<<<<< + * if X.dtype != np.float64: + * raise ValueError(f"expected X to have dtype {np.float64}, but got {X.dtype}") + */ + goto __pyx_L3; + } + + /* "l0learn/interface.pyx":91 + * # raise ValueError(f"expected X to have contiguous `indptr`, `indices`, and `data`, but is not.") + * else: + * raise ValueError(f"expected X to be a {np.ndarray} or a {csc_matrix}, but got {type(X)}.") # <<<<<<<<<<<<<< + * * n, p = X.shape */ + /*else*/ { + __pyx_t_1 = PyTuple_New(7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 91, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = 0; + __pyx_t_8 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_X_to_be_a); + __pyx_t_7 += 19; + __Pyx_GIVEREF(__pyx_kp_u_expected_X_to_be_a); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_expected_X_to_be_a); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 91, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 91, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_6, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 91, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_kp_u_or_a); + __pyx_t_7 += 6; + __Pyx_GIVEREF(__pyx_kp_u_or_a); + PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_or_a); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 91, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 91, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_kp_u_but_got); + __pyx_t_7 += 10; + __Pyx_GIVEREF(__pyx_kp_u_but_got); + PyTuple_SET_ITEM(__pyx_t_1, 4, __pyx_kp_u_but_got); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(((PyObject *)Py_TYPE(__pyx_v_X)), __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 91, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_1, 5, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_kp_u_); + __pyx_t_7 += 1; + __Pyx_GIVEREF(__pyx_kp_u_); + PyTuple_SET_ITEM(__pyx_t_1, 6, __pyx_kp_u_); + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_1, 7, __pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 91, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 91, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 91, __pyx_L1_error) } + __pyx_L3:; - /* "l0learn/interface.pyx":79 - * if not isinstance(X, (np.ndarray, csc_matrix)) or X.dtype != np.float64 or X.ndim != 2 or not np.product(X.shape) or not X.flags.contiguous: - * raise ValueError(f"expected X to be a 2D continuous non-degenerate real numpy or csc_matrix, but got {X}.") + /* "l0learn/interface.pyx":93 + * raise ValueError(f"expected X to be a {np.ndarray} or a {csc_matrix}, but got {type(X)}.") + * * n, p = X.shape # <<<<<<<<<<<<<< * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") */ - __Pyx_TraceLine(79,0,__PYX_ERR(0, 79, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 79, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { - PyObject* sequence = __pyx_t_3; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) { + PyObject* sequence = __pyx_t_1; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 79, __pyx_L1_error) + __PYX_ERR(0, 93, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_7 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_2 = PyTuple_GET_ITEM(sequence, 1); } else { - __pyx_t_7 = PyList_GET_ITEM(sequence, 0); + __pyx_t_6 = PyList_GET_ITEM(sequence, 0); __pyx_t_2 = PyList_GET_ITEM(sequence, 1); } - __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(__pyx_t_2); #else - __pyx_t_7 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 79, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_2 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 79, __pyx_L1_error) + __pyx_t_6 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 93, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #endif - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else { Py_ssize_t index = -1; - __pyx_t_8 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 79, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_11 = Py_TYPE(__pyx_t_8)->tp_iternext; - index = 0; __pyx_t_7 = __pyx_t_11(__pyx_t_8); if (unlikely(!__pyx_t_7)) goto __pyx_L11_unpacking_failed; - __Pyx_GOTREF(__pyx_t_7); - index = 1; __pyx_t_2 = __pyx_t_11(__pyx_t_8); if (unlikely(!__pyx_t_2)) goto __pyx_L11_unpacking_failed; + __pyx_t_9 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_10 = Py_TYPE(__pyx_t_9)->tp_iternext; + index = 0; __pyx_t_6 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_6)) goto __pyx_L9_unpacking_failed; + __Pyx_GOTREF(__pyx_t_6); + index = 1; __pyx_t_2 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_2)) goto __pyx_L9_unpacking_failed; __Pyx_GOTREF(__pyx_t_2); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_8), 2) < 0) __PYX_ERR(0, 79, __pyx_L1_error) - __pyx_t_11 = NULL; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - goto __pyx_L12_unpacking_done; - __pyx_L11_unpacking_failed:; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_11 = NULL; + if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 2) < 0) __PYX_ERR(0, 93, __pyx_L1_error) + __pyx_t_10 = NULL; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L10_unpacking_done; + __pyx_L9_unpacking_failed:; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_10 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 79, __pyx_L1_error) - __pyx_L12_unpacking_done:; + __PYX_ERR(0, 93, __pyx_L1_error) + __pyx_L10_unpacking_done:; } - __pyx_v_n = __pyx_t_7; - __pyx_t_7 = 0; + __pyx_v_n = __pyx_t_6; + __pyx_t_6 = 0; __pyx_v_p = __pyx_t_2; __pyx_t_2 = 0; - /* "l0learn/interface.pyx":80 - * raise ValueError(f"expected X to be a 2D continuous non-degenerate real numpy or csc_matrix, but got {X}.") + /* "l0learn/interface.pyx":94 + * * n, p = X.shape * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: # <<<<<<<<<<<<<< * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") * if loss not in SUPPORTED_LOSS: */ - __Pyx_TraceLine(80,0,__PYX_ERR(0, 80, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 80, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 94, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_5 = PyObject_IsInstance(__pyx_v_y, __pyx_t_2); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_4 = PyObject_IsInstance(__pyx_v_y, __pyx_t_2); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 94, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = ((!(__pyx_t_5 != 0)) != 0); - if (!__pyx_t_4) { + __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); + if (!__pyx_t_5) { } else { - __pyx_t_1 = __pyx_t_4; - goto __pyx_L14_bool_binop_done; + __pyx_t_3 = __pyx_t_5; + goto __pyx_L12_bool_binop_done; } - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 80, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 80, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_7); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); - __Pyx_INCREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_isrealobj); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_7, function); + __Pyx_DECREF_SET(__pyx_t_6, function); } } - __pyx_t_2 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_3, __pyx_v_y) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_y); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 80, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_1, __pyx_v_y) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_y); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 94, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 80, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 94, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_5 = ((!__pyx_t_4) != 0); - if (!__pyx_t_5) { + __pyx_t_4 = ((!__pyx_t_5) != 0); + if (!__pyx_t_4) { } else { - __pyx_t_1 = __pyx_t_5; - goto __pyx_L14_bool_binop_done; + __pyx_t_3 = __pyx_t_4; + goto __pyx_L12_bool_binop_done; } - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_y, __pyx_n_s_ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 80, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_y, __pyx_n_s_ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 94, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyInt_NeObjC(__pyx_t_2, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 80, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyInt_NeObjC(__pyx_t_2, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 80, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (!__pyx_t_5) { + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (!__pyx_t_4) { } else { - __pyx_t_1 = __pyx_t_5; - goto __pyx_L14_bool_binop_done; - } - __pyx_t_9 = PyObject_Length(__pyx_v_y); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 80, __pyx_L1_error) - __pyx_t_7 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 80, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_2 = PyObject_RichCompare(__pyx_t_7, __pyx_v_n, Py_NE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 80, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 80, __pyx_L1_error) + __pyx_t_3 = __pyx_t_4; + goto __pyx_L12_bool_binop_done; + } + __pyx_t_7 = PyObject_Length(__pyx_v_y); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(0, 94, __pyx_L1_error) + __pyx_t_6 = PyInt_FromSsize_t(__pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = PyObject_RichCompare(__pyx_t_6, __pyx_v_n, Py_NE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 94, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_1 = __pyx_t_5; - __pyx_L14_bool_binop_done:; - if (unlikely(__pyx_t_1)) { + __pyx_t_3 = __pyx_t_4; + __pyx_L12_bool_binop_done:; + if (unlikely(__pyx_t_3)) { - /* "l0learn/interface.pyx":81 + /* "l0learn/interface.pyx":95 * n, p = X.shape * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") # <<<<<<<<<<<<<< * if loss not in SUPPORTED_LOSS: * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") */ - __Pyx_TraceLine(81,0,__PYX_ERR(0, 81, __pyx_L1_error)) - __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 81, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 95, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_9 = 0; - __pyx_t_10 = 127; + __pyx_t_7 = 0; + __pyx_t_8 = 127; __Pyx_INCREF(__pyx_kp_u_expected_y_to_be_a_1D_real_numpy); - __pyx_t_9 += 42; + __pyx_t_7 += 42; __Pyx_GIVEREF(__pyx_kp_u_expected_y_to_be_a_1D_real_numpy); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_u_expected_y_to_be_a_1D_real_numpy); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_y, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 81, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_7); - __pyx_t_7 = 0; - __Pyx_INCREF(__pyx_kp_u__6); - __pyx_t_9 += 1; - __Pyx_GIVEREF(__pyx_kp_u__6); - PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_kp_u__6); - __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_2, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 81, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_y, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 95, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_kp_u_); + __pyx_t_7 += 1; + __Pyx_GIVEREF(__pyx_kp_u_); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_kp_u_); + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_2, 3, __pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 95, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 81, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 95, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 81, __pyx_L1_error) + __PYX_ERR(0, 95, __pyx_L1_error) - /* "l0learn/interface.pyx":80 - * raise ValueError(f"expected X to be a 2D continuous non-degenerate real numpy or csc_matrix, but got {X}.") + /* "l0learn/interface.pyx":94 + * * n, p = X.shape * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: # <<<<<<<<<<<<<< * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") @@ -3924,69 +3103,67 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":82 + /* "l0learn/interface.pyx":96 * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") * if loss not in SUPPORTED_LOSS: # <<<<<<<<<<<<<< * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") * if penalty not in SUPPORTED_PENALTY: */ - __Pyx_TraceLine(82,0,__PYX_ERR(0, 82, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 82, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 96, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_loss, __pyx_t_2, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 82, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PySequence_ContainsTF(__pyx_v_loss, __pyx_t_2, Py_NE)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 96, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_5 = (__pyx_t_1 != 0); - if (unlikely(__pyx_t_5)) { + __pyx_t_4 = (__pyx_t_3 != 0); + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":83 + /* "l0learn/interface.pyx":97 * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") * if loss not in SUPPORTED_LOSS: * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") # <<<<<<<<<<<<<< * if penalty not in SUPPORTED_PENALTY: * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") */ - __Pyx_TraceLine(83,0,__PYX_ERR(0, 83, __pyx_L1_error)) - __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 83, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_9 = 0; - __pyx_t_10 = 127; + __pyx_t_7 = 0; + __pyx_t_8 = 127; __Pyx_INCREF(__pyx_kp_u_expected_loss_parameter_to_be_on); - __pyx_t_9 += 36; + __pyx_t_7 += 36; __Pyx_GIVEREF(__pyx_kp_u_expected_loss_parameter_to_be_on); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_u_expected_loss_parameter_to_be_on); - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 83, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 83, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3); - __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_t_6, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_1); + __pyx_t_1 = 0; __Pyx_INCREF(__pyx_kp_u_but_got); - __pyx_t_9 += 10; + __pyx_t_7 += 10; __Pyx_GIVEREF(__pyx_kp_u_but_got); PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_kp_u_but_got); - __pyx_t_3 = __Pyx_PyUnicode_Unicode(__pyx_v_loss); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 83, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_3); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_2, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 83, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyUnicode_Unicode(__pyx_v_loss); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_2, 4, __pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 83, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 97, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 83, __pyx_L1_error) + __PYX_ERR(0, 97, __pyx_L1_error) - /* "l0learn/interface.pyx":82 + /* "l0learn/interface.pyx":96 * if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: * raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") * if loss not in SUPPORTED_LOSS: # <<<<<<<<<<<<<< @@ -3995,69 +3172,67 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":84 + /* "l0learn/interface.pyx":98 * if loss not in SUPPORTED_LOSS: * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") * if penalty not in SUPPORTED_PENALTY: # <<<<<<<<<<<<<< * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") * if algorithm not in SUPPORTED_ALGORITHM: */ - __Pyx_TraceLine(84,0,__PYX_ERR(0, 84, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SUPPORTED_PENALTY); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 84, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SUPPORTED_PENALTY); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_v_penalty, __pyx_t_2, Py_NE)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 84, __pyx_L1_error) + __pyx_t_4 = (__Pyx_PySequence_ContainsTF(__pyx_v_penalty, __pyx_t_2, Py_NE)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 98, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_1 = (__pyx_t_5 != 0); - if (unlikely(__pyx_t_1)) { + __pyx_t_3 = (__pyx_t_4 != 0); + if (unlikely(__pyx_t_3)) { - /* "l0learn/interface.pyx":85 + /* "l0learn/interface.pyx":99 * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") * if penalty not in SUPPORTED_PENALTY: * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") # <<<<<<<<<<<<<< * if algorithm not in SUPPORTED_ALGORITHM: * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") */ - __Pyx_TraceLine(85,0,__PYX_ERR(0, 85, __pyx_L1_error)) - __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 85, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_9 = 0; - __pyx_t_10 = 127; + __pyx_t_7 = 0; + __pyx_t_8 = 127; __Pyx_INCREF(__pyx_kp_u_expected_penalty_parameter_to_be); - __pyx_t_9 += 39; + __pyx_t_7 += 39; __Pyx_GIVEREF(__pyx_kp_u_expected_penalty_parameter_to_be); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_u_expected_penalty_parameter_to_be); - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_SUPPORTED_PENALTY); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 85, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 85, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_7); - __pyx_t_7 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SUPPORTED_PENALTY); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 99, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_1, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 99, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_6); + __pyx_t_6 = 0; __Pyx_INCREF(__pyx_kp_u_but_got); - __pyx_t_9 += 10; + __pyx_t_7 += 10; __Pyx_GIVEREF(__pyx_kp_u_but_got); PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_kp_u_but_got); - __pyx_t_7 = __Pyx_PyUnicode_Unicode(__pyx_v_penalty); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 85, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_7); - __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_2, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 85, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyUnicode_Unicode(__pyx_v_penalty); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 99, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_2, 4, __pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 99, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 85, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 85, __pyx_L1_error) + __PYX_ERR(0, 99, __pyx_L1_error) - /* "l0learn/interface.pyx":84 + /* "l0learn/interface.pyx":98 * if loss not in SUPPORTED_LOSS: * raise ValueError(f"expected loss parameter to be on of {SUPPORTED_LOSS}, but got {loss}") * if penalty not in SUPPORTED_PENALTY: # <<<<<<<<<<<<<< @@ -4066,69 +3241,67 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":86 + /* "l0learn/interface.pyx":100 * if penalty not in SUPPORTED_PENALTY: * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") * if algorithm not in SUPPORTED_ALGORITHM: # <<<<<<<<<<<<<< * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") * if not isinstance(max_support_size, int) or 1 > max_support_size: */ - __Pyx_TraceLine(86,0,__PYX_ERR(0, 86, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SUPPORTED_ALGORITHM); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_SUPPORTED_ALGORITHM); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 100, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_algorithm, __pyx_t_2, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 86, __pyx_L1_error) + __pyx_t_3 = (__Pyx_PySequence_ContainsTF(__pyx_v_algorithm, __pyx_t_2, Py_NE)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 100, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_5 = (__pyx_t_1 != 0); - if (unlikely(__pyx_t_5)) { + __pyx_t_4 = (__pyx_t_3 != 0); + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":87 + /* "l0learn/interface.pyx":101 * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") * if algorithm not in SUPPORTED_ALGORITHM: * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") # <<<<<<<<<<<<<< * if not isinstance(max_support_size, int) or 1 > max_support_size: * raise ValueError(f"expected max_support_size parameter to be a positive integer, but got {max_support_size}") */ - __Pyx_TraceLine(87,0,__PYX_ERR(0, 87, __pyx_L1_error)) - __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 87, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 101, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_9 = 0; - __pyx_t_10 = 127; + __pyx_t_7 = 0; + __pyx_t_8 = 127; __Pyx_INCREF(__pyx_kp_u_expected_algorithm_parameter_to); - __pyx_t_9 += 41; + __pyx_t_7 += 41; __Pyx_GIVEREF(__pyx_kp_u_expected_algorithm_parameter_to); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_u_expected_algorithm_parameter_to); - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_SUPPORTED_ALGORITHM); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3); - __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_SUPPORTED_ALGORITHM); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 101, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_t_6, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 101, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_1); + __pyx_t_1 = 0; __Pyx_INCREF(__pyx_kp_u_but_got); - __pyx_t_9 += 10; + __pyx_t_7 += 10; __Pyx_GIVEREF(__pyx_kp_u_but_got); PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_kp_u_but_got); - __pyx_t_3 = __Pyx_PyUnicode_Unicode(__pyx_v_algorithm); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_3); - __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_2, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyUnicode_Unicode(__pyx_v_algorithm); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 101, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_2, 4, __pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 101, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 87, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 101, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 87, __pyx_L1_error) + __PYX_ERR(0, 101, __pyx_L1_error) - /* "l0learn/interface.pyx":86 + /* "l0learn/interface.pyx":100 * if penalty not in SUPPORTED_PENALTY: * raise ValueError(f"expected penalty parameter to be on of {SUPPORTED_PENALTY}, but got {penalty}") * if algorithm not in SUPPORTED_ALGORITHM: # <<<<<<<<<<<<<< @@ -4137,49 +3310,47 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":88 + /* "l0learn/interface.pyx":102 * if algorithm not in SUPPORTED_ALGORITHM: * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") * if not isinstance(max_support_size, int) or 1 > max_support_size: # <<<<<<<<<<<<<< * raise ValueError(f"expected max_support_size parameter to be a positive integer, but got {max_support_size}") * max_support_size = min(p, max_support_size) */ - __Pyx_TraceLine(88,0,__PYX_ERR(0, 88, __pyx_L1_error)) - __pyx_t_1 = PyInt_Check(__pyx_v_max_support_size); - __pyx_t_4 = ((!(__pyx_t_1 != 0)) != 0); - if (!__pyx_t_4) { + __pyx_t_3 = PyInt_Check(__pyx_v_max_support_size); + __pyx_t_5 = ((!(__pyx_t_3 != 0)) != 0); + if (!__pyx_t_5) { } else { - __pyx_t_5 = __pyx_t_4; - goto __pyx_L22_bool_binop_done; + __pyx_t_4 = __pyx_t_5; + goto __pyx_L20_bool_binop_done; } - __pyx_t_2 = PyObject_RichCompare(__pyx_int_1, __pyx_v_max_support_size, Py_GT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 88, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 88, __pyx_L1_error) + __pyx_t_2 = PyObject_RichCompare(__pyx_int_1, __pyx_v_max_support_size, Py_GT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 102, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 102, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_5 = __pyx_t_4; - __pyx_L22_bool_binop_done:; - if (unlikely(__pyx_t_5)) { + __pyx_t_4 = __pyx_t_5; + __pyx_L20_bool_binop_done:; + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":89 + /* "l0learn/interface.pyx":103 * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") * if not isinstance(max_support_size, int) or 1 > max_support_size: * raise ValueError(f"expected max_support_size parameter to be a positive integer, but got {max_support_size}") # <<<<<<<<<<<<<< * max_support_size = min(p, max_support_size) * */ - __Pyx_TraceLine(89,0,__PYX_ERR(0, 89, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_max_support_size, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 89, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_max_support_size, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 103, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_support_size_parame, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 89, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_support_size_parame, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 89, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 103, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 89, __pyx_L1_error) + __PYX_ERR(0, 103, __pyx_L1_error) - /* "l0learn/interface.pyx":88 + /* "l0learn/interface.pyx":102 * if algorithm not in SUPPORTED_ALGORITHM: * raise ValueError(f"expected algorithm parameter to be on of {SUPPORTED_ALGORITHM}, but got {algorithm}") * if not isinstance(max_support_size, int) or 1 > max_support_size: # <<<<<<<<<<<<<< @@ -4188,71 +3359,68 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":90 + /* "l0learn/interface.pyx":104 * if not isinstance(max_support_size, int) or 1 > max_support_size: * raise ValueError(f"expected max_support_size parameter to be a positive integer, but got {max_support_size}") * max_support_size = min(p, max_support_size) # <<<<<<<<<<<<<< * * if gamma_max < 0: */ - __Pyx_TraceLine(90,0,__PYX_ERR(0, 90, __pyx_L1_error)) __Pyx_INCREF(__pyx_v_max_support_size); __pyx_t_2 = __pyx_v_max_support_size; __Pyx_INCREF(__pyx_v_p); - __pyx_t_3 = __pyx_v_p; - __pyx_t_8 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 90, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 90, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (__pyx_t_5) { + __pyx_t_1 = __pyx_v_p; + __pyx_t_9 = PyObject_RichCompare(__pyx_t_2, __pyx_t_1, Py_LT); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 104, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 104, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (__pyx_t_4) { __Pyx_INCREF(__pyx_t_2); - __pyx_t_7 = __pyx_t_2; + __pyx_t_6 = __pyx_t_2; } else { - __Pyx_INCREF(__pyx_t_3); - __pyx_t_7 = __pyx_t_3; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_6 = __pyx_t_1; } - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __pyx_t_7; + __pyx_t_2 = __pyx_t_6; __Pyx_INCREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF_SET(__pyx_v_max_support_size, __pyx_t_2); __pyx_t_2 = 0; - /* "l0learn/interface.pyx":92 + /* "l0learn/interface.pyx":106 * max_support_size = min(p, max_support_size) * * if gamma_max < 0: # <<<<<<<<<<<<<< * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") * if gamma_min < 0 or gamma_min > gamma_max: */ - __Pyx_TraceLine(92,0,__PYX_ERR(0, 92, __pyx_L1_error)) - __pyx_t_5 = ((__pyx_v_gamma_max < 0.0) != 0); - if (unlikely(__pyx_t_5)) { + __pyx_t_4 = ((__pyx_v_gamma_max < 0.0) != 0); + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":93 + /* "l0learn/interface.pyx":107 * * if gamma_max < 0: * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") # <<<<<<<<<<<<<< * if gamma_min < 0 or gamma_min > gamma_max: * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," */ - __Pyx_TraceLine(93,0,__PYX_ERR(0, 93, __pyx_L1_error)) - __pyx_t_2 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 93, __pyx_L1_error) + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 107, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 93, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_gamma_max_parameter_to, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 93, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_gamma_max_parameter_to, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 107, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 93, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_7, 0, 0, 0); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 93, __pyx_L1_error) + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 107, __pyx_L1_error) - /* "l0learn/interface.pyx":92 + /* "l0learn/interface.pyx":106 * max_support_size = min(p, max_support_size) * * if gamma_max < 0: # <<<<<<<<<<<<<< @@ -4261,58 +3429,55 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":94 + /* "l0learn/interface.pyx":108 * if gamma_max < 0: * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") * if gamma_min < 0 or gamma_min > gamma_max: # <<<<<<<<<<<<<< * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," * f" but got {gamma_min}") */ - __Pyx_TraceLine(94,0,__PYX_ERR(0, 94, __pyx_L1_error)) - __pyx_t_4 = ((__pyx_v_gamma_min < 0.0) != 0); - if (!__pyx_t_4) { + __pyx_t_5 = ((__pyx_v_gamma_min < 0.0) != 0); + if (!__pyx_t_5) { } else { - __pyx_t_5 = __pyx_t_4; - goto __pyx_L26_bool_binop_done; + __pyx_t_4 = __pyx_t_5; + goto __pyx_L24_bool_binop_done; } - __pyx_t_4 = ((__pyx_v_gamma_min > __pyx_v_gamma_max) != 0); - __pyx_t_5 = __pyx_t_4; - __pyx_L26_bool_binop_done:; - if (unlikely(__pyx_t_5)) { + __pyx_t_5 = ((__pyx_v_gamma_min > __pyx_v_gamma_max) != 0); + __pyx_t_4 = __pyx_t_5; + __pyx_L24_bool_binop_done:; + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":96 + /* "l0learn/interface.pyx":110 * if gamma_min < 0 or gamma_min > gamma_max: * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," * f" but got {gamma_min}") # <<<<<<<<<<<<<< * if not isinstance(partial_sort, bool): * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") */ - __Pyx_TraceLine(96,0,__PYX_ERR(0, 96, __pyx_L1_error)) - __pyx_t_7 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 96, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 96, __pyx_L1_error) + __pyx_t_6 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_6, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 110, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "l0learn/interface.pyx":95 + /* "l0learn/interface.pyx":109 * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") * if gamma_min < 0 or gamma_min > gamma_max: * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," # <<<<<<<<<<<<<< * f" but got {gamma_min}") * if not isinstance(partial_sort, bool): */ - __Pyx_TraceLine(95,0,__PYX_ERR(0, 95, __pyx_L1_error)) - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_gamma_max_parameter_to_2, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 95, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_gamma_max_parameter_to_2, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 95, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 109, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 95, __pyx_L1_error) + __PYX_ERR(0, 109, __pyx_L1_error) - /* "l0learn/interface.pyx":94 + /* "l0learn/interface.pyx":108 * if gamma_max < 0: * raise ValueError(f"expected gamma_max parameter to be a positive float, but got {gamma_max}") * if gamma_min < 0 or gamma_min > gamma_max: # <<<<<<<<<<<<<< @@ -4321,42 +3486,40 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":97 + /* "l0learn/interface.pyx":111 * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," * f" but got {gamma_min}") * if not isinstance(partial_sort, bool): # <<<<<<<<<<<<<< * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") * if not isinstance(max_iter, int) or max_iter < 1: */ - __Pyx_TraceLine(97,0,__PYX_ERR(0, 97, __pyx_L1_error)) __pyx_t_2 = ((PyObject*)&PyBool_Type); __Pyx_INCREF(__pyx_t_2); - __pyx_t_5 = PyObject_IsInstance(__pyx_v_partial_sort, __pyx_t_2); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 97, __pyx_L1_error) + __pyx_t_4 = PyObject_IsInstance(__pyx_v_partial_sort, __pyx_t_2); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 111, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = ((!(__pyx_t_5 != 0)) != 0); - if (unlikely(__pyx_t_4)) { + __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":98 + /* "l0learn/interface.pyx":112 * f" but got {gamma_min}") * if not isinstance(partial_sort, bool): * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") # <<<<<<<<<<<<<< * if not isinstance(max_iter, int) or max_iter < 1: * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") */ - __Pyx_TraceLine(98,0,__PYX_ERR(0, 98, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_partial_sort, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_partial_sort, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 112, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_partial_sort_parameter, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 98, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_partial_sort_parameter, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 112, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 98, __pyx_L1_error) + __PYX_ERR(0, 112, __pyx_L1_error) - /* "l0learn/interface.pyx":97 + /* "l0learn/interface.pyx":111 * raise ValueError(f"expected gamma_max parameter to be a positive float less than gamma_max," * f" but got {gamma_min}") * if not isinstance(partial_sort, bool): # <<<<<<<<<<<<<< @@ -4365,49 +3528,47 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":99 + /* "l0learn/interface.pyx":113 * if not isinstance(partial_sort, bool): * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") * if not isinstance(max_iter, int) or max_iter < 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") * if rtol < 0 or rtol >= 1: */ - __Pyx_TraceLine(99,0,__PYX_ERR(0, 99, __pyx_L1_error)) - __pyx_t_5 = PyInt_Check(__pyx_v_max_iter); - __pyx_t_1 = ((!(__pyx_t_5 != 0)) != 0); - if (!__pyx_t_1) { + __pyx_t_4 = PyInt_Check(__pyx_v_max_iter); + __pyx_t_3 = ((!(__pyx_t_4 != 0)) != 0); + if (!__pyx_t_3) { } else { - __pyx_t_4 = __pyx_t_1; - goto __pyx_L30_bool_binop_done; + __pyx_t_5 = __pyx_t_3; + goto __pyx_L28_bool_binop_done; } - __pyx_t_2 = PyObject_RichCompare(__pyx_v_max_iter, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __pyx_L1_error) - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 99, __pyx_L1_error) + __pyx_t_2 = PyObject_RichCompare(__pyx_v_max_iter, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 113, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 113, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __pyx_t_1; - __pyx_L30_bool_binop_done:; - if (unlikely(__pyx_t_4)) { + __pyx_t_5 = __pyx_t_3; + __pyx_L28_bool_binop_done:; + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":100 + /* "l0learn/interface.pyx":114 * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") * if not isinstance(max_iter, int) or max_iter < 1: * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") # <<<<<<<<<<<<<< * if rtol < 0 or rtol >= 1: * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") */ - __Pyx_TraceLine(100,0,__PYX_ERR(0, 100, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_max_iter, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 100, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_max_iter, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 114, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_iter_parameter_to_b, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 100, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_iter_parameter_to_b, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 100, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 114, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 100, __pyx_L1_error) + __PYX_ERR(0, 114, __pyx_L1_error) - /* "l0learn/interface.pyx":99 + /* "l0learn/interface.pyx":113 * if not isinstance(partial_sort, bool): * raise ValueError(f"expected partial_sort parameter to be a bool, but got {partial_sort}") * if not isinstance(max_iter, int) or max_iter < 1: # <<<<<<<<<<<<<< @@ -4416,49 +3577,47 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":101 + /* "l0learn/interface.pyx":115 * if not isinstance(max_iter, int) or max_iter < 1: * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") * if rtol < 0 or rtol >= 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") * if atol < 0: */ - __Pyx_TraceLine(101,0,__PYX_ERR(0, 101, __pyx_L1_error)) - __pyx_t_1 = ((__pyx_v_rtol < 0.0) != 0); - if (!__pyx_t_1) { + __pyx_t_3 = ((__pyx_v_rtol < 0.0) != 0); + if (!__pyx_t_3) { } else { - __pyx_t_4 = __pyx_t_1; - goto __pyx_L33_bool_binop_done; + __pyx_t_5 = __pyx_t_3; + goto __pyx_L31_bool_binop_done; } - __pyx_t_1 = ((__pyx_v_rtol >= 1.0) != 0); - __pyx_t_4 = __pyx_t_1; - __pyx_L33_bool_binop_done:; - if (unlikely(__pyx_t_4)) { + __pyx_t_3 = ((__pyx_v_rtol >= 1.0) != 0); + __pyx_t_5 = __pyx_t_3; + __pyx_L31_bool_binop_done:; + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":102 + /* "l0learn/interface.pyx":116 * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") * if rtol < 0 or rtol >= 1: * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") # <<<<<<<<<<<<<< * if atol < 0: * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") */ - __Pyx_TraceLine(102,0,__PYX_ERR(0, 102, __pyx_L1_error)) - __pyx_t_2 = PyFloat_FromDouble(__pyx_v_rtol); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 102, __pyx_L1_error) + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_rtol); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 116, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 102, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_rtol_parameter_to_exist, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 102, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_rtol_parameter_to_exist, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 116, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 102, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_7, 0, 0, 0); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 102, __pyx_L1_error) + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 116, __pyx_L1_error) - /* "l0learn/interface.pyx":101 + /* "l0learn/interface.pyx":115 * if not isinstance(max_iter, int) or max_iter < 1: * raise ValueError(f"expected max_iter parameter to be a positive integer, but got {max_iter}") * if rtol < 0 or rtol >= 1: # <<<<<<<<<<<<<< @@ -4467,41 +3626,39 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":103 + /* "l0learn/interface.pyx":117 * if rtol < 0 or rtol >= 1: * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") * if atol < 0: # <<<<<<<<<<<<<< * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") * if not isinstance(active_set, bool): */ - __Pyx_TraceLine(103,0,__PYX_ERR(0, 103, __pyx_L1_error)) - __pyx_t_4 = ((__pyx_v_atol < 0.0) != 0); - if (unlikely(__pyx_t_4)) { + __pyx_t_5 = ((__pyx_v_atol < 0.0) != 0); + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":104 + /* "l0learn/interface.pyx":118 * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") * if atol < 0: * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") # <<<<<<<<<<<<<< * if not isinstance(active_set, bool): * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") */ - __Pyx_TraceLine(104,0,__PYX_ERR(0, 104, __pyx_L1_error)) - __pyx_t_7 = PyFloat_FromDouble(__pyx_v_atol); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 104, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_7, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 104, __pyx_L1_error) + __pyx_t_6 = PyFloat_FromDouble(__pyx_v_atol); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 118, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_6, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 118, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_atol_parameter_to_exist, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 104, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_atol_parameter_to_exist, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 118, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 104, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 118, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 104, __pyx_L1_error) + __PYX_ERR(0, 118, __pyx_L1_error) - /* "l0learn/interface.pyx":103 + /* "l0learn/interface.pyx":117 * if rtol < 0 or rtol >= 1: * raise ValueError(f"expected rtol parameter to exist in [0, 1), but got {rtol}") * if atol < 0: # <<<<<<<<<<<<<< @@ -4510,42 +3667,40 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":105 + /* "l0learn/interface.pyx":119 * if atol < 0: * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") * if not isinstance(active_set, bool): # <<<<<<<<<<<<<< * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") * if not isinstance(active_set_num, int) or active_set_num < 1: */ - __Pyx_TraceLine(105,0,__PYX_ERR(0, 105, __pyx_L1_error)) __pyx_t_2 = ((PyObject*)&PyBool_Type); __Pyx_INCREF(__pyx_t_2); - __pyx_t_4 = PyObject_IsInstance(__pyx_v_active_set, __pyx_t_2); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 105, __pyx_L1_error) + __pyx_t_5 = PyObject_IsInstance(__pyx_v_active_set, __pyx_t_2); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 119, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_1 = ((!(__pyx_t_4 != 0)) != 0); - if (unlikely(__pyx_t_1)) { + __pyx_t_3 = ((!(__pyx_t_5 != 0)) != 0); + if (unlikely(__pyx_t_3)) { - /* "l0learn/interface.pyx":106 + /* "l0learn/interface.pyx":120 * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") * if not isinstance(active_set, bool): * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") # <<<<<<<<<<<<<< * if not isinstance(active_set_num, int) or active_set_num < 1: * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") */ - __Pyx_TraceLine(106,0,__PYX_ERR(0, 106, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_active_set, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 106, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_active_set, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_active_set_parameter_to, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 106, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_active_set_parameter_to, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 120, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 106, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 106, __pyx_L1_error) + __PYX_ERR(0, 120, __pyx_L1_error) - /* "l0learn/interface.pyx":105 + /* "l0learn/interface.pyx":119 * if atol < 0: * raise ValueError(f"expected atol parameter to exist in [0, INF), but got {atol}") * if not isinstance(active_set, bool): # <<<<<<<<<<<<<< @@ -4554,49 +3709,47 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":107 + /* "l0learn/interface.pyx":121 * if not isinstance(active_set, bool): * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") * if not isinstance(active_set_num, int) or active_set_num < 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") * if not isinstance(max_swaps, int) or max_swaps < 1: */ - __Pyx_TraceLine(107,0,__PYX_ERR(0, 107, __pyx_L1_error)) - __pyx_t_4 = PyInt_Check(__pyx_v_active_set_num); - __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); - if (!__pyx_t_5) { + __pyx_t_5 = PyInt_Check(__pyx_v_active_set_num); + __pyx_t_4 = ((!(__pyx_t_5 != 0)) != 0); + if (!__pyx_t_4) { } else { - __pyx_t_1 = __pyx_t_5; - goto __pyx_L38_bool_binop_done; + __pyx_t_3 = __pyx_t_4; + goto __pyx_L36_bool_binop_done; } - __pyx_t_2 = PyObject_RichCompare(__pyx_v_active_set_num, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 107, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 107, __pyx_L1_error) + __pyx_t_2 = PyObject_RichCompare(__pyx_v_active_set_num, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 121, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 121, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_1 = __pyx_t_5; - __pyx_L38_bool_binop_done:; - if (unlikely(__pyx_t_1)) { + __pyx_t_3 = __pyx_t_4; + __pyx_L36_bool_binop_done:; + if (unlikely(__pyx_t_3)) { - /* "l0learn/interface.pyx":108 + /* "l0learn/interface.pyx":122 * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") * if not isinstance(active_set_num, int) or active_set_num < 1: * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") # <<<<<<<<<<<<<< * if not isinstance(max_swaps, int) or max_swaps < 1: * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") */ - __Pyx_TraceLine(108,0,__PYX_ERR(0, 108, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_active_set_num, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 108, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_active_set_num, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 122, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_active_set_num_paramete, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 108, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_active_set_num_paramete, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 108, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 122, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 108, __pyx_L1_error) + __PYX_ERR(0, 122, __pyx_L1_error) - /* "l0learn/interface.pyx":107 + /* "l0learn/interface.pyx":121 * if not isinstance(active_set, bool): * raise ValueError(f"expected active_set parameter to be a bool, but got {active_set}") * if not isinstance(active_set_num, int) or active_set_num < 1: # <<<<<<<<<<<<<< @@ -4605,49 +3758,47 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":109 + /* "l0learn/interface.pyx":123 * if not isinstance(active_set_num, int) or active_set_num < 1: * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") * if not isinstance(max_swaps, int) or max_swaps < 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") * if not (0 < scale_down_factor < 1): */ - __Pyx_TraceLine(109,0,__PYX_ERR(0, 109, __pyx_L1_error)) - __pyx_t_5 = PyInt_Check(__pyx_v_max_swaps); - __pyx_t_4 = ((!(__pyx_t_5 != 0)) != 0); - if (!__pyx_t_4) { + __pyx_t_4 = PyInt_Check(__pyx_v_max_swaps); + __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); + if (!__pyx_t_5) { } else { - __pyx_t_1 = __pyx_t_4; - goto __pyx_L41_bool_binop_done; + __pyx_t_3 = __pyx_t_5; + goto __pyx_L39_bool_binop_done; } - __pyx_t_2 = PyObject_RichCompare(__pyx_v_max_swaps, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 109, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 109, __pyx_L1_error) + __pyx_t_2 = PyObject_RichCompare(__pyx_v_max_swaps, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 123, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_1 = __pyx_t_4; - __pyx_L41_bool_binop_done:; - if (unlikely(__pyx_t_1)) { + __pyx_t_3 = __pyx_t_5; + __pyx_L39_bool_binop_done:; + if (unlikely(__pyx_t_3)) { - /* "l0learn/interface.pyx":110 + /* "l0learn/interface.pyx":124 * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") * if not isinstance(max_swaps, int) or max_swaps < 1: * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") # <<<<<<<<<<<<<< * if not (0 < scale_down_factor < 1): * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") */ - __Pyx_TraceLine(110,0,__PYX_ERR(0, 110, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_max_swaps, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 110, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_max_swaps, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 124, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_swaps_parameter_to, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 110, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_max_swaps_parameter_to, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 124, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 110, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 124, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(0, 110, __pyx_L1_error) + __PYX_ERR(0, 124, __pyx_L1_error) - /* "l0learn/interface.pyx":109 + /* "l0learn/interface.pyx":123 * if not isinstance(active_set_num, int) or active_set_num < 1: * raise ValueError(f"expected active_set_num parameter to be a positive integer, but got {active_set_num}") * if not isinstance(max_swaps, int) or max_swaps < 1: # <<<<<<<<<<<<<< @@ -4656,45 +3807,43 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":111 + /* "l0learn/interface.pyx":125 * if not isinstance(max_swaps, int) or max_swaps < 1: * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") * if not (0 < scale_down_factor < 1): # <<<<<<<<<<<<<< * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") * if not isinstance(screen_size, int) or screen_size < 1: */ - __Pyx_TraceLine(111,0,__PYX_ERR(0, 111, __pyx_L1_error)) - __pyx_t_1 = (0.0 < __pyx_v_scale_down_factor); - if (__pyx_t_1) { - __pyx_t_1 = (__pyx_v_scale_down_factor < 1.0); + __pyx_t_3 = (0.0 < __pyx_v_scale_down_factor); + if (__pyx_t_3) { + __pyx_t_3 = (__pyx_v_scale_down_factor < 1.0); } - __pyx_t_4 = ((!(__pyx_t_1 != 0)) != 0); - if (unlikely(__pyx_t_4)) { + __pyx_t_5 = ((!(__pyx_t_3 != 0)) != 0); + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":112 + /* "l0learn/interface.pyx":126 * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") * if not (0 < scale_down_factor < 1): * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") # <<<<<<<<<<<<<< * if not isinstance(screen_size, int) or screen_size < 1: * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") */ - __Pyx_TraceLine(112,0,__PYX_ERR(0, 112, __pyx_L1_error)) - __pyx_t_2 = PyFloat_FromDouble(__pyx_v_scale_down_factor); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 112, __pyx_L1_error) + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_scale_down_factor); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 126, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 112, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_scale_down_factor_param, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 112, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_scale_down_factor_param, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 126, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 112, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_7, 0, 0, 0); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 112, __pyx_L1_error) + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 126, __pyx_L1_error) - /* "l0learn/interface.pyx":111 + /* "l0learn/interface.pyx":125 * if not isinstance(max_swaps, int) or max_swaps < 1: * raise ValueError(f"expected max_swaps parameter to be a positive integer, but got {max_swaps}") * if not (0 < scale_down_factor < 1): # <<<<<<<<<<<<<< @@ -4703,49 +3852,47 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":113 + /* "l0learn/interface.pyx":127 * if not (0 < scale_down_factor < 1): * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") * if not isinstance(screen_size, int) or screen_size < 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") * screen_size = min(screen_size, p) */ - __Pyx_TraceLine(113,0,__PYX_ERR(0, 113, __pyx_L1_error)) - __pyx_t_1 = PyInt_Check(__pyx_v_screen_size); - __pyx_t_5 = ((!(__pyx_t_1 != 0)) != 0); - if (!__pyx_t_5) { + __pyx_t_3 = PyInt_Check(__pyx_v_screen_size); + __pyx_t_4 = ((!(__pyx_t_3 != 0)) != 0); + if (!__pyx_t_4) { } else { - __pyx_t_4 = __pyx_t_5; - goto __pyx_L45_bool_binop_done; + __pyx_t_5 = __pyx_t_4; + goto __pyx_L43_bool_binop_done; } - __pyx_t_7 = PyObject_RichCompare(__pyx_v_screen_size, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 113, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 113, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = __pyx_t_5; - __pyx_L45_bool_binop_done:; - if (unlikely(__pyx_t_4)) { + __pyx_t_6 = PyObject_RichCompare(__pyx_v_screen_size, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 127, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 127, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_5 = __pyx_t_4; + __pyx_L43_bool_binop_done:; + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":114 + /* "l0learn/interface.pyx":128 * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") * if not isinstance(screen_size, int) or screen_size < 1: * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") # <<<<<<<<<<<<<< * screen_size = min(screen_size, p) * */ - __Pyx_TraceLine(114,0,__PYX_ERR(0, 114, __pyx_L1_error)) - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_screen_size, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 114, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_screen_size_parameter_t, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 114, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_screen_size, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_screen_size_parameter_t, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 128, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 114, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_7, 0, 0, 0); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 114, __pyx_L1_error) + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 128, __pyx_L1_error) - /* "l0learn/interface.pyx":113 + /* "l0learn/interface.pyx":127 * if not (0 < scale_down_factor < 1): * raise ValueError(f"expected scale_down_factor parameter to exist in (0, 1), but got {scale_down_factor}") * if not isinstance(screen_size, int) or screen_size < 1: # <<<<<<<<<<<<<< @@ -4754,126 +3901,121 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":115 + /* "l0learn/interface.pyx":129 * if not isinstance(screen_size, int) or screen_size < 1: * raise ValueError(f"expected screen_size parameter to be a positive integer, but got {screen_size}") * screen_size = min(screen_size, p) # <<<<<<<<<<<<<< * * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): */ - __Pyx_TraceLine(115,0,__PYX_ERR(0, 115, __pyx_L1_error)) __Pyx_INCREF(__pyx_v_p); - __pyx_t_7 = __pyx_v_p; + __pyx_t_6 = __pyx_v_p; __Pyx_INCREF(__pyx_v_screen_size); __pyx_t_2 = __pyx_v_screen_size; - __pyx_t_8 = PyObject_RichCompare(__pyx_t_7, __pyx_t_2, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 115, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 115, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (__pyx_t_4) { - __Pyx_INCREF(__pyx_t_7); - __pyx_t_3 = __pyx_t_7; + __pyx_t_9 = PyObject_RichCompare(__pyx_t_6, __pyx_t_2, Py_LT); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 129, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 129, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (__pyx_t_5) { + __Pyx_INCREF(__pyx_t_6); + __pyx_t_1 = __pyx_t_6; } else { __Pyx_INCREF(__pyx_t_2); - __pyx_t_3 = __pyx_t_2; + __pyx_t_1 = __pyx_t_2; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __pyx_t_3; - __Pyx_INCREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF_SET(__pyx_v_screen_size, __pyx_t_7); - __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __pyx_t_1; + __Pyx_INCREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_screen_size, __pyx_t_6); + __pyx_t_6 = 0; - /* "l0learn/interface.pyx":117 + /* "l0learn/interface.pyx":131 * screen_size = min(screen_size, p) * * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): # <<<<<<<<<<<<<< * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " * f"but got {exclude_first_k}") */ - __Pyx_TraceLine(117,0,__PYX_ERR(0, 117, __pyx_L1_error)) - __pyx_t_5 = PyInt_Check(__pyx_v_exclude_first_k); - __pyx_t_1 = ((!(__pyx_t_5 != 0)) != 0); - if (!__pyx_t_1) { + __pyx_t_4 = PyInt_Check(__pyx_v_exclude_first_k); + __pyx_t_3 = ((!(__pyx_t_4 != 0)) != 0); + if (!__pyx_t_3) { } else { - __pyx_t_4 = __pyx_t_1; - goto __pyx_L48_bool_binop_done; + __pyx_t_5 = __pyx_t_3; + goto __pyx_L46_bool_binop_done; } - __pyx_t_7 = PyObject_RichCompare(__pyx_int_0, __pyx_v_exclude_first_k, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 117, __pyx_L1_error) - if (__Pyx_PyObject_IsTrue(__pyx_t_7)) { - __Pyx_DECREF(__pyx_t_7); - __pyx_t_7 = PyObject_RichCompare(__pyx_v_exclude_first_k, __pyx_v_p, Py_LE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 117, __pyx_L1_error) + __pyx_t_6 = PyObject_RichCompare(__pyx_int_0, __pyx_v_exclude_first_k, Py_LE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 131, __pyx_L1_error) + if (__Pyx_PyObject_IsTrue(__pyx_t_6)) { + __Pyx_DECREF(__pyx_t_6); + __pyx_t_6 = PyObject_RichCompare(__pyx_v_exclude_first_k, __pyx_v_p, Py_LE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 131, __pyx_L1_error) } - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 117, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_5 = ((!__pyx_t_1) != 0); - __pyx_t_4 = __pyx_t_5; - __pyx_L48_bool_binop_done:; - if (unlikely(__pyx_t_4)) { + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 131, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_4 = ((!__pyx_t_3) != 0); + __pyx_t_5 = __pyx_t_4; + __pyx_L46_bool_binop_done:; + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":118 + /* "l0learn/interface.pyx":132 * * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " # <<<<<<<<<<<<<< * f"but got {exclude_first_k}") * if not isinstance(intercept, bool): */ - __Pyx_TraceLine(118,0,__PYX_ERR(0, 118, __pyx_L1_error)) - __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 118, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_9 = 0; - __pyx_t_10 = 127; + __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = 0; + __pyx_t_8 = 127; __Pyx_INCREF(__pyx_kp_u_expected_exclude_first_k_paramet); - __pyx_t_9 += 70; + __pyx_t_7 += 70; __Pyx_GIVEREF(__pyx_kp_u_expected_exclude_first_k_paramet); - PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_exclude_first_k_paramet); - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 118, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_3); - __pyx_t_3 = 0; + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_exclude_first_k_paramet); + __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_1); + __pyx_t_1 = 0; __Pyx_INCREF(__pyx_kp_u_but_got); - __pyx_t_9 += 10; + __pyx_t_7 += 10; __Pyx_GIVEREF(__pyx_kp_u_but_got); - PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_but_got); + PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u_but_got); - /* "l0learn/interface.pyx":119 + /* "l0learn/interface.pyx":133 * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " * f"but got {exclude_first_k}") # <<<<<<<<<<<<<< * if not isinstance(intercept, bool): * raise ValueError(f"expected intercept parameter to be a bool, " */ - __Pyx_TraceLine(119,0,__PYX_ERR(0, 119, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_exclude_first_k, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 119, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_3); - __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_exclude_first_k, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_1); + __pyx_t_1 = 0; - /* "l0learn/interface.pyx":118 + /* "l0learn/interface.pyx":132 * * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " # <<<<<<<<<<<<<< * f"but got {exclude_first_k}") * if not isinstance(intercept, bool): */ - __Pyx_TraceLine(118,0,__PYX_ERR(0, 118, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 118, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 118, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_t_7, 0, 0, 0); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 118, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_6, 4, __pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 132, __pyx_L1_error) - /* "l0learn/interface.pyx":117 + /* "l0learn/interface.pyx":131 * screen_size = min(screen_size, p) * * if not isinstance(exclude_first_k, int) or not (0 <= exclude_first_k <= p): # <<<<<<<<<<<<<< @@ -4882,51 +4024,48 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":120 + /* "l0learn/interface.pyx":134 * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " * f"but got {exclude_first_k}") * if not isinstance(intercept, bool): # <<<<<<<<<<<<<< * raise ValueError(f"expected intercept parameter to be a bool, " * f"but got {intercept}") */ - __Pyx_TraceLine(120,0,__PYX_ERR(0, 120, __pyx_L1_error)) - __pyx_t_7 = ((PyObject*)&PyBool_Type); - __Pyx_INCREF(__pyx_t_7); - __pyx_t_4 = PyObject_IsInstance(__pyx_v_intercept, __pyx_t_7); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 120, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); - if (unlikely(__pyx_t_5)) { + __pyx_t_6 = ((PyObject*)&PyBool_Type); + __Pyx_INCREF(__pyx_t_6); + __pyx_t_5 = PyObject_IsInstance(__pyx_v_intercept, __pyx_t_6); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 134, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_4 = ((!(__pyx_t_5 != 0)) != 0); + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":122 + /* "l0learn/interface.pyx":136 * if not isinstance(intercept, bool): * raise ValueError(f"expected intercept parameter to be a bool, " * f"but got {intercept}") # <<<<<<<<<<<<<< * * if loss in CLASSIFICATION_LOSS: */ - __Pyx_TraceLine(122,0,__PYX_ERR(0, 122, __pyx_L1_error)) - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_intercept, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 122, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_intercept, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); - /* "l0learn/interface.pyx":121 + /* "l0learn/interface.pyx":135 * f"but got {exclude_first_k}") * if not isinstance(intercept, bool): * raise ValueError(f"expected intercept parameter to be a bool, " # <<<<<<<<<<<<<< * f"but got {intercept}") * */ - __Pyx_TraceLine(121,0,__PYX_ERR(0, 121, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_intercept_parameter_to, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 121, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 121, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_t_7, 0, 0, 0); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 121, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_intercept_parameter_to, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 135, __pyx_L1_error) - /* "l0learn/interface.pyx":120 + /* "l0learn/interface.pyx":134 * raise ValueError(f"expected exclude_first_k parameter to be a positive integer less than {p}, " * f"but got {exclude_first_k}") * if not isinstance(intercept, bool): # <<<<<<<<<<<<<< @@ -4935,104 +4074,99 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":124 + /* "l0learn/interface.pyx":138 * f"but got {intercept}") * * if loss in CLASSIFICATION_LOSS: # <<<<<<<<<<<<<< * unique_items = sorted(np.unique(y)) * if len(unique_items) != 2: */ - __Pyx_TraceLine(124,0,__PYX_ERR(0, 124, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_CLASSIFICATION_LOSS); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 124, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_v_loss, __pyx_t_7, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 124, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = (__pyx_t_5 != 0); - if (__pyx_t_4) { + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_CLASSIFICATION_LOSS); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_4 = (__Pyx_PySequence_ContainsTF(__pyx_v_loss, __pyx_t_6, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_5 = (__pyx_t_4 != 0); + if (__pyx_t_5) { - /* "l0learn/interface.pyx":125 + /* "l0learn/interface.pyx":139 * * if loss in CLASSIFICATION_LOSS: * unique_items = sorted(np.unique(y)) # <<<<<<<<<<<<<< * if len(unique_items) != 2: * raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " */ - __Pyx_TraceLine(125,0,__PYX_ERR(0, 125, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 125, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 139, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_unique); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 125, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_unique); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_8); + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_9); if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_8, function); + __Pyx_DECREF_SET(__pyx_t_9, function); } } - __pyx_t_3 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_2, __pyx_v_y) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_y); + __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_2, __pyx_v_y) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_v_y); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 125, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = PySequence_List(__pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 125, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_7 = ((PyObject*)__pyx_t_8); - __pyx_t_8 = 0; - __pyx_t_12 = PyList_Sort(__pyx_t_7); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 125, __pyx_L1_error) - __pyx_v_unique_items = ((PyObject*)__pyx_t_7); - __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = PySequence_List(__pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_6 = ((PyObject*)__pyx_t_9); + __pyx_t_9 = 0; + __pyx_t_11 = PyList_Sort(__pyx_t_6); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(0, 139, __pyx_L1_error) + __pyx_v_unique_items = ((PyObject*)__pyx_t_6); + __pyx_t_6 = 0; - /* "l0learn/interface.pyx":126 + /* "l0learn/interface.pyx":140 * if loss in CLASSIFICATION_LOSS: * unique_items = sorted(np.unique(y)) * if len(unique_items) != 2: # <<<<<<<<<<<<<< * raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " * f"but got {unique_items}") */ - __Pyx_TraceLine(126,0,__PYX_ERR(0, 126, __pyx_L1_error)) if (unlikely(__pyx_v_unique_items == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(0, 126, __pyx_L1_error) + __PYX_ERR(0, 140, __pyx_L1_error) } - __pyx_t_9 = PyList_GET_SIZE(__pyx_v_unique_items); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 126, __pyx_L1_error) - __pyx_t_4 = ((__pyx_t_9 != 2) != 0); - if (unlikely(__pyx_t_4)) { + __pyx_t_7 = PyList_GET_SIZE(__pyx_v_unique_items); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(0, 140, __pyx_L1_error) + __pyx_t_5 = ((__pyx_t_7 != 2) != 0); + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":128 + /* "l0learn/interface.pyx":142 * if len(unique_items) != 2: * raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " * f"but got {unique_items}") # <<<<<<<<<<<<<< * else: * a, *_ = unique_items # a is the lower value */ - __Pyx_TraceLine(128,0,__PYX_ERR(0, 128, __pyx_L1_error)) - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_unique_items, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 128, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_unique_items, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); - /* "l0learn/interface.pyx":127 + /* "l0learn/interface.pyx":141 * unique_items = sorted(np.unique(y)) * if len(unique_items) != 2: * raise ValueError(f"expected y vector to only have two unique values (Binary Classification), " # <<<<<<<<<<<<<< * f"but got {unique_items}") * else: */ - __Pyx_TraceLine(127,0,__PYX_ERR(0, 127, __pyx_L1_error)) - __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_y_vector_to_only_have_t, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 127, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 127, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_Raise(__pyx_t_7, 0, 0, 0); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 127, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_y_vector_to_only_have_t, __pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 141, __pyx_L1_error) - /* "l0learn/interface.pyx":126 + /* "l0learn/interface.pyx":140 * if loss in CLASSIFICATION_LOSS: * unique_items = sorted(np.unique(y)) * if len(unique_items) != 2: # <<<<<<<<<<<<<< @@ -5041,168 +4175,160 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":130 + /* "l0learn/interface.pyx":144 * f"but got {unique_items}") * else: * a, *_ = unique_items # a is the lower value # <<<<<<<<<<<<<< * y = np.copy(y) * first_value = y==a */ - __Pyx_TraceLine(130,0,__PYX_ERR(0, 130, __pyx_L1_error)) /*else*/ { { Py_ssize_t index = -1; - PyObject** temps[2] = {&__pyx_t_7}; - __pyx_t_8 = PyObject_GetIter(__pyx_v_unique_items); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 130, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_11 = Py_TYPE(__pyx_t_8)->tp_iternext; + PyObject** temps[2] = {&__pyx_t_6}; + __pyx_t_9 = PyObject_GetIter(__pyx_v_unique_items); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = Py_TYPE(__pyx_t_9)->tp_iternext; for (index=0; index < 1; index++) { - PyObject* item = __pyx_t_11(__pyx_t_8); if (unlikely(!item)) goto __pyx_L53_unpacking_failed; + PyObject* item = __pyx_t_10(__pyx_t_9); if (unlikely(!item)) goto __pyx_L51_unpacking_failed; __Pyx_GOTREF(item); *(temps[index]) = item; } - goto __pyx_L54_unpacking_done; - __pyx_L53_unpacking_failed:; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_11 = NULL; + goto __pyx_L52_unpacking_done; + __pyx_L51_unpacking_failed:; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_10 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 130, __pyx_L1_error) - __pyx_L54_unpacking_done:; + __PYX_ERR(0, 144, __pyx_L1_error) + __pyx_L52_unpacking_done:; } - __pyx_t_3 = PySequence_List(__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 130, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_v_a = __pyx_t_7; - __pyx_t_7 = 0; - __pyx_v__ = ((PyObject*)__pyx_t_3); - __pyx_t_3 = 0; + __pyx_t_1 = PySequence_List(__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_a = __pyx_t_6; + __pyx_t_6 = 0; + __pyx_v__ = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; - /* "l0learn/interface.pyx":131 + /* "l0learn/interface.pyx":145 * else: * a, *_ = unique_items # a is the lower value * y = np.copy(y) # <<<<<<<<<<<<<< * first_value = y==a * second_value = y!=a */ - __Pyx_TraceLine(131,0,__PYX_ERR(0, 131, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 131, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_copy); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 131, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); - if (likely(__pyx_t_7)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); - __Pyx_INCREF(__pyx_t_7); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 145, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_copy); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 145, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_8, function); + __Pyx_DECREF_SET(__pyx_t_9, function); } } - __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_7, __pyx_v_y) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_y); - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 131, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF_SET(__pyx_v_y, __pyx_t_3); - __pyx_t_3 = 0; + __pyx_t_1 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_6, __pyx_v_y) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_v_y); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 145, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF_SET(__pyx_v_y, __pyx_t_1); + __pyx_t_1 = 0; - /* "l0learn/interface.pyx":132 + /* "l0learn/interface.pyx":146 * a, *_ = unique_items # a is the lower value * y = np.copy(y) * first_value = y==a # <<<<<<<<<<<<<< * second_value = y!=a * y[first_value] = -1.0 */ - __Pyx_TraceLine(132,0,__PYX_ERR(0, 132, __pyx_L1_error)) - __pyx_t_3 = PyObject_RichCompare(__pyx_v_y, __pyx_v_a, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 132, __pyx_L1_error) - __pyx_v_first_value = __pyx_t_3; - __pyx_t_3 = 0; + __pyx_t_1 = PyObject_RichCompare(__pyx_v_y, __pyx_v_a, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 146, __pyx_L1_error) + __pyx_v_first_value = __pyx_t_1; + __pyx_t_1 = 0; - /* "l0learn/interface.pyx":133 + /* "l0learn/interface.pyx":147 * y = np.copy(y) * first_value = y==a * second_value = y!=a # <<<<<<<<<<<<<< * y[first_value] = -1.0 * y[second_value] = 1.0 */ - __Pyx_TraceLine(133,0,__PYX_ERR(0, 133, __pyx_L1_error)) - __pyx_t_3 = PyObject_RichCompare(__pyx_v_y, __pyx_v_a, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 133, __pyx_L1_error) - __pyx_v_second_value = __pyx_t_3; - __pyx_t_3 = 0; + __pyx_t_1 = PyObject_RichCompare(__pyx_v_y, __pyx_v_a, Py_NE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 147, __pyx_L1_error) + __pyx_v_second_value = __pyx_t_1; + __pyx_t_1 = 0; - /* "l0learn/interface.pyx":134 + /* "l0learn/interface.pyx":148 * first_value = y==a * second_value = y!=a * y[first_value] = -1.0 # <<<<<<<<<<<<<< * y[second_value] = 1.0 * if y.dtype != np.float64: */ - __Pyx_TraceLine(134,0,__PYX_ERR(0, 134, __pyx_L1_error)) - if (unlikely(PyObject_SetItem(__pyx_v_y, __pyx_v_first_value, __pyx_float_neg_1_0) < 0)) __PYX_ERR(0, 134, __pyx_L1_error) + if (unlikely(PyObject_SetItem(__pyx_v_y, __pyx_v_first_value, __pyx_float_neg_1_0) < 0)) __PYX_ERR(0, 148, __pyx_L1_error) - /* "l0learn/interface.pyx":135 + /* "l0learn/interface.pyx":149 * second_value = y!=a * y[first_value] = -1.0 * y[second_value] = 1.0 # <<<<<<<<<<<<<< * if y.dtype != np.float64: * y = y.astype(float) */ - __Pyx_TraceLine(135,0,__PYX_ERR(0, 135, __pyx_L1_error)) - if (unlikely(PyObject_SetItem(__pyx_v_y, __pyx_v_second_value, __pyx_float_1_0) < 0)) __PYX_ERR(0, 135, __pyx_L1_error) + if (unlikely(PyObject_SetItem(__pyx_v_y, __pyx_v_second_value, __pyx_float_1_0) < 0)) __PYX_ERR(0, 149, __pyx_L1_error) - /* "l0learn/interface.pyx":136 + /* "l0learn/interface.pyx":150 * y[first_value] = -1.0 * y[second_value] = 1.0 * if y.dtype != np.float64: # <<<<<<<<<<<<<< * y = y.astype(float) * */ - __Pyx_TraceLine(136,0,__PYX_ERR(0, 136, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_y, __pyx_n_s_dtype); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 136, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 136, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_float64); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 136, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = PyObject_RichCompare(__pyx_t_3, __pyx_t_7, Py_NE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 136, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 136, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (__pyx_t_4) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_y, __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_float64); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = PyObject_RichCompare(__pyx_t_1, __pyx_t_6, Py_NE); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 150, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (__pyx_t_5) { - /* "l0learn/interface.pyx":137 + /* "l0learn/interface.pyx":151 * y[second_value] = 1.0 * if y.dtype != np.float64: * y = y.astype(float) # <<<<<<<<<<<<<< * * if penalty == "L0": */ - __Pyx_TraceLine(137,0,__PYX_ERR(0, 137, __pyx_L1_error)) - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_y, __pyx_n_s_astype); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 137, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_3 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_7); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); - __Pyx_INCREF(__pyx_t_3); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_y, __pyx_n_s_astype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_7, function); + __Pyx_DECREF_SET(__pyx_t_6, function); } } - __pyx_t_8 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_3, ((PyObject *)(&PyFloat_Type))) : __Pyx_PyObject_CallOneArg(__pyx_t_7, ((PyObject *)(&PyFloat_Type))); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 137, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF_SET(__pyx_v_y, __pyx_t_8); - __pyx_t_8 = 0; - - /* "l0learn/interface.pyx":136 + __pyx_t_9 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_1, ((PyObject *)(&PyFloat_Type))) : __Pyx_PyObject_CallOneArg(__pyx_t_6, ((PyObject *)(&PyFloat_Type))); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF_SET(__pyx_v_y, __pyx_t_9); + __pyx_t_9 = 0; + + /* "l0learn/interface.pyx":150 * y[first_value] = -1.0 * y[second_value] = 1.0 * if y.dtype != np.float64: # <<<<<<<<<<<<<< @@ -5212,77 +4338,74 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject } } - /* "l0learn/interface.pyx":139 + /* "l0learn/interface.pyx":153 * y = y.astype(float) * * if penalty == "L0": # <<<<<<<<<<<<<< * # Pure L0 is not supported for classification * # Below we add a small L2 component. */ - __Pyx_TraceLine(139,0,__PYX_ERR(0, 139, __pyx_L1_error)) - __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 139, __pyx_L1_error) - __pyx_t_5 = (__pyx_t_4 != 0); - if (__pyx_t_5) { + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 153, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_5 != 0); + if (__pyx_t_4) { - /* "l0learn/interface.pyx":143 + /* "l0learn/interface.pyx":157 * # Below we add a small L2 component. * * if lambda_grid is not None and len(lambda_grid) != 1: # <<<<<<<<<<<<<< * # If this error checking was left to the lower section, it would confuse users as * # we are converting L0 to L0L2 with small L2 penalty. */ - __Pyx_TraceLine(143,0,__PYX_ERR(0, 143, __pyx_L1_error)) - __pyx_t_4 = (__pyx_v_lambda_grid != Py_None); - __pyx_t_1 = (__pyx_t_4 != 0); - if (__pyx_t_1) { + __pyx_t_5 = (__pyx_v_lambda_grid != Py_None); + __pyx_t_3 = (__pyx_t_5 != 0); + if (__pyx_t_3) { } else { - __pyx_t_5 = __pyx_t_1; - goto __pyx_L58_bool_binop_done; + __pyx_t_4 = __pyx_t_3; + goto __pyx_L56_bool_binop_done; } - __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 143, __pyx_L1_error) - __pyx_t_1 = ((__pyx_t_9 != 1) != 0); - __pyx_t_5 = __pyx_t_1; - __pyx_L58_bool_binop_done:; - if (unlikely(__pyx_t_5)) { + __pyx_t_7 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(0, 157, __pyx_L1_error) + __pyx_t_3 = ((__pyx_t_7 != 1) != 0); + __pyx_t_4 = __pyx_t_3; + __pyx_L56_bool_binop_done:; + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":148 + /* "l0learn/interface.pyx":162 * # Here we must check if lambdaGrid is supplied (And thus use 'autolambda') * # If 'lambdaGrid' is supplied, we must only supply 1 list of lambda values * raise ValueError(f"L0 Penalty requires 'lambda_grid' to be a list of length 1, but got {lambda_grid}.") # <<<<<<<<<<<<<< * * penalty = "L0L2" */ - __Pyx_TraceLine(148,0,__PYX_ERR(0, 148, __pyx_L1_error)) - __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 148, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_9 = 0; - __pyx_t_10 = 127; + __pyx_t_9 = PyTuple_New(3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_7 = 0; + __pyx_t_8 = 127; __Pyx_INCREF(__pyx_kp_u_L0_Penalty_requires_lambda_grid); - __pyx_t_9 += 68; + __pyx_t_7 += 68; __Pyx_GIVEREF(__pyx_kp_u_L0_Penalty_requires_lambda_grid); - PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_u_L0_Penalty_requires_lambda_grid); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 148, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7); - __pyx_t_7 = 0; - __Pyx_INCREF(__pyx_kp_u__6); - __pyx_t_9 += 1; - __Pyx_GIVEREF(__pyx_kp_u__6); - PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__6); - __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 148, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 148, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 148, __pyx_L1_error) - - /* "l0learn/interface.pyx":143 + PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_kp_u_L0_Penalty_requires_lambda_grid); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_kp_u_); + __pyx_t_7 += 1; + __Pyx_GIVEREF(__pyx_kp_u_); + PyTuple_SET_ITEM(__pyx_t_9, 2, __pyx_kp_u_); + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_9, 3, __pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_9, 0, 0, 0); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __PYX_ERR(0, 162, __pyx_L1_error) + + /* "l0learn/interface.pyx":157 * # Below we add a small L2 component. * * if lambda_grid is not None and len(lambda_grid) != 1: # <<<<<<<<<<<<<< @@ -5291,7 +4414,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":139 + /* "l0learn/interface.pyx":153 * y = y.astype(float) * * if penalty == "L0": # <<<<<<<<<<<<<< @@ -5300,136 +4423,131 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":150 + /* "l0learn/interface.pyx":164 * raise ValueError(f"L0 Penalty requires 'lambda_grid' to be a list of length 1, but got {lambda_grid}.") * * penalty = "L0L2" # <<<<<<<<<<<<<< * gamma_max = 1e-7 * gamma_min = 1e-7 */ - __Pyx_TraceLine(150,0,__PYX_ERR(0, 150, __pyx_L1_error)) __Pyx_INCREF(__pyx_n_u_L0L2); __Pyx_DECREF_SET(__pyx_v_penalty, __pyx_n_u_L0L2); - /* "l0learn/interface.pyx":151 + /* "l0learn/interface.pyx":165 * * penalty = "L0L2" * gamma_max = 1e-7 # <<<<<<<<<<<<<< * gamma_min = 1e-7 * elif penalty != "L0" and num_gamma == 1: */ - __Pyx_TraceLine(151,0,__PYX_ERR(0, 151, __pyx_L1_error)) __pyx_v_gamma_max = 1e-7; - /* "l0learn/interface.pyx":152 + /* "l0learn/interface.pyx":166 * penalty = "L0L2" * gamma_max = 1e-7 * gamma_min = 1e-7 # <<<<<<<<<<<<<< * elif penalty != "L0" and num_gamma == 1: * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") */ - __Pyx_TraceLine(152,0,__PYX_ERR(0, 152, __pyx_L1_error)) __pyx_v_gamma_min = 1e-7; - /* "l0learn/interface.pyx":124 + /* "l0learn/interface.pyx":138 * f"but got {intercept}") * * if loss in CLASSIFICATION_LOSS: # <<<<<<<<<<<<<< * unique_items = sorted(np.unique(y)) * if len(unique_items) != 2: */ - goto __pyx_L51; + goto __pyx_L49; } - /* "l0learn/interface.pyx":153 + /* "l0learn/interface.pyx":167 * gamma_max = 1e-7 * gamma_min = 1e-7 * elif penalty != "L0" and num_gamma == 1: # <<<<<<<<<<<<<< * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") * */ - __Pyx_TraceLine(153,0,__PYX_ERR(0, 153, __pyx_L1_error)) - __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 153, __pyx_L1_error) - __pyx_t_4 = (__pyx_t_1 != 0); - if (__pyx_t_4) { + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_NE)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 167, __pyx_L1_error) + __pyx_t_5 = (__pyx_t_3 != 0); + if (__pyx_t_5) { } else { - __pyx_t_5 = __pyx_t_4; - goto __pyx_L60_bool_binop_done; + __pyx_t_4 = __pyx_t_5; + goto __pyx_L58_bool_binop_done; } - __pyx_t_8 = __Pyx_PyInt_EqObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 153, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 153, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_5 = __pyx_t_4; - __pyx_L60_bool_binop_done:; - if (__pyx_t_5) { + __pyx_t_9 = __Pyx_PyInt_EqObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 167, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_4 = __pyx_t_5; + __pyx_L58_bool_binop_done:; + if (__pyx_t_4) { - /* "l0learn/interface.pyx":154 + /* "l0learn/interface.pyx":168 * gamma_min = 1e-7 * elif penalty != "L0" and num_gamma == 1: * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") # <<<<<<<<<<<<<< * * if y.dtype != np.float64: */ - __Pyx_TraceLine(154,0,__PYX_ERR(0, 154, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_warn); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 154, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_3 = PyTuple_New(5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 154, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_9 = 0; - __pyx_t_10 = 127; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_warn); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 168, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = PyTuple_New(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 168, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = 0; + __pyx_t_8 = 127; __Pyx_INCREF(__pyx_kp_u_num_gamma_set_to_1_with); - __pyx_t_9 += 24; + __pyx_t_7 += 24; __Pyx_GIVEREF(__pyx_kp_u_num_gamma_set_to_1_with); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_num_gamma_set_to_1_with); - __pyx_t_2 = __Pyx_PyUnicode_Unicode(__pyx_v_penalty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 154, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_num_gamma_set_to_1_with); + __pyx_t_2 = __Pyx_PyUnicode_Unicode(__pyx_v_penalty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 168, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_2); __pyx_t_2 = 0; __Pyx_INCREF(__pyx_kp_u_penalty_Only_one); - __pyx_t_9 += 19; + __pyx_t_7 += 19; __Pyx_GIVEREF(__pyx_kp_u_penalty_Only_one); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_penalty_Only_one); + PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_penalty_Only_one); if (unlikely(__pyx_v_penalty == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(0, 154, __pyx_L1_error) + __PYX_ERR(0, 168, __pyx_L1_error) } - __pyx_t_2 = __Pyx_PyUnicode_Substring(__pyx_v_penalty, 2, PY_SSIZE_T_MAX); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 154, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyUnicode_Substring(__pyx_v_penalty, 2, PY_SSIZE_T_MAX); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 168, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_t_2); __pyx_t_2 = 0; __Pyx_INCREF(__pyx_kp_u_penalty_value_will_be_fit); - __pyx_t_9 += 27; + __pyx_t_7 += 27; __Pyx_GIVEREF(__pyx_kp_u_penalty_value_will_be_fit); - PyTuple_SET_ITEM(__pyx_t_3, 4, __pyx_kp_u_penalty_value_will_be_fit); - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_3, 5, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 154, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_1, 4, __pyx_kp_u_penalty_value_will_be_fit); + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_1, 5, __pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 168, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_7); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); - __Pyx_INCREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_7, function); + __Pyx_DECREF_SET(__pyx_t_6, function); } } - __pyx_t_8 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_3, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_9 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_1, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_2); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 154, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 168, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "l0learn/interface.pyx":153 + /* "l0learn/interface.pyx":167 * gamma_max = 1e-7 * gamma_min = 1e-7 * elif penalty != "L0" and num_gamma == 1: # <<<<<<<<<<<<<< @@ -5437,84 +4555,82 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject * */ } - __pyx_L51:; + __pyx_L49:; - /* "l0learn/interface.pyx":156 + /* "l0learn/interface.pyx":170 * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") * * if y.dtype != np.float64: # <<<<<<<<<<<<<< * raise ValueError(f"expected y vector to have type {np.float64}, but got {y.dtype}") * */ - __Pyx_TraceLine(156,0,__PYX_ERR(0, 156, __pyx_L1_error)) - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_y, __pyx_n_s_dtype); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 156, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 156, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_float64); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 156, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_y, __pyx_n_s_dtype); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_float64); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = PyObject_RichCompare(__pyx_t_8, __pyx_t_2, Py_NE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 156, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = PyObject_RichCompare(__pyx_t_9, __pyx_t_2, Py_NE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 170, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 156, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(__pyx_t_5)) { + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 170, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":157 + /* "l0learn/interface.pyx":171 * * if y.dtype != np.float64: * raise ValueError(f"expected y vector to have type {np.float64}, but got {y.dtype}") # <<<<<<<<<<<<<< * * if lambda_grid is None: */ - __Pyx_TraceLine(157,0,__PYX_ERR(0, 157, __pyx_L1_error)) - __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 157, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_9 = 0; - __pyx_t_10 = 127; + __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 171, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = 0; + __pyx_t_8 = 127; __Pyx_INCREF(__pyx_kp_u_expected_y_vector_to_have_type); - __pyx_t_9 += 31; + __pyx_t_7 += 31; __Pyx_GIVEREF(__pyx_kp_u_expected_y_vector_to_have_type); - PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_y_vector_to_have_type); - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 157, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_y_vector_to_have_type); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 171, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_float64); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 157, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_float64); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 171, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_8, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 157, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_t_9, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 171, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_2); __pyx_t_2 = 0; __Pyx_INCREF(__pyx_kp_u_but_got); - __pyx_t_9 += 10; + __pyx_t_7 += 10; __Pyx_GIVEREF(__pyx_kp_u_but_got); - PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_but_got); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_y, __pyx_n_s_dtype); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 157, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u_but_got); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_y, __pyx_n_s_dtype); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 171, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 157, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 171, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); - __Pyx_GIVEREF(__pyx_t_8); - PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_t_8); - __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_7, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 157, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 157, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_Raise(__pyx_t_7, 0, 0, 0); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 157, __pyx_L1_error) - - /* "l0learn/interface.pyx":156 + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_9); + __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyUnicode_Join(__pyx_t_6, 4, __pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 171, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 171, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 171, __pyx_L1_error) + + /* "l0learn/interface.pyx":170 * warn(f"num_gamma set to 1 with {penalty} penalty. Only one {penalty[2:]} penalty value will be fit.") * * if y.dtype != np.float64: # <<<<<<<<<<<<<< @@ -5523,109 +4639,104 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":159 + /* "l0learn/interface.pyx":173 * raise ValueError(f"expected y vector to have type {np.float64}, but got {y.dtype}") * * if lambda_grid is None: # <<<<<<<<<<<<<< * lambda_grid = [[0.]] * auto_lambda = True */ - __Pyx_TraceLine(159,0,__PYX_ERR(0, 159, __pyx_L1_error)) - __pyx_t_5 = (__pyx_v_lambda_grid == Py_None); - __pyx_t_4 = (__pyx_t_5 != 0); - if (__pyx_t_4) { + __pyx_t_4 = (__pyx_v_lambda_grid == Py_None); + __pyx_t_5 = (__pyx_t_4 != 0); + if (__pyx_t_5) { - /* "l0learn/interface.pyx":160 + /* "l0learn/interface.pyx":174 * * if lambda_grid is None: * lambda_grid = [[0.]] # <<<<<<<<<<<<<< * auto_lambda = True * if not isinstance(num_lambda, int) or num_lambda < 1: */ - __Pyx_TraceLine(160,0,__PYX_ERR(0, 160, __pyx_L1_error)) - __pyx_t_7 = PyList_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 160, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = PyList_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_float_0_); __Pyx_GIVEREF(__pyx_float_0_); - PyList_SET_ITEM(__pyx_t_7, 0, __pyx_float_0_); - __pyx_t_8 = PyList_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 160, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_GIVEREF(__pyx_t_7); - PyList_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); - __pyx_t_7 = 0; - __Pyx_DECREF_SET(__pyx_v_lambda_grid, __pyx_t_8); - __pyx_t_8 = 0; + PyList_SET_ITEM(__pyx_t_6, 0, __pyx_float_0_); + __pyx_t_9 = PyList_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_6); + PyList_SET_ITEM(__pyx_t_9, 0, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_DECREF_SET(__pyx_v_lambda_grid, __pyx_t_9); + __pyx_t_9 = 0; - /* "l0learn/interface.pyx":161 + /* "l0learn/interface.pyx":175 * if lambda_grid is None: * lambda_grid = [[0.]] * auto_lambda = True # <<<<<<<<<<<<<< * if not isinstance(num_lambda, int) or num_lambda < 1: * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") */ - __Pyx_TraceLine(161,0,__PYX_ERR(0, 161, __pyx_L1_error)) __pyx_v_auto_lambda = 1; - /* "l0learn/interface.pyx":162 + /* "l0learn/interface.pyx":176 * lambda_grid = [[0.]] * auto_lambda = True * if not isinstance(num_lambda, int) or num_lambda < 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") * if not isinstance(num_gamma, int) or num_gamma < 1: */ - __Pyx_TraceLine(162,0,__PYX_ERR(0, 162, __pyx_L1_error)) - __pyx_t_5 = PyInt_Check(__pyx_v_num_lambda); - __pyx_t_1 = ((!(__pyx_t_5 != 0)) != 0); - if (!__pyx_t_1) { + __pyx_t_4 = PyInt_Check(__pyx_v_num_lambda); + __pyx_t_3 = ((!(__pyx_t_4 != 0)) != 0); + if (!__pyx_t_3) { } else { - __pyx_t_4 = __pyx_t_1; - goto __pyx_L65_bool_binop_done; + __pyx_t_5 = __pyx_t_3; + goto __pyx_L63_bool_binop_done; } - __pyx_t_8 = PyObject_RichCompare(__pyx_v_num_lambda, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 162, __pyx_L1_error) - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 162, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_4 = __pyx_t_1; - __pyx_L65_bool_binop_done:; - if (unlikely(__pyx_t_4)) { + __pyx_t_9 = PyObject_RichCompare(__pyx_v_num_lambda, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 176, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 176, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_5 = __pyx_t_3; + __pyx_L63_bool_binop_done:; + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":163 + /* "l0learn/interface.pyx":177 * auto_lambda = True * if not isinstance(num_lambda, int) or num_lambda < 1: * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") # <<<<<<<<<<<<<< * if not isinstance(num_gamma, int) or num_gamma < 1: * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") */ - __Pyx_TraceLine(163,0,__PYX_ERR(0, 163, __pyx_L1_error)) - __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 163, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_9 = 0; - __pyx_t_10 = 127; + __pyx_t_9 = PyTuple_New(3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_7 = 0; + __pyx_t_8 = 127; __Pyx_INCREF(__pyx_kp_u_expected_num_lambda_to_a_positiv); - __pyx_t_9 += 76; + __pyx_t_7 += 76; __Pyx_GIVEREF(__pyx_kp_u_expected_num_lambda_to_a_positiv); - PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_u_expected_num_lambda_to_a_positiv); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 163, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7); - __pyx_t_7 = 0; - __Pyx_INCREF(__pyx_kp_u__6); - __pyx_t_9 += 1; - __Pyx_GIVEREF(__pyx_kp_u__6); - PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__6); - __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 163, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 163, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 163, __pyx_L1_error) + PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_kp_u_expected_num_lambda_to_a_positiv); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_kp_u_); + __pyx_t_7 += 1; + __Pyx_GIVEREF(__pyx_kp_u_); + PyTuple_SET_ITEM(__pyx_t_9, 2, __pyx_kp_u_); + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_9, 3, __pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_9, 0, 0, 0); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __PYX_ERR(0, 177, __pyx_L1_error) - /* "l0learn/interface.pyx":162 + /* "l0learn/interface.pyx":176 * lambda_grid = [[0.]] * auto_lambda = True * if not isinstance(num_lambda, int) or num_lambda < 1: # <<<<<<<<<<<<<< @@ -5634,66 +4745,64 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":164 + /* "l0learn/interface.pyx":178 * if not isinstance(num_lambda, int) or num_lambda < 1: * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") * if not isinstance(num_gamma, int) or num_gamma < 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") * if penalty == "L0" and num_gamma != 1: */ - __Pyx_TraceLine(164,0,__PYX_ERR(0, 164, __pyx_L1_error)) - __pyx_t_1 = PyInt_Check(__pyx_v_num_gamma); - __pyx_t_5 = ((!(__pyx_t_1 != 0)) != 0); - if (!__pyx_t_5) { + __pyx_t_3 = PyInt_Check(__pyx_v_num_gamma); + __pyx_t_4 = ((!(__pyx_t_3 != 0)) != 0); + if (!__pyx_t_4) { } else { - __pyx_t_4 = __pyx_t_5; - goto __pyx_L68_bool_binop_done; + __pyx_t_5 = __pyx_t_4; + goto __pyx_L66_bool_binop_done; } - __pyx_t_8 = PyObject_RichCompare(__pyx_v_num_gamma, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 164, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 164, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_4 = __pyx_t_5; - __pyx_L68_bool_binop_done:; - if (unlikely(__pyx_t_4)) { + __pyx_t_9 = PyObject_RichCompare(__pyx_v_num_gamma, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 178, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 178, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_5 = __pyx_t_4; + __pyx_L66_bool_binop_done:; + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":165 + /* "l0learn/interface.pyx":179 * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") * if not isinstance(num_gamma, int) or num_gamma < 1: * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") # <<<<<<<<<<<<<< * if penalty == "L0" and num_gamma != 1: * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") */ - __Pyx_TraceLine(165,0,__PYX_ERR(0, 165, __pyx_L1_error)) - __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 165, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_9 = 0; - __pyx_t_10 = 127; + __pyx_t_9 = PyTuple_New(3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_7 = 0; + __pyx_t_8 = 127; __Pyx_INCREF(__pyx_kp_u_expected_num_gamma_to_a_positive); - __pyx_t_9 += 75; + __pyx_t_7 += 75; __Pyx_GIVEREF(__pyx_kp_u_expected_num_gamma_to_a_positive); - PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_u_expected_num_gamma_to_a_positive); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 165, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7); - __pyx_t_7 = 0; - __Pyx_INCREF(__pyx_kp_u__6); - __pyx_t_9 += 1; - __Pyx_GIVEREF(__pyx_kp_u__6); - PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__6); - __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 165, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 165, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 165, __pyx_L1_error) - - /* "l0learn/interface.pyx":164 + PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_kp_u_expected_num_gamma_to_a_positive); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_kp_u_); + __pyx_t_7 += 1; + __Pyx_GIVEREF(__pyx_kp_u_); + PyTuple_SET_ITEM(__pyx_t_9, 2, __pyx_kp_u_); + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_9, 3, __pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_9, 0, 0, 0); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __PYX_ERR(0, 179, __pyx_L1_error) + + /* "l0learn/interface.pyx":178 * if not isinstance(num_lambda, int) or num_lambda < 1: * raise ValueError(f"expected num_lambda to a positive integer when lambda_grid is None, but got {num_lambda}.") * if not isinstance(num_gamma, int) or num_gamma < 1: # <<<<<<<<<<<<<< @@ -5702,67 +4811,65 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":166 + /* "l0learn/interface.pyx":180 * if not isinstance(num_gamma, int) or num_gamma < 1: * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") * else: # lambda_grid should be a List[List[float]] */ - __Pyx_TraceLine(166,0,__PYX_ERR(0, 166, __pyx_L1_error)) - __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 166, __pyx_L1_error) - __pyx_t_1 = (__pyx_t_5 != 0); - if (__pyx_t_1) { + __pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 180, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_4 != 0); + if (__pyx_t_3) { } else { - __pyx_t_4 = __pyx_t_1; - goto __pyx_L71_bool_binop_done; + __pyx_t_5 = __pyx_t_3; + goto __pyx_L69_bool_binop_done; } - __pyx_t_8 = __Pyx_PyInt_NeObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 166, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 166, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_4 = __pyx_t_1; - __pyx_L71_bool_binop_done:; - if (unlikely(__pyx_t_4)) { + __pyx_t_9 = __Pyx_PyInt_NeObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 180, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 180, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_5 = __pyx_t_3; + __pyx_L69_bool_binop_done:; + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":167 + /* "l0learn/interface.pyx":181 * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") * if penalty == "L0" and num_gamma != 1: * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") # <<<<<<<<<<<<<< * else: # lambda_grid should be a List[List[float]] * if num_gamma is not None: */ - __Pyx_TraceLine(167,0,__PYX_ERR(0, 167, __pyx_L1_error)) - __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 167, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_9 = 0; - __pyx_t_10 = 127; + __pyx_t_9 = PyTuple_New(3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_7 = 0; + __pyx_t_8 = 127; __Pyx_INCREF(__pyx_kp_u_expected_num_gamma_to_1_when_pen); - __pyx_t_9 += 53; + __pyx_t_7 += 53; __Pyx_GIVEREF(__pyx_kp_u_expected_num_gamma_to_1_when_pen); - PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_kp_u_expected_num_gamma_to_1_when_pen); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 167, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7); - __pyx_t_7 = 0; - __Pyx_INCREF(__pyx_kp_u__6); - __pyx_t_9 += 1; - __Pyx_GIVEREF(__pyx_kp_u__6); - PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_kp_u__6); - __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_8, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 167, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 167, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 167, __pyx_L1_error) - - /* "l0learn/interface.pyx":166 + PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_kp_u_expected_num_gamma_to_1_when_pen); + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_kp_u_); + __pyx_t_7 += 1; + __Pyx_GIVEREF(__pyx_kp_u_); + PyTuple_SET_ITEM(__pyx_t_9, 2, __pyx_kp_u_); + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_9, 3, __pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_9, 0, 0, 0); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __PYX_ERR(0, 181, __pyx_L1_error) + + /* "l0learn/interface.pyx":180 * if not isinstance(num_gamma, int) or num_gamma < 1: * raise ValueError(f"expected num_gamma to a positive integer when lambda_grid is None, but got {num_gamma}.") * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< @@ -5771,59 +4878,56 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":159 + /* "l0learn/interface.pyx":173 * raise ValueError(f"expected y vector to have type {np.float64}, but got {y.dtype}") * * if lambda_grid is None: # <<<<<<<<<<<<<< * lambda_grid = [[0.]] * auto_lambda = True */ - goto __pyx_L63; + goto __pyx_L61; } - /* "l0learn/interface.pyx":169 + /* "l0learn/interface.pyx":183 * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") * else: # lambda_grid should be a List[List[float]] * if num_gamma is not None: # <<<<<<<<<<<<<< * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " * f"but got {num_gamma}") */ - __Pyx_TraceLine(169,0,__PYX_ERR(0, 169, __pyx_L1_error)) /*else*/ { - __pyx_t_4 = (__pyx_v_num_gamma != Py_None); - __pyx_t_1 = (__pyx_t_4 != 0); - if (unlikely(__pyx_t_1)) { + __pyx_t_5 = (__pyx_v_num_gamma != Py_None); + __pyx_t_3 = (__pyx_t_5 != 0); + if (unlikely(__pyx_t_3)) { - /* "l0learn/interface.pyx":171 + /* "l0learn/interface.pyx":185 * if num_gamma is not None: * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " * f"but got {num_gamma}") # <<<<<<<<<<<<<< * num_gamma = len(lambda_grid) * */ - __Pyx_TraceLine(171,0,__PYX_ERR(0, 171, __pyx_L1_error)) - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 171, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyObject_FormatSimple(__pyx_v_num_gamma, __pyx_empty_unicode); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 185, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); - /* "l0learn/interface.pyx":170 + /* "l0learn/interface.pyx":184 * else: # lambda_grid should be a List[List[float]] * if num_gamma is not None: * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " # <<<<<<<<<<<<<< * f"but got {num_gamma}") * num_gamma = len(lambda_grid) */ - __Pyx_TraceLine(170,0,__PYX_ERR(0, 170, __pyx_L1_error)) - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_gamma_to_be_None_if, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 170, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 170, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 170, __pyx_L1_error) - - /* "l0learn/interface.pyx":169 + __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_gamma_to_be_None_if, __pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_9, 0, 0, 0); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __PYX_ERR(0, 184, __pyx_L1_error) + + /* "l0learn/interface.pyx":183 * raise ValueError(f"expected num_gamma to 1 when penalty = 'L0', but got {num_gamma}.") * else: # lambda_grid should be a List[List[float]] * if num_gamma is not None: # <<<<<<<<<<<<<< @@ -5832,62 +4936,58 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":172 + /* "l0learn/interface.pyx":186 * raise ValueError(f"expected num_gamma to be None if lambda_grid is specified by the user, " * f"but got {num_gamma}") * num_gamma = len(lambda_grid) # <<<<<<<<<<<<<< * * if num_lambda is not None: */ - __Pyx_TraceLine(172,0,__PYX_ERR(0, 172, __pyx_L1_error)) - __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 172, __pyx_L1_error) - __pyx_t_8 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 172, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF_SET(__pyx_v_num_gamma, __pyx_t_8); - __pyx_t_8 = 0; + __pyx_t_7 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(0, 186, __pyx_L1_error) + __pyx_t_9 = PyInt_FromSsize_t(__pyx_t_7); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF_SET(__pyx_v_num_gamma, __pyx_t_9); + __pyx_t_9 = 0; - /* "l0learn/interface.pyx":174 + /* "l0learn/interface.pyx":188 * num_gamma = len(lambda_grid) * * if num_lambda is not None: # <<<<<<<<<<<<<< * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " * f"but got {num_lambda}") */ - __Pyx_TraceLine(174,0,__PYX_ERR(0, 174, __pyx_L1_error)) - __pyx_t_1 = (__pyx_v_num_lambda != Py_None); - __pyx_t_4 = (__pyx_t_1 != 0); - if (unlikely(__pyx_t_4)) { + __pyx_t_3 = (__pyx_v_num_lambda != Py_None); + __pyx_t_5 = (__pyx_t_3 != 0); + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":176 + /* "l0learn/interface.pyx":190 * if num_lambda is not None: * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " * f"but got {num_lambda}") # <<<<<<<<<<<<<< * num_lambda = 0 # This value is ignored. * auto_lambda = False */ - __Pyx_TraceLine(176,0,__PYX_ERR(0, 176, __pyx_L1_error)) - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 176, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyObject_FormatSimple(__pyx_v_num_lambda, __pyx_empty_unicode); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); - /* "l0learn/interface.pyx":175 + /* "l0learn/interface.pyx":189 * * if num_lambda is not None: * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " # <<<<<<<<<<<<<< * f"but got {num_lambda}") * num_lambda = 0 # This value is ignored. */ - __Pyx_TraceLine(175,0,__PYX_ERR(0, 175, __pyx_L1_error)) - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_lambda_to_be_None_i, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 175, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 175, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 175, __pyx_L1_error) - - /* "l0learn/interface.pyx":174 + __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_num_lambda_to_be_None_i, __pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_9, 0, 0, 0); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __PYX_ERR(0, 189, __pyx_L1_error) + + /* "l0learn/interface.pyx":188 * num_gamma = len(lambda_grid) * * if num_lambda is not None: # <<<<<<<<<<<<<< @@ -5896,82 +4996,77 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":177 + /* "l0learn/interface.pyx":191 * raise ValueError(f"expected num_lambda to be None if lambda_grid is specified by the user, " * f"but got {num_lambda}") * num_lambda = 0 # This value is ignored. # <<<<<<<<<<<<<< * auto_lambda = False * bad_lambda_grid = False */ - __Pyx_TraceLine(177,0,__PYX_ERR(0, 177, __pyx_L1_error)) __Pyx_INCREF(__pyx_int_0); __Pyx_DECREF_SET(__pyx_v_num_lambda, __pyx_int_0); - /* "l0learn/interface.pyx":178 + /* "l0learn/interface.pyx":192 * f"but got {num_lambda}") * num_lambda = 0 # This value is ignored. * auto_lambda = False # <<<<<<<<<<<<<< * bad_lambda_grid = False * */ - __Pyx_TraceLine(178,0,__PYX_ERR(0, 178, __pyx_L1_error)) __pyx_v_auto_lambda = 0; - /* "l0learn/interface.pyx":179 + /* "l0learn/interface.pyx":193 * num_lambda = 0 # This value is ignored. * auto_lambda = False * bad_lambda_grid = False # <<<<<<<<<<<<<< * * if penalty == "L0" and num_gamma != 1: */ - __Pyx_TraceLine(179,0,__PYX_ERR(0, 179, __pyx_L1_error)) __pyx_v_bad_lambda_grid = 0; - /* "l0learn/interface.pyx":181 + /* "l0learn/interface.pyx":195 * bad_lambda_grid = False * * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") * */ - __Pyx_TraceLine(181,0,__PYX_ERR(0, 181, __pyx_L1_error)) - __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 181, __pyx_L1_error) - __pyx_t_5 = (__pyx_t_1 != 0); - if (__pyx_t_5) { + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_v_penalty, __pyx_n_u_L0, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 195, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 != 0); + if (__pyx_t_4) { } else { - __pyx_t_4 = __pyx_t_5; - goto __pyx_L76_bool_binop_done; + __pyx_t_5 = __pyx_t_4; + goto __pyx_L74_bool_binop_done; } - __pyx_t_8 = __Pyx_PyInt_NeObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 181, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 181, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_4 = __pyx_t_5; - __pyx_L76_bool_binop_done:; - if (unlikely(__pyx_t_4)) { + __pyx_t_9 = __Pyx_PyInt_NeObjC(__pyx_v_num_gamma, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 195, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 195, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_5 = __pyx_t_4; + __pyx_L74_bool_binop_done:; + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":182 + /* "l0learn/interface.pyx":196 * * if penalty == "L0" and num_gamma != 1: * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") # <<<<<<<<<<<<<< * * for i, sub_lambda_grid in enumerate(lambda_grid): */ - __Pyx_TraceLine(182,0,__PYX_ERR(0, 182, __pyx_L1_error)) - __pyx_t_9 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 182, __pyx_L1_error) - __pyx_t_8 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_9, 0, ' ', 'd'); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 182, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_of_lengt, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 182, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 182, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 182, __pyx_L1_error) - - /* "l0learn/interface.pyx":181 + __pyx_t_7 = PyObject_Length(__pyx_v_lambda_grid); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(0, 196, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_t_7, 0, ' ', 'd'); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_6 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_of_lengt, __pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_9, 0, 0, 0); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __PYX_ERR(0, 196, __pyx_L1_error) + + /* "l0learn/interface.pyx":195 * bad_lambda_grid = False * * if penalty == "L0" and num_gamma != 1: # <<<<<<<<<<<<<< @@ -5980,50 +5075,49 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":184 + /* "l0learn/interface.pyx":198 * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") * * for i, sub_lambda_grid in enumerate(lambda_grid): # <<<<<<<<<<<<<< * current = float("inf") * if sub_lambda_grid[0] <= 0: */ - __Pyx_TraceLine(184,0,__PYX_ERR(0, 184, __pyx_L1_error)) __Pyx_INCREF(__pyx_int_0); - __pyx_t_8 = __pyx_int_0; + __pyx_t_9 = __pyx_int_0; if (likely(PyList_CheckExact(__pyx_v_lambda_grid)) || PyTuple_CheckExact(__pyx_v_lambda_grid)) { - __pyx_t_7 = __pyx_v_lambda_grid; __Pyx_INCREF(__pyx_t_7); __pyx_t_9 = 0; - __pyx_t_13 = NULL; + __pyx_t_6 = __pyx_v_lambda_grid; __Pyx_INCREF(__pyx_t_6); __pyx_t_7 = 0; + __pyx_t_12 = NULL; } else { - __pyx_t_9 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_v_lambda_grid); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 184, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_13 = Py_TYPE(__pyx_t_7)->tp_iternext; if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 184, __pyx_L1_error) + __pyx_t_7 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_v_lambda_grid); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_12 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 198, __pyx_L1_error) } for (;;) { - if (likely(!__pyx_t_13)) { - if (likely(PyList_CheckExact(__pyx_t_7))) { - if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_7)) break; + if (likely(!__pyx_t_12)) { + if (likely(PyList_CheckExact(__pyx_t_6))) { + if (__pyx_t_7 >= PyList_GET_SIZE(__pyx_t_6)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_2 = PyList_GET_ITEM(__pyx_t_7, __pyx_t_9); __Pyx_INCREF(__pyx_t_2); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 184, __pyx_L1_error) + __pyx_t_2 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_7); __Pyx_INCREF(__pyx_t_2); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(0, 198, __pyx_L1_error) #else - __pyx_t_2 = PySequence_ITEM(__pyx_t_7, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 184, __pyx_L1_error) + __pyx_t_2 = PySequence_ITEM(__pyx_t_6, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 198, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #endif } else { - if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_7)) break; + if (__pyx_t_7 >= PyTuple_GET_SIZE(__pyx_t_6)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_9); __Pyx_INCREF(__pyx_t_2); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 184, __pyx_L1_error) + __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_7); __Pyx_INCREF(__pyx_t_2); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(0, 198, __pyx_L1_error) #else - __pyx_t_2 = PySequence_ITEM(__pyx_t_7, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 184, __pyx_L1_error) + __pyx_t_2 = PySequence_ITEM(__pyx_t_6, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 198, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); #endif } } else { - __pyx_t_2 = __pyx_t_13(__pyx_t_7); + __pyx_t_2 = __pyx_t_12(__pyx_t_6); if (unlikely(!__pyx_t_2)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(0, 184, __pyx_L1_error) + else __PYX_ERR(0, 198, __pyx_L1_error) } break; } @@ -6031,97 +5125,92 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject } __Pyx_XDECREF_SET(__pyx_v_sub_lambda_grid, __pyx_t_2); __pyx_t_2 = 0; - __Pyx_INCREF(__pyx_t_8); - __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_8); - __pyx_t_2 = __Pyx_PyInt_AddObjC(__pyx_t_8, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 184, __pyx_L1_error) + __Pyx_INCREF(__pyx_t_9); + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_9); + __pyx_t_2 = __Pyx_PyInt_AddObjC(__pyx_t_9, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 198, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_8); - __pyx_t_8 = __pyx_t_2; + __Pyx_DECREF(__pyx_t_9); + __pyx_t_9 = __pyx_t_2; __pyx_t_2 = 0; - /* "l0learn/interface.pyx":185 + /* "l0learn/interface.pyx":199 * * for i, sub_lambda_grid in enumerate(lambda_grid): * current = float("inf") # <<<<<<<<<<<<<< * if sub_lambda_grid[0] <= 0: * raise ValueError(f"Expected all values of lambda_grid to be positive, " */ - __Pyx_TraceLine(185,0,__PYX_ERR(0, 185, __pyx_L1_error)) - __pyx_t_14 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 185, __pyx_L1_error) - __pyx_v_current = __pyx_t_14; + __pyx_t_13 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_13 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 199, __pyx_L1_error) + __pyx_v_current = __pyx_t_13; - /* "l0learn/interface.pyx":186 + /* "l0learn/interface.pyx":200 * for i, sub_lambda_grid in enumerate(lambda_grid): * current = float("inf") * if sub_lambda_grid[0] <= 0: # <<<<<<<<<<<<<< * raise ValueError(f"Expected all values of lambda_grid to be positive, " * f"but got lambda_grid[{i}] containing a negative value") */ - __Pyx_TraceLine(186,0,__PYX_ERR(0, 186, __pyx_L1_error)) - __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_sub_lambda_grid, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 186, __pyx_L1_error) + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_sub_lambda_grid, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 200, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyObject_RichCompare(__pyx_t_2, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 186, __pyx_L1_error) + __pyx_t_1 = PyObject_RichCompare(__pyx_t_2, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 200, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 186, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(__pyx_t_4)) { + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 200, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":187 + /* "l0learn/interface.pyx":201 * current = float("inf") * if sub_lambda_grid[0] <= 0: * raise ValueError(f"Expected all values of lambda_grid to be positive, " # <<<<<<<<<<<<<< * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): */ - __Pyx_TraceLine(187,0,__PYX_ERR(0, 187, __pyx_L1_error)) - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 187, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_15 = 0; - __pyx_t_10 = 127; + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_14 = 0; + __pyx_t_8 = 127; __Pyx_INCREF(__pyx_kp_u_Expected_all_values_of_lambda_gr); - __pyx_t_15 += 71; + __pyx_t_14 += 71; __Pyx_GIVEREF(__pyx_kp_u_Expected_all_values_of_lambda_gr); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_Expected_all_values_of_lambda_gr); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_Expected_all_values_of_lambda_gr); - /* "l0learn/interface.pyx":188 + /* "l0learn/interface.pyx":202 * if sub_lambda_grid[0] <= 0: * raise ValueError(f"Expected all values of lambda_grid to be positive, " * f"but got lambda_grid[{i}] containing a negative value") # <<<<<<<<<<<<<< * if any(np.diff(sub_lambda_grid) >= 0): * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " */ - __Pyx_TraceLine(188,0,__PYX_ERR(0, 188, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 188, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 202, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_10; - __pyx_t_15 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) : __pyx_t_8; + __pyx_t_14 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_2); __pyx_t_2 = 0; __Pyx_INCREF(__pyx_kp_u_containing_a_negative_value); - __pyx_t_15 += 29; + __pyx_t_14 += 29; __Pyx_GIVEREF(__pyx_kp_u_containing_a_negative_value); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_containing_a_negative_value); + PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_containing_a_negative_value); - /* "l0learn/interface.pyx":187 + /* "l0learn/interface.pyx":201 * current = float("inf") * if sub_lambda_grid[0] <= 0: * raise ValueError(f"Expected all values of lambda_grid to be positive, " # <<<<<<<<<<<<<< * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): */ - __Pyx_TraceLine(187,0,__PYX_ERR(0, 187, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 187, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyUnicode_Join(__pyx_t_1, 3, __pyx_t_14, __pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 201, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 187, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 187, __pyx_L1_error) + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 201, __pyx_L1_error) - /* "l0learn/interface.pyx":186 + /* "l0learn/interface.pyx":200 * for i, sub_lambda_grid in enumerate(lambda_grid): * current = float("inf") * if sub_lambda_grid[0] <= 0: # <<<<<<<<<<<<<< @@ -6130,99 +5219,95 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":189 + /* "l0learn/interface.pyx":203 * raise ValueError(f"Expected all values of lambda_grid to be positive, " * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): # <<<<<<<<<<<<<< * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " * f"but got lambda_grid[{i}] containing an increasing value.") */ - __Pyx_TraceLine(189,0,__PYX_ERR(0, 189, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 189, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_diff); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 189, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_16); + __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_diff); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 203, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_16))) { - __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_16); + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_15))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_15); if (likely(__pyx_t_2)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_16); + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_15); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_16, function); + __Pyx_DECREF_SET(__pyx_t_15, function); } } - __pyx_t_3 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_16, __pyx_t_2, __pyx_v_sub_lambda_grid) : __Pyx_PyObject_CallOneArg(__pyx_t_16, __pyx_v_sub_lambda_grid); + __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_15, __pyx_t_2, __pyx_v_sub_lambda_grid) : __Pyx_PyObject_CallOneArg(__pyx_t_15, __pyx_v_sub_lambda_grid); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 189, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_16 = PyObject_RichCompare(__pyx_t_3, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_16); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 189, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_16); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 189, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 189, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(__pyx_t_4)) { + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 203, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_15 = PyObject_RichCompare(__pyx_t_1, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_15); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 203, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_15); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 203, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 203, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(__pyx_t_5)) { - /* "l0learn/interface.pyx":190 + /* "l0learn/interface.pyx":204 * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " # <<<<<<<<<<<<<< * f"but got lambda_grid[{i}] containing an increasing value.") * */ - __Pyx_TraceLine(190,0,__PYX_ERR(0, 190, __pyx_L1_error)) - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 190, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_15 = 0; - __pyx_t_10 = 127; + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 204, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_14 = 0; + __pyx_t_8 = 127; __Pyx_INCREF(__pyx_kp_u_Expected_each_element_of_lambda); - __pyx_t_15 += 91; + __pyx_t_14 += 91; __Pyx_GIVEREF(__pyx_kp_u_Expected_each_element_of_lambda); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_Expected_each_element_of_lambda); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_Expected_each_element_of_lambda); - /* "l0learn/interface.pyx":191 + /* "l0learn/interface.pyx":205 * if any(np.diff(sub_lambda_grid) >= 0): * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " * f"but got lambda_grid[{i}] containing an increasing value.") # <<<<<<<<<<<<<< * * n, p = X.shape */ - __Pyx_TraceLine(191,0,__PYX_ERR(0, 191, __pyx_L1_error)) - __pyx_t_16 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 191, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_16); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_16) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_16) : __pyx_t_10; - __pyx_t_15 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_16); - __Pyx_GIVEREF(__pyx_t_16); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_16); - __pyx_t_16 = 0; + __pyx_t_15 = __Pyx_PyObject_FormatSimple(__pyx_v_i, __pyx_empty_unicode); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 205, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_15) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_15) : __pyx_t_8; + __pyx_t_14 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_15); + __Pyx_GIVEREF(__pyx_t_15); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_15); + __pyx_t_15 = 0; __Pyx_INCREF(__pyx_kp_u_containing_an_increasing_value); - __pyx_t_15 += 33; + __pyx_t_14 += 33; __Pyx_GIVEREF(__pyx_kp_u_containing_an_increasing_value); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_containing_an_increasing_value); + PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_containing_an_increasing_value); - /* "l0learn/interface.pyx":190 + /* "l0learn/interface.pyx":204 * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): * raise ValueError(f"Expected each element of lambda_grid to be a list of decreasing value, " # <<<<<<<<<<<<<< * f"but got lambda_grid[{i}] containing an increasing value.") * */ - __Pyx_TraceLine(190,0,__PYX_ERR(0, 190, __pyx_L1_error)) - __pyx_t_16 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, __pyx_t_15, __pyx_t_10); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 190, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_16); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 190, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 190, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyUnicode_Join(__pyx_t_1, 3, __pyx_t_14, __pyx_t_8); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 204, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_15); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 204, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 204, __pyx_L1_error) - /* "l0learn/interface.pyx":189 + /* "l0learn/interface.pyx":203 * raise ValueError(f"Expected all values of lambda_grid to be positive, " * f"but got lambda_grid[{i}] containing a negative value") * if any(np.diff(sub_lambda_grid) >= 0): # <<<<<<<<<<<<<< @@ -6231,137 +5316,131 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":184 + /* "l0learn/interface.pyx":198 * raise ValueError(f"expected lambda_grid to of length 1 when penalty = 'L0', but got {len(lambda_grid)}") * * for i, sub_lambda_grid in enumerate(lambda_grid): # <<<<<<<<<<<<<< * current = float("inf") * if sub_lambda_grid[0] <= 0: */ - __Pyx_TraceLine(184,0,__PYX_ERR(0, 184, __pyx_L1_error)) } - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } - __pyx_L63:; + __pyx_L61:; - /* "l0learn/interface.pyx":193 + /* "l0learn/interface.pyx":207 * f"but got lambda_grid[{i}] containing an increasing value.") * * n, p = X.shape # <<<<<<<<<<<<<< * with_bounds = False * */ - __Pyx_TraceLine(193,0,__PYX_ERR(0, 193, __pyx_L1_error)) - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 193, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - if ((likely(PyTuple_CheckExact(__pyx_t_8))) || (PyList_CheckExact(__pyx_t_8))) { - PyObject* sequence = __pyx_t_8; + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if ((likely(PyTuple_CheckExact(__pyx_t_9))) || (PyList_CheckExact(__pyx_t_9))) { + PyObject* sequence = __pyx_t_9; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 193, __pyx_L1_error) + __PYX_ERR(0, 207, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_7 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); + __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_1 = PyTuple_GET_ITEM(sequence, 1); } else { - __pyx_t_7 = PyList_GET_ITEM(sequence, 0); - __pyx_t_3 = PyList_GET_ITEM(sequence, 1); + __pyx_t_6 = PyList_GET_ITEM(sequence, 0); + __pyx_t_1 = PyList_GET_ITEM(sequence, 1); } - __Pyx_INCREF(__pyx_t_7); - __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx_t_1); #else - __pyx_t_7 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 193, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 193, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); #endif - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } else { Py_ssize_t index = -1; - __pyx_t_16 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 193, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_16); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_11 = Py_TYPE(__pyx_t_16)->tp_iternext; - index = 0; __pyx_t_7 = __pyx_t_11(__pyx_t_16); if (unlikely(!__pyx_t_7)) goto __pyx_L82_unpacking_failed; - __Pyx_GOTREF(__pyx_t_7); - index = 1; __pyx_t_3 = __pyx_t_11(__pyx_t_16); if (unlikely(!__pyx_t_3)) goto __pyx_L82_unpacking_failed; - __Pyx_GOTREF(__pyx_t_3); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_16), 2) < 0) __PYX_ERR(0, 193, __pyx_L1_error) - __pyx_t_11 = NULL; - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - goto __pyx_L83_unpacking_done; - __pyx_L82_unpacking_failed:; - __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - __pyx_t_11 = NULL; + __pyx_t_15 = PyObject_GetIter(__pyx_t_9); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_10 = Py_TYPE(__pyx_t_15)->tp_iternext; + index = 0; __pyx_t_6 = __pyx_t_10(__pyx_t_15); if (unlikely(!__pyx_t_6)) goto __pyx_L80_unpacking_failed; + __Pyx_GOTREF(__pyx_t_6); + index = 1; __pyx_t_1 = __pyx_t_10(__pyx_t_15); if (unlikely(!__pyx_t_1)) goto __pyx_L80_unpacking_failed; + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_15), 2) < 0) __PYX_ERR(0, 207, __pyx_L1_error) + __pyx_t_10 = NULL; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + goto __pyx_L81_unpacking_done; + __pyx_L80_unpacking_failed:; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_t_10 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 193, __pyx_L1_error) - __pyx_L83_unpacking_done:; + __PYX_ERR(0, 207, __pyx_L1_error) + __pyx_L81_unpacking_done:; } - __Pyx_DECREF_SET(__pyx_v_n, __pyx_t_7); - __pyx_t_7 = 0; - __Pyx_DECREF_SET(__pyx_v_p, __pyx_t_3); - __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_n, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_DECREF_SET(__pyx_v_p, __pyx_t_1); + __pyx_t_1 = 0; - /* "l0learn/interface.pyx":194 + /* "l0learn/interface.pyx":208 * * n, p = X.shape * with_bounds = False # <<<<<<<<<<<<<< * * if isinstance(lows, float): */ - __Pyx_TraceLine(194,0,__PYX_ERR(0, 194, __pyx_L1_error)) __pyx_v_with_bounds = 0; - /* "l0learn/interface.pyx":196 + /* "l0learn/interface.pyx":210 * with_bounds = False * * if isinstance(lows, float): # <<<<<<<<<<<<<< * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") */ - __Pyx_TraceLine(196,0,__PYX_ERR(0, 196, __pyx_L1_error)) - __pyx_t_4 = PyFloat_Check(__pyx_v_lows); - __pyx_t_5 = (__pyx_t_4 != 0); - if (__pyx_t_5) { + __pyx_t_5 = PyFloat_Check(__pyx_v_lows); + __pyx_t_4 = (__pyx_t_5 != 0); + if (__pyx_t_4) { - /* "l0learn/interface.pyx":197 + /* "l0learn/interface.pyx":211 * * if isinstance(lows, float): * if lows > 0: # <<<<<<<<<<<<<< * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") * elif lows > -float('inf'): */ - __Pyx_TraceLine(197,0,__PYX_ERR(0, 197, __pyx_L1_error)) - __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_GT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 197, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 197, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(__pyx_t_5)) { + __pyx_t_9 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_GT); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 211, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 211, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(__pyx_t_4)) { - /* "l0learn/interface.pyx":198 + /* "l0learn/interface.pyx":212 * if isinstance(lows, float): * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") # <<<<<<<<<<<<<< * elif lows > -float('inf'): * with_bounds = True */ - __Pyx_TraceLine(198,0,__PYX_ERR(0, 198, __pyx_L1_error)) - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 198, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lows_to_be_a_non_positi, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 198, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 198, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(0, 198, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lows_to_be_a_non_positi, __pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_9, 0, 0, 0); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __PYX_ERR(0, 212, __pyx_L1_error) - /* "l0learn/interface.pyx":197 + /* "l0learn/interface.pyx":211 * * if isinstance(lows, float): * if lows > 0: # <<<<<<<<<<<<<< @@ -6370,34 +5449,32 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":199 + /* "l0learn/interface.pyx":213 * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") * elif lows > -float('inf'): # <<<<<<<<<<<<<< * with_bounds = True * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): */ - __Pyx_TraceLine(199,0,__PYX_ERR(0, 199, __pyx_L1_error)) - __pyx_t_14 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_14 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 199, __pyx_L1_error) - __pyx_t_8 = PyFloat_FromDouble((-__pyx_t_14)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 199, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_3 = PyObject_RichCompare(__pyx_v_lows, __pyx_t_8, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 199, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 199, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_5) { + __pyx_t_13 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_13 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 213, __pyx_L1_error) + __pyx_t_9 = PyFloat_FromDouble((-__pyx_t_13)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 213, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = PyObject_RichCompare(__pyx_v_lows, __pyx_t_9, Py_GT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 213, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 213, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_4) { - /* "l0learn/interface.pyx":200 + /* "l0learn/interface.pyx":214 * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") * elif lows > -float('inf'): * with_bounds = True # <<<<<<<<<<<<<< * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): * with_bounds = True */ - __Pyx_TraceLine(200,0,__PYX_ERR(0, 200, __pyx_L1_error)) __pyx_v_with_bounds = 1; - /* "l0learn/interface.pyx":199 + /* "l0learn/interface.pyx":213 * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") * elif lows > -float('inf'): # <<<<<<<<<<<<<< @@ -6406,202 +5483,194 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":196 + /* "l0learn/interface.pyx":210 * with_bounds = False * * if isinstance(lows, float): # <<<<<<<<<<<<<< * if lows > 0: * raise ValueError(f"expected lows to be a non-positive float, but got {lows}") */ - goto __pyx_L84; + goto __pyx_L82; } - /* "l0learn/interface.pyx":201 + /* "l0learn/interface.pyx":215 * elif lows > -float('inf'): * with_bounds = True * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): # <<<<<<<<<<<<<< * with_bounds = True * else: */ - __Pyx_TraceLine(201,0,__PYX_ERR(0, 201, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 201, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 201, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_4 = PyObject_IsInstance(__pyx_v_lows, __pyx_t_8); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 201, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_1 = (__pyx_t_4 != 0); - if (__pyx_t_1) { + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 215, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 215, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_5 = PyObject_IsInstance(__pyx_v_lows, __pyx_t_9); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 215, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_3 = (__pyx_t_5 != 0); + if (__pyx_t_3) { } else { - __pyx_t_5 = __pyx_t_1; - goto __pyx_L86_bool_binop_done; + __pyx_t_4 = __pyx_t_3; + goto __pyx_L84_bool_binop_done; } - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_lows, __pyx_n_s_ndim); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 201, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_3 = __Pyx_PyInt_EqObjC(__pyx_t_8, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 201, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 201, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_1) { + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_lows, __pyx_n_s_ndim); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 215, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __Pyx_PyInt_EqObjC(__pyx_t_9, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 215, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 215, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_3) { } else { - __pyx_t_5 = __pyx_t_1; - goto __pyx_L86_bool_binop_done; + __pyx_t_4 = __pyx_t_3; + goto __pyx_L84_bool_binop_done; } - __pyx_t_9 = PyObject_Length(__pyx_v_lows); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 201, __pyx_L1_error) - __pyx_t_3 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 201, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_8 = PyObject_RichCompare(__pyx_t_3, __pyx_v_p, Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 201, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 201, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (__pyx_t_1) { + __pyx_t_7 = PyObject_Length(__pyx_v_lows); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(0, 215, __pyx_L1_error) + __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 215, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = PyObject_RichCompare(__pyx_t_1, __pyx_v_p, Py_EQ); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 215, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 215, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (__pyx_t_3) { } else { - __pyx_t_5 = __pyx_t_1; - goto __pyx_L86_bool_binop_done; + __pyx_t_4 = __pyx_t_3; + goto __pyx_L84_bool_binop_done; } - __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 201, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_all, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 201, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 201, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_5 = __pyx_t_1; - __pyx_L86_bool_binop_done:; - if (likely(__pyx_t_5)) { + __pyx_t_9 = PyObject_RichCompare(__pyx_v_lows, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 215, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_all, __pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 215, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 215, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_4 = __pyx_t_3; + __pyx_L84_bool_binop_done:; + if (likely(__pyx_t_4)) { - /* "l0learn/interface.pyx":202 + /* "l0learn/interface.pyx":216 * with_bounds = True * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): * with_bounds = True # <<<<<<<<<<<<<< * else: * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " */ - __Pyx_TraceLine(202,0,__PYX_ERR(0, 202, __pyx_L1_error)) __pyx_v_with_bounds = 1; - /* "l0learn/interface.pyx":201 + /* "l0learn/interface.pyx":215 * elif lows > -float('inf'): * with_bounds = True * elif isinstance(lows, np.ndarray) and lows.ndim == 1 and len(lows) == p and all(lows <= 0): # <<<<<<<<<<<<<< * with_bounds = True * else: */ - goto __pyx_L84; + goto __pyx_L82; } - /* "l0learn/interface.pyx":204 + /* "l0learn/interface.pyx":218 * with_bounds = True * else: * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " # <<<<<<<<<<<<<< * f"floats, but got {lows}") * */ - __Pyx_TraceLine(204,0,__PYX_ERR(0, 204, __pyx_L1_error)) /*else*/ { - __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 204, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_9 = 0; - __pyx_t_10 = 127; + __pyx_t_1 = PyTuple_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = 0; + __pyx_t_8 = 127; __Pyx_INCREF(__pyx_kp_u_expected_lows_to_be_a_non_positi_2); - __pyx_t_9 += 72; + __pyx_t_7 += 72; __Pyx_GIVEREF(__pyx_kp_u_expected_lows_to_be_a_non_positi_2); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_lows_to_be_a_non_positi_2); - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 204, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); - __Pyx_GIVEREF(__pyx_t_8); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_8); - __pyx_t_8 = 0; + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_expected_lows_to_be_a_non_positi_2); + __pyx_t_9 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_9); + __pyx_t_9 = 0; __Pyx_INCREF(__pyx_kp_u_of_non_positives_floats_but_got); - __pyx_t_9 += 34; + __pyx_t_7 += 34; __Pyx_GIVEREF(__pyx_kp_u_of_non_positives_floats_but_got); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_of_non_positives_floats_but_got); + PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_of_non_positives_floats_but_got); - /* "l0learn/interface.pyx":205 + /* "l0learn/interface.pyx":219 * else: * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " * f"floats, but got {lows}") # <<<<<<<<<<<<<< * * if isinstance(highs, float): */ - __Pyx_TraceLine(205,0,__PYX_ERR(0, 205, __pyx_L1_error)) - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 205, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); - __Pyx_GIVEREF(__pyx_t_8); - PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_8); - __pyx_t_8 = 0; + __pyx_t_9 = __Pyx_PyObject_FormatSimple(__pyx_v_lows, __pyx_empty_unicode); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 219, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_t_9); + __pyx_t_9 = 0; - /* "l0learn/interface.pyx":204 + /* "l0learn/interface.pyx":218 * with_bounds = True * else: * raise ValueError(f"expected lows to be a non-positive float, or a 1D numpy array of length {p} of non-positives " # <<<<<<<<<<<<<< * f"floats, but got {lows}") * */ - __Pyx_TraceLine(204,0,__PYX_ERR(0, 204, __pyx_L1_error)) - __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 204, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 204, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 204, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyUnicode_Join(__pyx_t_1, 4, __pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 218, __pyx_L1_error) } - __pyx_L84:; + __pyx_L82:; - /* "l0learn/interface.pyx":207 + /* "l0learn/interface.pyx":221 * f"floats, but got {lows}") * * if isinstance(highs, float): # <<<<<<<<<<<<<< * if highs < 0: * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") */ - __Pyx_TraceLine(207,0,__PYX_ERR(0, 207, __pyx_L1_error)) - __pyx_t_5 = PyFloat_Check(__pyx_v_highs); - __pyx_t_1 = (__pyx_t_5 != 0); - if (__pyx_t_1) { + __pyx_t_4 = PyFloat_Check(__pyx_v_highs); + __pyx_t_3 = (__pyx_t_4 != 0); + if (__pyx_t_3) { - /* "l0learn/interface.pyx":208 + /* "l0learn/interface.pyx":222 * * if isinstance(highs, float): * if highs < 0: # <<<<<<<<<<<<<< * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") * if highs < float('inf'): */ - __Pyx_TraceLine(208,0,__PYX_ERR(0, 208, __pyx_L1_error)) - __pyx_t_3 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 208, __pyx_L1_error) - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 208, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(__pyx_t_1)) { + __pyx_t_1 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 222, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 222, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(__pyx_t_3)) { - /* "l0learn/interface.pyx":209 + /* "l0learn/interface.pyx":223 * if isinstance(highs, float): * if highs < 0: * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") # <<<<<<<<<<<<<< * if highs < float('inf'): * with_bounds = True */ - __Pyx_TraceLine(209,0,__PYX_ERR(0, 209, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 209, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_highs_to_be_a_non_negat, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 209, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 209, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 209, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_highs_to_be_a_non_negat, __pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 223, __pyx_L1_error) - /* "l0learn/interface.pyx":208 + /* "l0learn/interface.pyx":222 * * if isinstance(highs, float): * if highs < 0: # <<<<<<<<<<<<<< @@ -6610,33 +5679,31 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":210 + /* "l0learn/interface.pyx":224 * if highs < 0: * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") * if highs < float('inf'): # <<<<<<<<<<<<<< * with_bounds = True * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): */ - __Pyx_TraceLine(210,0,__PYX_ERR(0, 210, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyNumber_Float(__pyx_n_u_inf); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 210, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_8 = PyObject_RichCompare(__pyx_v_highs, __pyx_t_3, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 210, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 210, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (__pyx_t_1) { + __pyx_t_1 = __Pyx_PyNumber_Float(__pyx_n_u_inf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = PyObject_RichCompare(__pyx_v_highs, __pyx_t_1, Py_LT); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (__pyx_t_3) { - /* "l0learn/interface.pyx":211 + /* "l0learn/interface.pyx":225 * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") * if highs < float('inf'): * with_bounds = True # <<<<<<<<<<<<<< * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): * with_bounds = True */ - __Pyx_TraceLine(211,0,__PYX_ERR(0, 211, __pyx_L1_error)) __pyx_v_with_bounds = 1; - /* "l0learn/interface.pyx":210 + /* "l0learn/interface.pyx":224 * if highs < 0: * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") * if highs < float('inf'): # <<<<<<<<<<<<<< @@ -6645,211 +5712,203 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":207 + /* "l0learn/interface.pyx":221 * f"floats, but got {lows}") * * if isinstance(highs, float): # <<<<<<<<<<<<<< * if highs < 0: * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") */ - goto __pyx_L90; + goto __pyx_L88; } - /* "l0learn/interface.pyx":212 + /* "l0learn/interface.pyx":226 * if highs < float('inf'): * with_bounds = True * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): # <<<<<<<<<<<<<< * with_bounds = True * else: */ - __Pyx_TraceLine(212,0,__PYX_ERR(0, 212, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 212, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 212, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_5 = PyObject_IsInstance(__pyx_v_highs, __pyx_t_3); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 212, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_4 = (__pyx_t_5 != 0); - if (__pyx_t_4) { + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_4 = PyObject_IsInstance(__pyx_v_highs, __pyx_t_1); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_5 = (__pyx_t_4 != 0); + if (__pyx_t_5) { } else { - __pyx_t_1 = __pyx_t_4; - goto __pyx_L93_bool_binop_done; + __pyx_t_3 = __pyx_t_5; + goto __pyx_L91_bool_binop_done; } - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_highs, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 212, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_8 = __Pyx_PyInt_EqObjC(__pyx_t_3, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 212, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 212, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (__pyx_t_4) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_highs, __pyx_n_s_ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = __Pyx_PyInt_EqObjC(__pyx_t_1, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (__pyx_t_5) { } else { - __pyx_t_1 = __pyx_t_4; - goto __pyx_L93_bool_binop_done; + __pyx_t_3 = __pyx_t_5; + goto __pyx_L91_bool_binop_done; } - __pyx_t_9 = PyObject_Length(__pyx_v_highs); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 212, __pyx_L1_error) - __pyx_t_8 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 212, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_3 = PyObject_RichCompare(__pyx_t_8, __pyx_v_p, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 212, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 212, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_4) { + __pyx_t_7 = PyObject_Length(__pyx_v_highs); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(0, 226, __pyx_L1_error) + __pyx_t_9 = PyInt_FromSsize_t(__pyx_t_7); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = PyObject_RichCompare(__pyx_t_9, __pyx_v_p, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_5) { } else { - __pyx_t_1 = __pyx_t_4; - goto __pyx_L93_bool_binop_done; + __pyx_t_3 = __pyx_t_5; + goto __pyx_L91_bool_binop_done; } - __pyx_t_3 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 212, __pyx_L1_error) - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 212, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_1 = __pyx_t_4; - __pyx_L93_bool_binop_done:; - if (likely(__pyx_t_1)) { + __pyx_t_1 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 226, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __pyx_t_5; + __pyx_L91_bool_binop_done:; + if (likely(__pyx_t_3)) { - /* "l0learn/interface.pyx":213 + /* "l0learn/interface.pyx":227 * with_bounds = True * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): * with_bounds = True # <<<<<<<<<<<<<< * else: * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " */ - __Pyx_TraceLine(213,0,__PYX_ERR(0, 213, __pyx_L1_error)) __pyx_v_with_bounds = 1; - /* "l0learn/interface.pyx":212 + /* "l0learn/interface.pyx":226 * if highs < float('inf'): * with_bounds = True * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): # <<<<<<<<<<<<<< * with_bounds = True * else: */ - goto __pyx_L90; + goto __pyx_L88; } - /* "l0learn/interface.pyx":215 + /* "l0learn/interface.pyx":229 * with_bounds = True * else: * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " # <<<<<<<<<<<<<< * f"non-negative floats, but got {highs}") * */ - __Pyx_TraceLine(215,0,__PYX_ERR(0, 215, __pyx_L1_error)) /*else*/ { - __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 215, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_9 = 0; - __pyx_t_10 = 127; + __pyx_t_1 = PyTuple_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = 0; + __pyx_t_8 = 127; __Pyx_INCREF(__pyx_kp_u_expected_highs_to_be_a_non_negat_2); - __pyx_t_9 += 73; + __pyx_t_7 += 73; __Pyx_GIVEREF(__pyx_kp_u_expected_highs_to_be_a_non_negat_2); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_highs_to_be_a_non_negat_2); - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 215, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); - __Pyx_GIVEREF(__pyx_t_8); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_8); - __pyx_t_8 = 0; + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_expected_highs_to_be_a_non_negat_2); + __pyx_t_9 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_9); + __pyx_t_9 = 0; __Pyx_INCREF(__pyx_kp_u_of_non_negative_floats_but_got); - __pyx_t_9 += 33; + __pyx_t_7 += 33; __Pyx_GIVEREF(__pyx_kp_u_of_non_negative_floats_but_got); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_of_non_negative_floats_but_got); + PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_of_non_negative_floats_but_got); - /* "l0learn/interface.pyx":216 + /* "l0learn/interface.pyx":230 * else: * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " * f"non-negative floats, but got {highs}") # <<<<<<<<<<<<<< * * if with_bounds: */ - __Pyx_TraceLine(216,0,__PYX_ERR(0, 216, __pyx_L1_error)) - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 216, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); - __Pyx_GIVEREF(__pyx_t_8); - PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_8); - __pyx_t_8 = 0; + __pyx_t_9 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_t_9); + __pyx_t_9 = 0; - /* "l0learn/interface.pyx":215 + /* "l0learn/interface.pyx":229 * with_bounds = True * else: * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " # <<<<<<<<<<<<<< * f"non-negative floats, but got {highs}") * */ - __Pyx_TraceLine(215,0,__PYX_ERR(0, 215, __pyx_L1_error)) - __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 215, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 215, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 215, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyUnicode_Join(__pyx_t_1, 4, __pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 229, __pyx_L1_error) } - __pyx_L90:; + __pyx_L88:; - /* "l0learn/interface.pyx":218 + /* "l0learn/interface.pyx":232 * f"non-negative floats, but got {highs}") * * if with_bounds: # <<<<<<<<<<<<<< * if isinstance(lows, float): * lows = np.ones(p) * lows */ - __Pyx_TraceLine(218,0,__PYX_ERR(0, 218, __pyx_L1_error)) - __pyx_t_1 = (__pyx_v_with_bounds != 0); - if (__pyx_t_1) { + __pyx_t_3 = (__pyx_v_with_bounds != 0); + if (__pyx_t_3) { - /* "l0learn/interface.pyx":219 + /* "l0learn/interface.pyx":233 * * if with_bounds: * if isinstance(lows, float): # <<<<<<<<<<<<<< * lows = np.ones(p) * lows * if isinstance(highs, float): */ - __Pyx_TraceLine(219,0,__PYX_ERR(0, 219, __pyx_L1_error)) - __pyx_t_1 = PyFloat_Check(__pyx_v_lows); - __pyx_t_4 = (__pyx_t_1 != 0); - if (__pyx_t_4) { + __pyx_t_3 = PyFloat_Check(__pyx_v_lows); + __pyx_t_5 = (__pyx_t_3 != 0); + if (__pyx_t_5) { - /* "l0learn/interface.pyx":220 + /* "l0learn/interface.pyx":234 * if with_bounds: * if isinstance(lows, float): * lows = np.ones(p) * lows # <<<<<<<<<<<<<< * if isinstance(highs, float): * highs = np.ones(p) * highs */ - __Pyx_TraceLine(220,0,__PYX_ERR(0, 220, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 220, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_ones); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 220, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); - if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); - __Pyx_INCREF(__pyx_t_8); + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_ones); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_7, function); + __Pyx_DECREF_SET(__pyx_t_6, function); } } - __pyx_t_3 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_v_p) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_p); - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 220, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = PyNumber_Multiply(__pyx_t_3, __pyx_v_lows); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 220, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_7); - __pyx_t_7 = 0; + __pyx_t_1 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_9, __pyx_v_p) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_p); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = PyNumber_Multiply(__pyx_t_1, __pyx_v_lows); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_6); + __pyx_t_6 = 0; - /* "l0learn/interface.pyx":219 + /* "l0learn/interface.pyx":233 * * if with_bounds: * if isinstance(lows, float): # <<<<<<<<<<<<<< @@ -6858,53 +5917,51 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":221 + /* "l0learn/interface.pyx":235 * if isinstance(lows, float): * lows = np.ones(p) * lows * if isinstance(highs, float): # <<<<<<<<<<<<<< * highs = np.ones(p) * highs * */ - __Pyx_TraceLine(221,0,__PYX_ERR(0, 221, __pyx_L1_error)) - __pyx_t_4 = PyFloat_Check(__pyx_v_highs); - __pyx_t_1 = (__pyx_t_4 != 0); - if (__pyx_t_1) { + __pyx_t_5 = PyFloat_Check(__pyx_v_highs); + __pyx_t_3 = (__pyx_t_5 != 0); + if (__pyx_t_3) { - /* "l0learn/interface.pyx":222 + /* "l0learn/interface.pyx":236 * lows = np.ones(p) * lows * if isinstance(highs, float): * highs = np.ones(p) * highs # <<<<<<<<<<<<<< * * if any(lows >= highs): */ - __Pyx_TraceLine(222,0,__PYX_ERR(0, 222, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 222, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_ones); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 222, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_8); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); - __Pyx_INCREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_ones); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_8, function); + __Pyx_DECREF_SET(__pyx_t_9, function); } } - __pyx_t_7 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_3, __pyx_v_p) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_p); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 222, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = PyNumber_Multiply(__pyx_t_7, __pyx_v_highs); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 222, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_8); - __pyx_t_8 = 0; + __pyx_t_6 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_1, __pyx_v_p) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_v_p); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = PyNumber_Multiply(__pyx_t_6, __pyx_v_highs); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_9); + __pyx_t_9 = 0; - /* "l0learn/interface.pyx":221 + /* "l0learn/interface.pyx":235 * if isinstance(lows, float): * lows = np.ones(p) * lows * if isinstance(highs, float): # <<<<<<<<<<<<<< @@ -6913,114 +5970,109 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":224 + /* "l0learn/interface.pyx":238 * highs = np.ones(p) * highs * * if any(lows >= highs): # <<<<<<<<<<<<<< * bad_bounds = np.argwhere(lows >= highs) * raise ValueError(f"expected to be high to be elementwise greater than lows, " */ - __Pyx_TraceLine(224,0,__PYX_ERR(0, 224, __pyx_L1_error)) - __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 224, __pyx_L1_error) - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 224, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 224, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(__pyx_t_1)) { + __pyx_t_9 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 238, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(__pyx_t_3)) { - /* "l0learn/interface.pyx":225 + /* "l0learn/interface.pyx":239 * * if any(lows >= highs): * bad_bounds = np.argwhere(lows >= highs) # <<<<<<<<<<<<<< * raise ValueError(f"expected to be high to be elementwise greater than lows, " * f"but got indices {bad_bounds[0]} where that is not the case ") */ - __Pyx_TraceLine(225,0,__PYX_ERR(0, 225, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 225, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_argwhere); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 225, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 225, __pyx_L1_error) - __pyx_t_16 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_16)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_16); + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_argwhere); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 239, __pyx_L1_error) + __pyx_t_15 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_15)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_15); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); + __Pyx_DECREF_SET(__pyx_t_1, function); } } - __pyx_t_7 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_16, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_8); - __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 225, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_v_bad_bounds = __pyx_t_7; - __pyx_t_7 = 0; + __pyx_t_6 = (__pyx_t_15) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_15, __pyx_t_9) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_9); + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_bad_bounds = __pyx_t_6; + __pyx_t_6 = 0; - /* "l0learn/interface.pyx":226 + /* "l0learn/interface.pyx":240 * if any(lows >= highs): * bad_bounds = np.argwhere(lows >= highs) * raise ValueError(f"expected to be high to be elementwise greater than lows, " # <<<<<<<<<<<<<< * f"but got indices {bad_bounds[0]} where that is not the case ") * else: */ - __Pyx_TraceLine(226,0,__PYX_ERR(0, 226, __pyx_L1_error)) - __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 226, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_9 = 0; - __pyx_t_10 = 127; + __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = 0; + __pyx_t_8 = 127; __Pyx_INCREF(__pyx_kp_u_expected_to_be_high_to_be_elemen); - __pyx_t_9 += 73; + __pyx_t_7 += 73; __Pyx_GIVEREF(__pyx_kp_u_expected_to_be_high_to_be_elemen); - PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_kp_u_expected_to_be_high_to_be_elemen); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_kp_u_expected_to_be_high_to_be_elemen); - /* "l0learn/interface.pyx":227 + /* "l0learn/interface.pyx":241 * bad_bounds = np.argwhere(lows >= highs) * raise ValueError(f"expected to be high to be elementwise greater than lows, " * f"but got indices {bad_bounds[0]} where that is not the case ") # <<<<<<<<<<<<<< * else: * lows = np.array([0.]) */ - __Pyx_TraceLine(227,0,__PYX_ERR(0, 227, __pyx_L1_error)) - __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_bad_bounds, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 227, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_t_3, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 227, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_10 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) > __pyx_t_10) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_8) : __pyx_t_10; - __pyx_t_9 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_8); - __Pyx_GIVEREF(__pyx_t_8); - PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_8); - __pyx_t_8 = 0; + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_bad_bounds, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 241, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = __Pyx_PyObject_FormatSimple(__pyx_t_1, __pyx_empty_unicode); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 241, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_9); + __pyx_t_9 = 0; __Pyx_INCREF(__pyx_kp_u_where_that_is_not_the_case); - __pyx_t_9 += 28; + __pyx_t_7 += 28; __Pyx_GIVEREF(__pyx_kp_u_where_that_is_not_the_case); - PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_kp_u_where_that_is_not_the_case); + PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_kp_u_where_that_is_not_the_case); - /* "l0learn/interface.pyx":226 + /* "l0learn/interface.pyx":240 * if any(lows >= highs): * bad_bounds = np.argwhere(lows >= highs) * raise ValueError(f"expected to be high to be elementwise greater than lows, " # <<<<<<<<<<<<<< * f"but got indices {bad_bounds[0]} where that is not the case ") * else: */ - __Pyx_TraceLine(226,0,__PYX_ERR(0, 226, __pyx_L1_error)) - __pyx_t_8 = __Pyx_PyUnicode_Join(__pyx_t_7, 3, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 226, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 226, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_Raise(__pyx_t_7, 0, 0, 0); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __PYX_ERR(0, 226, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyUnicode_Join(__pyx_t_6, 3, __pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 240, __pyx_L1_error) - /* "l0learn/interface.pyx":224 + /* "l0learn/interface.pyx":238 * highs = np.ones(p) * highs * * if any(lows >= highs): # <<<<<<<<<<<<<< @@ -7029,239 +6081,224 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ } - /* "l0learn/interface.pyx":218 + /* "l0learn/interface.pyx":232 * f"non-negative floats, but got {highs}") * * if with_bounds: # <<<<<<<<<<<<<< * if isinstance(lows, float): * lows = np.ones(p) * lows */ - goto __pyx_L97; + goto __pyx_L95; } - /* "l0learn/interface.pyx":229 + /* "l0learn/interface.pyx":243 * f"but got indices {bad_bounds[0]} where that is not the case ") * else: * lows = np.array([0.]) # <<<<<<<<<<<<<< * highs = np.array(([0.])) * */ - __Pyx_TraceLine(229,0,__PYX_ERR(0, 229, __pyx_L1_error)) /*else*/ { - __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 229, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 229, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __pyx_t_8 = PyList_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 229, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_array); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = PyList_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); __Pyx_INCREF(__pyx_float_0_); __Pyx_GIVEREF(__pyx_float_0_); - PyList_SET_ITEM(__pyx_t_8, 0, __pyx_float_0_); - __pyx_t_16 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_16)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_16); + PyList_SET_ITEM(__pyx_t_9, 0, __pyx_float_0_); + __pyx_t_15 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_15)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_15); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); + __Pyx_DECREF_SET(__pyx_t_1, function); } } - __pyx_t_7 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_16, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_8); - __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 229, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_7); - __pyx_t_7 = 0; + __pyx_t_6 = (__pyx_t_15) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_15, __pyx_t_9) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_9); + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_6); + __pyx_t_6 = 0; - /* "l0learn/interface.pyx":230 + /* "l0learn/interface.pyx":244 * else: * lows = np.array([0.]) * highs = np.array(([0.])) # <<<<<<<<<<<<<< * * return {"max_support_size": max_support_size, */ - __Pyx_TraceLine(230,0,__PYX_ERR(0, 230, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 230, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_array); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 230, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 230, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 244, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_array); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 244, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 244, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_float_0_); __Pyx_GIVEREF(__pyx_float_0_); - PyList_SET_ITEM(__pyx_t_3, 0, __pyx_float_0_); - __pyx_t_16 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { - __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_8); - if (likely(__pyx_t_16)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); - __Pyx_INCREF(__pyx_t_16); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_float_0_); + __pyx_t_15 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_15)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_15); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_8, function); + __Pyx_DECREF_SET(__pyx_t_9, function); } } - __pyx_t_7 = (__pyx_t_16) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_16, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_3); - __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 230, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_7); - __pyx_t_7 = 0; + __pyx_t_6 = (__pyx_t_15) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_15, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 244, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_6); + __pyx_t_6 = 0; } - __pyx_L97:; + __pyx_L95:; - /* "l0learn/interface.pyx":232 + /* "l0learn/interface.pyx":246 * highs = np.array(([0.])) * * return {"max_support_size": max_support_size, # <<<<<<<<<<<<<< * "screen_size": screen_size, * "y": y, */ - __Pyx_TraceLine(232,0,__PYX_ERR(0, 232, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __pyx_t_7 = __Pyx_PyDict_NewPresized(13); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 232, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_max_support_size, __pyx_v_max_support_size) < 0) __PYX_ERR(0, 232, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyDict_NewPresized(13); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_6, __pyx_n_u_max_support_size, __pyx_v_max_support_size) < 0) __PYX_ERR(0, 246, __pyx_L1_error) - /* "l0learn/interface.pyx":233 + /* "l0learn/interface.pyx":247 * * return {"max_support_size": max_support_size, * "screen_size": screen_size, # <<<<<<<<<<<<<< * "y": y, * "penalty":penalty, */ - __Pyx_TraceLine(233,0,__PYX_ERR(0, 233, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_screen_size, __pyx_v_screen_size) < 0) __PYX_ERR(0, 232, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_u_screen_size, __pyx_v_screen_size) < 0) __PYX_ERR(0, 246, __pyx_L1_error) - /* "l0learn/interface.pyx":234 + /* "l0learn/interface.pyx":248 * return {"max_support_size": max_support_size, * "screen_size": screen_size, * "y": y, # <<<<<<<<<<<<<< * "penalty":penalty, * "gamma_max":gamma_max, */ - __Pyx_TraceLine(234,0,__PYX_ERR(0, 234, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_y, __pyx_v_y) < 0) __PYX_ERR(0, 232, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_u_y, __pyx_v_y) < 0) __PYX_ERR(0, 246, __pyx_L1_error) - /* "l0learn/interface.pyx":235 + /* "l0learn/interface.pyx":249 * "screen_size": screen_size, * "y": y, * "penalty":penalty, # <<<<<<<<<<<<<< * "gamma_max":gamma_max, * "gamma_min": gamma_min, */ - __Pyx_TraceLine(235,0,__PYX_ERR(0, 235, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 232, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_u_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 246, __pyx_L1_error) - /* "l0learn/interface.pyx":236 + /* "l0learn/interface.pyx":250 * "y": y, * "penalty":penalty, * "gamma_max":gamma_max, # <<<<<<<<<<<<<< * "gamma_min": gamma_min, * "lambda_grid": lambda_grid, */ - __Pyx_TraceLine(236,0,__PYX_ERR(0, 236, __pyx_L1_error)) - __pyx_t_8 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 236, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_gamma_max, __pyx_t_8) < 0) __PYX_ERR(0, 232, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_9 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (PyDict_SetItem(__pyx_t_6, __pyx_n_u_gamma_max, __pyx_t_9) < 0) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "l0learn/interface.pyx":237 + /* "l0learn/interface.pyx":251 * "penalty":penalty, * "gamma_max":gamma_max, * "gamma_min": gamma_min, # <<<<<<<<<<<<<< * "lambda_grid": lambda_grid, * "num_gamma": num_gamma, */ - __Pyx_TraceLine(237,0,__PYX_ERR(0, 237, __pyx_L1_error)) - __pyx_t_8 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 237, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_gamma_min, __pyx_t_8) < 0) __PYX_ERR(0, 232, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_9 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 251, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (PyDict_SetItem(__pyx_t_6, __pyx_n_u_gamma_min, __pyx_t_9) < 0) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "l0learn/interface.pyx":238 + /* "l0learn/interface.pyx":252 * "gamma_max":gamma_max, * "gamma_min": gamma_min, * "lambda_grid": lambda_grid, # <<<<<<<<<<<<<< * "num_gamma": num_gamma, * "num_lambda":num_lambda, */ - __Pyx_TraceLine(238,0,__PYX_ERR(0, 238, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_lambda_grid, __pyx_v_lambda_grid) < 0) __PYX_ERR(0, 232, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_u_lambda_grid, __pyx_v_lambda_grid) < 0) __PYX_ERR(0, 246, __pyx_L1_error) - /* "l0learn/interface.pyx":239 + /* "l0learn/interface.pyx":253 * "gamma_min": gamma_min, * "lambda_grid": lambda_grid, * "num_gamma": num_gamma, # <<<<<<<<<<<<<< * "num_lambda":num_lambda, * "auto_lambda": auto_lambda, */ - __Pyx_TraceLine(239,0,__PYX_ERR(0, 239, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_num_gamma, __pyx_v_num_gamma) < 0) __PYX_ERR(0, 232, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_u_num_gamma, __pyx_v_num_gamma) < 0) __PYX_ERR(0, 246, __pyx_L1_error) - /* "l0learn/interface.pyx":240 + /* "l0learn/interface.pyx":254 * "lambda_grid": lambda_grid, * "num_gamma": num_gamma, * "num_lambda":num_lambda, # <<<<<<<<<<<<<< * "auto_lambda": auto_lambda, * "with_bounds": with_bounds, */ - __Pyx_TraceLine(240,0,__PYX_ERR(0, 240, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_num_lambda, __pyx_v_num_lambda) < 0) __PYX_ERR(0, 232, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_u_num_lambda, __pyx_v_num_lambda) < 0) __PYX_ERR(0, 246, __pyx_L1_error) - /* "l0learn/interface.pyx":241 + /* "l0learn/interface.pyx":255 * "num_gamma": num_gamma, * "num_lambda":num_lambda, * "auto_lambda": auto_lambda, # <<<<<<<<<<<<<< * "with_bounds": with_bounds, * "lows": lows, */ - __Pyx_TraceLine(241,0,__PYX_ERR(0, 241, __pyx_L1_error)) - __pyx_t_8 = __Pyx_PyBool_FromLong(__pyx_v_auto_lambda); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 241, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_auto_lambda, __pyx_t_8) < 0) __PYX_ERR(0, 232, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_9 = __Pyx_PyBool_FromLong(__pyx_v_auto_lambda); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (PyDict_SetItem(__pyx_t_6, __pyx_n_u_auto_lambda, __pyx_t_9) < 0) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "l0learn/interface.pyx":242 + /* "l0learn/interface.pyx":256 * "num_lambda":num_lambda, * "auto_lambda": auto_lambda, * "with_bounds": with_bounds, # <<<<<<<<<<<<<< * "lows": lows, * "highs":highs} */ - __Pyx_TraceLine(242,0,__PYX_ERR(0, 242, __pyx_L1_error)) - __pyx_t_8 = __Pyx_PyBool_FromLong(__pyx_v_with_bounds); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 242, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_with_bounds, __pyx_t_8) < 0) __PYX_ERR(0, 232, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_9 = __Pyx_PyBool_FromLong(__pyx_v_with_bounds); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (PyDict_SetItem(__pyx_t_6, __pyx_n_u_with_bounds, __pyx_t_9) < 0) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "l0learn/interface.pyx":243 + /* "l0learn/interface.pyx":257 * "auto_lambda": auto_lambda, * "with_bounds": with_bounds, * "lows": lows, # <<<<<<<<<<<<<< * "highs":highs} * */ - __Pyx_TraceLine(243,0,__PYX_ERR(0, 243, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_lows, __pyx_v_lows) < 0) __PYX_ERR(0, 232, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_n_u_lows, __pyx_v_lows) < 0) __PYX_ERR(0, 246, __pyx_L1_error) - /* "l0learn/interface.pyx":244 + /* "l0learn/interface.pyx":258 * "with_bounds": with_bounds, * "lows": lows, * "highs":highs} # <<<<<<<<<<<<<< * * */ - __Pyx_TraceLine(244,0,__PYX_ERR(0, 244, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_7, __pyx_n_u_highs, __pyx_v_highs) < 0) __PYX_ERR(0, 232, __pyx_L1_error) - __pyx_r = __pyx_t_7; - __pyx_t_7 = 0; + if (PyDict_SetItem(__pyx_t_6, __pyx_n_u_highs, __pyx_v_highs) < 0) __PYX_ERR(0, 246, __pyx_L1_error) + __pyx_r = __pyx_t_6; + __pyx_t_6 = 0; goto __pyx_L0; /* "l0learn/interface.pyx":52 @@ -7274,11 +6311,11 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject /* function exit code */ __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_XDECREF(__pyx_t_16); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_15); __Pyx_AddTraceback("l0learn.interface._fit_check", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -7302,12 +6339,11 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject __Pyx_XDECREF(__pyx_v_lows); __Pyx_XDECREF(__pyx_v_highs); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "l0learn/interface.pyx":247 +/* "l0learn/interface.pyx":261 * * * def fit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< @@ -7316,10 +6352,10 @@ static PyObject *__pyx_pf_7l0learn_9interface_2_fit_check(CYTHON_UNUSED PyObject */ /* Python wrapper */ -static PyObject *__pyx_pw_7l0learn_9interface_5fit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_7l0learn_9interface_4fit[] = "fit(X: Union[np.ndarray, csc_matrix], y: np.ndarray, unicode loss: str = u'SquaredError', unicode penalty: str = u'L0', unicode algorithm: str = u'CD', max_support_size: int = 100, num_lambda: Optional[int] = 100, num_gamma: Optional[int] = 1, double gamma_max: float = 10., double gamma_min: float = .0001, partial_sort: bool = True, max_iter: int = 200, double rtol: float = 1e-6, double atol: float = 1e-9, active_set: bool = True, active_set_num: int = 3, max_swaps: int = 100, double scale_down_factor: float = 0.8, screen_size: int = 1000, lambda_grid: Optional[List[List[float]]] = None, exclude_first_k: int = 0, intercept: bool = True, lows: Union[np.ndarray, float] = -float(u'inf'), highs: Union[np.ndarray, float] = +float(u'inf')) -> l0learn.models.FitModel\n\n Computes the regularization path for the specified loss function and penalty function.\n\n Parameters\n ----------\n X : np.ndarray or csc_matrix of shape (N, P)\n Data Matrix where rows of X are observations and columns of X are features\n\n y : np.ndarray of shape (P)\n The response vector where y[i] corresponds to X[i, :]\n For classification, a binary vector (-1, 1) is requried .\n\n loss : str\n The loss function. Currently supports the choices:\n \"SquaredError\" (for regression),\n \"Logistic\" (for logistic regression), and\n \"SquaredHinge\" (for smooth SVM).\n\n penalty : str\n The type of regularization.\n This can take either one of the following choices:\n \"L0\",\n \"L0L2\", and\n \"L0L1\"\n\n algorithm : str\n The type of algorithm used to minimize the objective function. Currently \"CD\" and \"CDPSI\" are are supported.\n \"CD\" is a variant of cyclic coordinate descent and runs very fast. \"CDPSI\" performs local combinatorial search\n on top of CD and typically achieves higher quality solutions (at the expense of increased running time).""\n\n max_support_size : int\n Must be greater than 0.\n The maximum support size at which to terminate the regularization path. We recommend setting this to a small\n fraction of min(n,p) (e.g. 0.05 * min(n,p)) as L0 regularization typically selects a small portion of non-zeros.\n\n num_lambda : int, optional\n The number of lambda values to select in the regularization path.\n This value must be None if lambda_grid is supplied.When supplied, must be greater than 0.\n Note: lambda is the regularization parameter corresponding to the L0 norm.\n\n num_gamma: int, optional\n The number of gamma values to select in the regularization path.\n This value must be None if lambda_grid is supplied. When supplied, must be greater than 0.\n Note: gamma is the regularization parameter corresponding to L1 or L2, depending on the chosen penalty).\n\n gamma_max : float\n The maximum value of gamma when using the L0L2 penalty.\n This value must be greater than 0.\n\n Note: For the L0L1 penalty this is automatically selected.\n\n gamma_min : float\n The minimum value of Gamma when using the L0L2 penalty.\n This value must be greater than 0 but less than gamma_max.\n Note: For the L0L1 penalty, the minimum value of gamma in the grid is set to gammaMin * gammaMax.\n\n partial_sort : bool\n If TRUE partial sorting will be used for sorting the coordinates to do greedy cycling (see our paper for\n for details). Otherwise, full sorting is used. #TODO: Add link for paper\n\n max_iter : int\n The maximum number of iterations (full cycles) for CD per grid point. The algorithm may not use the full number\n of iteration per grid point if convergence is found (defined by rtol and atol parameter)\n Must be greater than 0\n\n rtol : float\n The relative tolerance which decides when to terminate optimization as based on the relat""ive change in the\n objective between iterations.\n Must be greater than 0 and less than 1.\n\n atol : float\n The absolute tolerance which decides when to terminate optimization as based on the absolute L2 norm of the\n residuals\n Must be greater than 0\n\n active_set : bool\n If TRUE, performs active set updates. (see our paper for for details). #TODO: Add link for paper\n\n active_set_num : int\n The number of consecutive times a support should appear before declaring support stabilization.\n (see our paper for for details). #TODO: Add link for paper\n\n Must be greater than 0.\n\n max_swaps : int\n The maximum number of swaps used by CDPSI for each grid point.\n Must be greater than 0. Ignored by CD algorithims.\n\n scale_down_factor : float\n Roughly amount each lambda value is scaled by between grid points. Larger values lead to closer lambdas and\n typically to smaller gaps between the support sizes.\n\n For details, see our paper - Section 5 on Adaptive Selection of Tuning Parameters). #TODO: Add link for paper\n\n Must be greater than 0 and less than 1 (strictly for both.)\n\n screen_size : int\n The number of coordinates to cycle over when performing initial correlation screening. #TODO: Add link for paper\n\n Must be greater than 0 and less than number of columns of X.\n\n lambda_grid : list of list of floats\n A grid of lambda values to use in computing the regularization path. This is by default an empty list\n and is ignored. When specified, lambda_grid should be a list of list of floats, where the ith element\n (corresponding to the ith gamma) should be a decreasing sequence of lambda values. The length of this sequence\n is directly the number of lambdas to be tried for that gamma.\n\n In the the \"L0\" penalty case, lambda_grid should be a list of 1.\n In the \"L0LX""\" penalty cases, lambda_grid can be a list of any length. The length of lambda_grid will be the\n number of gamma values tried.\n\n See the example notebook for more details.\n\n Note: When lambda_grid is supplied, num_gamma and num_lambda must be None.\n\n exclude_first_k : int\n The first exclude_first_k features in X will be excluded from variable selection. In other words, the first\n exclude_first_k variables will not be included in the L0-norm penalty however they will be included in the\n L1 or L2 norm penalties, if they are specified.\n\n Must be a positive integer less than the columns of X.\n\n intercept : bool\n If False, no intercept term is included or fit in the regularization path\n Intercept terms are not regularized by L0 or L1/L2.\n\n lows : np array or float\n Lower bounds for coefficients. Either a scalar for all coefficients to have the same bound or a vector of\n size p (number of columns of X) where lows[i] is the lower bound for coefficient i.\n\n Lower bounds can not be above 0 (i.e. we can not specify that all coefficients must be larger than a > 0).\n Lower bounds can be set to 0 iff the corresponding upper bound for that coefficient is also not 0.\n\n highs : np array or float\n Upper bounds for coefficients. Either a scalar for all coefficients to have the same bound or a vector of\n size p (number of columns of X) where highs[i] is the upper bound for coefficient i.\n\n Upper bounds can not be below 0 (i.e. we can not specify that all coefficients must be smaller than a < 0).\n Upper bounds can be set to 0 iff the corresponding lower bound for that coefficient is also not 0.\n\n Returns\n -------\n\n\n Examples\n --------\n "; -static PyMethodDef __pyx_mdef_7l0learn_9interface_5fit = {"fit", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7l0learn_9interface_5fit, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7l0learn_9interface_4fit}; -static PyObject *__pyx_pw_7l0learn_9interface_5fit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_7l0learn_9interface_3fit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_7l0learn_9interface_2fit[] = "fit(X: Union[np.ndarray, csc_matrix], y: np.ndarray, unicode loss: str = u'SquaredError', unicode penalty: str = u'L0', unicode algorithm: str = u'CD', max_support_size: int = 100, num_lambda: Optional[int] = 100, num_gamma: Optional[int] = 1, double gamma_max: float = 10., double gamma_min: float = .0001, partial_sort: bool = True, max_iter: int = 200, double rtol: float = 1e-6, double atol: float = 1e-9, active_set: bool = True, active_set_num: int = 3, max_swaps: int = 100, double scale_down_factor: float = 0.8, screen_size: int = 1000, lambda_grid: Optional[List[List[float]]] = None, exclude_first_k: int = 0, intercept: bool = True, lows: Union[np.ndarray, float] = -float(u'inf'), highs: Union[np.ndarray, float] = +float(u'inf')) -> l0learn.models.FitModel\n\n Computes the regularization path for the specified loss function and penalty function.\n\n Parameters\n ----------\n X : np.ndarray or csc_matrix of shape (N, P)\n Data Matrix where rows of X are observations and columns of X are features\n\n y : np.ndarray of shape (P)\n The response vector where y[i] corresponds to X[i, :]\n For classification, a binary vector (-1, 1) is requried .\n\n loss : str\n The loss function. Currently supports the choices:\n \"SquaredError\" (for regression),\n \"Logistic\" (for logistic regression), and\n \"SquaredHinge\" (for smooth SVM).\n\n penalty : str\n The type of regularization.\n This can take either one of the following choices:\n \"L0\",\n \"L0L2\", and\n \"L0L1\"\n\n algorithm : str\n The type of algorithm used to minimize the objective function. Currently \"CD\" and \"CDPSI\" are are supported.\n \"CD\" is a variant of cyclic coordinate descent and runs very fast. \"CDPSI\" performs local combinatorial search\n on top of CD and typically achieves higher quality solutions (at the expense of increased running time).""\n\n max_support_size : int\n Must be greater than 0.\n The maximum support size at which to terminate the regularization path. We recommend setting this to a small\n fraction of min(n,p) (e.g. 0.05 * min(n,p)) as L0 regularization typically selects a small portion of non-zeros.\n\n num_lambda : int, optional\n The number of lambda values to select in the regularization path.\n This value must be None if lambda_grid is supplied.When supplied, must be greater than 0.\n Note: lambda is the regularization parameter corresponding to the L0 norm.\n\n num_gamma: int, optional\n The number of gamma values to select in the regularization path.\n This value must be None if lambda_grid is supplied. When supplied, must be greater than 0.\n Note: gamma is the regularization parameter corresponding to L1 or L2, depending on the chosen penalty).\n\n gamma_max : float\n The maximum value of gamma when using the L0L2 penalty.\n This value must be greater than 0.\n\n Note: For the L0L1 penalty this is automatically selected.\n\n gamma_min : float\n The minimum value of Gamma when using the L0L2 penalty.\n This value must be greater than 0 but less than gamma_max.\n Note: For the L0L1 penalty, the minimum value of gamma in the grid is set to gammaMin * gammaMax.\n\n partial_sort : bool\n If TRUE partial sorting will be used for sorting the coordinates to do greedy cycling (see our paper for\n for details). Otherwise, full sorting is used. #TODO: Add link for paper\n\n max_iter : int\n The maximum number of iterations (full cycles) for CD per grid point. The algorithm may not use the full number\n of iteration per grid point if convergence is found (defined by rtol and atol parameter)\n Must be greater than 0\n\n rtol : float\n The relative tolerance which decides when to terminate optimization as based on the relat""ive change in the\n objective between iterations.\n Must be greater than 0 and less than 1.\n\n atol : float\n The absolute tolerance which decides when to terminate optimization as based on the absolute L2 norm of the\n residuals\n Must be greater than 0\n\n active_set : bool\n If TRUE, performs active set updates. (see our paper for for details). #TODO: Add link for paper\n\n active_set_num : int\n The number of consecutive times a support should appear before declaring support stabilization.\n (see our paper for for details). #TODO: Add link for paper\n\n Must be greater than 0.\n\n max_swaps : int\n The maximum number of swaps used by CDPSI for each grid point.\n Must be greater than 0. Ignored by CD algorithims.\n\n scale_down_factor : float\n Roughly amount each lambda value is scaled by between grid points. Larger values lead to closer lambdas and\n typically to smaller gaps between the support sizes.\n\n For details, see our paper - Section 5 on Adaptive Selection of Tuning Parameters). #TODO: Add link for paper\n\n Must be greater than 0 and less than 1 (strictly for both.)\n\n screen_size : int\n The number of coordinates to cycle over when performing initial correlation screening. #TODO: Add link for paper\n\n Must be greater than 0 and less than number of columns of X.\n\n lambda_grid : list of list of floats\n A grid of lambda values to use in computing the regularization path. This is by default an empty list\n and is ignored. When specified, lambda_grid should be a list of list of floats, where the ith element\n (corresponding to the ith gamma) should be a decreasing sequence of lambda values. The length of this sequence\n is directly the number of lambdas to be tried for that gamma.\n\n In the the \"L0\" penalty case, lambda_grid should be a list of 1.\n In the \"L0LX""\" penalty cases, lambda_grid can be a list of any length. The length of lambda_grid will be the\n number of gamma values tried.\n\n See the example notebook for more details.\n\n Note: When lambda_grid is supplied, num_gamma and num_lambda must be None.\n\n exclude_first_k : int\n The first exclude_first_k features in X will be excluded from variable selection. In other words, the first\n exclude_first_k variables will not be included in the L0-norm penalty however they will be included in the\n L1 or L2 norm penalties, if they are specified.\n\n Must be a positive integer less than the columns of X.\n\n intercept : bool\n If False, no intercept term is included or fit in the regularization path\n Intercept terms are not regularized by L0 or L1/L2.\n\n lows : np array or float\n Lower bounds for coefficients. Either a scalar for all coefficients to have the same bound or a vector of\n size p (number of columns of X) where lows[i] is the lower bound for coefficient i.\n\n Lower bounds can not be above 0 (i.e. we can not specify that all coefficients must be larger than a > 0).\n Lower bounds can be set to 0 iff the corresponding upper bound for that coefficient is also not 0.\n\n highs : np array or float\n Upper bounds for coefficients. Either a scalar for all coefficients to have the same bound or a vector of\n size p (number of columns of X) where highs[i] is the upper bound for coefficient i.\n\n Upper bounds can not be below 0 (i.e. we can not specify that all coefficients must be smaller than a < 0).\n Upper bounds can be set to 0 iff the corresponding lower bound for that coefficient is also not 0.\n\n Returns\n -------\n\n\n Examples\n --------\n "; +static PyMethodDef __pyx_mdef_7l0learn_9interface_3fit = {"fit", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7l0learn_9interface_3fit, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7l0learn_9interface_2fit}; +static PyObject *__pyx_pw_7l0learn_9interface_3fit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_X = 0; PyObject *__pyx_v_y = 0; PyObject *__pyx_v_loss = 0; @@ -7360,7 +6396,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5fit(PyObject *__pyx_self, PyObjec values[6] = ((PyObject *)__pyx_int_100); values[7] = ((PyObject *)__pyx_int_1); - /* "l0learn/interface.pyx":257 + /* "l0learn/interface.pyx":271 * gamma_max: float = 10., * gamma_min: float = .0001, * partial_sort: bool = True, # <<<<<<<<<<<<<< @@ -7370,7 +6406,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5fit(PyObject *__pyx_self, PyObjec values[10] = ((PyObject *)Py_True); values[11] = ((PyObject *)__pyx_int_200); - /* "l0learn/interface.pyx":261 + /* "l0learn/interface.pyx":275 * rtol: float = 1e-6, * atol: float = 1e-9, * active_set: bool = True, # <<<<<<<<<<<<<< @@ -7382,7 +6418,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5fit(PyObject *__pyx_self, PyObjec values[16] = ((PyObject *)__pyx_int_100); values[18] = ((PyObject *)__pyx_int_1000); - /* "l0learn/interface.pyx":266 + /* "l0learn/interface.pyx":280 * scale_down_factor: float = 0.8, * screen_size: int = 1000, * lambda_grid: Optional[List[List[float]]] = None, # <<<<<<<<<<<<<< @@ -7392,7 +6428,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5fit(PyObject *__pyx_self, PyObjec values[19] = ((PyObject *)Py_None); values[20] = ((PyObject *)__pyx_int_0); - /* "l0learn/interface.pyx":268 + /* "l0learn/interface.pyx":282 * lambda_grid: Optional[List[List[float]]] = None, * exclude_first_k: int = 0, * intercept: bool = True, # <<<<<<<<<<<<<< @@ -7400,8 +6436,8 @@ static PyObject *__pyx_pw_7l0learn_9interface_5fit(PyObject *__pyx_self, PyObjec * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.FitModel: */ values[21] = ((PyObject *)Py_True); - values[22] = __pyx_k__9; - values[23] = __pyx_k__10; + values[22] = __pyx_k__2; + values[23] = __pyx_k__3; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); @@ -7466,7 +6502,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5fit(PyObject *__pyx_self, PyObjec case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("fit", 0, 2, 24, 1); __PYX_ERR(0, 247, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("fit", 0, 2, 24, 1); __PYX_ERR(0, 261, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: @@ -7602,7 +6638,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5fit(PyObject *__pyx_self, PyObjec } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fit") < 0)) __PYX_ERR(0, 247, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fit") < 0)) __PYX_ERR(0, 261, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -7665,24 +6701,24 @@ static PyObject *__pyx_pw_7l0learn_9interface_5fit(PyObject *__pyx_self, PyObjec __pyx_v_num_lambda = values[6]; __pyx_v_num_gamma = values[7]; if (values[8]) { - __pyx_v_gamma_max = __pyx_PyFloat_AsDouble(values[8]); if (unlikely((__pyx_v_gamma_max == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 255, __pyx_L3_error) + __pyx_v_gamma_max = __pyx_PyFloat_AsDouble(values[8]); if (unlikely((__pyx_v_gamma_max == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 269, __pyx_L3_error) } else { __pyx_v_gamma_max = ((double)10.); } if (values[9]) { - __pyx_v_gamma_min = __pyx_PyFloat_AsDouble(values[9]); if (unlikely((__pyx_v_gamma_min == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 256, __pyx_L3_error) + __pyx_v_gamma_min = __pyx_PyFloat_AsDouble(values[9]); if (unlikely((__pyx_v_gamma_min == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 270, __pyx_L3_error) } else { __pyx_v_gamma_min = ((double).0001); } __pyx_v_partial_sort = values[10]; __pyx_v_max_iter = values[11]; if (values[12]) { - __pyx_v_rtol = __pyx_PyFloat_AsDouble(values[12]); if (unlikely((__pyx_v_rtol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 259, __pyx_L3_error) + __pyx_v_rtol = __pyx_PyFloat_AsDouble(values[12]); if (unlikely((__pyx_v_rtol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 273, __pyx_L3_error) } else { __pyx_v_rtol = ((double)1e-6); } if (values[13]) { - __pyx_v_atol = __pyx_PyFloat_AsDouble(values[13]); if (unlikely((__pyx_v_atol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 260, __pyx_L3_error) + __pyx_v_atol = __pyx_PyFloat_AsDouble(values[13]); if (unlikely((__pyx_v_atol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 274, __pyx_L3_error) } else { __pyx_v_atol = ((double)1e-9); } @@ -7690,7 +6726,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5fit(PyObject *__pyx_self, PyObjec __pyx_v_active_set_num = values[15]; __pyx_v_max_swaps = values[16]; if (values[17]) { - __pyx_v_scale_down_factor = __pyx_PyFloat_AsDouble(values[17]); if (unlikely((__pyx_v_scale_down_factor == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 264, __pyx_L3_error) + __pyx_v_scale_down_factor = __pyx_PyFloat_AsDouble(values[17]); if (unlikely((__pyx_v_scale_down_factor == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 278, __pyx_L3_error) } else { __pyx_v_scale_down_factor = ((double)0.8); } @@ -7703,18 +6739,18 @@ static PyObject *__pyx_pw_7l0learn_9interface_5fit(PyObject *__pyx_self, PyObjec } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("fit", 0, 2, 24, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 247, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("fit", 0, 2, 24, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 261, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("l0learn.interface.fit", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loss), (&PyUnicode_Type), 1, "loss", 1))) __PYX_ERR(0, 249, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_penalty), (&PyUnicode_Type), 1, "penalty", 1))) __PYX_ERR(0, 250, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_algorithm), (&PyUnicode_Type), 1, "algorithm", 1))) __PYX_ERR(0, 251, __pyx_L1_error) - __pyx_r = __pyx_pf_7l0learn_9interface_4fit(__pyx_self, __pyx_v_X, __pyx_v_y, __pyx_v_loss, __pyx_v_penalty, __pyx_v_algorithm, __pyx_v_max_support_size, __pyx_v_num_lambda, __pyx_v_num_gamma, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_v_partial_sort, __pyx_v_max_iter, __pyx_v_rtol, __pyx_v_atol, __pyx_v_active_set, __pyx_v_active_set_num, __pyx_v_max_swaps, __pyx_v_scale_down_factor, __pyx_v_screen_size, __pyx_v_lambda_grid, __pyx_v_exclude_first_k, __pyx_v_intercept, __pyx_v_lows, __pyx_v_highs); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loss), (&PyUnicode_Type), 1, "loss", 1))) __PYX_ERR(0, 263, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_penalty), (&PyUnicode_Type), 1, "penalty", 1))) __PYX_ERR(0, 264, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_algorithm), (&PyUnicode_Type), 1, "algorithm", 1))) __PYX_ERR(0, 265, __pyx_L1_error) + __pyx_r = __pyx_pf_7l0learn_9interface_2fit(__pyx_self, __pyx_v_X, __pyx_v_y, __pyx_v_loss, __pyx_v_penalty, __pyx_v_algorithm, __pyx_v_max_support_size, __pyx_v_num_lambda, __pyx_v_num_gamma, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_v_partial_sort, __pyx_v_max_iter, __pyx_v_rtol, __pyx_v_atol, __pyx_v_active_set, __pyx_v_active_set_num, __pyx_v_max_swaps, __pyx_v_scale_down_factor, __pyx_v_screen_size, __pyx_v_lambda_grid, __pyx_v_exclude_first_k, __pyx_v_intercept, __pyx_v_lows, __pyx_v_highs); - /* "l0learn/interface.pyx":247 + /* "l0learn/interface.pyx":261 * * * def fit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< @@ -7731,7 +6767,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5fit(PyObject *__pyx_self, PyObjec return __pyx_r; } -static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs) { +static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs) { PyObject *__pyx_v_check = NULL; PyObject *__pyx_v_auto_lambda = NULL; PyObject *__pyx_v_with_bounds = NULL; @@ -7742,7 +6778,6 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx fitmodel __pyx_v_c_results; PyObject *__pyx_v_results = NULL; PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; @@ -7773,9 +6808,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_TraceFrameInit(__pyx_codeobj__11) __Pyx_RefNannySetupContext("fit", 0); - __Pyx_TraceCall("fit", __pyx_f[0], 247, 0, __PYX_ERR(0, 247, __pyx_L1_error)); __Pyx_INCREF(__pyx_v_y); __Pyx_INCREF(__pyx_v_penalty); __Pyx_INCREF(__pyx_v_max_support_size); @@ -7786,460 +6819,421 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx __Pyx_INCREF(__pyx_v_lows); __Pyx_INCREF(__pyx_v_highs); - /* "l0learn/interface.pyx":418 + /* "l0learn/interface.pyx":432 * -------- * """ * check = _fit_check(X=X, # <<<<<<<<<<<<<< * y=y, * loss=loss, */ - __Pyx_TraceLine(418,0,__PYX_ERR(0, 418, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_fit_check); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 418, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_fit_check); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 432, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyDict_NewPresized(24); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 418, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyDict_NewPresized(24); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 432, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_X, __pyx_v_X) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_X, __pyx_v_X) < 0) __PYX_ERR(0, 432, __pyx_L1_error) - /* "l0learn/interface.pyx":419 + /* "l0learn/interface.pyx":433 * """ * check = _fit_check(X=X, * y=y, # <<<<<<<<<<<<<< * loss=loss, * penalty=penalty, */ - __Pyx_TraceLine(419,0,__PYX_ERR(0, 419, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_y, __pyx_v_y) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_y, __pyx_v_y) < 0) __PYX_ERR(0, 432, __pyx_L1_error) - /* "l0learn/interface.pyx":420 + /* "l0learn/interface.pyx":434 * check = _fit_check(X=X, * y=y, * loss=loss, # <<<<<<<<<<<<<< * penalty=penalty, * algorithm=algorithm, */ - __Pyx_TraceLine(420,0,__PYX_ERR(0, 420, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 432, __pyx_L1_error) - /* "l0learn/interface.pyx":421 + /* "l0learn/interface.pyx":435 * y=y, * loss=loss, * penalty=penalty, # <<<<<<<<<<<<<< * algorithm=algorithm, * max_support_size=max_support_size, */ - __Pyx_TraceLine(421,0,__PYX_ERR(0, 421, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 432, __pyx_L1_error) - /* "l0learn/interface.pyx":422 + /* "l0learn/interface.pyx":436 * loss=loss, * penalty=penalty, * algorithm=algorithm, # <<<<<<<<<<<<<< * max_support_size=max_support_size, * num_lambda=num_lambda, */ - __Pyx_TraceLine(422,0,__PYX_ERR(0, 422, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_algorithm, __pyx_v_algorithm) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_algorithm, __pyx_v_algorithm) < 0) __PYX_ERR(0, 432, __pyx_L1_error) - /* "l0learn/interface.pyx":423 + /* "l0learn/interface.pyx":437 * penalty=penalty, * algorithm=algorithm, * max_support_size=max_support_size, # <<<<<<<<<<<<<< * num_lambda=num_lambda, * num_gamma=num_gamma, */ - __Pyx_TraceLine(423,0,__PYX_ERR(0, 423, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_support_size, __pyx_v_max_support_size) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_support_size, __pyx_v_max_support_size) < 0) __PYX_ERR(0, 432, __pyx_L1_error) - /* "l0learn/interface.pyx":424 + /* "l0learn/interface.pyx":438 * algorithm=algorithm, * max_support_size=max_support_size, * num_lambda=num_lambda, # <<<<<<<<<<<<<< * num_gamma=num_gamma, * gamma_max=gamma_max, */ - __Pyx_TraceLine(424,0,__PYX_ERR(0, 424, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_lambda, __pyx_v_num_lambda) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_lambda, __pyx_v_num_lambda) < 0) __PYX_ERR(0, 432, __pyx_L1_error) - /* "l0learn/interface.pyx":425 + /* "l0learn/interface.pyx":439 * max_support_size=max_support_size, * num_lambda=num_lambda, * num_gamma=num_gamma, # <<<<<<<<<<<<<< * gamma_max=gamma_max, * gamma_min=gamma_min, */ - __Pyx_TraceLine(425,0,__PYX_ERR(0, 425, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_gamma, __pyx_v_num_gamma) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_gamma, __pyx_v_num_gamma) < 0) __PYX_ERR(0, 432, __pyx_L1_error) - /* "l0learn/interface.pyx":426 + /* "l0learn/interface.pyx":440 * num_lambda=num_lambda, * num_gamma=num_gamma, * gamma_max=gamma_max, # <<<<<<<<<<<<<< * gamma_min=gamma_min, * partial_sort=partial_sort, */ - __Pyx_TraceLine(426,0,__PYX_ERR(0, 426, __pyx_L1_error)) - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 426, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 440, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma_max, __pyx_t_3) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma_max, __pyx_t_3) < 0) __PYX_ERR(0, 432, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":427 + /* "l0learn/interface.pyx":441 * num_gamma=num_gamma, * gamma_max=gamma_max, * gamma_min=gamma_min, # <<<<<<<<<<<<<< * partial_sort=partial_sort, * max_iter=max_iter, */ - __Pyx_TraceLine(427,0,__PYX_ERR(0, 427, __pyx_L1_error)) - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 427, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 441, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma_min, __pyx_t_3) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma_min, __pyx_t_3) < 0) __PYX_ERR(0, 432, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":428 + /* "l0learn/interface.pyx":442 * gamma_max=gamma_max, * gamma_min=gamma_min, * partial_sort=partial_sort, # <<<<<<<<<<<<<< * max_iter=max_iter, * rtol=rtol, */ - __Pyx_TraceLine(428,0,__PYX_ERR(0, 428, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_partial_sort, __pyx_v_partial_sort) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_partial_sort, __pyx_v_partial_sort) < 0) __PYX_ERR(0, 432, __pyx_L1_error) - /* "l0learn/interface.pyx":429 + /* "l0learn/interface.pyx":443 * gamma_min=gamma_min, * partial_sort=partial_sort, * max_iter=max_iter, # <<<<<<<<<<<<<< * rtol=rtol, * atol=atol, */ - __Pyx_TraceLine(429,0,__PYX_ERR(0, 429, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_iter, __pyx_v_max_iter) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_iter, __pyx_v_max_iter) < 0) __PYX_ERR(0, 432, __pyx_L1_error) - /* "l0learn/interface.pyx":430 + /* "l0learn/interface.pyx":444 * partial_sort=partial_sort, * max_iter=max_iter, * rtol=rtol, # <<<<<<<<<<<<<< * atol=atol, * active_set=active_set, */ - __Pyx_TraceLine(430,0,__PYX_ERR(0, 430, __pyx_L1_error)) - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_rtol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 430, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_rtol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 444, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_rtol, __pyx_t_3) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_rtol, __pyx_t_3) < 0) __PYX_ERR(0, 432, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":431 + /* "l0learn/interface.pyx":445 * max_iter=max_iter, * rtol=rtol, * atol=atol, # <<<<<<<<<<<<<< * active_set=active_set, * active_set_num=active_set_num, */ - __Pyx_TraceLine(431,0,__PYX_ERR(0, 431, __pyx_L1_error)) - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_atol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 431, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_atol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 445, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_atol, __pyx_t_3) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_atol, __pyx_t_3) < 0) __PYX_ERR(0, 432, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":432 + /* "l0learn/interface.pyx":446 * rtol=rtol, * atol=atol, * active_set=active_set, # <<<<<<<<<<<<<< * active_set_num=active_set_num, * max_swaps=max_swaps, */ - __Pyx_TraceLine(432,0,__PYX_ERR(0, 432, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_active_set, __pyx_v_active_set) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_active_set, __pyx_v_active_set) < 0) __PYX_ERR(0, 432, __pyx_L1_error) - /* "l0learn/interface.pyx":433 + /* "l0learn/interface.pyx":447 * atol=atol, * active_set=active_set, * active_set_num=active_set_num, # <<<<<<<<<<<<<< * max_swaps=max_swaps, * scale_down_factor=scale_down_factor, */ - __Pyx_TraceLine(433,0,__PYX_ERR(0, 433, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_active_set_num, __pyx_v_active_set_num) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_active_set_num, __pyx_v_active_set_num) < 0) __PYX_ERR(0, 432, __pyx_L1_error) - /* "l0learn/interface.pyx":434 + /* "l0learn/interface.pyx":448 * active_set=active_set, * active_set_num=active_set_num, * max_swaps=max_swaps, # <<<<<<<<<<<<<< * scale_down_factor=scale_down_factor, * screen_size=screen_size, */ - __Pyx_TraceLine(434,0,__PYX_ERR(0, 434, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_swaps, __pyx_v_max_swaps) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_swaps, __pyx_v_max_swaps) < 0) __PYX_ERR(0, 432, __pyx_L1_error) - /* "l0learn/interface.pyx":435 + /* "l0learn/interface.pyx":449 * active_set_num=active_set_num, * max_swaps=max_swaps, * scale_down_factor=scale_down_factor, # <<<<<<<<<<<<<< * screen_size=screen_size, * lambda_grid=lambda_grid, */ - __Pyx_TraceLine(435,0,__PYX_ERR(0, 435, __pyx_L1_error)) - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_scale_down_factor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 435, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_scale_down_factor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 449, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_scale_down_factor, __pyx_t_3) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_scale_down_factor, __pyx_t_3) < 0) __PYX_ERR(0, 432, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":436 + /* "l0learn/interface.pyx":450 * max_swaps=max_swaps, * scale_down_factor=scale_down_factor, * screen_size=screen_size, # <<<<<<<<<<<<<< * lambda_grid=lambda_grid, * exclude_first_k=exclude_first_k, */ - __Pyx_TraceLine(436,0,__PYX_ERR(0, 436, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_screen_size, __pyx_v_screen_size) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_screen_size, __pyx_v_screen_size) < 0) __PYX_ERR(0, 432, __pyx_L1_error) - /* "l0learn/interface.pyx":437 + /* "l0learn/interface.pyx":451 * scale_down_factor=scale_down_factor, * screen_size=screen_size, * lambda_grid=lambda_grid, # <<<<<<<<<<<<<< * exclude_first_k=exclude_first_k, * intercept=intercept, */ - __Pyx_TraceLine(437,0,__PYX_ERR(0, 437, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lambda_grid, __pyx_v_lambda_grid) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lambda_grid, __pyx_v_lambda_grid) < 0) __PYX_ERR(0, 432, __pyx_L1_error) - /* "l0learn/interface.pyx":438 + /* "l0learn/interface.pyx":452 * screen_size=screen_size, * lambda_grid=lambda_grid, * exclude_first_k=exclude_first_k, # <<<<<<<<<<<<<< * intercept=intercept, * lows=lows, */ - __Pyx_TraceLine(438,0,__PYX_ERR(0, 438, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_exclude_first_k, __pyx_v_exclude_first_k) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_exclude_first_k, __pyx_v_exclude_first_k) < 0) __PYX_ERR(0, 432, __pyx_L1_error) - /* "l0learn/interface.pyx":439 + /* "l0learn/interface.pyx":453 * lambda_grid=lambda_grid, * exclude_first_k=exclude_first_k, * intercept=intercept, # <<<<<<<<<<<<<< * lows=lows, * highs=highs) */ - __Pyx_TraceLine(439,0,__PYX_ERR(0, 439, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 432, __pyx_L1_error) - /* "l0learn/interface.pyx":440 + /* "l0learn/interface.pyx":454 * exclude_first_k=exclude_first_k, * intercept=intercept, * lows=lows, # <<<<<<<<<<<<<< * highs=highs) * */ - __Pyx_TraceLine(440,0,__PYX_ERR(0, 440, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lows, __pyx_v_lows) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lows, __pyx_v_lows) < 0) __PYX_ERR(0, 432, __pyx_L1_error) - /* "l0learn/interface.pyx":441 + /* "l0learn/interface.pyx":455 * intercept=intercept, * lows=lows, * highs=highs) # <<<<<<<<<<<<<< * * max_support_size = check["max_support_size"] */ - __Pyx_TraceLine(441,0,__PYX_ERR(0, 441, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_highs, __pyx_v_highs) < 0) __PYX_ERR(0, 418, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_highs, __pyx_v_highs) < 0) __PYX_ERR(0, 432, __pyx_L1_error) - /* "l0learn/interface.pyx":418 + /* "l0learn/interface.pyx":432 * -------- * """ * check = _fit_check(X=X, # <<<<<<<<<<<<<< * y=y, * loss=loss, */ - __Pyx_TraceLine(418,0,__PYX_ERR(0, 418, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 418, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 432, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_check = __pyx_t_3; __pyx_t_3 = 0; - /* "l0learn/interface.pyx":443 + /* "l0learn/interface.pyx":457 * highs=highs) * * max_support_size = check["max_support_size"] # <<<<<<<<<<<<<< * screen_size = check["screen_size"] * y = check['y'] */ - __Pyx_TraceLine(443,0,__PYX_ERR(0, 443, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_max_support_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 443, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_max_support_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 457, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_max_support_size, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":444 + /* "l0learn/interface.pyx":458 * * max_support_size = check["max_support_size"] * screen_size = check["screen_size"] # <<<<<<<<<<<<<< * y = check['y'] * penalty = check['penalty'] */ - __Pyx_TraceLine(444,0,__PYX_ERR(0, 444, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_screen_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 444, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_screen_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 458, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_screen_size, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":445 + /* "l0learn/interface.pyx":459 * max_support_size = check["max_support_size"] * screen_size = check["screen_size"] * y = check['y'] # <<<<<<<<<<<<<< * penalty = check['penalty'] * gamma_max = check['gamma_max'] */ - __Pyx_TraceLine(445,0,__PYX_ERR(0, 445, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_y); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 445, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_y); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 459, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_y, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":446 + /* "l0learn/interface.pyx":460 * screen_size = check["screen_size"] * y = check['y'] * penalty = check['penalty'] # <<<<<<<<<<<<<< * gamma_max = check['gamma_max'] * gamma_min = check['gamma_min'] */ - __Pyx_TraceLine(446,0,__PYX_ERR(0, 446, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_penalty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 446, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_penalty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 460, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (!(likely(PyUnicode_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(0, 446, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(0, 460, __pyx_L1_error) __Pyx_DECREF_SET(__pyx_v_penalty, ((PyObject*)__pyx_t_3)); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":447 + /* "l0learn/interface.pyx":461 * y = check['y'] * penalty = check['penalty'] * gamma_max = check['gamma_max'] # <<<<<<<<<<<<<< * gamma_min = check['gamma_min'] * lambda_grid = check['lambda_grid'] */ - __Pyx_TraceLine(447,0,__PYX_ERR(0, 447, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 447, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 461, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 447, __pyx_L1_error) + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 461, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_gamma_max = __pyx_t_4; - /* "l0learn/interface.pyx":448 + /* "l0learn/interface.pyx":462 * penalty = check['penalty'] * gamma_max = check['gamma_max'] * gamma_min = check['gamma_min'] # <<<<<<<<<<<<<< * lambda_grid = check['lambda_grid'] * num_gamma = check['num_gamma'] */ - __Pyx_TraceLine(448,0,__PYX_ERR(0, 448, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_gamma_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 448, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_gamma_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 462, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 448, __pyx_L1_error) + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 462, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_gamma_min = __pyx_t_4; - /* "l0learn/interface.pyx":449 + /* "l0learn/interface.pyx":463 * gamma_max = check['gamma_max'] * gamma_min = check['gamma_min'] * lambda_grid = check['lambda_grid'] # <<<<<<<<<<<<<< * num_gamma = check['num_gamma'] * num_lambda = check['num_lambda'] */ - __Pyx_TraceLine(449,0,__PYX_ERR(0, 449, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_lambda_grid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 449, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_lambda_grid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 463, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_lambda_grid, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":450 + /* "l0learn/interface.pyx":464 * gamma_min = check['gamma_min'] * lambda_grid = check['lambda_grid'] * num_gamma = check['num_gamma'] # <<<<<<<<<<<<<< * num_lambda = check['num_lambda'] * auto_lambda = check['auto_lambda'] */ - __Pyx_TraceLine(450,0,__PYX_ERR(0, 450, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_num_gamma); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 450, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_num_gamma); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 464, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_num_gamma, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":451 + /* "l0learn/interface.pyx":465 * lambda_grid = check['lambda_grid'] * num_gamma = check['num_gamma'] * num_lambda = check['num_lambda'] # <<<<<<<<<<<<<< * auto_lambda = check['auto_lambda'] * with_bounds = check['with_bounds'] */ - __Pyx_TraceLine(451,0,__PYX_ERR(0, 451, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_num_lambda); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 451, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_num_lambda); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 465, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_num_lambda, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":452 + /* "l0learn/interface.pyx":466 * num_gamma = check['num_gamma'] * num_lambda = check['num_lambda'] * auto_lambda = check['auto_lambda'] # <<<<<<<<<<<<<< * with_bounds = check['with_bounds'] * lows = check['lows'] */ - __Pyx_TraceLine(452,0,__PYX_ERR(0, 452, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_auto_lambda); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 452, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_auto_lambda); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 466, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_auto_lambda = __pyx_t_3; __pyx_t_3 = 0; - /* "l0learn/interface.pyx":453 + /* "l0learn/interface.pyx":467 * num_lambda = check['num_lambda'] * auto_lambda = check['auto_lambda'] * with_bounds = check['with_bounds'] # <<<<<<<<<<<<<< * lows = check['lows'] * highs = check['highs'] */ - __Pyx_TraceLine(453,0,__PYX_ERR(0, 453, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_with_bounds); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 453, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_with_bounds); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 467, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_with_bounds = __pyx_t_3; __pyx_t_3 = 0; - /* "l0learn/interface.pyx":454 + /* "l0learn/interface.pyx":468 * auto_lambda = check['auto_lambda'] * with_bounds = check['with_bounds'] * lows = check['lows'] # <<<<<<<<<<<<<< * highs = check['highs'] * */ - __Pyx_TraceLine(454,0,__PYX_ERR(0, 454, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_lows); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 454, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_lows); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 468, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":455 + /* "l0learn/interface.pyx":469 * with_bounds = check['with_bounds'] * lows = check['lows'] * highs = check['highs'] # <<<<<<<<<<<<<< * * cdef vector[vector[double]] c_lambda_grid */ - __Pyx_TraceLine(455,0,__PYX_ERR(0, 455, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_highs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 455, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_highs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 469, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":458 + /* "l0learn/interface.pyx":472 * * cdef vector[vector[double]] c_lambda_grid * try: # <<<<<<<<<<<<<< * c_lambda_grid = lambda_grid * except TypeError: */ - __Pyx_TraceLine(458,0,__PYX_ERR(0, 458, __pyx_L1_error)) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign @@ -8249,18 +7243,17 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx __Pyx_XGOTREF(__pyx_t_7); /*try:*/ { - /* "l0learn/interface.pyx":459 + /* "l0learn/interface.pyx":473 * cdef vector[vector[double]] c_lambda_grid * try: * c_lambda_grid = lambda_grid # <<<<<<<<<<<<<< * except TypeError: * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") */ - __Pyx_TraceLine(459,0,__PYX_ERR(0, 459, __pyx_L3_error)) - __pyx_t_8 = __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_lambda_grid); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 459, __pyx_L3_error) + __pyx_t_8 = __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_lambda_grid); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 473, __pyx_L3_error) __pyx_v_c_lambda_grid = __pyx_t_8; - /* "l0learn/interface.pyx":458 + /* "l0learn/interface.pyx":472 * * cdef vector[vector[double]] c_lambda_grid * try: # <<<<<<<<<<<<<< @@ -8277,46 +7270,44 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":460 + /* "l0learn/interface.pyx":474 * try: * c_lambda_grid = lambda_grid * except TypeError: # <<<<<<<<<<<<<< * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") * */ - __Pyx_TraceLine(460,0,__PYX_ERR(0, 460, __pyx_L5_except_error)) __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); if (__pyx_t_9) { __Pyx_AddTraceback("l0learn.interface.fit", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_2, &__pyx_t_1) < 0) __PYX_ERR(0, 460, __pyx_L5_except_error) + if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_2, &__pyx_t_1) < 0) __PYX_ERR(0, 474, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GOTREF(__pyx_t_2); __Pyx_GOTREF(__pyx_t_1); - /* "l0learn/interface.pyx":461 + /* "l0learn/interface.pyx":475 * c_lambda_grid = lambda_grid * except TypeError: * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") # <<<<<<<<<<<<<< * * cdef string c_loss = loss.encode('UTF-8') */ - __Pyx_TraceLine(461,0,__PYX_ERR(0, 461, __pyx_L5_except_error)) - __pyx_t_10 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 461, __pyx_L5_except_error) + __pyx_t_10 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 475, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_10); - __pyx_t_11 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_be_a_lis, __pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 461, __pyx_L5_except_error) + __pyx_t_11 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_be_a_lis, __pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 475, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_11); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 461, __pyx_L5_except_error) + __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_11); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 475, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_Raise(__pyx_t_10, 0, 0, 0); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __PYX_ERR(0, 461, __pyx_L5_except_error) + __PYX_ERR(0, 475, __pyx_L5_except_error) } goto __pyx_L5_except_error; __pyx_L5_except_error:; - /* "l0learn/interface.pyx":458 + /* "l0learn/interface.pyx":472 * * cdef vector[vector[double]] c_lambda_grid * try: # <<<<<<<<<<<<<< @@ -8331,259 +7322,237 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx __pyx_L8_try_end:; } - /* "l0learn/interface.pyx":463 + /* "l0learn/interface.pyx":477 * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") * * cdef string c_loss = loss.encode('UTF-8') # <<<<<<<<<<<<<< * cdef string c_penalty = penalty.encode('UTF-8') * cdef string c_algorithim = algorithm.encode('UTF-8') */ - __Pyx_TraceLine(463,0,__PYX_ERR(0, 463, __pyx_L1_error)) if (unlikely(__pyx_v_loss == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 463, __pyx_L1_error) + __PYX_ERR(0, 477, __pyx_L1_error) } - __pyx_t_1 = PyUnicode_AsUTF8String(__pyx_v_loss); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 463, __pyx_L1_error) + __pyx_t_1 = PyUnicode_AsUTF8String(__pyx_v_loss); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 477, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_12 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 463, __pyx_L1_error) + __pyx_t_12 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 477, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_c_loss = __pyx_t_12; - /* "l0learn/interface.pyx":464 + /* "l0learn/interface.pyx":478 * * cdef string c_loss = loss.encode('UTF-8') * cdef string c_penalty = penalty.encode('UTF-8') # <<<<<<<<<<<<<< * cdef string c_algorithim = algorithm.encode('UTF-8') * */ - __Pyx_TraceLine(464,0,__PYX_ERR(0, 464, __pyx_L1_error)) if (unlikely(__pyx_v_penalty == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 464, __pyx_L1_error) + __PYX_ERR(0, 478, __pyx_L1_error) } - __pyx_t_1 = PyUnicode_AsUTF8String(__pyx_v_penalty); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 464, __pyx_L1_error) + __pyx_t_1 = PyUnicode_AsUTF8String(__pyx_v_penalty); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 478, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_12 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 464, __pyx_L1_error) + __pyx_t_12 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 478, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_c_penalty = __pyx_t_12; - /* "l0learn/interface.pyx":465 + /* "l0learn/interface.pyx":479 * cdef string c_loss = loss.encode('UTF-8') * cdef string c_penalty = penalty.encode('UTF-8') * cdef string c_algorithim = algorithm.encode('UTF-8') # <<<<<<<<<<<<<< * * cdef fitmodel c_results */ - __Pyx_TraceLine(465,0,__PYX_ERR(0, 465, __pyx_L1_error)) if (unlikely(__pyx_v_algorithm == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 465, __pyx_L1_error) + __PYX_ERR(0, 479, __pyx_L1_error) } - __pyx_t_1 = PyUnicode_AsUTF8String(__pyx_v_algorithm); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 465, __pyx_L1_error) + __pyx_t_1 = PyUnicode_AsUTF8String(__pyx_v_algorithm); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 479, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_12 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 465, __pyx_L1_error) + __pyx_t_12 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 479, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_c_algorithim = __pyx_t_12; - /* "l0learn/interface.pyx":468 + /* "l0learn/interface.pyx":482 * * cdef fitmodel c_results * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), * y=numpy_to_dvec_d(y), */ - __Pyx_TraceLine(468,0,__PYX_ERR(0, 468, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 468, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 482, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 468, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 482, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_13 = PyObject_IsInstance(__pyx_v_X, __pyx_t_2); if (unlikely(__pyx_t_13 == ((int)-1))) __PYX_ERR(0, 468, __pyx_L1_error) + __pyx_t_13 = PyObject_IsInstance(__pyx_v_X, __pyx_t_2); if (unlikely(__pyx_t_13 == ((int)-1))) __PYX_ERR(0, 482, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_14 = (__pyx_t_13 != 0); if (__pyx_t_14) { - /* "l0learn/interface.pyx":469 + /* "l0learn/interface.pyx":483 * cdef fitmodel c_results * if isinstance(X, np.ndarray): * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< * y=numpy_to_dvec_d(y), * Loss=c_loss, */ - __Pyx_TraceLine(469,0,__PYX_ERR(0, 469, __pyx_L1_error)) - if (!(likely(((__pyx_v_X) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_X, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 469, __pyx_L1_error) + if (!(likely(((__pyx_v_X) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_X, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 483, __pyx_L1_error) - /* "l0learn/interface.pyx":470 + /* "l0learn/interface.pyx":484 * if isinstance(X, np.ndarray): * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), * y=numpy_to_dvec_d(y), # <<<<<<<<<<<<<< * Loss=c_loss, * Penalty=c_penalty, */ - __Pyx_TraceLine(470,0,__PYX_ERR(0, 470, __pyx_L1_error)) - if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 470, __pyx_L1_error) + if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 484, __pyx_L1_error) - /* "l0learn/interface.pyx":474 + /* "l0learn/interface.pyx":488 * Penalty=c_penalty, * Algorithm=c_algorithim, * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< * G_ncols=num_lambda, * G_nrows=num_gamma, */ - __Pyx_TraceLine(474,0,__PYX_ERR(0, 474, __pyx_L1_error)) - __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 474, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 488, __pyx_L1_error) - /* "l0learn/interface.pyx":475 + /* "l0learn/interface.pyx":489 * Algorithm=c_algorithim, * NnzStopNum=max_support_size, * G_ncols=num_lambda, # <<<<<<<<<<<<<< * G_nrows=num_gamma, * Lambda2Max=gamma_max, */ - __Pyx_TraceLine(475,0,__PYX_ERR(0, 475, __pyx_L1_error)) - __pyx_t_16 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_16 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 475, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_16 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 489, __pyx_L1_error) - /* "l0learn/interface.pyx":476 + /* "l0learn/interface.pyx":490 * NnzStopNum=max_support_size, * G_ncols=num_lambda, * G_nrows=num_gamma, # <<<<<<<<<<<<<< * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, */ - __Pyx_TraceLine(476,0,__PYX_ERR(0, 476, __pyx_L1_error)) - __pyx_t_17 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_17 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 476, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_17 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 490, __pyx_L1_error) - /* "l0learn/interface.pyx":479 + /* "l0learn/interface.pyx":493 * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, * PartialSort=partial_sort, # <<<<<<<<<<<<<< * MaxIters=max_iter, * rtol=rtol, */ - __Pyx_TraceLine(479,0,__PYX_ERR(0, 479, __pyx_L1_error)) - __pyx_t_18 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_18 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 479, __pyx_L1_error) + __pyx_t_18 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_18 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 493, __pyx_L1_error) - /* "l0learn/interface.pyx":480 + /* "l0learn/interface.pyx":494 * Lambda2Min=gamma_min, * PartialSort=partial_sort, * MaxIters=max_iter, # <<<<<<<<<<<<<< * rtol=rtol, * atol=atol, */ - __Pyx_TraceLine(480,0,__PYX_ERR(0, 480, __pyx_L1_error)) - __pyx_t_19 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_19 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 480, __pyx_L1_error) + __pyx_t_19 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_19 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 494, __pyx_L1_error) - /* "l0learn/interface.pyx":483 + /* "l0learn/interface.pyx":497 * rtol=rtol, * atol=atol, * ActiveSet=active_set, # <<<<<<<<<<<<<< * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, */ - __Pyx_TraceLine(483,0,__PYX_ERR(0, 483, __pyx_L1_error)) - __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_20 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 483, __pyx_L1_error) + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_20 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 497, __pyx_L1_error) - /* "l0learn/interface.pyx":484 + /* "l0learn/interface.pyx":498 * atol=atol, * ActiveSet=active_set, * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, */ - __Pyx_TraceLine(484,0,__PYX_ERR(0, 484, __pyx_L1_error)) - __pyx_t_21 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_21 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 484, __pyx_L1_error) + __pyx_t_21 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_21 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 498, __pyx_L1_error) - /* "l0learn/interface.pyx":485 + /* "l0learn/interface.pyx":499 * ActiveSet=active_set, * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, */ - __Pyx_TraceLine(485,0,__PYX_ERR(0, 485, __pyx_L1_error)) - __pyx_t_22 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_22 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 485, __pyx_L1_error) + __pyx_t_22 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_22 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 499, __pyx_L1_error) - /* "l0learn/interface.pyx":487 + /* "l0learn/interface.pyx":501 * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, # <<<<<<<<<<<<<< * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, */ - __Pyx_TraceLine(487,0,__PYX_ERR(0, 487, __pyx_L1_error)) - __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 487, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 501, __pyx_L1_error) - /* "l0learn/interface.pyx":488 + /* "l0learn/interface.pyx":502 * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, * LambdaU=not auto_lambda, # <<<<<<<<<<<<<< * Lambdas=c_lambda_grid, * ExcludeFirstK=exclude_first_k, */ - __Pyx_TraceLine(488,0,__PYX_ERR(0, 488, __pyx_L1_error)) - __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 488, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 502, __pyx_L1_error) - /* "l0learn/interface.pyx":490 + /* "l0learn/interface.pyx":504 * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< * Intercept=intercept, * withBounds=with_bounds, */ - __Pyx_TraceLine(490,0,__PYX_ERR(0, 490, __pyx_L1_error)) - __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 490, __pyx_L1_error) + __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 504, __pyx_L1_error) - /* "l0learn/interface.pyx":491 + /* "l0learn/interface.pyx":505 * Lambdas=c_lambda_grid, * ExcludeFirstK=exclude_first_k, * Intercept=intercept, # <<<<<<<<<<<<<< * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), */ - __Pyx_TraceLine(491,0,__PYX_ERR(0, 491, __pyx_L1_error)) - __pyx_t_25 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_25 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 491, __pyx_L1_error) + __pyx_t_25 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_25 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 505, __pyx_L1_error) - /* "l0learn/interface.pyx":492 + /* "l0learn/interface.pyx":506 * ExcludeFirstK=exclude_first_k, * Intercept=intercept, * withBounds=with_bounds, # <<<<<<<<<<<<<< * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) */ - __Pyx_TraceLine(492,0,__PYX_ERR(0, 492, __pyx_L1_error)) - __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 492, __pyx_L1_error) + __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 506, __pyx_L1_error) - /* "l0learn/interface.pyx":493 + /* "l0learn/interface.pyx":507 * Intercept=intercept, * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< * Highs=numpy_to_dvec_d(highs)) * else: # isinstance(X, csc_matrix) */ - __Pyx_TraceLine(493,0,__PYX_ERR(0, 493, __pyx_L1_error)) - if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 493, __pyx_L1_error) + if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 507, __pyx_L1_error) - /* "l0learn/interface.pyx":494 + /* "l0learn/interface.pyx":508 * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< * else: # isinstance(X, csc_matrix) * c_results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), */ - __Pyx_TraceLine(494,0,__PYX_ERR(0, 494, __pyx_L1_error)) - if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 494, __pyx_L1_error) + if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 508, __pyx_L1_error) - /* "l0learn/interface.pyx":469 + /* "l0learn/interface.pyx":483 * cdef fitmodel c_results * if isinstance(X, np.ndarray): * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< * y=numpy_to_dvec_d(y), * Loss=c_loss, */ - __Pyx_TraceLine(469,0,__PYX_ERR(0, 469, __pyx_L1_error)) __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnFit_dense(__pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_X)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_15, __pyx_t_16, __pyx_t_17, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_18, __pyx_t_19, __pyx_v_rtol, __pyx_v_atol, __pyx_t_20, __pyx_t_21, __pyx_t_22, __pyx_v_scale_down_factor, __pyx_t_23, (!__pyx_t_14), __pyx_v_c_lambda_grid, __pyx_t_24, __pyx_t_25, __pyx_t_26, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); - /* "l0learn/interface.pyx":468 + /* "l0learn/interface.pyx":482 * * cdef fitmodel c_results * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< @@ -8593,315 +7562,288 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx goto __pyx_L11; } - /* "l0learn/interface.pyx":496 + /* "l0learn/interface.pyx":510 * Highs=numpy_to_dvec_d(highs)) * else: # isinstance(X, csc_matrix) * c_results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< * y=numpy_to_dvec_d(y), * Loss=c_loss, */ - __Pyx_TraceLine(496,0,__PYX_ERR(0, 496, __pyx_L1_error)) /*else*/ { - /* "l0learn/interface.pyx":497 + /* "l0learn/interface.pyx":511 * else: # isinstance(X, csc_matrix) * c_results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), * y=numpy_to_dvec_d(y), # <<<<<<<<<<<<<< * Loss=c_loss, * Penalty=c_penalty, */ - __Pyx_TraceLine(497,0,__PYX_ERR(0, 497, __pyx_L1_error)) - if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 497, __pyx_L1_error) + if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 511, __pyx_L1_error) - /* "l0learn/interface.pyx":501 + /* "l0learn/interface.pyx":515 * Penalty=c_penalty, * Algorithm=c_algorithim, * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< * G_ncols=num_lambda, * G_nrows=num_gamma, */ - __Pyx_TraceLine(501,0,__PYX_ERR(0, 501, __pyx_L1_error)) - __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 501, __pyx_L1_error) + __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 515, __pyx_L1_error) - /* "l0learn/interface.pyx":502 + /* "l0learn/interface.pyx":516 * Algorithm=c_algorithim, * NnzStopNum=max_support_size, * G_ncols=num_lambda, # <<<<<<<<<<<<<< * G_nrows=num_gamma, * Lambda2Max=gamma_max, */ - __Pyx_TraceLine(502,0,__PYX_ERR(0, 502, __pyx_L1_error)) - __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 502, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 516, __pyx_L1_error) - /* "l0learn/interface.pyx":503 + /* "l0learn/interface.pyx":517 * NnzStopNum=max_support_size, * G_ncols=num_lambda, * G_nrows=num_gamma, # <<<<<<<<<<<<<< * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, */ - __Pyx_TraceLine(503,0,__PYX_ERR(0, 503, __pyx_L1_error)) - __pyx_t_22 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_22 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 503, __pyx_L1_error) + __pyx_t_22 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_22 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 517, __pyx_L1_error) - /* "l0learn/interface.pyx":506 + /* "l0learn/interface.pyx":520 * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, * PartialSort=partial_sort, # <<<<<<<<<<<<<< * MaxIters=max_iter, * rtol=rtol, */ - __Pyx_TraceLine(506,0,__PYX_ERR(0, 506, __pyx_L1_error)) - __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 506, __pyx_L1_error) + __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 520, __pyx_L1_error) - /* "l0learn/interface.pyx":507 + /* "l0learn/interface.pyx":521 * Lambda2Min=gamma_min, * PartialSort=partial_sort, * MaxIters=max_iter, # <<<<<<<<<<<<<< * rtol=rtol, * atol=atol, */ - __Pyx_TraceLine(507,0,__PYX_ERR(0, 507, __pyx_L1_error)) - __pyx_t_21 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_21 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 507, __pyx_L1_error) + __pyx_t_21 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_21 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 521, __pyx_L1_error) - /* "l0learn/interface.pyx":510 + /* "l0learn/interface.pyx":524 * rtol=rtol, * atol=atol, * ActiveSet=active_set, # <<<<<<<<<<<<<< * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, */ - __Pyx_TraceLine(510,0,__PYX_ERR(0, 510, __pyx_L1_error)) - __pyx_t_25 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_25 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 510, __pyx_L1_error) + __pyx_t_25 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_25 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 524, __pyx_L1_error) - /* "l0learn/interface.pyx":511 + /* "l0learn/interface.pyx":525 * atol=atol, * ActiveSet=active_set, * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, */ - __Pyx_TraceLine(511,0,__PYX_ERR(0, 511, __pyx_L1_error)) - __pyx_t_19 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_19 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 511, __pyx_L1_error) + __pyx_t_19 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_19 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 525, __pyx_L1_error) - /* "l0learn/interface.pyx":512 + /* "l0learn/interface.pyx":526 * ActiveSet=active_set, * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, */ - __Pyx_TraceLine(512,0,__PYX_ERR(0, 512, __pyx_L1_error)) - __pyx_t_17 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_17 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 512, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_17 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 526, __pyx_L1_error) - /* "l0learn/interface.pyx":514 + /* "l0learn/interface.pyx":528 * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, # <<<<<<<<<<<<<< * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, */ - __Pyx_TraceLine(514,0,__PYX_ERR(0, 514, __pyx_L1_error)) - __pyx_t_16 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_16 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 514, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_16 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 528, __pyx_L1_error) - /* "l0learn/interface.pyx":515 + /* "l0learn/interface.pyx":529 * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, * LambdaU=not auto_lambda, # <<<<<<<<<<<<<< * Lambdas=c_lambda_grid, * ExcludeFirstK=exclude_first_k, */ - __Pyx_TraceLine(515,0,__PYX_ERR(0, 515, __pyx_L1_error)) - __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 515, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 529, __pyx_L1_error) - /* "l0learn/interface.pyx":517 + /* "l0learn/interface.pyx":531 * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< * Intercept=intercept, * withBounds=with_bounds, */ - __Pyx_TraceLine(517,0,__PYX_ERR(0, 517, __pyx_L1_error)) - __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 517, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 531, __pyx_L1_error) - /* "l0learn/interface.pyx":518 + /* "l0learn/interface.pyx":532 * Lambdas=c_lambda_grid, * ExcludeFirstK=exclude_first_k, * Intercept=intercept, # <<<<<<<<<<<<<< * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), */ - __Pyx_TraceLine(518,0,__PYX_ERR(0, 518, __pyx_L1_error)) - __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_20 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 518, __pyx_L1_error) + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_20 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 532, __pyx_L1_error) - /* "l0learn/interface.pyx":519 + /* "l0learn/interface.pyx":533 * ExcludeFirstK=exclude_first_k, * Intercept=intercept, * withBounds=with_bounds, # <<<<<<<<<<<<<< * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) */ - __Pyx_TraceLine(519,0,__PYX_ERR(0, 519, __pyx_L1_error)) - __pyx_t_18 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_18 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 519, __pyx_L1_error) + __pyx_t_18 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_18 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 533, __pyx_L1_error) - /* "l0learn/interface.pyx":520 + /* "l0learn/interface.pyx":534 * Intercept=intercept, * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< * Highs=numpy_to_dvec_d(highs)) * */ - __Pyx_TraceLine(520,0,__PYX_ERR(0, 520, __pyx_L1_error)) - if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 520, __pyx_L1_error) + if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 534, __pyx_L1_error) - /* "l0learn/interface.pyx":521 + /* "l0learn/interface.pyx":535 * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< * * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, */ - __Pyx_TraceLine(521,0,__PYX_ERR(0, 521, __pyx_L1_error)) - if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 521, __pyx_L1_error) + if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 535, __pyx_L1_error) - /* "l0learn/interface.pyx":496 + /* "l0learn/interface.pyx":510 * Highs=numpy_to_dvec_d(highs)) * else: # isinstance(X, csc_matrix) * c_results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< * y=numpy_to_dvec_d(y), * Loss=c_loss, */ - __Pyx_TraceLine(496,0,__PYX_ERR(0, 496, __pyx_L1_error)) __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnFit_sparse(__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(__pyx_v_X), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_24, __pyx_t_23, __pyx_t_22, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_26, __pyx_t_21, __pyx_v_rtol, __pyx_v_atol, __pyx_t_25, __pyx_t_19, __pyx_t_17, __pyx_v_scale_down_factor, __pyx_t_16, (!__pyx_t_14), __pyx_v_c_lambda_grid, __pyx_t_15, __pyx_t_20, __pyx_t_18, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); } __pyx_L11:; - /* "l0learn/interface.pyx":523 + /* "l0learn/interface.pyx":537 * Highs=numpy_to_dvec_d(highs)) * * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, # <<<<<<<<<<<<<< * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, */ - __Pyx_TraceLine(523,0,__PYX_ERR(0, 523, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_FitModel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_FitModel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 537, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 523, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 537, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 523, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 537, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 523, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 523, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 523, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_settings, __pyx_t_3) < 0) __PYX_ERR(0, 523, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 537, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 537, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 537, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_settings, __pyx_t_3) < 0) __PYX_ERR(0, 537, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":524 + /* "l0learn/interface.pyx":538 * * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, * lambda_0=c_results.Lambda0, # <<<<<<<<<<<<<< * gamma=c_results.Lambda12, * support_size=c_results.NnzCount, */ - __Pyx_TraceLine(524,0,__PYX_ERR(0, 524, __pyx_L1_error)) - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Lambda0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 524, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Lambda0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 538, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_lambda_0, __pyx_t_3) < 0) __PYX_ERR(0, 523, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_lambda_0, __pyx_t_3) < 0) __PYX_ERR(0, 537, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":525 + /* "l0learn/interface.pyx":539 * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, # <<<<<<<<<<<<<< * support_size=c_results.NnzCount, * coeffs=sp_dmat_field_to_list(c_results.Beta), */ - __Pyx_TraceLine(525,0,__PYX_ERR(0, 525, __pyx_L1_error)) - __pyx_t_3 = __pyx_convert_vector_to_py_double(__pyx_v_c_results.Lambda12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 525, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_double(__pyx_v_c_results.Lambda12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 539, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_gamma, __pyx_t_3) < 0) __PYX_ERR(0, 523, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_gamma, __pyx_t_3) < 0) __PYX_ERR(0, 537, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":526 + /* "l0learn/interface.pyx":540 * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, * support_size=c_results.NnzCount, # <<<<<<<<<<<<<< * coeffs=sp_dmat_field_to_list(c_results.Beta), * intercepts=c_results.Intercept, */ - __Pyx_TraceLine(526,0,__PYX_ERR(0, 526, __pyx_L1_error)) - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(__pyx_v_c_results.NnzCount); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 526, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(__pyx_v_c_results.NnzCount); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 540, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_support_size, __pyx_t_3) < 0) __PYX_ERR(0, 523, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_support_size, __pyx_t_3) < 0) __PYX_ERR(0, 537, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":527 + /* "l0learn/interface.pyx":541 * gamma=c_results.Lambda12, * support_size=c_results.NnzCount, * coeffs=sp_dmat_field_to_list(c_results.Beta), # <<<<<<<<<<<<<< * intercepts=c_results.Intercept, * converged=c_results.Converged) */ - __Pyx_TraceLine(527,0,__PYX_ERR(0, 527, __pyx_L1_error)) - __pyx_t_3 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_c_results.Beta); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 527, __pyx_L1_error) + __pyx_t_3 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_c_results.Beta); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 541, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_coeffs, __pyx_t_3) < 0) __PYX_ERR(0, 523, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_coeffs, __pyx_t_3) < 0) __PYX_ERR(0, 537, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":528 + /* "l0learn/interface.pyx":542 * support_size=c_results.NnzCount, * coeffs=sp_dmat_field_to_list(c_results.Beta), * intercepts=c_results.Intercept, # <<<<<<<<<<<<<< * converged=c_results.Converged) * return results */ - __Pyx_TraceLine(528,0,__PYX_ERR(0, 528, __pyx_L1_error)) - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Intercept); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 528, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Intercept); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 542, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_intercepts, __pyx_t_3) < 0) __PYX_ERR(0, 523, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_intercepts, __pyx_t_3) < 0) __PYX_ERR(0, 537, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":529 + /* "l0learn/interface.pyx":543 * coeffs=sp_dmat_field_to_list(c_results.Beta), * intercepts=c_results.Intercept, * converged=c_results.Converged) # <<<<<<<<<<<<<< * return results * */ - __Pyx_TraceLine(529,0,__PYX_ERR(0, 529, __pyx_L1_error)) - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(__pyx_v_c_results.Converged); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 529, __pyx_L1_error) + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(__pyx_v_c_results.Converged); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 543, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_converged, __pyx_t_3) < 0) __PYX_ERR(0, 523, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_converged, __pyx_t_3) < 0) __PYX_ERR(0, 537, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":523 + /* "l0learn/interface.pyx":537 * Highs=numpy_to_dvec_d(highs)) * * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, # <<<<<<<<<<<<<< * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, */ - __Pyx_TraceLine(523,0,__PYX_ERR(0, 523, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 523, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 537, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_results = __pyx_t_3; __pyx_t_3 = 0; - /* "l0learn/interface.pyx":530 + /* "l0learn/interface.pyx":544 * intercepts=c_results.Intercept, * converged=c_results.Converged) * return results # <<<<<<<<<<<<<< * * */ - __Pyx_TraceLine(530,0,__PYX_ERR(0, 530, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_results); __pyx_r = __pyx_v_results; goto __pyx_L0; - /* "l0learn/interface.pyx":247 + /* "l0learn/interface.pyx":261 * * * def fit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< @@ -8933,12 +7875,11 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx __Pyx_XDECREF(__pyx_v_lows); __Pyx_XDECREF(__pyx_v_highs); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "l0learn/interface.pyx":533 +/* "l0learn/interface.pyx":547 * * * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< @@ -8947,10 +7888,10 @@ static PyObject *__pyx_pf_7l0learn_9interface_4fit(CYTHON_UNUSED PyObject *__pyx */ /* Python wrapper */ -static PyObject *__pyx_pw_7l0learn_9interface_7cvfit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_7l0learn_9interface_6cvfit[] = "cvfit(X: Union[np.ndarray, csc_matrix], y: np.ndarray, unicode loss: str = u'SquaredError', unicode penalty: str = u'L0', unicode algorithm: str = u'CD', num_folds: int = 10, seed: int = 1, max_support_size: int = 100, num_lambda: Optional[int] = 100, num_gamma: Optional[int] = 1, double gamma_max: float = 10., double gamma_min: float = .0001, partial_sort: bool = True, max_iter: int = 200, double rtol: float = 1e-6, double atol: float = 1e-9, active_set: bool = True, active_set_num: int = 3, max_swaps: int = 100, double scale_down_factor: float = 0.8, screen_size: int = 1000, lambda_grid: Optional[List[List[float]]] = None, exclude_first_k: int = 0, intercept: bool = True, lows: Union[np.ndarray, float] = -float(u'inf'), highs: Union[np.ndarray, float] = +float(u'inf')) -> l0learn.models.CVFitModel"; -static PyMethodDef __pyx_mdef_7l0learn_9interface_7cvfit = {"cvfit", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7l0learn_9interface_7cvfit, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7l0learn_9interface_6cvfit}; -static PyObject *__pyx_pw_7l0learn_9interface_7cvfit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_7l0learn_9interface_4cvfit[] = "cvfit(X: Union[np.ndarray, csc_matrix], y: np.ndarray, unicode loss: str = u'SquaredError', unicode penalty: str = u'L0', unicode algorithm: str = u'CD', num_folds: int = 10, seed: int = 1, max_support_size: int = 100, num_lambda: Optional[int] = 100, num_gamma: Optional[int] = 1, double gamma_max: float = 10., double gamma_min: float = .0001, partial_sort: bool = True, max_iter: int = 200, double rtol: float = 1e-6, double atol: float = 1e-9, active_set: bool = True, active_set_num: int = 3, max_swaps: int = 100, double scale_down_factor: float = 0.8, screen_size: int = 1000, lambda_grid: Optional[List[List[float]]] = None, exclude_first_k: int = 0, intercept: bool = True, lows: Union[np.ndarray, float] = -float(u'inf'), highs: Union[np.ndarray, float] = +float(u'inf')) -> l0learn.models.CVFitModel"; +static PyMethodDef __pyx_mdef_7l0learn_9interface_5cvfit = {"cvfit", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7l0learn_9interface_5cvfit, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7l0learn_9interface_4cvfit}; +static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_X = 0; PyObject *__pyx_v_y = 0; PyObject *__pyx_v_loss = 0; @@ -8995,7 +7936,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_7cvfit(PyObject *__pyx_self, PyObj values[8] = ((PyObject *)__pyx_int_100); values[9] = ((PyObject *)__pyx_int_1); - /* "l0learn/interface.pyx":545 + /* "l0learn/interface.pyx":559 * gamma_max: float = 10., * gamma_min: float = .0001, * partial_sort: bool = True, # <<<<<<<<<<<<<< @@ -9005,7 +7946,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_7cvfit(PyObject *__pyx_self, PyObj values[12] = ((PyObject *)Py_True); values[13] = ((PyObject *)__pyx_int_200); - /* "l0learn/interface.pyx":549 + /* "l0learn/interface.pyx":563 * rtol: float = 1e-6, * atol: float = 1e-9, * active_set: bool = True, # <<<<<<<<<<<<<< @@ -9017,7 +7958,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_7cvfit(PyObject *__pyx_self, PyObj values[18] = ((PyObject *)__pyx_int_100); values[20] = ((PyObject *)__pyx_int_1000); - /* "l0learn/interface.pyx":554 + /* "l0learn/interface.pyx":568 * scale_down_factor: float = 0.8, * screen_size: int = 1000, * lambda_grid: Optional[List[List[float]]] = None, # <<<<<<<<<<<<<< @@ -9027,7 +7968,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_7cvfit(PyObject *__pyx_self, PyObj values[21] = ((PyObject *)Py_None); values[22] = ((PyObject *)__pyx_int_0); - /* "l0learn/interface.pyx":556 + /* "l0learn/interface.pyx":570 * lambda_grid: Optional[List[List[float]]] = None, * exclude_first_k: int = 0, * intercept: bool = True, # <<<<<<<<<<<<<< @@ -9035,8 +7976,8 @@ static PyObject *__pyx_pw_7l0learn_9interface_7cvfit(PyObject *__pyx_self, PyObj * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.CVFitModel: */ values[23] = ((PyObject *)Py_True); - values[24] = __pyx_k__12; - values[25] = __pyx_k__13; + values[24] = __pyx_k__4; + values[25] = __pyx_k__5; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); @@ -9105,7 +8046,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_7cvfit(PyObject *__pyx_self, PyObj case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("cvfit", 0, 2, 26, 1); __PYX_ERR(0, 533, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("cvfit", 0, 2, 26, 1); __PYX_ERR(0, 547, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: @@ -9253,7 +8194,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_7cvfit(PyObject *__pyx_self, PyObj } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "cvfit") < 0)) __PYX_ERR(0, 533, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "cvfit") < 0)) __PYX_ERR(0, 547, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -9300,1483 +8241,78 @@ static PyObject *__pyx_pw_7l0learn_9interface_7cvfit(PyObject *__pyx_self, PyObj case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); CYTHON_FALLTHROUGH; case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); - CYTHON_FALLTHROUGH; - case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); - CYTHON_FALLTHROUGH; - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } - } - __pyx_v_X = values[0]; - __pyx_v_y = values[1]; - __pyx_v_loss = ((PyObject*)values[2]); - __pyx_v_penalty = ((PyObject*)values[3]); - __pyx_v_algorithm = ((PyObject*)values[4]); - __pyx_v_num_folds = values[5]; - __pyx_v_seed = values[6]; - __pyx_v_max_support_size = values[7]; - __pyx_v_num_lambda = values[8]; - __pyx_v_num_gamma = values[9]; - if (values[10]) { - __pyx_v_gamma_max = __pyx_PyFloat_AsDouble(values[10]); if (unlikely((__pyx_v_gamma_max == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 543, __pyx_L3_error) - } else { - __pyx_v_gamma_max = ((double)10.); - } - if (values[11]) { - __pyx_v_gamma_min = __pyx_PyFloat_AsDouble(values[11]); if (unlikely((__pyx_v_gamma_min == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 544, __pyx_L3_error) - } else { - __pyx_v_gamma_min = ((double).0001); - } - __pyx_v_partial_sort = values[12]; - __pyx_v_max_iter = values[13]; - if (values[14]) { - __pyx_v_rtol = __pyx_PyFloat_AsDouble(values[14]); if (unlikely((__pyx_v_rtol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 547, __pyx_L3_error) - } else { - __pyx_v_rtol = ((double)1e-6); - } - if (values[15]) { - __pyx_v_atol = __pyx_PyFloat_AsDouble(values[15]); if (unlikely((__pyx_v_atol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 548, __pyx_L3_error) - } else { - __pyx_v_atol = ((double)1e-9); - } - __pyx_v_active_set = values[16]; - __pyx_v_active_set_num = values[17]; - __pyx_v_max_swaps = values[18]; - if (values[19]) { - __pyx_v_scale_down_factor = __pyx_PyFloat_AsDouble(values[19]); if (unlikely((__pyx_v_scale_down_factor == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 552, __pyx_L3_error) - } else { - __pyx_v_scale_down_factor = ((double)0.8); - } - __pyx_v_screen_size = values[20]; - __pyx_v_lambda_grid = values[21]; - __pyx_v_exclude_first_k = values[22]; - __pyx_v_intercept = values[23]; - __pyx_v_lows = values[24]; - __pyx_v_highs = values[25]; - } - goto __pyx_L4_argument_unpacking_done; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("cvfit", 0, 2, 26, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 533, __pyx_L3_error) - __pyx_L3_error:; - __Pyx_AddTraceback("l0learn.interface.cvfit", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loss), (&PyUnicode_Type), 1, "loss", 1))) __PYX_ERR(0, 535, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_penalty), (&PyUnicode_Type), 1, "penalty", 1))) __PYX_ERR(0, 536, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_algorithm), (&PyUnicode_Type), 1, "algorithm", 1))) __PYX_ERR(0, 537, __pyx_L1_error) - __pyx_r = __pyx_pf_7l0learn_9interface_6cvfit(__pyx_self, __pyx_v_X, __pyx_v_y, __pyx_v_loss, __pyx_v_penalty, __pyx_v_algorithm, __pyx_v_num_folds, __pyx_v_seed, __pyx_v_max_support_size, __pyx_v_num_lambda, __pyx_v_num_gamma, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_v_partial_sort, __pyx_v_max_iter, __pyx_v_rtol, __pyx_v_atol, __pyx_v_active_set, __pyx_v_active_set_num, __pyx_v_max_swaps, __pyx_v_scale_down_factor, __pyx_v_screen_size, __pyx_v_lambda_grid, __pyx_v_exclude_first_k, __pyx_v_intercept, __pyx_v_lows, __pyx_v_highs); - - /* "l0learn/interface.pyx":533 - * - * - * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< - * y: np.ndarray, - * loss: str = "SquaredError", - */ - - /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - __pyx_r = NULL; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_num_folds, PyObject *__pyx_v_seed, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs) { - PyObject *__pyx_v_check = NULL; - PyObject *__pyx_v_auto_lambda = NULL; - PyObject *__pyx_v_with_bounds = NULL; - CYTHON_UNUSED PyObject *__pyx_v__ = NULL; - PyObject *__pyx_v_p = NULL; - std::vector > __pyx_v_c_lambda_grid; - std::string __pyx_v_c_loss; - std::string __pyx_v_c_penalty; - std::string __pyx_v_c_algorithim; - cvfitmodel __pyx_v_c_results; - PyObject *__pyx_v_results = NULL; - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - double __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - PyObject *(*__pyx_t_6)(PyObject *); - int __pyx_t_7; - int __pyx_t_8; - int __pyx_t_9; - Py_ssize_t __pyx_t_10; - Py_UCS4 __pyx_t_11; - PyObject *__pyx_t_12 = NULL; - PyObject *__pyx_t_13 = NULL; - PyObject *__pyx_t_14 = NULL; - std::vector > __pyx_t_15; - int __pyx_t_16; - PyObject *__pyx_t_17 = NULL; - std::string __pyx_t_18; - size_t __pyx_t_19; - size_t __pyx_t_20; - size_t __pyx_t_21; - bool __pyx_t_22; - size_t __pyx_t_23; - bool __pyx_t_24; - size_t __pyx_t_25; - size_t __pyx_t_26; - size_t __pyx_t_27; - unsigned int __pyx_t_28; - size_t __pyx_t_29; - bool __pyx_t_30; - bool __pyx_t_31; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_TraceFrameInit(__pyx_codeobj__14) - __Pyx_RefNannySetupContext("cvfit", 0); - __Pyx_TraceCall("cvfit", __pyx_f[0], 533, 0, __PYX_ERR(0, 533, __pyx_L1_error)); - __Pyx_INCREF(__pyx_v_y); - __Pyx_INCREF(__pyx_v_penalty); - __Pyx_INCREF(__pyx_v_max_support_size); - __Pyx_INCREF(__pyx_v_num_lambda); - __Pyx_INCREF(__pyx_v_num_gamma); - __Pyx_INCREF(__pyx_v_screen_size); - __Pyx_INCREF(__pyx_v_lambda_grid); - __Pyx_INCREF(__pyx_v_lows); - __Pyx_INCREF(__pyx_v_highs); - - /* "l0learn/interface.pyx":560 - * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.CVFitModel: - * - * check = _fit_check(X=X, # <<<<<<<<<<<<<< - * y=y, - * loss=loss, - */ - __Pyx_TraceLine(560,0,__PYX_ERR(0, 560, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_fit_check); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 560, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyDict_NewPresized(24); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 560, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_X, __pyx_v_X) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - - /* "l0learn/interface.pyx":561 - * - * check = _fit_check(X=X, - * y=y, # <<<<<<<<<<<<<< - * loss=loss, - * penalty=penalty, - */ - __Pyx_TraceLine(561,0,__PYX_ERR(0, 561, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_y, __pyx_v_y) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - - /* "l0learn/interface.pyx":562 - * check = _fit_check(X=X, - * y=y, - * loss=loss, # <<<<<<<<<<<<<< - * penalty=penalty, - * algorithm=algorithm, - */ - __Pyx_TraceLine(562,0,__PYX_ERR(0, 562, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - - /* "l0learn/interface.pyx":563 - * y=y, - * loss=loss, - * penalty=penalty, # <<<<<<<<<<<<<< - * algorithm=algorithm, - * max_support_size=max_support_size, - */ - __Pyx_TraceLine(563,0,__PYX_ERR(0, 563, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - - /* "l0learn/interface.pyx":564 - * loss=loss, - * penalty=penalty, - * algorithm=algorithm, # <<<<<<<<<<<<<< - * max_support_size=max_support_size, - * num_lambda=num_lambda, - */ - __Pyx_TraceLine(564,0,__PYX_ERR(0, 564, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_algorithm, __pyx_v_algorithm) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - - /* "l0learn/interface.pyx":565 - * penalty=penalty, - * algorithm=algorithm, - * max_support_size=max_support_size, # <<<<<<<<<<<<<< - * num_lambda=num_lambda, - * num_gamma=num_gamma, - */ - __Pyx_TraceLine(565,0,__PYX_ERR(0, 565, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_support_size, __pyx_v_max_support_size) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - - /* "l0learn/interface.pyx":566 - * algorithm=algorithm, - * max_support_size=max_support_size, - * num_lambda=num_lambda, # <<<<<<<<<<<<<< - * num_gamma=num_gamma, - * gamma_max=gamma_max, - */ - __Pyx_TraceLine(566,0,__PYX_ERR(0, 566, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_lambda, __pyx_v_num_lambda) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - - /* "l0learn/interface.pyx":567 - * max_support_size=max_support_size, - * num_lambda=num_lambda, - * num_gamma=num_gamma, # <<<<<<<<<<<<<< - * gamma_max=gamma_max, - * gamma_min=gamma_min, - */ - __Pyx_TraceLine(567,0,__PYX_ERR(0, 567, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_gamma, __pyx_v_num_gamma) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - - /* "l0learn/interface.pyx":568 - * num_lambda=num_lambda, - * num_gamma=num_gamma, - * gamma_max=gamma_max, # <<<<<<<<<<<<<< - * gamma_min=gamma_min, - * partial_sort=partial_sort, - */ - __Pyx_TraceLine(568,0,__PYX_ERR(0, 568, __pyx_L1_error)) - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 568, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma_max, __pyx_t_3) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":569 - * num_gamma=num_gamma, - * gamma_max=gamma_max, - * gamma_min=gamma_min, # <<<<<<<<<<<<<< - * partial_sort=partial_sort, - * max_iter=max_iter, - */ - __Pyx_TraceLine(569,0,__PYX_ERR(0, 569, __pyx_L1_error)) - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 569, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma_min, __pyx_t_3) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":570 - * gamma_max=gamma_max, - * gamma_min=gamma_min, - * partial_sort=partial_sort, # <<<<<<<<<<<<<< - * max_iter=max_iter, - * rtol=rtol, - */ - __Pyx_TraceLine(570,0,__PYX_ERR(0, 570, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_partial_sort, __pyx_v_partial_sort) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - - /* "l0learn/interface.pyx":571 - * gamma_min=gamma_min, - * partial_sort=partial_sort, - * max_iter=max_iter, # <<<<<<<<<<<<<< - * rtol=rtol, - * atol=atol, - */ - __Pyx_TraceLine(571,0,__PYX_ERR(0, 571, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_iter, __pyx_v_max_iter) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - - /* "l0learn/interface.pyx":572 - * partial_sort=partial_sort, - * max_iter=max_iter, - * rtol=rtol, # <<<<<<<<<<<<<< - * atol=atol, - * active_set=active_set, - */ - __Pyx_TraceLine(572,0,__PYX_ERR(0, 572, __pyx_L1_error)) - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_rtol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 572, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_rtol, __pyx_t_3) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":573 - * max_iter=max_iter, - * rtol=rtol, - * atol=atol, # <<<<<<<<<<<<<< - * active_set=active_set, - * active_set_num=active_set_num, - */ - __Pyx_TraceLine(573,0,__PYX_ERR(0, 573, __pyx_L1_error)) - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_atol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 573, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_atol, __pyx_t_3) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":574 - * rtol=rtol, - * atol=atol, - * active_set=active_set, # <<<<<<<<<<<<<< - * active_set_num=active_set_num, - * max_swaps=max_swaps, - */ - __Pyx_TraceLine(574,0,__PYX_ERR(0, 574, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_active_set, __pyx_v_active_set) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - - /* "l0learn/interface.pyx":575 - * atol=atol, - * active_set=active_set, - * active_set_num=active_set_num, # <<<<<<<<<<<<<< - * max_swaps=max_swaps, - * scale_down_factor=scale_down_factor, - */ - __Pyx_TraceLine(575,0,__PYX_ERR(0, 575, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_active_set_num, __pyx_v_active_set_num) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - - /* "l0learn/interface.pyx":576 - * active_set=active_set, - * active_set_num=active_set_num, - * max_swaps=max_swaps, # <<<<<<<<<<<<<< - * scale_down_factor=scale_down_factor, - * screen_size=screen_size, - */ - __Pyx_TraceLine(576,0,__PYX_ERR(0, 576, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_swaps, __pyx_v_max_swaps) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - - /* "l0learn/interface.pyx":577 - * active_set_num=active_set_num, - * max_swaps=max_swaps, - * scale_down_factor=scale_down_factor, # <<<<<<<<<<<<<< - * screen_size=screen_size, - * lambda_grid=lambda_grid, - */ - __Pyx_TraceLine(577,0,__PYX_ERR(0, 577, __pyx_L1_error)) - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_scale_down_factor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 577, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_scale_down_factor, __pyx_t_3) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":578 - * max_swaps=max_swaps, - * scale_down_factor=scale_down_factor, - * screen_size=screen_size, # <<<<<<<<<<<<<< - * lambda_grid=lambda_grid, - * exclude_first_k=exclude_first_k, - */ - __Pyx_TraceLine(578,0,__PYX_ERR(0, 578, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_screen_size, __pyx_v_screen_size) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - - /* "l0learn/interface.pyx":579 - * scale_down_factor=scale_down_factor, - * screen_size=screen_size, - * lambda_grid=lambda_grid, # <<<<<<<<<<<<<< - * exclude_first_k=exclude_first_k, - * intercept=intercept, - */ - __Pyx_TraceLine(579,0,__PYX_ERR(0, 579, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lambda_grid, __pyx_v_lambda_grid) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - - /* "l0learn/interface.pyx":580 - * screen_size=screen_size, - * lambda_grid=lambda_grid, - * exclude_first_k=exclude_first_k, # <<<<<<<<<<<<<< - * intercept=intercept, - * lows=lows, - */ - __Pyx_TraceLine(580,0,__PYX_ERR(0, 580, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_exclude_first_k, __pyx_v_exclude_first_k) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - - /* "l0learn/interface.pyx":581 - * lambda_grid=lambda_grid, - * exclude_first_k=exclude_first_k, - * intercept=intercept, # <<<<<<<<<<<<<< - * lows=lows, - * highs=highs) - */ - __Pyx_TraceLine(581,0,__PYX_ERR(0, 581, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - - /* "l0learn/interface.pyx":582 - * exclude_first_k=exclude_first_k, - * intercept=intercept, - * lows=lows, # <<<<<<<<<<<<<< - * highs=highs) - * - */ - __Pyx_TraceLine(582,0,__PYX_ERR(0, 582, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lows, __pyx_v_lows) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - - /* "l0learn/interface.pyx":583 - * intercept=intercept, - * lows=lows, - * highs=highs) # <<<<<<<<<<<<<< - * - * max_support_size = check["max_support_size"] - */ - __Pyx_TraceLine(583,0,__PYX_ERR(0, 583, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_highs, __pyx_v_highs) < 0) __PYX_ERR(0, 560, __pyx_L1_error) - - /* "l0learn/interface.pyx":560 - * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.CVFitModel: - * - * check = _fit_check(X=X, # <<<<<<<<<<<<<< - * y=y, - * loss=loss, - */ - __Pyx_TraceLine(560,0,__PYX_ERR(0, 560, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 560, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v_check = __pyx_t_3; - __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":585 - * highs=highs) - * - * max_support_size = check["max_support_size"] # <<<<<<<<<<<<<< - * screen_size = check["screen_size"] - * y = check['y'] - */ - __Pyx_TraceLine(585,0,__PYX_ERR(0, 585, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_max_support_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 585, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF_SET(__pyx_v_max_support_size, __pyx_t_3); - __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":586 - * - * max_support_size = check["max_support_size"] - * screen_size = check["screen_size"] # <<<<<<<<<<<<<< - * y = check['y'] - * penalty = check['penalty'] - */ - __Pyx_TraceLine(586,0,__PYX_ERR(0, 586, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_screen_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 586, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF_SET(__pyx_v_screen_size, __pyx_t_3); - __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":587 - * max_support_size = check["max_support_size"] - * screen_size = check["screen_size"] - * y = check['y'] # <<<<<<<<<<<<<< - * penalty = check['penalty'] - * gamma_max = check['gamma_max'] - */ - __Pyx_TraceLine(587,0,__PYX_ERR(0, 587, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_y); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 587, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF_SET(__pyx_v_y, __pyx_t_3); - __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":588 - * screen_size = check["screen_size"] - * y = check['y'] - * penalty = check['penalty'] # <<<<<<<<<<<<<< - * gamma_max = check['gamma_max'] - * gamma_min = check['gamma_min'] - */ - __Pyx_TraceLine(588,0,__PYX_ERR(0, 588, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_penalty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 588, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (!(likely(PyUnicode_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(0, 588, __pyx_L1_error) - __Pyx_DECREF_SET(__pyx_v_penalty, ((PyObject*)__pyx_t_3)); - __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":589 - * y = check['y'] - * penalty = check['penalty'] - * gamma_max = check['gamma_max'] # <<<<<<<<<<<<<< - * gamma_min = check['gamma_min'] - * lambda_grid = check['lambda_grid'] - */ - __Pyx_TraceLine(589,0,__PYX_ERR(0, 589, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 589, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 589, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_v_gamma_max = __pyx_t_4; - - /* "l0learn/interface.pyx":590 - * penalty = check['penalty'] - * gamma_max = check['gamma_max'] - * gamma_min = check['gamma_min'] # <<<<<<<<<<<<<< - * lambda_grid = check['lambda_grid'] - * num_gamma = check['num_gamma'] - */ - __Pyx_TraceLine(590,0,__PYX_ERR(0, 590, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_gamma_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 590, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 590, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_v_gamma_min = __pyx_t_4; - - /* "l0learn/interface.pyx":591 - * gamma_max = check['gamma_max'] - * gamma_min = check['gamma_min'] - * lambda_grid = check['lambda_grid'] # <<<<<<<<<<<<<< - * num_gamma = check['num_gamma'] - * num_lambda = check['num_lambda'] - */ - __Pyx_TraceLine(591,0,__PYX_ERR(0, 591, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_lambda_grid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 591, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF_SET(__pyx_v_lambda_grid, __pyx_t_3); - __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":592 - * gamma_min = check['gamma_min'] - * lambda_grid = check['lambda_grid'] - * num_gamma = check['num_gamma'] # <<<<<<<<<<<<<< - * num_lambda = check['num_lambda'] - * auto_lambda = check['auto_lambda'] - */ - __Pyx_TraceLine(592,0,__PYX_ERR(0, 592, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_num_gamma); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 592, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF_SET(__pyx_v_num_gamma, __pyx_t_3); - __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":593 - * lambda_grid = check['lambda_grid'] - * num_gamma = check['num_gamma'] - * num_lambda = check['num_lambda'] # <<<<<<<<<<<<<< - * auto_lambda = check['auto_lambda'] - * with_bounds = check['with_bounds'] - */ - __Pyx_TraceLine(593,0,__PYX_ERR(0, 593, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_num_lambda); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 593, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF_SET(__pyx_v_num_lambda, __pyx_t_3); - __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":594 - * num_gamma = check['num_gamma'] - * num_lambda = check['num_lambda'] - * auto_lambda = check['auto_lambda'] # <<<<<<<<<<<<<< - * with_bounds = check['with_bounds'] - * lows = check['lows'] - */ - __Pyx_TraceLine(594,0,__PYX_ERR(0, 594, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_auto_lambda); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 594, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_v_auto_lambda = __pyx_t_3; - __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":595 - * num_lambda = check['num_lambda'] - * auto_lambda = check['auto_lambda'] - * with_bounds = check['with_bounds'] # <<<<<<<<<<<<<< - * lows = check['lows'] - * highs = check['highs'] - */ - __Pyx_TraceLine(595,0,__PYX_ERR(0, 595, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_with_bounds); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 595, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_v_with_bounds = __pyx_t_3; - __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":596 - * auto_lambda = check['auto_lambda'] - * with_bounds = check['with_bounds'] - * lows = check['lows'] # <<<<<<<<<<<<<< - * highs = check['highs'] - * - */ - __Pyx_TraceLine(596,0,__PYX_ERR(0, 596, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_lows); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 596, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_3); - __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":597 - * with_bounds = check['with_bounds'] - * lows = check['lows'] - * highs = check['highs'] # <<<<<<<<<<<<<< - * - * _, p = X.shape - */ - __Pyx_TraceLine(597,0,__PYX_ERR(0, 597, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_highs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 597, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_3); - __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":599 - * highs = check['highs'] - * - * _, p = X.shape # <<<<<<<<<<<<<< - * - * if not isinstance(num_folds, int) or num_folds < 2 or num_folds > p: - */ - __Pyx_TraceLine(599,0,__PYX_ERR(0, 599, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 599, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { - PyObject* sequence = __pyx_t_3; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 599, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_1 = PyTuple_GET_ITEM(sequence, 1); - } else { - __pyx_t_2 = PyList_GET_ITEM(sequence, 0); - __pyx_t_1 = PyList_GET_ITEM(sequence, 1); - } - __Pyx_INCREF(__pyx_t_2); - __Pyx_INCREF(__pyx_t_1); - #else - __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 599, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 599, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - #endif - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } else { - Py_ssize_t index = -1; - __pyx_t_5 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 599, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext; - index = 0; __pyx_t_2 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed; - __Pyx_GOTREF(__pyx_t_2); - index = 1; __pyx_t_1 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_1)) goto __pyx_L3_unpacking_failed; - __Pyx_GOTREF(__pyx_t_1); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 2) < 0) __PYX_ERR(0, 599, __pyx_L1_error) - __pyx_t_6 = NULL; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - goto __pyx_L4_unpacking_done; - __pyx_L3_unpacking_failed:; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_6 = NULL; - if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 599, __pyx_L1_error) - __pyx_L4_unpacking_done:; - } - __pyx_v__ = __pyx_t_2; - __pyx_t_2 = 0; - __pyx_v_p = __pyx_t_1; - __pyx_t_1 = 0; - - /* "l0learn/interface.pyx":601 - * _, p = X.shape - * - * if not isinstance(num_folds, int) or num_folds < 2 or num_folds > p: # <<<<<<<<<<<<<< - * raise ValueError(f"expected num_folds parameter to be a positive integer less than {p}, but got {num_folds}") - * - */ - __Pyx_TraceLine(601,0,__PYX_ERR(0, 601, __pyx_L1_error)) - __pyx_t_8 = PyInt_Check(__pyx_v_num_folds); - __pyx_t_9 = ((!(__pyx_t_8 != 0)) != 0); - if (!__pyx_t_9) { - } else { - __pyx_t_7 = __pyx_t_9; - goto __pyx_L6_bool_binop_done; - } - __pyx_t_3 = PyObject_RichCompare(__pyx_v_num_folds, __pyx_int_2, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 601, __pyx_L1_error) - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 601, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (!__pyx_t_9) { - } else { - __pyx_t_7 = __pyx_t_9; - goto __pyx_L6_bool_binop_done; - } - __pyx_t_3 = PyObject_RichCompare(__pyx_v_num_folds, __pyx_v_p, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 601, __pyx_L1_error) - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 601, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_7 = __pyx_t_9; - __pyx_L6_bool_binop_done:; - if (unlikely(__pyx_t_7)) { - - /* "l0learn/interface.pyx":602 - * - * if not isinstance(num_folds, int) or num_folds < 2 or num_folds > p: - * raise ValueError(f"expected num_folds parameter to be a positive integer less than {p}, but got {num_folds}") # <<<<<<<<<<<<<< - * - * - */ - __Pyx_TraceLine(602,0,__PYX_ERR(0, 602, __pyx_L1_error)) - __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 602, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = 0; - __pyx_t_11 = 127; - __Pyx_INCREF(__pyx_kp_u_expected_num_folds_parameter_to); - __pyx_t_10 += 64; - __Pyx_GIVEREF(__pyx_kp_u_expected_num_folds_parameter_to); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_num_folds_parameter_to); - __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 602, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_11 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) > __pyx_t_11) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) : __pyx_t_11; - __pyx_t_10 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); - __pyx_t_1 = 0; - __Pyx_INCREF(__pyx_kp_u_but_got); - __pyx_t_10 += 10; - __Pyx_GIVEREF(__pyx_kp_u_but_got); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_but_got); - __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_num_folds, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 602, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_11 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) > __pyx_t_11) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) : __pyx_t_11; - __pyx_t_10 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_1); - __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_10, __pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 602, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 602, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_Raise(__pyx_t_3, 0, 0, 0); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 602, __pyx_L1_error) - - /* "l0learn/interface.pyx":601 - * _, p = X.shape - * - * if not isinstance(num_folds, int) or num_folds < 2 or num_folds > p: # <<<<<<<<<<<<<< - * raise ValueError(f"expected num_folds parameter to be a positive integer less than {p}, but got {num_folds}") - * - */ - } - - /* "l0learn/interface.pyx":606 - * - * cdef vector[vector[double]] c_lambda_grid - * try: # <<<<<<<<<<<<<< - * c_lambda_grid = lambda_grid - * except TypeError: - */ - __Pyx_TraceLine(606,0,__PYX_ERR(0, 606, __pyx_L1_error)) - { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14); - __Pyx_XGOTREF(__pyx_t_12); - __Pyx_XGOTREF(__pyx_t_13); - __Pyx_XGOTREF(__pyx_t_14); - /*try:*/ { - - /* "l0learn/interface.pyx":607 - * cdef vector[vector[double]] c_lambda_grid - * try: - * c_lambda_grid = lambda_grid # <<<<<<<<<<<<<< - * except TypeError: - * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") - */ - __Pyx_TraceLine(607,0,__PYX_ERR(0, 607, __pyx_L9_error)) - __pyx_t_15 = __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_lambda_grid); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 607, __pyx_L9_error) - __pyx_v_c_lambda_grid = __pyx_t_15; - - /* "l0learn/interface.pyx":606 - * - * cdef vector[vector[double]] c_lambda_grid - * try: # <<<<<<<<<<<<<< - * c_lambda_grid = lambda_grid - * except TypeError: - */ - } - __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; - __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; - __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; - goto __pyx_L14_try_end; - __pyx_L9_error:; - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - - /* "l0learn/interface.pyx":608 - * try: - * c_lambda_grid = lambda_grid - * except TypeError: # <<<<<<<<<<<<<< - * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") - * - */ - __Pyx_TraceLine(608,0,__PYX_ERR(0, 608, __pyx_L11_except_error)) - __pyx_t_16 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); - if (__pyx_t_16) { - __Pyx_AddTraceback("l0learn.interface.cvfit", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_1, &__pyx_t_2) < 0) __PYX_ERR(0, 608, __pyx_L11_except_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_t_2); - - /* "l0learn/interface.pyx":609 - * c_lambda_grid = lambda_grid - * except TypeError: - * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") # <<<<<<<<<<<<<< - * - * cdef string c_loss = loss.encode('UTF-8') - */ - __Pyx_TraceLine(609,0,__PYX_ERR(0, 609, __pyx_L11_except_error)) - __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 609, __pyx_L11_except_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_17 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_be_a_lis, __pyx_t_5); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 609, __pyx_L11_except_error) - __Pyx_GOTREF(__pyx_t_17); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_17); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 609, __pyx_L11_except_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; - __Pyx_Raise(__pyx_t_5, 0, 0, 0); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __PYX_ERR(0, 609, __pyx_L11_except_error) - } - goto __pyx_L11_except_error; - __pyx_L11_except_error:; - - /* "l0learn/interface.pyx":606 - * - * cdef vector[vector[double]] c_lambda_grid - * try: # <<<<<<<<<<<<<< - * c_lambda_grid = lambda_grid - * except TypeError: - */ - __Pyx_XGIVEREF(__pyx_t_12); - __Pyx_XGIVEREF(__pyx_t_13); - __Pyx_XGIVEREF(__pyx_t_14); - __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14); - goto __pyx_L1_error; - __pyx_L14_try_end:; - } - - /* "l0learn/interface.pyx":611 - * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") - * - * cdef string c_loss = loss.encode('UTF-8') # <<<<<<<<<<<<<< - * cdef string c_penalty = penalty.encode('UTF-8') - * cdef string c_algorithim = algorithm.encode('UTF-8') - */ - __Pyx_TraceLine(611,0,__PYX_ERR(0, 611, __pyx_L1_error)) - if (unlikely(__pyx_v_loss == Py_None)) { - PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 611, __pyx_L1_error) - } - __pyx_t_2 = PyUnicode_AsUTF8String(__pyx_v_loss); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 611, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_18 = __pyx_convert_string_from_py_std__in_string(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 611, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v_c_loss = __pyx_t_18; - - /* "l0learn/interface.pyx":612 - * - * cdef string c_loss = loss.encode('UTF-8') - * cdef string c_penalty = penalty.encode('UTF-8') # <<<<<<<<<<<<<< - * cdef string c_algorithim = algorithm.encode('UTF-8') - * - */ - __Pyx_TraceLine(612,0,__PYX_ERR(0, 612, __pyx_L1_error)) - if (unlikely(__pyx_v_penalty == Py_None)) { - PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 612, __pyx_L1_error) - } - __pyx_t_2 = PyUnicode_AsUTF8String(__pyx_v_penalty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 612, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_18 = __pyx_convert_string_from_py_std__in_string(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 612, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v_c_penalty = __pyx_t_18; - - /* "l0learn/interface.pyx":613 - * cdef string c_loss = loss.encode('UTF-8') - * cdef string c_penalty = penalty.encode('UTF-8') - * cdef string c_algorithim = algorithm.encode('UTF-8') # <<<<<<<<<<<<<< - * - * cdef cvfitmodel c_results - */ - __Pyx_TraceLine(613,0,__PYX_ERR(0, 613, __pyx_L1_error)) - if (unlikely(__pyx_v_algorithm == Py_None)) { - PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 613, __pyx_L1_error) - } - __pyx_t_2 = PyUnicode_AsUTF8String(__pyx_v_algorithm); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 613, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_18 = __pyx_convert_string_from_py_std__in_string(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 613, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v_c_algorithim = __pyx_t_18; - - /* "l0learn/interface.pyx":616 - * - * cdef cvfitmodel c_results - * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< - * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), - * y=numpy_to_dvec_d(y), - */ - __Pyx_TraceLine(616,0,__PYX_ERR(0, 616, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 616, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 616, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_7 = PyObject_IsInstance(__pyx_v_X, __pyx_t_1); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 616, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_9 = (__pyx_t_7 != 0); - if (__pyx_t_9) { - - /* "l0learn/interface.pyx":617 - * cdef cvfitmodel c_results - * if isinstance(X, np.ndarray): - * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< - * y=numpy_to_dvec_d(y), - * Loss=c_loss, - */ - __Pyx_TraceLine(617,0,__PYX_ERR(0, 617, __pyx_L1_error)) - if (!(likely(((__pyx_v_X) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_X, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 617, __pyx_L1_error) - - /* "l0learn/interface.pyx":618 - * if isinstance(X, np.ndarray): - * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), - * y=numpy_to_dvec_d(y), # <<<<<<<<<<<<<< - * Loss=c_loss, - * Penalty=c_penalty, - */ - __Pyx_TraceLine(618,0,__PYX_ERR(0, 618, __pyx_L1_error)) - if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 618, __pyx_L1_error) - - /* "l0learn/interface.pyx":622 - * Penalty=c_penalty, - * Algorithm=c_algorithim, - * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< - * G_ncols=num_lambda, - * G_nrows=num_gamma, - */ - __Pyx_TraceLine(622,0,__PYX_ERR(0, 622, __pyx_L1_error)) - __pyx_t_19 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_19 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 622, __pyx_L1_error) - - /* "l0learn/interface.pyx":623 - * Algorithm=c_algorithim, - * NnzStopNum=max_support_size, - * G_ncols=num_lambda, # <<<<<<<<<<<<<< - * G_nrows=num_gamma, - * Lambda2Max=gamma_max, - */ - __Pyx_TraceLine(623,0,__PYX_ERR(0, 623, __pyx_L1_error)) - __pyx_t_20 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_20 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 623, __pyx_L1_error) - - /* "l0learn/interface.pyx":624 - * NnzStopNum=max_support_size, - * G_ncols=num_lambda, - * G_nrows=num_gamma, # <<<<<<<<<<<<<< - * Lambda2Max=gamma_max, - * Lambda2Min=gamma_min, - */ - __Pyx_TraceLine(624,0,__PYX_ERR(0, 624, __pyx_L1_error)) - __pyx_t_21 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_21 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 624, __pyx_L1_error) - - /* "l0learn/interface.pyx":627 - * Lambda2Max=gamma_max, - * Lambda2Min=gamma_min, - * PartialSort=partial_sort, # <<<<<<<<<<<<<< - * MaxIters=max_iter, - * rtol=rtol, - */ - __Pyx_TraceLine(627,0,__PYX_ERR(0, 627, __pyx_L1_error)) - __pyx_t_22 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_22 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 627, __pyx_L1_error) - - /* "l0learn/interface.pyx":628 - * Lambda2Min=gamma_min, - * PartialSort=partial_sort, - * MaxIters=max_iter, # <<<<<<<<<<<<<< - * rtol=rtol, - * atol=atol, - */ - __Pyx_TraceLine(628,0,__PYX_ERR(0, 628, __pyx_L1_error)) - __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 628, __pyx_L1_error) - - /* "l0learn/interface.pyx":631 - * rtol=rtol, - * atol=atol, - * ActiveSet=active_set, # <<<<<<<<<<<<<< - * ActiveSetNum=active_set_num, - * MaxNumSwaps=max_swaps, - */ - __Pyx_TraceLine(631,0,__PYX_ERR(0, 631, __pyx_L1_error)) - __pyx_t_24 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_24 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 631, __pyx_L1_error) - - /* "l0learn/interface.pyx":632 - * atol=atol, - * ActiveSet=active_set, - * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< - * MaxNumSwaps=max_swaps, - * ScaleDownFactor=scale_down_factor, - */ - __Pyx_TraceLine(632,0,__PYX_ERR(0, 632, __pyx_L1_error)) - __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 632, __pyx_L1_error) - - /* "l0learn/interface.pyx":633 - * ActiveSet=active_set, - * ActiveSetNum=active_set_num, - * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< - * ScaleDownFactor=scale_down_factor, - * ScreenSize=screen_size, - */ - __Pyx_TraceLine(633,0,__PYX_ERR(0, 633, __pyx_L1_error)) - __pyx_t_26 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_26 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 633, __pyx_L1_error) - - /* "l0learn/interface.pyx":635 - * MaxNumSwaps=max_swaps, - * ScaleDownFactor=scale_down_factor, - * ScreenSize=screen_size, # <<<<<<<<<<<<<< - * LambdaU=not auto_lambda, - * Lambdas=c_lambda_grid, - */ - __Pyx_TraceLine(635,0,__PYX_ERR(0, 635, __pyx_L1_error)) - __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 635, __pyx_L1_error) - - /* "l0learn/interface.pyx":636 - * ScaleDownFactor=scale_down_factor, - * ScreenSize=screen_size, - * LambdaU=not auto_lambda, # <<<<<<<<<<<<<< - * Lambdas=c_lambda_grid, - * nfolds=num_folds, - */ - __Pyx_TraceLine(636,0,__PYX_ERR(0, 636, __pyx_L1_error)) - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 636, __pyx_L1_error) - - /* "l0learn/interface.pyx":638 - * LambdaU=not auto_lambda, - * Lambdas=c_lambda_grid, - * nfolds=num_folds, # <<<<<<<<<<<<<< - * seed=seed, - * ExcludeFirstK=exclude_first_k, - */ - __Pyx_TraceLine(638,0,__PYX_ERR(0, 638, __pyx_L1_error)) - __pyx_t_28 = __Pyx_PyInt_As_unsigned_int(__pyx_v_num_folds); if (unlikely((__pyx_t_28 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 638, __pyx_L1_error) - - /* "l0learn/interface.pyx":639 - * Lambdas=c_lambda_grid, - * nfolds=num_folds, - * seed=seed, # <<<<<<<<<<<<<< - * ExcludeFirstK=exclude_first_k, - * Intercept=intercept, - */ - __Pyx_TraceLine(639,0,__PYX_ERR(0, 639, __pyx_L1_error)) - __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_seed); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 639, __pyx_L1_error) - - /* "l0learn/interface.pyx":640 - * nfolds=num_folds, - * seed=seed, - * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< - * Intercept=intercept, - * withBounds=with_bounds, - */ - __Pyx_TraceLine(640,0,__PYX_ERR(0, 640, __pyx_L1_error)) - __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 640, __pyx_L1_error) - - /* "l0learn/interface.pyx":641 - * seed=seed, - * ExcludeFirstK=exclude_first_k, - * Intercept=intercept, # <<<<<<<<<<<<<< - * withBounds=with_bounds, - * Lows=numpy_to_dvec_d(lows), - */ - __Pyx_TraceLine(641,0,__PYX_ERR(0, 641, __pyx_L1_error)) - __pyx_t_30 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_30 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 641, __pyx_L1_error) - - /* "l0learn/interface.pyx":642 - * ExcludeFirstK=exclude_first_k, - * Intercept=intercept, - * withBounds=with_bounds, # <<<<<<<<<<<<<< - * Lows=numpy_to_dvec_d(lows), - * Highs=numpy_to_dvec_d(highs)) - */ - __Pyx_TraceLine(642,0,__PYX_ERR(0, 642, __pyx_L1_error)) - __pyx_t_31 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_31 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 642, __pyx_L1_error) - - /* "l0learn/interface.pyx":643 - * Intercept=intercept, - * withBounds=with_bounds, - * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< - * Highs=numpy_to_dvec_d(highs)) - * else: # isinstance(X, csc_matrix) - */ - __Pyx_TraceLine(643,0,__PYX_ERR(0, 643, __pyx_L1_error)) - if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 643, __pyx_L1_error) - - /* "l0learn/interface.pyx":644 - * withBounds=with_bounds, - * Lows=numpy_to_dvec_d(lows), - * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< - * else: # isinstance(X, csc_matrix) - * c_results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), - */ - __Pyx_TraceLine(644,0,__PYX_ERR(0, 644, __pyx_L1_error)) - if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 644, __pyx_L1_error) - - /* "l0learn/interface.pyx":617 - * cdef cvfitmodel c_results - * if isinstance(X, np.ndarray): - * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< - * y=numpy_to_dvec_d(y), - * Loss=c_loss, - */ - __Pyx_TraceLine(617,0,__PYX_ERR(0, 617, __pyx_L1_error)) - __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnCV_dense(__pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_X)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_19, __pyx_t_20, __pyx_t_21, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_22, __pyx_t_23, __pyx_v_rtol, __pyx_v_atol, __pyx_t_24, __pyx_t_25, __pyx_t_26, __pyx_v_scale_down_factor, __pyx_t_27, (!__pyx_t_9), __pyx_v_c_lambda_grid, __pyx_t_28, __pyx_t_4, __pyx_t_29, __pyx_t_30, __pyx_t_31, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); - - /* "l0learn/interface.pyx":616 - * - * cdef cvfitmodel c_results - * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< - * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), - * y=numpy_to_dvec_d(y), - */ - goto __pyx_L17; - } - - /* "l0learn/interface.pyx":646 - * Highs=numpy_to_dvec_d(highs)) - * else: # isinstance(X, csc_matrix) - * c_results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< - * y=numpy_to_dvec_d(y), - * Loss=c_loss, - */ - __Pyx_TraceLine(646,0,__PYX_ERR(0, 646, __pyx_L1_error)) - /*else*/ { - - /* "l0learn/interface.pyx":647 - * else: # isinstance(X, csc_matrix) - * c_results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), - * y=numpy_to_dvec_d(y), # <<<<<<<<<<<<<< - * Loss=c_loss, - * Penalty=c_penalty, - */ - __Pyx_TraceLine(647,0,__PYX_ERR(0, 647, __pyx_L1_error)) - if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 647, __pyx_L1_error) - - /* "l0learn/interface.pyx":651 - * Penalty=c_penalty, - * Algorithm=c_algorithim, - * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< - * G_ncols=num_lambda, - * G_nrows=num_gamma, - */ - __Pyx_TraceLine(651,0,__PYX_ERR(0, 651, __pyx_L1_error)) - __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 651, __pyx_L1_error) - - /* "l0learn/interface.pyx":652 - * Algorithm=c_algorithim, - * NnzStopNum=max_support_size, - * G_ncols=num_lambda, # <<<<<<<<<<<<<< - * G_nrows=num_gamma, - * Lambda2Max=gamma_max, - */ - __Pyx_TraceLine(652,0,__PYX_ERR(0, 652, __pyx_L1_error)) - __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 652, __pyx_L1_error) - - /* "l0learn/interface.pyx":653 - * NnzStopNum=max_support_size, - * G_ncols=num_lambda, - * G_nrows=num_gamma, # <<<<<<<<<<<<<< - * Lambda2Max=gamma_max, - * Lambda2Min=gamma_min, - */ - __Pyx_TraceLine(653,0,__PYX_ERR(0, 653, __pyx_L1_error)) - __pyx_t_26 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_26 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 653, __pyx_L1_error) - - /* "l0learn/interface.pyx":656 - * Lambda2Max=gamma_max, - * Lambda2Min=gamma_min, - * PartialSort=partial_sort, # <<<<<<<<<<<<<< - * MaxIters=max_iter, - * rtol=rtol, - */ - __Pyx_TraceLine(656,0,__PYX_ERR(0, 656, __pyx_L1_error)) - __pyx_t_31 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_31 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 656, __pyx_L1_error) - - /* "l0learn/interface.pyx":657 - * Lambda2Min=gamma_min, - * PartialSort=partial_sort, - * MaxIters=max_iter, # <<<<<<<<<<<<<< - * rtol=rtol, - * atol=atol, - */ - __Pyx_TraceLine(657,0,__PYX_ERR(0, 657, __pyx_L1_error)) - __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 657, __pyx_L1_error) - - /* "l0learn/interface.pyx":660 - * rtol=rtol, - * atol=atol, - * ActiveSet=active_set, # <<<<<<<<<<<<<< - * ActiveSetNum=active_set_num, - * MaxNumSwaps=max_swaps, - */ - __Pyx_TraceLine(660,0,__PYX_ERR(0, 660, __pyx_L1_error)) - __pyx_t_30 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_30 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 660, __pyx_L1_error) - - /* "l0learn/interface.pyx":661 - * atol=atol, - * ActiveSet=active_set, - * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< - * MaxNumSwaps=max_swaps, - * ScaleDownFactor=scale_down_factor, - */ - __Pyx_TraceLine(661,0,__PYX_ERR(0, 661, __pyx_L1_error)) - __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 661, __pyx_L1_error) - - /* "l0learn/interface.pyx":662 - * ActiveSet=active_set, - * ActiveSetNum=active_set_num, - * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< - * ScaleDownFactor=scale_down_factor, - * ScreenSize=screen_size, - */ - __Pyx_TraceLine(662,0,__PYX_ERR(0, 662, __pyx_L1_error)) - __pyx_t_21 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_21 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 662, __pyx_L1_error) - - /* "l0learn/interface.pyx":664 - * MaxNumSwaps=max_swaps, - * ScaleDownFactor=scale_down_factor, - * ScreenSize=screen_size, # <<<<<<<<<<<<<< - * LambdaU=not auto_lambda, - * Lambdas=c_lambda_grid, - */ - __Pyx_TraceLine(664,0,__PYX_ERR(0, 664, __pyx_L1_error)) - __pyx_t_20 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_20 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 664, __pyx_L1_error) - - /* "l0learn/interface.pyx":665 - * ScaleDownFactor=scale_down_factor, - * ScreenSize=screen_size, - * LambdaU=not auto_lambda, # <<<<<<<<<<<<<< - * Lambdas=c_lambda_grid, - * nfolds=num_folds, - */ - __Pyx_TraceLine(665,0,__PYX_ERR(0, 665, __pyx_L1_error)) - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 665, __pyx_L1_error) - - /* "l0learn/interface.pyx":667 - * LambdaU=not auto_lambda, - * Lambdas=c_lambda_grid, - * nfolds=num_folds, # <<<<<<<<<<<<<< - * seed=seed, - * ExcludeFirstK=exclude_first_k, - */ - __Pyx_TraceLine(667,0,__PYX_ERR(0, 667, __pyx_L1_error)) - __pyx_t_28 = __Pyx_PyInt_As_unsigned_int(__pyx_v_num_folds); if (unlikely((__pyx_t_28 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 667, __pyx_L1_error) - - /* "l0learn/interface.pyx":668 - * Lambdas=c_lambda_grid, - * nfolds=num_folds, - * seed=seed, # <<<<<<<<<<<<<< - * ExcludeFirstK=exclude_first_k, - * Intercept=intercept, - */ - __Pyx_TraceLine(668,0,__PYX_ERR(0, 668, __pyx_L1_error)) - __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_seed); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 668, __pyx_L1_error) - - /* "l0learn/interface.pyx":669 - * nfolds=num_folds, - * seed=seed, - * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< - * Intercept=intercept, - * withBounds=with_bounds, - */ - __Pyx_TraceLine(669,0,__PYX_ERR(0, 669, __pyx_L1_error)) - __pyx_t_19 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_19 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 669, __pyx_L1_error) - - /* "l0learn/interface.pyx":670 - * seed=seed, - * ExcludeFirstK=exclude_first_k, - * Intercept=intercept, # <<<<<<<<<<<<<< - * withBounds=with_bounds, - * Lows=numpy_to_dvec_d(lows), - */ - __Pyx_TraceLine(670,0,__PYX_ERR(0, 670, __pyx_L1_error)) - __pyx_t_24 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_24 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 670, __pyx_L1_error) - - /* "l0learn/interface.pyx":671 - * ExcludeFirstK=exclude_first_k, - * Intercept=intercept, - * withBounds=with_bounds, # <<<<<<<<<<<<<< - * Lows=numpy_to_dvec_d(lows), - * Highs=numpy_to_dvec_d(highs)) - */ - __Pyx_TraceLine(671,0,__PYX_ERR(0, 671, __pyx_L1_error)) - __pyx_t_22 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_22 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 671, __pyx_L1_error) - - /* "l0learn/interface.pyx":672 - * Intercept=intercept, - * withBounds=with_bounds, - * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< - * Highs=numpy_to_dvec_d(highs)) - * - */ - __Pyx_TraceLine(672,0,__PYX_ERR(0, 672, __pyx_L1_error)) - if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 672, __pyx_L1_error) - - /* "l0learn/interface.pyx":673 - * withBounds=with_bounds, - * Lows=numpy_to_dvec_d(lows), - * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< - * - * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, - */ - __Pyx_TraceLine(673,0,__PYX_ERR(0, 673, __pyx_L1_error)) - if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 673, __pyx_L1_error) - - /* "l0learn/interface.pyx":646 - * Highs=numpy_to_dvec_d(highs)) - * else: # isinstance(X, csc_matrix) - * c_results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< - * y=numpy_to_dvec_d(y), - * Loss=c_loss, - */ - __Pyx_TraceLine(646,0,__PYX_ERR(0, 646, __pyx_L1_error)) - __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnCV_sparse(__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(__pyx_v_X), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_29, __pyx_t_27, __pyx_t_26, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_31, __pyx_t_25, __pyx_v_rtol, __pyx_v_atol, __pyx_t_30, __pyx_t_23, __pyx_t_21, __pyx_v_scale_down_factor, __pyx_t_20, (!__pyx_t_9), __pyx_v_c_lambda_grid, __pyx_t_28, __pyx_t_4, __pyx_t_19, __pyx_t_24, __pyx_t_22, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_X = values[0]; + __pyx_v_y = values[1]; + __pyx_v_loss = ((PyObject*)values[2]); + __pyx_v_penalty = ((PyObject*)values[3]); + __pyx_v_algorithm = ((PyObject*)values[4]); + __pyx_v_num_folds = values[5]; + __pyx_v_seed = values[6]; + __pyx_v_max_support_size = values[7]; + __pyx_v_num_lambda = values[8]; + __pyx_v_num_gamma = values[9]; + if (values[10]) { + __pyx_v_gamma_max = __pyx_PyFloat_AsDouble(values[10]); if (unlikely((__pyx_v_gamma_max == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 557, __pyx_L3_error) + } else { + __pyx_v_gamma_max = ((double)10.); + } + if (values[11]) { + __pyx_v_gamma_min = __pyx_PyFloat_AsDouble(values[11]); if (unlikely((__pyx_v_gamma_min == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 558, __pyx_L3_error) + } else { + __pyx_v_gamma_min = ((double).0001); + } + __pyx_v_partial_sort = values[12]; + __pyx_v_max_iter = values[13]; + if (values[14]) { + __pyx_v_rtol = __pyx_PyFloat_AsDouble(values[14]); if (unlikely((__pyx_v_rtol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 561, __pyx_L3_error) + } else { + __pyx_v_rtol = ((double)1e-6); + } + if (values[15]) { + __pyx_v_atol = __pyx_PyFloat_AsDouble(values[15]); if (unlikely((__pyx_v_atol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 562, __pyx_L3_error) + } else { + __pyx_v_atol = ((double)1e-9); + } + __pyx_v_active_set = values[16]; + __pyx_v_active_set_num = values[17]; + __pyx_v_max_swaps = values[18]; + if (values[19]) { + __pyx_v_scale_down_factor = __pyx_PyFloat_AsDouble(values[19]); if (unlikely((__pyx_v_scale_down_factor == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 566, __pyx_L3_error) + } else { + __pyx_v_scale_down_factor = ((double)0.8); + } + __pyx_v_screen_size = values[20]; + __pyx_v_lambda_grid = values[21]; + __pyx_v_exclude_first_k = values[22]; + __pyx_v_intercept = values[23]; + __pyx_v_lows = values[24]; + __pyx_v_highs = values[25]; } - __pyx_L17:; - - /* "l0learn/interface.pyx":675 - * Highs=numpy_to_dvec_d(highs)) - * - * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, # <<<<<<<<<<<<<< - * lambda_0=c_results.Lambda0, - * gamma=c_results.Lambda12, - */ - __Pyx_TraceLine(675,0,__PYX_ERR(0, 675, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_CVFitModel); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 675, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyDict_NewPresized(9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 675, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 675, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 675, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 675, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 675, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_settings, __pyx_t_3) < 0) __PYX_ERR(0, 675, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":676 - * - * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, - * lambda_0=c_results.Lambda0, # <<<<<<<<<<<<<< - * gamma=c_results.Lambda12, - * support_size=c_results.NnzCount, - */ - __Pyx_TraceLine(676,0,__PYX_ERR(0, 676, __pyx_L1_error)) - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Lambda0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 676, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lambda_0, __pyx_t_3) < 0) __PYX_ERR(0, 675, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":677 - * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, - * lambda_0=c_results.Lambda0, - * gamma=c_results.Lambda12, # <<<<<<<<<<<<<< - * support_size=c_results.NnzCount, - * coeffs=sp_dmat_field_to_list(c_results.Beta), - */ - __Pyx_TraceLine(677,0,__PYX_ERR(0, 677, __pyx_L1_error)) - __pyx_t_3 = __pyx_convert_vector_to_py_double(__pyx_v_c_results.Lambda12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 677, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma, __pyx_t_3) < 0) __PYX_ERR(0, 675, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":678 - * lambda_0=c_results.Lambda0, - * gamma=c_results.Lambda12, - * support_size=c_results.NnzCount, # <<<<<<<<<<<<<< - * coeffs=sp_dmat_field_to_list(c_results.Beta), - * intercepts=c_results.Intercept, - */ - __Pyx_TraceLine(678,0,__PYX_ERR(0, 678, __pyx_L1_error)) - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(__pyx_v_c_results.NnzCount); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 678, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_support_size, __pyx_t_3) < 0) __PYX_ERR(0, 675, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":679 - * gamma=c_results.Lambda12, - * support_size=c_results.NnzCount, - * coeffs=sp_dmat_field_to_list(c_results.Beta), # <<<<<<<<<<<<<< - * intercepts=c_results.Intercept, - * converged=c_results.Converged, - */ - __Pyx_TraceLine(679,0,__PYX_ERR(0, 679, __pyx_L1_error)) - __pyx_t_3 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_c_results.Beta); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 679, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_coeffs, __pyx_t_3) < 0) __PYX_ERR(0, 675, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":680 - * support_size=c_results.NnzCount, - * coeffs=sp_dmat_field_to_list(c_results.Beta), - * intercepts=c_results.Intercept, # <<<<<<<<<<<<<< - * converged=c_results.Converged, - * cv_means=dvec_field_to_list(c_results.CVMeans), - */ - __Pyx_TraceLine(680,0,__PYX_ERR(0, 680, __pyx_L1_error)) - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Intercept); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 680, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_intercepts, __pyx_t_3) < 0) __PYX_ERR(0, 675, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":681 - * coeffs=sp_dmat_field_to_list(c_results.Beta), - * intercepts=c_results.Intercept, - * converged=c_results.Converged, # <<<<<<<<<<<<<< - * cv_means=dvec_field_to_list(c_results.CVMeans), - * cv_sds=dvec_field_to_list(c_results.CVSDs)) - */ - __Pyx_TraceLine(681,0,__PYX_ERR(0, 681, __pyx_L1_error)) - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(__pyx_v_c_results.Converged); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 681, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_converged, __pyx_t_3) < 0) __PYX_ERR(0, 675, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":682 - * intercepts=c_results.Intercept, - * converged=c_results.Converged, - * cv_means=dvec_field_to_list(c_results.CVMeans), # <<<<<<<<<<<<<< - * cv_sds=dvec_field_to_list(c_results.CVSDs)) - * return results - */ - __Pyx_TraceLine(682,0,__PYX_ERR(0, 682, __pyx_L1_error)) - __pyx_t_3 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_c_results.CVMeans); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 682, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_cv_means, __pyx_t_3) < 0) __PYX_ERR(0, 675, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":683 - * converged=c_results.Converged, - * cv_means=dvec_field_to_list(c_results.CVMeans), - * cv_sds=dvec_field_to_list(c_results.CVSDs)) # <<<<<<<<<<<<<< - * return results - * - */ - __Pyx_TraceLine(683,0,__PYX_ERR(0, 683, __pyx_L1_error)) - __pyx_t_3 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_c_results.CVSDs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 683, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_cv_sds, __pyx_t_3) < 0) __PYX_ERR(0, 675, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":675 - * Highs=numpy_to_dvec_d(highs)) - * - * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, # <<<<<<<<<<<<<< - * lambda_0=c_results.Lambda0, - * gamma=c_results.Lambda12, - */ - __Pyx_TraceLine(675,0,__PYX_ERR(0, 675, __pyx_L1_error)) - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 675, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v_results = __pyx_t_3; - __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":684 - * cv_means=dvec_field_to_list(c_results.CVMeans), - * cv_sds=dvec_field_to_list(c_results.CVSDs)) - * return results # <<<<<<<<<<<<<< - * - * - */ - __Pyx_TraceLine(684,0,__PYX_ERR(0, 684, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_results); - __pyx_r = __pyx_v_results; - goto __pyx_L0; + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("cvfit", 0, 2, 26, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 547, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("l0learn.interface.cvfit", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loss), (&PyUnicode_Type), 1, "loss", 1))) __PYX_ERR(0, 549, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_penalty), (&PyUnicode_Type), 1, "penalty", 1))) __PYX_ERR(0, 550, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_algorithm), (&PyUnicode_Type), 1, "algorithm", 1))) __PYX_ERR(0, 551, __pyx_L1_error) + __pyx_r = __pyx_pf_7l0learn_9interface_4cvfit(__pyx_self, __pyx_v_X, __pyx_v_y, __pyx_v_loss, __pyx_v_penalty, __pyx_v_algorithm, __pyx_v_num_folds, __pyx_v_seed, __pyx_v_max_support_size, __pyx_v_num_lambda, __pyx_v_num_gamma, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_v_partial_sort, __pyx_v_max_iter, __pyx_v_rtol, __pyx_v_atol, __pyx_v_active_set, __pyx_v_active_set_num, __pyx_v_max_swaps, __pyx_v_scale_down_factor, __pyx_v_screen_size, __pyx_v_lambda_grid, __pyx_v_exclude_first_k, __pyx_v_intercept, __pyx_v_lows, __pyx_v_highs); - /* "l0learn/interface.pyx":533 + /* "l0learn/interface.pyx":547 * * * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< @@ -10785,3024 +8321,3425 @@ static PyObject *__pyx_pf_7l0learn_9interface_6cvfit(CYTHON_UNUSED PyObject *__p */ /* function exit code */ + goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_17); - __Pyx_AddTraceback("l0learn.interface.cvfit", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; - __Pyx_XDECREF(__pyx_v_check); - __Pyx_XDECREF(__pyx_v_auto_lambda); - __Pyx_XDECREF(__pyx_v_with_bounds); - __Pyx_XDECREF(__pyx_v__); - __Pyx_XDECREF(__pyx_v_p); - __Pyx_XDECREF(__pyx_v_results); - __Pyx_XDECREF(__pyx_v_y); - __Pyx_XDECREF(__pyx_v_penalty); - __Pyx_XDECREF(__pyx_v_max_support_size); - __Pyx_XDECREF(__pyx_v_num_lambda); - __Pyx_XDECREF(__pyx_v_num_gamma); - __Pyx_XDECREF(__pyx_v_screen_size); - __Pyx_XDECREF(__pyx_v_lambda_grid); - __Pyx_XDECREF(__pyx_v_lows); - __Pyx_XDECREF(__pyx_v_highs); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "l0learn/interface.pyx":687 +static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_X, PyObject *__pyx_v_y, PyObject *__pyx_v_loss, PyObject *__pyx_v_penalty, PyObject *__pyx_v_algorithm, PyObject *__pyx_v_num_folds, PyObject *__pyx_v_seed, PyObject *__pyx_v_max_support_size, PyObject *__pyx_v_num_lambda, PyObject *__pyx_v_num_gamma, double __pyx_v_gamma_max, double __pyx_v_gamma_min, PyObject *__pyx_v_partial_sort, PyObject *__pyx_v_max_iter, double __pyx_v_rtol, double __pyx_v_atol, PyObject *__pyx_v_active_set, PyObject *__pyx_v_active_set_num, PyObject *__pyx_v_max_swaps, double __pyx_v_scale_down_factor, PyObject *__pyx_v_screen_size, PyObject *__pyx_v_lambda_grid, PyObject *__pyx_v_exclude_first_k, PyObject *__pyx_v_intercept, PyObject *__pyx_v_lows, PyObject *__pyx_v_highs) { + PyObject *__pyx_v_check = NULL; + PyObject *__pyx_v_auto_lambda = NULL; + PyObject *__pyx_v_with_bounds = NULL; + CYTHON_UNUSED PyObject *__pyx_v__ = NULL; + PyObject *__pyx_v_p = NULL; + std::vector > __pyx_v_c_lambda_grid; + std::string __pyx_v_c_loss; + std::string __pyx_v_c_penalty; + std::string __pyx_v_c_algorithim; + cvfitmodel __pyx_v_c_results; + PyObject *__pyx_v_results = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + double __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *(*__pyx_t_6)(PyObject *); + int __pyx_t_7; + int __pyx_t_8; + int __pyx_t_9; + Py_ssize_t __pyx_t_10; + Py_UCS4 __pyx_t_11; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + std::vector > __pyx_t_15; + int __pyx_t_16; + PyObject *__pyx_t_17 = NULL; + std::string __pyx_t_18; + size_t __pyx_t_19; + size_t __pyx_t_20; + size_t __pyx_t_21; + bool __pyx_t_22; + size_t __pyx_t_23; + bool __pyx_t_24; + size_t __pyx_t_25; + size_t __pyx_t_26; + size_t __pyx_t_27; + unsigned int __pyx_t_28; + size_t __pyx_t_29; + bool __pyx_t_30; + bool __pyx_t_31; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("cvfit", 0); + __Pyx_INCREF(__pyx_v_y); + __Pyx_INCREF(__pyx_v_penalty); + __Pyx_INCREF(__pyx_v_max_support_size); + __Pyx_INCREF(__pyx_v_num_lambda); + __Pyx_INCREF(__pyx_v_num_gamma); + __Pyx_INCREF(__pyx_v_screen_size); + __Pyx_INCREF(__pyx_v_lambda_grid); + __Pyx_INCREF(__pyx_v_lows); + __Pyx_INCREF(__pyx_v_highs); + + /* "l0learn/interface.pyx":574 + * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.CVFitModel: * + * check = _fit_check(X=X, # <<<<<<<<<<<<<< + * y=y, + * loss=loss, + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_fit_check); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyDict_NewPresized(24); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_X, __pyx_v_X) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + + /* "l0learn/interface.pyx":575 * - * cdef fitmodel _L0LearnFit_dense(const dmat& X, # <<<<<<<<<<<<<< - * const dvec& y, - * const string Loss, + * check = _fit_check(X=X, + * y=y, # <<<<<<<<<<<<<< + * loss=loss, + * penalty=penalty, */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_y, __pyx_v_y) < 0) __PYX_ERR(0, 574, __pyx_L1_error) -static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_dense(arma::dmat const &__pyx_v_X, arma::dvec const &__pyx_v_y, std::string const __pyx_v_Loss, std::string const __pyx_v_Penalty, std::string const __pyx_v_Algorithm, size_t const __pyx_v_NnzStopNum, size_t const __pyx_v_G_ncols, size_t const __pyx_v_G_nrows, double const __pyx_v_Lambda2Max, double const __pyx_v_Lambda2Min, bool const __pyx_v_PartialSort, size_t const __pyx_v_MaxIters, double const __pyx_v_rtol, double const __pyx_v_atol, bool const __pyx_v_ActiveSet, size_t const __pyx_v_ActiveSetNum, size_t const __pyx_v_MaxNumSwaps, double const __pyx_v_ScaleDownFactor, size_t const __pyx_v_ScreenSize, bool const __pyx_v_LambdaU, std::vector > const &__pyx_v_Lambdas, size_t const __pyx_v_ExcludeFirstK, bool const __pyx_v_Intercept, bool const __pyx_v_withBounds, arma::dvec const &__pyx_v_Lows, arma::dvec const &__pyx_v_Highs) { - fitmodel __pyx_r; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("_L0LearnFit_dense", 0); - __Pyx_TraceCall("_L0LearnFit_dense", __pyx_f[0], 687, 0, __PYX_ERR(0, 687, __pyx_L1_error)); + /* "l0learn/interface.pyx":576 + * check = _fit_check(X=X, + * y=y, + * loss=loss, # <<<<<<<<<<<<<< + * penalty=penalty, + * algorithm=algorithm, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 574, __pyx_L1_error) - /* "l0learn/interface.pyx":713 - * const dvec &Lows, - * const dvec &Highs): - * return L0LearnFit[dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< - * MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, - * Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs) + /* "l0learn/interface.pyx":577 + * y=y, + * loss=loss, + * penalty=penalty, # <<<<<<<<<<<<<< + * algorithm=algorithm, + * max_support_size=max_support_size, */ - __Pyx_TraceLine(713,0,__PYX_ERR(0, 713, __pyx_L1_error)) - __pyx_r = L0LearnFit(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); - goto __pyx_L0; + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 574, __pyx_L1_error) - /* "l0learn/interface.pyx":687 - * - * - * cdef fitmodel _L0LearnFit_dense(const dmat& X, # <<<<<<<<<<<<<< - * const dvec& y, - * const string Loss, + /* "l0learn/interface.pyx":578 + * loss=loss, + * penalty=penalty, + * algorithm=algorithm, # <<<<<<<<<<<<<< + * max_support_size=max_support_size, + * num_lambda=num_lambda, */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_algorithm, __pyx_v_algorithm) < 0) __PYX_ERR(0, 574, __pyx_L1_error) - /* function exit code */ - __pyx_L1_error:; - __Pyx_WriteUnraisable("l0learn.interface._L0LearnFit_dense", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); - __Pyx_pretend_to_initialize(&__pyx_r); - __pyx_L0:; - __Pyx_TraceReturn(Py_None, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "l0learn/interface.pyx":579 + * penalty=penalty, + * algorithm=algorithm, + * max_support_size=max_support_size, # <<<<<<<<<<<<<< + * num_lambda=num_lambda, + * num_gamma=num_gamma, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_support_size, __pyx_v_max_support_size) < 0) __PYX_ERR(0, 574, __pyx_L1_error) -/* "l0learn/interface.pyx":718 - * - * - * cdef fitmodel _L0LearnFit_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< - * const dvec& y, - * const string Loss, + /* "l0learn/interface.pyx":580 + * algorithm=algorithm, + * max_support_size=max_support_size, + * num_lambda=num_lambda, # <<<<<<<<<<<<<< + * num_gamma=num_gamma, + * gamma_max=gamma_max, */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_lambda, __pyx_v_num_lambda) < 0) __PYX_ERR(0, 574, __pyx_L1_error) -static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_sparse(arma::sp_dmat const &__pyx_v_X, arma::dvec const &__pyx_v_y, std::string const __pyx_v_Loss, std::string const __pyx_v_Penalty, std::string const __pyx_v_Algorithm, size_t const __pyx_v_NnzStopNum, size_t const __pyx_v_G_ncols, size_t const __pyx_v_G_nrows, double const __pyx_v_Lambda2Max, double const __pyx_v_Lambda2Min, bool const __pyx_v_PartialSort, size_t const __pyx_v_MaxIters, double const __pyx_v_rtol, double const __pyx_v_atol, bool const __pyx_v_ActiveSet, size_t const __pyx_v_ActiveSetNum, size_t const __pyx_v_MaxNumSwaps, double const __pyx_v_ScaleDownFactor, size_t const __pyx_v_ScreenSize, bool const __pyx_v_LambdaU, std::vector > const &__pyx_v_Lambdas, size_t const __pyx_v_ExcludeFirstK, bool const __pyx_v_Intercept, bool const __pyx_v_withBounds, arma::dvec const &__pyx_v_Lows, arma::dvec const &__pyx_v_Highs) { - fitmodel __pyx_r; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("_L0LearnFit_sparse", 0); - __Pyx_TraceCall("_L0LearnFit_sparse", __pyx_f[0], 718, 0, __PYX_ERR(0, 718, __pyx_L1_error)); + /* "l0learn/interface.pyx":581 + * max_support_size=max_support_size, + * num_lambda=num_lambda, + * num_gamma=num_gamma, # <<<<<<<<<<<<<< + * gamma_max=gamma_max, + * gamma_min=gamma_min, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_gamma, __pyx_v_num_gamma) < 0) __PYX_ERR(0, 574, __pyx_L1_error) - /* "l0learn/interface.pyx":744 - * const dvec &Lows, - * const dvec &Highs): - * return L0LearnFit[sp_dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< - * MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, - * Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs) + /* "l0learn/interface.pyx":582 + * num_lambda=num_lambda, + * num_gamma=num_gamma, + * gamma_max=gamma_max, # <<<<<<<<<<<<<< + * gamma_min=gamma_min, + * partial_sort=partial_sort, */ - __Pyx_TraceLine(744,0,__PYX_ERR(0, 744, __pyx_L1_error)) - __pyx_r = L0LearnFit(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); - goto __pyx_L0; + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 582, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma_max, __pyx_t_3) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":718 - * - * - * cdef fitmodel _L0LearnFit_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< - * const dvec& y, - * const string Loss, + /* "l0learn/interface.pyx":583 + * num_gamma=num_gamma, + * gamma_max=gamma_max, + * gamma_min=gamma_min, # <<<<<<<<<<<<<< + * partial_sort=partial_sort, + * max_iter=max_iter, */ + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma_min, __pyx_t_3) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* function exit code */ - __pyx_L1_error:; - __Pyx_WriteUnraisable("l0learn.interface._L0LearnFit_sparse", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); - __Pyx_pretend_to_initialize(&__pyx_r); - __pyx_L0:; - __Pyx_TraceReturn(Py_None, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "l0learn/interface.pyx":584 + * gamma_max=gamma_max, + * gamma_min=gamma_min, + * partial_sort=partial_sort, # <<<<<<<<<<<<<< + * max_iter=max_iter, + * rtol=rtol, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_partial_sort, __pyx_v_partial_sort) < 0) __PYX_ERR(0, 574, __pyx_L1_error) -/* "l0learn/interface.pyx":749 - * - * - * cdef cvfitmodel _L0LearnCV_dense(const dmat& X, # <<<<<<<<<<<<<< - * const dvec& y, - * const string Loss, + /* "l0learn/interface.pyx":585 + * gamma_min=gamma_min, + * partial_sort=partial_sort, + * max_iter=max_iter, # <<<<<<<<<<<<<< + * rtol=rtol, + * atol=atol, */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_iter, __pyx_v_max_iter) < 0) __PYX_ERR(0, 574, __pyx_L1_error) -static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_dense(arma::dmat const &__pyx_v_X, arma::dvec const &__pyx_v_y, std::string const __pyx_v_Loss, std::string const __pyx_v_Penalty, std::string const __pyx_v_Algorithm, size_t const __pyx_v_NnzStopNum, size_t const __pyx_v_G_ncols, size_t const __pyx_v_G_nrows, double const __pyx_v_Lambda2Max, double const __pyx_v_Lambda2Min, bool const __pyx_v_PartialSort, size_t const __pyx_v_MaxIters, double const __pyx_v_rtol, double const __pyx_v_atol, bool const __pyx_v_ActiveSet, size_t const __pyx_v_ActiveSetNum, size_t const __pyx_v_MaxNumSwaps, double const __pyx_v_ScaleDownFactor, size_t const __pyx_v_ScreenSize, bool const __pyx_v_LambdaU, std::vector > const &__pyx_v_Lambdas, unsigned int const __pyx_v_nfolds, double const __pyx_v_seed, size_t const __pyx_v_ExcludeFirstK, bool const __pyx_v_Intercept, bool const __pyx_v_withBounds, arma::dvec const &__pyx_v_Lows, arma::dvec const &__pyx_v_Highs) { - cvfitmodel __pyx_r; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("_L0LearnCV_dense", 0); - __Pyx_TraceCall("_L0LearnCV_dense", __pyx_f[0], 749, 0, __PYX_ERR(0, 749, __pyx_L1_error)); + /* "l0learn/interface.pyx":586 + * partial_sort=partial_sort, + * max_iter=max_iter, + * rtol=rtol, # <<<<<<<<<<<<<< + * atol=atol, + * active_set=active_set, + */ + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_rtol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 586, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_rtol, __pyx_t_3) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":777 - * const dvec &Lows, - * const dvec &Highs): - * return L0LearnCV[dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< - * MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, - * Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs) + /* "l0learn/interface.pyx":587 + * max_iter=max_iter, + * rtol=rtol, + * atol=atol, # <<<<<<<<<<<<<< + * active_set=active_set, + * active_set_num=active_set_num, */ - __Pyx_TraceLine(777,0,__PYX_ERR(0, 777, __pyx_L1_error)) - __pyx_r = L0LearnCV(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_nfolds, __pyx_v_seed, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); - goto __pyx_L0; + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_atol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 587, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_atol, __pyx_t_3) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":749 - * - * - * cdef cvfitmodel _L0LearnCV_dense(const dmat& X, # <<<<<<<<<<<<<< - * const dvec& y, - * const string Loss, + /* "l0learn/interface.pyx":588 + * rtol=rtol, + * atol=atol, + * active_set=active_set, # <<<<<<<<<<<<<< + * active_set_num=active_set_num, + * max_swaps=max_swaps, */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_active_set, __pyx_v_active_set) < 0) __PYX_ERR(0, 574, __pyx_L1_error) - /* function exit code */ - __pyx_L1_error:; - __Pyx_WriteUnraisable("l0learn.interface._L0LearnCV_dense", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); - __Pyx_pretend_to_initialize(&__pyx_r); - __pyx_L0:; - __Pyx_TraceReturn(Py_None, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "l0learn/interface.pyx":589 + * atol=atol, + * active_set=active_set, + * active_set_num=active_set_num, # <<<<<<<<<<<<<< + * max_swaps=max_swaps, + * scale_down_factor=scale_down_factor, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_active_set_num, __pyx_v_active_set_num) < 0) __PYX_ERR(0, 574, __pyx_L1_error) -/* "l0learn/interface.pyx":782 - * - * - * cdef cvfitmodel _L0LearnCV_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< - * const dvec& y, - * const string Loss, + /* "l0learn/interface.pyx":590 + * active_set=active_set, + * active_set_num=active_set_num, + * max_swaps=max_swaps, # <<<<<<<<<<<<<< + * scale_down_factor=scale_down_factor, + * screen_size=screen_size, */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_swaps, __pyx_v_max_swaps) < 0) __PYX_ERR(0, 574, __pyx_L1_error) -static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_sparse(arma::sp_dmat const &__pyx_v_X, arma::dvec const &__pyx_v_y, std::string const __pyx_v_Loss, std::string const __pyx_v_Penalty, std::string const __pyx_v_Algorithm, size_t const __pyx_v_NnzStopNum, size_t const __pyx_v_G_ncols, size_t const __pyx_v_G_nrows, double const __pyx_v_Lambda2Max, double const __pyx_v_Lambda2Min, bool const __pyx_v_PartialSort, size_t const __pyx_v_MaxIters, double const __pyx_v_rtol, double const __pyx_v_atol, bool const __pyx_v_ActiveSet, size_t const __pyx_v_ActiveSetNum, size_t const __pyx_v_MaxNumSwaps, double const __pyx_v_ScaleDownFactor, size_t const __pyx_v_ScreenSize, bool const __pyx_v_LambdaU, std::vector > const &__pyx_v_Lambdas, unsigned int const __pyx_v_nfolds, double const __pyx_v_seed, size_t const __pyx_v_ExcludeFirstK, bool const __pyx_v_Intercept, bool const __pyx_v_withBounds, arma::dvec const &__pyx_v_Lows, arma::dvec const &__pyx_v_Highs) { - cvfitmodel __pyx_r; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("_L0LearnCV_sparse", 0); - __Pyx_TraceCall("_L0LearnCV_sparse", __pyx_f[0], 782, 0, __PYX_ERR(0, 782, __pyx_L1_error)); + /* "l0learn/interface.pyx":591 + * active_set_num=active_set_num, + * max_swaps=max_swaps, + * scale_down_factor=scale_down_factor, # <<<<<<<<<<<<<< + * screen_size=screen_size, + * lambda_grid=lambda_grid, + */ + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_scale_down_factor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 591, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_scale_down_factor, __pyx_t_3) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":810 - * const dvec &Lows, - * const dvec &Highs): - * return L0LearnCV[sp_dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< - * MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, - * Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs) + /* "l0learn/interface.pyx":592 + * max_swaps=max_swaps, + * scale_down_factor=scale_down_factor, + * screen_size=screen_size, # <<<<<<<<<<<<<< + * lambda_grid=lambda_grid, + * exclude_first_k=exclude_first_k, */ - __Pyx_TraceLine(810,0,__PYX_ERR(0, 810, __pyx_L1_error)) - __pyx_r = L0LearnCV(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_nfolds, __pyx_v_seed, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); - goto __pyx_L0; + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_screen_size, __pyx_v_screen_size) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + + /* "l0learn/interface.pyx":593 + * scale_down_factor=scale_down_factor, + * screen_size=screen_size, + * lambda_grid=lambda_grid, # <<<<<<<<<<<<<< + * exclude_first_k=exclude_first_k, + * intercept=intercept, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lambda_grid, __pyx_v_lambda_grid) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + + /* "l0learn/interface.pyx":594 + * screen_size=screen_size, + * lambda_grid=lambda_grid, + * exclude_first_k=exclude_first_k, # <<<<<<<<<<<<<< + * intercept=intercept, + * lows=lows, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_exclude_first_k, __pyx_v_exclude_first_k) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + + /* "l0learn/interface.pyx":595 + * lambda_grid=lambda_grid, + * exclude_first_k=exclude_first_k, + * intercept=intercept, # <<<<<<<<<<<<<< + * lows=lows, + * highs=highs) + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 574, __pyx_L1_error) - /* "l0learn/interface.pyx":782 - * + /* "l0learn/interface.pyx":596 + * exclude_first_k=exclude_first_k, + * intercept=intercept, + * lows=lows, # <<<<<<<<<<<<<< + * highs=highs) * - * cdef cvfitmodel _L0LearnCV_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< - * const dvec& y, - * const string Loss, */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lows, __pyx_v_lows) < 0) __PYX_ERR(0, 574, __pyx_L1_error) - /* function exit code */ - __pyx_L1_error:; - __Pyx_WriteUnraisable("l0learn.interface._L0LearnCV_sparse", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); - __Pyx_pretend_to_initialize(&__pyx_r); - __pyx_L0:; - __Pyx_TraceReturn(Py_None, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":735 - * ctypedef npy_cdouble complex_t - * - * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(1, a) + /* "l0learn/interface.pyx":597 + * intercept=intercept, + * lows=lows, + * highs=highs) # <<<<<<<<<<<<<< * + * max_support_size = check["max_support_size"] */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_highs, __pyx_v_highs) < 0) __PYX_ERR(0, 574, __pyx_L1_error) -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); - __Pyx_TraceCall("PyArray_MultiIterNew1", __pyx_f[1], 735, 0, __PYX_ERR(1, 735, __pyx_L1_error)); - - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":736 - * - * cdef inline object PyArray_MultiIterNew1(a): - * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< + /* "l0learn/interface.pyx":574 + * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.CVFitModel: * - * cdef inline object PyArray_MultiIterNew2(a, b): + * check = _fit_check(X=X, # <<<<<<<<<<<<<< + * y=y, + * loss=loss, */ - __Pyx_TraceLine(736,0,__PYX_ERR(1, 736, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 736, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_check = __pyx_t_3; + __pyx_t_3 = 0; - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":735 - * ctypedef npy_cdouble complex_t - * - * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(1, a) + /* "l0learn/interface.pyx":599 + * highs=highs) * + * max_support_size = check["max_support_size"] # <<<<<<<<<<<<<< + * screen_size = check["screen_size"] + * y = check['y'] */ + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_max_support_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 599, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_max_support_size, __pyx_t_3); + __pyx_t_3 = 0; - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":738 - * return PyArray_MultiIterNew(1, a) - * - * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(2, a, b) + /* "l0learn/interface.pyx":600 * + * max_support_size = check["max_support_size"] + * screen_size = check["screen_size"] # <<<<<<<<<<<<<< + * y = check['y'] + * penalty = check['penalty'] */ + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_screen_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_screen_size, __pyx_t_3); + __pyx_t_3 = 0; -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); - __Pyx_TraceCall("PyArray_MultiIterNew2", __pyx_f[1], 738, 0, __PYX_ERR(1, 738, __pyx_L1_error)); - - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":739 - * - * cdef inline object PyArray_MultiIterNew2(a, b): - * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< - * - * cdef inline object PyArray_MultiIterNew3(a, b, c): + /* "l0learn/interface.pyx":601 + * max_support_size = check["max_support_size"] + * screen_size = check["screen_size"] + * y = check['y'] # <<<<<<<<<<<<<< + * penalty = check['penalty'] + * gamma_max = check['gamma_max'] */ - __Pyx_TraceLine(739,0,__PYX_ERR(1, 739, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 739, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_y); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 601, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_y, __pyx_t_3); + __pyx_t_3 = 0; - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":738 - * return PyArray_MultiIterNew(1, a) - * - * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(2, a, b) - * + /* "l0learn/interface.pyx":602 + * screen_size = check["screen_size"] + * y = check['y'] + * penalty = check['penalty'] # <<<<<<<<<<<<<< + * gamma_max = check['gamma_max'] + * gamma_min = check['gamma_min'] */ + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_penalty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 602, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (!(likely(PyUnicode_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(0, 602, __pyx_L1_error) + __Pyx_DECREF_SET(__pyx_v_penalty, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "l0learn/interface.pyx":603 + * y = check['y'] + * penalty = check['penalty'] + * gamma_max = check['gamma_max'] # <<<<<<<<<<<<<< + * gamma_min = check['gamma_min'] + * lambda_grid = check['lambda_grid'] + */ + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 603, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 603, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_gamma_max = __pyx_t_4; -/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":741 - * return PyArray_MultiIterNew(2, a, b) - * - * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(3, a, b, c) - * + /* "l0learn/interface.pyx":604 + * penalty = check['penalty'] + * gamma_max = check['gamma_max'] + * gamma_min = check['gamma_min'] # <<<<<<<<<<<<<< + * lambda_grid = check['lambda_grid'] + * num_gamma = check['num_gamma'] */ + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_gamma_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 604, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 604, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_gamma_min = __pyx_t_4; -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); - __Pyx_TraceCall("PyArray_MultiIterNew3", __pyx_f[1], 741, 0, __PYX_ERR(1, 741, __pyx_L1_error)); + /* "l0learn/interface.pyx":605 + * gamma_max = check['gamma_max'] + * gamma_min = check['gamma_min'] + * lambda_grid = check['lambda_grid'] # <<<<<<<<<<<<<< + * num_gamma = check['num_gamma'] + * num_lambda = check['num_lambda'] + */ + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_lambda_grid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 605, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_lambda_grid, __pyx_t_3); + __pyx_t_3 = 0; - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":742 - * - * cdef inline object PyArray_MultiIterNew3(a, b, c): - * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< - * - * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + /* "l0learn/interface.pyx":606 + * gamma_min = check['gamma_min'] + * lambda_grid = check['lambda_grid'] + * num_gamma = check['num_gamma'] # <<<<<<<<<<<<<< + * num_lambda = check['num_lambda'] + * auto_lambda = check['auto_lambda'] */ - __Pyx_TraceLine(742,0,__PYX_ERR(1, 742, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 742, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_num_gamma); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 606, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_num_gamma, __pyx_t_3); + __pyx_t_3 = 0; - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":741 - * return PyArray_MultiIterNew(2, a, b) - * - * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(3, a, b, c) - * + /* "l0learn/interface.pyx":607 + * lambda_grid = check['lambda_grid'] + * num_gamma = check['num_gamma'] + * num_lambda = check['num_lambda'] # <<<<<<<<<<<<<< + * auto_lambda = check['auto_lambda'] + * with_bounds = check['with_bounds'] */ + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_num_lambda); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 607, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_num_lambda, __pyx_t_3); + __pyx_t_3 = 0; - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "l0learn/interface.pyx":608 + * num_gamma = check['num_gamma'] + * num_lambda = check['num_lambda'] + * auto_lambda = check['auto_lambda'] # <<<<<<<<<<<<<< + * with_bounds = check['with_bounds'] + * lows = check['lows'] + */ + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_auto_lambda); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 608, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_auto_lambda = __pyx_t_3; + __pyx_t_3 = 0; -/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":744 - * return PyArray_MultiIterNew(3, a, b, c) - * - * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(4, a, b, c, d) + /* "l0learn/interface.pyx":609 + * num_lambda = check['num_lambda'] + * auto_lambda = check['auto_lambda'] + * with_bounds = check['with_bounds'] # <<<<<<<<<<<<<< + * lows = check['lows'] + * highs = check['highs'] + */ + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_with_bounds); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 609, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_with_bounds = __pyx_t_3; + __pyx_t_3 = 0; + + /* "l0learn/interface.pyx":610 + * auto_lambda = check['auto_lambda'] + * with_bounds = check['with_bounds'] + * lows = check['lows'] # <<<<<<<<<<<<<< + * highs = check['highs'] * */ + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_lows); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 610, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_3); + __pyx_t_3 = 0; -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); - __Pyx_TraceCall("PyArray_MultiIterNew4", __pyx_f[1], 744, 0, __PYX_ERR(1, 744, __pyx_L1_error)); + /* "l0learn/interface.pyx":611 + * with_bounds = check['with_bounds'] + * lows = check['lows'] + * highs = check['highs'] # <<<<<<<<<<<<<< + * + * _, p = X.shape + */ + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_highs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 611, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_3); + __pyx_t_3 = 0; - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":745 + /* "l0learn/interface.pyx":613 + * highs = check['highs'] * - * cdef inline object PyArray_MultiIterNew4(a, b, c, d): - * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< + * _, p = X.shape # <<<<<<<<<<<<<< * - * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + * if not isinstance(num_folds, int) or num_folds < 2 or num_folds > p: */ - __Pyx_TraceLine(745,0,__PYX_ERR(1, 745, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 745, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 613, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { + PyObject* sequence = __pyx_t_3; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 613, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_1 = PyTuple_GET_ITEM(sequence, 1); + } else { + __pyx_t_2 = PyList_GET_ITEM(sequence, 0); + __pyx_t_1 = PyList_GET_ITEM(sequence, 1); + } + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + #else + __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 613, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 613, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_5 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 613, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext; + index = 0; __pyx_t_2 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed; + __Pyx_GOTREF(__pyx_t_2); + index = 1; __pyx_t_1 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_1)) goto __pyx_L3_unpacking_failed; + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 2) < 0) __PYX_ERR(0, 613, __pyx_L1_error) + __pyx_t_6 = NULL; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L4_unpacking_done; + __pyx_L3_unpacking_failed:; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_6 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 613, __pyx_L1_error) + __pyx_L4_unpacking_done:; + } + __pyx_v__ = __pyx_t_2; + __pyx_t_2 = 0; + __pyx_v_p = __pyx_t_1; __pyx_t_1 = 0; - goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":744 - * return PyArray_MultiIterNew(3, a, b, c) + /* "l0learn/interface.pyx":615 + * _, p = X.shape * - * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(4, a, b, c, d) + * if not isinstance(num_folds, int) or num_folds < 2 or num_folds > p: # <<<<<<<<<<<<<< + * raise ValueError(f"expected num_folds parameter to be a positive integer less than {p}, but got {num_folds}") * */ + __pyx_t_8 = PyInt_Check(__pyx_v_num_folds); + __pyx_t_9 = ((!(__pyx_t_8 != 0)) != 0); + if (!__pyx_t_9) { + } else { + __pyx_t_7 = __pyx_t_9; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_3 = PyObject_RichCompare(__pyx_v_num_folds, __pyx_int_2, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 615, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 615, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!__pyx_t_9) { + } else { + __pyx_t_7 = __pyx_t_9; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_3 = PyObject_RichCompare(__pyx_v_num_folds, __pyx_v_p, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 615, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 615, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = __pyx_t_9; + __pyx_L6_bool_binop_done:; + if (unlikely(__pyx_t_7)) { - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":747 - * return PyArray_MultiIterNew(4, a, b, c, d) + /* "l0learn/interface.pyx":616 + * + * if not isinstance(num_folds, int) or num_folds < 2 or num_folds > p: + * raise ValueError(f"expected num_folds parameter to be a positive integer less than {p}, but got {num_folds}") # <<<<<<<<<<<<<< * - * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(5, a, b, c, d, e) * */ + __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_10 = 0; + __pyx_t_11 = 127; + __Pyx_INCREF(__pyx_kp_u_expected_num_folds_parameter_to); + __pyx_t_10 += 64; + __Pyx_GIVEREF(__pyx_kp_u_expected_num_folds_parameter_to); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_num_folds_parameter_to); + __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_11 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) > __pyx_t_11) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) : __pyx_t_11; + __pyx_t_10 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); + __pyx_t_1 = 0; + __Pyx_INCREF(__pyx_kp_u_but_got); + __pyx_t_10 += 10; + __Pyx_GIVEREF(__pyx_kp_u_but_got); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_but_got); + __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_num_folds, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_11 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) > __pyx_t_11) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) : __pyx_t_11; + __pyx_t_10 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_10, __pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 616, __pyx_L1_error) -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); - __Pyx_TraceCall("PyArray_MultiIterNew5", __pyx_f[1], 747, 0, __PYX_ERR(1, 747, __pyx_L1_error)); - - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":748 + /* "l0learn/interface.pyx":615 + * _, p = X.shape * - * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): - * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< + * if not isinstance(num_folds, int) or num_folds < 2 or num_folds > p: # <<<<<<<<<<<<<< + * raise ValueError(f"expected num_folds parameter to be a positive integer less than {p}, but got {num_folds}") * - * cdef inline tuple PyDataType_SHAPE(dtype d): */ - __Pyx_TraceLine(748,0,__PYX_ERR(1, 748, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 748, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + } - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":747 - * return PyArray_MultiIterNew(4, a, b, c, d) - * - * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(5, a, b, c, d, e) + /* "l0learn/interface.pyx":620 * + * cdef vector[vector[double]] c_lambda_grid + * try: # <<<<<<<<<<<<<< + * c_lambda_grid = lambda_grid + * except TypeError: */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14); + __Pyx_XGOTREF(__pyx_t_12); + __Pyx_XGOTREF(__pyx_t_13); + __Pyx_XGOTREF(__pyx_t_14); + /*try:*/ { - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "l0learn/interface.pyx":621 + * cdef vector[vector[double]] c_lambda_grid + * try: + * c_lambda_grid = lambda_grid # <<<<<<<<<<<<<< + * except TypeError: + * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") + */ + __pyx_t_15 = __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_lambda_grid); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 621, __pyx_L9_error) + __pyx_v_c_lambda_grid = __pyx_t_15; -/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":750 - * return PyArray_MultiIterNew(5, a, b, c, d, e) + /* "l0learn/interface.pyx":620 * - * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< - * if PyDataType_HASSUBARRAY(d): - * return d.subarray.shape + * cdef vector[vector[double]] c_lambda_grid + * try: # <<<<<<<<<<<<<< + * c_lambda_grid = lambda_grid + * except TypeError: */ + } + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + goto __pyx_L14_try_end; + __pyx_L9_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; -static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); - __Pyx_TraceCall("PyDataType_SHAPE", __pyx_f[1], 750, 0, __PYX_ERR(1, 750, __pyx_L1_error)); + /* "l0learn/interface.pyx":622 + * try: + * c_lambda_grid = lambda_grid + * except TypeError: # <<<<<<<<<<<<<< + * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") + * + */ + __pyx_t_16 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); + if (__pyx_t_16) { + __Pyx_AddTraceback("l0learn.interface.cvfit", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_1, &__pyx_t_2) < 0) __PYX_ERR(0, 622, __pyx_L11_except_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_t_2); - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":751 + /* "l0learn/interface.pyx":623 + * c_lambda_grid = lambda_grid + * except TypeError: + * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") # <<<<<<<<<<<<<< * - * cdef inline tuple PyDataType_SHAPE(dtype d): - * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< - * return d.subarray.shape - * else: + * cdef string c_loss = loss.encode('UTF-8') */ - __Pyx_TraceLine(751,0,__PYX_ERR(1, 751, __pyx_L1_error)) - __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); - if (__pyx_t_1) { + __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 623, __pyx_L11_except_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_17 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_be_a_lis, __pyx_t_5); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 623, __pyx_L11_except_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_17); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 623, __pyx_L11_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(0, 623, __pyx_L11_except_error) + } + goto __pyx_L11_except_error; + __pyx_L11_except_error:; - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":752 - * cdef inline tuple PyDataType_SHAPE(dtype d): - * if PyDataType_HASSUBARRAY(d): - * return d.subarray.shape # <<<<<<<<<<<<<< - * else: - * return () + /* "l0learn/interface.pyx":620 + * + * cdef vector[vector[double]] c_lambda_grid + * try: # <<<<<<<<<<<<<< + * c_lambda_grid = lambda_grid + * except TypeError: */ - __Pyx_TraceLine(752,0,__PYX_ERR(1, 752, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); - __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); - goto __pyx_L0; + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_XGIVEREF(__pyx_t_13); + __Pyx_XGIVEREF(__pyx_t_14); + __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14); + goto __pyx_L1_error; + __pyx_L14_try_end:; + } - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":751 + /* "l0learn/interface.pyx":625 + * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") * - * cdef inline tuple PyDataType_SHAPE(dtype d): - * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< - * return d.subarray.shape - * else: + * cdef string c_loss = loss.encode('UTF-8') # <<<<<<<<<<<<<< + * cdef string c_penalty = penalty.encode('UTF-8') + * cdef string c_algorithim = algorithm.encode('UTF-8') */ + if (unlikely(__pyx_v_loss == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); + __PYX_ERR(0, 625, __pyx_L1_error) } + __pyx_t_2 = PyUnicode_AsUTF8String(__pyx_v_loss); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_18 = __pyx_convert_string_from_py_std__in_string(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 625, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_c_loss = __pyx_t_18; - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":754 - * return d.subarray.shape - * else: - * return () # <<<<<<<<<<<<<< + /* "l0learn/interface.pyx":626 * + * cdef string c_loss = loss.encode('UTF-8') + * cdef string c_penalty = penalty.encode('UTF-8') # <<<<<<<<<<<<<< + * cdef string c_algorithim = algorithm.encode('UTF-8') * */ - __Pyx_TraceLine(754,0,__PYX_ERR(1, 754, __pyx_L1_error)) - /*else*/ { - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_empty_tuple); - __pyx_r = __pyx_empty_tuple; - goto __pyx_L0; + if (unlikely(__pyx_v_penalty == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); + __PYX_ERR(0, 626, __pyx_L1_error) } + __pyx_t_2 = PyUnicode_AsUTF8String(__pyx_v_penalty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 626, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_18 = __pyx_convert_string_from_py_std__in_string(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 626, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_c_penalty = __pyx_t_18; - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":750 - * return PyArray_MultiIterNew(5, a, b, c, d, e) + /* "l0learn/interface.pyx":627 + * cdef string c_loss = loss.encode('UTF-8') + * cdef string c_penalty = penalty.encode('UTF-8') + * cdef string c_algorithim = algorithm.encode('UTF-8') # <<<<<<<<<<<<<< * - * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< - * if PyDataType_HASSUBARRAY(d): - * return d.subarray.shape + * cdef cvfitmodel c_results */ + if (unlikely(__pyx_v_algorithm == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); + __PYX_ERR(0, 627, __pyx_L1_error) + } + __pyx_t_2 = PyUnicode_AsUTF8String(__pyx_v_algorithm); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 627, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_18 = __pyx_convert_string_from_py_std__in_string(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 627, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_c_algorithim = __pyx_t_18; - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("numpy.PyDataType_SHAPE", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":929 - * int _import_umath() except -1 + /* "l0learn/interface.pyx":630 * - * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< - * Py_INCREF(base) # important to do this before stealing the reference below! - * PyArray_SetBaseObject(arr, base) + * cdef cvfitmodel c_results + * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< + * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), + * y=numpy_to_dvec_d(y), */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 630, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 630, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_7 = PyObject_IsInstance(__pyx_v_X, __pyx_t_1); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 630, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_9 = (__pyx_t_7 != 0); + if (__pyx_t_9) { -static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("set_array_base", 0); - __Pyx_TraceCall("set_array_base", __pyx_f[1], 929, 0, __PYX_ERR(1, 929, __pyx_L1_error)); + /* "l0learn/interface.pyx":631 + * cdef cvfitmodel c_results + * if isinstance(X, np.ndarray): + * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< + * y=numpy_to_dvec_d(y), + * Loss=c_loss, + */ + if (!(likely(((__pyx_v_X) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_X, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 631, __pyx_L1_error) - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":930 - * - * cdef inline void set_array_base(ndarray arr, object base): - * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< - * PyArray_SetBaseObject(arr, base) - * + /* "l0learn/interface.pyx":632 + * if isinstance(X, np.ndarray): + * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), + * y=numpy_to_dvec_d(y), # <<<<<<<<<<<<<< + * Loss=c_loss, + * Penalty=c_penalty, */ - __Pyx_TraceLine(930,0,__PYX_ERR(1, 930, __pyx_L1_error)) - Py_INCREF(__pyx_v_base); + if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 632, __pyx_L1_error) - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":931 - * cdef inline void set_array_base(ndarray arr, object base): - * Py_INCREF(base) # important to do this before stealing the reference below! - * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< - * - * cdef inline object get_array_base(ndarray arr): + /* "l0learn/interface.pyx":636 + * Penalty=c_penalty, + * Algorithm=c_algorithim, + * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< + * G_ncols=num_lambda, + * G_nrows=num_gamma, */ - __Pyx_TraceLine(931,0,__PYX_ERR(1, 931, __pyx_L1_error)) - (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); + __pyx_t_19 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_19 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 636, __pyx_L1_error) - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":929 - * int _import_umath() except -1 - * - * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< - * Py_INCREF(base) # important to do this before stealing the reference below! - * PyArray_SetBaseObject(arr, base) + /* "l0learn/interface.pyx":637 + * Algorithm=c_algorithim, + * NnzStopNum=max_support_size, + * G_ncols=num_lambda, # <<<<<<<<<<<<<< + * G_nrows=num_gamma, + * Lambda2Max=gamma_max, */ + __pyx_t_20 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_20 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 637, __pyx_L1_error) - /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_WriteUnraisable("numpy.set_array_base", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); - __pyx_L0:; - __Pyx_TraceReturn(Py_None, 0); - __Pyx_RefNannyFinishContext(); -} + /* "l0learn/interface.pyx":638 + * NnzStopNum=max_support_size, + * G_ncols=num_lambda, + * G_nrows=num_gamma, # <<<<<<<<<<<<<< + * Lambda2Max=gamma_max, + * Lambda2Min=gamma_min, + */ + __pyx_t_21 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_21 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 638, __pyx_L1_error) -/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":933 - * PyArray_SetBaseObject(arr, base) - * - * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< - * base = PyArray_BASE(arr) - * if base is NULL: + /* "l0learn/interface.pyx":641 + * Lambda2Max=gamma_max, + * Lambda2Min=gamma_min, + * PartialSort=partial_sort, # <<<<<<<<<<<<<< + * MaxIters=max_iter, + * rtol=rtol, */ + __pyx_t_22 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_22 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 641, __pyx_L1_error) -static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { - PyObject *__pyx_v_base; - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - int __pyx_t_1; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_array_base", 0); - __Pyx_TraceCall("get_array_base", __pyx_f[1], 933, 0, __PYX_ERR(1, 933, __pyx_L1_error)); + /* "l0learn/interface.pyx":642 + * Lambda2Min=gamma_min, + * PartialSort=partial_sort, + * MaxIters=max_iter, # <<<<<<<<<<<<<< + * rtol=rtol, + * atol=atol, + */ + __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 642, __pyx_L1_error) - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":934 - * - * cdef inline object get_array_base(ndarray arr): - * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< - * if base is NULL: - * return None + /* "l0learn/interface.pyx":645 + * rtol=rtol, + * atol=atol, + * ActiveSet=active_set, # <<<<<<<<<<<<<< + * ActiveSetNum=active_set_num, + * MaxNumSwaps=max_swaps, */ - __Pyx_TraceLine(934,0,__PYX_ERR(1, 934, __pyx_L1_error)) - __pyx_v_base = PyArray_BASE(__pyx_v_arr); + __pyx_t_24 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_24 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 645, __pyx_L1_error) - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":935 - * cdef inline object get_array_base(ndarray arr): - * base = PyArray_BASE(arr) - * if base is NULL: # <<<<<<<<<<<<<< - * return None - * return base + /* "l0learn/interface.pyx":646 + * atol=atol, + * ActiveSet=active_set, + * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< + * MaxNumSwaps=max_swaps, + * ScaleDownFactor=scale_down_factor, */ - __Pyx_TraceLine(935,0,__PYX_ERR(1, 935, __pyx_L1_error)) - __pyx_t_1 = ((__pyx_v_base == NULL) != 0); - if (__pyx_t_1) { + __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 646, __pyx_L1_error) + + /* "l0learn/interface.pyx":647 + * ActiveSet=active_set, + * ActiveSetNum=active_set_num, + * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< + * ScaleDownFactor=scale_down_factor, + * ScreenSize=screen_size, + */ + __pyx_t_26 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_26 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 647, __pyx_L1_error) + + /* "l0learn/interface.pyx":649 + * MaxNumSwaps=max_swaps, + * ScaleDownFactor=scale_down_factor, + * ScreenSize=screen_size, # <<<<<<<<<<<<<< + * LambdaU=not auto_lambda, + * Lambdas=c_lambda_grid, + */ + __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 649, __pyx_L1_error) + + /* "l0learn/interface.pyx":650 + * ScaleDownFactor=scale_down_factor, + * ScreenSize=screen_size, + * LambdaU=not auto_lambda, # <<<<<<<<<<<<<< + * Lambdas=c_lambda_grid, + * nfolds=num_folds, + */ + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 650, __pyx_L1_error) + + /* "l0learn/interface.pyx":652 + * LambdaU=not auto_lambda, + * Lambdas=c_lambda_grid, + * nfolds=num_folds, # <<<<<<<<<<<<<< + * seed=seed, + * ExcludeFirstK=exclude_first_k, + */ + __pyx_t_28 = __Pyx_PyInt_As_unsigned_int(__pyx_v_num_folds); if (unlikely((__pyx_t_28 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 652, __pyx_L1_error) - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":936 - * base = PyArray_BASE(arr) - * if base is NULL: - * return None # <<<<<<<<<<<<<< - * return base - * + /* "l0learn/interface.pyx":653 + * Lambdas=c_lambda_grid, + * nfolds=num_folds, + * seed=seed, # <<<<<<<<<<<<<< + * ExcludeFirstK=exclude_first_k, + * Intercept=intercept, */ - __Pyx_TraceLine(936,0,__PYX_ERR(1, 936, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_r = Py_None; __Pyx_INCREF(Py_None); - goto __pyx_L0; + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_seed); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 653, __pyx_L1_error) - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":935 - * cdef inline object get_array_base(ndarray arr): - * base = PyArray_BASE(arr) - * if base is NULL: # <<<<<<<<<<<<<< - * return None - * return base + /* "l0learn/interface.pyx":654 + * nfolds=num_folds, + * seed=seed, + * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< + * Intercept=intercept, + * withBounds=with_bounds, */ - } + __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 654, __pyx_L1_error) - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":937 - * if base is NULL: - * return None - * return base # <<<<<<<<<<<<<< - * - * # Versions of the import_* functions which are more suitable for + /* "l0learn/interface.pyx":655 + * seed=seed, + * ExcludeFirstK=exclude_first_k, + * Intercept=intercept, # <<<<<<<<<<<<<< + * withBounds=with_bounds, + * Lows=numpy_to_dvec_d(lows), */ - __Pyx_TraceLine(937,0,__PYX_ERR(1, 937, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_base)); - __pyx_r = ((PyObject *)__pyx_v_base); - goto __pyx_L0; + __pyx_t_30 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_30 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 655, __pyx_L1_error) - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":933 - * PyArray_SetBaseObject(arr, base) - * - * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< - * base = PyArray_BASE(arr) - * if base is NULL: + /* "l0learn/interface.pyx":656 + * ExcludeFirstK=exclude_first_k, + * Intercept=intercept, + * withBounds=with_bounds, # <<<<<<<<<<<<<< + * Lows=numpy_to_dvec_d(lows), + * Highs=numpy_to_dvec_d(highs)) */ + __pyx_t_31 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_31 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 656, __pyx_L1_error) - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("numpy.get_array_base", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "l0learn/interface.pyx":657 + * Intercept=intercept, + * withBounds=with_bounds, + * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< + * Highs=numpy_to_dvec_d(highs)) + * else: # isinstance(X, csc_matrix) + */ + if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 657, __pyx_L1_error) -/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":941 - * # Versions of the import_* functions which are more suitable for - * # Cython code. - * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< - * try: - * __pyx_import_array() + /* "l0learn/interface.pyx":658 + * withBounds=with_bounds, + * Lows=numpy_to_dvec_d(lows), + * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< + * else: # isinstance(X, csc_matrix) + * c_results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), */ + if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 658, __pyx_L1_error) -static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { - int __pyx_r; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("import_array", 0); - __Pyx_TraceCall("import_array", __pyx_f[1], 941, 0, __PYX_ERR(1, 941, __pyx_L1_error)); + /* "l0learn/interface.pyx":631 + * cdef cvfitmodel c_results + * if isinstance(X, np.ndarray): + * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< + * y=numpy_to_dvec_d(y), + * Loss=c_loss, + */ + __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnCV_dense(__pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_X)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_19, __pyx_t_20, __pyx_t_21, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_22, __pyx_t_23, __pyx_v_rtol, __pyx_v_atol, __pyx_t_24, __pyx_t_25, __pyx_t_26, __pyx_v_scale_down_factor, __pyx_t_27, (!__pyx_t_9), __pyx_v_c_lambda_grid, __pyx_t_28, __pyx_t_4, __pyx_t_29, __pyx_t_30, __pyx_t_31, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":942 - * # Cython code. - * cdef inline int import_array() except -1: - * try: # <<<<<<<<<<<<<< - * __pyx_import_array() - * except Exception: + /* "l0learn/interface.pyx":630 + * + * cdef cvfitmodel c_results + * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< + * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), + * y=numpy_to_dvec_d(y), */ - __Pyx_TraceLine(942,0,__PYX_ERR(1, 942, __pyx_L1_error)) - { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); - __Pyx_XGOTREF(__pyx_t_1); - __Pyx_XGOTREF(__pyx_t_2); - __Pyx_XGOTREF(__pyx_t_3); - /*try:*/ { + goto __pyx_L17; + } - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":943 - * cdef inline int import_array() except -1: - * try: - * __pyx_import_array() # <<<<<<<<<<<<<< - * except Exception: - * raise ImportError("numpy.core.multiarray failed to import") + /* "l0learn/interface.pyx":660 + * Highs=numpy_to_dvec_d(highs)) + * else: # isinstance(X, csc_matrix) + * c_results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< + * y=numpy_to_dvec_d(y), + * Loss=c_loss, */ - __Pyx_TraceLine(943,0,__PYX_ERR(1, 943, __pyx_L3_error)) - __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 943, __pyx_L3_error) + /*else*/ { - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":942 - * # Cython code. - * cdef inline int import_array() except -1: - * try: # <<<<<<<<<<<<<< - * __pyx_import_array() - * except Exception: + /* "l0learn/interface.pyx":661 + * else: # isinstance(X, csc_matrix) + * c_results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), + * y=numpy_to_dvec_d(y), # <<<<<<<<<<<<<< + * Loss=c_loss, + * Penalty=c_penalty, */ - } - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - goto __pyx_L8_try_end; - __pyx_L3_error:; + if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 661, __pyx_L1_error) - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":944 - * try: - * __pyx_import_array() - * except Exception: # <<<<<<<<<<<<<< - * raise ImportError("numpy.core.multiarray failed to import") - * + /* "l0learn/interface.pyx":665 + * Penalty=c_penalty, + * Algorithm=c_algorithim, + * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< + * G_ncols=num_lambda, + * G_nrows=num_gamma, */ - __Pyx_TraceLine(944,0,__PYX_ERR(1, 944, __pyx_L5_except_error)) - __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); - if (__pyx_t_4) { - __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 944, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 665, __pyx_L1_error) - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":945 - * __pyx_import_array() - * except Exception: - * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< - * - * cdef inline int import_umath() except -1: + /* "l0learn/interface.pyx":666 + * Algorithm=c_algorithim, + * NnzStopNum=max_support_size, + * G_ncols=num_lambda, # <<<<<<<<<<<<<< + * G_nrows=num_gamma, + * Lambda2Max=gamma_max, */ - __Pyx_TraceLine(945,0,__PYX_ERR(1, 945, __pyx_L5_except_error)) - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 945, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(1, 945, __pyx_L5_except_error) - } - goto __pyx_L5_except_error; - __pyx_L5_except_error:; + __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 666, __pyx_L1_error) - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":942 - * # Cython code. - * cdef inline int import_array() except -1: - * try: # <<<<<<<<<<<<<< - * __pyx_import_array() - * except Exception: + /* "l0learn/interface.pyx":667 + * NnzStopNum=max_support_size, + * G_ncols=num_lambda, + * G_nrows=num_gamma, # <<<<<<<<<<<<<< + * Lambda2Max=gamma_max, + * Lambda2Min=gamma_min, */ - __Pyx_XGIVEREF(__pyx_t_1); - __Pyx_XGIVEREF(__pyx_t_2); - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); - goto __pyx_L1_error; - __pyx_L8_try_end:; - } + __pyx_t_26 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_26 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 667, __pyx_L1_error) - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":941 - * # Versions of the import_* functions which are more suitable for - * # Cython code. - * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< - * try: - * __pyx_import_array() + /* "l0learn/interface.pyx":670 + * Lambda2Max=gamma_max, + * Lambda2Min=gamma_min, + * PartialSort=partial_sort, # <<<<<<<<<<<<<< + * MaxIters=max_iter, + * rtol=rtol, */ + __pyx_t_31 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_31 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 670, __pyx_L1_error) - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_TraceReturn(Py_None, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "l0learn/interface.pyx":671 + * Lambda2Min=gamma_min, + * PartialSort=partial_sort, + * MaxIters=max_iter, # <<<<<<<<<<<<<< + * rtol=rtol, + * atol=atol, + */ + __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 671, __pyx_L1_error) -/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":947 - * raise ImportError("numpy.core.multiarray failed to import") - * - * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() + /* "l0learn/interface.pyx":674 + * rtol=rtol, + * atol=atol, + * ActiveSet=active_set, # <<<<<<<<<<<<<< + * ActiveSetNum=active_set_num, + * MaxNumSwaps=max_swaps, */ + __pyx_t_30 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_30 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 674, __pyx_L1_error) -static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { - int __pyx_r; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("import_umath", 0); - __Pyx_TraceCall("import_umath", __pyx_f[1], 947, 0, __PYX_ERR(1, 947, __pyx_L1_error)); + /* "l0learn/interface.pyx":675 + * atol=atol, + * ActiveSet=active_set, + * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< + * MaxNumSwaps=max_swaps, + * ScaleDownFactor=scale_down_factor, + */ + __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 675, __pyx_L1_error) - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":948 - * - * cdef inline int import_umath() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: + /* "l0learn/interface.pyx":676 + * ActiveSet=active_set, + * ActiveSetNum=active_set_num, + * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< + * ScaleDownFactor=scale_down_factor, + * ScreenSize=screen_size, */ - __Pyx_TraceLine(948,0,__PYX_ERR(1, 948, __pyx_L1_error)) - { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); - __Pyx_XGOTREF(__pyx_t_1); - __Pyx_XGOTREF(__pyx_t_2); - __Pyx_XGOTREF(__pyx_t_3); - /*try:*/ { + __pyx_t_21 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_21 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 676, __pyx_L1_error) - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":949 - * cdef inline int import_umath() except -1: - * try: - * _import_umath() # <<<<<<<<<<<<<< - * except Exception: - * raise ImportError("numpy.core.umath failed to import") + /* "l0learn/interface.pyx":678 + * MaxNumSwaps=max_swaps, + * ScaleDownFactor=scale_down_factor, + * ScreenSize=screen_size, # <<<<<<<<<<<<<< + * LambdaU=not auto_lambda, + * Lambdas=c_lambda_grid, */ - __Pyx_TraceLine(949,0,__PYX_ERR(1, 949, __pyx_L3_error)) - __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 949, __pyx_L3_error) + __pyx_t_20 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_20 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 678, __pyx_L1_error) - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":948 - * - * cdef inline int import_umath() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: + /* "l0learn/interface.pyx":679 + * ScaleDownFactor=scale_down_factor, + * ScreenSize=screen_size, + * LambdaU=not auto_lambda, # <<<<<<<<<<<<<< + * Lambdas=c_lambda_grid, + * nfolds=num_folds, */ - } - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - goto __pyx_L8_try_end; - __pyx_L3_error:; + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 679, __pyx_L1_error) - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":950 - * try: - * _import_umath() - * except Exception: # <<<<<<<<<<<<<< - * raise ImportError("numpy.core.umath failed to import") - * + /* "l0learn/interface.pyx":681 + * LambdaU=not auto_lambda, + * Lambdas=c_lambda_grid, + * nfolds=num_folds, # <<<<<<<<<<<<<< + * seed=seed, + * ExcludeFirstK=exclude_first_k, */ - __Pyx_TraceLine(950,0,__PYX_ERR(1, 950, __pyx_L5_except_error)) - __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); - if (__pyx_t_4) { - __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 950, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_28 = __Pyx_PyInt_As_unsigned_int(__pyx_v_num_folds); if (unlikely((__pyx_t_28 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 681, __pyx_L1_error) - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":951 - * _import_umath() - * except Exception: - * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< - * - * cdef inline int import_ufunc() except -1: + /* "l0learn/interface.pyx":682 + * Lambdas=c_lambda_grid, + * nfolds=num_folds, + * seed=seed, # <<<<<<<<<<<<<< + * ExcludeFirstK=exclude_first_k, + * Intercept=intercept, */ - __Pyx_TraceLine(951,0,__PYX_ERR(1, 951, __pyx_L5_except_error)) - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 951, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(1, 951, __pyx_L5_except_error) - } - goto __pyx_L5_except_error; - __pyx_L5_except_error:; + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_seed); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 682, __pyx_L1_error) - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":948 - * - * cdef inline int import_umath() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: + /* "l0learn/interface.pyx":683 + * nfolds=num_folds, + * seed=seed, + * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< + * Intercept=intercept, + * withBounds=with_bounds, */ - __Pyx_XGIVEREF(__pyx_t_1); - __Pyx_XGIVEREF(__pyx_t_2); - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); - goto __pyx_L1_error; - __pyx_L8_try_end:; - } + __pyx_t_19 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_19 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 683, __pyx_L1_error) - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":947 - * raise ImportError("numpy.core.multiarray failed to import") - * - * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() + /* "l0learn/interface.pyx":684 + * seed=seed, + * ExcludeFirstK=exclude_first_k, + * Intercept=intercept, # <<<<<<<<<<<<<< + * withBounds=with_bounds, + * Lows=numpy_to_dvec_d(lows), */ + __pyx_t_24 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_24 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 684, __pyx_L1_error) - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_TraceReturn(Py_None, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "l0learn/interface.pyx":685 + * ExcludeFirstK=exclude_first_k, + * Intercept=intercept, + * withBounds=with_bounds, # <<<<<<<<<<<<<< + * Lows=numpy_to_dvec_d(lows), + * Highs=numpy_to_dvec_d(highs)) + */ + __pyx_t_22 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_22 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 685, __pyx_L1_error) -/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":953 - * raise ImportError("numpy.core.umath failed to import") + /* "l0learn/interface.pyx":686 + * Intercept=intercept, + * withBounds=with_bounds, + * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< + * Highs=numpy_to_dvec_d(highs)) * - * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() */ + if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 686, __pyx_L1_error) -static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { - int __pyx_r; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("import_ufunc", 0); - __Pyx_TraceCall("import_ufunc", __pyx_f[1], 953, 0, __PYX_ERR(1, 953, __pyx_L1_error)); - - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":954 + /* "l0learn/interface.pyx":687 + * withBounds=with_bounds, + * Lows=numpy_to_dvec_d(lows), + * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< * - * cdef inline int import_ufunc() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: + * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, */ - __Pyx_TraceLine(954,0,__PYX_ERR(1, 954, __pyx_L1_error)) - { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); - __Pyx_XGOTREF(__pyx_t_1); - __Pyx_XGOTREF(__pyx_t_2); - __Pyx_XGOTREF(__pyx_t_3); - /*try:*/ { + if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 687, __pyx_L1_error) - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":955 - * cdef inline int import_ufunc() except -1: - * try: - * _import_umath() # <<<<<<<<<<<<<< - * except Exception: - * raise ImportError("numpy.core.umath failed to import") + /* "l0learn/interface.pyx":660 + * Highs=numpy_to_dvec_d(highs)) + * else: # isinstance(X, csc_matrix) + * c_results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< + * y=numpy_to_dvec_d(y), + * Loss=c_loss, */ - __Pyx_TraceLine(955,0,__PYX_ERR(1, 955, __pyx_L3_error)) - __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 955, __pyx_L3_error) + __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnCV_sparse(__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(__pyx_v_X), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_29, __pyx_t_27, __pyx_t_26, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_31, __pyx_t_25, __pyx_v_rtol, __pyx_v_atol, __pyx_t_30, __pyx_t_23, __pyx_t_21, __pyx_v_scale_down_factor, __pyx_t_20, (!__pyx_t_9), __pyx_v_c_lambda_grid, __pyx_t_28, __pyx_t_4, __pyx_t_19, __pyx_t_24, __pyx_t_22, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); + } + __pyx_L17:; - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":954 + /* "l0learn/interface.pyx":689 + * Highs=numpy_to_dvec_d(highs)) * - * cdef inline int import_ufunc() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: + * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, # <<<<<<<<<<<<<< + * lambda_0=c_results.Lambda0, + * gamma=c_results.Lambda12, */ - } - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - goto __pyx_L8_try_end; - __pyx_L3_error:; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_CVFitModel); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 689, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyDict_NewPresized(9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 689, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 689, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 689, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 689, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 689, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_settings, __pyx_t_3) < 0) __PYX_ERR(0, 689, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":956 - * try: - * _import_umath() - * except Exception: # <<<<<<<<<<<<<< - * raise ImportError("numpy.core.umath failed to import") + /* "l0learn/interface.pyx":690 * + * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, + * lambda_0=c_results.Lambda0, # <<<<<<<<<<<<<< + * gamma=c_results.Lambda12, + * support_size=c_results.NnzCount, + */ + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Lambda0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 690, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lambda_0, __pyx_t_3) < 0) __PYX_ERR(0, 689, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "l0learn/interface.pyx":691 + * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, + * lambda_0=c_results.Lambda0, + * gamma=c_results.Lambda12, # <<<<<<<<<<<<<< + * support_size=c_results.NnzCount, + * coeffs=sp_dmat_field_to_list(c_results.Beta), + */ + __pyx_t_3 = __pyx_convert_vector_to_py_double(__pyx_v_c_results.Lambda12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 691, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma, __pyx_t_3) < 0) __PYX_ERR(0, 689, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "l0learn/interface.pyx":692 + * lambda_0=c_results.Lambda0, + * gamma=c_results.Lambda12, + * support_size=c_results.NnzCount, # <<<<<<<<<<<<<< + * coeffs=sp_dmat_field_to_list(c_results.Beta), + * intercepts=c_results.Intercept, */ - __Pyx_TraceLine(956,0,__PYX_ERR(1, 956, __pyx_L5_except_error)) - __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); - if (__pyx_t_4) { - __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 956, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GOTREF(__pyx_t_6); - __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(__pyx_v_c_results.NnzCount); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 692, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_support_size, __pyx_t_3) < 0) __PYX_ERR(0, 689, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":957 - * _import_umath() - * except Exception: - * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< - * - * cdef extern from *: + /* "l0learn/interface.pyx":693 + * gamma=c_results.Lambda12, + * support_size=c_results.NnzCount, + * coeffs=sp_dmat_field_to_list(c_results.Beta), # <<<<<<<<<<<<<< + * intercepts=c_results.Intercept, + * converged=c_results.Converged, */ - __Pyx_TraceLine(957,0,__PYX_ERR(1, 957, __pyx_L5_except_error)) - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 957, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_Raise(__pyx_t_8, 0, 0, 0); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __PYX_ERR(1, 957, __pyx_L5_except_error) - } - goto __pyx_L5_except_error; - __pyx_L5_except_error:; + __pyx_t_3 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_c_results.Beta); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 693, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_coeffs, __pyx_t_3) < 0) __PYX_ERR(0, 689, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":954 - * - * cdef inline int import_ufunc() except -1: - * try: # <<<<<<<<<<<<<< - * _import_umath() - * except Exception: + /* "l0learn/interface.pyx":694 + * support_size=c_results.NnzCount, + * coeffs=sp_dmat_field_to_list(c_results.Beta), + * intercepts=c_results.Intercept, # <<<<<<<<<<<<<< + * converged=c_results.Converged, + * cv_means=dvec_field_to_list(c_results.CVMeans), */ - __Pyx_XGIVEREF(__pyx_t_1); - __Pyx_XGIVEREF(__pyx_t_2); - __Pyx_XGIVEREF(__pyx_t_3); - __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); - goto __pyx_L1_error; - __pyx_L8_try_end:; - } + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Intercept); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 694, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_intercepts, __pyx_t_3) < 0) __PYX_ERR(0, 689, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":953 - * raise ImportError("numpy.core.umath failed to import") - * - * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() + /* "l0learn/interface.pyx":695 + * coeffs=sp_dmat_field_to_list(c_results.Beta), + * intercepts=c_results.Intercept, + * converged=c_results.Converged, # <<<<<<<<<<<<<< + * cv_means=dvec_field_to_list(c_results.CVMeans), + * cv_sds=dvec_field_to_list(c_results.CVSDs)) */ + __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(__pyx_v_c_results.Converged); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 695, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_converged, __pyx_t_3) < 0) __PYX_ERR(0, 689, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_TraceReturn(Py_None, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "l0learn/interface.pyx":696 + * intercepts=c_results.Intercept, + * converged=c_results.Converged, + * cv_means=dvec_field_to_list(c_results.CVMeans), # <<<<<<<<<<<<<< + * cv_sds=dvec_field_to_list(c_results.CVSDs)) + * return results + */ + __pyx_t_3 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_c_results.CVMeans); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 696, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_cv_means, __pyx_t_3) < 0) __PYX_ERR(0, 689, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; -/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":967 - * + /* "l0learn/interface.pyx":697 + * converged=c_results.Converged, + * cv_means=dvec_field_to_list(c_results.CVMeans), + * cv_sds=dvec_field_to_list(c_results.CVSDs)) # <<<<<<<<<<<<<< + * return results * - * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< - * """ - * Cython equivalent of `isinstance(obj, np.timedelta64)` */ + __pyx_t_3 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_c_results.CVSDs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 697, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_cv_sds, __pyx_t_3) < 0) __PYX_ERR(0, 689, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; -static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_obj) { - int __pyx_r; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("is_timedelta64_object", 0); - __Pyx_TraceCall("is_timedelta64_object", __pyx_f[1], 967, 0, __PYX_ERR(1, 967, __pyx_L1_error)); + /* "l0learn/interface.pyx":689 + * Highs=numpy_to_dvec_d(highs)) + * + * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, # <<<<<<<<<<<<<< + * lambda_0=c_results.Lambda0, + * gamma=c_results.Lambda12, + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 689, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_results = __pyx_t_3; + __pyx_t_3 = 0; - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":979 - * bool - * """ - * return PyObject_TypeCheck(obj, &PyTimedeltaArrType_Type) # <<<<<<<<<<<<<< + /* "l0learn/interface.pyx":698 + * cv_means=dvec_field_to_list(c_results.CVMeans), + * cv_sds=dvec_field_to_list(c_results.CVSDs)) + * return results # <<<<<<<<<<<<<< * * */ - __Pyx_TraceLine(979,0,__PYX_ERR(1, 979, __pyx_L1_error)) - __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyTimedeltaArrType_Type)); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_results); + __pyx_r = __pyx_v_results; goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":967 + /* "l0learn/interface.pyx":547 * * - * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< - * """ - * Cython equivalent of `isinstance(obj, np.timedelta64)` + * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< + * y: np.ndarray, + * loss: str = "SquaredError", */ /* function exit code */ __pyx_L1_error:; - __Pyx_WriteUnraisable("numpy.is_timedelta64_object", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); - __pyx_r = 0; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_17); + __Pyx_AddTraceback("l0learn.interface.cvfit", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; __pyx_L0:; - __Pyx_TraceReturn(Py_None, 0); + __Pyx_XDECREF(__pyx_v_check); + __Pyx_XDECREF(__pyx_v_auto_lambda); + __Pyx_XDECREF(__pyx_v_with_bounds); + __Pyx_XDECREF(__pyx_v__); + __Pyx_XDECREF(__pyx_v_p); + __Pyx_XDECREF(__pyx_v_results); + __Pyx_XDECREF(__pyx_v_y); + __Pyx_XDECREF(__pyx_v_penalty); + __Pyx_XDECREF(__pyx_v_max_support_size); + __Pyx_XDECREF(__pyx_v_num_lambda); + __Pyx_XDECREF(__pyx_v_num_gamma); + __Pyx_XDECREF(__pyx_v_screen_size); + __Pyx_XDECREF(__pyx_v_lambda_grid); + __Pyx_XDECREF(__pyx_v_lows); + __Pyx_XDECREF(__pyx_v_highs); + __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":982 +/* "l0learn/interface.pyx":701 * * - * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< - * """ - * Cython equivalent of `isinstance(obj, np.datetime64)` + * cdef fitmodel _L0LearnFit_dense(const dmat& X, # <<<<<<<<<<<<<< + * const dvec& y, + * const string Loss, */ -static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_obj) { - int __pyx_r; - __Pyx_TraceDeclarations +static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_dense(arma::dmat const &__pyx_v_X, arma::dvec const &__pyx_v_y, std::string const __pyx_v_Loss, std::string const __pyx_v_Penalty, std::string const __pyx_v_Algorithm, size_t const __pyx_v_NnzStopNum, size_t const __pyx_v_G_ncols, size_t const __pyx_v_G_nrows, double const __pyx_v_Lambda2Max, double const __pyx_v_Lambda2Min, bool const __pyx_v_PartialSort, size_t const __pyx_v_MaxIters, double const __pyx_v_rtol, double const __pyx_v_atol, bool const __pyx_v_ActiveSet, size_t const __pyx_v_ActiveSetNum, size_t const __pyx_v_MaxNumSwaps, double const __pyx_v_ScaleDownFactor, size_t const __pyx_v_ScreenSize, bool const __pyx_v_LambdaU, std::vector > const &__pyx_v_Lambdas, size_t const __pyx_v_ExcludeFirstK, bool const __pyx_v_Intercept, bool const __pyx_v_withBounds, arma::dvec const &__pyx_v_Lows, arma::dvec const &__pyx_v_Highs) { + fitmodel __pyx_r; __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("is_datetime64_object", 0); - __Pyx_TraceCall("is_datetime64_object", __pyx_f[1], 982, 0, __PYX_ERR(1, 982, __pyx_L1_error)); + __Pyx_RefNannySetupContext("_L0LearnFit_dense", 0); - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":994 - * bool - * """ - * return PyObject_TypeCheck(obj, &PyDatetimeArrType_Type) # <<<<<<<<<<<<<< - * - * + /* "l0learn/interface.pyx":727 + * const dvec &Lows, + * const dvec &Highs): + * return L0LearnFit[dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< + * MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, + * Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs) */ - __Pyx_TraceLine(994,0,__PYX_ERR(1, 994, __pyx_L1_error)) - __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyDatetimeArrType_Type)); + __pyx_r = L0LearnFit(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":982 + /* "l0learn/interface.pyx":701 * * - * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< - * """ - * Cython equivalent of `isinstance(obj, np.datetime64)` + * cdef fitmodel _L0LearnFit_dense(const dmat& X, # <<<<<<<<<<<<<< + * const dvec& y, + * const string Loss, */ /* function exit code */ - __pyx_L1_error:; - __Pyx_WriteUnraisable("numpy.is_datetime64_object", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); - __pyx_r = 0; __pyx_L0:; - __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":997 +/* "l0learn/interface.pyx":732 * * - * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< - * """ - * returns the int64 value underlying scalar numpy datetime64 object + * cdef fitmodel _L0LearnFit_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< + * const dvec& y, + * const string Loss, */ -static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject *__pyx_v_obj) { - npy_datetime __pyx_r; - __Pyx_TraceDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_TraceCall("get_datetime64_value", __pyx_f[1], 997, 1, __PYX_ERR(1, 997, __pyx_L1_error)); +static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_sparse(arma::sp_dmat const &__pyx_v_X, arma::dvec const &__pyx_v_y, std::string const __pyx_v_Loss, std::string const __pyx_v_Penalty, std::string const __pyx_v_Algorithm, size_t const __pyx_v_NnzStopNum, size_t const __pyx_v_G_ncols, size_t const __pyx_v_G_nrows, double const __pyx_v_Lambda2Max, double const __pyx_v_Lambda2Min, bool const __pyx_v_PartialSort, size_t const __pyx_v_MaxIters, double const __pyx_v_rtol, double const __pyx_v_atol, bool const __pyx_v_ActiveSet, size_t const __pyx_v_ActiveSetNum, size_t const __pyx_v_MaxNumSwaps, double const __pyx_v_ScaleDownFactor, size_t const __pyx_v_ScreenSize, bool const __pyx_v_LambdaU, std::vector > const &__pyx_v_Lambdas, size_t const __pyx_v_ExcludeFirstK, bool const __pyx_v_Intercept, bool const __pyx_v_withBounds, arma::dvec const &__pyx_v_Lows, arma::dvec const &__pyx_v_Highs) { + fitmodel __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_L0LearnFit_sparse", 0); - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1004 - * also needed. That can be found using `get_datetime64_unit`. - * """ - * return (obj).obval # <<<<<<<<<<<<<< - * - * + /* "l0learn/interface.pyx":758 + * const dvec &Lows, + * const dvec &Highs): + * return L0LearnFit[sp_dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< + * MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, + * Lambdas, ExcludeFirstK, Intercept, withBounds, Lows, Highs) */ - __Pyx_TraceLine(1004,1,__PYX_ERR(1, 1004, __pyx_L1_error)) - __pyx_r = ((PyDatetimeScalarObject *)__pyx_v_obj)->obval; + __pyx_r = L0LearnFit(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":997 + /* "l0learn/interface.pyx":732 * * - * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< - * """ - * returns the int64 value underlying scalar numpy datetime64 object + * cdef fitmodel _L0LearnFit_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< + * const dvec& y, + * const string Loss, */ /* function exit code */ - __pyx_L1_error:; - __Pyx_WriteUnraisable("numpy.get_datetime64_value", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1); - __pyx_r = 0; __pyx_L0:; - __Pyx_TraceReturn(Py_None, 1); + __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1007 +/* "l0learn/interface.pyx":763 * * - * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< - * """ - * returns the int64 value underlying scalar numpy timedelta64 object + * cdef cvfitmodel _L0LearnCV_dense(const dmat& X, # <<<<<<<<<<<<<< + * const dvec& y, + * const string Loss, */ -static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject *__pyx_v_obj) { - npy_timedelta __pyx_r; - __Pyx_TraceDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_TraceCall("get_timedelta64_value", __pyx_f[1], 1007, 1, __PYX_ERR(1, 1007, __pyx_L1_error)); +static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_dense(arma::dmat const &__pyx_v_X, arma::dvec const &__pyx_v_y, std::string const __pyx_v_Loss, std::string const __pyx_v_Penalty, std::string const __pyx_v_Algorithm, size_t const __pyx_v_NnzStopNum, size_t const __pyx_v_G_ncols, size_t const __pyx_v_G_nrows, double const __pyx_v_Lambda2Max, double const __pyx_v_Lambda2Min, bool const __pyx_v_PartialSort, size_t const __pyx_v_MaxIters, double const __pyx_v_rtol, double const __pyx_v_atol, bool const __pyx_v_ActiveSet, size_t const __pyx_v_ActiveSetNum, size_t const __pyx_v_MaxNumSwaps, double const __pyx_v_ScaleDownFactor, size_t const __pyx_v_ScreenSize, bool const __pyx_v_LambdaU, std::vector > const &__pyx_v_Lambdas, unsigned int const __pyx_v_nfolds, double const __pyx_v_seed, size_t const __pyx_v_ExcludeFirstK, bool const __pyx_v_Intercept, bool const __pyx_v_withBounds, arma::dvec const &__pyx_v_Lows, arma::dvec const &__pyx_v_Highs) { + cvfitmodel __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_L0LearnCV_dense", 0); - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1011 - * returns the int64 value underlying scalar numpy timedelta64 object - * """ - * return (obj).obval # <<<<<<<<<<<<<< - * - * + /* "l0learn/interface.pyx":791 + * const dvec &Lows, + * const dvec &Highs): + * return L0LearnCV[dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< + * MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, + * Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs) */ - __Pyx_TraceLine(1011,1,__PYX_ERR(1, 1011, __pyx_L1_error)) - __pyx_r = ((PyTimedeltaScalarObject *)__pyx_v_obj)->obval; + __pyx_r = L0LearnCV(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_nfolds, __pyx_v_seed, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1007 + /* "l0learn/interface.pyx":763 * * - * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< - * """ - * returns the int64 value underlying scalar numpy timedelta64 object + * cdef cvfitmodel _L0LearnCV_dense(const dmat& X, # <<<<<<<<<<<<<< + * const dvec& y, + * const string Loss, */ /* function exit code */ - __pyx_L1_error:; - __Pyx_WriteUnraisable("numpy.get_timedelta64_value", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1); - __pyx_r = 0; __pyx_L0:; - __Pyx_TraceReturn(Py_None, 1); + __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1014 +/* "l0learn/interface.pyx":796 * * - * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< - * """ - * returns the unit part of the dtype for a numpy datetime64 object. + * cdef cvfitmodel _L0LearnCV_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< + * const dvec& y, + * const string Loss, */ -static CYTHON_INLINE NPY_DATETIMEUNIT __pyx_f_5numpy_get_datetime64_unit(PyObject *__pyx_v_obj) { - NPY_DATETIMEUNIT __pyx_r; - __Pyx_TraceDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_TraceCall("get_datetime64_unit", __pyx_f[1], 1014, 1, __PYX_ERR(1, 1014, __pyx_L1_error)); +static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_sparse(arma::sp_dmat const &__pyx_v_X, arma::dvec const &__pyx_v_y, std::string const __pyx_v_Loss, std::string const __pyx_v_Penalty, std::string const __pyx_v_Algorithm, size_t const __pyx_v_NnzStopNum, size_t const __pyx_v_G_ncols, size_t const __pyx_v_G_nrows, double const __pyx_v_Lambda2Max, double const __pyx_v_Lambda2Min, bool const __pyx_v_PartialSort, size_t const __pyx_v_MaxIters, double const __pyx_v_rtol, double const __pyx_v_atol, bool const __pyx_v_ActiveSet, size_t const __pyx_v_ActiveSetNum, size_t const __pyx_v_MaxNumSwaps, double const __pyx_v_ScaleDownFactor, size_t const __pyx_v_ScreenSize, bool const __pyx_v_LambdaU, std::vector > const &__pyx_v_Lambdas, unsigned int const __pyx_v_nfolds, double const __pyx_v_seed, size_t const __pyx_v_ExcludeFirstK, bool const __pyx_v_Intercept, bool const __pyx_v_withBounds, arma::dvec const &__pyx_v_Lows, arma::dvec const &__pyx_v_Highs) { + cvfitmodel __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_L0LearnCV_sparse", 0); - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1018 - * returns the unit part of the dtype for a numpy datetime64 object. - * """ - * return (obj).obmeta.base # <<<<<<<<<<<<<< + /* "l0learn/interface.pyx":824 + * const dvec &Lows, + * const dvec &Highs): + * return L0LearnCV[sp_dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< + * MaxIters, rtol, atol, ActiveSet, ActiveSetNum, MaxNumSwaps, ScaleDownFactor, ScreenSize, LambdaU, + * Lambdas, nfolds, seed, ExcludeFirstK, Intercept, withBounds, Lows, Highs) */ - __Pyx_TraceLine(1018,1,__PYX_ERR(1, 1018, __pyx_L1_error)) - __pyx_r = ((NPY_DATETIMEUNIT)((PyDatetimeScalarObject *)__pyx_v_obj)->obmeta.base); + __pyx_r = L0LearnCV(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_nfolds, __pyx_v_seed, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); goto __pyx_L0; - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1014 + /* "l0learn/interface.pyx":796 * * - * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< - * """ - * returns the unit part of the dtype for a numpy datetime64 object. + * cdef cvfitmodel _L0LearnCV_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< + * const dvec& y, + * const string Loss, */ /* function exit code */ - __pyx_L1_error:; - __Pyx_WriteUnraisable("numpy.get_datetime64_unit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1); - __pyx_r = (NPY_DATETIMEUNIT) 0; __pyx_L0:; - __Pyx_TraceReturn(Py_None, 1); + __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "vector.from_py":45 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":735 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) * - * @cname("__pyx_convert_vector_from_py_double") - * cdef vector[X] __pyx_convert_vector_from_py_double(object o) except *: # <<<<<<<<<<<<<< - * cdef vector[X] v - * for item in o: */ -static std::vector __pyx_convert_vector_from_py_double(PyObject *__pyx_v_o) { - std::vector __pyx_v_v; - PyObject *__pyx_v_item = NULL; - std::vector __pyx_r; - __Pyx_TraceDeclarations +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { + PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - Py_ssize_t __pyx_t_2; - PyObject *(*__pyx_t_3)(PyObject *); - PyObject *__pyx_t_4 = NULL; - double __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_convert_vector_from_py_double", 0); - __Pyx_TraceCall("__pyx_convert_vector_from_py_double", __pyx_f[2], 45, 0, __PYX_ERR(2, 45, __pyx_L1_error)); - - /* "vector.from_py":47 - * cdef vector[X] __pyx_convert_vector_from_py_double(object o) except *: - * cdef vector[X] v - * for item in o: # <<<<<<<<<<<<<< - * v.push_back(item) - * return v - */ - __Pyx_TraceLine(47,0,__PYX_ERR(2, 47, __pyx_L1_error)) - if (likely(PyList_CheckExact(__pyx_v_o)) || PyTuple_CheckExact(__pyx_v_o)) { - __pyx_t_1 = __pyx_v_o; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; - __pyx_t_3 = NULL; - } else { - __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_o); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 47, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 47, __pyx_L1_error) - } - for (;;) { - if (likely(!__pyx_t_3)) { - if (likely(PyList_CheckExact(__pyx_t_1))) { - if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(2, 47, __pyx_L1_error) - #else - __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 47, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - } else { - if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(2, 47, __pyx_L1_error) - #else - __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 47, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - } - } else { - __pyx_t_4 = __pyx_t_3(__pyx_t_1); - if (unlikely(!__pyx_t_4)) { - PyObject* exc_type = PyErr_Occurred(); - if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(2, 47, __pyx_L1_error) - } - break; - } - __Pyx_GOTREF(__pyx_t_4); - } - __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_4); - __pyx_t_4 = 0; - - /* "vector.from_py":48 - * cdef vector[X] v - * for item in o: - * v.push_back(item) # <<<<<<<<<<<<<< - * return v - * - */ - __Pyx_TraceLine(48,0,__PYX_ERR(2, 48, __pyx_L1_error)) - __pyx_t_5 = __pyx_PyFloat_AsDouble(__pyx_v_item); if (unlikely((__pyx_t_5 == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 48, __pyx_L1_error) - __pyx_v_v.push_back(((double)__pyx_t_5)); - - /* "vector.from_py":47 - * cdef vector[X] __pyx_convert_vector_from_py_double(object o) except *: - * cdef vector[X] v - * for item in o: # <<<<<<<<<<<<<< - * v.push_back(item) - * return v - */ - __Pyx_TraceLine(47,0,__PYX_ERR(2, 47, __pyx_L1_error)) - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); - /* "vector.from_py":49 - * for item in o: - * v.push_back(item) - * return v # <<<<<<<<<<<<<< + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":736 * + * cdef inline object PyArray_MultiIterNew1(a): + * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< * + * cdef inline object PyArray_MultiIterNew2(a, b): */ - __Pyx_TraceLine(49,0,__PYX_ERR(2, 49, __pyx_L1_error)) - __pyx_r = __pyx_v_v; + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 736, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; goto __pyx_L0; - /* "vector.from_py":45 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":735 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) * - * @cname("__pyx_convert_vector_from_py_double") - * cdef vector[X] __pyx_convert_vector_from_py_double(object o) except *: # <<<<<<<<<<<<<< - * cdef vector[X] v - * for item in o: */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("vector.from_py.__pyx_convert_vector_from_py_double", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_pretend_to_initialize(&__pyx_r); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; - __Pyx_XDECREF(__pyx_v_item); - __Pyx_TraceReturn(Py_None, 0); + __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -static std::vector > __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(PyObject *__pyx_v_o) { - std::vector > __pyx_v_v; - PyObject *__pyx_v_item = NULL; - std::vector > __pyx_r; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - Py_ssize_t __pyx_t_2; - PyObject *(*__pyx_t_3)(PyObject *); - PyObject *__pyx_t_4 = NULL; - std::vector __pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___", 0); - __Pyx_TraceCall("__pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___", __pyx_f[2], 45, 0, __PYX_ERR(2, 45, __pyx_L1_error)); - - /* "vector.from_py":47 - * cdef vector[X] __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(object o) except *: - * cdef vector[X] v - * for item in o: # <<<<<<<<<<<<<< - * v.push_back(item) - * return v - */ - __Pyx_TraceLine(47,0,__PYX_ERR(2, 47, __pyx_L1_error)) - if (likely(PyList_CheckExact(__pyx_v_o)) || PyTuple_CheckExact(__pyx_v_o)) { - __pyx_t_1 = __pyx_v_o; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; - __pyx_t_3 = NULL; - } else { - __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_o); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 47, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 47, __pyx_L1_error) - } - for (;;) { - if (likely(!__pyx_t_3)) { - if (likely(PyList_CheckExact(__pyx_t_1))) { - if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(2, 47, __pyx_L1_error) - #else - __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 47, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - } else { - if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(2, 47, __pyx_L1_error) - #else - __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 47, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - } - } else { - __pyx_t_4 = __pyx_t_3(__pyx_t_1); - if (unlikely(!__pyx_t_4)) { - PyObject* exc_type = PyErr_Occurred(); - if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(2, 47, __pyx_L1_error) - } - break; - } - __Pyx_GOTREF(__pyx_t_4); - } - __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_4); - __pyx_t_4 = 0; - - /* "vector.from_py":48 - * cdef vector[X] v - * for item in o: - * v.push_back(item) # <<<<<<<<<<<<<< - * return v - * - */ - __Pyx_TraceLine(48,0,__PYX_ERR(2, 48, __pyx_L1_error)) - __pyx_t_5 = __pyx_convert_vector_from_py_double(__pyx_v_item); if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 48, __pyx_L1_error) - __pyx_v_v.push_back(((std::vector )__pyx_t_5)); - - /* "vector.from_py":47 - * cdef vector[X] __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(object o) except *: - * cdef vector[X] v - * for item in o: # <<<<<<<<<<<<<< - * v.push_back(item) - * return v +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":738 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * */ - __Pyx_TraceLine(47,0,__PYX_ERR(2, 47, __pyx_L1_error)) - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "vector.from_py":49 - * for item in o: - * v.push_back(item) - * return v # <<<<<<<<<<<<<< +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":739 * + * cdef inline object PyArray_MultiIterNew2(a, b): + * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< * + * cdef inline object PyArray_MultiIterNew3(a, b, c): */ - __Pyx_TraceLine(49,0,__PYX_ERR(2, 49, __pyx_L1_error)) - __pyx_r = __pyx_v_v; + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 739, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; goto __pyx_L0; - /* "vector.from_py":45 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":738 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) * - * @cname("__pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___") - * cdef vector[X] __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(object o) except *: # <<<<<<<<<<<<<< - * cdef vector[X] v - * for item in o: */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("vector.from_py.__pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_pretend_to_initialize(&__pyx_r); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; - __Pyx_XDECREF(__pyx_v_item); - __Pyx_TraceReturn(Py_None, 0); + __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "string.from_py":13 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":741 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) * - * @cname("__pyx_convert_string_from_py_std__in_string") - * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: # <<<<<<<<<<<<<< - * cdef Py_ssize_t length = 0 - * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) */ -static std::string __pyx_convert_string_from_py_std__in_string(PyObject *__pyx_v_o) { - Py_ssize_t __pyx_v_length; - char const *__pyx_v_data; - std::string __pyx_r; - __Pyx_TraceDeclarations +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { + PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - char const *__pyx_t_1; + PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_convert_string_from_py_std__in_string", 0); - __Pyx_TraceCall("__pyx_convert_string_from_py_std__in_string", __pyx_f[2], 13, 0, __PYX_ERR(2, 13, __pyx_L1_error)); + __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); - /* "string.from_py":14 - * @cname("__pyx_convert_string_from_py_std__in_string") - * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: - * cdef Py_ssize_t length = 0 # <<<<<<<<<<<<<< - * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) - * return string(data, length) + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":742 + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): */ - __Pyx_TraceLine(14,0,__PYX_ERR(2, 14, __pyx_L1_error)) - __pyx_v_length = 0; + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 742, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "string.from_py":15 - * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: - * cdef Py_ssize_t length = 0 - * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) # <<<<<<<<<<<<<< - * return string(data, length) + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":741 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) * */ - __Pyx_TraceLine(15,0,__PYX_ERR(2, 15, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyObject_AsStringAndSize(__pyx_v_o, (&__pyx_v_length)); if (unlikely(__pyx_t_1 == ((char const *)NULL))) __PYX_ERR(2, 15, __pyx_L1_error) - __pyx_v_data = __pyx_t_1; - /* "string.from_py":16 - * cdef Py_ssize_t length = 0 - * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) - * return string(data, length) # <<<<<<<<<<<<<< + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":744 + * return PyArray_MultiIterNew(3, a, b, c) * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) * */ - __Pyx_TraceLine(16,0,__PYX_ERR(2, 16, __pyx_L1_error)) - __pyx_r = std::string(__pyx_v_data, __pyx_v_length); + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":745 + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 745, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; goto __pyx_L0; - /* "string.from_py":13 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":744 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) * - * @cname("__pyx_convert_string_from_py_std__in_string") - * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: # <<<<<<<<<<<<<< - * cdef Py_ssize_t length = 0 - * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) */ /* function exit code */ __pyx_L1_error:; - __Pyx_AddTraceback("string.from_py.__pyx_convert_string_from_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_pretend_to_initialize(&__pyx_r); + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; __pyx_L0:; - __Pyx_TraceReturn(Py_None, 0); + __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } -/* "vector.to_py":60 +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":747 + * return PyArray_MultiIterNew(4, a, b, c, d) * - * @cname("__pyx_convert_vector_to_py_double") - * cdef object __pyx_convert_vector_to_py_double(vector[X]& v): # <<<<<<<<<<<<<< - * return [v[i] for i in range(v.size())] + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) * */ -static PyObject *__pyx_convert_vector_to_py_double(const std::vector &__pyx_v_v) { - size_t __pyx_v_i; +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - size_t __pyx_t_2; - size_t __pyx_t_3; - size_t __pyx_t_4; - PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_double", 0); - __Pyx_TraceCall("__pyx_convert_vector_to_py_double", __pyx_f[2], 60, 0, __PYX_ERR(2, 60, __pyx_L1_error)); + __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); - /* "vector.to_py":61 - * @cname("__pyx_convert_vector_to_py_double") - * cdef object __pyx_convert_vector_to_py_double(vector[X]& v): - * return [v[i] for i in range(v.size())] # <<<<<<<<<<<<<< + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":748 * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< * + * cdef inline tuple PyDataType_SHAPE(dtype d): */ - __Pyx_TraceLine(61,0,__PYX_ERR(2, 61, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 61, __pyx_L1_error) + __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 748, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __pyx_v_v.size(); - __pyx_t_3 = __pyx_t_2; - for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { - __pyx_v_i = __pyx_t_4; - __pyx_t_5 = PyFloat_FromDouble((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 61, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(2, 61, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - } __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "vector.to_py":60 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":747 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":750 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":751 + * + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< + * return d.subarray.shape + * else: + */ + __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); + if (__pyx_t_1) { + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":752 + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape # <<<<<<<<<<<<<< + * else: + * return () + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); + __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":751 + * + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< + * return d.subarray.shape + * else: + */ + } + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":754 + * return d.subarray.shape + * else: + * return () # <<<<<<<<<<<<<< * - * @cname("__pyx_convert_vector_to_py_double") - * cdef object __pyx_convert_vector_to_py_double(vector[X]& v): # <<<<<<<<<<<<<< - * return [v[i] for i in range(v.size())] * + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_empty_tuple); + __pyx_r = __pyx_empty_tuple; + goto __pyx_L0; + } + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":750 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape */ /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_double", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(const std::vector > &__pyx_v_v) { - size_t __pyx_v_i; - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":929 + * int _import_umath() except -1 + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) + */ + +static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - size_t __pyx_t_2; - size_t __pyx_t_3; - size_t __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___", 0); - __Pyx_TraceCall("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___", __pyx_f[2], 60, 0, __PYX_ERR(2, 60, __pyx_L1_error)); + __Pyx_RefNannySetupContext("set_array_base", 0); - /* "vector.to_py":61 - * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___") - * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(vector[X]& v): - * return [v[i] for i in range(v.size())] # <<<<<<<<<<<<<< + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":930 * + * cdef inline void set_array_base(ndarray arr, object base): + * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< + * PyArray_SetBaseObject(arr, base) * */ - __Pyx_TraceLine(61,0,__PYX_ERR(2, 61, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 61, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __pyx_v_v.size(); - __pyx_t_3 = __pyx_t_2; - for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { - __pyx_v_i = __pyx_t_4; - __pyx_t_5 = __pyx_convert_vector_to_py_double((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 61, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(2, 61, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - } - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + Py_INCREF(__pyx_v_base); - /* "vector.to_py":60 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":931 + * cdef inline void set_array_base(ndarray arr, object base): + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< * - * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___") - * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(vector[X]& v): # <<<<<<<<<<<<<< - * return [v[i] for i in range(v.size())] + * cdef inline object get_array_base(ndarray arr): + */ + (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":929 + * int _import_umath() except -1 * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) */ /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); - return __pyx_r; } -static PyObject *__pyx_convert_vector_to_py_size_t(const std::vector &__pyx_v_v) { - size_t __pyx_v_i; +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":933 + * PyArray_SetBaseObject(arr, base) + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) + * if base is NULL: + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { + PyObject *__pyx_v_base; PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - size_t __pyx_t_2; - size_t __pyx_t_3; - size_t __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_size_t", 0); - __Pyx_TraceCall("__pyx_convert_vector_to_py_size_t", __pyx_f[2], 60, 0, __PYX_ERR(2, 60, __pyx_L1_error)); + int __pyx_t_1; + __Pyx_RefNannySetupContext("get_array_base", 0); - /* "vector.to_py":61 - * @cname("__pyx_convert_vector_to_py_size_t") - * cdef object __pyx_convert_vector_to_py_size_t(vector[X]& v): - * return [v[i] for i in range(v.size())] # <<<<<<<<<<<<<< + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":934 + * + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< + * if base is NULL: + * return None + */ + __pyx_v_base = PyArray_BASE(__pyx_v_arr); + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":935 + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) + * if base is NULL: # <<<<<<<<<<<<<< + * return None + * return base + */ + __pyx_t_1 = ((__pyx_v_base == NULL) != 0); + if (__pyx_t_1) { + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":936 + * base = PyArray_BASE(arr) + * if base is NULL: + * return None # <<<<<<<<<<<<<< + * return base * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":935 + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) + * if base is NULL: # <<<<<<<<<<<<<< + * return None + * return base + */ + } + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":937 + * if base is NULL: + * return None + * return base # <<<<<<<<<<<<<< * + * # Versions of the import_* functions which are more suitable for */ - __Pyx_TraceLine(61,0,__PYX_ERR(2, 61, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 61, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __pyx_v_v.size(); - __pyx_t_3 = __pyx_t_2; - for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { - __pyx_v_i = __pyx_t_4; - __pyx_t_5 = __Pyx_PyInt_FromSize_t((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 61, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(2, 61, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - } - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; + __Pyx_INCREF(((PyObject *)__pyx_v_base)); + __pyx_r = ((PyObject *)__pyx_v_base); goto __pyx_L0; - /* "vector.to_py":60 - * - * @cname("__pyx_convert_vector_to_py_size_t") - * cdef object __pyx_convert_vector_to_py_size_t(vector[X]& v): # <<<<<<<<<<<<<< - * return [v[i] for i in range(v.size())] + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":933 + * PyArray_SetBaseObject(arr, base) * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) + * if base is NULL: */ /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_size_t", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(const std::vector > &__pyx_v_v) { - size_t __pyx_v_i; - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":941 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * __pyx_import_array() + */ + +static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { + int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - size_t __pyx_t_2; - size_t __pyx_t_3; - size_t __pyx_t_4; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___", 0); - __Pyx_TraceCall("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___", __pyx_f[2], 60, 0, __PYX_ERR(2, 60, __pyx_L1_error)); + __Pyx_RefNannySetupContext("import_array", 0); + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":942 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * __pyx_import_array() + * except Exception: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":943 + * cdef inline int import_array() except -1: + * try: + * __pyx_import_array() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") + */ + __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 943, __pyx_L3_error) + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":942 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * __pyx_import_array() + * except Exception: + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; - /* "vector.to_py":61 - * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___") - * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(vector[X]& v): - * return [v[i] for i in range(v.size())] # <<<<<<<<<<<<<< + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":944 + * try: + * __pyx_import_array() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.multiarray failed to import") * + */ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 944, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":945 + * __pyx_import_array() + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * + * cdef inline int import_umath() except -1: */ - __Pyx_TraceLine(61,0,__PYX_ERR(2, 61, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 61, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __pyx_v_v.size(); - __pyx_t_3 = __pyx_t_2; - for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { - __pyx_v_i = __pyx_t_4; - __pyx_t_5 = __pyx_convert_vector_to_py_size_t((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 61, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(2, 61, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 945, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 945, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":942 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * __pyx_import_array() + * except Exception: + */ + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; } - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - /* "vector.to_py":60 - * - * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___") - * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(vector[X]& v): # <<<<<<<<<<<<<< - * return [v[i] for i in range(v.size())] - * + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":941 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * __pyx_import_array() */ /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_convert_vector_to_py_bool(const std::vector &__pyx_v_v) { - size_t __pyx_v_i; - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":947 + * raise ImportError("numpy.core.multiarray failed to import") + * + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + +static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { + int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - size_t __pyx_t_2; - size_t __pyx_t_3; - size_t __pyx_t_4; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_bool", 0); - __Pyx_TraceCall("__pyx_convert_vector_to_py_bool", __pyx_f[2], 60, 0, __PYX_ERR(2, 60, __pyx_L1_error)); + __Pyx_RefNannySetupContext("import_umath", 0); - /* "vector.to_py":61 - * @cname("__pyx_convert_vector_to_py_bool") - * cdef object __pyx_convert_vector_to_py_bool(vector[X]& v): - * return [v[i] for i in range(v.size())] # <<<<<<<<<<<<<< - * + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":948 * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: */ - __Pyx_TraceLine(61,0,__PYX_ERR(2, 61, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 61, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __pyx_v_v.size(); - __pyx_t_3 = __pyx_t_2; - for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { - __pyx_v_i = __pyx_t_4; - __pyx_t_5 = __Pyx_PyBool_FromLong((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 61, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(2, 61, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - } - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { - /* "vector.to_py":60 - * - * @cname("__pyx_convert_vector_to_py_bool") - * cdef object __pyx_convert_vector_to_py_bool(vector[X]& v): # <<<<<<<<<<<<<< - * return [v[i] for i in range(v.size())] - * + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":949 + * cdef inline int import_umath() except -1: + * try: + * _import_umath() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.umath failed to import") */ + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 949, __pyx_L3_error) - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_bool", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":948 + * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; -static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(const std::vector > &__pyx_v_v) { - size_t __pyx_v_i; - PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - size_t __pyx_t_2; - size_t __pyx_t_3; - size_t __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___", 0); - __Pyx_TraceCall("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___", __pyx_f[2], 60, 0, __PYX_ERR(2, 60, __pyx_L1_error)); + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":950 + * try: + * _import_umath() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.umath failed to import") + * + */ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 950, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); - /* "vector.to_py":61 - * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___") - * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(vector[X]& v): - * return [v[i] for i in range(v.size())] # <<<<<<<<<<<<<< + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":951 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * + * cdef inline int import_ufunc() except -1: + */ + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 951, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 951, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":948 * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: */ - __Pyx_TraceLine(61,0,__PYX_ERR(2, 61, __pyx_L1_error)) - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 61, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __pyx_v_v.size(); - __pyx_t_3 = __pyx_t_2; - for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { - __pyx_v_i = __pyx_t_4; - __pyx_t_5 = __pyx_convert_vector_to_py_bool((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 61, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(2, 61, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; } - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - /* "vector.to_py":60 - * - * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___") - * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(vector[X]& v): # <<<<<<<<<<<<<< - * return [v[i] for i in range(v.size())] + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":947 + * raise ImportError("numpy.core.multiarray failed to import") * + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() */ /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyMethodDef __pyx_methods[] = { - {0, 0, 0, 0} -}; - -#if PY_MAJOR_VERSION >= 3 -#if CYTHON_PEP489_MULTI_PHASE_INIT -static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ -static int __pyx_pymod_exec_interface(PyObject* module); /*proto*/ -static PyModuleDef_Slot __pyx_moduledef_slots[] = { - {Py_mod_create, (void*)__pyx_pymod_create}, - {Py_mod_exec, (void*)__pyx_pymod_exec_interface}, - {0, NULL} -}; -#endif - -static struct PyModuleDef __pyx_moduledef = { - PyModuleDef_HEAD_INIT, - "interface", - 0, /* m_doc */ - #if CYTHON_PEP489_MULTI_PHASE_INIT - 0, /* m_size */ - #else - -1, /* m_size */ - #endif - __pyx_methods /* m_methods */, - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_moduledef_slots, /* m_slots */ - #else - NULL, /* m_reload */ - #endif - NULL, /* m_traverse */ - NULL, /* m_clear */ - NULL /* m_free */ -}; -#endif -#ifndef CYTHON_SMALL_CODE -#if defined(__clang__) - #define CYTHON_SMALL_CODE -#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) - #define CYTHON_SMALL_CODE __attribute__((cold)) -#else - #define CYTHON_SMALL_CODE -#endif -#endif - -static __Pyx_StringTabEntry __pyx_string_tab[] = { - {&__pyx_n_s_Any, __pyx_k_Any, sizeof(__pyx_k_Any), 0, 0, 1, 1}, - {&__pyx_n_u_CD, __pyx_k_CD, sizeof(__pyx_k_CD), 0, 1, 0, 1}, - {&__pyx_n_u_CDPSI, __pyx_k_CDPSI, sizeof(__pyx_k_CDPSI), 0, 1, 0, 1}, - {&__pyx_n_s_CLASSIFICATION_LOSS, __pyx_k_CLASSIFICATION_LOSS, sizeof(__pyx_k_CLASSIFICATION_LOSS), 0, 0, 1, 1}, - {&__pyx_n_s_CVFitModel, __pyx_k_CVFitModel, sizeof(__pyx_k_CVFitModel), 0, 0, 1, 1}, - {&__pyx_n_s_Dict, __pyx_k_Dict, sizeof(__pyx_k_Dict), 0, 0, 1, 1}, - {&__pyx_kp_u_Expected_all_values_of_lambda_gr, __pyx_k_Expected_all_values_of_lambda_gr, sizeof(__pyx_k_Expected_all_values_of_lambda_gr), 0, 1, 0, 0}, - {&__pyx_kp_u_Expected_each_element_of_lambda, __pyx_k_Expected_each_element_of_lambda, sizeof(__pyx_k_Expected_each_element_of_lambda), 0, 1, 0, 0}, - {&__pyx_n_u_F_CONTIGUOUS, __pyx_k_F_CONTIGUOUS, sizeof(__pyx_k_F_CONTIGUOUS), 0, 1, 0, 1}, - {&__pyx_n_s_FitModel, __pyx_k_FitModel, sizeof(__pyx_k_FitModel), 0, 0, 1, 1}, - {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1}, - {&__pyx_n_u_L0, __pyx_k_L0, sizeof(__pyx_k_L0), 0, 1, 0, 1}, - {&__pyx_n_u_L0L1, __pyx_k_L0L1, sizeof(__pyx_k_L0L1), 0, 1, 0, 1}, - {&__pyx_n_u_L0L2, __pyx_k_L0L2, sizeof(__pyx_k_L0L2), 0, 1, 0, 1}, - {&__pyx_kp_u_L0_Penalty_requires_lambda_grid, __pyx_k_L0_Penalty_requires_lambda_grid, sizeof(__pyx_k_L0_Penalty_requires_lambda_grid), 0, 1, 0, 0}, - {&__pyx_n_s_List, __pyx_k_List, sizeof(__pyx_k_List), 0, 0, 1, 1}, - {&__pyx_n_u_Logistic, __pyx_k_Logistic, sizeof(__pyx_k_Logistic), 0, 1, 0, 1}, - {&__pyx_kp_u_None, __pyx_k_None, sizeof(__pyx_k_None), 0, 1, 0, 0}, - {&__pyx_n_s_NotImplementedError, __pyx_k_NotImplementedError, sizeof(__pyx_k_NotImplementedError), 0, 0, 1, 1}, - {&__pyx_kp_u_Not_supported, __pyx_k_Not_supported, sizeof(__pyx_k_Not_supported), 0, 1, 0, 0}, - {&__pyx_n_s_Optional, __pyx_k_Optional, sizeof(__pyx_k_Optional), 0, 0, 1, 1}, - {&__pyx_n_s_SUPPORTED_ALGORITHM, __pyx_k_SUPPORTED_ALGORITHM, sizeof(__pyx_k_SUPPORTED_ALGORITHM), 0, 0, 1, 1}, - {&__pyx_n_s_SUPPORTED_LOSS, __pyx_k_SUPPORTED_LOSS, sizeof(__pyx_k_SUPPORTED_LOSS), 0, 0, 1, 1}, - {&__pyx_n_s_SUPPORTED_PENALTY, __pyx_k_SUPPORTED_PENALTY, sizeof(__pyx_k_SUPPORTED_PENALTY), 0, 0, 1, 1}, - {&__pyx_n_u_SquaredError, __pyx_k_SquaredError, sizeof(__pyx_k_SquaredError), 0, 1, 0, 1}, - {&__pyx_n_u_SquaredHinge, __pyx_k_SquaredHinge, sizeof(__pyx_k_SquaredHinge), 0, 1, 0, 1}, - {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, - {&__pyx_n_s_Union, __pyx_k_Union, sizeof(__pyx_k_Union), 0, 0, 1, 1}, - {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, - {&__pyx_n_s_X, __pyx_k_X, sizeof(__pyx_k_X), 0, 0, 1, 1}, - {&__pyx_n_s__21, __pyx_k__21, sizeof(__pyx_k__21), 0, 0, 1, 1}, - {&__pyx_kp_u__6, __pyx_k__6, sizeof(__pyx_k__6), 0, 1, 0, 0}, - {&__pyx_n_s_a, __pyx_k_a, sizeof(__pyx_k_a), 0, 0, 1, 1}, - {&__pyx_n_s_active_set, __pyx_k_active_set, sizeof(__pyx_k_active_set), 0, 0, 1, 1}, - {&__pyx_n_s_active_set_num, __pyx_k_active_set_num, sizeof(__pyx_k_active_set_num), 0, 0, 1, 1}, - {&__pyx_n_s_algorithm, __pyx_k_algorithm, sizeof(__pyx_k_algorithm), 0, 0, 1, 1}, - {&__pyx_n_s_all, __pyx_k_all, sizeof(__pyx_k_all), 0, 0, 1, 1}, - {&__pyx_n_s_any, __pyx_k_any, sizeof(__pyx_k_any), 0, 0, 1, 1}, - {&__pyx_n_s_argwhere, __pyx_k_argwhere, sizeof(__pyx_k_argwhere), 0, 0, 1, 1}, - {&__pyx_n_s_arr, __pyx_k_arr, sizeof(__pyx_k_arr), 0, 0, 1, 1}, - {&__pyx_n_s_array, __pyx_k_array, sizeof(__pyx_k_array), 0, 0, 1, 1}, - {&__pyx_n_s_astype, __pyx_k_astype, sizeof(__pyx_k_astype), 0, 0, 1, 1}, - {&__pyx_n_s_atol, __pyx_k_atol, sizeof(__pyx_k_atol), 0, 0, 1, 1}, - {&__pyx_n_s_auto_lambda, __pyx_k_auto_lambda, sizeof(__pyx_k_auto_lambda), 0, 0, 1, 1}, - {&__pyx_n_u_auto_lambda, __pyx_k_auto_lambda, sizeof(__pyx_k_auto_lambda), 0, 1, 0, 1}, - {&__pyx_n_s_bad_bounds, __pyx_k_bad_bounds, sizeof(__pyx_k_bad_bounds), 0, 0, 1, 1}, - {&__pyx_n_s_bad_lambda_grid, __pyx_k_bad_lambda_grid, sizeof(__pyx_k_bad_lambda_grid), 0, 0, 1, 1}, - {&__pyx_kp_u_but_got, __pyx_k_but_got, sizeof(__pyx_k_but_got), 0, 1, 0, 0}, - {&__pyx_n_s_c_algorithim, __pyx_k_c_algorithim, sizeof(__pyx_k_c_algorithim), 0, 0, 1, 1}, - {&__pyx_n_s_c_lambda_grid, __pyx_k_c_lambda_grid, sizeof(__pyx_k_c_lambda_grid), 0, 0, 1, 1}, - {&__pyx_n_s_c_loss, __pyx_k_c_loss, sizeof(__pyx_k_c_loss), 0, 0, 1, 1}, - {&__pyx_n_s_c_penalty, __pyx_k_c_penalty, sizeof(__pyx_k_c_penalty), 0, 0, 1, 1}, - {&__pyx_n_s_c_results, __pyx_k_c_results, sizeof(__pyx_k_c_results), 0, 0, 1, 1}, - {&__pyx_n_s_check, __pyx_k_check, sizeof(__pyx_k_check), 0, 0, 1, 1}, - {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, - {&__pyx_n_s_coeffs, __pyx_k_coeffs, sizeof(__pyx_k_coeffs), 0, 0, 1, 1}, - {&__pyx_kp_u_containing_a_negative_value, __pyx_k_containing_a_negative_value, sizeof(__pyx_k_containing_a_negative_value), 0, 1, 0, 0}, - {&__pyx_kp_u_containing_an_increasing_value, __pyx_k_containing_an_increasing_value, sizeof(__pyx_k_containing_an_increasing_value), 0, 1, 0, 0}, - {&__pyx_n_s_contiguous, __pyx_k_contiguous, sizeof(__pyx_k_contiguous), 0, 0, 1, 1}, - {&__pyx_n_s_converged, __pyx_k_converged, sizeof(__pyx_k_converged), 0, 0, 1, 1}, - {&__pyx_n_s_copy, __pyx_k_copy, sizeof(__pyx_k_copy), 0, 0, 1, 1}, - {&__pyx_n_s_csc_matrix, __pyx_k_csc_matrix, sizeof(__pyx_k_csc_matrix), 0, 0, 1, 1}, - {&__pyx_n_s_current, __pyx_k_current, sizeof(__pyx_k_current), 0, 0, 1, 1}, - {&__pyx_n_s_cv_means, __pyx_k_cv_means, sizeof(__pyx_k_cv_means), 0, 0, 1, 1}, - {&__pyx_n_s_cv_sds, __pyx_k_cv_sds, sizeof(__pyx_k_cv_sds), 0, 0, 1, 1}, - {&__pyx_n_s_cvfit, __pyx_k_cvfit, sizeof(__pyx_k_cvfit), 0, 0, 1, 1}, - {&__pyx_n_s_data, __pyx_k_data, sizeof(__pyx_k_data), 0, 0, 1, 1}, - {&__pyx_n_s_diff, __pyx_k_diff, sizeof(__pyx_k_diff), 0, 0, 1, 1}, - {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1}, - {&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1}, - {&__pyx_n_s_exclude_first_k, __pyx_k_exclude_first_k, sizeof(__pyx_k_exclude_first_k), 0, 0, 1, 1}, - {&__pyx_kp_u_expected_X_to_be_a_2D_continuous, __pyx_k_expected_X_to_be_a_2D_continuous, sizeof(__pyx_k_expected_X_to_be_a_2D_continuous), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_active_set_num_paramete, __pyx_k_expected_active_set_num_paramete, sizeof(__pyx_k_expected_active_set_num_paramete), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_active_set_parameter_to, __pyx_k_expected_active_set_parameter_to, sizeof(__pyx_k_expected_active_set_parameter_to), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_algorithm_parameter_to, __pyx_k_expected_algorithm_parameter_to, sizeof(__pyx_k_expected_algorithm_parameter_to), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_arr_data_to_be_F_CONTIG, __pyx_k_expected_arr_data_to_be_F_CONTIG, sizeof(__pyx_k_expected_arr_data_to_be_F_CONTIG), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_arr_indices_to_be_F_CON, __pyx_k_expected_arr_indices_to_be_F_CON, sizeof(__pyx_k_expected_arr_indices_to_be_F_CON), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_arr_indptr_to_be_F_CONT, __pyx_k_expected_arr_indptr_to_be_F_CONT, sizeof(__pyx_k_expected_arr_indptr_to_be_F_CONT), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_arr_ndim_to_be_1_or_2_b, __pyx_k_expected_arr_ndim_to_be_1_or_2_b, sizeof(__pyx_k_expected_arr_ndim_to_be_1_or_2_b), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_arr_ndim_to_be_1_or_2_b_2, __pyx_k_expected_arr_ndim_to_be_1_or_2_b_2, sizeof(__pyx_k_expected_arr_ndim_to_be_1_or_2_b_2), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_arr_to_be_F_CONTIGUOUS, __pyx_k_expected_arr_to_be_F_CONTIGUOUS, sizeof(__pyx_k_expected_arr_to_be_F_CONTIGUOUS), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_arr_to_be_of_type, __pyx_k_expected_arr_to_be_of_type, sizeof(__pyx_k_expected_arr_to_be_of_type), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_atol_parameter_to_exist, __pyx_k_expected_atol_parameter_to_exist, sizeof(__pyx_k_expected_atol_parameter_to_exist), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_exclude_first_k_paramet, __pyx_k_expected_exclude_first_k_paramet, sizeof(__pyx_k_expected_exclude_first_k_paramet), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_gamma_max_parameter_to, __pyx_k_expected_gamma_max_parameter_to, sizeof(__pyx_k_expected_gamma_max_parameter_to), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_gamma_max_parameter_to_2, __pyx_k_expected_gamma_max_parameter_to_2, sizeof(__pyx_k_expected_gamma_max_parameter_to_2), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_highs_to_be_a_non_negat, __pyx_k_expected_highs_to_be_a_non_negat, sizeof(__pyx_k_expected_highs_to_be_a_non_negat), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_highs_to_be_a_non_negat_2, __pyx_k_expected_highs_to_be_a_non_negat_2, sizeof(__pyx_k_expected_highs_to_be_a_non_negat_2), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_intercept_parameter_to, __pyx_k_expected_intercept_parameter_to, sizeof(__pyx_k_expected_intercept_parameter_to), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_lambda_grid_to_be_a_lis, __pyx_k_expected_lambda_grid_to_be_a_lis, sizeof(__pyx_k_expected_lambda_grid_to_be_a_lis), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_lambda_grid_to_of_lengt, __pyx_k_expected_lambda_grid_to_of_lengt, sizeof(__pyx_k_expected_lambda_grid_to_of_lengt), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_loss_parameter_to_be_on, __pyx_k_expected_loss_parameter_to_be_on, sizeof(__pyx_k_expected_loss_parameter_to_be_on), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_lows_to_be_a_non_positi, __pyx_k_expected_lows_to_be_a_non_positi, sizeof(__pyx_k_expected_lows_to_be_a_non_positi), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_lows_to_be_a_non_positi_2, __pyx_k_expected_lows_to_be_a_non_positi_2, sizeof(__pyx_k_expected_lows_to_be_a_non_positi_2), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_max_iter_parameter_to_b, __pyx_k_expected_max_iter_parameter_to_b, sizeof(__pyx_k_expected_max_iter_parameter_to_b), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_max_support_size_parame, __pyx_k_expected_max_support_size_parame, sizeof(__pyx_k_expected_max_support_size_parame), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_max_swaps_parameter_to, __pyx_k_expected_max_swaps_parameter_to, sizeof(__pyx_k_expected_max_swaps_parameter_to), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_non_complex_dtype_but_g, __pyx_k_expected_non_complex_dtype_but_g, sizeof(__pyx_k_expected_non_complex_dtype_but_g), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_non_degenerate_dimensio, __pyx_k_expected_non_degenerate_dimensio, sizeof(__pyx_k_expected_non_degenerate_dimensio), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_num_folds_parameter_to, __pyx_k_expected_num_folds_parameter_to, sizeof(__pyx_k_expected_num_folds_parameter_to), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_num_gamma_to_1_when_pen, __pyx_k_expected_num_gamma_to_1_when_pen, sizeof(__pyx_k_expected_num_gamma_to_1_when_pen), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_num_gamma_to_a_positive, __pyx_k_expected_num_gamma_to_a_positive, sizeof(__pyx_k_expected_num_gamma_to_a_positive), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_num_gamma_to_be_None_if, __pyx_k_expected_num_gamma_to_be_None_if, sizeof(__pyx_k_expected_num_gamma_to_be_None_if), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_num_lambda_to_a_positiv, __pyx_k_expected_num_lambda_to_a_positiv, sizeof(__pyx_k_expected_num_lambda_to_a_positiv), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_num_lambda_to_be_None_i, __pyx_k_expected_num_lambda_to_be_None_i, sizeof(__pyx_k_expected_num_lambda_to_be_None_i), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_numerical_dtype_but_got, __pyx_k_expected_numerical_dtype_but_got, sizeof(__pyx_k_expected_numerical_dtype_but_got), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_partial_sort_parameter, __pyx_k_expected_partial_sort_parameter, sizeof(__pyx_k_expected_partial_sort_parameter), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_penalty_parameter_to_be, __pyx_k_expected_penalty_parameter_to_be, sizeof(__pyx_k_expected_penalty_parameter_to_be), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_rtol_parameter_to_exist, __pyx_k_expected_rtol_parameter_to_exist, sizeof(__pyx_k_expected_rtol_parameter_to_exist), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_scale_down_factor_param, __pyx_k_expected_scale_down_factor_param, sizeof(__pyx_k_expected_scale_down_factor_param), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_screen_size_parameter_t, __pyx_k_expected_screen_size_parameter_t, sizeof(__pyx_k_expected_screen_size_parameter_t), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_to_be_high_to_be_elemen, __pyx_k_expected_to_be_high_to_be_elemen, sizeof(__pyx_k_expected_to_be_high_to_be_elemen), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_y_to_be_a_1D_real_numpy, __pyx_k_expected_y_to_be_a_1D_real_numpy, sizeof(__pyx_k_expected_y_to_be_a_1D_real_numpy), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_y_vector_to_have_type, __pyx_k_expected_y_vector_to_have_type, sizeof(__pyx_k_expected_y_vector_to_have_type), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_y_vector_to_only_have_t, __pyx_k_expected_y_vector_to_only_have_t, sizeof(__pyx_k_expected_y_vector_to_only_have_t), 0, 1, 0, 0}, - {&__pyx_n_s_first_value, __pyx_k_first_value, sizeof(__pyx_k_first_value), 0, 0, 1, 1}, - {&__pyx_n_s_fit, __pyx_k_fit, sizeof(__pyx_k_fit), 0, 0, 1, 1}, - {&__pyx_n_s_fit_check, __pyx_k_fit_check, sizeof(__pyx_k_fit_check), 0, 0, 1, 1}, - {&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 1}, - {&__pyx_n_s_float64, __pyx_k_float64, sizeof(__pyx_k_float64), 0, 0, 1, 1}, - {&__pyx_n_s_gamma, __pyx_k_gamma, sizeof(__pyx_k_gamma), 0, 0, 1, 1}, - {&__pyx_n_s_gamma_max, __pyx_k_gamma_max, sizeof(__pyx_k_gamma_max), 0, 0, 1, 1}, - {&__pyx_n_u_gamma_max, __pyx_k_gamma_max, sizeof(__pyx_k_gamma_max), 0, 1, 0, 1}, - {&__pyx_n_s_gamma_min, __pyx_k_gamma_min, sizeof(__pyx_k_gamma_min), 0, 0, 1, 1}, - {&__pyx_n_u_gamma_min, __pyx_k_gamma_min, sizeof(__pyx_k_gamma_min), 0, 1, 0, 1}, - {&__pyx_n_s_highs, __pyx_k_highs, sizeof(__pyx_k_highs), 0, 0, 1, 1}, - {&__pyx_n_u_highs, __pyx_k_highs, sizeof(__pyx_k_highs), 0, 1, 0, 1}, - {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1}, - {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, - {&__pyx_n_s_indices, __pyx_k_indices, sizeof(__pyx_k_indices), 0, 0, 1, 1}, - {&__pyx_n_s_indptr, __pyx_k_indptr, sizeof(__pyx_k_indptr), 0, 0, 1, 1}, - {&__pyx_n_u_inf, __pyx_k_inf, sizeof(__pyx_k_inf), 0, 1, 0, 1}, - {&__pyx_n_s_intercept, __pyx_k_intercept, sizeof(__pyx_k_intercept), 0, 0, 1, 1}, - {&__pyx_n_u_intercept, __pyx_k_intercept, sizeof(__pyx_k_intercept), 0, 1, 0, 1}, - {&__pyx_n_s_intercepts, __pyx_k_intercepts, sizeof(__pyx_k_intercepts), 0, 0, 1, 1}, - {&__pyx_n_s_isrealobj, __pyx_k_isrealobj, sizeof(__pyx_k_isrealobj), 0, 0, 1, 1}, - {&__pyx_n_s_issubdtype, __pyx_k_issubdtype, sizeof(__pyx_k_issubdtype), 0, 0, 1, 1}, - {&__pyx_n_s_l0learn, __pyx_k_l0learn, sizeof(__pyx_k_l0learn), 0, 0, 1, 1}, - {&__pyx_n_s_l0learn_interface, __pyx_k_l0learn_interface, sizeof(__pyx_k_l0learn_interface), 0, 0, 1, 1}, - {&__pyx_kp_s_l0learn_interface_pyx, __pyx_k_l0learn_interface_pyx, sizeof(__pyx_k_l0learn_interface_pyx), 0, 0, 1, 0}, - {&__pyx_n_s_l0learn_models, __pyx_k_l0learn_models, sizeof(__pyx_k_l0learn_models), 0, 0, 1, 1}, - {&__pyx_n_s_lambda_0, __pyx_k_lambda_0, sizeof(__pyx_k_lambda_0), 0, 0, 1, 1}, - {&__pyx_n_s_lambda_grid, __pyx_k_lambda_grid, sizeof(__pyx_k_lambda_grid), 0, 0, 1, 1}, - {&__pyx_n_u_lambda_grid, __pyx_k_lambda_grid, sizeof(__pyx_k_lambda_grid), 0, 1, 0, 1}, - {&__pyx_n_s_loss, __pyx_k_loss, sizeof(__pyx_k_loss), 0, 0, 1, 1}, - {&__pyx_n_u_loss, __pyx_k_loss, sizeof(__pyx_k_loss), 0, 1, 0, 1}, - {&__pyx_n_s_lows, __pyx_k_lows, sizeof(__pyx_k_lows), 0, 0, 1, 1}, - {&__pyx_n_u_lows, __pyx_k_lows, sizeof(__pyx_k_lows), 0, 1, 0, 1}, - {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, - {&__pyx_n_s_max_iter, __pyx_k_max_iter, sizeof(__pyx_k_max_iter), 0, 0, 1, 1}, - {&__pyx_n_s_max_support_size, __pyx_k_max_support_size, sizeof(__pyx_k_max_support_size), 0, 0, 1, 1}, - {&__pyx_n_u_max_support_size, __pyx_k_max_support_size, sizeof(__pyx_k_max_support_size), 0, 1, 0, 1}, - {&__pyx_n_s_max_swaps, __pyx_k_max_swaps, sizeof(__pyx_k_max_swaps), 0, 0, 1, 1}, - {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1}, - {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, - {&__pyx_n_s_ndarray, __pyx_k_ndarray, sizeof(__pyx_k_ndarray), 0, 0, 1, 1}, - {&__pyx_n_s_ndim, __pyx_k_ndim, sizeof(__pyx_k_ndim), 0, 0, 1, 1}, - {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, - {&__pyx_n_s_np_to_arma_check, __pyx_k_np_to_arma_check, sizeof(__pyx_k_np_to_arma_check), 0, 0, 1, 1}, - {&__pyx_n_s_num_folds, __pyx_k_num_folds, sizeof(__pyx_k_num_folds), 0, 0, 1, 1}, - {&__pyx_n_s_num_gamma, __pyx_k_num_gamma, sizeof(__pyx_k_num_gamma), 0, 0, 1, 1}, - {&__pyx_n_u_num_gamma, __pyx_k_num_gamma, sizeof(__pyx_k_num_gamma), 0, 1, 0, 1}, - {&__pyx_kp_u_num_gamma_set_to_1_with, __pyx_k_num_gamma_set_to_1_with, sizeof(__pyx_k_num_gamma_set_to_1_with), 0, 1, 0, 0}, - {&__pyx_n_s_num_lambda, __pyx_k_num_lambda, sizeof(__pyx_k_num_lambda), 0, 0, 1, 1}, - {&__pyx_n_u_num_lambda, __pyx_k_num_lambda, sizeof(__pyx_k_num_lambda), 0, 1, 0, 1}, - {&__pyx_n_s_number, __pyx_k_number, sizeof(__pyx_k_number), 0, 0, 1, 1}, - {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, - {&__pyx_kp_u_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 1, 0, 0}, - {&__pyx_kp_u_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 1, 0, 0}, - {&__pyx_kp_u_of_non_negative_floats_but_got, __pyx_k_of_non_negative_floats_but_got, sizeof(__pyx_k_of_non_negative_floats_but_got), 0, 1, 0, 0}, - {&__pyx_kp_u_of_non_positives_floats_but_got, __pyx_k_of_non_positives_floats_but_got, sizeof(__pyx_k_of_non_positives_floats_but_got), 0, 1, 0, 0}, - {&__pyx_n_s_ones, __pyx_k_ones, sizeof(__pyx_k_ones), 0, 0, 1, 1}, - {&__pyx_kp_u_or, __pyx_k_or, sizeof(__pyx_k_or), 0, 1, 0, 0}, - {&__pyx_n_s_p, __pyx_k_p, sizeof(__pyx_k_p), 0, 0, 1, 1}, - {&__pyx_n_s_partial_sort, __pyx_k_partial_sort, sizeof(__pyx_k_partial_sort), 0, 0, 1, 1}, - {&__pyx_n_s_penalty, __pyx_k_penalty, sizeof(__pyx_k_penalty), 0, 0, 1, 1}, - {&__pyx_n_u_penalty, __pyx_k_penalty, sizeof(__pyx_k_penalty), 0, 1, 0, 1}, - {&__pyx_kp_u_penalty_Only_one, __pyx_k_penalty_Only_one, sizeof(__pyx_k_penalty_Only_one), 0, 1, 0, 0}, - {&__pyx_kp_u_penalty_value_will_be_fit, __pyx_k_penalty_value_will_be_fit, sizeof(__pyx_k_penalty_value_will_be_fit), 0, 1, 0, 0}, - {&__pyx_n_s_product, __pyx_k_product, sizeof(__pyx_k_product), 0, 0, 1, 1}, - {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, - {&__pyx_n_s_results, __pyx_k_results, sizeof(__pyx_k_results), 0, 0, 1, 1}, - {&__pyx_n_s_rtol, __pyx_k_rtol, sizeof(__pyx_k_rtol), 0, 0, 1, 1}, - {&__pyx_n_s_scale_down_factor, __pyx_k_scale_down_factor, sizeof(__pyx_k_scale_down_factor), 0, 0, 1, 1}, - {&__pyx_n_s_scipy_sparse, __pyx_k_scipy_sparse, sizeof(__pyx_k_scipy_sparse), 0, 0, 1, 1}, - {&__pyx_n_s_screen_size, __pyx_k_screen_size, sizeof(__pyx_k_screen_size), 0, 0, 1, 1}, - {&__pyx_n_u_screen_size, __pyx_k_screen_size, sizeof(__pyx_k_screen_size), 0, 1, 0, 1}, - {&__pyx_n_s_second_value, __pyx_k_second_value, sizeof(__pyx_k_second_value), 0, 0, 1, 1}, - {&__pyx_n_s_seed, __pyx_k_seed, sizeof(__pyx_k_seed), 0, 0, 1, 1}, - {&__pyx_n_s_settings, __pyx_k_settings, sizeof(__pyx_k_settings), 0, 0, 1, 1}, - {&__pyx_n_s_shape, __pyx_k_shape, sizeof(__pyx_k_shape), 0, 0, 1, 1}, - {&__pyx_n_s_sub_lambda_grid, __pyx_k_sub_lambda_grid, sizeof(__pyx_k_sub_lambda_grid), 0, 0, 1, 1}, - {&__pyx_n_s_support_size, __pyx_k_support_size, sizeof(__pyx_k_support_size), 0, 0, 1, 1}, - {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, - {&__pyx_n_s_typing, __pyx_k_typing, sizeof(__pyx_k_typing), 0, 0, 1, 1}, - {&__pyx_n_s_unique, __pyx_k_unique, sizeof(__pyx_k_unique), 0, 0, 1, 1}, - {&__pyx_n_s_unique_items, __pyx_k_unique_items, sizeof(__pyx_k_unique_items), 0, 0, 1, 1}, - {&__pyx_n_s_warn, __pyx_k_warn, sizeof(__pyx_k_warn), 0, 0, 1, 1}, - {&__pyx_n_s_warnings, __pyx_k_warnings, sizeof(__pyx_k_warnings), 0, 0, 1, 1}, - {&__pyx_kp_u_where_that_is_not_the_case, __pyx_k_where_that_is_not_the_case, sizeof(__pyx_k_where_that_is_not_the_case), 0, 1, 0, 0}, - {&__pyx_n_s_with_bounds, __pyx_k_with_bounds, sizeof(__pyx_k_with_bounds), 0, 0, 1, 1}, - {&__pyx_n_u_with_bounds, __pyx_k_with_bounds, sizeof(__pyx_k_with_bounds), 0, 1, 0, 1}, - {&__pyx_n_s_y, __pyx_k_y, sizeof(__pyx_k_y), 0, 0, 1, 1}, - {&__pyx_n_u_y, __pyx_k_y, sizeof(__pyx_k_y), 0, 1, 0, 1}, - {0, 0, 0, 0, 0, 0, 0} -}; -static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { - __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 20, __pyx_L1_error) - __pyx_builtin_NotImplementedError = __Pyx_GetBuiltinName(__pyx_n_s_NotImplementedError); if (!__pyx_builtin_NotImplementedError) __PYX_ERR(0, 29, __pyx_L1_error) - __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(0, 184, __pyx_L1_error) - __pyx_builtin_any = __Pyx_GetBuiltinName(__pyx_n_s_any); if (!__pyx_builtin_any) __PYX_ERR(0, 189, __pyx_L1_error) - __pyx_builtin_all = __Pyx_GetBuiltinName(__pyx_n_s_all); if (!__pyx_builtin_all) __PYX_ERR(0, 201, __pyx_L1_error) - __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 460, __pyx_L1_error) - __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 945, __pyx_L1_error) - __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(2, 61, __pyx_L1_error) - return 0; - __pyx_L1_error:; - return -1; -} +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":953 + * raise ImportError("numpy.core.umath failed to import") + * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ -static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { +static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { + int __pyx_r; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("import_ufunc", 0); - /* "l0learn/interface.pyx":20 - * if isinstance(arr, np.ndarray): - * if not arr.flags['F_CONTIGUOUS']: - * raise ValueError("expected arr to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< - * elif isinstance(arr, csc_matrix): - * if not arr.data.flags['F_CONTIGUOUS']: - */ - __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_to_be_F_CONTIGUOUS); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 20, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__2); - __Pyx_GIVEREF(__pyx_tuple__2); - - /* "l0learn/interface.pyx":23 - * elif isinstance(arr, csc_matrix): - * if not arr.data.flags['F_CONTIGUOUS']: - * raise ValueError("expected arr.data to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< - * if not arr.indices.flags['F_CONTIGUOUS']: - * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") - */ - __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_data_to_be_F_CONTIG); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 23, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__3); - __Pyx_GIVEREF(__pyx_tuple__3); - - /* "l0learn/interface.pyx":25 - * raise ValueError("expected arr.data to be F_CONTIGUOUS.") - * if not arr.indices.flags['F_CONTIGUOUS']: - * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< - * if not arr.indptr.flags['F_CONTIGUOUS']: - * raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") - */ - __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_indices_to_be_F_CON); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 25, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__4); - __Pyx_GIVEREF(__pyx_tuple__4); - - /* "l0learn/interface.pyx":27 - * raise ValueError("expected arr.indices to be F_CONTIGUOUS.") - * if not arr.indptr.flags['F_CONTIGUOUS']: - * raise ValueError("expected arr.indptr to be F_CONTIGUOUS.") # <<<<<<<<<<<<<< - * else: - * raise NotImplementedError(f"expected arr to be of type {np.ndarray} or {csc_matrix}, but got {type(arr)}.") + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":954 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: */ - __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_indptr_to_be_F_CONT); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 27, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__5); - __Pyx_GIVEREF(__pyx_tuple__5); + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { - /* "l0learn/interface.pyx":32 - * - * if arr.ndim == 0: - * raise ValueError("expected 'arr.ndim' to be 1 or 2, but got 0. Should be passed as scalar") # <<<<<<<<<<<<<< - * elif arr.ndim > 2: - * raise NotImplementedError(f"expected 'arr.ndim' to be 1 or 2, but got {arr.ndim}. Not supported") + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":955 + * cdef inline int import_ufunc() except -1: + * try: + * _import_umath() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.umath failed to import") */ - __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_u_expected_arr_ndim_to_be_1_or_2_b); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 32, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__7); - __Pyx_GIVEREF(__pyx_tuple__7); + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 955, __pyx_L3_error) - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":945 - * __pyx_import_array() + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":954 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() * except Exception: - * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":956 + * try: + * _import_umath() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.umath failed to import") * - * cdef inline int import_umath() except -1: */ - __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(1, 945, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__15); - __Pyx_GIVEREF(__pyx_tuple__15); + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 956, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":951 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":957 * _import_umath() * except Exception: * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * + * cdef extern from *: + */ + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 957, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 957, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":954 + * * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: */ - __pyx_tuple__16 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(1, 951, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__16); - __Pyx_GIVEREF(__pyx_tuple__16); + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } - /* "l0learn/interface.pyx":16 - * from l0learn.models import FitModel, CVFitModel + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":953 + * raise ImportError("numpy.core.umath failed to import") * - * def np_to_arma_check(arr): # <<<<<<<<<<<<<< - * # TODO: Add checks for Behaved and OwnsData - * if isinstance(arr, np.ndarray): + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() */ - __pyx_tuple__17 = PyTuple_Pack(1, __pyx_n_s_arr); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(0, 16, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__17); - __Pyx_GIVEREF(__pyx_tuple__17); - __pyx_codeobj_ = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__17, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_np_to_arma_check, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj_)) __PYX_ERR(0, 16, __pyx_L1_error) - /* "l0learn/interface.pyx":46 + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":967 * * - * SUPPORTED_LOSS = ("SquaredError", "Logistic", "SquaredHinge") # <<<<<<<<<<<<<< - * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] - * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") + * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.timedelta64)` */ - __pyx_tuple__18 = PyTuple_Pack(3, __pyx_n_u_SquaredError, __pyx_n_u_Logistic, __pyx_n_u_SquaredHinge); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(0, 46, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__18); - __Pyx_GIVEREF(__pyx_tuple__18); - /* "l0learn/interface.pyx":48 - * SUPPORTED_LOSS = ("SquaredError", "Logistic", "SquaredHinge") - * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] - * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") # <<<<<<<<<<<<<< - * SUPPORTED_ALGORITHM = ("CD", "CDPSI") +static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_obj) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_timedelta64_object", 0); + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":979 + * bool + * """ + * return PyObject_TypeCheck(obj, &PyTimedeltaArrType_Type) # <<<<<<<<<<<<<< + * * */ - __pyx_tuple__19 = PyTuple_Pack(3, __pyx_n_u_L0, __pyx_n_u_L0L1, __pyx_n_u_L0L2); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(0, 48, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__19); - __Pyx_GIVEREF(__pyx_tuple__19); + __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyTimedeltaArrType_Type)); + goto __pyx_L0; - /* "l0learn/interface.pyx":49 - * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] - * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") - * SUPPORTED_ALGORITHM = ("CD", "CDPSI") # <<<<<<<<<<<<<< + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":967 + * + * + * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.timedelta64)` + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":982 + * + * + * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.datetime64)` + */ + +static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_obj) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_datetime64_object", 0); + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":994 + * bool + * """ + * return PyObject_TypeCheck(obj, &PyDatetimeArrType_Type) # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyDatetimeArrType_Type)); + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":982 + * + * + * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.datetime64)` + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":997 + * + * + * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy datetime64 object + */ + +static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject *__pyx_v_obj) { + npy_datetime __pyx_r; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1004 + * also needed. That can be found using `get_datetime64_unit`. + * """ + * return (obj).obval # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = ((PyDatetimeScalarObject *)__pyx_v_obj)->obval; + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":997 + * + * + * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy datetime64 object + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1007 + * + * + * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy timedelta64 object + */ + +static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject *__pyx_v_obj) { + npy_timedelta __pyx_r; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1011 + * returns the int64 value underlying scalar numpy timedelta64 object + * """ + * return (obj).obval # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = ((PyTimedeltaScalarObject *)__pyx_v_obj)->obval; + goto __pyx_L0; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1007 * * + * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy timedelta64 object */ - __pyx_tuple__20 = PyTuple_Pack(2, __pyx_n_u_CD, __pyx_n_u_CDPSI); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(0, 49, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__20); - __Pyx_GIVEREF(__pyx_tuple__20); - /* "l0learn/interface.pyx":52 + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1014 * * - * def _fit_check(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< - * y: np.ndarray, - * loss: str, + * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the unit part of the dtype for a numpy datetime64 object. */ - __pyx_tuple__22 = PyTuple_Pack(38, __pyx_n_s_X, __pyx_n_s_y, __pyx_n_s_loss, __pyx_n_s_penalty, __pyx_n_s_algorithm, __pyx_n_s_max_support_size, __pyx_n_s_num_lambda, __pyx_n_s_num_gamma, __pyx_n_s_gamma_max, __pyx_n_s_gamma_min, __pyx_n_s_partial_sort, __pyx_n_s_max_iter, __pyx_n_s_rtol, __pyx_n_s_atol, __pyx_n_s_active_set, __pyx_n_s_active_set_num, __pyx_n_s_max_swaps, __pyx_n_s_scale_down_factor, __pyx_n_s_screen_size, __pyx_n_s_lambda_grid, __pyx_n_s_exclude_first_k, __pyx_n_s_intercept, __pyx_n_s_lows, __pyx_n_s_highs, __pyx_n_s_n, __pyx_n_s_p, __pyx_n_s_unique_items, __pyx_n_s_a, __pyx_n_s__21, __pyx_n_s_first_value, __pyx_n_s_second_value, __pyx_n_s_auto_lambda, __pyx_n_s_bad_lambda_grid, __pyx_n_s_i, __pyx_n_s_sub_lambda_grid, __pyx_n_s_current, __pyx_n_s_with_bounds, __pyx_n_s_bad_bounds); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(0, 52, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__22); - __Pyx_GIVEREF(__pyx_tuple__22); - __pyx_codeobj__8 = (PyObject*)__Pyx_PyCode_New(24, 0, 38, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__22, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_fit_check, 52, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__8)) __PYX_ERR(0, 52, __pyx_L1_error) - /* "l0learn/interface.pyx":247 - * - * - * def fit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< - * y: np.ndarray, - * loss: str = "SquaredError", +static CYTHON_INLINE NPY_DATETIMEUNIT __pyx_f_5numpy_get_datetime64_unit(PyObject *__pyx_v_obj) { + NPY_DATETIMEUNIT __pyx_r; + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1018 + * returns the unit part of the dtype for a numpy datetime64 object. + * """ + * return (obj).obmeta.base # <<<<<<<<<<<<<< */ - __pyx_tuple__23 = PyTuple_Pack(33, __pyx_n_s_X, __pyx_n_s_y, __pyx_n_s_loss, __pyx_n_s_penalty, __pyx_n_s_algorithm, __pyx_n_s_max_support_size, __pyx_n_s_num_lambda, __pyx_n_s_num_gamma, __pyx_n_s_gamma_max, __pyx_n_s_gamma_min, __pyx_n_s_partial_sort, __pyx_n_s_max_iter, __pyx_n_s_rtol, __pyx_n_s_atol, __pyx_n_s_active_set, __pyx_n_s_active_set_num, __pyx_n_s_max_swaps, __pyx_n_s_scale_down_factor, __pyx_n_s_screen_size, __pyx_n_s_lambda_grid, __pyx_n_s_exclude_first_k, __pyx_n_s_intercept, __pyx_n_s_lows, __pyx_n_s_highs, __pyx_n_s_check, __pyx_n_s_auto_lambda, __pyx_n_s_with_bounds, __pyx_n_s_c_lambda_grid, __pyx_n_s_c_loss, __pyx_n_s_c_penalty, __pyx_n_s_c_algorithim, __pyx_n_s_c_results, __pyx_n_s_results); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(0, 247, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__23); - __Pyx_GIVEREF(__pyx_tuple__23); - __pyx_codeobj__11 = (PyObject*)__Pyx_PyCode_New(24, 0, 33, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__23, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_fit, 247, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__11)) __PYX_ERR(0, 247, __pyx_L1_error) + __pyx_r = ((NPY_DATETIMEUNIT)((PyDatetimeScalarObject *)__pyx_v_obj)->obmeta.base); + goto __pyx_L0; - /* "l0learn/interface.pyx":533 + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1014 * * - * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< - * y: np.ndarray, - * loss: str = "SquaredError", + * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the unit part of the dtype for a numpy datetime64 object. */ - __pyx_tuple__24 = PyTuple_Pack(37, __pyx_n_s_X, __pyx_n_s_y, __pyx_n_s_loss, __pyx_n_s_penalty, __pyx_n_s_algorithm, __pyx_n_s_num_folds, __pyx_n_s_seed, __pyx_n_s_max_support_size, __pyx_n_s_num_lambda, __pyx_n_s_num_gamma, __pyx_n_s_gamma_max, __pyx_n_s_gamma_min, __pyx_n_s_partial_sort, __pyx_n_s_max_iter, __pyx_n_s_rtol, __pyx_n_s_atol, __pyx_n_s_active_set, __pyx_n_s_active_set_num, __pyx_n_s_max_swaps, __pyx_n_s_scale_down_factor, __pyx_n_s_screen_size, __pyx_n_s_lambda_grid, __pyx_n_s_exclude_first_k, __pyx_n_s_intercept, __pyx_n_s_lows, __pyx_n_s_highs, __pyx_n_s_check, __pyx_n_s_auto_lambda, __pyx_n_s_with_bounds, __pyx_n_s__21, __pyx_n_s_p, __pyx_n_s_c_lambda_grid, __pyx_n_s_c_loss, __pyx_n_s_c_penalty, __pyx_n_s_c_algorithim, __pyx_n_s_c_results, __pyx_n_s_results); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(0, 533, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__24); - __Pyx_GIVEREF(__pyx_tuple__24); - __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(26, 0, 37, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__24, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_cvfit, 533, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(0, 533, __pyx_L1_error) - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_RefNannyFinishContext(); - return -1; -} - -static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { - if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); - __pyx_float_0_ = PyFloat_FromDouble(0.); if (unlikely(!__pyx_float_0_)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_float_1_0 = PyFloat_FromDouble(1.0); if (unlikely(!__pyx_float_1_0)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_float_neg_1_0 = PyFloat_FromDouble(-1.0); if (unlikely(!__pyx_float_neg_1_0)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_10 = PyInt_FromLong(10); if (unlikely(!__pyx_int_10)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_100 = PyInt_FromLong(100); if (unlikely(!__pyx_int_100)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_200 = PyInt_FromLong(200); if (unlikely(!__pyx_int_200)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_1000 = PyInt_FromLong(1000); if (unlikely(!__pyx_int_1000)) __PYX_ERR(0, 1, __pyx_L1_error) - return 0; - __pyx_L1_error:; - return -1; -} - -static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ -static int __Pyx_modinit_global_init_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); - /*--- Global init code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; + /* function exit code */ + __pyx_L0:; + return __pyx_r; } -static int __Pyx_modinit_variable_export_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); - /*--- Variable export code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} +/* "vector.from_py":45 + * + * @cname("__pyx_convert_vector_from_py_double") + * cdef vector[X] __pyx_convert_vector_from_py_double(object o) except *: # <<<<<<<<<<<<<< + * cdef vector[X] v + * for item in o: + */ -static int __Pyx_modinit_function_export_code(void) { +static std::vector __pyx_convert_vector_from_py_double(PyObject *__pyx_v_o) { + std::vector __pyx_v_v; + PyObject *__pyx_v_item = NULL; + std::vector __pyx_r; __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *(*__pyx_t_3)(PyObject *); + PyObject *__pyx_t_4 = NULL; + double __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); - /*--- Function export code ---*/ - if (__Pyx_ExportFunction("_L0LearnFit_dense", (void (*)(void))__pyx_f_7l0learn_9interface__L0LearnFit_dense, "fitmodel (arma::dmat const &, arma::dvec const &, std::string const , std::string const , std::string const , size_t const , size_t const , size_t const , double const , double const , bool const , size_t const , double const , double const , bool const , size_t const , size_t const , double const , size_t const , bool const , std::vector > const &, size_t const , bool const , bool const , arma::dvec const &, arma::dvec const &)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) - if (__Pyx_ExportFunction("_L0LearnFit_sparse", (void (*)(void))__pyx_f_7l0learn_9interface__L0LearnFit_sparse, "fitmodel (arma::sp_dmat const &, arma::dvec const &, std::string const , std::string const , std::string const , size_t const , size_t const , size_t const , double const , double const , bool const , size_t const , double const , double const , bool const , size_t const , size_t const , double const , size_t const , bool const , std::vector > const &, size_t const , bool const , bool const , arma::dvec const &, arma::dvec const &)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) - if (__Pyx_ExportFunction("_L0LearnCV_dense", (void (*)(void))__pyx_f_7l0learn_9interface__L0LearnCV_dense, "cvfitmodel (arma::dmat const &, arma::dvec const &, std::string const , std::string const , std::string const , size_t const , size_t const , size_t const , double const , double const , bool const , size_t const , double const , double const , bool const , size_t const , size_t const , double const , size_t const , bool const , std::vector > const &, unsigned int const , double const , size_t const , bool const , bool const , arma::dvec const &, arma::dvec const &)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) - if (__Pyx_ExportFunction("_L0LearnCV_sparse", (void (*)(void))__pyx_f_7l0learn_9interface__L0LearnCV_sparse, "cvfitmodel (arma::sp_dmat const &, arma::dvec const &, std::string const , std::string const , std::string const , size_t const , size_t const , size_t const , double const , double const , bool const , size_t const , double const , double const , bool const , size_t const , size_t const , double const , size_t const , bool const , std::vector > const &, unsigned int const , double const , size_t const , bool const , bool const , arma::dvec const &, arma::dvec const &)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_RefNannyFinishContext(); - return -1; -} + __Pyx_RefNannySetupContext("__pyx_convert_vector_from_py_double", 0); -static int __Pyx_modinit_type_init_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); - /*--- Type init code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} + /* "vector.from_py":47 + * cdef vector[X] __pyx_convert_vector_from_py_double(object o) except *: + * cdef vector[X] v + * for item in o: # <<<<<<<<<<<<<< + * v.push_back(item) + * return v + */ + if (likely(PyList_CheckExact(__pyx_v_o)) || PyTuple_CheckExact(__pyx_v_o)) { + __pyx_t_1 = __pyx_v_o; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + __pyx_t_3 = NULL; + } else { + __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_o); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 47, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_3)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(2, 47, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(2, 47, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } + } else { + __pyx_t_4 = __pyx_t_3(__pyx_t_1); + if (unlikely(!__pyx_t_4)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(2, 47, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_4); + __pyx_t_4 = 0; -static int __Pyx_modinit_type_import_code(void) { - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); - /*--- Type import code ---*/ - __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", - #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 - sizeof(PyTypeObject), - #else - sizeof(PyHeapTypeObject), - #endif - __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(3, 9, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 200, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 200, __pyx_L1_error) - __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 223, __pyx_L1_error) - __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 227, __pyx_L1_error) - __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 239, __pyx_L1_error) - __pyx_ptype_5numpy_generic = __Pyx_ImportType(__pyx_t_1, "numpy", "generic", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_5numpy_generic) __PYX_ERR(1, 771, __pyx_L1_error) - __pyx_ptype_5numpy_number = __Pyx_ImportType(__pyx_t_1, "numpy", "number", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_5numpy_number) __PYX_ERR(1, 773, __pyx_L1_error) - __pyx_ptype_5numpy_integer = __Pyx_ImportType(__pyx_t_1, "numpy", "integer", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_5numpy_integer) __PYX_ERR(1, 775, __pyx_L1_error) - __pyx_ptype_5numpy_signedinteger = __Pyx_ImportType(__pyx_t_1, "numpy", "signedinteger", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_5numpy_signedinteger) __PYX_ERR(1, 777, __pyx_L1_error) - __pyx_ptype_5numpy_unsignedinteger = __Pyx_ImportType(__pyx_t_1, "numpy", "unsignedinteger", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_5numpy_unsignedinteger) __PYX_ERR(1, 779, __pyx_L1_error) - __pyx_ptype_5numpy_inexact = __Pyx_ImportType(__pyx_t_1, "numpy", "inexact", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_5numpy_inexact) __PYX_ERR(1, 781, __pyx_L1_error) - __pyx_ptype_5numpy_floating = __Pyx_ImportType(__pyx_t_1, "numpy", "floating", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_5numpy_floating) __PYX_ERR(1, 783, __pyx_L1_error) - __pyx_ptype_5numpy_complexfloating = __Pyx_ImportType(__pyx_t_1, "numpy", "complexfloating", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_5numpy_complexfloating) __PYX_ERR(1, 785, __pyx_L1_error) - __pyx_ptype_5numpy_flexible = __Pyx_ImportType(__pyx_t_1, "numpy", "flexible", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_5numpy_flexible) __PYX_ERR(1, 787, __pyx_L1_error) - __pyx_ptype_5numpy_character = __Pyx_ImportType(__pyx_t_1, "numpy", "character", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); - if (!__pyx_ptype_5numpy_character) __PYX_ERR(1, 789, __pyx_L1_error) - __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Ignore); - if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 827, __pyx_L1_error) + /* "vector.from_py":48 + * cdef vector[X] v + * for item in o: + * v.push_back(item) # <<<<<<<<<<<<<< + * return v + * + */ + __pyx_t_5 = __pyx_PyFloat_AsDouble(__pyx_v_item); if (unlikely((__pyx_t_5 == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 48, __pyx_L1_error) + __pyx_v_v.push_back(((double)__pyx_t_5)); + + /* "vector.from_py":47 + * cdef vector[X] __pyx_convert_vector_from_py_double(object o) except *: + * cdef vector[X] v + * for item in o: # <<<<<<<<<<<<<< + * v.push_back(item) + * return v + */ + } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_RefNannyFinishContext(); - return 0; + + /* "vector.from_py":49 + * for item in o: + * v.push_back(item) + * return v # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_v; + goto __pyx_L0; + + /* "vector.from_py":45 + * + * @cname("__pyx_convert_vector_from_py_double") + * cdef vector[X] __pyx_convert_vector_from_py_double(object o) except *: # <<<<<<<<<<<<<< + * cdef vector[X] v + * for item in o: + */ + + /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("vector.from_py.__pyx_convert_vector_from_py_double", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_item); __Pyx_RefNannyFinishContext(); - return -1; -} - -static int __Pyx_modinit_variable_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); - /*--- Variable import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; + return __pyx_r; } -static int __Pyx_modinit_function_import_code(void) { +static std::vector > __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(PyObject *__pyx_v_o) { + std::vector > __pyx_v_v; + PyObject *__pyx_v_item = NULL; + std::vector > __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *(*__pyx_t_3)(PyObject *); + PyObject *__pyx_t_4 = NULL; + std::vector __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); - /*--- Function import code ---*/ - __pyx_t_1 = PyImport_ImportModule("l0learn.cyarma"); if (!__pyx_t_1) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (__Pyx_ImportFunction(__pyx_t_1, "numpy_to_dmat_d", (void (**)(void))&__pyx_f_7l0learn_6cyarma_numpy_to_dmat_d, "arma::dmat (PyArrayObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) - if (__Pyx_ImportFunction(__pyx_t_1, "numpy_to_dvec_d", (void (**)(void))&__pyx_f_7l0learn_6cyarma_numpy_to_dvec_d, "arma::dvec (PyArrayObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) - if (__Pyx_ImportFunction(__pyx_t_1, "numpy_to_sp_dmat_d", (void (**)(void))&__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d, "arma::sp_dmat (PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) - if (__Pyx_ImportFunction(__pyx_t_1, "sp_dmat_field_to_list", (void (**)(void))&__pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list, "PyObject *(arma::field )") < 0) __PYX_ERR(0, 1, __pyx_L1_error) - if (__Pyx_ImportFunction(__pyx_t_1, "dvec_field_to_list", (void (**)(void))&__pyx_f_7l0learn_6cyarma_dvec_field_to_list, "PyObject *(arma::field )") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_RefNannySetupContext("__pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___", 0); + + /* "vector.from_py":47 + * cdef vector[X] __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(object o) except *: + * cdef vector[X] v + * for item in o: # <<<<<<<<<<<<<< + * v.push_back(item) + * return v + */ + if (likely(PyList_CheckExact(__pyx_v_o)) || PyTuple_CheckExact(__pyx_v_o)) { + __pyx_t_1 = __pyx_v_o; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + __pyx_t_3 = NULL; + } else { + __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_o); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 47, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_3)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(2, 47, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(2, 47, __pyx_L1_error) + #else + __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } + } else { + __pyx_t_4 = __pyx_t_3(__pyx_t_1); + if (unlikely(!__pyx_t_4)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(2, 47, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_4); + __pyx_t_4 = 0; + + /* "vector.from_py":48 + * cdef vector[X] v + * for item in o: + * v.push_back(item) # <<<<<<<<<<<<<< + * return v + * + */ + __pyx_t_5 = __pyx_convert_vector_from_py_double(__pyx_v_item); if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 48, __pyx_L1_error) + __pyx_v_v.push_back(((std::vector )__pyx_t_5)); + + /* "vector.from_py":47 + * cdef vector[X] __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(object o) except *: + * cdef vector[X] v + * for item in o: # <<<<<<<<<<<<<< + * v.push_back(item) + * return v + */ + } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_RefNannyFinishContext(); - return 0; + + /* "vector.from_py":49 + * for item in o: + * v.push_back(item) + * return v # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_v; + goto __pyx_L0; + + /* "vector.from_py":45 + * + * @cname("__pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___") + * cdef vector[X] __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(object o) except *: # <<<<<<<<<<<<<< + * cdef vector[X] v + * for item in o: + */ + + /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("vector.from_py.__pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_item); __Pyx_RefNannyFinishContext(); - return -1; + return __pyx_r; } +/* "string.from_py":13 + * + * @cname("__pyx_convert_string_from_py_std__in_string") + * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: # <<<<<<<<<<<<<< + * cdef Py_ssize_t length = 0 + * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) + */ -#ifndef CYTHON_NO_PYINIT_EXPORT -#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC -#elif PY_MAJOR_VERSION < 3 -#ifdef __cplusplus -#define __Pyx_PyMODINIT_FUNC extern "C" void -#else -#define __Pyx_PyMODINIT_FUNC void -#endif -#else -#ifdef __cplusplus -#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * -#else -#define __Pyx_PyMODINIT_FUNC PyObject * -#endif -#endif +static std::string __pyx_convert_string_from_py_std__in_string(PyObject *__pyx_v_o) { + Py_ssize_t __pyx_v_length; + char const *__pyx_v_data; + std::string __pyx_r; + __Pyx_RefNannyDeclarations + char const *__pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_convert_string_from_py_std__in_string", 0); + /* "string.from_py":14 + * @cname("__pyx_convert_string_from_py_std__in_string") + * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: + * cdef Py_ssize_t length = 0 # <<<<<<<<<<<<<< + * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) + * return string(data, length) + */ + __pyx_v_length = 0; -#if PY_MAJOR_VERSION < 3 -__Pyx_PyMODINIT_FUNC initinterface(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC initinterface(void) -#else -__Pyx_PyMODINIT_FUNC PyInit_interface(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC PyInit_interface(void) -#if CYTHON_PEP489_MULTI_PHASE_INIT -{ - return PyModuleDef_Init(&__pyx_moduledef); -} -static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { - #if PY_VERSION_HEX >= 0x030700A1 - static PY_INT64_T main_interpreter_id = -1; - PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); - if (main_interpreter_id == -1) { - main_interpreter_id = current_id; - return (unlikely(current_id == -1)) ? -1 : 0; - } else if (unlikely(main_interpreter_id != current_id)) - #else - static PyInterpreterState *main_interpreter = NULL; - PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; - if (!main_interpreter) { - main_interpreter = current_interpreter; - } else if (unlikely(main_interpreter != current_interpreter)) - #endif - { - PyErr_SetString( - PyExc_ImportError, - "Interpreter change detected - this module can only be loaded into one interpreter per process."); - return -1; - } - return 0; -} -static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { - PyObject *value = PyObject_GetAttrString(spec, from_name); - int result = 0; - if (likely(value)) { - if (allow_none || value != Py_None) { - result = PyDict_SetItemString(moddict, to_name, value); - } - Py_DECREF(value); - } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { - PyErr_Clear(); - } else { - result = -1; - } - return result; -} -static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { - PyObject *module = NULL, *moddict, *modname; - if (__Pyx_check_single_interpreter()) - return NULL; - if (__pyx_m) - return __Pyx_NewRef(__pyx_m); - modname = PyObject_GetAttrString(spec, "name"); - if (unlikely(!modname)) goto bad; - module = PyModule_NewObject(modname); - Py_DECREF(modname); - if (unlikely(!module)) goto bad; - moddict = PyModule_GetDict(module); - if (unlikely(!moddict)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; - return module; -bad: - Py_XDECREF(module); - return NULL; + /* "string.from_py":15 + * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: + * cdef Py_ssize_t length = 0 + * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) # <<<<<<<<<<<<<< + * return string(data, length) + * + */ + __pyx_t_1 = __Pyx_PyObject_AsStringAndSize(__pyx_v_o, (&__pyx_v_length)); if (unlikely(__pyx_t_1 == ((char const *)NULL))) __PYX_ERR(2, 15, __pyx_L1_error) + __pyx_v_data = __pyx_t_1; + + /* "string.from_py":16 + * cdef Py_ssize_t length = 0 + * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) + * return string(data, length) # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = std::string(__pyx_v_data, __pyx_v_length); + goto __pyx_L0; + + /* "string.from_py":13 + * + * @cname("__pyx_convert_string_from_py_std__in_string") + * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: # <<<<<<<<<<<<<< + * cdef Py_ssize_t length = 0 + * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("string.from_py.__pyx_convert_string_from_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_pretend_to_initialize(&__pyx_r); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; } +/* "vector.to_py":60 + * + * @cname("__pyx_convert_vector_to_py_double") + * cdef object __pyx_convert_vector_to_py_double(vector[X]& v): # <<<<<<<<<<<<<< + * return [v[i] for i in range(v.size())] + * + */ -static CYTHON_SMALL_CODE int __pyx_pymod_exec_interface(PyObject *__pyx_pyinit_module) -#endif -#endif -{ - __Pyx_TraceDeclarations +static PyObject *__pyx_convert_vector_to_py_double(const std::vector &__pyx_v_v) { + size_t __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - double __pyx_t_4; + size_t __pyx_t_2; + size_t __pyx_t_3; + size_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannyDeclarations - #if CYTHON_PEP489_MULTI_PHASE_INIT - if (__pyx_m) { - if (__pyx_m == __pyx_pyinit_module) return 0; - PyErr_SetString(PyExc_RuntimeError, "Module 'interface' has already been imported. Re-initialisation is not supported."); - return -1; + __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_double", 0); + + /* "vector.to_py":61 + * @cname("__pyx_convert_vector_to_py_double") + * cdef object __pyx_convert_vector_to_py_double(vector[X]& v): + * return [v[i] for i in range(v.size())] # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_v_v.size(); + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + __pyx_t_5 = PyFloat_FromDouble((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } - #elif PY_MAJOR_VERSION >= 3 - if (__pyx_m) return __Pyx_NewRef(__pyx_m); - #endif - #if CYTHON_REFNANNY -__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); -if (!__Pyx_RefNanny) { - PyErr_Clear(); - __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); - if (!__Pyx_RefNanny) - Py_FatalError("failed to import 'refnanny' module"); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "vector.to_py":60 + * + * @cname("__pyx_convert_vector_to_py_double") + * cdef object __pyx_convert_vector_to_py_double(vector[X]& v): # <<<<<<<<<<<<<< + * return [v[i] for i in range(v.size())] + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_double", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; } -#endif - __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_interface(void)", 0); - if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #ifdef __Pxy_PyFrame_Initialize_Offsets - __Pxy_PyFrame_Initialize_Offsets(); - #endif - __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) - #ifdef __Pyx_CyFunction_USED - if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_FusedFunction_USED - if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_Coroutine_USED - if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_Generator_USED - if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_AsyncGen_USED - if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_StopAsyncIteration_USED - if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - /*--- Library function declarations ---*/ - /*--- Threads initialization code ---*/ - #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS - PyEval_InitThreads(); - #endif - /*--- Module creation code ---*/ - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_m = __pyx_pyinit_module; - Py_INCREF(__pyx_m); - #else - #if PY_MAJOR_VERSION < 3 - __pyx_m = Py_InitModule4("interface", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); - #else - __pyx_m = PyModule_Create(&__pyx_moduledef); - #endif - if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_d); - __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_b); - __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_cython_runtime); - if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); - /*--- Initialize various global constants etc. ---*/ - if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) - if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - if (__pyx_module_is_main_l0learn__interface) { - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - } - #if PY_MAJOR_VERSION >= 3 - { - PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) - if (!PyDict_GetItemString(modules, "l0learn.interface")) { - if (unlikely(PyDict_SetItemString(modules, "l0learn.interface", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) - } + +static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(const std::vector > &__pyx_v_v) { + size_t __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + size_t __pyx_t_2; + size_t __pyx_t_3; + size_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___", 0); + + /* "vector.to_py":61 + * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___") + * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(vector[X]& v): + * return [v[i] for i in range(v.size())] # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_v_v.size(); + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + __pyx_t_5 = __pyx_convert_vector_to_py_double((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } - #endif - /*--- Builtin init code ---*/ - if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - /*--- Constants init code ---*/ - if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - /*--- Global type/function init code ---*/ - (void)__Pyx_modinit_global_init_code(); - (void)__Pyx_modinit_variable_export_code(); - if (unlikely(__Pyx_modinit_function_export_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) - (void)__Pyx_modinit_type_init_code(); - if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) - (void)__Pyx_modinit_variable_import_code(); - if (unlikely(__Pyx_modinit_function_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) - /*--- Execution code ---*/ - #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) - if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - __Pyx_TraceCall("__Pyx_PyMODINIT_FUNC PyInit_interface(void)", __pyx_f[0], 1, 0, __PYX_ERR(0, 1, __pyx_L1_error)); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "l0learn/interface.pyx":4 - * from libcpp.string cimport string - * from libcpp cimport bool as cppbool - * import numpy as np # <<<<<<<<<<<<<< - * from scipy.sparse import csc_matrix - * from warnings import warn + /* "vector.to_py":60 + * + * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___") + * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(vector[X]& v): # <<<<<<<<<<<<<< + * return [v[i] for i in range(v.size())] + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_convert_vector_to_py_size_t(const std::vector &__pyx_v_v) { + size_t __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + size_t __pyx_t_2; + size_t __pyx_t_3; + size_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_size_t", 0); + + /* "vector.to_py":61 + * @cname("__pyx_convert_vector_to_py_size_t") + * cdef object __pyx_convert_vector_to_py_size_t(vector[X]& v): + * return [v[i] for i in range(v.size())] # <<<<<<<<<<<<<< + * + * */ - __Pyx_TraceLine(4,0,__PYX_ERR(0, 4, __pyx_L1_error)) - __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 61, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_2 = __pyx_v_v.size(); + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + __pyx_t_5 = __Pyx_PyInt_FromSize_t((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "l0learn/interface.pyx":5 - * from libcpp cimport bool as cppbool - * import numpy as np - * from scipy.sparse import csc_matrix # <<<<<<<<<<<<<< - * from warnings import warn + /* "vector.to_py":60 + * + * @cname("__pyx_convert_vector_to_py_size_t") + * cdef object __pyx_convert_vector_to_py_size_t(vector[X]& v): # <<<<<<<<<<<<<< + * return [v[i] for i in range(v.size())] * */ - __Pyx_TraceLine(5,0,__PYX_ERR(0, 5, __pyx_L1_error)) - __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_n_s_csc_matrix); - __Pyx_GIVEREF(__pyx_n_s_csc_matrix); - PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_csc_matrix); - __pyx_t_2 = __Pyx_Import(__pyx_n_s_scipy_sparse, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_csc_matrix, __pyx_t_1) < 0) __PYX_ERR(0, 5, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "l0learn/interface.pyx":6 - * import numpy as np - * from scipy.sparse import csc_matrix - * from warnings import warn # <<<<<<<<<<<<<< + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_size_t", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(const std::vector > &__pyx_v_v) { + size_t __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + size_t __pyx_t_2; + size_t __pyx_t_3; + size_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___", 0); + + /* "vector.to_py":61 + * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___") + * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(vector[X]& v): + * return [v[i] for i in range(v.size())] # <<<<<<<<<<<<<< + * * - * from typing import Union, Optional, List, Dict, Any */ - __Pyx_TraceLine(6,0,__PYX_ERR(0, 6, __pyx_L1_error)) - __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_n_s_warn); - __Pyx_GIVEREF(__pyx_n_s_warn); - PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_warn); - __pyx_t_1 = __Pyx_Import(__pyx_n_s_warnings, __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 61, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_warn); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_warn, __pyx_t_2) < 0) __PYX_ERR(0, 6, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_2 = __pyx_v_v.size(); + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + __pyx_t_5 = __pyx_convert_vector_to_py_size_t((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "l0learn/interface.pyx":8 - * from warnings import warn + /* "vector.to_py":60 * - * from typing import Union, Optional, List, Dict, Any # <<<<<<<<<<<<<< + * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___") + * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(vector[X]& v): # <<<<<<<<<<<<<< + * return [v[i] for i in range(v.size())] * - * from l0learn.cyarma cimport dmat, sp_dmat, numpy_to_sp_dmat_d, numpy_to_dmat_d, dvec, numpy_to_dvec_d, \ */ - __Pyx_TraceLine(8,0,__PYX_ERR(0, 8, __pyx_L1_error)) - __pyx_t_1 = PyList_New(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(__pyx_n_s_Union); - __Pyx_GIVEREF(__pyx_n_s_Union); - PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_Union); - __Pyx_INCREF(__pyx_n_s_Optional); - __Pyx_GIVEREF(__pyx_n_s_Optional); - PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_Optional); - __Pyx_INCREF(__pyx_n_s_List); - __Pyx_GIVEREF(__pyx_n_s_List); - PyList_SET_ITEM(__pyx_t_1, 2, __pyx_n_s_List); - __Pyx_INCREF(__pyx_n_s_Dict); - __Pyx_GIVEREF(__pyx_n_s_Dict); - PyList_SET_ITEM(__pyx_t_1, 3, __pyx_n_s_Dict); - __Pyx_INCREF(__pyx_n_s_Any); - __Pyx_GIVEREF(__pyx_n_s_Any); - PyList_SET_ITEM(__pyx_t_1, 4, __pyx_n_s_Any); - __pyx_t_2 = __Pyx_Import(__pyx_n_s_typing, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Union); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_Union, __pyx_t_1) < 0) __PYX_ERR(0, 8, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Optional); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_Optional, __pyx_t_1) < 0) __PYX_ERR(0, 8, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_List); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_List, __pyx_t_1) < 0) __PYX_ERR(0, 8, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Dict); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_convert_vector_to_py_bool(const std::vector &__pyx_v_v) { + size_t __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + size_t __pyx_t_2; + size_t __pyx_t_3; + size_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_bool", 0); + + /* "vector.to_py":61 + * @cname("__pyx_convert_vector_to_py_bool") + * cdef object __pyx_convert_vector_to_py_bool(vector[X]& v): + * return [v[i] for i in range(v.size())] # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 61, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_Dict, __pyx_t_1) < 0) __PYX_ERR(0, 8, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Any); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) + __pyx_t_2 = __pyx_v_v.size(); + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + __pyx_t_5 = __Pyx_PyBool_FromLong((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "vector.to_py":60 + * + * @cname("__pyx_convert_vector_to_py_bool") + * cdef object __pyx_convert_vector_to_py_bool(vector[X]& v): # <<<<<<<<<<<<<< + * return [v[i] for i in range(v.size())] + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_bool", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(const std::vector > &__pyx_v_v) { + size_t __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + size_t __pyx_t_2; + size_t __pyx_t_3; + size_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___", 0); + + /* "vector.to_py":61 + * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___") + * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(vector[X]& v): + * return [v[i] for i in range(v.size())] # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 61, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_Any, __pyx_t_1) < 0) __PYX_ERR(0, 8, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __pyx_v_v.size(); + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + __pyx_t_5 = __pyx_convert_vector_to_py_bool((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(2, 61, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; - /* "l0learn/interface.pyx":13 - * sp_dmat_field_to_list, dvec_field_to_list + /* "vector.to_py":60 * - * import l0learn.models # <<<<<<<<<<<<<< - * from l0learn.models import FitModel, CVFitModel + * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___") + * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(vector[X]& v): # <<<<<<<<<<<<<< + * return [v[i] for i in range(v.size())] * */ - __Pyx_TraceLine(13,0,__PYX_ERR(0, 13, __pyx_L1_error)) - __pyx_t_2 = __Pyx_Import(__pyx_n_s_l0learn_models, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 13, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_l0learn, __pyx_t_2) < 0) __PYX_ERR(0, 13, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "l0learn/interface.pyx":14 - * - * import l0learn.models - * from l0learn.models import FitModel, CVFitModel # <<<<<<<<<<<<<< + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; + +#if PY_MAJOR_VERSION >= 3 +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_interface(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_interface}, + {0, NULL} +}; +#endif + +static struct PyModuleDef __pyx_moduledef = { + PyModuleDef_HEAD_INIT, + "interface", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif +#ifndef CYTHON_SMALL_CODE +#if defined(__clang__) + #define CYTHON_SMALL_CODE +#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) + #define CYTHON_SMALL_CODE __attribute__((cold)) +#else + #define CYTHON_SMALL_CODE +#endif +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_kp_u_, __pyx_k_, sizeof(__pyx_k_), 0, 1, 0, 0}, + {&__pyx_n_s_Any, __pyx_k_Any, sizeof(__pyx_k_Any), 0, 0, 1, 1}, + {&__pyx_n_u_CD, __pyx_k_CD, sizeof(__pyx_k_CD), 0, 1, 0, 1}, + {&__pyx_n_u_CDPSI, __pyx_k_CDPSI, sizeof(__pyx_k_CDPSI), 0, 1, 0, 1}, + {&__pyx_n_s_CLASSIFICATION_LOSS, __pyx_k_CLASSIFICATION_LOSS, sizeof(__pyx_k_CLASSIFICATION_LOSS), 0, 0, 1, 1}, + {&__pyx_n_s_CVFitModel, __pyx_k_CVFitModel, sizeof(__pyx_k_CVFitModel), 0, 0, 1, 1}, + {&__pyx_n_u_D, __pyx_k_D, sizeof(__pyx_k_D), 0, 1, 0, 1}, + {&__pyx_n_s_Dict, __pyx_k_Dict, sizeof(__pyx_k_Dict), 0, 0, 1, 1}, + {&__pyx_kp_u_Expected_all_values_of_lambda_gr, __pyx_k_Expected_all_values_of_lambda_gr, sizeof(__pyx_k_Expected_all_values_of_lambda_gr), 0, 1, 0, 0}, + {&__pyx_kp_u_Expected_each_element_of_lambda, __pyx_k_Expected_each_element_of_lambda, sizeof(__pyx_k_Expected_each_element_of_lambda), 0, 1, 0, 0}, + {&__pyx_n_s_FitModel, __pyx_k_FitModel, sizeof(__pyx_k_FitModel), 0, 0, 1, 1}, + {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1}, + {&__pyx_n_u_L0, __pyx_k_L0, sizeof(__pyx_k_L0), 0, 1, 0, 1}, + {&__pyx_n_u_L0L1, __pyx_k_L0L1, sizeof(__pyx_k_L0L1), 0, 1, 0, 1}, + {&__pyx_n_u_L0L2, __pyx_k_L0L2, sizeof(__pyx_k_L0L2), 0, 1, 0, 1}, + {&__pyx_kp_u_L0_Penalty_requires_lambda_grid, __pyx_k_L0_Penalty_requires_lambda_grid, sizeof(__pyx_k_L0_Penalty_requires_lambda_grid), 0, 1, 0, 0}, + {&__pyx_n_s_List, __pyx_k_List, sizeof(__pyx_k_List), 0, 0, 1, 1}, + {&__pyx_n_u_Logistic, __pyx_k_Logistic, sizeof(__pyx_k_Logistic), 0, 1, 0, 1}, + {&__pyx_kp_u_None, __pyx_k_None, sizeof(__pyx_k_None), 0, 1, 0, 0}, + {&__pyx_n_s_Optional, __pyx_k_Optional, sizeof(__pyx_k_Optional), 0, 0, 1, 1}, + {&__pyx_n_s_SUPPORTED_ALGORITHM, __pyx_k_SUPPORTED_ALGORITHM, sizeof(__pyx_k_SUPPORTED_ALGORITHM), 0, 0, 1, 1}, + {&__pyx_n_s_SUPPORTED_LOSS, __pyx_k_SUPPORTED_LOSS, sizeof(__pyx_k_SUPPORTED_LOSS), 0, 0, 1, 1}, + {&__pyx_n_s_SUPPORTED_PENALTY, __pyx_k_SUPPORTED_PENALTY, sizeof(__pyx_k_SUPPORTED_PENALTY), 0, 0, 1, 1}, + {&__pyx_n_u_SquaredError, __pyx_k_SquaredError, sizeof(__pyx_k_SquaredError), 0, 1, 0, 1}, + {&__pyx_n_u_SquaredHinge, __pyx_k_SquaredHinge, sizeof(__pyx_k_SquaredHinge), 0, 1, 0, 1}, + {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, + {&__pyx_n_s_Union, __pyx_k_Union, sizeof(__pyx_k_Union), 0, 0, 1, 1}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s_X, __pyx_k_X, sizeof(__pyx_k_X), 0, 0, 1, 1}, + {&__pyx_n_s__11, __pyx_k__11, sizeof(__pyx_k__11), 0, 0, 1, 1}, + {&__pyx_n_s_a, __pyx_k_a, sizeof(__pyx_k_a), 0, 0, 1, 1}, + {&__pyx_n_s_active_set, __pyx_k_active_set, sizeof(__pyx_k_active_set), 0, 0, 1, 1}, + {&__pyx_n_s_active_set_num, __pyx_k_active_set_num, sizeof(__pyx_k_active_set_num), 0, 0, 1, 1}, + {&__pyx_n_s_algorithm, __pyx_k_algorithm, sizeof(__pyx_k_algorithm), 0, 0, 1, 1}, + {&__pyx_n_s_all, __pyx_k_all, sizeof(__pyx_k_all), 0, 0, 1, 1}, + {&__pyx_n_s_any, __pyx_k_any, sizeof(__pyx_k_any), 0, 0, 1, 1}, + {&__pyx_n_s_argwhere, __pyx_k_argwhere, sizeof(__pyx_k_argwhere), 0, 0, 1, 1}, + {&__pyx_n_s_array, __pyx_k_array, sizeof(__pyx_k_array), 0, 0, 1, 1}, + {&__pyx_n_s_astype, __pyx_k_astype, sizeof(__pyx_k_astype), 0, 0, 1, 1}, + {&__pyx_n_s_atol, __pyx_k_atol, sizeof(__pyx_k_atol), 0, 0, 1, 1}, + {&__pyx_n_s_auto_lambda, __pyx_k_auto_lambda, sizeof(__pyx_k_auto_lambda), 0, 0, 1, 1}, + {&__pyx_n_u_auto_lambda, __pyx_k_auto_lambda, sizeof(__pyx_k_auto_lambda), 0, 1, 0, 1}, + {&__pyx_n_s_bad_bounds, __pyx_k_bad_bounds, sizeof(__pyx_k_bad_bounds), 0, 0, 1, 1}, + {&__pyx_n_s_bad_lambda_grid, __pyx_k_bad_lambda_grid, sizeof(__pyx_k_bad_lambda_grid), 0, 0, 1, 1}, + {&__pyx_kp_u_but_got, __pyx_k_but_got, sizeof(__pyx_k_but_got), 0, 1, 0, 0}, + {&__pyx_n_s_c_algorithim, __pyx_k_c_algorithim, sizeof(__pyx_k_c_algorithim), 0, 0, 1, 1}, + {&__pyx_n_s_c_lambda_grid, __pyx_k_c_lambda_grid, sizeof(__pyx_k_c_lambda_grid), 0, 0, 1, 1}, + {&__pyx_n_s_c_loss, __pyx_k_c_loss, sizeof(__pyx_k_c_loss), 0, 0, 1, 1}, + {&__pyx_n_s_c_penalty, __pyx_k_c_penalty, sizeof(__pyx_k_c_penalty), 0, 0, 1, 1}, + {&__pyx_n_s_c_results, __pyx_k_c_results, sizeof(__pyx_k_c_results), 0, 0, 1, 1}, + {&__pyx_n_s_check, __pyx_k_check, sizeof(__pyx_k_check), 0, 0, 1, 1}, + {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_n_s_coeffs, __pyx_k_coeffs, sizeof(__pyx_k_coeffs), 0, 0, 1, 1}, + {&__pyx_kp_u_containing_a_negative_value, __pyx_k_containing_a_negative_value, sizeof(__pyx_k_containing_a_negative_value), 0, 1, 0, 0}, + {&__pyx_kp_u_containing_an_increasing_value, __pyx_k_containing_an_increasing_value, sizeof(__pyx_k_containing_an_increasing_value), 0, 1, 0, 0}, + {&__pyx_n_s_converged, __pyx_k_converged, sizeof(__pyx_k_converged), 0, 0, 1, 1}, + {&__pyx_n_s_copy, __pyx_k_copy, sizeof(__pyx_k_copy), 0, 0, 1, 1}, + {&__pyx_n_s_csc_matrix, __pyx_k_csc_matrix, sizeof(__pyx_k_csc_matrix), 0, 0, 1, 1}, + {&__pyx_n_s_current, __pyx_k_current, sizeof(__pyx_k_current), 0, 0, 1, 1}, + {&__pyx_n_s_cv_means, __pyx_k_cv_means, sizeof(__pyx_k_cv_means), 0, 0, 1, 1}, + {&__pyx_n_s_cv_sds, __pyx_k_cv_sds, sizeof(__pyx_k_cv_sds), 0, 0, 1, 1}, + {&__pyx_n_s_cvfit, __pyx_k_cvfit, sizeof(__pyx_k_cvfit), 0, 0, 1, 1}, + {&__pyx_n_s_diff, __pyx_k_diff, sizeof(__pyx_k_diff), 0, 0, 1, 1}, + {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1}, + {&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1}, + {&__pyx_n_s_exclude_first_k, __pyx_k_exclude_first_k, sizeof(__pyx_k_exclude_first_k), 0, 0, 1, 1}, + {&__pyx_kp_u_expected_X_to_be_2D_but_got, __pyx_k_expected_X_to_be_2D_but_got, sizeof(__pyx_k_expected_X_to_be_2D_but_got), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_X_to_be_a, __pyx_k_expected_X_to_be_a, sizeof(__pyx_k_expected_X_to_be_a), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_X_to_have_dtype, __pyx_k_expected_X_to_have_dtype, sizeof(__pyx_k_expected_X_to_have_dtype), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_X_to_have_non_degenerat, __pyx_k_expected_X_to_have_non_degenerat, sizeof(__pyx_k_expected_X_to_have_non_degenerat), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_active_set_num_paramete, __pyx_k_expected_active_set_num_paramete, sizeof(__pyx_k_expected_active_set_num_paramete), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_active_set_parameter_to, __pyx_k_expected_active_set_parameter_to, sizeof(__pyx_k_expected_active_set_parameter_to), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_algorithm_parameter_to, __pyx_k_expected_algorithm_parameter_to, sizeof(__pyx_k_expected_algorithm_parameter_to), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_atol_parameter_to_exist, __pyx_k_expected_atol_parameter_to_exist, sizeof(__pyx_k_expected_atol_parameter_to_exist), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_exclude_first_k_paramet, __pyx_k_expected_exclude_first_k_paramet, sizeof(__pyx_k_expected_exclude_first_k_paramet), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_gamma_max_parameter_to, __pyx_k_expected_gamma_max_parameter_to, sizeof(__pyx_k_expected_gamma_max_parameter_to), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_gamma_max_parameter_to_2, __pyx_k_expected_gamma_max_parameter_to_2, sizeof(__pyx_k_expected_gamma_max_parameter_to_2), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_highs_to_be_a_non_negat, __pyx_k_expected_highs_to_be_a_non_negat, sizeof(__pyx_k_expected_highs_to_be_a_non_negat), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_highs_to_be_a_non_negat_2, __pyx_k_expected_highs_to_be_a_non_negat_2, sizeof(__pyx_k_expected_highs_to_be_a_non_negat_2), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_intercept_parameter_to, __pyx_k_expected_intercept_parameter_to, sizeof(__pyx_k_expected_intercept_parameter_to), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_lambda_grid_to_be_a_lis, __pyx_k_expected_lambda_grid_to_be_a_lis, sizeof(__pyx_k_expected_lambda_grid_to_be_a_lis), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_lambda_grid_to_of_lengt, __pyx_k_expected_lambda_grid_to_of_lengt, sizeof(__pyx_k_expected_lambda_grid_to_of_lengt), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_loss_parameter_to_be_on, __pyx_k_expected_loss_parameter_to_be_on, sizeof(__pyx_k_expected_loss_parameter_to_be_on), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_lows_to_be_a_non_positi, __pyx_k_expected_lows_to_be_a_non_positi, sizeof(__pyx_k_expected_lows_to_be_a_non_positi), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_lows_to_be_a_non_positi_2, __pyx_k_expected_lows_to_be_a_non_positi_2, sizeof(__pyx_k_expected_lows_to_be_a_non_positi_2), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_max_iter_parameter_to_b, __pyx_k_expected_max_iter_parameter_to_b, sizeof(__pyx_k_expected_max_iter_parameter_to_b), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_max_support_size_parame, __pyx_k_expected_max_support_size_parame, sizeof(__pyx_k_expected_max_support_size_parame), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_max_swaps_parameter_to, __pyx_k_expected_max_swaps_parameter_to, sizeof(__pyx_k_expected_max_swaps_parameter_to), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_num_folds_parameter_to, __pyx_k_expected_num_folds_parameter_to, sizeof(__pyx_k_expected_num_folds_parameter_to), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_num_gamma_to_1_when_pen, __pyx_k_expected_num_gamma_to_1_when_pen, sizeof(__pyx_k_expected_num_gamma_to_1_when_pen), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_num_gamma_to_a_positive, __pyx_k_expected_num_gamma_to_a_positive, sizeof(__pyx_k_expected_num_gamma_to_a_positive), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_num_gamma_to_be_None_if, __pyx_k_expected_num_gamma_to_be_None_if, sizeof(__pyx_k_expected_num_gamma_to_be_None_if), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_num_lambda_to_a_positiv, __pyx_k_expected_num_lambda_to_a_positiv, sizeof(__pyx_k_expected_num_lambda_to_a_positiv), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_num_lambda_to_be_None_i, __pyx_k_expected_num_lambda_to_be_None_i, sizeof(__pyx_k_expected_num_lambda_to_be_None_i), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_partial_sort_parameter, __pyx_k_expected_partial_sort_parameter, sizeof(__pyx_k_expected_partial_sort_parameter), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_penalty_parameter_to_be, __pyx_k_expected_penalty_parameter_to_be, sizeof(__pyx_k_expected_penalty_parameter_to_be), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_rtol_parameter_to_exist, __pyx_k_expected_rtol_parameter_to_exist, sizeof(__pyx_k_expected_rtol_parameter_to_exist), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_scale_down_factor_param, __pyx_k_expected_scale_down_factor_param, sizeof(__pyx_k_expected_scale_down_factor_param), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_screen_size_parameter_t, __pyx_k_expected_screen_size_parameter_t, sizeof(__pyx_k_expected_screen_size_parameter_t), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_to_be_high_to_be_elemen, __pyx_k_expected_to_be_high_to_be_elemen, sizeof(__pyx_k_expected_to_be_high_to_be_elemen), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_y_to_be_a_1D_real_numpy, __pyx_k_expected_y_to_be_a_1D_real_numpy, sizeof(__pyx_k_expected_y_to_be_a_1D_real_numpy), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_y_vector_to_have_type, __pyx_k_expected_y_vector_to_have_type, sizeof(__pyx_k_expected_y_vector_to_have_type), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_y_vector_to_only_have_t, __pyx_k_expected_y_vector_to_only_have_t, sizeof(__pyx_k_expected_y_vector_to_only_have_t), 0, 1, 0, 0}, + {&__pyx_n_s_first_value, __pyx_k_first_value, sizeof(__pyx_k_first_value), 0, 0, 1, 1}, + {&__pyx_n_s_fit, __pyx_k_fit, sizeof(__pyx_k_fit), 0, 0, 1, 1}, + {&__pyx_n_s_fit_check, __pyx_k_fit_check, sizeof(__pyx_k_fit_check), 0, 0, 1, 1}, + {&__pyx_n_s_float64, __pyx_k_float64, sizeof(__pyx_k_float64), 0, 0, 1, 1}, + {&__pyx_n_s_gamma, __pyx_k_gamma, sizeof(__pyx_k_gamma), 0, 0, 1, 1}, + {&__pyx_n_s_gamma_max, __pyx_k_gamma_max, sizeof(__pyx_k_gamma_max), 0, 0, 1, 1}, + {&__pyx_n_u_gamma_max, __pyx_k_gamma_max, sizeof(__pyx_k_gamma_max), 0, 1, 0, 1}, + {&__pyx_n_s_gamma_min, __pyx_k_gamma_min, sizeof(__pyx_k_gamma_min), 0, 0, 1, 1}, + {&__pyx_n_u_gamma_min, __pyx_k_gamma_min, sizeof(__pyx_k_gamma_min), 0, 1, 0, 1}, + {&__pyx_n_s_highs, __pyx_k_highs, sizeof(__pyx_k_highs), 0, 0, 1, 1}, + {&__pyx_n_u_highs, __pyx_k_highs, sizeof(__pyx_k_highs), 0, 1, 0, 1}, + {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_u_inf, __pyx_k_inf, sizeof(__pyx_k_inf), 0, 1, 0, 1}, + {&__pyx_n_s_intercept, __pyx_k_intercept, sizeof(__pyx_k_intercept), 0, 0, 1, 1}, + {&__pyx_n_u_intercept, __pyx_k_intercept, sizeof(__pyx_k_intercept), 0, 1, 0, 1}, + {&__pyx_n_s_intercepts, __pyx_k_intercepts, sizeof(__pyx_k_intercepts), 0, 0, 1, 1}, + {&__pyx_n_s_isrealobj, __pyx_k_isrealobj, sizeof(__pyx_k_isrealobj), 0, 0, 1, 1}, + {&__pyx_n_s_l0learn, __pyx_k_l0learn, sizeof(__pyx_k_l0learn), 0, 0, 1, 1}, + {&__pyx_n_s_l0learn_interface, __pyx_k_l0learn_interface, sizeof(__pyx_k_l0learn_interface), 0, 0, 1, 1}, + {&__pyx_kp_s_l0learn_interface_pyx, __pyx_k_l0learn_interface_pyx, sizeof(__pyx_k_l0learn_interface_pyx), 0, 0, 1, 0}, + {&__pyx_n_s_l0learn_models, __pyx_k_l0learn_models, sizeof(__pyx_k_l0learn_models), 0, 0, 1, 1}, + {&__pyx_n_s_lambda_0, __pyx_k_lambda_0, sizeof(__pyx_k_lambda_0), 0, 0, 1, 1}, + {&__pyx_n_s_lambda_grid, __pyx_k_lambda_grid, sizeof(__pyx_k_lambda_grid), 0, 0, 1, 1}, + {&__pyx_n_u_lambda_grid, __pyx_k_lambda_grid, sizeof(__pyx_k_lambda_grid), 0, 1, 0, 1}, + {&__pyx_n_s_loss, __pyx_k_loss, sizeof(__pyx_k_loss), 0, 0, 1, 1}, + {&__pyx_n_u_loss, __pyx_k_loss, sizeof(__pyx_k_loss), 0, 1, 0, 1}, + {&__pyx_n_s_lows, __pyx_k_lows, sizeof(__pyx_k_lows), 0, 0, 1, 1}, + {&__pyx_n_u_lows, __pyx_k_lows, sizeof(__pyx_k_lows), 0, 1, 0, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_max_iter, __pyx_k_max_iter, sizeof(__pyx_k_max_iter), 0, 0, 1, 1}, + {&__pyx_n_s_max_support_size, __pyx_k_max_support_size, sizeof(__pyx_k_max_support_size), 0, 0, 1, 1}, + {&__pyx_n_u_max_support_size, __pyx_k_max_support_size, sizeof(__pyx_k_max_support_size), 0, 1, 0, 1}, + {&__pyx_n_s_max_swaps, __pyx_k_max_swaps, sizeof(__pyx_k_max_swaps), 0, 0, 1, 1}, + {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_n_s_ndarray, __pyx_k_ndarray, sizeof(__pyx_k_ndarray), 0, 0, 1, 1}, + {&__pyx_n_s_ndim, __pyx_k_ndim, sizeof(__pyx_k_ndim), 0, 0, 1, 1}, + {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, + {&__pyx_n_s_num_folds, __pyx_k_num_folds, sizeof(__pyx_k_num_folds), 0, 0, 1, 1}, + {&__pyx_n_s_num_gamma, __pyx_k_num_gamma, sizeof(__pyx_k_num_gamma), 0, 0, 1, 1}, + {&__pyx_n_u_num_gamma, __pyx_k_num_gamma, sizeof(__pyx_k_num_gamma), 0, 1, 0, 1}, + {&__pyx_kp_u_num_gamma_set_to_1_with, __pyx_k_num_gamma_set_to_1_with, sizeof(__pyx_k_num_gamma_set_to_1_with), 0, 1, 0, 0}, + {&__pyx_n_s_num_lambda, __pyx_k_num_lambda, sizeof(__pyx_k_num_lambda), 0, 0, 1, 1}, + {&__pyx_n_u_num_lambda, __pyx_k_num_lambda, sizeof(__pyx_k_num_lambda), 0, 1, 0, 1}, + {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, + {&__pyx_kp_u_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 1, 0, 0}, + {&__pyx_kp_u_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 1, 0, 0}, + {&__pyx_kp_u_of_non_negative_floats_but_got, __pyx_k_of_non_negative_floats_but_got, sizeof(__pyx_k_of_non_negative_floats_but_got), 0, 1, 0, 0}, + {&__pyx_kp_u_of_non_positives_floats_but_got, __pyx_k_of_non_positives_floats_but_got, sizeof(__pyx_k_of_non_positives_floats_but_got), 0, 1, 0, 0}, + {&__pyx_n_s_ones, __pyx_k_ones, sizeof(__pyx_k_ones), 0, 0, 1, 1}, + {&__pyx_kp_u_or_a, __pyx_k_or_a, sizeof(__pyx_k_or_a), 0, 1, 0, 0}, + {&__pyx_n_s_p, __pyx_k_p, sizeof(__pyx_k_p), 0, 0, 1, 1}, + {&__pyx_n_s_partial_sort, __pyx_k_partial_sort, sizeof(__pyx_k_partial_sort), 0, 0, 1, 1}, + {&__pyx_n_s_penalty, __pyx_k_penalty, sizeof(__pyx_k_penalty), 0, 0, 1, 1}, + {&__pyx_n_u_penalty, __pyx_k_penalty, sizeof(__pyx_k_penalty), 0, 1, 0, 1}, + {&__pyx_kp_u_penalty_Only_one, __pyx_k_penalty_Only_one, sizeof(__pyx_k_penalty_Only_one), 0, 1, 0, 0}, + {&__pyx_kp_u_penalty_value_will_be_fit, __pyx_k_penalty_value_will_be_fit, sizeof(__pyx_k_penalty_value_will_be_fit), 0, 1, 0, 0}, + {&__pyx_n_s_product, __pyx_k_product, sizeof(__pyx_k_product), 0, 0, 1, 1}, + {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, + {&__pyx_n_s_results, __pyx_k_results, sizeof(__pyx_k_results), 0, 0, 1, 1}, + {&__pyx_n_s_rtol, __pyx_k_rtol, sizeof(__pyx_k_rtol), 0, 0, 1, 1}, + {&__pyx_n_s_scale_down_factor, __pyx_k_scale_down_factor, sizeof(__pyx_k_scale_down_factor), 0, 0, 1, 1}, + {&__pyx_n_s_scipy_sparse, __pyx_k_scipy_sparse, sizeof(__pyx_k_scipy_sparse), 0, 0, 1, 1}, + {&__pyx_n_s_screen_size, __pyx_k_screen_size, sizeof(__pyx_k_screen_size), 0, 0, 1, 1}, + {&__pyx_n_u_screen_size, __pyx_k_screen_size, sizeof(__pyx_k_screen_size), 0, 1, 0, 1}, + {&__pyx_n_s_second_value, __pyx_k_second_value, sizeof(__pyx_k_second_value), 0, 0, 1, 1}, + {&__pyx_n_s_seed, __pyx_k_seed, sizeof(__pyx_k_seed), 0, 0, 1, 1}, + {&__pyx_n_s_settings, __pyx_k_settings, sizeof(__pyx_k_settings), 0, 0, 1, 1}, + {&__pyx_n_s_shape, __pyx_k_shape, sizeof(__pyx_k_shape), 0, 0, 1, 1}, + {&__pyx_n_s_sub_lambda_grid, __pyx_k_sub_lambda_grid, sizeof(__pyx_k_sub_lambda_grid), 0, 0, 1, 1}, + {&__pyx_n_s_support_size, __pyx_k_support_size, sizeof(__pyx_k_support_size), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_s_typing, __pyx_k_typing, sizeof(__pyx_k_typing), 0, 0, 1, 1}, + {&__pyx_n_s_unique, __pyx_k_unique, sizeof(__pyx_k_unique), 0, 0, 1, 1}, + {&__pyx_n_s_unique_items, __pyx_k_unique_items, sizeof(__pyx_k_unique_items), 0, 0, 1, 1}, + {&__pyx_n_s_warn, __pyx_k_warn, sizeof(__pyx_k_warn), 0, 0, 1, 1}, + {&__pyx_n_s_warnings, __pyx_k_warnings, sizeof(__pyx_k_warnings), 0, 0, 1, 1}, + {&__pyx_kp_u_where_that_is_not_the_case, __pyx_k_where_that_is_not_the_case, sizeof(__pyx_k_where_that_is_not_the_case), 0, 1, 0, 0}, + {&__pyx_n_s_with_bounds, __pyx_k_with_bounds, sizeof(__pyx_k_with_bounds), 0, 0, 1, 1}, + {&__pyx_n_u_with_bounds, __pyx_k_with_bounds, sizeof(__pyx_k_with_bounds), 0, 1, 0, 1}, + {&__pyx_n_s_y, __pyx_k_y, sizeof(__pyx_k_y), 0, 0, 1, 1}, + {&__pyx_n_u_y, __pyx_k_y, sizeof(__pyx_k_y), 0, 1, 0, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 79, __pyx_L1_error) + __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(0, 198, __pyx_L1_error) + __pyx_builtin_any = __Pyx_GetBuiltinName(__pyx_n_s_any); if (!__pyx_builtin_any) __PYX_ERR(0, 203, __pyx_L1_error) + __pyx_builtin_all = __Pyx_GetBuiltinName(__pyx_n_s_all); if (!__pyx_builtin_all) __PYX_ERR(0, 215, __pyx_L1_error) + __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 474, __pyx_L1_error) + __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 945, __pyx_L1_error) + __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(2, 61, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":945 + * __pyx_import_array() + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< * - * def np_to_arma_check(arr): + * cdef inline int import_umath() except -1: */ - __Pyx_TraceLine(14,0,__PYX_ERR(0, 14, __pyx_L1_error)) - __pyx_t_2 = PyList_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_n_s_FitModel); - __Pyx_GIVEREF(__pyx_n_s_FitModel); - PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_FitModel); - __Pyx_INCREF(__pyx_n_s_CVFitModel); - __Pyx_GIVEREF(__pyx_n_s_CVFitModel); - PyList_SET_ITEM(__pyx_t_2, 1, __pyx_n_s_CVFitModel); - __pyx_t_1 = __Pyx_Import(__pyx_n_s_l0learn_models, __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_FitModel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_FitModel, __pyx_t_2) < 0) __PYX_ERR(0, 14, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_CVFitModel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_CVFitModel, __pyx_t_2) < 0) __PYX_ERR(0, 14, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 945, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); - /* "l0learn/interface.pyx":16 - * from l0learn.models import FitModel, CVFitModel + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":951 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< * - * def np_to_arma_check(arr): # <<<<<<<<<<<<<< - * # TODO: Add checks for Behaved and OwnsData - * if isinstance(arr, np.ndarray): + * cdef inline int import_ufunc() except -1: */ - __Pyx_TraceLine(16,0,__PYX_ERR(0, 16, __pyx_L1_error)) - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_1np_to_arma_check, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 16, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_np_to_arma_check, __pyx_t_1) < 0) __PYX_ERR(0, 16, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_u_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 951, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__7); + __Pyx_GIVEREF(__pyx_tuple__7); /* "l0learn/interface.pyx":46 * @@ -13811,37 +11748,9 @@ if (!__Pyx_RefNanny) { * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") */ - __Pyx_TraceLine(46,0,__PYX_ERR(0, 46, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_d, __pyx_n_s_SUPPORTED_LOSS, __pyx_tuple__18) < 0) __PYX_ERR(0, 46, __pyx_L1_error) - - /* "l0learn/interface.pyx":47 - * - * SUPPORTED_LOSS = ("SquaredError", "Logistic", "SquaredHinge") - * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] # <<<<<<<<<<<<<< - * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") - * SUPPORTED_ALGORITHM = ("CD", "CDPSI") - */ - __Pyx_TraceLine(47,0,__PYX_ERR(0, 47, __pyx_L1_error)) - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 47, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 47, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 47, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 47, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 47, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3); - __pyx_t_2 = 0; - __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_CLASSIFICATION_LOSS, __pyx_t_1) < 0) __PYX_ERR(0, 47, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_tuple__8 = PyTuple_Pack(3, __pyx_n_u_SquaredError, __pyx_n_u_Logistic, __pyx_n_u_SquaredHinge); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); /* "l0learn/interface.pyx":48 * SUPPORTED_LOSS = ("SquaredError", "Logistic", "SquaredHinge") @@ -13850,8 +11759,9 @@ if (!__Pyx_RefNanny) { * SUPPORTED_ALGORITHM = ("CD", "CDPSI") * */ - __Pyx_TraceLine(48,0,__PYX_ERR(0, 48, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_d, __pyx_n_s_SUPPORTED_PENALTY, __pyx_tuple__19) < 0) __PYX_ERR(0, 48, __pyx_L1_error) + __pyx_tuple__9 = PyTuple_Pack(3, __pyx_n_u_L0, __pyx_n_u_L0L1, __pyx_n_u_L0L2); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(0, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__9); + __Pyx_GIVEREF(__pyx_tuple__9); /* "l0learn/interface.pyx":49 * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] @@ -13860,8 +11770,9 @@ if (!__Pyx_RefNanny) { * * */ - __Pyx_TraceLine(49,0,__PYX_ERR(0, 49, __pyx_L1_error)) - if (PyDict_SetItem(__pyx_d, __pyx_n_s_SUPPORTED_ALGORITHM, __pyx_tuple__20) < 0) __PYX_ERR(0, 49, __pyx_L1_error) + __pyx_tuple__10 = PyTuple_Pack(2, __pyx_n_u_CD, __pyx_n_u_CDPSI); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); /* "l0learn/interface.pyx":52 * @@ -13870,398 +11781,703 @@ if (!__Pyx_RefNanny) { * y: np.ndarray, * loss: str, */ - __Pyx_TraceLine(52,0,__PYX_ERR(0, 52, __pyx_L1_error)) - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_3_fit_check, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 52, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_fit_check, __pyx_t_1) < 0) __PYX_ERR(0, 52, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "l0learn/interface.pyx":269 - * exclude_first_k: int = 0, - * intercept: bool = True, - * lows: Union[np.ndarray, float] = -float('inf'), # <<<<<<<<<<<<<< - * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.FitModel: - * """ - */ - __Pyx_TraceLine(269,0,__PYX_ERR(0, 269, __pyx_L1_error)) - __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 269, __pyx_L1_error) - __pyx_t_1 = PyFloat_FromDouble((-__pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 269, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_k__9 = __pyx_t_1; - __Pyx_GIVEREF(__pyx_t_1); - __pyx_t_1 = 0; - - /* "l0learn/interface.pyx":270 - * intercept: bool = True, - * lows: Union[np.ndarray, float] = -float('inf'), - * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.FitModel: # <<<<<<<<<<<<<< - * """ - * Computes the regularization path for the specified loss function and penalty function. - */ - __Pyx_TraceLine(270,0,__PYX_ERR(0, 270, __pyx_L1_error)) - __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 270, __pyx_L1_error) - __pyx_t_1 = PyFloat_FromDouble(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 270, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_k__10 = __pyx_t_1; - __Pyx_GIVEREF(__pyx_t_1); - __pyx_t_1 = 0; + __pyx_tuple__12 = PyTuple_Pack(38, __pyx_n_s_X, __pyx_n_s_y, __pyx_n_s_loss, __pyx_n_s_penalty, __pyx_n_s_algorithm, __pyx_n_s_max_support_size, __pyx_n_s_num_lambda, __pyx_n_s_num_gamma, __pyx_n_s_gamma_max, __pyx_n_s_gamma_min, __pyx_n_s_partial_sort, __pyx_n_s_max_iter, __pyx_n_s_rtol, __pyx_n_s_atol, __pyx_n_s_active_set, __pyx_n_s_active_set_num, __pyx_n_s_max_swaps, __pyx_n_s_scale_down_factor, __pyx_n_s_screen_size, __pyx_n_s_lambda_grid, __pyx_n_s_exclude_first_k, __pyx_n_s_intercept, __pyx_n_s_lows, __pyx_n_s_highs, __pyx_n_s_n, __pyx_n_s_p, __pyx_n_s_unique_items, __pyx_n_s_a, __pyx_n_s__11, __pyx_n_s_first_value, __pyx_n_s_second_value, __pyx_n_s_auto_lambda, __pyx_n_s_bad_lambda_grid, __pyx_n_s_i, __pyx_n_s_sub_lambda_grid, __pyx_n_s_current, __pyx_n_s_with_bounds, __pyx_n_s_bad_bounds); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__12); + __Pyx_GIVEREF(__pyx_tuple__12); + __pyx_codeobj__13 = (PyObject*)__Pyx_PyCode_New(24, 0, 38, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_fit_check, 52, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__13)) __PYX_ERR(0, 52, __pyx_L1_error) - /* "l0learn/interface.pyx":247 + /* "l0learn/interface.pyx":261 * * * def fit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< * y: np.ndarray, * loss: str = "SquaredError", */ - __Pyx_TraceLine(247,0,__PYX_ERR(0, 247, __pyx_L1_error)) - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_5fit, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 247, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_fit, __pyx_t_1) < 0) __PYX_ERR(0, 247, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "l0learn/interface.pyx":557 - * exclude_first_k: int = 0, - * intercept: bool = True, - * lows: Union[np.ndarray, float] = -float('inf'), # <<<<<<<<<<<<<< - * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.CVFitModel: - * - */ - __Pyx_TraceLine(557,0,__PYX_ERR(0, 557, __pyx_L1_error)) - __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 557, __pyx_L1_error) - __pyx_t_1 = PyFloat_FromDouble((-__pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 557, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_k__12 = __pyx_t_1; - __Pyx_GIVEREF(__pyx_t_1); - __pyx_t_1 = 0; - - /* "l0learn/interface.pyx":558 - * intercept: bool = True, - * lows: Union[np.ndarray, float] = -float('inf'), - * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.CVFitModel: # <<<<<<<<<<<<<< - * - * check = _fit_check(X=X, - */ - __Pyx_TraceLine(558,0,__PYX_ERR(0, 558, __pyx_L1_error)) - __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 558, __pyx_L1_error) - __pyx_t_1 = PyFloat_FromDouble(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 558, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_k__13 = __pyx_t_1; - __Pyx_GIVEREF(__pyx_t_1); - __pyx_t_1 = 0; + __pyx_tuple__14 = PyTuple_Pack(33, __pyx_n_s_X, __pyx_n_s_y, __pyx_n_s_loss, __pyx_n_s_penalty, __pyx_n_s_algorithm, __pyx_n_s_max_support_size, __pyx_n_s_num_lambda, __pyx_n_s_num_gamma, __pyx_n_s_gamma_max, __pyx_n_s_gamma_min, __pyx_n_s_partial_sort, __pyx_n_s_max_iter, __pyx_n_s_rtol, __pyx_n_s_atol, __pyx_n_s_active_set, __pyx_n_s_active_set_num, __pyx_n_s_max_swaps, __pyx_n_s_scale_down_factor, __pyx_n_s_screen_size, __pyx_n_s_lambda_grid, __pyx_n_s_exclude_first_k, __pyx_n_s_intercept, __pyx_n_s_lows, __pyx_n_s_highs, __pyx_n_s_check, __pyx_n_s_auto_lambda, __pyx_n_s_with_bounds, __pyx_n_s_c_lambda_grid, __pyx_n_s_c_loss, __pyx_n_s_c_penalty, __pyx_n_s_c_algorithim, __pyx_n_s_c_results, __pyx_n_s_results); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(0, 261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__14); + __Pyx_GIVEREF(__pyx_tuple__14); + __pyx_codeobj__15 = (PyObject*)__Pyx_PyCode_New(24, 0, 33, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__14, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_fit, 261, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__15)) __PYX_ERR(0, 261, __pyx_L1_error) - /* "l0learn/interface.pyx":533 + /* "l0learn/interface.pyx":547 * * * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< * y: np.ndarray, * loss: str = "SquaredError", */ - __Pyx_TraceLine(533,0,__PYX_ERR(0, 533, __pyx_L1_error)) - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_7cvfit, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 533, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_cvfit, __pyx_t_1) < 0) __PYX_ERR(0, 533, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_tuple__16 = PyTuple_Pack(37, __pyx_n_s_X, __pyx_n_s_y, __pyx_n_s_loss, __pyx_n_s_penalty, __pyx_n_s_algorithm, __pyx_n_s_num_folds, __pyx_n_s_seed, __pyx_n_s_max_support_size, __pyx_n_s_num_lambda, __pyx_n_s_num_gamma, __pyx_n_s_gamma_max, __pyx_n_s_gamma_min, __pyx_n_s_partial_sort, __pyx_n_s_max_iter, __pyx_n_s_rtol, __pyx_n_s_atol, __pyx_n_s_active_set, __pyx_n_s_active_set_num, __pyx_n_s_max_swaps, __pyx_n_s_scale_down_factor, __pyx_n_s_screen_size, __pyx_n_s_lambda_grid, __pyx_n_s_exclude_first_k, __pyx_n_s_intercept, __pyx_n_s_lows, __pyx_n_s_highs, __pyx_n_s_check, __pyx_n_s_auto_lambda, __pyx_n_s_with_bounds, __pyx_n_s__11, __pyx_n_s_p, __pyx_n_s_c_lambda_grid, __pyx_n_s_c_loss, __pyx_n_s_c_penalty, __pyx_n_s_c_algorithim, __pyx_n_s_c_results, __pyx_n_s_results); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 547, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__16); + __Pyx_GIVEREF(__pyx_tuple__16); + __pyx_codeobj__17 = (PyObject*)__Pyx_PyCode_New(26, 0, 37, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_cvfit, 547, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__17)) __PYX_ERR(0, 547, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} - /* "l0learn/interface.pyx":687 - * - * - * cdef fitmodel _L0LearnFit_dense(const dmat& X, # <<<<<<<<<<<<<< - * const dvec& y, - * const string Loss, - */ - __Pyx_TraceLine(687,0,__PYX_ERR(0, 687, __pyx_L1_error)) +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + __pyx_float_0_ = PyFloat_FromDouble(0.); if (unlikely(!__pyx_float_0_)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_float_1_0 = PyFloat_FromDouble(1.0); if (unlikely(!__pyx_float_1_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_float_neg_1_0 = PyFloat_FromDouble(-1.0); if (unlikely(!__pyx_float_neg_1_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_10 = PyInt_FromLong(10); if (unlikely(!__pyx_int_10)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_100 = PyInt_FromLong(100); if (unlikely(!__pyx_int_100)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_200 = PyInt_FromLong(200); if (unlikely(!__pyx_int_200)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_1000 = PyInt_FromLong(1000); if (unlikely(!__pyx_int_1000)) __PYX_ERR(0, 1, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} +static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ - /* "l0learn/interface.pyx":718 - * - * - * cdef fitmodel _L0LearnFit_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< - * const dvec& y, - * const string Loss, - */ - __Pyx_TraceLine(718,0,__PYX_ERR(0, 718, __pyx_L1_error)) +static int __Pyx_modinit_global_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); + /*--- Global init code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} +static int __Pyx_modinit_variable_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); + /*--- Variable export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} - /* "l0learn/interface.pyx":749 - * - * - * cdef cvfitmodel _L0LearnCV_dense(const dmat& X, # <<<<<<<<<<<<<< - * const dvec& y, - * const string Loss, - */ - __Pyx_TraceLine(749,0,__PYX_ERR(0, 749, __pyx_L1_error)) +static int __Pyx_modinit_function_export_code(void) { + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); + /*--- Function export code ---*/ + if (__Pyx_ExportFunction("_L0LearnFit_dense", (void (*)(void))__pyx_f_7l0learn_9interface__L0LearnFit_dense, "fitmodel (arma::dmat const &, arma::dvec const &, std::string const , std::string const , std::string const , size_t const , size_t const , size_t const , double const , double const , bool const , size_t const , double const , double const , bool const , size_t const , size_t const , double const , size_t const , bool const , std::vector > const &, size_t const , bool const , bool const , arma::dvec const &, arma::dvec const &)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_L0LearnFit_sparse", (void (*)(void))__pyx_f_7l0learn_9interface__L0LearnFit_sparse, "fitmodel (arma::sp_dmat const &, arma::dvec const &, std::string const , std::string const , std::string const , size_t const , size_t const , size_t const , double const , double const , bool const , size_t const , double const , double const , bool const , size_t const , size_t const , double const , size_t const , bool const , std::vector > const &, size_t const , bool const , bool const , arma::dvec const &, arma::dvec const &)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_L0LearnCV_dense", (void (*)(void))__pyx_f_7l0learn_9interface__L0LearnCV_dense, "cvfitmodel (arma::dmat const &, arma::dvec const &, std::string const , std::string const , std::string const , size_t const , size_t const , size_t const , double const , double const , bool const , size_t const , double const , double const , bool const , size_t const , size_t const , double const , size_t const , bool const , std::vector > const &, unsigned int const , double const , size_t const , bool const , bool const , arma::dvec const &, arma::dvec const &)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("_L0LearnCV_sparse", (void (*)(void))__pyx_f_7l0learn_9interface__L0LearnCV_sparse, "cvfitmodel (arma::sp_dmat const &, arma::dvec const &, std::string const , std::string const , std::string const , size_t const , size_t const , size_t const , double const , double const , bool const , size_t const , double const , double const , bool const , size_t const , size_t const , double const , size_t const , bool const , std::vector > const &, unsigned int const , double const , size_t const , bool const , bool const , arma::dvec const &, arma::dvec const &)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} +static int __Pyx_modinit_type_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); + /*--- Type init code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} - /* "l0learn/interface.pyx":782 - * - * - * cdef cvfitmodel _L0LearnCV_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< - * const dvec& y, - * const string Loss, - */ - __Pyx_TraceLine(782,0,__PYX_ERR(0, 782, __pyx_L1_error)) +static int __Pyx_modinit_type_import_code(void) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); + /*--- Type import code ---*/ + __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyTypeObject), + #else + sizeof(PyHeapTypeObject), + #endif + __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(3, 9, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 200, __pyx_L1_error) + __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 223, __pyx_L1_error) + __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 227, __pyx_L1_error) + __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 239, __pyx_L1_error) + __pyx_ptype_5numpy_generic = __Pyx_ImportType(__pyx_t_1, "numpy", "generic", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_generic) __PYX_ERR(1, 771, __pyx_L1_error) + __pyx_ptype_5numpy_number = __Pyx_ImportType(__pyx_t_1, "numpy", "number", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_number) __PYX_ERR(1, 773, __pyx_L1_error) + __pyx_ptype_5numpy_integer = __Pyx_ImportType(__pyx_t_1, "numpy", "integer", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_integer) __PYX_ERR(1, 775, __pyx_L1_error) + __pyx_ptype_5numpy_signedinteger = __Pyx_ImportType(__pyx_t_1, "numpy", "signedinteger", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_signedinteger) __PYX_ERR(1, 777, __pyx_L1_error) + __pyx_ptype_5numpy_unsignedinteger = __Pyx_ImportType(__pyx_t_1, "numpy", "unsignedinteger", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_unsignedinteger) __PYX_ERR(1, 779, __pyx_L1_error) + __pyx_ptype_5numpy_inexact = __Pyx_ImportType(__pyx_t_1, "numpy", "inexact", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_inexact) __PYX_ERR(1, 781, __pyx_L1_error) + __pyx_ptype_5numpy_floating = __Pyx_ImportType(__pyx_t_1, "numpy", "floating", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_floating) __PYX_ERR(1, 783, __pyx_L1_error) + __pyx_ptype_5numpy_complexfloating = __Pyx_ImportType(__pyx_t_1, "numpy", "complexfloating", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_complexfloating) __PYX_ERR(1, 785, __pyx_L1_error) + __pyx_ptype_5numpy_flexible = __Pyx_ImportType(__pyx_t_1, "numpy", "flexible", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_flexible) __PYX_ERR(1, 787, __pyx_L1_error) + __pyx_ptype_5numpy_character = __Pyx_ImportType(__pyx_t_1, "numpy", "character", sizeof(PyObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_character) __PYX_ERR(1, 789, __pyx_L1_error) + __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 827, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_RefNannyFinishContext(); + return -1; +} +static int __Pyx_modinit_variable_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); + /*--- Variable import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} - /* "l0learn/interface.pyx":1 - * from libcpp.vector cimport vector # <<<<<<<<<<<<<< - * from libcpp.string cimport string - * from libcpp cimport bool as cppbool - */ - __Pyx_TraceLine(1,0,__PYX_ERR(0, 1, __pyx_L1_error)) - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) +static int __Pyx_modinit_function_import_code(void) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); + /*--- Function import code ---*/ + __pyx_t_1 = PyImport_ImportModule("l0learn.cyarma"); if (!__pyx_t_1) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ImportFunction(__pyx_t_1, "numpy_to_dmat_d", (void (**)(void))&__pyx_f_7l0learn_6cyarma_numpy_to_dmat_d, "arma::dmat (PyArrayObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ImportFunction(__pyx_t_1, "numpy_to_dvec_d", (void (**)(void))&__pyx_f_7l0learn_6cyarma_numpy_to_dvec_d, "arma::dvec (PyArrayObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ImportFunction(__pyx_t_1, "numpy_to_sp_dmat_d", (void (**)(void))&__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d, "arma::sp_dmat (PyObject *)") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ImportFunction(__pyx_t_1, "sp_dmat_field_to_list", (void (**)(void))&__pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list, "PyObject *(arma::field )") < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_ImportFunction(__pyx_t_1, "dvec_field_to_list", (void (**)(void))&__pyx_f_7l0learn_6cyarma_dvec_field_to_list, "PyObject *(arma::field )") < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_RefNannyFinishContext(); + return -1; +} - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":735 - * ctypedef npy_cdouble complex_t - * - * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(1, a) - * - */ - __Pyx_TraceLine(735,0,__PYX_ERR(1, 735, __pyx_L1_error)) - - - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":738 - * return PyArray_MultiIterNew(1, a) - * - * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(2, a, b) - * - */ - __Pyx_TraceLine(738,0,__PYX_ERR(1, 738, __pyx_L1_error)) - - - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":741 - * return PyArray_MultiIterNew(2, a, b) - * - * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(3, a, b, c) - * - */ - __Pyx_TraceLine(741,0,__PYX_ERR(1, 741, __pyx_L1_error)) - - - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":744 - * return PyArray_MultiIterNew(3, a, b, c) - * - * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(4, a, b, c, d) - * - */ - __Pyx_TraceLine(744,0,__PYX_ERR(1, 744, __pyx_L1_error)) - - - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":747 - * return PyArray_MultiIterNew(4, a, b, c, d) - * - * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(5, a, b, c, d, e) - * - */ - __Pyx_TraceLine(747,0,__PYX_ERR(1, 747, __pyx_L1_error)) - - - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":750 - * return PyArray_MultiIterNew(5, a, b, c, d, e) - * - * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< - * if PyDataType_HASSUBARRAY(d): - * return d.subarray.shape - */ - __Pyx_TraceLine(750,0,__PYX_ERR(1, 750, __pyx_L1_error)) +#ifndef CYTHON_NO_PYINIT_EXPORT +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#elif PY_MAJOR_VERSION < 3 +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" void +#else +#define __Pyx_PyMODINIT_FUNC void +#endif +#else +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * +#else +#define __Pyx_PyMODINIT_FUNC PyObject * +#endif +#endif - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":929 - * int _import_umath() except -1 - * - * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< - * Py_INCREF(base) # important to do this before stealing the reference below! - * PyArray_SetBaseObject(arr, base) - */ - __Pyx_TraceLine(929,0,__PYX_ERR(1, 929, __pyx_L1_error)) +#if PY_MAJOR_VERSION < 3 +__Pyx_PyMODINIT_FUNC initinterface(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC initinterface(void) +#else +__Pyx_PyMODINIT_FUNC PyInit_interface(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_interface(void) +#if CYTHON_PEP489_MULTI_PHASE_INIT +{ + return PyModuleDef_Init(&__pyx_moduledef); +} +static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { + #if PY_VERSION_HEX >= 0x030700A1 + static PY_INT64_T main_interpreter_id = -1; + PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); + if (main_interpreter_id == -1) { + main_interpreter_id = current_id; + return (unlikely(current_id == -1)) ? -1 : 0; + } else if (unlikely(main_interpreter_id != current_id)) + #else + static PyInterpreterState *main_interpreter = NULL; + PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; + if (!main_interpreter) { + main_interpreter = current_interpreter; + } else if (unlikely(main_interpreter != current_interpreter)) + #endif + { + PyErr_SetString( + PyExc_ImportError, + "Interpreter change detected - this module can only be loaded into one interpreter per process."); + return -1; + } + return 0; +} +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { + PyObject *value = PyObject_GetAttrString(spec, from_name); + int result = 0; + if (likely(value)) { + if (allow_none || value != Py_None) { + result = PyDict_SetItemString(moddict, to_name, value); + } + Py_DECREF(value); + } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + } else { + result = -1; + } + return result; +} +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { + PyObject *module = NULL, *moddict, *modname; + if (__Pyx_check_single_interpreter()) + return NULL; + if (__pyx_m) + return __Pyx_NewRef(__pyx_m); + modname = PyObject_GetAttrString(spec, "name"); + if (unlikely(!modname)) goto bad; + module = PyModule_NewObject(modname); + Py_DECREF(modname); + if (unlikely(!module)) goto bad; + moddict = PyModule_GetDict(module); + if (unlikely(!moddict)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; + return module; +bad: + Py_XDECREF(module); + return NULL; +} - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":933 - * PyArray_SetBaseObject(arr, base) - * - * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< - * base = PyArray_BASE(arr) - * if base is NULL: - */ - __Pyx_TraceLine(933,0,__PYX_ERR(1, 933, __pyx_L1_error)) +static CYTHON_SMALL_CODE int __pyx_pymod_exec_interface(PyObject *__pyx_pyinit_module) +#endif +#endif +{ + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + double __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + #if CYTHON_PEP489_MULTI_PHASE_INIT + if (__pyx_m) { + if (__pyx_m == __pyx_pyinit_module) return 0; + PyErr_SetString(PyExc_RuntimeError, "Module 'interface' has already been imported. Re-initialisation is not supported."); + return -1; + } + #elif PY_MAJOR_VERSION >= 3 + if (__pyx_m) return __Pyx_NewRef(__pyx_m); + #endif + #if CYTHON_REFNANNY +__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); +if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); +} +#endif + __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_interface(void)", 0); + if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pxy_PyFrame_Initialize_Offsets + __Pxy_PyFrame_Initialize_Offsets(); + #endif + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + PyEval_InitThreads(); + #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_m = __pyx_pyinit_module; + Py_INCREF(__pyx_m); + #else + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("interface", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_b); + __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_cython_runtime); + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + if (__pyx_module_is_main_l0learn__interface) { + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "l0learn.interface")) { + if (unlikely(PyDict_SetItemString(modules, "l0learn.interface", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Global type/function init code ---*/ + (void)__Pyx_modinit_global_init_code(); + (void)__Pyx_modinit_variable_export_code(); + if (unlikely(__Pyx_modinit_function_export_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + (void)__Pyx_modinit_type_init_code(); + if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + (void)__Pyx_modinit_variable_import_code(); + if (unlikely(__Pyx_modinit_function_import_code() < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":941 - * # Versions of the import_* functions which are more suitable for - * # Cython code. - * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< - * try: - * __pyx_import_array() + /* "l0learn/interface.pyx":4 + * from libcpp.string cimport string + * from libcpp cimport bool as cppbool + * import numpy as np # <<<<<<<<<<<<<< + * from scipy.sparse import csc_matrix + * from warnings import warn */ - __Pyx_TraceLine(941,0,__PYX_ERR(1, 941, __pyx_L1_error)) - + __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":947 - * raise ImportError("numpy.core.multiarray failed to import") + /* "l0learn/interface.pyx":5 + * from libcpp cimport bool as cppbool + * import numpy as np + * from scipy.sparse import csc_matrix # <<<<<<<<<<<<<< + * from warnings import warn * - * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() */ - __Pyx_TraceLine(947,0,__PYX_ERR(1, 947, __pyx_L1_error)) - + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_csc_matrix); + __Pyx_GIVEREF(__pyx_n_s_csc_matrix); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_csc_matrix); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_scipy_sparse, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_csc_matrix, __pyx_t_1) < 0) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":953 - * raise ImportError("numpy.core.umath failed to import") + /* "l0learn/interface.pyx":6 + * import numpy as np + * from scipy.sparse import csc_matrix + * from warnings import warn # <<<<<<<<<<<<<< * - * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() + * from typing import Union, Optional, List, Dict, Any */ - __Pyx_TraceLine(953,0,__PYX_ERR(1, 953, __pyx_L1_error)) - + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_warn); + __Pyx_GIVEREF(__pyx_n_s_warn); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_warn); + __pyx_t_1 = __Pyx_Import(__pyx_n_s_warnings, __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_warn); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_warn, __pyx_t_2) < 0) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":967 + /* "l0learn/interface.pyx":8 + * from warnings import warn * + * from typing import Union, Optional, List, Dict, Any # <<<<<<<<<<<<<< * - * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< - * """ - * Cython equivalent of `isinstance(obj, np.timedelta64)` + * from l0learn.cyarma cimport dmat, sp_dmat, numpy_to_sp_dmat_d, numpy_to_dmat_d, dvec, numpy_to_dvec_d, \ */ - __Pyx_TraceLine(967,0,__PYX_ERR(1, 967, __pyx_L1_error)) - + __pyx_t_1 = PyList_New(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_Union); + __Pyx_GIVEREF(__pyx_n_s_Union); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_Union); + __Pyx_INCREF(__pyx_n_s_Optional); + __Pyx_GIVEREF(__pyx_n_s_Optional); + PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_Optional); + __Pyx_INCREF(__pyx_n_s_List); + __Pyx_GIVEREF(__pyx_n_s_List); + PyList_SET_ITEM(__pyx_t_1, 2, __pyx_n_s_List); + __Pyx_INCREF(__pyx_n_s_Dict); + __Pyx_GIVEREF(__pyx_n_s_Dict); + PyList_SET_ITEM(__pyx_t_1, 3, __pyx_n_s_Dict); + __Pyx_INCREF(__pyx_n_s_Any); + __Pyx_GIVEREF(__pyx_n_s_Any); + PyList_SET_ITEM(__pyx_t_1, 4, __pyx_n_s_Any); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_typing, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Union); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Union, __pyx_t_1) < 0) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Optional); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Optional, __pyx_t_1) < 0) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_List); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_List, __pyx_t_1) < 0) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Dict); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Dict, __pyx_t_1) < 0) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Any); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Any, __pyx_t_1) < 0) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":982 + /* "l0learn/interface.pyx":13 + * sp_dmat_field_to_list, dvec_field_to_list * + * import l0learn.models # <<<<<<<<<<<<<< + * from l0learn.models import FitModel, CVFitModel * - * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< - * """ - * Cython equivalent of `isinstance(obj, np.datetime64)` */ - __Pyx_TraceLine(982,0,__PYX_ERR(1, 982, __pyx_L1_error)) - + __pyx_t_2 = __Pyx_Import(__pyx_n_s_l0learn_models, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_l0learn, __pyx_t_2) < 0) __PYX_ERR(0, 13, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":997 + /* "l0learn/interface.pyx":14 * + * import l0learn.models + * from l0learn.models import FitModel, CVFitModel # <<<<<<<<<<<<<< * - * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< - * """ - * returns the int64 value underlying scalar numpy datetime64 object + * # def np_to_arma_check(arr): */ - __Pyx_TraceLine(997,0,__PYX_ERR(1, 997, __pyx_L1_error)) - + __pyx_t_2 = PyList_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_FitModel); + __Pyx_GIVEREF(__pyx_n_s_FitModel); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_FitModel); + __Pyx_INCREF(__pyx_n_s_CVFitModel); + __Pyx_GIVEREF(__pyx_n_s_CVFitModel); + PyList_SET_ITEM(__pyx_t_2, 1, __pyx_n_s_CVFitModel); + __pyx_t_1 = __Pyx_Import(__pyx_n_s_l0learn_models, __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_FitModel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_FitModel, __pyx_t_2) < 0) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_CVFitModel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_CVFitModel, __pyx_t_2) < 0) __PYX_ERR(0, 14, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1007 + /* "l0learn/interface.pyx":46 * * - * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< - * """ - * returns the int64 value underlying scalar numpy timedelta64 object + * SUPPORTED_LOSS = ("SquaredError", "Logistic", "SquaredHinge") # <<<<<<<<<<<<<< + * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] + * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") */ - __Pyx_TraceLine(1007,0,__PYX_ERR(1, 1007, __pyx_L1_error)) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SUPPORTED_LOSS, __pyx_tuple__8) < 0) __PYX_ERR(0, 46, __pyx_L1_error) - - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1014 - * + /* "l0learn/interface.pyx":47 * - * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< - * """ - * returns the unit part of the dtype for a numpy datetime64 object. + * SUPPORTED_LOSS = ("SquaredError", "Logistic", "SquaredHinge") + * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] # <<<<<<<<<<<<<< + * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") + * SUPPORTED_ALGORITHM = ("CD", "CDPSI") */ - __Pyx_TraceLine(1014,0,__PYX_ERR(1, 1014, __pyx_L1_error)) - + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_SUPPORTED_LOSS); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3); + __pyx_t_2 = 0; + __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_CLASSIFICATION_LOSS, __pyx_t_1) < 0) __PYX_ERR(0, 47, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "vector.from_py":45 + /* "l0learn/interface.pyx":48 + * SUPPORTED_LOSS = ("SquaredError", "Logistic", "SquaredHinge") + * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] + * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") # <<<<<<<<<<<<<< + * SUPPORTED_ALGORITHM = ("CD", "CDPSI") * - * @cname("__pyx_convert_vector_from_py_double") - * cdef vector[X] __pyx_convert_vector_from_py_double(object o) except *: # <<<<<<<<<<<<<< - * cdef vector[X] v - * for item in o: */ - __Pyx_TraceLine(45,0,__PYX_ERR(2, 45, __pyx_L1_error)) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SUPPORTED_PENALTY, __pyx_tuple__9) < 0) __PYX_ERR(0, 48, __pyx_L1_error) - - /* "vector.from_py":40 - * + /* "l0learn/interface.pyx":49 + * CLASSIFICATION_LOSS = SUPPORTED_LOSS[1], SUPPORTED_LOSS[2] + * SUPPORTED_PENALTY = ("L0", "L0L1", "L0L2") + * SUPPORTED_ALGORITHM = ("CD", "CDPSI") # <<<<<<<<<<<<<< * - * cdef extern from *: # <<<<<<<<<<<<<< - * cdef cppclass vector "std::vector" [T]: - * void push_back(T&) - */ - __Pyx_TraceLine(40,0,__PYX_ERR(2, 40, __pyx_L1_error)) - - - /* "string.from_py":13 * - * @cname("__pyx_convert_string_from_py_std__in_string") - * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: # <<<<<<<<<<<<<< - * cdef Py_ssize_t length = 0 - * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) */ - __Pyx_TraceLine(13,0,__PYX_ERR(2, 13, __pyx_L1_error)) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SUPPORTED_ALGORITHM, __pyx_tuple__10) < 0) __PYX_ERR(0, 49, __pyx_L1_error) - - /* "vector.to_py":60 + /* "l0learn/interface.pyx":52 * - * @cname("__pyx_convert_vector_to_py_double") - * cdef object __pyx_convert_vector_to_py_double(vector[X]& v): # <<<<<<<<<<<<<< - * return [v[i] for i in range(v.size())] * + * def _fit_check(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< + * y: np.ndarray, + * loss: str, */ - __Pyx_TraceLine(60,0,__PYX_ERR(2, 60, __pyx_L1_error)) - + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_1_fit_check, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_fit_check, __pyx_t_1) < 0) __PYX_ERR(0, 52, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "vector.to_py":54 - * - * - * cdef extern from *: # <<<<<<<<<<<<<< - * cdef cppclass vector "const std::vector" [T]: - * size_t size() + /* "l0learn/interface.pyx":283 + * exclude_first_k: int = 0, + * intercept: bool = True, + * lows: Union[np.ndarray, float] = -float('inf'), # <<<<<<<<<<<<<< + * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.FitModel: + * """ */ - __Pyx_TraceLine(54,0,__PYX_ERR(2, 54, __pyx_L1_error)) + __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 283, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble((-__pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 283, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_k__2 = __pyx_t_1; + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + /* "l0learn/interface.pyx":284 + * intercept: bool = True, + * lows: Union[np.ndarray, float] = -float('inf'), + * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.FitModel: # <<<<<<<<<<<<<< + * """ + * Computes the regularization path for the specified loss function and penalty function. + */ + __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 284, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_k__3 = __pyx_t_1; + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; - /* "vector.to_py":60 + /* "l0learn/interface.pyx":261 * - * @cname("__pyx_convert_vector_to_py_size_t") - * cdef object __pyx_convert_vector_to_py_size_t(vector[X]& v): # <<<<<<<<<<<<<< - * return [v[i] for i in range(v.size())] * + * def fit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< + * y: np.ndarray, + * loss: str = "SquaredError", */ - __Pyx_TraceLine(60,0,__PYX_ERR(2, 60, __pyx_L1_error)) - + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_3fit, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_fit, __pyx_t_1) < 0) __PYX_ERR(0, 261, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "vector.to_py":54 - * + /* "l0learn/interface.pyx":571 + * exclude_first_k: int = 0, + * intercept: bool = True, + * lows: Union[np.ndarray, float] = -float('inf'), # <<<<<<<<<<<<<< + * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.CVFitModel: * - * cdef extern from *: # <<<<<<<<<<<<<< - * cdef cppclass vector "const std::vector" [T]: - * size_t size() */ - __Pyx_TraceLine(54,0,__PYX_ERR(2, 54, __pyx_L1_error)) - + __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 571, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble((-__pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 571, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_k__4 = __pyx_t_1; + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; - /* "vector.to_py":60 - * - * @cname("__pyx_convert_vector_to_py_bool") - * cdef object __pyx_convert_vector_to_py_bool(vector[X]& v): # <<<<<<<<<<<<<< - * return [v[i] for i in range(v.size())] + /* "l0learn/interface.pyx":572 + * intercept: bool = True, + * lows: Union[np.ndarray, float] = -float('inf'), + * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.CVFitModel: # <<<<<<<<<<<<<< * + * check = _fit_check(X=X, */ - __Pyx_TraceLine(60,0,__PYX_ERR(2, 60, __pyx_L1_error)) - + __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 572, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_k__5 = __pyx_t_1; + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; - /* "vector.to_py":54 + /* "l0learn/interface.pyx":547 * * - * cdef extern from *: # <<<<<<<<<<<<<< - * cdef cppclass vector "const std::vector" [T]: - * size_t size() + * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< + * y: np.ndarray, + * loss: str = "SquaredError", */ - __Pyx_TraceLine(54,0,__PYX_ERR(2, 54, __pyx_L1_error)) + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_5cvfit, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 547, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_cvfit, __pyx_t_1) < 0) __PYX_ERR(0, 547, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /* "l0learn/interface.pyx":1 + * from libcpp.vector cimport vector # <<<<<<<<<<<<<< + * from libcpp.string cimport string + * from libcpp cimport bool as cppbool + */ + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "vector.to_py":60 * @@ -14270,7 +12486,6 @@ if (!__Pyx_RefNanny) { * return [v[i] for i in range(v.size())] * */ - __Pyx_TraceReturn(Py_None, 0); /*--- Wrapped vars code ---*/ @@ -14335,395 +12550,239 @@ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); if (unlikely(!result)) { PyErr_Format(PyExc_NameError, -#if PY_MAJOR_VERSION >= 3 - "name '%U' is not defined", name); -#else - "name '%.200s' is not defined", PyString_AS_STRING(name)); -#endif - } - return result; -} - -/* PyErrFetchRestore */ -#if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { - PyObject *tmp_type, *tmp_value, *tmp_tb; - tmp_type = tstate->curexc_type; - tmp_value = tstate->curexc_value; - tmp_tb = tstate->curexc_traceback; - tstate->curexc_type = type; - tstate->curexc_value = value; - tstate->curexc_traceback = tb; - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); -} -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { - *type = tstate->curexc_type; - *value = tstate->curexc_value; - *tb = tstate->curexc_traceback; - tstate->curexc_type = 0; - tstate->curexc_value = 0; - tstate->curexc_traceback = 0; -} -#endif - -/* Profile */ -#if CYTHON_PROFILE -static int __Pyx_TraceSetupAndCall(PyCodeObject** code, - PyFrameObject** frame, - PyThreadState* tstate, - const char *funcname, - const char *srcfile, - int firstlineno) { - PyObject *type, *value, *traceback; - int retval; - if (*frame == NULL || !CYTHON_PROFILE_REUSE_FRAME) { - if (*code == NULL) { - *code = __Pyx_createFrameCodeObject(funcname, srcfile, firstlineno); - if (*code == NULL) return 0; - } - *frame = PyFrame_New( - tstate, /*PyThreadState *tstate*/ - *code, /*PyCodeObject *code*/ - __pyx_d, /*PyObject *globals*/ - 0 /*PyObject *locals*/ - ); - if (*frame == NULL) return 0; - if (CYTHON_TRACE && (*frame)->f_trace == NULL) { - Py_INCREF(Py_None); - (*frame)->f_trace = Py_None; - } -#if PY_VERSION_HEX < 0x030400B1 - } else { - (*frame)->f_tstate = tstate; -#endif - } - __Pyx_PyFrame_SetLineNumber(*frame, firstlineno); - retval = 1; - tstate->tracing++; - __Pyx_SetTracing(tstate, 0); - __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); - #if CYTHON_TRACE - if (tstate->c_tracefunc) - retval = tstate->c_tracefunc(tstate->c_traceobj, *frame, PyTrace_CALL, NULL) == 0; - if (retval && tstate->c_profilefunc) - #endif - retval = tstate->c_profilefunc(tstate->c_profileobj, *frame, PyTrace_CALL, NULL) == 0; - __Pyx_SetTracing(tstate, (tstate->c_profilefunc || (CYTHON_TRACE && tstate->c_tracefunc))); - tstate->tracing--; - if (retval) { - __Pyx_ErrRestoreInState(tstate, type, value, traceback); - return __Pyx_IsTracing(tstate, 0, 0) && retval; - } else { - Py_XDECREF(type); - Py_XDECREF(value); - Py_XDECREF(traceback); - return -1; - } -} -static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno) { - PyCodeObject *py_code = 0; -#if PY_MAJOR_VERSION >= 3 - py_code = PyCode_NewEmpty(srcfile, funcname, firstlineno); - if (likely(py_code)) { - py_code->co_flags |= CO_OPTIMIZED | CO_NEWLOCALS; - } -#else - PyObject *py_srcfile = 0; - PyObject *py_funcname = 0; - py_funcname = PyString_FromString(funcname); - if (unlikely(!py_funcname)) goto bad; - py_srcfile = PyString_FromString(srcfile); - if (unlikely(!py_srcfile)) goto bad; - py_code = PyCode_New( - 0, - 0, - 0, - CO_OPTIMIZED | CO_NEWLOCALS, - __pyx_empty_bytes, /*PyObject *code,*/ - __pyx_empty_tuple, /*PyObject *consts,*/ - __pyx_empty_tuple, /*PyObject *names,*/ - __pyx_empty_tuple, /*PyObject *varnames,*/ - __pyx_empty_tuple, /*PyObject *freevars,*/ - __pyx_empty_tuple, /*PyObject *cellvars,*/ - py_srcfile, /*PyObject *filename,*/ - py_funcname, /*PyObject *name,*/ - firstlineno, - __pyx_empty_bytes /*PyObject *lnotab*/ - ); -bad: - Py_XDECREF(py_srcfile); - Py_XDECREF(py_funcname); -#endif - return py_code; -} -#endif - -/* PyDictVersioning */ -#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { - PyObject *dict = Py_TYPE(obj)->tp_dict; - return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; -} -static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { - PyObject **dictptr = NULL; - Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; - if (offset) { -#if CYTHON_COMPILING_IN_CPYTHON - dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); -#else - dictptr = _PyObject_GetDictPtr(obj); -#endif - } - return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; -} -static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { - PyObject *dict = Py_TYPE(obj)->tp_dict; - if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) - return 0; - return obj_dict_version == __Pyx_get_object_dict_version(obj); -} -#endif - -/* GetModuleGlobalName */ -#if CYTHON_USE_DICT_VERSIONS -static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) -#else -static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) -#endif -{ - PyObject *result; -#if !CYTHON_AVOID_BORROWED_REFS -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 - result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } else if (unlikely(PyErr_Occurred())) { - return NULL; - } -#else - result = PyDict_GetItem(__pyx_d, name); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } -#endif -#else - result = PyObject_GetItem(__pyx_d, name); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } - PyErr_Clear(); -#endif - return __Pyx_GetBuiltinName(name); -} - -/* DictGetItem */ -#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY -static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { - PyObject *value; - value = PyDict_GetItemWithError(d, key); - if (unlikely(!value)) { - if (!PyErr_Occurred()) { - if (unlikely(PyTuple_Check(key))) { - PyObject* args = PyTuple_Pack(1, key); - if (likely(args)) { - PyErr_SetObject(PyExc_KeyError, args); - Py_DECREF(args); - } - } else { - PyErr_SetObject(PyExc_KeyError, key); - } - } - return NULL; - } - Py_INCREF(value); - return value; -} +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); #endif - -/* PyObjectCall */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { - PyObject *result; - ternaryfunc call = Py_TYPE(func)->tp_call; - if (unlikely(!call)) - return PyObject_Call(func, arg, kw); - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) - return NULL; - result = (*call)(func, arg, kw); - Py_LeaveRecursiveCall(); - if (unlikely(!result) && unlikely(!PyErr_Occurred())) { - PyErr_SetString( - PyExc_SystemError, - "NULL result without error in PyObject_Call"); } return result; } -#endif -/* RaiseException */ -#if PY_MAJOR_VERSION < 3 -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, - CYTHON_UNUSED PyObject *cause) { - __Pyx_PyThreadState_declare - Py_XINCREF(type); - if (!value || value == Py_None) - value = NULL; - else - Py_INCREF(value); - if (!tb || tb == Py_None) - tb = NULL; - else { - Py_INCREF(tb); - if (!PyTraceBack_Check(tb)) { - PyErr_SetString(PyExc_TypeError, - "raise: arg 3 must be a traceback or None"); - goto raise_error; - } - } - if (PyType_Check(type)) { -#if CYTHON_COMPILING_IN_PYPY - if (!value) { - Py_INCREF(Py_None); - value = Py_None; - } -#endif - PyErr_NormalizeException(&type, &value, &tb); +/* RaiseArgTupleInvalid */ +static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; } else { - if (value) { - PyErr_SetString(PyExc_TypeError, - "instance exception may not have a separate value"); - goto raise_error; - } - value = type; - type = (PyObject*) Py_TYPE(type); - Py_INCREF(type); - if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { - PyErr_SetString(PyExc_TypeError, - "raise: exception class must be a subclass of BaseException"); - goto raise_error; - } + num_expected = num_max; + more_or_less = "at most"; } - __Pyx_PyThreadState_assign - __Pyx_ErrRestore(type, value, tb); - return; -raise_error: - Py_XDECREF(value); - Py_XDECREF(type); - Py_XDECREF(tb); - return; -} -#else -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { - PyObject* owned_instance = NULL; - if (tb == Py_None) { - tb = 0; - } else if (tb && !PyTraceBack_Check(tb)) { - PyErr_SetString(PyExc_TypeError, - "raise: arg 3 must be a traceback or None"); - goto bad; + if (exact) { + more_or_less = "exactly"; } - if (value == Py_None) - value = 0; - if (PyExceptionInstance_Check(type)) { - if (value) { - PyErr_SetString(PyExc_TypeError, - "instance exception may not have a separate value"); - goto bad; + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +/* RaiseDoubleKeywords */ +static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION >= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +/* ParseKeywords */ +static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + while (PyDict_Next(kwds, &pos, &key, &value)) { + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; + continue; } - value = type; - type = (PyObject*) Py_TYPE(value); - } else if (PyExceptionClass_Check(type)) { - PyObject *instance_class = NULL; - if (value && PyExceptionInstance_Check(value)) { - instance_class = (PyObject*) Py_TYPE(value); - if (instance_class != type) { - int is_subclass = PyObject_IsSubclass(instance_class, type); - if (!is_subclass) { - instance_class = NULL; - } else if (unlikely(is_subclass == -1)) { - goto bad; - } else { - type = instance_class; + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; + break; } + name++; } - } - if (!instance_class) { - PyObject *args; - if (!value) - args = PyTuple_New(0); - else if (PyTuple_Check(value)) { - Py_INCREF(value); - args = value; - } else - args = PyTuple_Pack(1, value); - if (!args) - goto bad; - owned_instance = PyObject_Call(type, args, NULL); - Py_DECREF(args); - if (!owned_instance) - goto bad; - value = owned_instance; - if (!PyExceptionInstance_Check(value)) { - PyErr_Format(PyExc_TypeError, - "calling %R should have returned an instance of " - "BaseException, not %R", - type, Py_TYPE(value)); - goto bad; + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } } - } - } else { - PyErr_SetString(PyExc_TypeError, - "raise: exception class must be a subclass of BaseException"); - goto bad; - } - if (cause) { - PyObject *fixed_cause; - if (cause == Py_None) { - fixed_cause = NULL; - } else if (PyExceptionClass_Check(cause)) { - fixed_cause = PyObject_CallObject(cause, NULL); - if (fixed_cause == NULL) - goto bad; - } else if (PyExceptionInstance_Check(cause)) { - fixed_cause = cause; - Py_INCREF(fixed_cause); + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = (**name == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; } else { - PyErr_SetString(PyExc_TypeError, - "exception causes must derive from " - "BaseException"); - goto bad; + goto invalid_keyword; } - PyException_SetCause(value, fixed_cause); } - PyErr_SetObject(type, value); - if (tb) { -#if CYTHON_COMPILING_IN_PYPY - PyObject *tmp_type, *tmp_value, *tmp_tb; - PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); - Py_INCREF(tb); - PyErr_Restore(tmp_type, tmp_value, tb); - Py_XDECREF(tmp_tb); + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + return -1; +} + +/* ArgTypeTest */ +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + else if (exact) { + #if PY_MAJOR_VERSION == 2 + if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; + #endif + } + else { + if (likely(__Pyx_TypeCheck(obj, type))) return 1; + } + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", + name, type->tp_name, Py_TYPE(obj)->tp_name); + return 0; +} + +/* PyDictVersioning */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { + PyObject **dictptr = NULL; + Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; + if (offset) { +#if CYTHON_COMPILING_IN_CPYTHON + dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); #else - PyThreadState *tstate = __Pyx_PyThreadState_Current; - PyObject* tmp_tb = tstate->curexc_traceback; - if (tb != tmp_tb) { - Py_INCREF(tb); - tstate->curexc_traceback = tb; - Py_XDECREF(tmp_tb); - } + dictptr = _PyObject_GetDictPtr(obj); #endif } -bad: - Py_XDECREF(owned_instance); - return; + return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; +} +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) + return 0; + return obj_dict_version == __Pyx_get_object_dict_version(obj); } #endif +/* GetModuleGlobalName */ +#if CYTHON_USE_DICT_VERSIONS +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) +#else +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) +#endif +{ + PyObject *result; +#if !CYTHON_AVOID_BORROWED_REFS +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 + result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } else if (unlikely(PyErr_Occurred())) { + return NULL; + } +#else + result = PyDict_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } +#endif +#else + result = PyObject_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } + PyErr_Clear(); +#endif + return __Pyx_GetBuiltinName(name); +} + /* JoinPyUnicode */ static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, CYTHON_UNUSED Py_UCS4 max_char) { @@ -14928,16 +12987,16 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, #endif #endif -/* PyObjectCallMethO */ +/* PyObjectCall */ #if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { - PyObject *self, *result; - PyCFunction cfunc; - cfunc = PyCFunction_GET_FUNCTION(func); - self = PyCFunction_GET_SELF(func); +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = Py_TYPE(func)->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; - result = cfunc(self, arg); + result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( @@ -14948,304 +13007,248 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject } #endif -/* PyObjectCallOneArg */ +/* PyObjectCallMethO */ #if CYTHON_COMPILING_IN_CPYTHON -static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { - PyObject *result; - PyObject *args = PyTuple_New(1); - if (unlikely(!args)) return NULL; - Py_INCREF(arg); - PyTuple_SET_ITEM(args, 0, arg); - result = __Pyx_PyObject_Call(func, args, NULL); - Py_DECREF(args); - return result; -} -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { -#if CYTHON_FAST_PYCALL - if (PyFunction_Check(func)) { - return __Pyx_PyFunction_FastCall(func, &arg, 1); - } -#endif - if (likely(PyCFunction_Check(func))) { - if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { - return __Pyx_PyObject_CallMethO(func, arg); -#if CYTHON_FAST_PYCCALL - } else if (__Pyx_PyFastCFunction_Check(func)) { - return __Pyx_PyCFunction_FastCall(func, &arg, 1); -#endif - } - } - return __Pyx__PyObject_CallOneArg(func, arg); -} -#else -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { - PyObject *result; - PyObject *args = PyTuple_Pack(1, arg); - if (unlikely(!args)) return NULL; - result = __Pyx_PyObject_Call(func, args, NULL); - Py_DECREF(args); - return result; -} -#endif - -/* PyIntCompare */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED long inplace) { - if (op1 == op2) { - Py_RETURN_TRUE; - } - #if PY_MAJOR_VERSION < 3 - if (likely(PyInt_CheckExact(op1))) { - const long b = intval; - long a = PyInt_AS_LONG(op1); - if (a == b) Py_RETURN_TRUE; else Py_RETURN_FALSE; - } - #endif - #if CYTHON_USE_PYLONG_INTERNALS - if (likely(PyLong_CheckExact(op1))) { - int unequal; - unsigned long uintval; - Py_ssize_t size = Py_SIZE(op1); - const digit* digits = ((PyLongObject*)op1)->ob_digit; - if (intval == 0) { - if (size == 0) Py_RETURN_TRUE; else Py_RETURN_FALSE; - } else if (intval < 0) { - if (size >= 0) - Py_RETURN_FALSE; - intval = -intval; - size = -size; - } else { - if (size <= 0) - Py_RETURN_FALSE; - } - uintval = (unsigned long) intval; -#if PyLong_SHIFT * 4 < SIZEOF_LONG*8 - if (uintval >> (PyLong_SHIFT * 4)) { - unequal = (size != 5) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) - | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[4] != ((uintval >> (4 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); - } else -#endif -#if PyLong_SHIFT * 3 < SIZEOF_LONG*8 - if (uintval >> (PyLong_SHIFT * 3)) { - unequal = (size != 4) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) - | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); - } else -#endif -#if PyLong_SHIFT * 2 < SIZEOF_LONG*8 - if (uintval >> (PyLong_SHIFT * 2)) { - unequal = (size != 3) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) - | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); - } else -#endif -#if PyLong_SHIFT * 1 < SIZEOF_LONG*8 - if (uintval >> (PyLong_SHIFT * 1)) { - unequal = (size != 2) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) - | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); - } else -#endif - unequal = (size != 1) || (((unsigned long) digits[0]) != (uintval & (unsigned long) PyLong_MASK)); - if (unequal == 0) Py_RETURN_TRUE; else Py_RETURN_FALSE; - } - #endif - if (PyFloat_CheckExact(op1)) { - const long b = intval; - double a = PyFloat_AS_DOUBLE(op1); - if ((double)a == (double)b) Py_RETURN_TRUE; else Py_RETURN_FALSE; - } - return ( - PyObject_RichCompare(op1, op2, Py_EQ)); -} - -/* PyObjectCall2Args */ -static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { - PyObject *args, *result = NULL; - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(function)) { - PyObject *args[2] = {arg1, arg2}; - return __Pyx_PyFunction_FastCall(function, args, 2); - } - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(function)) { - PyObject *args[2] = {arg1, arg2}; - return __Pyx_PyCFunction_FastCall(function, args, 2); +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = PyCFunction_GET_FUNCTION(func); + self = PyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); } - #endif - args = PyTuple_New(2); - if (unlikely(!args)) goto done; - Py_INCREF(arg1); - PyTuple_SET_ITEM(args, 0, arg1); - Py_INCREF(arg2); - PyTuple_SET_ITEM(args, 1, arg2); - Py_INCREF(function); - result = __Pyx_PyObject_Call(function, args, NULL); - Py_DECREF(args); - Py_DECREF(function); -done: return result; } +#endif -/* RaiseArgTupleInvalid */ -static void __Pyx_RaiseArgtupleInvalid( - const char* func_name, - int exact, - Py_ssize_t num_min, - Py_ssize_t num_max, - Py_ssize_t num_found) -{ - Py_ssize_t num_expected; - const char *more_or_less; - if (num_found < num_min) { - num_expected = num_min; - more_or_less = "at least"; - } else { - num_expected = num_max; - more_or_less = "at most"; +/* PyObjectCallOneArg */ +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, &arg, 1); } - if (exact) { - more_or_less = "exactly"; +#endif + if (likely(PyCFunction_Check(func))) { + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { + return __Pyx_PyObject_CallMethO(func, arg); +#if CYTHON_FAST_PYCCALL + } else if (__Pyx_PyFastCFunction_Check(func)) { + return __Pyx_PyCFunction_FastCall(func, &arg, 1); +#endif + } } - PyErr_Format(PyExc_TypeError, - "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", - func_name, more_or_less, num_expected, - (num_expected == 1) ? "" : "s", num_found); + return __Pyx__PyObject_CallOneArg(func, arg); +} +#else +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; } +#endif -/* RaiseDoubleKeywords */ -static void __Pyx_RaiseDoubleKeywordsError( - const char* func_name, - PyObject* kw_name) -{ - PyErr_Format(PyExc_TypeError, - #if PY_MAJOR_VERSION >= 3 - "%s() got multiple values for keyword argument '%U'", func_name, kw_name); - #else - "%s() got multiple values for keyword argument '%s'", func_name, - PyString_AsString(kw_name)); - #endif +/* PyErrFetchRestore */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; } +#endif -/* ParseKeywords */ -static int __Pyx_ParseOptionalKeywords( - PyObject *kwds, - PyObject **argnames[], - PyObject *kwds2, - PyObject *values[], - Py_ssize_t num_pos_args, - const char* function_name) -{ - PyObject *key = 0, *value = 0; - Py_ssize_t pos = 0; - PyObject*** name; - PyObject*** first_kw_arg = argnames + num_pos_args; - while (PyDict_Next(kwds, &pos, &key, &value)) { - name = first_kw_arg; - while (*name && (**name != key)) name++; - if (*name) { - values[name-argnames] = value; - continue; +/* RaiseException */ +#if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + __Pyx_PyThreadState_declare + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; } - name = first_kw_arg; - #if PY_MAJOR_VERSION < 3 - if (likely(PyString_Check(key))) { - while (*name) { - if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) - && _PyString_Eq(**name, key)) { - values[name-argnames] = value; - break; - } - name++; - } - if (*name) continue; - else { - PyObject*** argname = argnames; - while (argname != first_kw_arg) { - if ((**argname == key) || ( - (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) - && _PyString_Eq(**argname, key))) { - goto arg_passed_twice; - } - argname++; - } - } - } else - #endif - if (likely(PyUnicode_Check(key))) { - while (*name) { - int cmp = (**name == key) ? 0 : - #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 - (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : - #endif - PyUnicode_Compare(**name, key); - if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; - if (cmp == 0) { - values[name-argnames] = value; - break; - } - name++; - } - if (*name) continue; - else { - PyObject*** argname = argnames; - while (argname != first_kw_arg) { - int cmp = (**argname == key) ? 0 : - #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 - (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : - #endif - PyUnicode_Compare(**argname, key); - if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; - if (cmp == 0) goto arg_passed_twice; - argname++; + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_PyThreadState_assign + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; } } - } else - goto invalid_keyword_type; - if (kwds2) { - if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; - } else { - goto invalid_keyword; } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; } - return 0; -arg_passed_twice: - __Pyx_RaiseDoubleKeywordsError(function_name, key); - goto bad; -invalid_keyword_type: - PyErr_Format(PyExc_TypeError, - "%.200s() keywords must be strings", function_name); - goto bad; -invalid_keyword: - PyErr_Format(PyExc_TypeError, - #if PY_MAJOR_VERSION < 3 - "%.200s() got an unexpected keyword argument '%.200s'", - function_name, PyString_AsString(key)); - #else - "%s() got an unexpected keyword argument '%U'", - function_name, key); - #endif -bad: - return -1; -} - -/* ArgTypeTest */ -static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) -{ - if (unlikely(!type)) { - PyErr_SetString(PyExc_SystemError, "Missing type object"); - return 0; - } - else if (exact) { - #if PY_MAJOR_VERSION == 2 - if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; - #endif + if (cause) { + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); } - else { - if (likely(__Pyx_TypeCheck(obj, type))) return 1; + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_COMPILING_IN_PYPY + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#else + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#endif } - PyErr_Format(PyExc_TypeError, - "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", - name, type->tp_name, Py_TYPE(obj)->tp_name); - return 0; +bad: + Py_XDECREF(owned_instance); + return; } +#endif /* PyIntCompare */ static CYTHON_INLINE PyObject* __Pyx_PyInt_NeObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED long inplace) { @@ -15314,6 +13317,35 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_NeObjC(PyObject *op1, PyObject *op2, PyObject_RichCompare(op1, op2, Py_NE)); } +/* PyObjectCall2Args */ +static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { + PyObject *args, *result = NULL; + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(function)) { + PyObject *args[2] = {arg1, arg2}; + return __Pyx_PyFunction_FastCall(function, args, 2); + } + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(function)) { + PyObject *args[2] = {arg1, arg2}; + return __Pyx_PyCFunction_FastCall(function, args, 2); + } + #endif + args = PyTuple_New(2); + if (unlikely(!args)) goto done; + Py_INCREF(arg1); + PyTuple_SET_ITEM(args, 0, arg1); + Py_INCREF(arg2); + PyTuple_SET_ITEM(args, 1, arg2); + Py_INCREF(function); + result = __Pyx_PyObject_Call(function, args, NULL); + Py_DECREF(args); + Py_DECREF(function); +done: + return result; +} + /* RaiseTooManyValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { PyErr_Format(PyExc_ValueError, @@ -15530,6 +13562,73 @@ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int #endif } +/* PyIntCompare */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED long inplace) { + if (op1 == op2) { + Py_RETURN_TRUE; + } + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + const long b = intval; + long a = PyInt_AS_LONG(op1); + if (a == b) Py_RETURN_TRUE; else Py_RETURN_FALSE; + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op1))) { + int unequal; + unsigned long uintval; + Py_ssize_t size = Py_SIZE(op1); + const digit* digits = ((PyLongObject*)op1)->ob_digit; + if (intval == 0) { + if (size == 0) Py_RETURN_TRUE; else Py_RETURN_FALSE; + } else if (intval < 0) { + if (size >= 0) + Py_RETURN_FALSE; + intval = -intval; + size = -size; + } else { + if (size <= 0) + Py_RETURN_FALSE; + } + uintval = (unsigned long) intval; +#if PyLong_SHIFT * 4 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 4)) { + unequal = (size != 5) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[4] != ((uintval >> (4 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else +#endif +#if PyLong_SHIFT * 3 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 3)) { + unequal = (size != 4) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else +#endif +#if PyLong_SHIFT * 2 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 2)) { + unequal = (size != 3) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else +#endif +#if PyLong_SHIFT * 1 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 1)) { + unequal = (size != 2) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else +#endif + unequal = (size != 1) || (((unsigned long) digits[0]) != (uintval & (unsigned long) PyLong_MASK)); + if (unequal == 0) Py_RETURN_TRUE; else Py_RETURN_FALSE; + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + if ((double)a == (double)b) Py_RETURN_TRUE; else Py_RETURN_FALSE; + } + return ( + PyObject_RichCompare(op1, op2, Py_EQ)); +} + /* PyUnicode_Substring */ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_Substring( PyObject* text, Py_ssize_t start, Py_ssize_t stop) { @@ -15994,6 +14093,30 @@ static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); } +/* DictGetItem */ +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { + PyObject *value; + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (!PyErr_Occurred()) { + if (unlikely(PyTuple_Check(key))) { + PyObject* args = PyTuple_Pack(1, key); + if (likely(args)) { + PyErr_SetObject(PyExc_KeyError, args); + Py_DECREF(args); + } + } else { + PyErr_SetObject(PyExc_KeyError, key); + } + } + return NULL; + } + Py_INCREF(value); + return value; +} +#endif + /* GetTopmostException */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * @@ -16162,48 +14285,6 @@ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { return 0; } -/* WriteUnraisableException */ -static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, - CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, - int full_traceback, CYTHON_UNUSED int nogil) { - PyObject *old_exc, *old_val, *old_tb; - PyObject *ctx; - __Pyx_PyThreadState_declare -#ifdef WITH_THREAD - PyGILState_STATE state; - if (nogil) - state = PyGILState_Ensure(); -#ifdef _MSC_VER - else state = (PyGILState_STATE)-1; -#endif -#endif - __Pyx_PyThreadState_assign - __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); - if (full_traceback) { - Py_XINCREF(old_exc); - Py_XINCREF(old_val); - Py_XINCREF(old_tb); - __Pyx_ErrRestore(old_exc, old_val, old_tb); - PyErr_PrintEx(1); - } - #if PY_MAJOR_VERSION < 3 - ctx = PyString_FromString(name); - #else - ctx = PyUnicode_FromString(name); - #endif - __Pyx_ErrRestore(old_exc, old_val, old_tb); - if (!ctx) { - PyErr_WriteUnraisable(Py_None); - } else { - PyErr_WriteUnraisable(ctx); - Py_DECREF(ctx); - } -#ifdef WITH_THREAD - if (nogil) - PyGILState_Release(state); -#endif -} - /* TypeImport */ #ifndef __PYX_HAVE_RT_ImportType #define __PYX_HAVE_RT_ImportType diff --git a/python/l0learn/interface.pyx b/python/l0learn/interface.pyx index 94d0bd2..101e9d3 100644 --- a/python/l0learn/interface.pyx +++ b/python/l0learn/interface.pyx @@ -74,8 +74,22 @@ def _fit_check(X: Union[np.ndarray, csc_matrix], lows: Union[np.ndarray, float], highs: Union[np.ndarray, float]) -> Dict[str, Any]: - if not isinstance(X, (np.ndarray, csc_matrix)) or X.dtype != np.float64 or X.ndim != 2 or not np.product(X.shape) or not X.flags.contiguous: - raise ValueError(f"expected X to be a 2D continuous non-degenerate real numpy or csc_matrix, but got {X}.") + if isinstance(X, (np.ndarray, csc_matrix)): + if X.dtype != np.float64: + raise ValueError(f"expected X to have dtype {np.float64}, but got {X.dtype}") + if X.ndim != 2: + raise ValueError(f"expected X to be 2D, but got {X.ndim}D") + if not np.product(X.shape): + raise ValueError(f"expected X to have non-degenerate axis, but got {X.shape}") + # if isinstance(X, np.ndarray): + # if not X.flags.contiguous: + # raise ValueError(f"expected X to be contiguous, but is not.") + # else: # isinstance(X, csc_matrix): + # if not (X.indptr.flags.contiguous and X.indices.flags.contiguous and X.data.flags.continuous): + # raise ValueError(f"expected X to have contiguous `indptr`, `indices`, and `data`, but is not.") + else: + raise ValueError(f"expected X to be a {np.ndarray} or a {csc_matrix}, but got {type(X)}.") + n, p = X.shape if not isinstance(y, np.ndarray) or not np.isrealobj(y) or y.ndim != 1 or len(y) != n: raise ValueError(f"expected y to be a 1D real numpy, but got {y}.") diff --git a/python/tests/test_fit.py b/python/tests/test_fit.py index 93ac80e..cab8edd 100644 --- a/python/tests/test_fit.py +++ b/python/tests/test_fit.py @@ -1,16 +1,24 @@ import pytest import numpy as np +from scipy.sparse import csc_matrix + import l0learn N = 50 +@pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) +def test_X_sparse_support(f): + x = np.random.random(size=(N, N)) + y = np.random.random(size=(N,)) + _ = l0learn.fit(csc_matrix(x), y, intercept=False) + @pytest.mark.parametrize("x", [np.random.random(size=(N, N, N)), # Wrong Size "A String", # Wrong Type np.random.random(size=(N, N)).astype(complex), # Wrong dtype np.random.random(size=(N, N)).astype(int), # Wrong dtype np.random.random(size=(0, N))]) # degenerate 2D array @pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) -def test_X_bad_checks(f, x): +def test_X_dense_bad_checks(f, x): # Check size of matrix X y = np.random.random(size=(N,)) with pytest.raises(ValueError): From 6b15a4ee10399b073c5f179a58dc5691c7477816 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 26 Nov 2021 09:12:55 -0500 Subject: [PATCH 074/125] Update test coverages on models and fit functions --- python/l0learn/interface.cpp | 1504 +++++++++++++++------------------- python/l0learn/interface.pyx | 16 +- python/l0learn/models.py | 25 +- python/tests/test_fit.py | 10 +- python/tests/test_models.py | 138 +++- 5 files changed, 809 insertions(+), 884 deletions(-) diff --git a/python/l0learn/interface.cpp b/python/l0learn/interface.cpp index 00629ab..65e66b7 100644 --- a/python/l0learn/interface.cpp +++ b/python/l0learn/interface.cpp @@ -1537,6 +1537,9 @@ static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); #define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) #endif +/* ExtTypeTest.proto */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + /* GetTopmostException.proto */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); @@ -1569,9 +1572,6 @@ static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); #endif -/* ExtTypeTest.proto */ -static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); - /* ListCompAppend.proto */ #if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { @@ -1845,7 +1845,6 @@ static PyObject *__pyx_builtin_ValueError; static PyObject *__pyx_builtin_enumerate; static PyObject *__pyx_builtin_any; static PyObject *__pyx_builtin_all; -static PyObject *__pyx_builtin_TypeError; static PyObject *__pyx_builtin_ImportError; static PyObject *__pyx_builtin_range; static const char __pyx_k_[] = "."; @@ -1919,7 +1918,6 @@ static const char __pyx_k_lambda_0[] = "lambda_0"; static const char __pyx_k_max_iter[] = "max_iter"; static const char __pyx_k_settings[] = "settings"; static const char __pyx_k_warnings[] = "warnings"; -static const char __pyx_k_TypeError[] = "TypeError"; static const char __pyx_k_algorithm[] = "algorithm"; static const char __pyx_k_c_penalty[] = "c_penalty"; static const char __pyx_k_c_results[] = "c_results"; @@ -1997,7 +1995,6 @@ static const char __pyx_k_expected_active_set_parameter_to[] = "expected active_ static const char __pyx_k_expected_atol_parameter_to_exist[] = "expected atol parameter to exist in [0, INF), but got "; static const char __pyx_k_expected_exclude_first_k_paramet[] = "expected exclude_first_k parameter to be a positive integer less than "; static const char __pyx_k_expected_highs_to_be_a_non_negat[] = "expected highs to be a non-negative float, but got "; -static const char __pyx_k_expected_lambda_grid_to_be_a_lis[] = "expected lambda_grid to be a list of list of doubles, but got "; static const char __pyx_k_expected_lambda_grid_to_of_lengt[] = "expected lambda_grid to of length 1 when penalty = 'L0', but got "; static const char __pyx_k_expected_loss_parameter_to_be_on[] = "expected loss parameter to be on of "; static const char __pyx_k_expected_lows_to_be_a_non_positi[] = "expected lows to be a non-positive float, but got "; @@ -2044,7 +2041,6 @@ static PyObject *__pyx_n_s_SUPPORTED_LOSS; static PyObject *__pyx_n_s_SUPPORTED_PENALTY; static PyObject *__pyx_n_u_SquaredError; static PyObject *__pyx_n_u_SquaredHinge; -static PyObject *__pyx_n_s_TypeError; static PyObject *__pyx_n_s_Union; static PyObject *__pyx_n_s_ValueError; static PyObject *__pyx_n_s_X; @@ -2099,7 +2095,6 @@ static PyObject *__pyx_kp_u_expected_gamma_max_parameter_to_2; static PyObject *__pyx_kp_u_expected_highs_to_be_a_non_negat; static PyObject *__pyx_kp_u_expected_highs_to_be_a_non_negat_2; static PyObject *__pyx_kp_u_expected_intercept_parameter_to; -static PyObject *__pyx_kp_u_expected_lambda_grid_to_be_a_lis; static PyObject *__pyx_kp_u_expected_lambda_grid_to_of_lengt; static PyObject *__pyx_kp_u_expected_loss_parameter_to_be_on; static PyObject *__pyx_kp_u_expected_lows_to_be_a_non_positi; @@ -5684,7 +5679,7 @@ static PyObject *__pyx_pf_7l0learn_9interface__fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") * if highs < float('inf'): # <<<<<<<<<<<<<< * with_bounds = True - * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): + * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and all(highs >= 0): */ __pyx_t_1 = __Pyx_PyNumber_Float(__pyx_n_u_inf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 224, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -5698,7 +5693,7 @@ static PyObject *__pyx_pf_7l0learn_9interface__fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") * if highs < float('inf'): * with_bounds = True # <<<<<<<<<<<<<< - * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): + * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and all(highs >= 0): * with_bounds = True */ __pyx_v_with_bounds = 1; @@ -5708,7 +5703,7 @@ static PyObject *__pyx_pf_7l0learn_9interface__fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected highs to be a non-negative float, but got {highs}") * if highs < float('inf'): # <<<<<<<<<<<<<< * with_bounds = True - * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): + * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and all(highs >= 0): */ } @@ -5725,7 +5720,7 @@ static PyObject *__pyx_pf_7l0learn_9interface__fit_check(CYTHON_UNUSED PyObject /* "l0learn/interface.pyx":226 * if highs < float('inf'): * with_bounds = True - * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): # <<<<<<<<<<<<<< + * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and all(highs >= 0): # <<<<<<<<<<<<<< * with_bounds = True * else: */ @@ -5767,15 +5762,18 @@ static PyObject *__pyx_pf_7l0learn_9interface__fit_check(CYTHON_UNUSED PyObject goto __pyx_L91_bool_binop_done; } __pyx_t_1 = PyObject_RichCompare(__pyx_v_highs, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 226, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 226, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_builtin_all, __pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 226, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_3 = __pyx_t_5; __pyx_L91_bool_binop_done:; if (likely(__pyx_t_3)) { /* "l0learn/interface.pyx":227 * with_bounds = True - * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): + * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and all(highs >= 0): * with_bounds = True # <<<<<<<<<<<<<< * else: * raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " @@ -5785,7 +5783,7 @@ static PyObject *__pyx_pf_7l0learn_9interface__fit_check(CYTHON_UNUSED PyObject /* "l0learn/interface.pyx":226 * if highs < float('inf'): * with_bounds = True - * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): # <<<<<<<<<<<<<< + * elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and all(highs >= 0): # <<<<<<<<<<<<<< * with_bounds = True * else: */ @@ -5800,25 +5798,25 @@ static PyObject *__pyx_pf_7l0learn_9interface__fit_check(CYTHON_UNUSED PyObject * */ /*else*/ { - __pyx_t_1 = PyTuple_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 229, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = PyTuple_New(4); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); __pyx_t_7 = 0; __pyx_t_8 = 127; __Pyx_INCREF(__pyx_kp_u_expected_highs_to_be_a_non_negat_2); __pyx_t_7 += 73; __Pyx_GIVEREF(__pyx_kp_u_expected_highs_to_be_a_non_negat_2); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_expected_highs_to_be_a_non_negat_2); - __pyx_t_9 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 229, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9) : __pyx_t_8; - __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9); - __Pyx_GIVEREF(__pyx_t_9); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_9); - __pyx_t_9 = 0; + PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_kp_u_expected_highs_to_be_a_non_negat_2); + __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_t_1); + __pyx_t_1 = 0; __Pyx_INCREF(__pyx_kp_u_of_non_negative_floats_but_got); __pyx_t_7 += 33; __Pyx_GIVEREF(__pyx_kp_u_of_non_negative_floats_but_got); - PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u_of_non_negative_floats_but_got); + PyTuple_SET_ITEM(__pyx_t_9, 2, __pyx_kp_u_of_non_negative_floats_but_got); /* "l0learn/interface.pyx":230 * else: @@ -5827,13 +5825,13 @@ static PyObject *__pyx_pf_7l0learn_9interface__fit_check(CYTHON_UNUSED PyObject * * if with_bounds: */ - __pyx_t_9 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 230, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9) : __pyx_t_8; - __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9); - __Pyx_GIVEREF(__pyx_t_9); - PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_t_9); - __pyx_t_9 = 0; + __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_highs, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_9, 3, __pyx_t_1); + __pyx_t_1 = 0; /* "l0learn/interface.pyx":229 * with_bounds = True @@ -5842,14 +5840,14 @@ static PyObject *__pyx_pf_7l0learn_9interface__fit_check(CYTHON_UNUSED PyObject * f"non-negative floats, but got {highs}") * */ - __pyx_t_9 = __Pyx_PyUnicode_Join(__pyx_t_1, 4, __pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 229, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 229, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_9, 4, __pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 229, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_9, 0, 0, 0); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __PYX_ERR(0, 229, __pyx_L1_error) } __pyx_L88:; @@ -5882,29 +5880,29 @@ static PyObject *__pyx_pf_7l0learn_9interface__fit_check(CYTHON_UNUSED PyObject * if isinstance(highs, float): * highs = np.ones(p) * highs */ - __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 234, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_ones); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_ones); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_9 = NULL; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { - __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_6); - if (likely(__pyx_t_9)) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); - __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } - __pyx_t_1 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_9, __pyx_v_p) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_p); - __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 234, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_1, __pyx_v_p) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_p); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyNumber_Multiply(__pyx_t_1, __pyx_v_lows); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 234, __pyx_L1_error) + __pyx_t_6 = PyNumber_Multiply(__pyx_t_9, __pyx_v_lows); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_6); __pyx_t_6 = 0; @@ -5935,31 +5933,31 @@ static PyObject *__pyx_pf_7l0learn_9interface__fit_check(CYTHON_UNUSED PyObject * * if any(lows >= highs): */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 236, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_ones); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 236, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { - __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_9); - if (likely(__pyx_t_1)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); - __Pyx_INCREF(__pyx_t_1); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_ones); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_9, function); + __Pyx_DECREF_SET(__pyx_t_1, function); } } - __pyx_t_6 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_1, __pyx_v_p) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_v_p); - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_6 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_9, __pyx_v_p) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_p); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 236, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_9 = PyNumber_Multiply(__pyx_t_6, __pyx_v_highs); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 236, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyNumber_Multiply(__pyx_t_6, __pyx_v_highs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_9); - __pyx_t_9 = 0; + __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_1); + __pyx_t_1 = 0; /* "l0learn/interface.pyx":235 * if isinstance(lows, float): @@ -5977,10 +5975,10 @@ static PyObject *__pyx_pf_7l0learn_9interface__fit_check(CYTHON_UNUSED PyObject * bad_bounds = np.argwhere(lows >= highs) * raise ValueError(f"expected to be high to be elementwise greater than lows, " */ - __pyx_t_9 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 238, __pyx_L1_error) - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 238, __pyx_L1_error) + __pyx_t_1 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 238, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_any, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 238, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 238, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(__pyx_t_3)) { @@ -5992,28 +5990,28 @@ static PyObject *__pyx_pf_7l0learn_9interface__fit_check(CYTHON_UNUSED PyObject * raise ValueError(f"expected to be high to be elementwise greater than lows, " * f"but got indices {bad_bounds[0]} where that is not the case ") */ - __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 239, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_argwhere); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 239, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_9 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 239, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_argwhere); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyObject_RichCompare(__pyx_v_lows, __pyx_v_highs, Py_GE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 239, __pyx_L1_error) __pyx_t_15 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_1); + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_9); if (likely(__pyx_t_15)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); __Pyx_INCREF(__pyx_t_15); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); + __Pyx_DECREF_SET(__pyx_t_9, function); } } - __pyx_t_6 = (__pyx_t_15) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_15, __pyx_t_9) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_9); + __pyx_t_6 = (__pyx_t_15) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_15, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_1); __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 239, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_v_bad_bounds = __pyx_t_6; __pyx_t_6 = 0; @@ -6040,16 +6038,16 @@ static PyObject *__pyx_pf_7l0learn_9interface__fit_check(CYTHON_UNUSED PyObject * else: * lows = np.array([0.]) */ - __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_bad_bounds, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 241, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_9 = __Pyx_PyObject_FormatSimple(__pyx_t_1, __pyx_empty_unicode); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 241, __pyx_L1_error) + __pyx_t_9 = __Pyx_GetItemInt(__pyx_v_bad_bounds, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 241, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9) : __pyx_t_8; - __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9); - __Pyx_GIVEREF(__pyx_t_9); - PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_9); - __pyx_t_9 = 0; + __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_t_9, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 241, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_1); + __pyx_t_1 = 0; __Pyx_INCREF(__pyx_kp_u_where_that_is_not_the_case); __pyx_t_7 += 28; __Pyx_GIVEREF(__pyx_kp_u_where_that_is_not_the_case); @@ -6062,12 +6060,12 @@ static PyObject *__pyx_pf_7l0learn_9interface__fit_check(CYTHON_UNUSED PyObject * f"but got indices {bad_bounds[0]} where that is not the case ") * else: */ - __pyx_t_9 = __Pyx_PyUnicode_Join(__pyx_t_6, 3, __pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_6, 3, __pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 240, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 240, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(0, 240, __pyx_L1_error) @@ -6099,32 +6097,32 @@ static PyObject *__pyx_pf_7l0learn_9interface__fit_check(CYTHON_UNUSED PyObject * */ /*else*/ { - __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 243, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_array); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 243, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 243, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __pyx_t_9 = PyList_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 243, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_array); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 243, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_float_0_); __Pyx_GIVEREF(__pyx_float_0_); - PyList_SET_ITEM(__pyx_t_9, 0, __pyx_float_0_); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_float_0_); __pyx_t_15 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { - __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_1); + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_9); if (likely(__pyx_t_15)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); __Pyx_INCREF(__pyx_t_15); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_1, function); + __Pyx_DECREF_SET(__pyx_t_9, function); } } - __pyx_t_6 = (__pyx_t_15) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_15, __pyx_t_9) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_9); + __pyx_t_6 = (__pyx_t_15) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_15, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_1); __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 243, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_6); __pyx_t_6 = 0; @@ -6135,32 +6133,32 @@ static PyObject *__pyx_pf_7l0learn_9interface__fit_check(CYTHON_UNUSED PyObject * * return {"max_support_size": max_support_size, */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 244, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_array); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 244, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 244, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 244, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_array); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 244, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = PyList_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 244, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); __Pyx_INCREF(__pyx_float_0_); __Pyx_GIVEREF(__pyx_float_0_); - PyList_SET_ITEM(__pyx_t_1, 0, __pyx_float_0_); + PyList_SET_ITEM(__pyx_t_9, 0, __pyx_float_0_); __pyx_t_15 = NULL; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) { - __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_9); + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_15)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_15); __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_9, function); + __Pyx_DECREF_SET(__pyx_t_1, function); } } - __pyx_t_6 = (__pyx_t_15) ? __Pyx_PyObject_Call2Args(__pyx_t_9, __pyx_t_15, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_1); + __pyx_t_6 = (__pyx_t_15) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_15, __pyx_t_9) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_9); __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 244, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_6); __pyx_t_6 = 0; } @@ -6212,10 +6210,10 @@ static PyObject *__pyx_pf_7l0learn_9interface__fit_check(CYTHON_UNUSED PyObject * "gamma_min": gamma_min, * "lambda_grid": lambda_grid, */ - __pyx_t_9 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 250, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_u_gamma_max, __pyx_t_9) < 0) __PYX_ERR(0, 246, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_6, __pyx_n_u_gamma_max, __pyx_t_1) < 0) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "l0learn/interface.pyx":251 * "penalty":penalty, @@ -6224,10 +6222,10 @@ static PyObject *__pyx_pf_7l0learn_9interface__fit_check(CYTHON_UNUSED PyObject * "lambda_grid": lambda_grid, * "num_gamma": num_gamma, */ - __pyx_t_9 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 251, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_u_gamma_min, __pyx_t_9) < 0) __PYX_ERR(0, 246, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 251, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_6, __pyx_n_u_gamma_min, __pyx_t_1) < 0) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "l0learn/interface.pyx":252 * "gamma_max":gamma_max, @@ -6263,10 +6261,10 @@ static PyObject *__pyx_pf_7l0learn_9interface__fit_check(CYTHON_UNUSED PyObject * "with_bounds": with_bounds, * "lows": lows, */ - __pyx_t_9 = __Pyx_PyBool_FromLong(__pyx_v_auto_lambda); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 255, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_u_auto_lambda, __pyx_t_9) < 0) __PYX_ERR(0, 246, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_auto_lambda); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_6, __pyx_n_u_auto_lambda, __pyx_t_1) < 0) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "l0learn/interface.pyx":256 * "num_lambda":num_lambda, @@ -6275,10 +6273,10 @@ static PyObject *__pyx_pf_7l0learn_9interface__fit_check(CYTHON_UNUSED PyObject * "lows": lows, * "highs":highs} */ - __pyx_t_9 = __Pyx_PyBool_FromLong(__pyx_v_with_bounds); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 256, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_u_with_bounds, __pyx_t_9) < 0) __PYX_ERR(0, 246, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_with_bounds); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_6, __pyx_n_u_with_bounds, __pyx_t_1) < 0) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "l0learn/interface.pyx":257 * "auto_lambda": auto_lambda, @@ -6783,28 +6781,22 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; double __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; - std::vector > __pyx_t_8; - int __pyx_t_9; - PyObject *__pyx_t_10 = NULL; - PyObject *__pyx_t_11 = NULL; - std::string __pyx_t_12; - int __pyx_t_13; - int __pyx_t_14; + std::vector > __pyx_t_5; + std::string __pyx_t_6; + int __pyx_t_7; + int __pyx_t_8; + size_t __pyx_t_9; + size_t __pyx_t_10; + size_t __pyx_t_11; + bool __pyx_t_12; + size_t __pyx_t_13; + bool __pyx_t_14; size_t __pyx_t_15; size_t __pyx_t_16; size_t __pyx_t_17; - bool __pyx_t_18; - size_t __pyx_t_19; + size_t __pyx_t_18; + bool __pyx_t_19; bool __pyx_t_20; - size_t __pyx_t_21; - size_t __pyx_t_22; - size_t __pyx_t_23; - size_t __pyx_t_24; - bool __pyx_t_25; - bool __pyx_t_26; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -7220,127 +7212,42 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx * lows = check['lows'] * highs = check['highs'] # <<<<<<<<<<<<<< * - * cdef vector[vector[double]] c_lambda_grid + * cdef vector[vector[double]] c_lambda_grid = lambda_grid */ __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_highs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 469, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":472 - * - * cdef vector[vector[double]] c_lambda_grid - * try: # <<<<<<<<<<<<<< - * c_lambda_grid = lambda_grid - * except TypeError: - */ - { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7); - __Pyx_XGOTREF(__pyx_t_5); - __Pyx_XGOTREF(__pyx_t_6); - __Pyx_XGOTREF(__pyx_t_7); - /*try:*/ { - - /* "l0learn/interface.pyx":473 - * cdef vector[vector[double]] c_lambda_grid - * try: - * c_lambda_grid = lambda_grid # <<<<<<<<<<<<<< - * except TypeError: - * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") - */ - __pyx_t_8 = __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_lambda_grid); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 473, __pyx_L3_error) - __pyx_v_c_lambda_grid = __pyx_t_8; - - /* "l0learn/interface.pyx":472 - * - * cdef vector[vector[double]] c_lambda_grid - * try: # <<<<<<<<<<<<<< - * c_lambda_grid = lambda_grid - * except TypeError: - */ - } - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - goto __pyx_L8_try_end; - __pyx_L3_error:; - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "l0learn/interface.pyx":474 - * try: - * c_lambda_grid = lambda_grid - * except TypeError: # <<<<<<<<<<<<<< - * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") - * - */ - __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); - if (__pyx_t_9) { - __Pyx_AddTraceback("l0learn.interface.fit", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_2, &__pyx_t_1) < 0) __PYX_ERR(0, 474, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GOTREF(__pyx_t_2); - __Pyx_GOTREF(__pyx_t_1); - - /* "l0learn/interface.pyx":475 - * c_lambda_grid = lambda_grid - * except TypeError: - * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") # <<<<<<<<<<<<<< + /* "l0learn/interface.pyx":471 + * highs = check['highs'] * + * cdef vector[vector[double]] c_lambda_grid = lambda_grid # <<<<<<<<<<<<<< * cdef string c_loss = loss.encode('UTF-8') + * cdef string c_penalty = penalty.encode('UTF-8') */ - __pyx_t_10 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 475, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_10); - __pyx_t_11 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_be_a_lis, __pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 475, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_11); - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_11); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 475, __pyx_L5_except_error) - __Pyx_GOTREF(__pyx_t_10); - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __Pyx_Raise(__pyx_t_10, 0, 0, 0); - __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - __PYX_ERR(0, 475, __pyx_L5_except_error) - } - goto __pyx_L5_except_error; - __pyx_L5_except_error:; - - /* "l0learn/interface.pyx":472 - * - * cdef vector[vector[double]] c_lambda_grid - * try: # <<<<<<<<<<<<<< - * c_lambda_grid = lambda_grid - * except TypeError: - */ - __Pyx_XGIVEREF(__pyx_t_5); - __Pyx_XGIVEREF(__pyx_t_6); - __Pyx_XGIVEREF(__pyx_t_7); - __Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7); - goto __pyx_L1_error; - __pyx_L8_try_end:; - } + __pyx_t_5 = __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_lambda_grid); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 471, __pyx_L1_error) + __pyx_v_c_lambda_grid = __pyx_t_5; - /* "l0learn/interface.pyx":477 - * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") + /* "l0learn/interface.pyx":472 * + * cdef vector[vector[double]] c_lambda_grid = lambda_grid * cdef string c_loss = loss.encode('UTF-8') # <<<<<<<<<<<<<< * cdef string c_penalty = penalty.encode('UTF-8') * cdef string c_algorithim = algorithm.encode('UTF-8') */ if (unlikely(__pyx_v_loss == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 477, __pyx_L1_error) + __PYX_ERR(0, 472, __pyx_L1_error) } - __pyx_t_1 = PyUnicode_AsUTF8String(__pyx_v_loss); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 477, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_12 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 477, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_c_loss = __pyx_t_12; + __pyx_t_3 = PyUnicode_AsUTF8String(__pyx_v_loss); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 472, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __pyx_convert_string_from_py_std__in_string(__pyx_t_3); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 472, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_c_loss = __pyx_t_6; - /* "l0learn/interface.pyx":478 - * + /* "l0learn/interface.pyx":473 + * cdef vector[vector[double]] c_lambda_grid = lambda_grid * cdef string c_loss = loss.encode('UTF-8') * cdef string c_penalty = penalty.encode('UTF-8') # <<<<<<<<<<<<<< * cdef string c_algorithim = algorithm.encode('UTF-8') @@ -7348,15 +7255,15 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ if (unlikely(__pyx_v_penalty == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 478, __pyx_L1_error) + __PYX_ERR(0, 473, __pyx_L1_error) } - __pyx_t_1 = PyUnicode_AsUTF8String(__pyx_v_penalty); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 478, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_12 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 478, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_c_penalty = __pyx_t_12; + __pyx_t_3 = PyUnicode_AsUTF8String(__pyx_v_penalty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 473, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __pyx_convert_string_from_py_std__in_string(__pyx_t_3); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 473, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_c_penalty = __pyx_t_6; - /* "l0learn/interface.pyx":479 + /* "l0learn/interface.pyx":474 * cdef string c_loss = loss.encode('UTF-8') * cdef string c_penalty = penalty.encode('UTF-8') * cdef string c_algorithim = algorithm.encode('UTF-8') # <<<<<<<<<<<<<< @@ -7365,204 +7272,204 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ if (unlikely(__pyx_v_algorithm == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 479, __pyx_L1_error) + __PYX_ERR(0, 474, __pyx_L1_error) } - __pyx_t_1 = PyUnicode_AsUTF8String(__pyx_v_algorithm); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 479, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_12 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 479, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_c_algorithim = __pyx_t_12; + __pyx_t_3 = PyUnicode_AsUTF8String(__pyx_v_algorithm); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 474, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __pyx_convert_string_from_py_std__in_string(__pyx_t_3); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 474, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_c_algorithim = __pyx_t_6; - /* "l0learn/interface.pyx":482 + /* "l0learn/interface.pyx":477 * * cdef fitmodel c_results * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), * y=numpy_to_dvec_d(y), */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 482, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 482, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 477, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 477, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_13 = PyObject_IsInstance(__pyx_v_X, __pyx_t_2); if (unlikely(__pyx_t_13 == ((int)-1))) __PYX_ERR(0, 482, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = PyObject_IsInstance(__pyx_v_X, __pyx_t_2); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 477, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_14 = (__pyx_t_13 != 0); - if (__pyx_t_14) { + __pyx_t_8 = (__pyx_t_7 != 0); + if (__pyx_t_8) { - /* "l0learn/interface.pyx":483 + /* "l0learn/interface.pyx":478 * cdef fitmodel c_results * if isinstance(X, np.ndarray): * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< * y=numpy_to_dvec_d(y), * Loss=c_loss, */ - if (!(likely(((__pyx_v_X) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_X, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 483, __pyx_L1_error) + if (!(likely(((__pyx_v_X) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_X, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 478, __pyx_L1_error) - /* "l0learn/interface.pyx":484 + /* "l0learn/interface.pyx":479 * if isinstance(X, np.ndarray): * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), * y=numpy_to_dvec_d(y), # <<<<<<<<<<<<<< * Loss=c_loss, * Penalty=c_penalty, */ - if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 484, __pyx_L1_error) + if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 479, __pyx_L1_error) - /* "l0learn/interface.pyx":488 + /* "l0learn/interface.pyx":483 * Penalty=c_penalty, * Algorithm=c_algorithim, * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< * G_ncols=num_lambda, * G_nrows=num_gamma, */ - __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 488, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_9 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 483, __pyx_L1_error) - /* "l0learn/interface.pyx":489 + /* "l0learn/interface.pyx":484 * Algorithm=c_algorithim, * NnzStopNum=max_support_size, * G_ncols=num_lambda, # <<<<<<<<<<<<<< * G_nrows=num_gamma, * Lambda2Max=gamma_max, */ - __pyx_t_16 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_16 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 489, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_10 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 484, __pyx_L1_error) - /* "l0learn/interface.pyx":490 + /* "l0learn/interface.pyx":485 * NnzStopNum=max_support_size, * G_ncols=num_lambda, * G_nrows=num_gamma, # <<<<<<<<<<<<<< * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, */ - __pyx_t_17 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_17 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 490, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_11 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 485, __pyx_L1_error) - /* "l0learn/interface.pyx":493 + /* "l0learn/interface.pyx":488 * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, * PartialSort=partial_sort, # <<<<<<<<<<<<<< * MaxIters=max_iter, * rtol=rtol, */ - __pyx_t_18 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_18 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 493, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_12 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 488, __pyx_L1_error) - /* "l0learn/interface.pyx":494 + /* "l0learn/interface.pyx":489 * Lambda2Min=gamma_min, * PartialSort=partial_sort, * MaxIters=max_iter, # <<<<<<<<<<<<<< * rtol=rtol, * atol=atol, */ - __pyx_t_19 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_19 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 494, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_13 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 489, __pyx_L1_error) - /* "l0learn/interface.pyx":497 + /* "l0learn/interface.pyx":492 * rtol=rtol, * atol=atol, * ActiveSet=active_set, # <<<<<<<<<<<<<< * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, */ - __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_20 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 497, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_14 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 492, __pyx_L1_error) - /* "l0learn/interface.pyx":498 + /* "l0learn/interface.pyx":493 * atol=atol, * ActiveSet=active_set, * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, */ - __pyx_t_21 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_21 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 498, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 493, __pyx_L1_error) - /* "l0learn/interface.pyx":499 + /* "l0learn/interface.pyx":494 * ActiveSet=active_set, * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, */ - __pyx_t_22 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_22 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 499, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_16 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 494, __pyx_L1_error) - /* "l0learn/interface.pyx":501 + /* "l0learn/interface.pyx":496 * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, # <<<<<<<<<<<<<< * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, */ - __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 501, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_17 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 496, __pyx_L1_error) - /* "l0learn/interface.pyx":502 + /* "l0learn/interface.pyx":497 * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, * LambdaU=not auto_lambda, # <<<<<<<<<<<<<< * Lambdas=c_lambda_grid, * ExcludeFirstK=exclude_first_k, */ - __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 502, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 497, __pyx_L1_error) - /* "l0learn/interface.pyx":504 + /* "l0learn/interface.pyx":499 * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< * Intercept=intercept, * withBounds=with_bounds, */ - __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 504, __pyx_L1_error) + __pyx_t_18 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_18 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 499, __pyx_L1_error) - /* "l0learn/interface.pyx":505 + /* "l0learn/interface.pyx":500 * Lambdas=c_lambda_grid, * ExcludeFirstK=exclude_first_k, * Intercept=intercept, # <<<<<<<<<<<<<< * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), */ - __pyx_t_25 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_25 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 505, __pyx_L1_error) + __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_19 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 500, __pyx_L1_error) - /* "l0learn/interface.pyx":506 + /* "l0learn/interface.pyx":501 * ExcludeFirstK=exclude_first_k, * Intercept=intercept, * withBounds=with_bounds, # <<<<<<<<<<<<<< * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) */ - __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 506, __pyx_L1_error) + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_20 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 501, __pyx_L1_error) - /* "l0learn/interface.pyx":507 + /* "l0learn/interface.pyx":502 * Intercept=intercept, * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< * Highs=numpy_to_dvec_d(highs)) * else: # isinstance(X, csc_matrix) */ - if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 507, __pyx_L1_error) + if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 502, __pyx_L1_error) - /* "l0learn/interface.pyx":508 + /* "l0learn/interface.pyx":503 * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< * else: # isinstance(X, csc_matrix) * c_results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), */ - if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 508, __pyx_L1_error) + if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 503, __pyx_L1_error) - /* "l0learn/interface.pyx":483 + /* "l0learn/interface.pyx":478 * cdef fitmodel c_results * if isinstance(X, np.ndarray): * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< * y=numpy_to_dvec_d(y), * Loss=c_loss, */ - __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnFit_dense(__pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_X)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_15, __pyx_t_16, __pyx_t_17, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_18, __pyx_t_19, __pyx_v_rtol, __pyx_v_atol, __pyx_t_20, __pyx_t_21, __pyx_t_22, __pyx_v_scale_down_factor, __pyx_t_23, (!__pyx_t_14), __pyx_v_c_lambda_grid, __pyx_t_24, __pyx_t_25, __pyx_t_26, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); + __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnFit_dense(__pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_X)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_9, __pyx_t_10, __pyx_t_11, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_12, __pyx_t_13, __pyx_v_rtol, __pyx_v_atol, __pyx_t_14, __pyx_t_15, __pyx_t_16, __pyx_v_scale_down_factor, __pyx_t_17, (!__pyx_t_8), __pyx_v_c_lambda_grid, __pyx_t_18, __pyx_t_19, __pyx_t_20, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); - /* "l0learn/interface.pyx":482 + /* "l0learn/interface.pyx":477 * * cdef fitmodel c_results * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), * y=numpy_to_dvec_d(y), */ - goto __pyx_L11; + goto __pyx_L3; } - /* "l0learn/interface.pyx":510 + /* "l0learn/interface.pyx":505 * Highs=numpy_to_dvec_d(highs)) * else: # isinstance(X, csc_matrix) * c_results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< @@ -7571,267 +7478,267 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ /*else*/ { - /* "l0learn/interface.pyx":511 + /* "l0learn/interface.pyx":506 * else: # isinstance(X, csc_matrix) * c_results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), * y=numpy_to_dvec_d(y), # <<<<<<<<<<<<<< * Loss=c_loss, * Penalty=c_penalty, */ - if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 511, __pyx_L1_error) + if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 506, __pyx_L1_error) - /* "l0learn/interface.pyx":515 + /* "l0learn/interface.pyx":510 * Penalty=c_penalty, * Algorithm=c_algorithim, * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< * G_ncols=num_lambda, * G_nrows=num_gamma, */ - __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 515, __pyx_L1_error) + __pyx_t_18 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_18 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 510, __pyx_L1_error) - /* "l0learn/interface.pyx":516 + /* "l0learn/interface.pyx":511 * Algorithm=c_algorithim, * NnzStopNum=max_support_size, * G_ncols=num_lambda, # <<<<<<<<<<<<<< * G_nrows=num_gamma, * Lambda2Max=gamma_max, */ - __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 516, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_17 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 511, __pyx_L1_error) - /* "l0learn/interface.pyx":517 + /* "l0learn/interface.pyx":512 * NnzStopNum=max_support_size, * G_ncols=num_lambda, * G_nrows=num_gamma, # <<<<<<<<<<<<<< * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, */ - __pyx_t_22 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_22 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 517, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_16 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 512, __pyx_L1_error) - /* "l0learn/interface.pyx":520 + /* "l0learn/interface.pyx":515 * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, * PartialSort=partial_sort, # <<<<<<<<<<<<<< * MaxIters=max_iter, * rtol=rtol, */ - __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 520, __pyx_L1_error) + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_20 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 515, __pyx_L1_error) - /* "l0learn/interface.pyx":521 + /* "l0learn/interface.pyx":516 * Lambda2Min=gamma_min, * PartialSort=partial_sort, * MaxIters=max_iter, # <<<<<<<<<<<<<< * rtol=rtol, * atol=atol, */ - __pyx_t_21 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_21 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 521, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 516, __pyx_L1_error) - /* "l0learn/interface.pyx":524 + /* "l0learn/interface.pyx":519 * rtol=rtol, * atol=atol, * ActiveSet=active_set, # <<<<<<<<<<<<<< * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, */ - __pyx_t_25 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_25 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 524, __pyx_L1_error) + __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_19 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 519, __pyx_L1_error) - /* "l0learn/interface.pyx":525 + /* "l0learn/interface.pyx":520 * atol=atol, * ActiveSet=active_set, * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, */ - __pyx_t_19 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_19 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 525, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_13 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 520, __pyx_L1_error) - /* "l0learn/interface.pyx":526 + /* "l0learn/interface.pyx":521 * ActiveSet=active_set, * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, */ - __pyx_t_17 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_17 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 526, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_11 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 521, __pyx_L1_error) - /* "l0learn/interface.pyx":528 + /* "l0learn/interface.pyx":523 * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, # <<<<<<<<<<<<<< * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, */ - __pyx_t_16 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_16 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 528, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_10 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 523, __pyx_L1_error) - /* "l0learn/interface.pyx":529 + /* "l0learn/interface.pyx":524 * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, * LambdaU=not auto_lambda, # <<<<<<<<<<<<<< * Lambdas=c_lambda_grid, * ExcludeFirstK=exclude_first_k, */ - __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 529, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 524, __pyx_L1_error) - /* "l0learn/interface.pyx":531 + /* "l0learn/interface.pyx":526 * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< * Intercept=intercept, * withBounds=with_bounds, */ - __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 531, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_9 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 526, __pyx_L1_error) - /* "l0learn/interface.pyx":532 + /* "l0learn/interface.pyx":527 * Lambdas=c_lambda_grid, * ExcludeFirstK=exclude_first_k, * Intercept=intercept, # <<<<<<<<<<<<<< * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), */ - __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_20 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 532, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_14 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 527, __pyx_L1_error) - /* "l0learn/interface.pyx":533 + /* "l0learn/interface.pyx":528 * ExcludeFirstK=exclude_first_k, * Intercept=intercept, * withBounds=with_bounds, # <<<<<<<<<<<<<< * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) */ - __pyx_t_18 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_18 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 533, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_12 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 528, __pyx_L1_error) - /* "l0learn/interface.pyx":534 + /* "l0learn/interface.pyx":529 * Intercept=intercept, * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< * Highs=numpy_to_dvec_d(highs)) * */ - if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 534, __pyx_L1_error) + if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 529, __pyx_L1_error) - /* "l0learn/interface.pyx":535 + /* "l0learn/interface.pyx":530 * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< * * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, */ - if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 535, __pyx_L1_error) + if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 530, __pyx_L1_error) - /* "l0learn/interface.pyx":510 + /* "l0learn/interface.pyx":505 * Highs=numpy_to_dvec_d(highs)) * else: # isinstance(X, csc_matrix) * c_results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< * y=numpy_to_dvec_d(y), * Loss=c_loss, */ - __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnFit_sparse(__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(__pyx_v_X), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_24, __pyx_t_23, __pyx_t_22, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_26, __pyx_t_21, __pyx_v_rtol, __pyx_v_atol, __pyx_t_25, __pyx_t_19, __pyx_t_17, __pyx_v_scale_down_factor, __pyx_t_16, (!__pyx_t_14), __pyx_v_c_lambda_grid, __pyx_t_15, __pyx_t_20, __pyx_t_18, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); + __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnFit_sparse(__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(__pyx_v_X), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_18, __pyx_t_17, __pyx_t_16, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_20, __pyx_t_15, __pyx_v_rtol, __pyx_v_atol, __pyx_t_19, __pyx_t_13, __pyx_t_11, __pyx_v_scale_down_factor, __pyx_t_10, (!__pyx_t_8), __pyx_v_c_lambda_grid, __pyx_t_9, __pyx_t_14, __pyx_t_12, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); } - __pyx_L11:; + __pyx_L3:; - /* "l0learn/interface.pyx":537 + /* "l0learn/interface.pyx":532 * Highs=numpy_to_dvec_d(highs)) * * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, # <<<<<<<<<<<<<< * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_FitModel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 537, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_FitModel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 532, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 537, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 537, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 532, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 537, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 537, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 537, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_settings, __pyx_t_3) < 0) __PYX_ERR(0, 537, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 532, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_u_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 532, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_n_u_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 532, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_n_u_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 532, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_settings, __pyx_t_1) < 0) __PYX_ERR(0, 532, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":538 + /* "l0learn/interface.pyx":533 * * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, * lambda_0=c_results.Lambda0, # <<<<<<<<<<<<<< * gamma=c_results.Lambda12, * support_size=c_results.NnzCount, */ - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Lambda0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 538, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_lambda_0, __pyx_t_3) < 0) __PYX_ERR(0, 537, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Lambda0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 533, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_lambda_0, __pyx_t_1) < 0) __PYX_ERR(0, 532, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":539 + /* "l0learn/interface.pyx":534 * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, # <<<<<<<<<<<<<< * support_size=c_results.NnzCount, * coeffs=sp_dmat_field_to_list(c_results.Beta), */ - __pyx_t_3 = __pyx_convert_vector_to_py_double(__pyx_v_c_results.Lambda12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 539, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_gamma, __pyx_t_3) < 0) __PYX_ERR(0, 537, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __pyx_convert_vector_to_py_double(__pyx_v_c_results.Lambda12); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 534, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_gamma, __pyx_t_1) < 0) __PYX_ERR(0, 532, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":540 + /* "l0learn/interface.pyx":535 * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, * support_size=c_results.NnzCount, # <<<<<<<<<<<<<< * coeffs=sp_dmat_field_to_list(c_results.Beta), * intercepts=c_results.Intercept, */ - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(__pyx_v_c_results.NnzCount); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 540, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_support_size, __pyx_t_3) < 0) __PYX_ERR(0, 537, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(__pyx_v_c_results.NnzCount); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 535, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_support_size, __pyx_t_1) < 0) __PYX_ERR(0, 532, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":541 + /* "l0learn/interface.pyx":536 * gamma=c_results.Lambda12, * support_size=c_results.NnzCount, * coeffs=sp_dmat_field_to_list(c_results.Beta), # <<<<<<<<<<<<<< * intercepts=c_results.Intercept, * converged=c_results.Converged) */ - __pyx_t_3 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_c_results.Beta); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 541, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_coeffs, __pyx_t_3) < 0) __PYX_ERR(0, 537, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_c_results.Beta); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 536, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_coeffs, __pyx_t_1) < 0) __PYX_ERR(0, 532, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":542 + /* "l0learn/interface.pyx":537 * support_size=c_results.NnzCount, * coeffs=sp_dmat_field_to_list(c_results.Beta), * intercepts=c_results.Intercept, # <<<<<<<<<<<<<< * converged=c_results.Converged) * return results */ - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Intercept); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 542, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_intercepts, __pyx_t_3) < 0) __PYX_ERR(0, 537, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Intercept); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 537, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_intercepts, __pyx_t_1) < 0) __PYX_ERR(0, 532, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":543 + /* "l0learn/interface.pyx":538 * coeffs=sp_dmat_field_to_list(c_results.Beta), * intercepts=c_results.Intercept, * converged=c_results.Converged) # <<<<<<<<<<<<<< * return results * */ - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(__pyx_v_c_results.Converged); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 543, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_converged, __pyx_t_3) < 0) __PYX_ERR(0, 537, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(__pyx_v_c_results.Converged); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 538, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_converged, __pyx_t_1) < 0) __PYX_ERR(0, 532, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":537 + /* "l0learn/interface.pyx":532 * Highs=numpy_to_dvec_d(highs)) * * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, # <<<<<<<<<<<<<< * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 537, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 532, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_results = __pyx_t_3; - __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_results = __pyx_t_1; + __pyx_t_1 = 0; - /* "l0learn/interface.pyx":544 + /* "l0learn/interface.pyx":539 * intercepts=c_results.Intercept, * converged=c_results.Converged) * return results # <<<<<<<<<<<<<< @@ -7856,8 +7763,6 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_10); - __Pyx_XDECREF(__pyx_t_11); __Pyx_AddTraceback("l0learn.interface.fit", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -7879,7 +7784,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx return __pyx_r; } -/* "l0learn/interface.pyx":547 +/* "l0learn/interface.pyx":542 * * * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< @@ -7936,7 +7841,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj values[8] = ((PyObject *)__pyx_int_100); values[9] = ((PyObject *)__pyx_int_1); - /* "l0learn/interface.pyx":559 + /* "l0learn/interface.pyx":554 * gamma_max: float = 10., * gamma_min: float = .0001, * partial_sort: bool = True, # <<<<<<<<<<<<<< @@ -7946,7 +7851,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj values[12] = ((PyObject *)Py_True); values[13] = ((PyObject *)__pyx_int_200); - /* "l0learn/interface.pyx":563 + /* "l0learn/interface.pyx":558 * rtol: float = 1e-6, * atol: float = 1e-9, * active_set: bool = True, # <<<<<<<<<<<<<< @@ -7958,7 +7863,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj values[18] = ((PyObject *)__pyx_int_100); values[20] = ((PyObject *)__pyx_int_1000); - /* "l0learn/interface.pyx":568 + /* "l0learn/interface.pyx":563 * scale_down_factor: float = 0.8, * screen_size: int = 1000, * lambda_grid: Optional[List[List[float]]] = None, # <<<<<<<<<<<<<< @@ -7968,7 +7873,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj values[21] = ((PyObject *)Py_None); values[22] = ((PyObject *)__pyx_int_0); - /* "l0learn/interface.pyx":570 + /* "l0learn/interface.pyx":565 * lambda_grid: Optional[List[List[float]]] = None, * exclude_first_k: int = 0, * intercept: bool = True, # <<<<<<<<<<<<<< @@ -8046,7 +7951,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("cvfit", 0, 2, 26, 1); __PYX_ERR(0, 547, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("cvfit", 0, 2, 26, 1); __PYX_ERR(0, 542, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: @@ -8194,7 +8099,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "cvfit") < 0)) __PYX_ERR(0, 547, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "cvfit") < 0)) __PYX_ERR(0, 542, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -8263,24 +8168,24 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj __pyx_v_num_lambda = values[8]; __pyx_v_num_gamma = values[9]; if (values[10]) { - __pyx_v_gamma_max = __pyx_PyFloat_AsDouble(values[10]); if (unlikely((__pyx_v_gamma_max == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 557, __pyx_L3_error) + __pyx_v_gamma_max = __pyx_PyFloat_AsDouble(values[10]); if (unlikely((__pyx_v_gamma_max == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 552, __pyx_L3_error) } else { __pyx_v_gamma_max = ((double)10.); } if (values[11]) { - __pyx_v_gamma_min = __pyx_PyFloat_AsDouble(values[11]); if (unlikely((__pyx_v_gamma_min == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 558, __pyx_L3_error) + __pyx_v_gamma_min = __pyx_PyFloat_AsDouble(values[11]); if (unlikely((__pyx_v_gamma_min == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 553, __pyx_L3_error) } else { __pyx_v_gamma_min = ((double).0001); } __pyx_v_partial_sort = values[12]; __pyx_v_max_iter = values[13]; if (values[14]) { - __pyx_v_rtol = __pyx_PyFloat_AsDouble(values[14]); if (unlikely((__pyx_v_rtol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 561, __pyx_L3_error) + __pyx_v_rtol = __pyx_PyFloat_AsDouble(values[14]); if (unlikely((__pyx_v_rtol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 556, __pyx_L3_error) } else { __pyx_v_rtol = ((double)1e-6); } if (values[15]) { - __pyx_v_atol = __pyx_PyFloat_AsDouble(values[15]); if (unlikely((__pyx_v_atol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 562, __pyx_L3_error) + __pyx_v_atol = __pyx_PyFloat_AsDouble(values[15]); if (unlikely((__pyx_v_atol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 557, __pyx_L3_error) } else { __pyx_v_atol = ((double)1e-9); } @@ -8288,7 +8193,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj __pyx_v_active_set_num = values[17]; __pyx_v_max_swaps = values[18]; if (values[19]) { - __pyx_v_scale_down_factor = __pyx_PyFloat_AsDouble(values[19]); if (unlikely((__pyx_v_scale_down_factor == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 566, __pyx_L3_error) + __pyx_v_scale_down_factor = __pyx_PyFloat_AsDouble(values[19]); if (unlikely((__pyx_v_scale_down_factor == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 561, __pyx_L3_error) } else { __pyx_v_scale_down_factor = ((double)0.8); } @@ -8301,18 +8206,18 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("cvfit", 0, 2, 26, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 547, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("cvfit", 0, 2, 26, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 542, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("l0learn.interface.cvfit", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loss), (&PyUnicode_Type), 1, "loss", 1))) __PYX_ERR(0, 549, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_penalty), (&PyUnicode_Type), 1, "penalty", 1))) __PYX_ERR(0, 550, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_algorithm), (&PyUnicode_Type), 1, "algorithm", 1))) __PYX_ERR(0, 551, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loss), (&PyUnicode_Type), 1, "loss", 1))) __PYX_ERR(0, 544, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_penalty), (&PyUnicode_Type), 1, "penalty", 1))) __PYX_ERR(0, 545, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_algorithm), (&PyUnicode_Type), 1, "algorithm", 1))) __PYX_ERR(0, 546, __pyx_L1_error) __pyx_r = __pyx_pf_7l0learn_9interface_4cvfit(__pyx_self, __pyx_v_X, __pyx_v_y, __pyx_v_loss, __pyx_v_penalty, __pyx_v_algorithm, __pyx_v_num_folds, __pyx_v_seed, __pyx_v_max_support_size, __pyx_v_num_lambda, __pyx_v_num_gamma, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_v_partial_sort, __pyx_v_max_iter, __pyx_v_rtol, __pyx_v_atol, __pyx_v_active_set, __pyx_v_active_set_num, __pyx_v_max_swaps, __pyx_v_scale_down_factor, __pyx_v_screen_size, __pyx_v_lambda_grid, __pyx_v_exclude_first_k, __pyx_v_intercept, __pyx_v_lows, __pyx_v_highs); - /* "l0learn/interface.pyx":547 + /* "l0learn/interface.pyx":542 * * * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< @@ -8354,26 +8259,21 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p int __pyx_t_9; Py_ssize_t __pyx_t_10; Py_UCS4 __pyx_t_11; - PyObject *__pyx_t_12 = NULL; - PyObject *__pyx_t_13 = NULL; - PyObject *__pyx_t_14 = NULL; - std::vector > __pyx_t_15; - int __pyx_t_16; - PyObject *__pyx_t_17 = NULL; - std::string __pyx_t_18; - size_t __pyx_t_19; + std::vector > __pyx_t_12; + std::string __pyx_t_13; + size_t __pyx_t_14; + size_t __pyx_t_15; + size_t __pyx_t_16; + bool __pyx_t_17; + size_t __pyx_t_18; + bool __pyx_t_19; size_t __pyx_t_20; size_t __pyx_t_21; - bool __pyx_t_22; - size_t __pyx_t_23; - bool __pyx_t_24; - size_t __pyx_t_25; - size_t __pyx_t_26; - size_t __pyx_t_27; - unsigned int __pyx_t_28; - size_t __pyx_t_29; - bool __pyx_t_30; - bool __pyx_t_31; + size_t __pyx_t_22; + unsigned int __pyx_t_23; + size_t __pyx_t_24; + bool __pyx_t_25; + bool __pyx_t_26; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; @@ -8388,422 +8288,422 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_INCREF(__pyx_v_lows); __Pyx_INCREF(__pyx_v_highs); - /* "l0learn/interface.pyx":574 + /* "l0learn/interface.pyx":569 * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.CVFitModel: * * check = _fit_check(X=X, # <<<<<<<<<<<<<< * y=y, * loss=loss, */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_fit_check); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 574, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_fit_check); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 569, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyDict_NewPresized(24); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 574, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyDict_NewPresized(24); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 569, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_X, __pyx_v_X) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_X, __pyx_v_X) < 0) __PYX_ERR(0, 569, __pyx_L1_error) - /* "l0learn/interface.pyx":575 + /* "l0learn/interface.pyx":570 * * check = _fit_check(X=X, * y=y, # <<<<<<<<<<<<<< * loss=loss, * penalty=penalty, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_y, __pyx_v_y) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_y, __pyx_v_y) < 0) __PYX_ERR(0, 569, __pyx_L1_error) - /* "l0learn/interface.pyx":576 + /* "l0learn/interface.pyx":571 * check = _fit_check(X=X, * y=y, * loss=loss, # <<<<<<<<<<<<<< * penalty=penalty, * algorithm=algorithm, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 569, __pyx_L1_error) - /* "l0learn/interface.pyx":577 + /* "l0learn/interface.pyx":572 * y=y, * loss=loss, * penalty=penalty, # <<<<<<<<<<<<<< * algorithm=algorithm, * max_support_size=max_support_size, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 569, __pyx_L1_error) - /* "l0learn/interface.pyx":578 + /* "l0learn/interface.pyx":573 * loss=loss, * penalty=penalty, * algorithm=algorithm, # <<<<<<<<<<<<<< * max_support_size=max_support_size, * num_lambda=num_lambda, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_algorithm, __pyx_v_algorithm) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_algorithm, __pyx_v_algorithm) < 0) __PYX_ERR(0, 569, __pyx_L1_error) - /* "l0learn/interface.pyx":579 + /* "l0learn/interface.pyx":574 * penalty=penalty, * algorithm=algorithm, * max_support_size=max_support_size, # <<<<<<<<<<<<<< * num_lambda=num_lambda, * num_gamma=num_gamma, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_support_size, __pyx_v_max_support_size) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_support_size, __pyx_v_max_support_size) < 0) __PYX_ERR(0, 569, __pyx_L1_error) - /* "l0learn/interface.pyx":580 + /* "l0learn/interface.pyx":575 * algorithm=algorithm, * max_support_size=max_support_size, * num_lambda=num_lambda, # <<<<<<<<<<<<<< * num_gamma=num_gamma, * gamma_max=gamma_max, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_lambda, __pyx_v_num_lambda) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_lambda, __pyx_v_num_lambda) < 0) __PYX_ERR(0, 569, __pyx_L1_error) - /* "l0learn/interface.pyx":581 + /* "l0learn/interface.pyx":576 * max_support_size=max_support_size, * num_lambda=num_lambda, * num_gamma=num_gamma, # <<<<<<<<<<<<<< * gamma_max=gamma_max, * gamma_min=gamma_min, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_gamma, __pyx_v_num_gamma) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_gamma, __pyx_v_num_gamma) < 0) __PYX_ERR(0, 569, __pyx_L1_error) - /* "l0learn/interface.pyx":582 + /* "l0learn/interface.pyx":577 * num_lambda=num_lambda, * num_gamma=num_gamma, * gamma_max=gamma_max, # <<<<<<<<<<<<<< * gamma_min=gamma_min, * partial_sort=partial_sort, */ - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 582, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 577, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma_max, __pyx_t_3) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma_max, __pyx_t_3) < 0) __PYX_ERR(0, 569, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":583 + /* "l0learn/interface.pyx":578 * num_gamma=num_gamma, * gamma_max=gamma_max, * gamma_min=gamma_min, # <<<<<<<<<<<<<< * partial_sort=partial_sort, * max_iter=max_iter, */ - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 583, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 578, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma_min, __pyx_t_3) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma_min, __pyx_t_3) < 0) __PYX_ERR(0, 569, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":584 + /* "l0learn/interface.pyx":579 * gamma_max=gamma_max, * gamma_min=gamma_min, * partial_sort=partial_sort, # <<<<<<<<<<<<<< * max_iter=max_iter, * rtol=rtol, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_partial_sort, __pyx_v_partial_sort) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_partial_sort, __pyx_v_partial_sort) < 0) __PYX_ERR(0, 569, __pyx_L1_error) - /* "l0learn/interface.pyx":585 + /* "l0learn/interface.pyx":580 * gamma_min=gamma_min, * partial_sort=partial_sort, * max_iter=max_iter, # <<<<<<<<<<<<<< * rtol=rtol, * atol=atol, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_iter, __pyx_v_max_iter) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_iter, __pyx_v_max_iter) < 0) __PYX_ERR(0, 569, __pyx_L1_error) - /* "l0learn/interface.pyx":586 + /* "l0learn/interface.pyx":581 * partial_sort=partial_sort, * max_iter=max_iter, * rtol=rtol, # <<<<<<<<<<<<<< * atol=atol, * active_set=active_set, */ - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_rtol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 586, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_rtol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 581, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_rtol, __pyx_t_3) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_rtol, __pyx_t_3) < 0) __PYX_ERR(0, 569, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":587 + /* "l0learn/interface.pyx":582 * max_iter=max_iter, * rtol=rtol, * atol=atol, # <<<<<<<<<<<<<< * active_set=active_set, * active_set_num=active_set_num, */ - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_atol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 587, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_atol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 582, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_atol, __pyx_t_3) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_atol, __pyx_t_3) < 0) __PYX_ERR(0, 569, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":588 + /* "l0learn/interface.pyx":583 * rtol=rtol, * atol=atol, * active_set=active_set, # <<<<<<<<<<<<<< * active_set_num=active_set_num, * max_swaps=max_swaps, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_active_set, __pyx_v_active_set) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_active_set, __pyx_v_active_set) < 0) __PYX_ERR(0, 569, __pyx_L1_error) - /* "l0learn/interface.pyx":589 + /* "l0learn/interface.pyx":584 * atol=atol, * active_set=active_set, * active_set_num=active_set_num, # <<<<<<<<<<<<<< * max_swaps=max_swaps, * scale_down_factor=scale_down_factor, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_active_set_num, __pyx_v_active_set_num) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_active_set_num, __pyx_v_active_set_num) < 0) __PYX_ERR(0, 569, __pyx_L1_error) - /* "l0learn/interface.pyx":590 + /* "l0learn/interface.pyx":585 * active_set=active_set, * active_set_num=active_set_num, * max_swaps=max_swaps, # <<<<<<<<<<<<<< * scale_down_factor=scale_down_factor, * screen_size=screen_size, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_swaps, __pyx_v_max_swaps) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_swaps, __pyx_v_max_swaps) < 0) __PYX_ERR(0, 569, __pyx_L1_error) - /* "l0learn/interface.pyx":591 + /* "l0learn/interface.pyx":586 * active_set_num=active_set_num, * max_swaps=max_swaps, * scale_down_factor=scale_down_factor, # <<<<<<<<<<<<<< * screen_size=screen_size, * lambda_grid=lambda_grid, */ - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_scale_down_factor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 591, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_scale_down_factor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 586, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_scale_down_factor, __pyx_t_3) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_scale_down_factor, __pyx_t_3) < 0) __PYX_ERR(0, 569, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":592 + /* "l0learn/interface.pyx":587 * max_swaps=max_swaps, * scale_down_factor=scale_down_factor, * screen_size=screen_size, # <<<<<<<<<<<<<< * lambda_grid=lambda_grid, * exclude_first_k=exclude_first_k, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_screen_size, __pyx_v_screen_size) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_screen_size, __pyx_v_screen_size) < 0) __PYX_ERR(0, 569, __pyx_L1_error) - /* "l0learn/interface.pyx":593 + /* "l0learn/interface.pyx":588 * scale_down_factor=scale_down_factor, * screen_size=screen_size, * lambda_grid=lambda_grid, # <<<<<<<<<<<<<< * exclude_first_k=exclude_first_k, * intercept=intercept, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lambda_grid, __pyx_v_lambda_grid) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lambda_grid, __pyx_v_lambda_grid) < 0) __PYX_ERR(0, 569, __pyx_L1_error) - /* "l0learn/interface.pyx":594 + /* "l0learn/interface.pyx":589 * screen_size=screen_size, * lambda_grid=lambda_grid, * exclude_first_k=exclude_first_k, # <<<<<<<<<<<<<< * intercept=intercept, * lows=lows, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_exclude_first_k, __pyx_v_exclude_first_k) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_exclude_first_k, __pyx_v_exclude_first_k) < 0) __PYX_ERR(0, 569, __pyx_L1_error) - /* "l0learn/interface.pyx":595 + /* "l0learn/interface.pyx":590 * lambda_grid=lambda_grid, * exclude_first_k=exclude_first_k, * intercept=intercept, # <<<<<<<<<<<<<< * lows=lows, * highs=highs) */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 569, __pyx_L1_error) - /* "l0learn/interface.pyx":596 + /* "l0learn/interface.pyx":591 * exclude_first_k=exclude_first_k, * intercept=intercept, * lows=lows, # <<<<<<<<<<<<<< * highs=highs) * */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lows, __pyx_v_lows) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lows, __pyx_v_lows) < 0) __PYX_ERR(0, 569, __pyx_L1_error) - /* "l0learn/interface.pyx":597 + /* "l0learn/interface.pyx":592 * intercept=intercept, * lows=lows, * highs=highs) # <<<<<<<<<<<<<< * * max_support_size = check["max_support_size"] */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_highs, __pyx_v_highs) < 0) __PYX_ERR(0, 574, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_highs, __pyx_v_highs) < 0) __PYX_ERR(0, 569, __pyx_L1_error) - /* "l0learn/interface.pyx":574 + /* "l0learn/interface.pyx":569 * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.CVFitModel: * * check = _fit_check(X=X, # <<<<<<<<<<<<<< * y=y, * loss=loss, */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 574, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 569, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_check = __pyx_t_3; __pyx_t_3 = 0; - /* "l0learn/interface.pyx":599 + /* "l0learn/interface.pyx":594 * highs=highs) * * max_support_size = check["max_support_size"] # <<<<<<<<<<<<<< * screen_size = check["screen_size"] * y = check['y'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_max_support_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 599, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_max_support_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 594, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_max_support_size, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":600 + /* "l0learn/interface.pyx":595 * * max_support_size = check["max_support_size"] * screen_size = check["screen_size"] # <<<<<<<<<<<<<< * y = check['y'] * penalty = check['penalty'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_screen_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 600, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_screen_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 595, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_screen_size, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":601 + /* "l0learn/interface.pyx":596 * max_support_size = check["max_support_size"] * screen_size = check["screen_size"] * y = check['y'] # <<<<<<<<<<<<<< * penalty = check['penalty'] * gamma_max = check['gamma_max'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_y); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 601, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_y); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 596, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_y, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":602 + /* "l0learn/interface.pyx":597 * screen_size = check["screen_size"] * y = check['y'] * penalty = check['penalty'] # <<<<<<<<<<<<<< * gamma_max = check['gamma_max'] * gamma_min = check['gamma_min'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_penalty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 602, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_penalty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 597, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (!(likely(PyUnicode_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(0, 602, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(0, 597, __pyx_L1_error) __Pyx_DECREF_SET(__pyx_v_penalty, ((PyObject*)__pyx_t_3)); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":603 + /* "l0learn/interface.pyx":598 * y = check['y'] * penalty = check['penalty'] * gamma_max = check['gamma_max'] # <<<<<<<<<<<<<< * gamma_min = check['gamma_min'] * lambda_grid = check['lambda_grid'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 603, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 598, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 603, __pyx_L1_error) + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 598, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_gamma_max = __pyx_t_4; - /* "l0learn/interface.pyx":604 + /* "l0learn/interface.pyx":599 * penalty = check['penalty'] * gamma_max = check['gamma_max'] * gamma_min = check['gamma_min'] # <<<<<<<<<<<<<< * lambda_grid = check['lambda_grid'] * num_gamma = check['num_gamma'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_gamma_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 604, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_gamma_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 599, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 604, __pyx_L1_error) + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 599, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_gamma_min = __pyx_t_4; - /* "l0learn/interface.pyx":605 + /* "l0learn/interface.pyx":600 * gamma_max = check['gamma_max'] * gamma_min = check['gamma_min'] * lambda_grid = check['lambda_grid'] # <<<<<<<<<<<<<< * num_gamma = check['num_gamma'] * num_lambda = check['num_lambda'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_lambda_grid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 605, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_lambda_grid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 600, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_lambda_grid, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":606 + /* "l0learn/interface.pyx":601 * gamma_min = check['gamma_min'] * lambda_grid = check['lambda_grid'] * num_gamma = check['num_gamma'] # <<<<<<<<<<<<<< * num_lambda = check['num_lambda'] * auto_lambda = check['auto_lambda'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_num_gamma); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 606, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_num_gamma); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 601, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_num_gamma, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":607 + /* "l0learn/interface.pyx":602 * lambda_grid = check['lambda_grid'] * num_gamma = check['num_gamma'] * num_lambda = check['num_lambda'] # <<<<<<<<<<<<<< * auto_lambda = check['auto_lambda'] * with_bounds = check['with_bounds'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_num_lambda); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 607, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_num_lambda); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 602, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_num_lambda, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":608 + /* "l0learn/interface.pyx":603 * num_gamma = check['num_gamma'] * num_lambda = check['num_lambda'] * auto_lambda = check['auto_lambda'] # <<<<<<<<<<<<<< * with_bounds = check['with_bounds'] * lows = check['lows'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_auto_lambda); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 608, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_auto_lambda); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 603, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_auto_lambda = __pyx_t_3; __pyx_t_3 = 0; - /* "l0learn/interface.pyx":609 + /* "l0learn/interface.pyx":604 * num_lambda = check['num_lambda'] * auto_lambda = check['auto_lambda'] * with_bounds = check['with_bounds'] # <<<<<<<<<<<<<< * lows = check['lows'] * highs = check['highs'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_with_bounds); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 609, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_with_bounds); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 604, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_with_bounds = __pyx_t_3; __pyx_t_3 = 0; - /* "l0learn/interface.pyx":610 + /* "l0learn/interface.pyx":605 * auto_lambda = check['auto_lambda'] * with_bounds = check['with_bounds'] * lows = check['lows'] # <<<<<<<<<<<<<< * highs = check['highs'] * */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_lows); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 610, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_lows); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 605, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":611 + /* "l0learn/interface.pyx":606 * with_bounds = check['with_bounds'] * lows = check['lows'] * highs = check['highs'] # <<<<<<<<<<<<<< * * _, p = X.shape */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_highs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 611, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_highs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 606, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":613 + /* "l0learn/interface.pyx":608 * highs = check['highs'] * * _, p = X.shape # <<<<<<<<<<<<<< * * if not isinstance(num_folds, int) or num_folds < 2 or num_folds > p: */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 613, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 608, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { PyObject* sequence = __pyx_t_3; @@ -8811,7 +8711,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 613, __pyx_L1_error) + __PYX_ERR(0, 608, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { @@ -8824,15 +8724,15 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(__pyx_t_1); #else - __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 613, __pyx_L1_error) + __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 608, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 613, __pyx_L1_error) + __pyx_t_1 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 608, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { Py_ssize_t index = -1; - __pyx_t_5 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 613, __pyx_L1_error) + __pyx_t_5 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 608, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext; @@ -8840,7 +8740,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_GOTREF(__pyx_t_2); index = 1; __pyx_t_1 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_1)) goto __pyx_L3_unpacking_failed; __Pyx_GOTREF(__pyx_t_1); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 2) < 0) __PYX_ERR(0, 613, __pyx_L1_error) + if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 2) < 0) __PYX_ERR(0, 608, __pyx_L1_error) __pyx_t_6 = NULL; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L4_unpacking_done; @@ -8848,7 +8748,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_6 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 613, __pyx_L1_error) + __PYX_ERR(0, 608, __pyx_L1_error) __pyx_L4_unpacking_done:; } __pyx_v__ = __pyx_t_2; @@ -8856,7 +8756,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_v_p = __pyx_t_1; __pyx_t_1 = 0; - /* "l0learn/interface.pyx":615 + /* "l0learn/interface.pyx":610 * _, p = X.shape * * if not isinstance(num_folds, int) or num_folds < 2 or num_folds > p: # <<<<<<<<<<<<<< @@ -8870,29 +8770,29 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_7 = __pyx_t_9; goto __pyx_L6_bool_binop_done; } - __pyx_t_3 = PyObject_RichCompare(__pyx_v_num_folds, __pyx_int_2, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 615, __pyx_L1_error) - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 615, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_num_folds, __pyx_int_2, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 610, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 610, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (!__pyx_t_9) { } else { __pyx_t_7 = __pyx_t_9; goto __pyx_L6_bool_binop_done; } - __pyx_t_3 = PyObject_RichCompare(__pyx_v_num_folds, __pyx_v_p, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 615, __pyx_L1_error) - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 615, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_num_folds, __pyx_v_p, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 610, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 610, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_7 = __pyx_t_9; __pyx_L6_bool_binop_done:; if (unlikely(__pyx_t_7)) { - /* "l0learn/interface.pyx":616 + /* "l0learn/interface.pyx":611 * * if not isinstance(num_folds, int) or num_folds < 2 or num_folds > p: * raise ValueError(f"expected num_folds parameter to be a positive integer less than {p}, but got {num_folds}") # <<<<<<<<<<<<<< * * */ - __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 616, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 611, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_10 = 0; __pyx_t_11 = 127; @@ -8900,7 +8800,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_10 += 64; __Pyx_GIVEREF(__pyx_kp_u_expected_num_folds_parameter_to); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_num_folds_parameter_to); - __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 616, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 611, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_11 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) > __pyx_t_11) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) : __pyx_t_11; __pyx_t_10 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1); @@ -8911,24 +8811,24 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_10 += 10; __Pyx_GIVEREF(__pyx_kp_u_but_got); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_but_got); - __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_num_folds, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 616, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_num_folds, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 611, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_11 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) > __pyx_t_11) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) : __pyx_t_11; __pyx_t_10 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_10, __pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 616, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_10, __pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 611, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 616, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 611, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 616, __pyx_L1_error) + __PYX_ERR(0, 611, __pyx_L1_error) - /* "l0learn/interface.pyx":615 + /* "l0learn/interface.pyx":610 * _, p = X.shape * * if not isinstance(num_folds, int) or num_folds < 2 or num_folds > p: # <<<<<<<<<<<<<< @@ -8937,121 +8837,35 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ } - /* "l0learn/interface.pyx":620 - * - * cdef vector[vector[double]] c_lambda_grid - * try: # <<<<<<<<<<<<<< - * c_lambda_grid = lambda_grid - * except TypeError: - */ - { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ExceptionSave(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14); - __Pyx_XGOTREF(__pyx_t_12); - __Pyx_XGOTREF(__pyx_t_13); - __Pyx_XGOTREF(__pyx_t_14); - /*try:*/ { - - /* "l0learn/interface.pyx":621 - * cdef vector[vector[double]] c_lambda_grid - * try: - * c_lambda_grid = lambda_grid # <<<<<<<<<<<<<< - * except TypeError: - * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") - */ - __pyx_t_15 = __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_lambda_grid); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 621, __pyx_L9_error) - __pyx_v_c_lambda_grid = __pyx_t_15; - - /* "l0learn/interface.pyx":620 - * - * cdef vector[vector[double]] c_lambda_grid - * try: # <<<<<<<<<<<<<< - * c_lambda_grid = lambda_grid - * except TypeError: - */ - } - __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; - __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; - __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; - goto __pyx_L14_try_end; - __pyx_L9_error:; - __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - - /* "l0learn/interface.pyx":622 - * try: - * c_lambda_grid = lambda_grid - * except TypeError: # <<<<<<<<<<<<<< - * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") + /* "l0learn/interface.pyx":614 * - */ - __pyx_t_16 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); - if (__pyx_t_16) { - __Pyx_AddTraceback("l0learn.interface.cvfit", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_1, &__pyx_t_2) < 0) __PYX_ERR(0, 622, __pyx_L11_except_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_t_2); - - /* "l0learn/interface.pyx":623 - * c_lambda_grid = lambda_grid - * except TypeError: - * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") # <<<<<<<<<<<<<< * + * cdef vector[vector[double]] c_lambda_grid = lambda_grid # <<<<<<<<<<<<<< * cdef string c_loss = loss.encode('UTF-8') + * cdef string c_penalty = penalty.encode('UTF-8') */ - __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_v_lambda_grid, __pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 623, __pyx_L11_except_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_17 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_lambda_grid_to_be_a_lis, __pyx_t_5); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 623, __pyx_L11_except_error) - __Pyx_GOTREF(__pyx_t_17); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_17); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 623, __pyx_L11_except_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; - __Pyx_Raise(__pyx_t_5, 0, 0, 0); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __PYX_ERR(0, 623, __pyx_L11_except_error) - } - goto __pyx_L11_except_error; - __pyx_L11_except_error:; - - /* "l0learn/interface.pyx":620 - * - * cdef vector[vector[double]] c_lambda_grid - * try: # <<<<<<<<<<<<<< - * c_lambda_grid = lambda_grid - * except TypeError: - */ - __Pyx_XGIVEREF(__pyx_t_12); - __Pyx_XGIVEREF(__pyx_t_13); - __Pyx_XGIVEREF(__pyx_t_14); - __Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14); - goto __pyx_L1_error; - __pyx_L14_try_end:; - } + __pyx_t_12 = __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_lambda_grid); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 614, __pyx_L1_error) + __pyx_v_c_lambda_grid = __pyx_t_12; - /* "l0learn/interface.pyx":625 - * raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") + /* "l0learn/interface.pyx":615 * + * cdef vector[vector[double]] c_lambda_grid = lambda_grid * cdef string c_loss = loss.encode('UTF-8') # <<<<<<<<<<<<<< * cdef string c_penalty = penalty.encode('UTF-8') * cdef string c_algorithim = algorithm.encode('UTF-8') */ if (unlikely(__pyx_v_loss == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 625, __pyx_L1_error) + __PYX_ERR(0, 615, __pyx_L1_error) } - __pyx_t_2 = PyUnicode_AsUTF8String(__pyx_v_loss); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 625, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_18 = __pyx_convert_string_from_py_std__in_string(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 625, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v_c_loss = __pyx_t_18; + __pyx_t_3 = PyUnicode_AsUTF8String(__pyx_v_loss); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 615, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_13 = __pyx_convert_string_from_py_std__in_string(__pyx_t_3); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 615, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_c_loss = __pyx_t_13; - /* "l0learn/interface.pyx":626 - * + /* "l0learn/interface.pyx":616 + * cdef vector[vector[double]] c_lambda_grid = lambda_grid * cdef string c_loss = loss.encode('UTF-8') * cdef string c_penalty = penalty.encode('UTF-8') # <<<<<<<<<<<<<< * cdef string c_algorithim = algorithm.encode('UTF-8') @@ -9059,15 +8873,15 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ if (unlikely(__pyx_v_penalty == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 626, __pyx_L1_error) + __PYX_ERR(0, 616, __pyx_L1_error) } - __pyx_t_2 = PyUnicode_AsUTF8String(__pyx_v_penalty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 626, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_18 = __pyx_convert_string_from_py_std__in_string(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 626, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v_c_penalty = __pyx_t_18; + __pyx_t_3 = PyUnicode_AsUTF8String(__pyx_v_penalty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_13 = __pyx_convert_string_from_py_std__in_string(__pyx_t_3); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 616, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_c_penalty = __pyx_t_13; - /* "l0learn/interface.pyx":627 + /* "l0learn/interface.pyx":617 * cdef string c_loss = loss.encode('UTF-8') * cdef string c_penalty = penalty.encode('UTF-8') * cdef string c_algorithim = algorithm.encode('UTF-8') # <<<<<<<<<<<<<< @@ -9076,222 +8890,222 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ if (unlikely(__pyx_v_algorithm == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 627, __pyx_L1_error) + __PYX_ERR(0, 617, __pyx_L1_error) } - __pyx_t_2 = PyUnicode_AsUTF8String(__pyx_v_algorithm); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 627, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_18 = __pyx_convert_string_from_py_std__in_string(__pyx_t_2); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 627, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v_c_algorithim = __pyx_t_18; + __pyx_t_3 = PyUnicode_AsUTF8String(__pyx_v_algorithm); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 617, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_13 = __pyx_convert_string_from_py_std__in_string(__pyx_t_3); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 617, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_c_algorithim = __pyx_t_13; - /* "l0learn/interface.pyx":630 + /* "l0learn/interface.pyx":620 * * cdef cvfitmodel c_results * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), * y=numpy_to_dvec_d(y), */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 630, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 630, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 620, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 620, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_7 = PyObject_IsInstance(__pyx_v_X, __pyx_t_1); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 630, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = PyObject_IsInstance(__pyx_v_X, __pyx_t_1); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 620, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_9 = (__pyx_t_7 != 0); if (__pyx_t_9) { - /* "l0learn/interface.pyx":631 + /* "l0learn/interface.pyx":621 * cdef cvfitmodel c_results * if isinstance(X, np.ndarray): * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< * y=numpy_to_dvec_d(y), * Loss=c_loss, */ - if (!(likely(((__pyx_v_X) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_X, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 631, __pyx_L1_error) + if (!(likely(((__pyx_v_X) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_X, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 621, __pyx_L1_error) - /* "l0learn/interface.pyx":632 + /* "l0learn/interface.pyx":622 * if isinstance(X, np.ndarray): * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), * y=numpy_to_dvec_d(y), # <<<<<<<<<<<<<< * Loss=c_loss, * Penalty=c_penalty, */ - if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 632, __pyx_L1_error) + if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 622, __pyx_L1_error) - /* "l0learn/interface.pyx":636 + /* "l0learn/interface.pyx":626 * Penalty=c_penalty, * Algorithm=c_algorithim, * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< * G_ncols=num_lambda, * G_nrows=num_gamma, */ - __pyx_t_19 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_19 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 636, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_14 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 626, __pyx_L1_error) - /* "l0learn/interface.pyx":637 + /* "l0learn/interface.pyx":627 * Algorithm=c_algorithim, * NnzStopNum=max_support_size, * G_ncols=num_lambda, # <<<<<<<<<<<<<< * G_nrows=num_gamma, * Lambda2Max=gamma_max, */ - __pyx_t_20 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_20 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 637, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 627, __pyx_L1_error) - /* "l0learn/interface.pyx":638 + /* "l0learn/interface.pyx":628 * NnzStopNum=max_support_size, * G_ncols=num_lambda, * G_nrows=num_gamma, # <<<<<<<<<<<<<< * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, */ - __pyx_t_21 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_21 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 638, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_16 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 628, __pyx_L1_error) - /* "l0learn/interface.pyx":641 + /* "l0learn/interface.pyx":631 * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, * PartialSort=partial_sort, # <<<<<<<<<<<<<< * MaxIters=max_iter, * rtol=rtol, */ - __pyx_t_22 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_22 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 641, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_17 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 631, __pyx_L1_error) - /* "l0learn/interface.pyx":642 + /* "l0learn/interface.pyx":632 * Lambda2Min=gamma_min, * PartialSort=partial_sort, * MaxIters=max_iter, # <<<<<<<<<<<<<< * rtol=rtol, * atol=atol, */ - __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 642, __pyx_L1_error) + __pyx_t_18 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_18 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 632, __pyx_L1_error) - /* "l0learn/interface.pyx":645 + /* "l0learn/interface.pyx":635 * rtol=rtol, * atol=atol, * ActiveSet=active_set, # <<<<<<<<<<<<<< * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, */ - __pyx_t_24 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_24 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 645, __pyx_L1_error) + __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_19 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 635, __pyx_L1_error) - /* "l0learn/interface.pyx":646 + /* "l0learn/interface.pyx":636 * atol=atol, * ActiveSet=active_set, * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, */ - __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 646, __pyx_L1_error) + __pyx_t_20 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_20 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 636, __pyx_L1_error) - /* "l0learn/interface.pyx":647 + /* "l0learn/interface.pyx":637 * ActiveSet=active_set, * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, */ - __pyx_t_26 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_26 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 647, __pyx_L1_error) + __pyx_t_21 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_21 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 637, __pyx_L1_error) - /* "l0learn/interface.pyx":649 + /* "l0learn/interface.pyx":639 * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, # <<<<<<<<<<<<<< * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, */ - __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 649, __pyx_L1_error) + __pyx_t_22 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_22 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 639, __pyx_L1_error) - /* "l0learn/interface.pyx":650 + /* "l0learn/interface.pyx":640 * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, * LambdaU=not auto_lambda, # <<<<<<<<<<<<<< * Lambdas=c_lambda_grid, * nfolds=num_folds, */ - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 650, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 640, __pyx_L1_error) - /* "l0learn/interface.pyx":652 + /* "l0learn/interface.pyx":642 * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, * nfolds=num_folds, # <<<<<<<<<<<<<< * seed=seed, * ExcludeFirstK=exclude_first_k, */ - __pyx_t_28 = __Pyx_PyInt_As_unsigned_int(__pyx_v_num_folds); if (unlikely((__pyx_t_28 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 652, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyInt_As_unsigned_int(__pyx_v_num_folds); if (unlikely((__pyx_t_23 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 642, __pyx_L1_error) - /* "l0learn/interface.pyx":653 + /* "l0learn/interface.pyx":643 * Lambdas=c_lambda_grid, * nfolds=num_folds, * seed=seed, # <<<<<<<<<<<<<< * ExcludeFirstK=exclude_first_k, * Intercept=intercept, */ - __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_seed); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 653, __pyx_L1_error) + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_seed); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 643, __pyx_L1_error) - /* "l0learn/interface.pyx":654 + /* "l0learn/interface.pyx":644 * nfolds=num_folds, * seed=seed, * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< * Intercept=intercept, * withBounds=with_bounds, */ - __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 654, __pyx_L1_error) + __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 644, __pyx_L1_error) - /* "l0learn/interface.pyx":655 + /* "l0learn/interface.pyx":645 * seed=seed, * ExcludeFirstK=exclude_first_k, * Intercept=intercept, # <<<<<<<<<<<<<< * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), */ - __pyx_t_30 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_30 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 655, __pyx_L1_error) + __pyx_t_25 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_25 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 645, __pyx_L1_error) - /* "l0learn/interface.pyx":656 + /* "l0learn/interface.pyx":646 * ExcludeFirstK=exclude_first_k, * Intercept=intercept, * withBounds=with_bounds, # <<<<<<<<<<<<<< * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) */ - __pyx_t_31 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_31 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 656, __pyx_L1_error) + __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 646, __pyx_L1_error) - /* "l0learn/interface.pyx":657 + /* "l0learn/interface.pyx":647 * Intercept=intercept, * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< * Highs=numpy_to_dvec_d(highs)) * else: # isinstance(X, csc_matrix) */ - if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 657, __pyx_L1_error) + if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 647, __pyx_L1_error) - /* "l0learn/interface.pyx":658 + /* "l0learn/interface.pyx":648 * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< * else: # isinstance(X, csc_matrix) * c_results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), */ - if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 658, __pyx_L1_error) + if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 648, __pyx_L1_error) - /* "l0learn/interface.pyx":631 + /* "l0learn/interface.pyx":621 * cdef cvfitmodel c_results * if isinstance(X, np.ndarray): * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< * y=numpy_to_dvec_d(y), * Loss=c_loss, */ - __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnCV_dense(__pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_X)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_19, __pyx_t_20, __pyx_t_21, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_22, __pyx_t_23, __pyx_v_rtol, __pyx_v_atol, __pyx_t_24, __pyx_t_25, __pyx_t_26, __pyx_v_scale_down_factor, __pyx_t_27, (!__pyx_t_9), __pyx_v_c_lambda_grid, __pyx_t_28, __pyx_t_4, __pyx_t_29, __pyx_t_30, __pyx_t_31, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); + __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnCV_dense(__pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_X)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_14, __pyx_t_15, __pyx_t_16, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_17, __pyx_t_18, __pyx_v_rtol, __pyx_v_atol, __pyx_t_19, __pyx_t_20, __pyx_t_21, __pyx_v_scale_down_factor, __pyx_t_22, (!__pyx_t_9), __pyx_v_c_lambda_grid, __pyx_t_23, __pyx_t_4, __pyx_t_24, __pyx_t_25, __pyx_t_26, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); - /* "l0learn/interface.pyx":630 + /* "l0learn/interface.pyx":620 * * cdef cvfitmodel c_results * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), * y=numpy_to_dvec_d(y), */ - goto __pyx_L17; + goto __pyx_L9; } - /* "l0learn/interface.pyx":660 + /* "l0learn/interface.pyx":650 * Highs=numpy_to_dvec_d(highs)) * else: # isinstance(X, csc_matrix) * c_results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< @@ -9300,309 +9114,309 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ /*else*/ { - /* "l0learn/interface.pyx":661 + /* "l0learn/interface.pyx":651 * else: # isinstance(X, csc_matrix) * c_results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), * y=numpy_to_dvec_d(y), # <<<<<<<<<<<<<< * Loss=c_loss, * Penalty=c_penalty, */ - if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 661, __pyx_L1_error) + if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 651, __pyx_L1_error) - /* "l0learn/interface.pyx":665 + /* "l0learn/interface.pyx":655 * Penalty=c_penalty, * Algorithm=c_algorithim, * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< * G_ncols=num_lambda, * G_nrows=num_gamma, */ - __pyx_t_29 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_29 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 665, __pyx_L1_error) + __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 655, __pyx_L1_error) - /* "l0learn/interface.pyx":666 + /* "l0learn/interface.pyx":656 * Algorithm=c_algorithim, * NnzStopNum=max_support_size, * G_ncols=num_lambda, # <<<<<<<<<<<<<< * G_nrows=num_gamma, * Lambda2Max=gamma_max, */ - __pyx_t_27 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_27 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 666, __pyx_L1_error) + __pyx_t_22 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_22 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 656, __pyx_L1_error) - /* "l0learn/interface.pyx":667 + /* "l0learn/interface.pyx":657 * NnzStopNum=max_support_size, * G_ncols=num_lambda, * G_nrows=num_gamma, # <<<<<<<<<<<<<< * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, */ - __pyx_t_26 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_26 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 667, __pyx_L1_error) + __pyx_t_21 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_21 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 657, __pyx_L1_error) - /* "l0learn/interface.pyx":670 + /* "l0learn/interface.pyx":660 * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, * PartialSort=partial_sort, # <<<<<<<<<<<<<< * MaxIters=max_iter, * rtol=rtol, */ - __pyx_t_31 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_31 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 670, __pyx_L1_error) + __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 660, __pyx_L1_error) - /* "l0learn/interface.pyx":671 + /* "l0learn/interface.pyx":661 * Lambda2Min=gamma_min, * PartialSort=partial_sort, * MaxIters=max_iter, # <<<<<<<<<<<<<< * rtol=rtol, * atol=atol, */ - __pyx_t_25 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_25 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 671, __pyx_L1_error) + __pyx_t_20 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_20 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 661, __pyx_L1_error) - /* "l0learn/interface.pyx":674 + /* "l0learn/interface.pyx":664 * rtol=rtol, * atol=atol, * ActiveSet=active_set, # <<<<<<<<<<<<<< * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, */ - __pyx_t_30 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_30 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 674, __pyx_L1_error) + __pyx_t_25 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_25 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 664, __pyx_L1_error) - /* "l0learn/interface.pyx":675 + /* "l0learn/interface.pyx":665 * atol=atol, * ActiveSet=active_set, * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, */ - __pyx_t_23 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_23 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 675, __pyx_L1_error) + __pyx_t_18 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_18 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 665, __pyx_L1_error) - /* "l0learn/interface.pyx":676 + /* "l0learn/interface.pyx":666 * ActiveSet=active_set, * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, */ - __pyx_t_21 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_21 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 676, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_16 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 666, __pyx_L1_error) - /* "l0learn/interface.pyx":678 + /* "l0learn/interface.pyx":668 * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, # <<<<<<<<<<<<<< * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, */ - __pyx_t_20 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_20 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 678, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 668, __pyx_L1_error) - /* "l0learn/interface.pyx":679 + /* "l0learn/interface.pyx":669 * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, * LambdaU=not auto_lambda, # <<<<<<<<<<<<<< * Lambdas=c_lambda_grid, * nfolds=num_folds, */ - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 679, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 669, __pyx_L1_error) - /* "l0learn/interface.pyx":681 + /* "l0learn/interface.pyx":671 * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, * nfolds=num_folds, # <<<<<<<<<<<<<< * seed=seed, * ExcludeFirstK=exclude_first_k, */ - __pyx_t_28 = __Pyx_PyInt_As_unsigned_int(__pyx_v_num_folds); if (unlikely((__pyx_t_28 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 681, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyInt_As_unsigned_int(__pyx_v_num_folds); if (unlikely((__pyx_t_23 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 671, __pyx_L1_error) - /* "l0learn/interface.pyx":682 + /* "l0learn/interface.pyx":672 * Lambdas=c_lambda_grid, * nfolds=num_folds, * seed=seed, # <<<<<<<<<<<<<< * ExcludeFirstK=exclude_first_k, * Intercept=intercept, */ - __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_seed); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 682, __pyx_L1_error) + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_seed); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 672, __pyx_L1_error) - /* "l0learn/interface.pyx":683 + /* "l0learn/interface.pyx":673 * nfolds=num_folds, * seed=seed, * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< * Intercept=intercept, * withBounds=with_bounds, */ - __pyx_t_19 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_19 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 683, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_14 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 673, __pyx_L1_error) - /* "l0learn/interface.pyx":684 + /* "l0learn/interface.pyx":674 * seed=seed, * ExcludeFirstK=exclude_first_k, * Intercept=intercept, # <<<<<<<<<<<<<< * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), */ - __pyx_t_24 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_24 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 684, __pyx_L1_error) + __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_19 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 674, __pyx_L1_error) - /* "l0learn/interface.pyx":685 + /* "l0learn/interface.pyx":675 * ExcludeFirstK=exclude_first_k, * Intercept=intercept, * withBounds=with_bounds, # <<<<<<<<<<<<<< * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) */ - __pyx_t_22 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_22 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 685, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_17 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 675, __pyx_L1_error) - /* "l0learn/interface.pyx":686 + /* "l0learn/interface.pyx":676 * Intercept=intercept, * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< * Highs=numpy_to_dvec_d(highs)) * */ - if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 686, __pyx_L1_error) + if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 676, __pyx_L1_error) - /* "l0learn/interface.pyx":687 + /* "l0learn/interface.pyx":677 * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< * * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, */ - if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 687, __pyx_L1_error) + if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 677, __pyx_L1_error) - /* "l0learn/interface.pyx":660 + /* "l0learn/interface.pyx":650 * Highs=numpy_to_dvec_d(highs)) * else: # isinstance(X, csc_matrix) * c_results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< * y=numpy_to_dvec_d(y), * Loss=c_loss, */ - __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnCV_sparse(__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(__pyx_v_X), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_29, __pyx_t_27, __pyx_t_26, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_31, __pyx_t_25, __pyx_v_rtol, __pyx_v_atol, __pyx_t_30, __pyx_t_23, __pyx_t_21, __pyx_v_scale_down_factor, __pyx_t_20, (!__pyx_t_9), __pyx_v_c_lambda_grid, __pyx_t_28, __pyx_t_4, __pyx_t_19, __pyx_t_24, __pyx_t_22, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); + __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnCV_sparse(__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(__pyx_v_X), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_24, __pyx_t_22, __pyx_t_21, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_26, __pyx_t_20, __pyx_v_rtol, __pyx_v_atol, __pyx_t_25, __pyx_t_18, __pyx_t_16, __pyx_v_scale_down_factor, __pyx_t_15, (!__pyx_t_9), __pyx_v_c_lambda_grid, __pyx_t_23, __pyx_t_4, __pyx_t_14, __pyx_t_19, __pyx_t_17, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); } - __pyx_L17:; + __pyx_L9:; - /* "l0learn/interface.pyx":689 + /* "l0learn/interface.pyx":679 * Highs=numpy_to_dvec_d(highs)) * * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, # <<<<<<<<<<<<<< * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_CVFitModel); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 689, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_CVFitModel); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 679, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyDict_NewPresized(9); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 689, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 689, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 679, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 689, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 689, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_u_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 689, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_settings, __pyx_t_3) < 0) __PYX_ERR(0, 689, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 679, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 679, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 679, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 679, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_settings, __pyx_t_2) < 0) __PYX_ERR(0, 679, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "l0learn/interface.pyx":690 + /* "l0learn/interface.pyx":680 * * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, * lambda_0=c_results.Lambda0, # <<<<<<<<<<<<<< * gamma=c_results.Lambda12, * support_size=c_results.NnzCount, */ - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Lambda0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 690, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lambda_0, __pyx_t_3) < 0) __PYX_ERR(0, 689, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Lambda0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 680, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_lambda_0, __pyx_t_2) < 0) __PYX_ERR(0, 679, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "l0learn/interface.pyx":691 + /* "l0learn/interface.pyx":681 * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, # <<<<<<<<<<<<<< * support_size=c_results.NnzCount, * coeffs=sp_dmat_field_to_list(c_results.Beta), */ - __pyx_t_3 = __pyx_convert_vector_to_py_double(__pyx_v_c_results.Lambda12); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 691, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma, __pyx_t_3) < 0) __PYX_ERR(0, 689, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __pyx_convert_vector_to_py_double(__pyx_v_c_results.Lambda12); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 681, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_gamma, __pyx_t_2) < 0) __PYX_ERR(0, 679, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "l0learn/interface.pyx":692 + /* "l0learn/interface.pyx":682 * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, * support_size=c_results.NnzCount, # <<<<<<<<<<<<<< * coeffs=sp_dmat_field_to_list(c_results.Beta), * intercepts=c_results.Intercept, */ - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(__pyx_v_c_results.NnzCount); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 692, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_support_size, __pyx_t_3) < 0) __PYX_ERR(0, 689, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(__pyx_v_c_results.NnzCount); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 682, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_support_size, __pyx_t_2) < 0) __PYX_ERR(0, 679, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "l0learn/interface.pyx":693 + /* "l0learn/interface.pyx":683 * gamma=c_results.Lambda12, * support_size=c_results.NnzCount, * coeffs=sp_dmat_field_to_list(c_results.Beta), # <<<<<<<<<<<<<< * intercepts=c_results.Intercept, * converged=c_results.Converged, */ - __pyx_t_3 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_c_results.Beta); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 693, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_coeffs, __pyx_t_3) < 0) __PYX_ERR(0, 689, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_c_results.Beta); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 683, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_coeffs, __pyx_t_2) < 0) __PYX_ERR(0, 679, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "l0learn/interface.pyx":694 + /* "l0learn/interface.pyx":684 * support_size=c_results.NnzCount, * coeffs=sp_dmat_field_to_list(c_results.Beta), * intercepts=c_results.Intercept, # <<<<<<<<<<<<<< * converged=c_results.Converged, * cv_means=dvec_field_to_list(c_results.CVMeans), */ - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Intercept); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 694, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_intercepts, __pyx_t_3) < 0) __PYX_ERR(0, 689, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Intercept); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 684, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_intercepts, __pyx_t_2) < 0) __PYX_ERR(0, 679, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "l0learn/interface.pyx":695 + /* "l0learn/interface.pyx":685 * coeffs=sp_dmat_field_to_list(c_results.Beta), * intercepts=c_results.Intercept, * converged=c_results.Converged, # <<<<<<<<<<<<<< * cv_means=dvec_field_to_list(c_results.CVMeans), * cv_sds=dvec_field_to_list(c_results.CVSDs)) */ - __pyx_t_3 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(__pyx_v_c_results.Converged); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 695, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_converged, __pyx_t_3) < 0) __PYX_ERR(0, 689, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(__pyx_v_c_results.Converged); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 685, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_converged, __pyx_t_2) < 0) __PYX_ERR(0, 679, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "l0learn/interface.pyx":696 + /* "l0learn/interface.pyx":686 * intercepts=c_results.Intercept, * converged=c_results.Converged, * cv_means=dvec_field_to_list(c_results.CVMeans), # <<<<<<<<<<<<<< * cv_sds=dvec_field_to_list(c_results.CVSDs)) * return results */ - __pyx_t_3 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_c_results.CVMeans); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 696, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_cv_means, __pyx_t_3) < 0) __PYX_ERR(0, 689, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_c_results.CVMeans); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 686, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_cv_means, __pyx_t_2) < 0) __PYX_ERR(0, 679, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "l0learn/interface.pyx":697 + /* "l0learn/interface.pyx":687 * converged=c_results.Converged, * cv_means=dvec_field_to_list(c_results.CVMeans), * cv_sds=dvec_field_to_list(c_results.CVSDs)) # <<<<<<<<<<<<<< * return results * */ - __pyx_t_3 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_c_results.CVSDs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 697, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_cv_sds, __pyx_t_3) < 0) __PYX_ERR(0, 689, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_c_results.CVSDs); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 687, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_cv_sds, __pyx_t_2) < 0) __PYX_ERR(0, 679, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "l0learn/interface.pyx":689 + /* "l0learn/interface.pyx":679 * Highs=numpy_to_dvec_d(highs)) * * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, # <<<<<<<<<<<<<< * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 689, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 679, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_v_results = __pyx_t_3; - __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_results = __pyx_t_2; + __pyx_t_2 = 0; - /* "l0learn/interface.pyx":698 + /* "l0learn/interface.pyx":688 * cv_means=dvec_field_to_list(c_results.CVMeans), * cv_sds=dvec_field_to_list(c_results.CVSDs)) * return results # <<<<<<<<<<<<<< @@ -9614,7 +9428,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_r = __pyx_v_results; goto __pyx_L0; - /* "l0learn/interface.pyx":547 + /* "l0learn/interface.pyx":542 * * * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< @@ -9628,7 +9442,6 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_17); __Pyx_AddTraceback("l0learn.interface.cvfit", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -9652,7 +9465,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p return __pyx_r; } -/* "l0learn/interface.pyx":701 +/* "l0learn/interface.pyx":691 * * * cdef fitmodel _L0LearnFit_dense(const dmat& X, # <<<<<<<<<<<<<< @@ -9665,7 +9478,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_dense(arma::dmat const & __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_L0LearnFit_dense", 0); - /* "l0learn/interface.pyx":727 + /* "l0learn/interface.pyx":717 * const dvec &Lows, * const dvec &Highs): * return L0LearnFit[dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< @@ -9675,7 +9488,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_dense(arma::dmat const & __pyx_r = L0LearnFit(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); goto __pyx_L0; - /* "l0learn/interface.pyx":701 + /* "l0learn/interface.pyx":691 * * * cdef fitmodel _L0LearnFit_dense(const dmat& X, # <<<<<<<<<<<<<< @@ -9689,7 +9502,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_dense(arma::dmat const & return __pyx_r; } -/* "l0learn/interface.pyx":732 +/* "l0learn/interface.pyx":722 * * * cdef fitmodel _L0LearnFit_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< @@ -9702,7 +9515,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_sparse(arma::sp_dmat con __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_L0LearnFit_sparse", 0); - /* "l0learn/interface.pyx":758 + /* "l0learn/interface.pyx":748 * const dvec &Lows, * const dvec &Highs): * return L0LearnFit[sp_dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< @@ -9712,7 +9525,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_sparse(arma::sp_dmat con __pyx_r = L0LearnFit(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); goto __pyx_L0; - /* "l0learn/interface.pyx":732 + /* "l0learn/interface.pyx":722 * * * cdef fitmodel _L0LearnFit_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< @@ -9726,7 +9539,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_sparse(arma::sp_dmat con return __pyx_r; } -/* "l0learn/interface.pyx":763 +/* "l0learn/interface.pyx":753 * * * cdef cvfitmodel _L0LearnCV_dense(const dmat& X, # <<<<<<<<<<<<<< @@ -9739,7 +9552,7 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_dense(arma::dmat const __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_L0LearnCV_dense", 0); - /* "l0learn/interface.pyx":791 + /* "l0learn/interface.pyx":781 * const dvec &Lows, * const dvec &Highs): * return L0LearnCV[dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< @@ -9749,7 +9562,7 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_dense(arma::dmat const __pyx_r = L0LearnCV(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_nfolds, __pyx_v_seed, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); goto __pyx_L0; - /* "l0learn/interface.pyx":763 + /* "l0learn/interface.pyx":753 * * * cdef cvfitmodel _L0LearnCV_dense(const dmat& X, # <<<<<<<<<<<<<< @@ -9763,7 +9576,7 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_dense(arma::dmat const return __pyx_r; } -/* "l0learn/interface.pyx":796 +/* "l0learn/interface.pyx":786 * * * cdef cvfitmodel _L0LearnCV_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< @@ -9776,7 +9589,7 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_sparse(arma::sp_dmat co __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_L0LearnCV_sparse", 0); - /* "l0learn/interface.pyx":824 + /* "l0learn/interface.pyx":814 * const dvec &Lows, * const dvec &Highs): * return L0LearnCV[sp_dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< @@ -9786,7 +9599,7 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_sparse(arma::sp_dmat co __pyx_r = L0LearnCV(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_nfolds, __pyx_v_seed, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); goto __pyx_L0; - /* "l0learn/interface.pyx":796 + /* "l0learn/interface.pyx":786 * * * cdef cvfitmodel _L0LearnCV_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< @@ -11539,7 +11352,6 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_SUPPORTED_PENALTY, __pyx_k_SUPPORTED_PENALTY, sizeof(__pyx_k_SUPPORTED_PENALTY), 0, 0, 1, 1}, {&__pyx_n_u_SquaredError, __pyx_k_SquaredError, sizeof(__pyx_k_SquaredError), 0, 1, 0, 1}, {&__pyx_n_u_SquaredHinge, __pyx_k_SquaredHinge, sizeof(__pyx_k_SquaredHinge), 0, 1, 0, 1}, - {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, {&__pyx_n_s_Union, __pyx_k_Union, sizeof(__pyx_k_Union), 0, 0, 1, 1}, {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, {&__pyx_n_s_X, __pyx_k_X, sizeof(__pyx_k_X), 0, 0, 1, 1}, @@ -11594,7 +11406,6 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_kp_u_expected_highs_to_be_a_non_negat, __pyx_k_expected_highs_to_be_a_non_negat, sizeof(__pyx_k_expected_highs_to_be_a_non_negat), 0, 1, 0, 0}, {&__pyx_kp_u_expected_highs_to_be_a_non_negat_2, __pyx_k_expected_highs_to_be_a_non_negat_2, sizeof(__pyx_k_expected_highs_to_be_a_non_negat_2), 0, 1, 0, 0}, {&__pyx_kp_u_expected_intercept_parameter_to, __pyx_k_expected_intercept_parameter_to, sizeof(__pyx_k_expected_intercept_parameter_to), 0, 1, 0, 0}, - {&__pyx_kp_u_expected_lambda_grid_to_be_a_lis, __pyx_k_expected_lambda_grid_to_be_a_lis, sizeof(__pyx_k_expected_lambda_grid_to_be_a_lis), 0, 1, 0, 0}, {&__pyx_kp_u_expected_lambda_grid_to_of_lengt, __pyx_k_expected_lambda_grid_to_of_lengt, sizeof(__pyx_k_expected_lambda_grid_to_of_lengt), 0, 1, 0, 0}, {&__pyx_kp_u_expected_loss_parameter_to_be_on, __pyx_k_expected_loss_parameter_to_be_on, sizeof(__pyx_k_expected_loss_parameter_to_be_on), 0, 1, 0, 0}, {&__pyx_kp_u_expected_lows_to_be_a_non_positi, __pyx_k_expected_lows_to_be_a_non_positi, sizeof(__pyx_k_expected_lows_to_be_a_non_positi), 0, 1, 0, 0}, @@ -11707,7 +11518,6 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(0, 198, __pyx_L1_error) __pyx_builtin_any = __Pyx_GetBuiltinName(__pyx_n_s_any); if (!__pyx_builtin_any) __PYX_ERR(0, 203, __pyx_L1_error) __pyx_builtin_all = __Pyx_GetBuiltinName(__pyx_n_s_all); if (!__pyx_builtin_all) __PYX_ERR(0, 215, __pyx_L1_error) - __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 474, __pyx_L1_error) __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 945, __pyx_L1_error) __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(2, 61, __pyx_L1_error) return 0; @@ -11798,17 +11608,17 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_GIVEREF(__pyx_tuple__14); __pyx_codeobj__15 = (PyObject*)__Pyx_PyCode_New(24, 0, 33, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__14, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_fit, 261, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__15)) __PYX_ERR(0, 261, __pyx_L1_error) - /* "l0learn/interface.pyx":547 + /* "l0learn/interface.pyx":542 * * * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< * y: np.ndarray, * loss: str = "SquaredError", */ - __pyx_tuple__16 = PyTuple_Pack(37, __pyx_n_s_X, __pyx_n_s_y, __pyx_n_s_loss, __pyx_n_s_penalty, __pyx_n_s_algorithm, __pyx_n_s_num_folds, __pyx_n_s_seed, __pyx_n_s_max_support_size, __pyx_n_s_num_lambda, __pyx_n_s_num_gamma, __pyx_n_s_gamma_max, __pyx_n_s_gamma_min, __pyx_n_s_partial_sort, __pyx_n_s_max_iter, __pyx_n_s_rtol, __pyx_n_s_atol, __pyx_n_s_active_set, __pyx_n_s_active_set_num, __pyx_n_s_max_swaps, __pyx_n_s_scale_down_factor, __pyx_n_s_screen_size, __pyx_n_s_lambda_grid, __pyx_n_s_exclude_first_k, __pyx_n_s_intercept, __pyx_n_s_lows, __pyx_n_s_highs, __pyx_n_s_check, __pyx_n_s_auto_lambda, __pyx_n_s_with_bounds, __pyx_n_s__11, __pyx_n_s_p, __pyx_n_s_c_lambda_grid, __pyx_n_s_c_loss, __pyx_n_s_c_penalty, __pyx_n_s_c_algorithim, __pyx_n_s_c_results, __pyx_n_s_results); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 547, __pyx_L1_error) + __pyx_tuple__16 = PyTuple_Pack(37, __pyx_n_s_X, __pyx_n_s_y, __pyx_n_s_loss, __pyx_n_s_penalty, __pyx_n_s_algorithm, __pyx_n_s_num_folds, __pyx_n_s_seed, __pyx_n_s_max_support_size, __pyx_n_s_num_lambda, __pyx_n_s_num_gamma, __pyx_n_s_gamma_max, __pyx_n_s_gamma_min, __pyx_n_s_partial_sort, __pyx_n_s_max_iter, __pyx_n_s_rtol, __pyx_n_s_atol, __pyx_n_s_active_set, __pyx_n_s_active_set_num, __pyx_n_s_max_swaps, __pyx_n_s_scale_down_factor, __pyx_n_s_screen_size, __pyx_n_s_lambda_grid, __pyx_n_s_exclude_first_k, __pyx_n_s_intercept, __pyx_n_s_lows, __pyx_n_s_highs, __pyx_n_s_check, __pyx_n_s_auto_lambda, __pyx_n_s_with_bounds, __pyx_n_s__11, __pyx_n_s_p, __pyx_n_s_c_lambda_grid, __pyx_n_s_c_loss, __pyx_n_s_c_penalty, __pyx_n_s_c_algorithim, __pyx_n_s_c_results, __pyx_n_s_results); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 542, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__16); __Pyx_GIVEREF(__pyx_tuple__16); - __pyx_codeobj__17 = (PyObject*)__Pyx_PyCode_New(26, 0, 37, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_cvfit, 547, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__17)) __PYX_ERR(0, 547, __pyx_L1_error) + __pyx_codeobj__17 = (PyObject*)__Pyx_PyCode_New(26, 0, 37, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_cvfit, 542, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__17)) __PYX_ERR(0, 542, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; @@ -12429,44 +12239,44 @@ if (!__Pyx_RefNanny) { if (PyDict_SetItem(__pyx_d, __pyx_n_s_fit, __pyx_t_1) < 0) __PYX_ERR(0, 261, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":571 + /* "l0learn/interface.pyx":566 * exclude_first_k: int = 0, * intercept: bool = True, * lows: Union[np.ndarray, float] = -float('inf'), # <<<<<<<<<<<<<< * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.CVFitModel: * */ - __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 571, __pyx_L1_error) - __pyx_t_1 = PyFloat_FromDouble((-__pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 571, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 566, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble((-__pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 566, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_k__4 = __pyx_t_1; __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":572 + /* "l0learn/interface.pyx":567 * intercept: bool = True, * lows: Union[np.ndarray, float] = -float('inf'), * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.CVFitModel: # <<<<<<<<<<<<<< * * check = _fit_check(X=X, */ - __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 572, __pyx_L1_error) - __pyx_t_1 = PyFloat_FromDouble(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 572, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 567, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 567, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_k__5 = __pyx_t_1; __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":547 + /* "l0learn/interface.pyx":542 * * * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< * y: np.ndarray, * loss: str = "SquaredError", */ - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_5cvfit, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 547, __pyx_L1_error) + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_5cvfit, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 542, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_cvfit, __pyx_t_1) < 0) __PYX_ERR(0, 547, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_cvfit, __pyx_t_1) < 0) __PYX_ERR(0, 542, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "l0learn/interface.pyx":1 @@ -14117,6 +13927,19 @@ static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { } #endif +/* ExtTypeTest */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(__Pyx_TypeCheck(obj, type))) + return 1; + PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", + Py_TYPE(obj)->tp_name, type->tp_name); + return 0; +} + /* GetTopmostException */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * @@ -14272,19 +14095,6 @@ static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) return -1; } -/* ExtTypeTest */ -static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { - if (unlikely(!type)) { - PyErr_SetString(PyExc_SystemError, "Missing type object"); - return 0; - } - if (likely(__Pyx_TypeCheck(obj, type))) - return 1; - PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", - Py_TYPE(obj)->tp_name, type->tp_name); - return 0; -} - /* TypeImport */ #ifndef __PYX_HAVE_RT_ImportType #define __PYX_HAVE_RT_ImportType diff --git a/python/l0learn/interface.pyx b/python/l0learn/interface.pyx index 101e9d3..f980add 100644 --- a/python/l0learn/interface.pyx +++ b/python/l0learn/interface.pyx @@ -223,7 +223,7 @@ def _fit_check(X: Union[np.ndarray, csc_matrix], raise ValueError(f"expected highs to be a non-negative float, but got {highs}") if highs < float('inf'): with_bounds = True - elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and (highs >= 0): + elif isinstance(highs, np.ndarray) and highs.ndim == 1 and len(highs) == p and all(highs >= 0): with_bounds = True else: raise ValueError(f"expected highs to be a non-negative float, or a 1D numpy array of length {p} of " @@ -468,12 +468,7 @@ def fit(X: Union[np.ndarray, csc_matrix], lows = check['lows'] highs = check['highs'] - cdef vector[vector[double]] c_lambda_grid - try: - c_lambda_grid = lambda_grid - except TypeError: - raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") - + cdef vector[vector[double]] c_lambda_grid = lambda_grid cdef string c_loss = loss.encode('UTF-8') cdef string c_penalty = penalty.encode('UTF-8') cdef string c_algorithim = algorithm.encode('UTF-8') @@ -616,12 +611,7 @@ def cvfit(X: Union[np.ndarray, csc_matrix], raise ValueError(f"expected num_folds parameter to be a positive integer less than {p}, but got {num_folds}") - cdef vector[vector[double]] c_lambda_grid - try: - c_lambda_grid = lambda_grid - except TypeError: - raise ValueError(f"expected lambda_grid to be a list of list of doubles, but got {lambda_grid}") - + cdef vector[vector[double]] c_lambda_grid = lambda_grid cdef string c_loss = loss.encode('UTF-8') cdef string c_penalty = penalty.encode('UTF-8') cdef string c_algorithim = algorithm.encode('UTF-8') diff --git a/python/l0learn/models.py b/python/l0learn/models.py index e28e4f3..56f082d 100644 --- a/python/l0learn/models.py +++ b/python/l0learn/models.py @@ -37,9 +37,6 @@ def regularization_loss(coeffs: csc_matrix, ----- """ - if coeffs.ndim != 2: - raise NotImplementedError("expected coeffs to be a 2D array") - l0 = np.asarray(l0) l1 = np.asarray(l1) l2 = np.asarray(l2) @@ -133,7 +130,7 @@ def squared_error(y_true: np.ndarray, if y_pred.ndim == 2: y_true = y_true[:, np.newaxis] - squared_residuals = 0.5 * np.square(y_true - y_pred) + squared_residuals = 0.5 * np.square(y_true - y_pred).sum(axis=0) return squared_residuals + reg_loss @@ -143,7 +140,8 @@ def logistic_loss(y_true: np.ndarray, coeffs: Optional[csc_matrix] = None, l0: float = 0, l1: float = 0, - l2: float = 0, ) -> Union[float, np.ndarray]: + l2: float = 0, + eps: float = 1e-15) -> Union[float, np.ndarray]: # TODO: Check this formula. If there is an error here, there might be an error in the C++ code for Logistic. reg_loss = 0 @@ -154,8 +152,9 @@ def logistic_loss(y_true: np.ndarray, # ExpyXB = arma::exp(this->y % (*(this->X) * this->B + this->b0)); # return arma::sum(arma::log(1 + 1 / expyXB)) + regularization - exp_y_XB = np.exp(y_true * np.log(y_pred)) - log_loss = np.log(1 + 1 / exp_y_XB) + y_pred = np.clip(y_pred, eps, 1 - eps) + + log_loss = -(y_true*np.log(y_pred) + (1-y_true)*np.log(1-y_pred)).sum(axis=0) return log_loss + reg_loss @@ -178,7 +177,7 @@ def squared_hinge_loss(y_true: np.ndarray, # return arma::sum(onemyxb.elem(indices) % onemyxb.elem(indices)) + this->lambda0 * n_nonzero( # B) + this->lambda1 * arma::norm(B, 1) + this->lambda2 * l2norm * l2norm; - square_one_minus_y_XB = np.square(np.max(1 - y_true * y_pred, 0)) + square_one_minus_y_XB = np.square(np.max(1 - y_true * y_pred, 0)).sum(axis=0) return square_one_minus_y_XB + reg_loss @@ -438,7 +437,7 @@ def plot(self, gamma: float = 0, show_lines: bool = False, **kwargs): f, ax = plt.subplots(**kwargs) if show_lines: - linestyle = kwargs.pop("linestyle", "_.") + linestyle = kwargs.pop("linestyle", "-.") else: linestyle = kwargs.pop("linestyle", "None") @@ -629,7 +628,7 @@ def gen_synthetic(n: int, rho: float = 0, b0: float = 0, snr: float = 1 - ) -> Dict[str, Union[float, np.ndarray]]: + ) -> Dict[str, Union[float, np.ndarray]]: # pragma: no cover """ Generates a synthetic dataset as follows: 1) Sample every element in data matrix X from N(0,1). @@ -690,7 +689,7 @@ def gen_synthetic(n: int, return {"X": X, "y": y, "B": B, "e": e, "b0": b0} -def cor_matrix(p: int, base_cor: float): +def cor_matrix(p: int, base_cor: float): # pragma: no cover if not (0 < base_cor < 1): raise ValueError(f"Expected base_cor to be a float between 0 and 1 exclusively, but got {base_cor}") @@ -709,7 +708,7 @@ def gen_synthetic_high_corr(n: int, snr: float = 1, mu: float = 0, base_cor: float = 0.8, - ) -> Dict[str, Union[float, np.ndarray]]: + ) -> Dict[str, Union[float, np.ndarray]]: # pragma: no cover """ Generates a synthetic dataset as follows: 1) Generate a correlation matrix, SIG, where item [i, j] = base_core^|i-j|. @@ -787,7 +786,7 @@ def gen_synthetic_logistic(n: int, s: float = 1, mu: Optional[float] = None, base_cor: Optional[float] = None, - ) -> Dict[str, Union[float, np.ndarray]]: + ) -> Dict[str, Union[float, np.ndarray]]: # pragma: no cover """ Generates a synthetic dataset as follows: 1) Generate a data matrix, X, drawn from either N(0, 1) (see gen_synthetic) or a multivariate_normal(mu, sigma) diff --git a/python/tests/test_fit.py b/python/tests/test_fit.py index cab8edd..cd0c57a 100644 --- a/python/tests/test_fit.py +++ b/python/tests/test_fit.py @@ -6,11 +6,15 @@ N = 50 + @pytest.mark.parametrize("f", [l0learn.fit, l0learn.cvfit]) def test_X_sparse_support(f): x = np.random.random(size=(N, N)) + x_sparse = csc_matrix(x) y = np.random.random(size=(N,)) - _ = l0learn.fit(csc_matrix(x), y, intercept=False) + model_fit = f(x_sparse, y, intercept=False) + assert max(model_fit.support_size[0]) == N + @pytest.mark.parametrize("x", [np.random.random(size=(N, N, N)), # Wrong Size "A String", # Wrong Type @@ -381,10 +385,10 @@ def test_with_bounds_bad_checks(f, bounds): _ = f(x, y, lows=lows, highs=highs) -@pytest.mark.parametrize("num_folds", [-1, 0, 1, N, 2.0]) +@pytest.mark.parametrize("num_folds", [-1, 0, 1, N+1, 2.0]) def test_cvfit_num_folds_bad_check(num_folds): x = np.random.random(size=(N, N)) - y = np.random.randint(0, 2, size=N) + y = np.random.random(size=N) with pytest.raises(ValueError): _ = l0learn.cvfit(x, y, num_folds=num_folds) \ No newline at end of file diff --git a/python/tests/test_models.py b/python/tests/test_models.py index c4faec5..81a6c71 100644 --- a/python/tests/test_models.py +++ b/python/tests/test_models.py @@ -1,9 +1,10 @@ import numpy as np import pandas as pd +import pytest from hypothesis.strategies import floats -from scipy.sparse import csc_matrix +from scipy.sparse import csc_matrix, rand -from l0learn.models import FitModel, regularization_loss +from l0learn.models import FitModel, CVFitModel, regularization_loss, squared_error, logistic_loss, squared_hinge_loss from pytest import fixture from hypothesis import given @@ -29,6 +30,35 @@ def sample_FitModel(loss: str = 'SquaredError', intercept: bool = True, penalty: converged=[[True, True], [False], [True, False, True]]) +@fixture +def sample_CVFitModel(sample_FitModel: FitModel, num_folds: int=2): + cvMeans = np.random.random(num_folds) + 2 # Ensure positive + cvSTDs = np.random.random(num_folds) + + settings = sample_FitModel.settings + settings['num_folds'] = num_folds + + return CVFitModel(settings=sample_FitModel.settings, + lambda_0=sample_FitModel.lambda_0, + gamma=sample_FitModel.gamma, + support_size=sample_FitModel.support_size, + coeffs=sample_FitModel.coeffs, + intercepts=sample_FitModel.intercepts, + converged=sample_FitModel.converged, + cv_means=cvMeans, + cv_sds=cvSTDs) + + +def test_CVFitModel_plot(sample_CVFitModel): + sample_CVFitModel.cv_plot(gamma=1) + + +def test_FitModel_plot(sample_FitModel): + sample_FitModel.plot(gamma=1) + sample_FitModel.plot(gamma=1, show_lines=True) + + + def test_FitModel_coeff(sample_FitModel): np.testing.assert_array_equal(sample_FitModel.coeff().toarray(), np.array([[-1, -2, -3, -4, -5, -6], @@ -112,16 +142,108 @@ def test_regularization_loss(coeffs): regularization_loss(coeffs_csc, l0=range(num_solutions), l1=1, l2=1)) -def test_squared_error(): - pass +def test_regularization_loss_bad_inputs(): + N = 10 + a = rand(N, N, .2, format='csc') + l0 = np.ones(N) + l1 = np.ones((1, N)) + l2 = 5 + with pytest.raises(ValueError): + regularization_loss(a, l0, l1, l2) + + l0 = np.ones(N+1) + l1 = np.ones(N+1) + l2 = 5 + with pytest.raises(ValueError): + regularization_loss(a, l0, l1, l2) + + +@pytest.mark.parametrize("y_y_hat_error", + [(np.arange(10), np.arange(10), 0,), + (np.arange(10).reshape(10, 1), + np.arange(10), + np.array([142.5, 102.5, 72.5, 52.5, 42.5, 42.5, 52.5, 72.5, 102.5, 142.5])), + ]) +def test_squared_error_testing(y_y_hat_error): + y, y_hat, error = y_y_hat_error + np.testing.assert_equal(squared_error(y, y_hat), error) + + +@pytest.mark.parametrize("y_y_hat_error", + [(np.arange(10), np.arange(10), 0), + (np.arange(10).reshape(10, 1), + np.arange(10), + np.array([142.5, 102.5, 72.5, 52.5, 42.5, 42.5, 52.5, 72.5, 102.5, 142.5])), + ]) +@given(coeffs=npst.arrays(dtype=np.float, + elements=floats(allow_nan=False, allow_infinity=False, max_value=100, min_value=-100), + shape=(10, 10))) +def test_squared_error_testing_reg(y_y_hat_error, coeffs): + coeffs_csc = csc_matrix(coeffs) + y, y_hat, error = y_y_hat_error + np.testing.assert_array_almost_equal(squared_error(y, y_hat, coeffs_csc, l0=0, l1=0, l2=0), error) + reg_error = (coeffs != 0).sum(axis=0) + abs(coeffs).sum(axis=0) + np.square(coeffs).sum(axis=0) + np.testing.assert_array_almost_equal(squared_error(y, y_hat, coeffs_csc, l0=np.ones(10), l1=1, l2=1), + error+reg_error) -def test_logistic_loss(): - pass +@pytest.mark.parametrize("y_y_hat_error", + [(np.ones(10), np.ones(10), 0,), + (np.ones(10).reshape(10, 1), np.ones(10), np.zeros(10)), + (np.ones(10), 0.5*np.ones(10), np.log(2)*10) + ]) +def test_logistic_loss(y_y_hat_error): + y, y_hat, error = y_y_hat_error + np.testing.assert_almost_equal(logistic_loss(y, y_hat), error) -def test_squared_hinge_loss(): - pass + +@pytest.mark.parametrize("y_y_hat_error", + [(np.ones(10), np.ones(10), 0,), + (np.ones(10).reshape(10, 1), np.ones(10), np.zeros(10)), + (np.ones(10), 0.5*np.ones(10), np.log(2)*10) + ]) +@given(coeffs=npst.arrays(dtype=np.float, + elements=floats(allow_nan=False, allow_infinity=False, max_value=100, min_value=-100), + shape=(10, 10))) +def test_logistic_loss_testing_reg(y_y_hat_error, coeffs): + coeffs_csc = csc_matrix(coeffs) + y, y_hat, error = y_y_hat_error + np.testing.assert_almost_equal(logistic_loss(y, y_hat, coeffs_csc, l0=0, l1=0, l2=0), error) + + reg_error = (coeffs != 0).sum(axis=0) + abs(coeffs).sum(axis=0) + np.square(coeffs).sum(axis=0) + np.testing.assert_array_almost_equal(logistic_loss(y, y_hat, coeffs_csc, l0=np.ones(10), l1=1, l2=1), + error+reg_error) + + +@pytest.mark.parametrize("y_y_hat_error", + [(np.ones(10), np.ones(10), 0,), + (np.ones(10).reshape(10, 1), np.ones(10), np.zeros(10)), + (np.ones(10), 0.5*np.ones(10), 0.25), + (np.ones(10), 0, 1) + ]) +def test_squared_hinge_loss(y_y_hat_error): + y, y_hat, error = y_y_hat_error + np.testing.assert_almost_equal(squared_hinge_loss(y, y_hat), error) + + +@pytest.mark.parametrize("y_y_hat_error", + [(np.ones(10), np.ones(10), 0,), + (np.ones(10).reshape(10, 1), np.ones(10), np.zeros(10)), + (np.ones(10), 0.5*np.ones(10), 0.25), + (np.ones(10), 0, 1) + ]) +@given(coeffs=npst.arrays(dtype=np.float, + elements=floats(allow_nan=False, allow_infinity=False, max_value=100, min_value=-100), + shape=(10, 10))) +def test_squared_hinge_loss_reg(y_y_hat_error, coeffs): + coeffs_csc = csc_matrix(coeffs) + y, y_hat, error = y_y_hat_error + np.testing.assert_almost_equal(squared_hinge_loss(y, y_hat, coeffs_csc, l0=0, l1=0, l2=0), error) + + reg_error = (coeffs != 0).sum(axis=0) + abs(coeffs).sum(axis=0) + np.square(coeffs).sum(axis=0) + np.testing.assert_array_almost_equal(squared_hinge_loss(y, y_hat, coeffs_csc, l0=np.ones(10), l1=1, l2=1), + error+reg_error) def test_score(): From f14369e91c10ce98a5125ce44693be0d1f795967 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 26 Nov 2021 16:24:16 -0500 Subject: [PATCH 075/125] Improved test coverage for FitModel.predict and FitModel.score --- python/l0learn/models.py | 7 +- python/tests/test_models.py | 148 +++++++++++++++++++++++------------- 2 files changed, 101 insertions(+), 54 deletions(-) diff --git a/python/l0learn/models.py b/python/l0learn/models.py index 56f082d..90c97e2 100644 --- a/python/l0learn/models.py +++ b/python/l0learn/models.py @@ -152,6 +152,9 @@ def logistic_loss(y_true: np.ndarray, # ExpyXB = arma::exp(this->y % (*(this->X) * this->B + this->b0)); # return arma::sum(arma::log(1 + 1 / expyXB)) + regularization + if y_pred.ndim == 2: + y_true = y_true[:, np.newaxis] + y_pred = np.clip(y_pred, eps, 1 - eps) log_loss = -(y_true*np.log(y_pred) + (1-y_true)*np.log(1-y_pred)).sum(axis=0) @@ -176,6 +179,8 @@ def squared_hinge_loss(y_true: np.ndarray, # arma::uvec indices = arma::find(onemyxb > 0); # return arma::sum(onemyxb.elem(indices) % onemyxb.elem(indices)) + this->lambda0 * n_nonzero( # B) + this->lambda1 * arma::norm(B, 1) + this->lambda2 * l2norm * l2norm; + if y_pred.ndim == 2: + y_true = y_true[:, np.newaxis] square_one_minus_y_XB = np.square(np.max(1 - y_true * y_pred, 0)).sum(axis=0) return square_one_minus_y_XB + reg_loss @@ -513,7 +518,7 @@ def score(self, characteristics = self.characteristics(lambda_0=lambda_0, gamma=gamma) if training: - coeffs = self.coeff(lambda_0=lambda_0, gamma=gamma) + coeffs = self.coeff(lambda_0=lambda_0, gamma=gamma, include_intercept=False) l0 = characteristics.get('l0', 0) l1 = characteristics.get('l1', 0) l2 = characteristics.get('l2', 0) diff --git a/python/tests/test_models.py b/python/tests/test_models.py index 81a6c71..d5aa18e 100644 --- a/python/tests/test_models.py +++ b/python/tests/test_models.py @@ -11,8 +11,7 @@ from hypothesis.extra import numpy as npst -@fixture -def sample_FitModel(loss: str = 'SquaredError', intercept: bool = True, penalty: str = 'L0L1'): +def _sample_FitModel(loss: str = 'SquaredError', intercept: bool = True, penalty: str = 'L0L1'): i = intercept beta1 = csc_matrix([[0, 0], [1, 2]]) @@ -26,25 +25,31 @@ def sample_FitModel(loss: str = 'SquaredError', intercept: bool = True, penalty: gamma=[2, 1, 0], support_size=[[0, 1], [3], [4, 5, 6]], coeffs=[beta1, beta2, beta3], - intercepts=[[-1*i, -2*i], [-3*i], [-4*i, -5*i, -6*i]], + intercepts=[[-1 * i, -2 * i], [-3 * i], [-4 * i, -5 * i, -6 * i]], converged=[[True, True], [False], [True, False, True]]) @fixture -def sample_CVFitModel(sample_FitModel: FitModel, num_folds: int=2): +def sample_FitModel(): + return _sample_FitModel() + + +@fixture +def sample_CVFitModel(num_folds: int = 2): + fit_model = _sample_FitModel() cvMeans = np.random.random(num_folds) + 2 # Ensure positive cvSTDs = np.random.random(num_folds) - settings = sample_FitModel.settings + settings = fit_model.settings settings['num_folds'] = num_folds - return CVFitModel(settings=sample_FitModel.settings, - lambda_0=sample_FitModel.lambda_0, - gamma=sample_FitModel.gamma, - support_size=sample_FitModel.support_size, - coeffs=sample_FitModel.coeffs, - intercepts=sample_FitModel.intercepts, - converged=sample_FitModel.converged, + return CVFitModel(settings=fit_model.settings, + lambda_0=fit_model.lambda_0, + gamma=fit_model.gamma, + support_size=fit_model.support_size, + coeffs=fit_model.coeffs, + intercepts=fit_model.intercepts, + converged=fit_model.converged, cv_means=cvMeans, cv_sds=cvSTDs) @@ -58,12 +63,11 @@ def test_FitModel_plot(sample_FitModel): sample_FitModel.plot(gamma=1, show_lines=True) - def test_FitModel_coeff(sample_FitModel): np.testing.assert_array_equal(sample_FitModel.coeff().toarray(), np.array([[-1, -2, -3, -4, -5, -6], - [0, 0, 0, 0, 0, 0], - [1, 2, 3, 4, 5, 6]])) + [0, 0, 0, 0, 0, 0], + [1, 2, 3, 4, 5, 6]])) np.testing.assert_array_equal(sample_FitModel.coeff(include_intercept=False).toarray(), np.array([[0, 0, 0, 0, 0, 0], [1, 2, 3, 4, 5, 6]])) @@ -94,32 +98,32 @@ def test_FitModel_coeff(sample_FitModel): def test_characteristics(sample_FitModel): pd.testing.assert_frame_equal(sample_FitModel.characteristics(), - pd.DataFrame({'l0': [10, 5, 10, 10, 5, 0], - 'support_size': [0, 1, 3, 4, 5, 6], - 'intercept': [-1, -2, -3, -4, -5, -6], - 'converged': [True, True, False, True, False, True], - 'l1': [2, 2, 1, 0, 0, 0]})) + pd.DataFrame({'l0': [10, 5, 10, 10, 5, 0], + 'support_size': [0, 1, 3, 4, 5, 6], + 'intercept': [-1, -2, -3, -4, -5, -6], + 'converged': [True, True, False, True, False, True], + 'l1': [2, 2, 1, 0, 0, 0]})) pd.testing.assert_frame_equal(sample_FitModel.characteristics(gamma=1), - pd.DataFrame({'l0': [10], - 'support_size': [3], - 'intercept': [-3], - 'converged': [False], - 'l1': [1]})) + pd.DataFrame({'l0': [10], + 'support_size': [3], + 'intercept': [-3], + 'converged': [False], + 'l1': [1]})) pd.testing.assert_frame_equal(sample_FitModel.characteristics(lambda_0=6), - pd.DataFrame({'l0': [5], - 'support_size': [1], - 'intercept': [-2], - 'converged': [True], - 'l1': [2]})) + pd.DataFrame({'l0': [5], + 'support_size': [1], + 'intercept': [-2], + 'converged': [True], + 'l1': [2]})) pd.testing.assert_frame_equal(sample_FitModel.characteristics(gamma=0, lambda_0=5), - pd.DataFrame({'l0': [5], - 'support_size': [5], - 'intercept': [-5], - 'converged': [False], - 'l1': [0]})) + pd.DataFrame({'l0': [5], + 'support_size': [5], + 'intercept': [-5], + 'converged': [False], + 'l1': [0]})) @given(coeffs=npst.arrays(dtype=np.float, @@ -129,14 +133,14 @@ def test_regularization_loss(coeffs): coeffs_csc = csc_matrix(coeffs) if coeffs.shape[1] == 1: np.testing.assert_equal((coeffs != 0).sum(), regularization_loss(coeffs_csc, l0=1)) - np.testing.assert_equal((coeffs != 0).sum() + sum(abs(coeffs)) + sum(coeffs**2), + np.testing.assert_equal((coeffs != 0).sum() + sum(abs(coeffs)) + sum(coeffs ** 2), regularization_loss(coeffs_csc, l0=1, l1=1, l2=1)) else: num_solutions = coeffs.shape[1] - np.testing.assert_equal((coeffs != 0).sum(axis=0), regularization_loss(coeffs_csc, l0=[1]*num_solutions)) + np.testing.assert_equal((coeffs != 0).sum(axis=0), regularization_loss(coeffs_csc, l0=[1] * num_solutions)) np.testing.assert_equal((coeffs != 0).sum(axis=0) + abs(coeffs).sum(axis=0) + (coeffs ** 2).sum(axis=0), - regularization_loss(coeffs_csc, l0=[1]*num_solutions, l1=1, l2=1)) - np.testing.assert_equal(np.arange(num_solutions)*((coeffs != 0).sum(axis=0)) + regularization_loss(coeffs_csc, l0=[1] * num_solutions, l1=1, l2=1)) + np.testing.assert_equal(np.arange(num_solutions) * ((coeffs != 0).sum(axis=0)) + abs(coeffs).sum(axis=0) + (coeffs ** 2).sum(axis=0), regularization_loss(coeffs_csc, l0=range(num_solutions), l1=1, l2=1)) @@ -151,8 +155,8 @@ def test_regularization_loss_bad_inputs(): with pytest.raises(ValueError): regularization_loss(a, l0, l1, l2) - l0 = np.ones(N+1) - l1 = np.ones(N+1) + l0 = np.ones(N + 1) + l1 = np.ones(N + 1) l2 = 5 with pytest.raises(ValueError): regularization_loss(a, l0, l1, l2) @@ -162,7 +166,7 @@ def test_regularization_loss_bad_inputs(): [(np.arange(10), np.arange(10), 0,), (np.arange(10).reshape(10, 1), np.arange(10), - np.array([142.5, 102.5, 72.5, 52.5, 42.5, 42.5, 52.5, 72.5, 102.5, 142.5])), + np.array([142.5, 102.5, 72.5, 52.5, 42.5, 42.5, 52.5, 72.5, 102.5, 142.5])), ]) def test_squared_error_testing(y_y_hat_error): y, y_hat, error = y_y_hat_error @@ -173,7 +177,7 @@ def test_squared_error_testing(y_y_hat_error): [(np.arange(10), np.arange(10), 0), (np.arange(10).reshape(10, 1), np.arange(10), - np.array([142.5, 102.5, 72.5, 52.5, 42.5, 42.5, 52.5, 72.5, 102.5, 142.5])), + np.array([142.5, 102.5, 72.5, 52.5, 42.5, 42.5, 52.5, 72.5, 102.5, 142.5])), ]) @given(coeffs=npst.arrays(dtype=np.float, elements=floats(allow_nan=False, allow_infinity=False, max_value=100, min_value=-100), @@ -185,13 +189,13 @@ def test_squared_error_testing_reg(y_y_hat_error, coeffs): reg_error = (coeffs != 0).sum(axis=0) + abs(coeffs).sum(axis=0) + np.square(coeffs).sum(axis=0) np.testing.assert_array_almost_equal(squared_error(y, y_hat, coeffs_csc, l0=np.ones(10), l1=1, l2=1), - error+reg_error) + error + reg_error) @pytest.mark.parametrize("y_y_hat_error", [(np.ones(10), np.ones(10), 0,), (np.ones(10).reshape(10, 1), np.ones(10), np.zeros(10)), - (np.ones(10), 0.5*np.ones(10), np.log(2)*10) + (np.ones(10), 0.5 * np.ones(10), np.log(2) * 10) ]) def test_logistic_loss(y_y_hat_error): y, y_hat, error = y_y_hat_error @@ -201,7 +205,7 @@ def test_logistic_loss(y_y_hat_error): @pytest.mark.parametrize("y_y_hat_error", [(np.ones(10), np.ones(10), 0,), (np.ones(10).reshape(10, 1), np.ones(10), np.zeros(10)), - (np.ones(10), 0.5*np.ones(10), np.log(2)*10) + (np.ones(10), 0.5 * np.ones(10), np.log(2) * 10) ]) @given(coeffs=npst.arrays(dtype=np.float, elements=floats(allow_nan=False, allow_infinity=False, max_value=100, min_value=-100), @@ -213,14 +217,14 @@ def test_logistic_loss_testing_reg(y_y_hat_error, coeffs): reg_error = (coeffs != 0).sum(axis=0) + abs(coeffs).sum(axis=0) + np.square(coeffs).sum(axis=0) np.testing.assert_array_almost_equal(logistic_loss(y, y_hat, coeffs_csc, l0=np.ones(10), l1=1, l2=1), - error+reg_error) + error + reg_error) @pytest.mark.parametrize("y_y_hat_error", [(np.ones(10), np.ones(10), 0,), (np.ones(10).reshape(10, 1), np.ones(10), np.zeros(10)), - (np.ones(10), 0.5*np.ones(10), 0.25), - (np.ones(10), 0, 1) + (np.ones(10), 0.5 * np.ones(10), 0.25), + (np.ones(10), np.zeros(10), 1) ]) def test_squared_hinge_loss(y_y_hat_error): y, y_hat, error = y_y_hat_error @@ -230,8 +234,8 @@ def test_squared_hinge_loss(y_y_hat_error): @pytest.mark.parametrize("y_y_hat_error", [(np.ones(10), np.ones(10), 0,), (np.ones(10).reshape(10, 1), np.ones(10), np.zeros(10)), - (np.ones(10), 0.5*np.ones(10), 0.25), - (np.ones(10), 0, 1) + (np.ones(10), 0.5 * np.ones(10), 0.25), + (np.ones(10), np.zeros(10), 1) ]) @given(coeffs=npst.arrays(dtype=np.float, elements=floats(allow_nan=False, allow_infinity=False, max_value=100, min_value=-100), @@ -243,10 +247,48 @@ def test_squared_hinge_loss_reg(y_y_hat_error, coeffs): reg_error = (coeffs != 0).sum(axis=0) + abs(coeffs).sum(axis=0) + np.square(coeffs).sum(axis=0) np.testing.assert_array_almost_equal(squared_hinge_loss(y, y_hat, coeffs_csc, l0=np.ones(10), l1=1, l2=1), - error+reg_error) + error + reg_error) + + +@pytest.mark.parametrize("training", [True, False]) +@pytest.mark.parametrize("loss", ["SquaredHinge", "Logistic", "SquaredError"]) +def test_score(training, loss): + fit_model = _sample_FitModel(loss=loss) + + x_training = np.identity(2) + y_training = np.array([1, 1]) + + scored = fit_model.score(x_training, y_training, lambda_0=10, gamma=2, training=training) + + if training: + exra_args = {"coeffs": fit_model.coeff(lambda_0=10, gamma=2, include_intercept=False), + "l0": fit_model.characteristics(lambda_0=10, gamma=2)["l0"], + "l1": fit_model.characteristics(lambda_0=10, gamma=2)["l1"]} + else: + exra_args = {} + + print(exra_args) + + if loss == "Logistic": + expected_value = logistic_loss(y_true=y_training, + y_pred=fit_model.predict(x_training, lambda_0=10, gamma=2), + **exra_args) + elif loss == "SquaredHinge": + expected_value = squared_hinge_loss(y_true=y_training, + y_pred=fit_model.predict(x_training, lambda_0=10, gamma=2), + **exra_args) + + else: + expected_value = squared_error(y_true=y_training, + y_pred=fit_model.predict(x_training, lambda_0=10, gamma=2), + **exra_args) + + np.testing.assert_array_almost_equal(scored, expected_value) -def test_score(): +@pytest.mark.parametrize("training", [True, False]) +@pytest.mark.parametrize("loss", ["SquaredHinge", "Logistic", "SquaredError"]) +def test_score_characteristics(training, loss, sample_FitModel): pass From 14ab2cabd1d5912ae948e38664a9d0749a28f93c Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 3 Dec 2021 09:46:09 -0600 Subject: [PATCH 076/125] Updated Documentation --- python/_tutorial.rst | 300 ++++++++ python/doc/code.rst | 42 +- python/doc/conf.py | 10 +- python/doc/index.rst | 1 + python/doc/tutorial.ipynb | 1338 ++++++++++++++++++++++++++++++++++ python/l0learn/cyarma.cpp | 1145 +++-------------------------- python/l0learn/cyarma.pyx | 2 +- python/l0learn/interface.cpp | 1056 ++++++++++++++------------- python/l0learn/interface.pyx | 179 ++++- python/l0learn/models.py | 84 ++- python/sparse.ipynb | 994 +++++++++++++++++++++---- 11 files changed, 3433 insertions(+), 1718 deletions(-) create mode 100644 python/_tutorial.rst create mode 100644 python/doc/tutorial.ipynb diff --git a/python/_tutorial.rst b/python/_tutorial.rst new file mode 100644 index 0000000..b282719 --- /dev/null +++ b/python/_tutorial.rst @@ -0,0 +1,300 @@ +l0learn starter guide +===================== + +Introduction +============ +`l0learn` is a fast toolkit for L0-regularized learning. L0 regularization selects the best subset of features and can outperform commonly used feature selection methods (e.g., L1 and MCP) under many sparse learning regimes. The toolkit can (approximately) solve the following three problems. + +.. math:: + \\min_{\beta_0, \beta} \sum_{i=1}^{n} \ell(y_i, \beta_0+ \langle x_i, \beta \rangle) + \lambda ||\beta||_0 \quad \quad (L0) + +.. math:: + \\min_{\beta_0, \beta} \sum_{i=1}^{n} \ell(y_i, \beta_0+ \langle x_i, \beta \rangle) + \lambda ||\beta||_0 + \gamma||\beta||_1 \quad (L0L1) + +.. math:: + \\min_{\beta_0, \beta} \sum_{i=1}^{n} \ell(y_i, \beta_0+ \langle x_i, \beta \rangle) + \lambda ||\beta||_0 + \gamma||\beta||_2^2 \quad (L0L2) + +where :math:`\ell` is the loss function, :math:`\beta_0` is the intercept, :math:`\beta` is the vector of coefficients, and :math:`||\beta||_0` denotes the L0 norm of :math:`\beta`, i.e., the number of non-zeros in :math:`\beta`. We support both regression and classification using either one of the following loss functions: + +* Squared error loss +* Logistic loss (logistic regression) +* Squared hinge loss (smoothed version of SVM). + +The parameter :math:`\lambda` controls the strength of the L0 regularization (larger :math:`\lambda` leads to less non-zeros). The parameter :math:`\gamma` controls the strength of the shrinkage component (which is the L1 norm in case of L0L1 or squared L2 norm in case of L0L2); adding a shrinkage term to L0 can be very effective in avoiding overfitting and typically leads to better predictive models. The fitting is done over a grid of :math:`\lambda` and :math:`\gamma` values to generate a regularization path. + +The algorithms provided in `l0learn` are based on cyclic coordinate descent and local combinatorial search. Many computational tricks and heuristics are used to speed up the algorithms and improve the solution quality. These heuristics include warm starts, active set convergence, correlation screening, greedy cycling order, and efficient methods for updating the residuals through exploiting sparsity and problem dimensions. Moreover, we employed a new computationally efficient method for dynamically selecting the regularization parameter :math:`\lambda` in the path. For more details on the algorithms used, please refer to our paper [Fast Best Subset Selection: Coordinate Descent and Local Combinatorial Optimization Algorithms](https://pubsonline.informs.org/doi/10.1287/opre.2019.1919). + +The toolkit is implemented in C++ along with an easy-to-use Python interface. In this tutorial, we provide a tutorial on using the Python interface. Particularly, we will demonstrate how use L0Learn's main functions for fitting models, cross-validation, and visualization. + +Installation +============ +L0Learn can be installed directly from pip by running the following command in terminal: + +.. code-block:: console + + pip install l0learn + +If you face installation issues, please refer to the [Installation Troubleshooting Wiki](https://github.com/hazimehh/L0Learn/wiki/Installation-Troubleshooting). If the issue is not resolved, you can submit an issue on [L0Learn's Github Repo](https://github.com/hazimehh/L0Learn). + +Tutorial +======== +To demonstrate how `l0learn` works, we will first generate a synthetic dataset and then proceed to fitting L0-regularized models. The synthetic dataset (y,X) will be generated from a sparse linear model as follows: + +* X is a 500x1000 design matrix with iid standard normal entries +* B is a 1000x1 vector with the first 10 entries set to 1 and the rest are zeros. +* e is a 500x1 vector with iid standard normal entries +* y is a 500x1 response vector such that y = XB + e + +This dataset can be generated in Python as follows: + +.. code-block:: python + + import numpy as np + np.random.seed(4) # fix the seed to get a reproducible result + n, p, k = 500, 1000, 100 + X = np.random.normal(size=(n, p)) + B = np.zeros(p) + B[:k] = 1 + e = np.random.normal(n) + y = X@B + e + +More expressive and complete functions for generating datasets can be found are available in :py:mod:`l0learn.models`. The available functions are: + +* :py:meth:`l0learn.models.gen_synthetic` +* :py:meth:`l0learn.models.gen_synthetic_high_corr` +* :py:meth:`l0learn.models.gen_synthetic_logistic` + +We will use L0Learn to estimate B from the data (y,X). First we load L0Learn: + +.. code-block:: python + + from l0learn import fit + + +We will start by fitting a simple L0 model and then proceed to the case of L0L2 and L0L1. + +Fitting L0 Regression Models +============================ + +To fit a path of solutions for the L0-regularized model with at most 20 non-zeros using coordinate descent (CD), we use the :py:meth:`l0learn.models.fit` function as follows: + +.. code-block:: python + + fit = fit(X, y, penalty="L0", max_support_size=20) + + +This will generate solutions for a sequence of :math:`\lambda` values (chosen automatically by the algorithm). To view the sequence of :math:`\lambda` along with the associated support sizes (i.e., the number of non-zeros), we use the built in rich display from `ipython Rich Display `_ in iPython Notebooks. When running this tutorial in a more standard python environment, use the function :py:meth:`l0learn.models.FitModel.characteristics` to display the sequence of solutions. + +.. code-block:: python + + fit # will render as an pandas DataFrame. + + +To extract the estimated B for particular values of :math:`\lambda` and :math:`\gamma`, we use the function :py:meth:`l0learn.models.FitModel.coeff`. For example, the solution at :math:`\lambda = 0.0325142` (which corresponds to a support size of 10) can be extracted using: + +.. code-block:: python + + fit.coeff(lambda_0=0.0325) + +The output is a sparse matrix of type `scipy.sparse.csc_matrix `. Depending on the `include_intercept` parameter of :py:meth:`l0learn.models.FitModel.coeff`, The first element in the vector is the intercept and the rest are the B coefficients. Aside from the intercept, the only non-zeros in the above solution are coordinates 0, 1, 2, 3, ..., 9, which are the non-zero coordinates in the true support (used to generated the data). Thus, this solution successfully recovers the true support. Note that on some BLAS implementations, the `lambda` value we used above (i.e., `0.0325142`) might be slightly different due to the limitations of numerical precision. Moreover, all the solutions in the regularization path can be extracted at once by calling :code:`fit.coeff()`. + +The sequence of :math:`\lambda` generated by `l0learn` is stored in the object :code:`fit`. Specifically, :code:`fit.lambda_0` is a list, where each element of the list is a sequence of :math:`\lambda` values corresponding to a single value of :math:`\gamma`. When using an L0 penalty , which has only one value of :math:`\gamma` (i.e., 0), we can access the sequence of :math:`\lambda` values using :code:`fit.lambda_0[0]`. Thus, :math:`\lambda=0.0325142` we used previously can be accessed using :code:`fit.lambda_0[1][6]` (since it is the 7th value in the output of :code:`fit.characteristics()`). So the previous solution can also be extracted using :code:`fit.coeff(lambda_0=fit.lambda_0[1][6], gamma=0)`. + +We can make predictions using a specific solution in the grid using the function :code:`fit.predict(newx, lambda, gamma)` where :code:`newx` is a testing sample (vector or matrix). For example, to predict the response for the samples in the data matrix X using the solution with :math:`\lambda=0.0325142`, we call the prediction function as follows: + +.. code-block:: python + + fit.predict(x=X, lambda_0=0.0325142, gamma=0) + +We can also visualize the regularization path by plotting the coefficients of the estimated B versus the support size (i.e., the number of non-zeros) using the :py:meth:`l0learn.models.FitModel.plot` method as follows: + +.. code-block:: python + + fit.plot(fit, gamma=0) + +The legend of the plot presents the variables in the order they entered the regularization path. For example, variable 7 is the first variable to enter the path, and variable 6 is the second to enter. Thus, roughly speaking, we can view the first $k$ variables in the legend as the best subset of size $k$. To show the lines connecting the points in the plot, we can set the parameter :code:`show_lines=True` in the `plot` function, i.e., call :code:`fit.plot(fit, gamma=0, show_lines=True)`. Moreover, we note that the plot function returns a :code:`matplotlib.axes._subplots.AxesSubplot` object, which can be further customized using the :code:`matplotlib` package. In addition, both the :py:meth:`l0learn.models.FitModel.plot` and :py:meth:`l0learn.models.CVFitModel.cv_plot` accept :code:`**kwargs` parameter to allow for customization of the plotting behavior. + +Fitting L0L2 and L0L1 Regression Models +======================================= +We have demonstrated the simple case of using an L0 penalty. We can also fit more elaborate models that combine L0 regularization with shrinkage-inducing penalties like the L1 norm or squared L2 norm. Adding shrinkage helps in avoiding overfitting and typically improves the predictive performance of the models. Next, we will discuss how to fit a model using the L0L2 penalty for a two-dimensional grid of :math:`\lambda` and :math:`\gamma` values. Recall that by default, `l0learn` automatically selects the :math:`\lambda` sequence, so we only need to specify the :math:`\gamma` sequence. Suppose we want to fit an L0L2 model with a maximum of 20 non-zeros and a sequence of 5 :math:`\gamma` values ranging between 0.0001 and 10. We can do so by calling :py:meth:`l0learn.fit` with :code:`penalty="L0L2"`, :code:`num_gamma=5`, :code:`gamma_min=0.0001`, and :code:`gamma_max=10` as follows: + +.. code-block:: python + + fit = fit(X, y, penalty="L0L2", num_gamma = 5, gamma_min = 0.0001, gamma_max = 10, max_support_size=20) + +`l0learn` will generate a grid of 5 :math:`\gamma` values equi-spaced on the logarithmic scale between 0.0001 and 10. Similar to the case for L0, we can display a summary of the regularization path using the :code:`fit.characteristics()` function as follows: + +.. code-block:: python + + fit # Using ipython Rich Display + # fit.characteristics() # For non Rich Display + + +The sequence of :math:`\gamma` values can be accessed using :code:`fit.gamma`. To extract a solution we use the :py:meth:`l0learn.models.FitModel.coeff` method. For example, extracting the solution at `:math:`\lambda=0.0011539` and :math:`\gamma=10` can be done using + +.. code-block:: python + + fit.coeff(lambda_0=0.0011539, gamma=10) # Using ipython Rich Display + + +Similarly, we can predict the response at this pair of :math:`\lambda` and :math:`\gamma` for the matrix X using + +.. code-block:: python + + fit.predict(x=X, lambda_0=0.0011539, gamma=10) + +The regularization path can also be plot at a specific :math:`\gamma` using :code:`fit.plot(gamma)`. Finally, we note that fitting an L0L1 model can be done by just changing the `penalty` to "L0L1" in the above (in this case `gamma_max` will be ignored since it is automatically selected by the toolkit; see the reference manual for more details.) + +Higher-quality Solutions using Local Search +=========================================== +By default, `l0learn` uses coordinate descent (CD) to fit models. Since the objective function is non-convex, the choice of the optimization algorithm can have a significant effect on the solution quality (different algorithms can lead to solutions with very different objective values). A more elaborate algorithm based on combinatorial search can be used by setting the parameter `algorithm="CDPSI"` in the call to :py:meth:`l0learn.fit`. `CDPSI` typically leads to higher-quality solutions compared to CD, especially when the features are highly correlated. `CDPSI` is slower than `CD`, however, for typical applications it terminates in the order of seconds. + +Cross-validation +================ + +We will demonstrate how to use K-fold cross-validation (CV) to select the optimal values of the tuning parameters :math:`\lambda` and math:`\gamma`. To perform CV, we use the :py:meth:`l0learn.cvfit` function, which takes the same parameters as :code:`l0learn.fit`, in addition to the number of folds using the :code:`num_folds` parameter and a seed value using the :code:`seed` parameter (this is used when randomly shuffling the data before performing CV). + +For example, to perform 5-fold CV using the `L0L2` penalty (over a range of 5 `gamma` values between 0.0001 and 0.1) with a maximum of 50 non-zeros, we run: + +.. code-block:: python + + cv_fit_result = cvfit(X, y, num_folds=5, seed=1, penalty="L0L2", num_gamma=5, gamma_min=0.0001, gamma_max=0.1, max_support_size=50) + +Note that the object :py:class:`l0learn.models.CVFitModel` subclasses :py:class:`l0learn.models.FitModel` and thus has the same methods and underlinying structure which is output of running :py:meth:`l0learn.cvfit` on (y,X). The cross-validation errors can be accessed using the `cv_means` attribute of `cvfit`: `cvfit.cv_means` is a list where the ith element, :code:`cvfit.cv_means[i]`, stores the cross-validation errors for the ith value of gamma (:code:`cvfit.gamma[i]`). To find the minimum cross-validation error for every `gamma`, we apply the :code:`np.argmin` function for every element in the list :code:`cvfit.cv_means`, as follows: + +.. code-block:: python + + gamma_mins = [(np.argmin(cv_mean), np.min(cv_mean)) for cv_mean in cv_fit_result.cv_means] + gamma_mins + +The above output indicates that the 3rd value of gamma achieves the lowest CV error (`=0.9899542`). We can plot the CV errors against the support size for the 4th value of gamma, i.e., `gamma = cvfit$fit$gamma[4]`, using: + + +```{r, fig.height = 4.7, fig.width = 7, out.width="90%", dpi=300} +plot(cvfit, gamma=cvfit$fit$gamma[4]) +``` + +The above plot is produced using the `ggplot2` package and can be further customized by the user. To extract the optimal $\lambda$ (i.e., the one with minimum CV error) in this plot, we execute the following: +```{r} +optimalGammaIndex = 4 # index of the optimal gamma identified previously +optimalLambdaIndex = which.min(cvfit$cvMeans[[optimalGammaIndex]]) +optimalLambda = cvfit$fit$lambda[[optimalGammaIndex]][optimalLambdaIndex] +optimalLambda +``` +To print the solution corresponding to the optimal gamma/lambda pair: +```{r output.lines=15} +coef(cvfit, lambda=optimalLambda, gamma=cvfit$fit$gamma[4]) +``` +The optimal solution (above) selected by cross-validation correctly recovers the support of the true vector of coefficients used to generated the model. + +## Fitting Classification Models +All the commands and plots we have seen in the case of regression extend to classification. We currently support logistic regression (using the parameter `loss = "Logistic"`) and a smoothed version of SVM (using the parameter `loss="SquaredHinge"`). To give some examples, we first generate a synthetic classification dataset (similar to the one we generated in the case of regression): +```{r} +set.seed(1) # fix the seed to get a reproducible result +X = matrix(rnorm(500*1000),nrow=500,ncol=1000) +B = c(rep(1,10),rep(0,990)) +e = rnorm(500) +y = sign(X%*%B + e) +``` +An L0-regularized logistic regression model can be fit by specificying `loss = "Logistic"` as follows: +```{r output.lines=15} +fit = L0Learn.fit(X,y,loss="Logistic") +print(fit) +``` +The output above indicates that $\gamma=10^{-7}$---by default we use a small ridge regularization (with $\gamma=10^{-7}$) to ensure the existence of a solution. To extract the coefficients of the solution with $\lambda = 8.69435$: +```{r output.lines=15} +coef(fit, lambda=8.69435, gamma=1e-7) +``` +The above indicates that the 10 non-zeros in the estimated model match those we used in generating the data (i.e, L0 regularization correctly recovered the true support). We can also make predictions at the latter $\lambda$ using: +```{r output.lines=15} +predict(fit, newx=X, lambda=8.69435, gamma=1e-7) +``` +Each row in the above is the probability that the corresponding sample belongs to class $1$. Other models (i.e., L0L2 and L0L1) can be similarly fit by specifying `loss = "Logistic"`. + +Finally, we note that L0Learn also supports a smoothed version of SVM by using squared hinge loss (`loss = "SquaredHinge"`). The only difference from logistic regression is that the `predict` function returns $\beta_0 + \langle x, \beta \rangle$ (where $x$ is the testing sample), instead of returning probabilities. The latter predictions can be assigned to the appropriate classes by using a thresholding function (e.g., the sign function). + + +## Advanced Options + +### Sparse Matrix Support +Starting in version 2.0.0, L0Learn supports sparse matrices of type dgCMatrix. If your sparse matrix uses a different storage format, please convert it to dgCMatrix before using it in L0Learn. L0Learn keeps the matrix sparse internally and thus is highly efficient if the matrix is sufficiently sparse. The API for sparse matrices is the same as that of dense matrices, so all the demonstrations in this vignette also apply for sparse matrices. For example, we can fit an L0-regularized model on a sparse matrix as follows: +```{r} + +# As an example, we generate a random, sparse matrix with +# 500 samples, 1000 features, and 10% nonzero entries. +X_sparse <- Matrix::rsparsematrix(nrow=500, ncol=1000, density=0.1, rand.x = rnorm) +# Below we generate the response using the same linear model as before, +# but with the sparse data matrix X_sparse. +y_sparseX <- as.vector(X_sparse%*%B + e) + +# Call L0Learn. +fit_sparse <- L0Learn.fit(X_sparse, y_sparseX, penalty="L0") + +# Note: In the setup above, X_sparse is of type dgCMatrix. +# If your sparse matrix is of a different type, convert it +# to dgCMatrix before calling L0Learn, e.g., using: X_sparse <- as(X_sparse, "dgCMatrix"). +``` + +### Selection on Subset of Variables +In certain applications, it is desirable to always include some of the variables in the model and perform variable selection on others. `L0Learn` supports this option through the `excludeFirstK` parameter. Specifically, setting `excludeFirstK = K` (where K is a non-negative integer) instructs `L0Learn` to exclude the first K variables in the data matrix `X` from the L0-norm penalty (those K variables will still be penalized using the L2 or L1 norm penalties.). For example, below we fit an `L0` model and exclude the first 3 variables from selection by setting `excludeFirstK = 3`: +```{r} +fit <- L0Learn.fit(X, y, penalty="L0", maxSuppSize=10, excludeFirstK=3) +``` +Plotting the regularization path: +```{r, fig.height = 4.7, fig.width = 7, out.width="90%", dpi=300} +plot(fit, gamma=0) +``` + +We can see in the plot above that first 3 variables are included in all the solutions of the path. + +### Coefficient Bounds +Starting in version 2.0.0, L0Learn supports bounds for CD algorithms for all losses and penalties. (We plan to support bound constraints for the CDPSI algorithm in the future). By default, L0Learn does not apply bounds, i.e., it assumes $-\infty <= \beta_i <= \infty$ for all i. Users can supply the same bounds for all coefficients by setting the parameters `lows` and `highs` to scalar values (these should satisfy: `lows <= 0`, `lows != highs`, and `highs >= 0`). To use different bounds for the coefficients, `lows` and `highs` can be both set to vectors of length `p` (where the i-th entry corresponds to the bound on coefficient i). + +All of the following examples are valid. +```{r} +L0Learn.fit(X, y, penalty="L0", lows=-0.5) +L0Learn.fit(X, y, penalty="L0", highs=0.5) +L0Learn.fit(X, y, penalty="L0", lows=-0.5, highs=0.5) + +low_vector <- c(rep(-0.1, 500), rep(-0.125, 500)) +fit <- L0Learn.fit(X, y, penalty="L0", lows=low_vector, highs=0.25) +``` + +We can see the coefficients are subject to the bounds. +```{r} +print(max(fit$beta[[1]])) +print(min(fit$beta[[1]][1:500, ])) +print(min(fit$beta[[1]][501:1000, ])) +``` + +### User-specified Lambda Grids +By default, `L0Learn` selects the sequence of lambda values in an efficient manner to avoid wasted computation (since close $\lambda$ values can typically lead to the same solution). Advanced users of the toolkit can change this default behavior and supply their own sequence of $\lambda$ values. This can be done supplying the $\lambda$ values through the parameter `lambdaGrid`. L0Learn versions before 2.0.0 would also require setting the `autoLambda` parameter to `FALSE`. This parameter remains in version 2.0.0 for backwards compatibility, but is no longer needed or used. + +Specifically, the value assigned to `lambdaGrid` should be a list of lists of decreasing positive values (doubles). The length of `lambdaGrid` (the number of lists stored) specifies the number of gamma parameters that will fill between `gammaMin`, and `gammaMax`. In the case of L0 penalty, `lambdaGrid` must be a list of length 1. In case of L0L2/L0L1 `lambdaGrid` can have any number of sub-lists stored. The length of `lambdaGrid` (the number of lists stored) specifies the number of gamma parameters that will fill between `gammaMin`, and `gammaMax`. The ith element in `LambdaGrid` should be a **decreasing** sequence of positive lambda values which are used by the algorithm for the ith value of gamma. For example, to fit an L0 model with the sequence of user-specified lambda values: 1, 1e-1, 1e-2, 1e-3, 1e-4, we run the following: +```{r} +userLambda <- list() +userLambda[[1]] <- c(1, 1e-1, 1e-2, 1e-3, 1e-4) +fit <- L0Learn.fit(X, y, penalty="L0", lambdaGrid=userLambda, maxSuppSize=1000) +``` +To verify the results we print the fit object: +```{r} +print(fit) +``` +Note that the $\lambda$ values above are the desired values. For L0L2 and L0L1 penalties, the same can be done where the `lambdaGrid` parameter. +```{r} +userLambda <- list() +userLambda[[1]] <- c(1, 1e-1, 1e-2, 1e-3, 1e-4) +userLambda[[2]] <- c(10, 2, 1, 0.01, 0.002, 0.001, 1e-5) +userLambda[[3]] <- c(1e-4, 1e-5) +# userLambda[[i]] must be a vector of positive decreasing reals. +fit <- L0Learn.fit(X, y, penalty="L0L2", lambdaGrid=userLambda, maxSuppSize=1000) +``` + +```{r} +print(fit) +``` + +# References +Hussein Hazimeh and Rahul Mazumder. [Fast Best Subset Selection: Coordinate Descent and Local Combinatorial Optimization Algorithms](https://pubsonline.informs.org/doi/10.1287/opre.2019.1919). Operations Research (2020). + +Antoine Dedieu, Hussein Hazimeh, and Rahul Mazumder. [Learning Sparse Classifiers: Continuous and Mixed Integer Optimization Perspectives](https://arxiv.org/abs/2001.06471). JMLR (to appear). diff --git a/python/doc/code.rst b/python/doc/code.rst index 056f2a0..fe9f1e0 100644 --- a/python/doc/code.rst +++ b/python/doc/code.rst @@ -1,13 +1,39 @@ -Documentation for the Code -************************** +`fit` function +---------------- -.. automodule:: l0learn +.. autofunction:: l0learn.fit -useful #1 -- auto members -========================= +`cvfit` function +---------------- + +.. autofunction:: l0learn.cvfit + + +FitModels +--------- +.. autoclass:: l0learn.models.FitModel + + +CVFitModels +----------- +.. autoclass:: l0learn.models.CVFitModel + + +Generating Functions +-------------------- +.. autofunction:: l0learn.models.gen_synthetic +.. autofunction:: l0learn.models.gen_synthetic_high_corr +.. autofunction:: l0learn.models.gen_synthetic_logistic + +Scoring Functions +-------------------- +These functions are called by :py:meth:`l0learn.models.FitModel.score` and :py:meth:`l0learn.models.CVFitModel.score`. + +.. autofunction:: l0learn.models.regularization_loss +.. autofunction:: l0learn.models.squared_error +.. autofunction:: l0learn.models.logistic_loss +.. autofunction:: l0learn.models.squared_hinge_loss + -This is something I want to say that is not in the docstring. -.. automodule:: l0learn.models - :members: diff --git a/python/doc/conf.py b/python/doc/conf.py index 12d9b6b..d354ab9 100644 --- a/python/doc/conf.py +++ b/python/doc/conf.py @@ -28,7 +28,13 @@ # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. -extensions = ['sphinx.ext.autodoc'] +extensions = ['sphinx.ext.autodoc', + 'sphinx.ext.napoleon', + 'nbsphinx', + 'sphinx.ext.mathjax', + ] + +html_theme = "classic" # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] @@ -36,7 +42,7 @@ # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. # This pattern also affects html_static_path and html_extra_path. -exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store'] +exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store', '**.ipynb_checkpoints'] # -- Options for HTML output ------------------------------------------------- diff --git a/python/doc/index.rst b/python/doc/index.rst index f8c2f70..18e9975 100644 --- a/python/doc/index.rst +++ b/python/doc/index.rst @@ -9,6 +9,7 @@ Welcome to l0learn's documentation! .. toctree:: :maxdepth: 2 + tutorial.ipynb code diff --git a/python/doc/tutorial.ipynb b/python/doc/tutorial.ipynb new file mode 100644 index 0000000..fce1fac --- /dev/null +++ b/python/doc/tutorial.ipynb @@ -0,0 +1,1338 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Introduction\n", + "`l0learn` is a fast toolkit for L0-regularized learning. L0 regularization selects the best subset of features and can outperform commonly used feature selection methods (e.g., L1 and MCP) under many sparse learning regimes. The toolkit can (approximately) solve the following three problems\n", + "\n", + "\\begin{equation}\n", + "\\min_{\\beta_0, \\beta} \\sum_{i=1}^{n} \\ell(y_i, \\beta_0+ \\langle x_i, \\beta \\rangle) + \\lambda ||\\beta||_0 \\quad \\quad (L0) \n", + "\\end{equation}\n", + "\n", + "\n", + "\\begin{equation}\n", + "\\min_{\\beta_0, \\beta} \\sum_{i=1}^{n} \\ell(y_i, \\beta_0+ \\langle x_i, \\beta \\rangle) + \\lambda ||\\beta||_0 + \\gamma||\\beta||_1 \\quad (L0L1) \n", + "\\end{equation}\n", + "\n", + "\n", + "\\begin{equation}\n", + "\\min_{\\beta_0, \\beta} \\sum_{i=1}^{n} \\ell(y_i, \\beta_0+ \\langle x_i, \\beta \\rangle) + \\lambda ||\\beta||_0 + \\gamma||\\beta||_2^2 \\quad (L0L2)\n", + "\\end{equation}\n", + "\n", + "where $\\ell$ is the loss function, $\\beta_0$ is the intercept, $\\beta$ is the vector of coefficients, and $||\\beta||_0$ denotes the L0 norm of $\\beta$, i.e., the number of non-zeros in $\\beta$. We support both regression and classification using either one of the following loss functions:\n", + "\n", + "* Squared error loss\n", + "* Logistic loss (logistic regression)\n", + "* Squared hinge loss (smoothed version of SVM).\n", + "\n", + "The parameter $\\lambda$ controls the strength of the L0 regularization (larger $\\lambda$ leads to less non-zeros). The parameter $\\gamma$ controls the strength of the shrinkage component (which is the L1 norm in case of L0L1 or squared L2 norm in case of L0L2); adding a shrinkage term to L0 can be very effective in avoiding overfitting and typically leads to better predictive models. The fitting is done over a grid of $\\lambda$ and $\\gamma$ values to generate a regularization path. \n", + "\n", + "The algorithms provided in l0learn` are based on cyclic coordinate descent and local combinatorial search. Many computational tricks and heuristics are used to speed up the algorithms and improve the solution quality. These heuristics include warm starts, active set convergence, correlation screening, greedy cycling order, and efficient methods for updating the residuals through exploiting sparsity and problem dimensions. Moreover, we employed a new computationally efficient method for dynamically selecting the regularization parameter $\\lambda$ in the path. For more details on the algorithms used, please refer to our paper [Fast Best Subset Selection: Coordinate Descent and Local Combinatorial Optimization Algorithms](https://pubsonline.informs.org/doi/10.1287/opre.2019.1919).\n", + "\n", + "The toolkit is implemented in C++ along with an easy-to-use Python interface. In this vignette, we provide a tutorial on using the Python interface. Particularly, we will demonstrate how use L0Learn's main functions for fitting models, cross-validation, and visualization.\n", + "\n", + "# Installation\n", + "L0Learn can be installed directly from pip by executing:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "```console\n", + "pip install l0learn\n", + "```" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "If you face installation issues, please refer to the [Installation Troubleshooting Wiki](https://github.com/hazimehh/L0Learn/wiki/Installation-Troubleshooting). If the issue is not resolved, you can submit an issue on [L0Learn's Github Repo](https://github.com/hazimehh/L0Learn).\n", + "\n", + "# Tutorial\n", + "To demonstrate how `l0learn` works, we will first generate a synthetic dataset and then proceed to fitting L0-regularized models. The synthetic dataset (y,X) will be generated from a sparse linear model as follows:\n", + "\n", + "* X is a 500x1000 design matrix with iid standard normal entries\n", + "* B is a 1000x1 vector with the first 10 entries set to 1 and the rest are zeros.\n", + "* e is a 500x1 vector with iid standard normal entries\n", + "* y is a 500x1 response vector such that y = XB + e\n", + "\n", + "This dataset can be generated in python as follows:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 1, + "outputs": [], + "source": [ + "import numpy as np\n", + "np.random.seed(4) # fix the seed to get a reproducible result\n", + "n, p, k = 500, 1000, 10\n", + "X = np.random.normal(size=(n, p))\n", + "B = np.zeros(p)\n", + "B[:k] = 1\n", + "e = np.random.normal(size=(n,))/2\n", + "y = X@B + e" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "More expressive and complete functions for generating datasets can be found are available in [l0learn.models](code.rst#l0learn.models). The available functions are:\n", + "\n", + "* [l0learn.models.gen_synthetic()](code.rst#l0learn.models.gen_synthetic)\n", + "* [l0learn.models.gen_synthetic_high_corr()](code.rst#l0learn.models.gen_synthetic_high_corr)\n", + "* [l0learn.models.gen_synthetic_logistic()](code.rst#l0learn.models.gen_synthetic_logistic)" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "We will use `l0learn` to estimate B from the data (y,X). First we load L0Learn:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 2, + "outputs": [], + "source": [ + "import l0learn" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "We will start by fitting a simple L0 model and then proceed to the case of L0L2 and L0L1.\n", + "\n", + "## Fitting L0 Regression Models\n", + "To fit a path of solutions for the L0-regularized model with at most 20 non-zeros using coordinate descent (CD), we use the [l0learn.fit](code.rst#l0learn.models.gen_synthetic) function as follows:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 3, + "outputs": [], + "source": [ + "fit_model = l0learn.fit(X, y, penalty=\"L0\", max_support_size=20)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "This will generate solutions for a sequence of $\\lambda$ values (chosen automatically by the algorithm). To view the sequence of $\\lambda$ along with the associated support sizes (i.e., the number of non-zeros), we use the built-in rich display from [ipython Rich Display](https://ipython.readthedocs.io/en/stable/config/integrating.html+) for iPython Notebooks. When running this tutorial in a more standard python environment, use the function [l0learn.models.FitModel.characteristics](code.rst#l0learn.models.FitModel.characteristics) to display the sequence of solutions." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 4, + "outputs": [ + { + "data": { + "text/plain": "FitModel({'loss': 'SquaredError', 'intercept': True, 'penalty': 'L0'})", + "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
l0support_sizeinterceptconverged
00.0795460-0.156704True
10.0787501-0.147182True
20.0658622-0.161024True
30.0504643-0.002500True
40.0445175-0.041058True
50.0416727-0.058013True
60.0397058-0.061685True
70.032715100.002157True
80.00021211-0.000857True
90.00018712-0.002161True
100.00017813-0.001199True
110.00015915-0.007959True
120.00014116-0.009603True
130.00013318-0.015697True
140.00013221-0.012732True
\n
" + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fit_model\n", + "# fit_model.characteristics()" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "To extract the estimated B for particular values of $\\lambda$ and $\\gamma$, we use the function [l0learn.models.FitModel.coeff](code.rst#l0learn.models.FitModel.coeff). For example, the solution at $\\lambda = 0.032715$ (which corresponds to a support size of 10 + plus an intercept term) can be extracted using:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 6, + "outputs": [ + { + "data": { + "text/plain": "<1001x1 sparse matrix of type ''\n\twith 11 stored elements in Compressed Sparse Column format>" + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fit_model.coeff(lambda_0=0.032715, gamma=0)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "The output is a sparse matrix of type [scipy.sparse.csc_matrix](https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.csc_matrix.html). Depending on the `include_intercept` parameter of [l0learn.models.FitModel.coeff](code.rst#l0learn.models.FitModel.coeff), The first element in the vector is the intercept and the rest are the B coefficients. Aside from the intercept, the only non-zeros in the above solution are coordinates 0, 1, 2, 3, ..., 9, which are the non-zero coordinates in the true support (used to generated the data). Thus, this solution successfully recovers the true support. Note that on some BLAS implementations, the `lambda` value we used above (i.e., `0.032715`) might be slightly different due to the limitations of numerical precision. Moreover, all the solutions in the regularization path can be extracted at once by calling [l0learn.models.FitModel.coeff](code.rst#l0learn.models.FitModel.coeff) without specifying a `lambda_0` or `gamma` value.\n", + "\n", + "The sequence of $\\lambda$ generated by `L0Learn` is stored in the object `fit_model`. Specifically, `fit_model.lambda_0` is a list, where each element of the list is a sequence of $\\lambda$ values corresponding to a single value of $\\gamma$. When using an L0 penalty , which has only one value of $\\gamma$ (i.e., 0), we can access the sequence of $\\lambda$ values using `fit.lambda_0[0]`. Thus, $\\lambda=0.032715$ we used previously can be accessed using `fit_model.lambda_0[0][7]` (since it is the 8th value in the output of :code:`fit.characteristics()`). The previous solution can also be extracted using `fit_model.coeff(lambda_0=0.032, gamma=0)`." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 8, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fit_model.lambda_0[0][7] = 0.03271533058913737\n" + ] + }, + { + "data": { + "text/plain": "array([[0.00215713],\n [1.02014176],\n [0.97338278],\n ...,\n [0. ],\n [0. ],\n [0. ]])" + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(f\"fit_model.lambda_0[0][7] = {fit_model.lambda_0[0][7]}\")\n", + "fit_model.coeff(lambda_0=0.032715, gamma=0).toarray()" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "We can make predictions using a specific solution in the grid using the function `fit_model.predict(newx, lambda, gamma)` where `newx` is a testing sample (vector or matrix). For example, to predict the response for the samples in the data matrix X using the solution with $\\lambda=0.0058037$, we call the prediction function as follows:" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 10, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[-2.68272239]\n", + " [-3.667317 ]\n", + " [-1.77309853]\n", + " ...\n", + " [ 2.25545111]\n", + " [-0.77364234]\n", + " [-2.15002055]]\n" + ] + } + ], + "source": [ + "with np.printoptions(threshold=10):\n", + " print(fit_model.predict(x=X, lambda_0=0.032715, gamma=0))" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "We can also visualize the regularization path by plotting the coefficients of the estimated B versus the support size (i.e., the number of non-zeros) using the [l0learn.models.FitModel.plot()](code.rst#l0learn.models.FitModel.plot) method as follows:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 9, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgYAAAEGCAYAAAAe1109AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAABJ6klEQVR4nO3de1zUZfYH8M8ZYLgIglwUHAUUQQTvYmbZYrKliWmpmW67Wa25bbW5ubVt7a6Z7a5tFy+1tq2VZWWWqamJpUZmP0sNrMQrigoIioDKTYGZYc7vD2YIcK7MfJ1Bzvv14iU8833mOc84Oofv9/s8h5gZQgghhBAAoHJ3AEIIIYTwHJIYCCGEEKKJJAZCCCGEaCKJgRBCCCGaSGIghBBCiCbe7g7AUeHh4RwbG+vuMIQQol3Zt29fOTNHOPkcXb29vd8C0B/yi2V7ZQBwUK/Xzxo2bFipuQPaXWIQGxuL7Oxsd4chhBDtChEVOPsc3t7eb0VGRvaLiIi4qFKpZK17O2QwGKisrCyppKTkLQATzR0jGZ8QQgh79Y+IiKiSpKD9UqlUHBERUYnGsz7mj7mK8QghhGjfVJIUtH/Gv0OLn/+SGAghhBCiiSQGQggh2o21a9d2jo2N7R8dHd3/mWeeiXR3PFfD888/3zU+Pj65T58+yQsWLOgKACtWrOjSp0+fZJVKNeybb74JcOV47e7mQyGEEO3DB3sKQl/NPK4pq65XRwT5ah9Liy/+9fUxF9r6fHq9Ho8//nj01q1bj/Xu3Vs3aNCgflOmTKkYNmxYnSvjbrOst0Ox898a1JSqEdhVi9SnijH8t22eLwBkZWX5vffeexE//PDDET8/P0NqamrC5MmTKwcPHly7bt26vAcffDDWRdE3kTMGCsk4mYFb196KgSsH4ta1tyLjZIa7QxJCiKvmgz0Foc9vPhxTWl2vZgCl1fXq5zcfjvlgT0FoW5/z66+/7hQTE1OflJSk9fPz48mTJ19Yu3ZtiOuidkLW26HY+nQMas6pAQZqzqmx9ekYZL3d5vkCwIEDB/yHDBlSExQUZPDx8cGNN95Y/dFHH4UMHTq0btCgQfWuCr85SQwUkHEyA/O/m4+zl86CwTh76SzmfzdfkgMhRIfxauZxTb3e0OIzpl5vUL2aeVzT1uc8ffq0WqPRaE0/9+jRQ1tcXKx2Jk6X2flvDfT1LT9T9fUq7Px3m+cLAIMHD679/vvvg0pKSryqq6tV27dvDz59+rSic5ZLCQpY+sNS1DW0PLNV11CHpT8sRXrvdDdFJYQQV09Zdb3ZDy9L7e1eTan5eVlqt9PQoUPr5syZU5KWlpbg7+9vSE5Ovuzl5eXMU9okZwwUUHKpxKF2IYS41kQE+WodabdHz549W5whKCoqanEGwa0Cu5qPw1K7Ax5//PHyQ4cOHcnOzs7t0qVLQ0JCgqL3VEhioIDITuZvlLXULoQQ15rH0uKLfb1VhuZtvt4qw2Np8cVtfc7U1NRL+fn5fkePHlXX1dXR+vXrQ6dMmVLhdLCukPpUMbx9W8wX3r4GpD7V5vmaFBcXewPA8ePH1RkZGSGzZs1y6oZGWxRLDIhoBRGVEtFBG8cNJyI9EU1VKparbc7QOfDz8mvR5uflhzlD57gpIiGEuLp+fX3Mhb9PSCroGuSrJQBdg3y1f5+QVODMqgQfHx+88sorhePGjUuIj49PvuOOOy6kpKR4xoqE4b+9gLELCxDYTQsQENhNi7ELC5xdlQAAEydOjIuLi0ueMGFCnyVLlhSGh4c3vPfeeyHdunUb+NNPP3W6884740eNGhXvimkAADErs4kVEf0CQA2A95jZ7NaLROQFYDuAOgArmHmtredNSUnh9lArIeNkBpb+sBQll0oQ2SkSc4bOsfv+Amf6CiGEOUS0j5lTnHmO/fv35w8aNKjcVTEJ99m/f3/4oEGDYs09ptjNh8z8DRGZHbSZPwBYB2C4UnG4S3rv9DZ9mJtWNJhuXjStaDA9pxBCCKEkt91jQEQaAHcC+K8dx84momwiyi4rK1M+ODeytqJBCCGEUJo7bz5cAuApZjbYOpCZlzNzCjOnREQ4VU7c48mKBiGEEO7kzn0MUgB8REQAEA5gPBHpmXmDG2Nyu8hOkTh76azZdiGEEEJpbjtjwMy9mDmWmWMBrAXwcEdPCgBZ0SCEEMK9FDtjQESrAYwGEE5ERQCeBeADAMz8hlLjutrVXiFgem5ZlSCEEMIdlFyVMMOBY+9TKg5nuGuFQFtXNAghxLXurrvuis3MzAwOCwvTHz9+/JC741Ha5cuXacSIEYlarZYaGhro9ttvv7h48eIzR48eVU+bNq13RUWF94ABAy6vW7fulJ+fX9P+A++++27I/fffH7dz584jv/jFLy47MqbsfGiFrBAQQggnZL0dipcTBmB+yDC8nDDA2UqDAPDAAw+Ub9q06bgrwnO1j3M/Dr15zc0DBq4cOOzmNTcP+Dj3Y6fn6+fnx7t27crNzc09fOjQocOZmZmdMzMzO82dO7fHo48+eq6wsPBgcHCwfunSpeGmPhcvXlT95z//6TZw4MBLbRlTEgMrZIWAEEK0kUJliG+77baaiIgIvavCdJWPcz8OfTHrxZjy2nI1g1FeW65+MevFGGeTA5VKheDgYAMAaLVa0uv1RETYvXt30P33338RAB544IHzn332WYipz5/+9CfNE088UeLr69umHQwlMbBCah4IIUQbKVSG2FO9sf8NjbZB22K+2gat6o39bzg9X71ej8TExKRu3boNSk1NrerXr199UFBQg4+PDwAgNjZWe+7cOTUA7Nq1K6C4uFg9ffr0yraOJ4mBFR1phUDGyQzcuvZWDFw5ELeuvRUZJzPcHZIQoj1TqAyxpzpfe97svCy1O8Lb2xtHjx49XFhYmPPDDz90ysnJ8TN3XENDA+bOndvz1VdfPe3MeJIYWJHeOx3zb5iPqE5RIBCiOkVh/g3zr7kbA003WZ69dBYMbrrJUpIDIUSbKViG2BOF+YeZnZel9rYIDw9vuOmmm6p37drVqbq62kun0wEA8vPz1d26ddNWVFR4HT9+3G/MmDF9NRrNgP3793eaOnVqn2+++SbAkXEkMbAhvXc6tk3dhpyZOdg2dds1lxQAcpOlEEIBCpYh9kQPDXqoWO2lbjFftZfa8NCgh5ya75kzZ7zLy8u9AKCmpoZ27NjROSkpqe7666+vfuedd7oAwIoVK8ImTJhQERYW1nDx4sX9xcXFB4qLiw8MGjTo0tq1a/NkVYJwmNxkKYRwOYXKEN9+++29Ro0alXjq1Cnfbt26DVy8eHG47V7Ku7vv3Rf+PPzPBeH+4VoCIdw/XPvn4X8uuLvv3U7N9/Tp0z433XRT34SEhKQhQ4Yk3XzzzVUzZsyofOWVV4pee+21yOjo6P4XL170njNnjsuqXipWdlkp7aXscnty69pbzW7DHNUpCtumbnNDREIIV5Oyy6I5a2WX5YyB6FA3WQohhLDOnUWUhIeQbZiFEEKYSGIgAMg2zEIIIRrJpQQhhBBCNJHEQAghhBBNJDEQQgghRBNJDIQQQrQLeXl5PiNGjEiIi4tL7tOnT/Lzzz/f1d0xKe3y5cs0YMCAfn379k3q06dP8uOPP969+eP33Xdfz4CAgCHN2956660uptfo9ttv7+XomHLzoXCbjJMZshJCiGvYx7kfh76x/w3N+drz6jD/MO1Dgx4qdmbDHx8fH7zyyitFo0aNunzx4kXVkCFDksaPH181bNiwOtu9lXdh9Ueh519/XaMvL1d7h4drwx5+uDh0xnSnNjgylV0ODg421NfX0/Dhw/tmZmZWpqWlXfrmm28CKioqWnyOHzhwwPeVV16J2rNnz9GIiIiG4uJihz/n5YyBcAupzyDEtU2JMsQxMTG6UaNGXQaALl26GOLi4moLCws9oijThdUfhZa+8EKMvqxMDWboy8rUpS+8EHNh9UeKlF3W6/V48skneyxdurSo+fHLli2LePDBB0sjIiIaAECj0ThcolqxxICIVhBRKREdtPD4PUSUQ0QHiOg7IhqkVCzC80h9BiGubUqWIQaA3Nxc9eHDhwNSU1NrXPF8zjr/+usarm9ZZprr61XnX3/d5WWXx4wZc2nhwoVdx48fXxETE6NrfmxeXp7vsWPH/IYOHZo4aNCgxLVr13Z2dDwlLyW8C+A/AN6z8PgpAKnMfJGIbgOwHMAIBeMRHkTqMwhxbVOyDHFlZaVq8uTJcS+88MLp0NBQg+0eytOXl5udl6V2R5jKLpeXl3ulp6fHff7554EbNmzosmfPntzWxzY0NNCJEyd8d+/enXvq1Cmf0aNHJ44ePfpQeHh4g73jKXbGgJm/AWDx2gozf8fMF40/7gHQQ6lYhOeJ7BTpULsQon1RqgxxfX09paenx911110XZs6cWeHMc7mSd3i42XlZam8LU9nlL7/8MqigoMAvNjZ2gEajGVBXV6eKjo7uDwBRUVHaCRMmVPj6+nJiYqK2V69edYcOHfJ1ZBxPucfgtwA+t/QgEc0momwiyi4rK7uKYXUcx/aWYOUz32LZQ19h5TPf4theZX9zl/oMQlzblChDbDAYMH369JiEhIS6+fPnn3M+StcJe/jhYvJtWWaafH0NYQ8/7PKyyykpKZfLy8ubyiv7+fkZCgsLDwLA5MmTK3bu3BkEAGfPnvU+deqUX9++fesdGdPtqxKI6GY0JgajLB3DzMvReKkBKSkp7aIc5LG9Jdi98QRqLtQjMNQXIyfFIWGEZ/42fGxvCXasOgq9tvE9XXOhHjtWHQUAxWKW+gxCXNtMqw9cuSph+/btgRs2bAiLj4+vTUxMTAKA5557rvjuu++udFXcbWVafeDqVQmnT5/2ue+++3o1NDSAmWnSpEkXZsyYYXG+kydPrvriiy86x8XFJXt5efGCBQtOR0ZG2n0ZAVC47DIRxQLYzMz9LTw+EMCnAG5j5mP2PGd7KLvc+oMWALzVKtx8T6JHJgcrn/kWNReuTCgDQ30x8183uiEiIYSrSdll0ZxHll0momgA6wH8xt6koL3YvfFEi6QAAPRaA3ZvPOGmiKwzlxRYaxdCCHHtUuxSAhGtBjAaQDgRFQF4FoAPADDzGwDmAQgD8DoRAYDe2WzWU7S3D9rAUF+LZww8kWyMJIQQylEsMWDmGTYenwVgllLju1N7+6AdOSnO7KWPkZPi3BiVeaaNkUx7IJg2RgIgyYEQQriAp6xKuKaMnBQHb3XLl9ZTP2iBxhsMb74nsSlxCQz19dj7IWRjJCGEUJbbVyVci0wfqG1dleCOFQ0JIyI9MhFoTTZGEkIIZUlioJC2ftC6Y+lgexLZKRJnL5012y6EEMJ5cinBw7S3FQ1Xm2yMJETHZasE8bXI0pw3btwYlJSU1C8xMTFp2LBhfQ8ePOgLALW1tZSent47Ojq6/8CBAxNzc3Md3pJZzhh4mPa2ouFqk42RhGg/XF2G2FoJYlfG3VYHdhaFZm/J11yu1KoDgtXalPGxxQNSeyhSdnnOnDkx69evzxs6dGjdCy+8EPHss89GrVu3Ln/p0qXhwcHB+sLCwoPLly/vMnfu3B4ZGRknHRlTEgMP095WNLhDeu90SQSE8HCmMsSmioOmMsTAz7sEOspSCWJPcGBnUei3n+TFNOgNKgC4XKlVf/tJXgwAOJMcWJtzRUWFFwBUVlZ6RUVF6QBg8+bNIfPnzz8DAPfff//Fp556KtpgMEClsv8CgSQGHsZdSwfXlVzAwpNnUVyvg8bXB0/3jsKUSKfKiNvUnraNFkI4xloZYmfOGuj1evTv3z+psLDQd+bMmaVjxozxiLMF2VvyNaakwKRBb1Blb8nXOHvWwNyc33jjjfzJkyfH+/r6GgIDAxuysrKOAMC5c+fUvXr10gKAj48PAgMDG86dO+cdFRWlt3c8ucfAw7hj6eC6kgt4Ivc0iup1YABF9To8kXsa60qcei9bZbrJ0nR2xHSTpdLFm4QQV4dSZYhNJYgLCwtzfvjhh05ZWVl+tnsp73Kl1uy8LLU7wtycFy1a1G39+vXHz507l/OrX/2q/Pe//31PZ8dpGs9VTyRc52ovHVx48ixqDS1rZtQaGAtPnlXsrIG1myzlrIEQ7Z93eLhWX1Z2xYeiq8oQm0oQf/bZZ8HDhw+vs91DWQHBaq25JCAgWO3yssubNm0KPnLkiL/pbMm99957cdy4cfEA0K1bN+2pU6fUcXFxOp1Oh5qaGq9u3brZfbYAkDMGAkBxvc6hdleQmyyFuLYpUYbYXAnifv36uT0pAICU8bHFXt6qFvP18lYZUsbHurzsclJSUl1NTY1XTk6OLwBs3ry5c58+feoAID09vWLFihVhAPDOO+90GTlyZLUj9xcAcsbAI13t6/0aXx8UmUkCNL4+io0pN1kKcW1TogyxoyWIrybTfQSuXpVgac46na5g6tSpcUSE4ODghnffffcUAMyZM6d8ypQpvaKjo/sHBwc3fPzxxw6vdVe07LIS2kPZZWeYrvc3P7XvryK83LenYsmBO8Zsb6WphWjvpOyyaM5a2WU5Y+Bh3HG93/S8V/MsRcKISJwqPo7v9+9BA+rgBT9cN+hGu5KCnJwcZGZmorKyEsHBwUhLS8PAgQMVi1UIIToSSQw8jDuu9wONyYHSyxOby8nJQfaRb9BAjfNqQB2yj3yDqJxgqx/yOTk52LhhExoMjffSVFZWYuOGTQAgyYEQQriAJAYexh3X+90hMzMTOl3Leep0OmRmZlr9gP9iy7ampMCkwaDHF1u2KZoYOHPfhzv2iHAH2ZdCOR3lPSQ8gyQGHubp3lFmr/c/3TvKjVG5XmWl+fuFLLWbXK6tAcxsdHa5tsYVYZm1ruQCHj9SCNOao6J6HR4/UggANv9zdqbv3I0H8JmXFtUBKgRdNuD2BjUWTRpgV8zO9G2LY3tLsHhHHr66wR+VAQEIvmzAmB15eBy2i3+tWnMYxTtLENDAuOxF0KRG4p5pSYrFCgDLdp3Ea1UVqPAjhNQx/tA5BI+M6q3omG21ruQC5h4uRL3xfV9Ur8Pcw/a9h4RoC1mu6GGmRIbi5b490cPXBwSgh6+PojcBukuwv/mc1FK7iY/B/OOW2l3h70eL0HohstbYrlTfuRsP4JMAPao7eQFEqO7khU8C9Ji78YDNMZ3p21ZLvj2JzcMCUGkcs7KTFzYPC8CSb61v0b5qzWHsPn0Kb6b74x/TQvFmuj92nz6FVWsOKxbrsl0n8UJtBSr8VQARKvxVeKG2Ast2ObSd/FWz4ODppqTApJ4a24VQgmKJARGtIKJSIjpo4XEioleJKI+IcohoqFKxtDdTIkORfUMyzt48GNk3JF9zSQEApOFbeHHLDY682IA0fGu1X4quJ7y45dvWi1VI0bls068rXDA0ONTuir6fe2uh8275aaDzJnzubXuvFGf6ttVXfX2g827596LzVuGrvtYvgX1XdAobBnVDtb9/YxLj748Ng7rhu6JTisX6WtV5s7G+VnVesTGdUdpyabzNdiGcpeSlhHcB/AfAexYevw1AvPFrBID/Gv8UbpCzeTky9x1HJQcgmC4jbVg8Bk6Yrdh4/qVh4OgR+DA+FFV+fuhcV4dfH78A/0Lrv7UlcS/46vyR7X0SNVSHQPZDir434li5a9ndag04F+Bltt2WsDodzvtfuSNqWJ31m0kv+pvP2S21u6pvW1VYONNjqd1kW2Io9F4tj9F7eWNbonLJcIWfhVgttLtbWJ0e5f5XJlhhdQ5tZndN0ev1GDBgQFJkZKR2x44dee6O52poPeeJEyf2ysnJ6eTj48ODBw++9MEHHxT4+vpyWVmZ169+9avYgoICX19fX16xYsUpR3eGVOx/Cmb+BoC1jR0mAXiPG+0BEEJE19aF9HYiZ/NyfJZdgEruBIBQyZ3wWXYBcjYvV2zMbZr7sSK5O6qMvylW+ftjRXJ3bNPcb7VfbUMl+hiiMF17I2bVp2G69kb0MUShtkG5PU4eKD0INbfcjEnN9Xig1OzJsBZuLv8Kam75b1LNdbi5/Cur/YJ11Q61u6pvW7V1zGo/89vcW2p3BXe8Ps4YXZ5p9j00ujzTTRHZ78DOotB3nto1YNlDXw1756ldAw7sLHJJxvePf/yjW58+fWpd8Vyu9NP2LaFv/O43A165e8KwN373mwE/bd/isgy39ZzvueeeCydPnjyYm5t7qK6ujpYsWRIOAH/729+iBg4cePnYsWOH33vvvVOPPfZYtKNjufMeAw2A5hfJioxt4irL3HccOrT8jUQHH2TuO67YmG8mdkGdV8vT3XVehDcTu1jtR73OQW9oeUpcb9CCep1zeYwmyV2XYhZeRziXAmxAOJdiFl5HctelNvveFv4hZuG/rfr+F7eFf2i1311YZfbD4C6ssjmmM33bapqFMafZGDOMzZ++t9TuCm2N1V3a+h5yN1MZYlP9AFMZYmeTgxMnTvhs3bo1+MEHH/SojZZ+2r4l9OuVb8ZcqrioBoBLFRfVX698M8YVyYG5Od99992VKpUKKpUKKSkpl4qKitQAkJub63fLLbdUA8CQIUPqioqK1KdPn3bodJjdBxNRADNfduTJXYWIZgOYDQDR0Q4nP8KGSg5wqN0VzvmZr6Fuqd0k/pFZOL7sLWhPdYO/VzBqGypBvc4h/pFZSoTZyK8SN2IXbsSuFs1sxy+1vr6XzPe1sfPzaO8voUYd1vA9KEc4wlGOaViFG7x3We/oZN+2SvX+Ej5tGHMa3sfb/Hto6ecXs/FD+n0Av/SoWN2lre8hd1OqDPEjjzzS88UXXyyqrKy88vqeG+1Zu1rToNO1nK9Op9qzdrVm8C3jndoW2dqc6+vr6eOPPw5btGjRaQDo379/7SeffNJl3LhxNTt27Ag4e/asb35+vrpnz552X3uymRgQ0Q0A3gIQCCCaiAYB+B0zP2z/tMwqBtD8jrEexrYrMPNyAMuBxi2RnRxXtBJMl42XEa5sV0pXgwHnvK78d93VYPu6vaJJgBn19Z3g53dlyff6+itfs9YaanzgHXTl/QQNNdZvymuo8cGNQVd+GOht9AMA7SU1bgy8sm/9Jaerv1qkr/bGjZ2vHFNXbf2/mBHVe0CdccWH9HXVezwuVnfRXvaFb6cr64poL3t2ZqBEGeLVq1cHh4eH62+66abLmzdvDmp7dK5nOlNgb7u9bM155syZ0ddff33NuHHjagBgwYIFZ2fPnh2dmJiYlJiYWJuYmHjZy8vLoc9Ney4lLAYwFsB5AGDm/QB+4cggFmwCcK9xdcL1ACqZ+awLnlc4KG1YPHzQ8sPLBzqkDYtXbMx5/XvBt9XWz74Gxrz+vWz2XVdyASnfHULUjp+Q8t0hrCtxKhm3qehEPzQ0tExiGhq8UHSin82+PgfrYNC1PAti0BF8Dlq/F8jnqMF8v6O2Eyd9jg8a9C3/aTfoVdDnKLdJlmq7j9l4Vdutj6na7oORum+xFL/HKtyFpfg9Ruq+tdnPGfovfc3Gqv/SMz9oy3YFm/37LNsV7KaI7GOp3LAzZYh37doVuH379hCNRjPgvvvu671nz56gSZMm2f5P4yroFNLF7LwstdvL2pz/9Kc/RZWXl3u/+eabTZflQ0NDDWvXrs0/evTo4fXr15+6ePGid2JiokNla+26x4CZWy+YtblOi4hWA9gNoC8RFRHRb4noISJ6yHjIFgAnAeQBeBOAs2cgRBsNnDAbt6fEIJguAWAE0yXcnhKj6KqEKZGhWJQc02K/hkXJMXZtGPRE7mkU1evAaNzs5Ync04omByPP5yMvdzjq6jqBGair64S83OEYeT7fZt8xAYHwytYBFwEwgIuAV7YOYwICrfe77R/w2mdo2W+fAWNu+4fNMSdO/Bvq9vhAW+UNZkBb5Y26PT6YOPFv9ky3TUawAfjUHzrjmLoqb+BT/8Z2Bfo5I1Clh+HTgBZjGj4NQKDKM+/yD7ygR/GOrtBWG/8+q71RvKMrAi94ZrwmSpQhXrZsWfG5c+dyiouLD7z77rsnr7/++uqNGzcqt7bVAddPnVHs5ePTcr4+Pobrp85wquyypTkvWrQo/KuvvgresGHDSa9mZ1/Ly8u96urqCAAWL14cft1111WHhoY69A/KnnNnp42XE5iIfADMAXDEVidmnmHjcQbwiF1RCsUNnDAbAydc3THbUp/BHUWmBgZfAsqPI7P8l6hEEIJRjTTswsBgOy61pM3DmM8eAw5U/Nzm4w+kvWRj0GkYAwCZC4ADRUBwD2DCPGDgNDsCnoaJpr6V5xr73mFn3zYKfmg+rlv6J5Qu8IP+sg+8AxrQdUgFgue8okg/Z4yeNR9f//cv8PmXL0Kq1KjoDOiG1WD0rBcUG9MZU/7wJNYt+RfyVsZC6+0NtV6P7iHnMOWPz7g7NKuUKkPsqUz3EexZu1pzqeKiulNIF+31U2cUO3t/gSV//vOfY6KioupTUlL6AcCECRMuvvzyy2d/+uknv1mzZvUCgISEhNpVq1blO/rcNssuE1E4gKVovBOIAGwDMIdZwduGrbjWyy4L66J2/ARz71gCcPbmwcoMmrMG+OwxQNdsdZSPP3D7q/Z92OasMX5IGz/g05T9kHabts7THa9Pe/s7cUG8UnZZNGet7LLNxMDTSGLQsaV8d8hskakevj7IviFZuYHb2weJEK1IYiCas5YY2LMq4R3gyl/SmPkB50MTwjFuKzI1cJokAkKIDsGeeww2N/veD8CdAM4oE44Q1pnuI5AStEIIoQybiQEzr2v+s3G1gWfuBCI6hLbctCiEEMI+bdkSOR5AV1cHIoQQQgj3s+ceg2o03mNAxj9LADylcFxCWLThx2K8tDUXZypq0T3EH0+O7Ys7hkiZDSGEcAV7LiV41LaTomPb8GMxnl5/ALW6xj22iitq8fT6AwAgyYEQHYRGoxnQqVOnBpVKBW9vbz548KDNvXXaM3PznTNnTvfPP/88RKVSISwsTLdq1ar82NhYncFgwAMPPNDzq6++Cvbz8zOsWLEif9SoUQ7tb28xMSCiodY6MvMPjgwkhCu8tDW3KSkwqdU14KWtuZIYCOFhftq+JVSpDX927tx5LCoqyqO2f6zZcya0KvO0xlCtVauC1NrOaT2LA6/vrsh8n3322ZKlS5eeAYB//OMfXZ955pmoDz/8sPCTTz4JPnnypF9+fv7BHTt2dHr44Yejc3JyjjoylrUzBta2HmOgcWM2Ia6mMxXmS7BbahdCuIepDLGp4qCpDDHw8y6B15KaPWdCKzafioGxoqShWquu2HwqBgBclRw013yb40uXLqmIGut/bNy4MeSee+45r1KpkJaWdqmqqsq7oKDAJyYm5soNYCywePMhM99s5UuSAuEW3UP8HWoXQriHtTLErnj+tLS0+OTk5H4vv/xyuCuez1lVmac1aFVmGnqDqirztGLz/cMf/qCJjIwcuHbt2rCXXnrpDACcPXvWJzY2tqlwU1RUlLagoMChqmR2rUogov5ENI2I7jV9OTKIEK7y5Ni+8PdpWenQ38cLT47t66aIhBDmKFWGGAB27dp19PDhw0e2bdt2/M033+z6+eefW69KdhUYqs2Xk7bU7ghL833ttdeKS0pKcqZOnXr+pZdectlqQZuJARE9C+A149fNAF4EGmu0CHG13TFEg4WTB0AT4g8CoAnxx8LJA+T+AiE8jFJliAGgV69eOgDQaDT69PT0it27d3dy9jmdpQoyX07aUrsjbM33gQceuLB58+YuABAVFaXLz89vSkbOnj2rduQyAmDfGYOpANIAlDDz/QAGAfDsQuDimnbHEA2+/csYnHohHd/+ZYwkBUJ4IKXKEFdVVakuXryoMn2/Y8eOzgMHDnT7TUad03oWo1WZaXirDJ3Teioy3wMHDviajlmzZk1IXFxcLQBMnDixYtWqVWEGgwGZmZmdgoKCGhxNDOzZErmWmQ1EpCeizgBKAfR0ZBAhhBAdi1JliIuKirzvvPPOPgDQ0NBAU6ZMOT916tQqV8TsDNMNhq5elWBpvmPHjo07efKkHxFxjx49tG+//XYBAEybNq0yIyMjOCYmpr+/v7/hrbfeynd0THvKLr8O4BkA0wH8CUANgJ+MZw+uOqmuKIQQjpPqiqK5NlVXJKJlAD5k5oeNTW8Q0RcAOjNzjuvDFEIIIYS7WbuUcAzAy0QUBWANgNXM/OPVCUsIIYQQ7mBtH4OlzDwSQCqA8wBWENFRInqWiBLseXIiGkdEuUSUR0R/MfN4NBHtIKIfiSiHiMa3eSZCCCGEcJrNVQnMXMDM/2bmIQBmALgDgM19qYnIC8AyALcBSAIwg4iSWh32NwBrjM89HcDrjoUvhBBCCFeyZx8DbyK6nYhWAfgcQC6AyXY893UA8pj5JDNrAXwEYFKrYxhAZ+P3wQDO2B25EEIIIVzO2s2Ht6DxDMF4AN+j8YN9NjNfsvO5NQBON/u5CMCIVsfMB7CNiP4AoBOAX1qIZTaA2QAQHR1t5/BCCCGEcJS1MwZPA/gOQD9mnsjMHzqQFNhrBoB3mbkHGhOQ94noipiYeTkzpzBzSkREhItDEEII0V6Ul5d7jRs3rnevXr2Se/funfzll1+6fddDpZmbc3p6eu/ExMSkxMTEJI1GMyAxMbHpUv3evXv9Bw8enNinT5/khISEpMuXL5Mj41k8Y+CCQknFaLkRUg9jW3O/BTDOON5uIvIDEI7GTZSEEEK0Y0qUIZ49e3bPW2+9teqLL744WVdXRzU1NXbV/LkasrKyQnfu3KmpqalRBwYGalNTU4uHDx/udGVFc3POyMg4aXr8wQcf7BEcHNwAADqdDr/5zW96rVy58tTIkSNrS0pKvNRqtfUNi1qxZ+fDtsoCEE9EvdCYEEwH8KtWxxSicbvld4moHwA/AGUKxiSEEOIqUKIM8fnz57327t0btHbt2nwA8PPzYz8/vwaXBe2ErKys0K1bt8bo9XoVANTU1Ki3bt0aAwDOJAe25mwwGPDZZ5+Fbt++PRcA1q9fH9yvX7/akSNH1gJAZGSkw6+PYpkWM+sBPApgKxpXMaxh5kNEtICITEWY/gTgQSLaD2A1gPvY1laMQgghPJ4SZYhzc3PVoaGh+rvuuiu2X79+SXfffXdMVVWVR5wx2Llzp8aUFJjo9XrVzp07nSrmYmvOW7duDQwPD9cNGDCg3ni8LxFh1KhR8UlJSf3+9re/dXN0THtWJfzbnjZzmHkLMycwcxwz/9PYNo+ZNxm/P8zMNzLzIGYezMzbHJ2AEEIIz6NEGWK9Xk9HjhwJeOSRR8qOHDlyOCAgwPD3v/89su1Ruk5NTY3ZeVlqt5etOX/wwQehU6ZMudD8+KysrMBPPvnk1N69e3M3b97cZePGjUGOjGlPpnWLmbbbHBlECCFEx6JEGeLY2Fhtt27dtGPGjLkEAHfffffF/fv3B7T1+VwpMDDQ7LwstdvL2px1Oh2++OKLLvfee29TYtCjRw/tiBEjqqOiovRBQUGGW265pTI7O9uh18hiYkBEvyeiAwD6GnclNH2dAiC1EoQQQlikRBni6OhofWRkpHb//v2+ALBt27bOffv2rXMyVJdITU0t9vb2bjFfb29vQ2pqqlNll63NeePGjZ179+5dFxcX11RW+c4776w6evSof3V1tUqn0+Hbb78NSk5Odug1snbz4Ydo3NBoIYDm2xlXM7PTd1kKIYS4dilVhvi1114rvOeee3prtVqKjo6uX716db5LAnaS6QZDJVYlWJrz6tWrQ++6664Wzx8REdHw6KOPnhsyZEg/IkJaWlrl9OnTKx0Zz2bZZaBpe+NuaJZIMHOhIwO5ipRdFkIIx0nZZdFcm8oumxDRo2jcofAcANNpEgYw0EXxCSGEEMJD2LOPwR8B9GXm8wrHIoQQQgg3s2dVwmkADl2fEEIIIUT7ZM8Zg5MAviaiDAD1pkZmXqRYVEIIIYRwC3sSg0Ljl9r4JYQQQohrlM3EgJmfAwAiCmDmy8qHJIQQQgh3sWdL5JFEdBjAUePPg4jodcUjE0IIIVrZv3+/r6nccGJiYlJgYOCQBQsWdHV3XEqxNF9LZZfr6upo6tSpsQkJCUl9+/ZN2rx5s0PbIQP2XUpYAmAsAFN9g/1E9AtHBxJCCNGxKFGGeNCgQfVHjx49DAB6vR6RkZGDpk+fXuGSgJ1UVLQq9FT+fzRabZlarY7Q9op9tLhHj3sUme+8efNKTcc0L7u8ePHicAA4duzY4eLiYu9bb701/rbbbjvi5eVl95h2VaVi5tOtmjyizKUQQgjPZCpDbCoiZCpDnJWVFeqqMTZt2tQ5Ojq6PiEhwal6BK5QVLQq9HjeP2O02lI1wNBqS9XH8/4ZU1S0StH5msouz5w58wIAHD582P/mm2+uAgCNRqPv3LlzwzfffOOaWgnNnCaiGwAwEfkQ0RNoLKMshBBCmKVUGeLmVq9eHTp16lSP2GPnVP5/NAZDfYv5Ggz1qlP5/1F0vq3LLg8aNOjy5s2bQ3Q6HY4ePao+ePBgQEFBgUMLB+y5lPAQgKUANACKAWwD8IgjgwghhOhYlCpDbFJXV0dffvll8KJFi4pc8XzO0mrLzM7LUrujLM23ddnlOXPmlB85csR/wIABSRqNpn7o0KE1jlxGAOxblVAO4B6HnlUIIUSHFhgYqDWXBDhbhthk7dq1wUlJSZd79uypd8XzOUutjtA2Xka4st0Vz29uvqayy99///1hU5uPjw/efvvtpsv/Q4YMSUxKSnKouqK1sst/Nv75GhG92vrLsSkJIYToSJQqQ2zy0UcfhU6bNs1jKv32in20WKXybTFflcrX0Cv2UcXma67scnV1taqqqkoFAJ9++mlnLy8vHjZsmMvKLpvuI2hzKUMiGofGyxBeAN5i5hfMHDMNjUWaGMB+Zv5VW8cTQgjhGZQsQ1xVVaXatWtX55UrVxY4H6lrmFYfuHpVAmB5vubKLp85c8Z77NixCSqViiMjI3UffvjhKUfHs6vsclsYSzUfA3ALgCIAWQBmMPPhZsfEA1gDYAwzXySirsxcavYJjaTsshBCOE7KLovmrJVdtmeDo+1EFNLs5y5EtNWOca8DkMfMJ5lZC+AjAJNaHfMggGXMfBEAbCUFQgghhFCWPcsVI5i5wvSD8UPcnl2mNGiszGhSZGxrLgFAAhF9S0R7jJcerkBEs4kom4iyy8rK7BhaCCGEEG1hT2LQQETRph+IKAaN9wO4gjeAeACjAcwA8GbzsxMmzLycmVOYOSUiIsJFQwshhBCiNXv2MfgrgF1EtBMAAbgJwGw7+hUD6Nns5x7GtuaKAOxlZh2AU0R0DI2JQpYdzy+EEEIIF7N5xoCZvwAwFMDHaLxPYBgz23OPQRaAeCLqRURqANNhrLfQzAY0ni0AEYWj8dLCSXuDF0IIIYRrWdvHINH451AA0QDOGL+ijW1WMbMewKMAtqJx6eMaZj5ERAuIaKLxsK0AzhurN+4A8CQze8T2lkIIIURHZO1Swlw0XjJ4xcxjDGCMrSdn5i0AtrRqm9fsezaOM9eeYIUQQnRszz33XNf3338/goiQmJh4+eOPP84PCAhQZt29h3j++ee7vvfeexHMjHvvvbds3rx5penp6b1PnDjhBwDV1dVeQUFBDUePHj386aefdv7b3/6m0el05OPjwwsXLiyaOHFitSPjWUsMthv//C0zy+l9IYQQDnF1GeJTp075LF++vFtubu7BwMBAHj9+fO+33nor9LHHHvOIM80ri8tDF+WXaEq1enVXtbd2bmxk8UxNuFMbHGVlZfm99957ET/88MMRPz8/Q2pqasLkyZMrMzIymj6Xm5dd7tq1qy4jIyMvNjZWl5WV5Zeenp5QWlqa48iY1u4xeNr451rHpyKEEKIjU6oMcUNDA126dEml0+lQW1ur6tGjh852L+WtLC4PnZdXHHNOq1czgHNavXpeXnHMyuJyp+Z74MAB/yFDhtQEBQUZfHx8cOONN1Z/9NFHIabHW5ddvvHGG2tjY2N1ADBs2LC6+vp6VW1tLTkyprXE4AIRbQPQm4g2tf5qw/yEEEJ0EEqUIe7Vq5fukUceKenVq9fArl27DgoKCmqYPHlylfPROm9Rfomm3sAt5ltvYNWi/BKnyi4PHjy49vvvvw8qKSnxqq6uVm3fvj349OnTTcWaWpddbm7lypVdkpOTL/v7+zt0qcXapYTxaFyN8D7M32cghBBCmKVEGeKysjKvjIyMkLy8vANhYWEN6enpvV9//fXQhx9+2O3FlEq1erPzstRur6FDh9bNmTOnJC0tLcHf39+QnJx8uXkZ5dZll02ys7P95s2bp/niiy+OOzqmtTMGbzPzHgBvMvPO1l+ODiSEEKLjsFRu2JkyxJ999lnn6Ojo+u7du+t9fX35jjvuqPjuu+8C2x6l63RVe5udl6V2Rzz++OPlhw4dOpKdnZ3bpUuXhoSEhDrg57LL9957b4vE4MSJEz5Tp07t8/bbb59KTk6+4kyCLdYSg2FE1B3APcb6CKHNvxwdSAghRMehRBni2NhY7Q8//BBYXV2tMhgM+Oqrr4L69evnUElhpcyNjSz2VVGL+fqqyDA3NtLpssvFxcXeAHD8+HF1RkZGyKxZsy4A5ssul5eXe40fPz7+ueeeK7r11lsvtWU8a5cS3gCQCaA3gH1o3PXQhI3tQgghxBWUKEM8ZsyYS7fffvvFgQMH9vP29kZycvLluXPnekQBHdPqA1evSgCAiRMnxlVUVHh7e3vzkiVLCsPDwxsA82WXX3zxxa6FhYW+Cxcu7L5w4cLuAJCZmXlMo9Ho7R3PZtllIvovM/++DXNRhJRdFkIIx0nZZdGcU2WXmfn3RDSKiO4HGrcuJqJeLo5RCCGEEB7AZmJARM8CeAo/72ugBvCBkkEJIYQQwj3sKbt8J4CJAC4BADOfARCkZFBCCCGEcA97EgOtsaYBAwARdVI2JCGEEEK4iz2JwRoi+h+AECJ6EMCXAN5UNiwhhBBCuIO15YoAAGZ+mYhuAVAFoC+Aecy83UY3IYQQQrRD9pwxAIAcADsBfA1gv2LRCCGEEFY8//zzXePj45P79OmTvGDBgq7ujudqMDfn9PT03omJiUmJiYlJGo1mQGJiYlLzPsePH1cHBAQMmTdvXjdHx7N5xoCIpgF4CY1JAQF4jYieZGapuiiEEMIiV5chtlSCuH///g5v+6uED/YUhL6aeVxTVl2vjgjy1T6WFl/86+tjrmrZZZM//OEPPVJTUyvbMqY9Zwz+CmA4M89k5nsBXAfg720ZTAghRMegRBliWyWI3emDPQWhz28+HFNaXa9mAKXV9ernNx+O+WBPwVUtuwwA77//fkhMTIy2rdtF25MYqJi5tNnP5+3sByIaR0S5RJRHRH+xctwUImIicmpXLiGEEJ5BiTLEtkoQu9Ormcc19XpDy/nqDapXM49f1bLLlZWVqldeeSXyxRdfPNPWMW1eSgDwBRFtBbDa+PPdAD631YmIvAAsA3ALgCIAWUS0iZkPtzouCMAcAHsdCVwIIYTnUqIMsa0SxO5UVl1vdl6W2u3laNnlJ598svujjz56Ljg42GD2Ce1gz5bITwL4H4CBxq/lzPxnO577OgB5zHySmbUAPgIwycxxzwP4NwCPqJAlhBDCeUqVIbZUgtjdIoJ8zc7LUrsjHCm7vG/fvk7PPvtsD41GM+DNN9/sunTp0qh//etfEY6MZzExIKI+RHQjADDzemaey8xzAZQRUZwdz60BcLrZz0XGtuZjDAXQk5kzrD0REc0momwiyi4r84hCWkIIIaxQqgyxpRLE7vZYWnyxr7eq5Xy9VYbH0uKvatnlffv25RYXFx8oLi4+8OCDD5bOmTPn7DPPPOPQB6e1SwlL8HN9hOYqjY/d7shArRGRCsAiAPfZOpaZlwNYDjRWV3RmXCGEEMpTqgyxpRLE7mZafeDqVQmAY2WXXcFi2WUiymLm4RYeO8DMA6w+MdFIAPOZeazx56cBgJkXGn8OBnACQI2xSySACwAmMrPFuspSdlkIIRwnZZdFc20tuxxi5TF/O8bNAhBPRL2ISA1gOoBNpgeZuZKZw5k5lpljAeyBjaRACCGEEMqylhhkG2sjtEBEswDss/XEzKwH8CiArQCOAFjDzIeIaAERTWxrwEIIIYRQjrV7DP4I4FMiugc/JwIpANRoLMVsEzNvAbClVds8C8eOtuc5hRBCCKEci4kBM58DcAMR3Qygv7E5g5m/uiqRCSGEEOKqs6e64g4AO65CLEIIIYRwM3urKwohhBCiA5DEQAghRLuQl5fnM2LEiIS4uLjkPn36JD///PNdAeDcuXNeN9xwQ3xMTEz/G264Ib6srMwz9klupyQxEEIIoYgP9hSEXvfPLwf0+kvGsOv++eUAZysN+vj44JVXXik6ceLEoaysrCNvv/1213379vk9++yzUaNHj64uKCg4OHr06Op58+ZFumoOHZE9RZSEEEIIh5jKEJsqDprKEAM/7xLoqJiYGF1MTIwOALp06WKIi4urLSwsVH/xxRchO3fuzAWA3/3ud+dTU1P7AnB6K+KOSs4YCCGEcDmlyhCb5Obmqg8fPhyQmppac/78eW9TwtCzZ0/d+fPn5ZdeJ0hiIIQQwuWUKkMMAJWVlarJkyfHvfDCC6dDQ0NbFC5SqVQgImeH6NAkMRBCCOFySpUhrq+vp/T09Li77rrrwsyZMysAICwsTF9QUOADAAUFBT6hoaF6Z8bo6CQxEEII4XJKlCE2GAyYPn16TEJCQt38+fPPmdrHjh1b8b///S8MAP73v/+FjRs3rqLNgQu5+VAIIYTrKVGGePv27YEbNmwIi4+Pr01MTEwCgOeee674ueeeO3vnnXfGxcTEhGs0Gu2nn356wlXz6IgkMRBCCKGIX18fc8GZRKC1sWPH1jCz2SJ+u3fvPuaqcTo6uZQghBBCiCaSGAghhBCiiSQGQggh7GUwGAyyFrCdM/4dGiw9LomBEEIIex0sKysLluSg/TIYDFRWVhYM4KClY+TmQyGEEHbR6/WzSkpK3iopKekP+cWyvTIAOKjX62dZOkDRxICIxgFYCsALwFvM/EKrx+cCmAVAD6AMwAPMXKBkTEIIIdpm2LBhpQAmujsOoSzFMj4i8gKwDMBtAJIAzCCipFaH/QgghZkHAlgL4EWl4hFCCCGEbUqeCroOQB4zn2RmLYCPAExqfgAz72Dmy8Yf9wDooWA8QgghhLBBycRAA+B0s5+LjG2W/BbA5+YeIKLZRJRNRNllZWUuDFEIIYQQzXnEzSNE9GsAKQBeMvc4My9n5hRmTomIiLi6wQkhhBAdiJI3HxYD6Nns5x7GthaI6JcA/goglZnrFYxHCCGEEDYoecYgC0A8EfUiIjWA6QA2NT+AiIYA+B+AicxcqmAsQgghhLCDYokBM+sBPApgK4AjANYw8yEiWkBEpuUuLwEIBPAJEf1ERJssPJ0QQgghrgJF9zFg5i0AtrRqm9fs+18qOb4QQgghHOMRNx8KIYQQwjNIYiCEEEKIJpIYCCGEEKKJJAZCCCGEaCKJgRBCCCGaSGIghBBCiCaSGAghhBCiiSQGQgghhGii6AZHQgghnHf2+6dx8sInqPMxwE+nQu/QuxB13UJ3hyWuUZIYCCFcYsPGdXhpby3OGELQXVWBJ0f4445JU2x3zFkDZC4AKouA4B5A2jxg4DRFY21PH7Rnv38aRyrWgNUAQKhTM45UrAG+h8fGLNo3SQyEEE7bsHEdnt5NqEUXAECxoQue3l0PYJ315CBnDTasW4WX6p/AGYShe915PLluFe4AFEsOzn7/NN45mod1J5/F+bouCPO7iCm9N+F+PO2RH7S5ZWux8uIMfJM3EoY6QOUH/KLPbtyv+xhR8Lx4Rfsn9xgIIZz20t5a1MK3RVstfPHS3lqr/TZs3oSn62eiGBFgqFCMCDxdPxMbNitXT+39Iyfx7tFf4XxdKADC+bpQvHv0V3j/yEnFxnTGiot34+vDI8F1AAHgOuDrwyOx4uLd7g5NXKMkMRBCOO2MIcRCe7DVfi9V/dJ8QlGlXH21j09NgNagbtGmNajx8akJio3pjP/LGwkytGwjQ2O7EEqQxEAI4bTuqgoL7ZVW+51BuEPtrnC+rotD7e5mqHOsXQhnSWIghHDakyP84Y/6Fm3+qMeTI/yt9usewA61u0Kkf71D7e6m8jP/37SldiGcJe8sIYTT7pg0BQtHMjSqiyAYoFFdxMKRbHNVwpO3D4W/V8skwN+L8eTtQxWL9S8Tr4efV0OLNj+vBvxl4vWKjemMGaN7g1XUoo1VhBmje7spInGtk1UJQgiXuGPSFNwxycE+QzQAgJe25uJMRS26h/jjybF9m9qV4I4xnfGv0X0BAB/tPIWG2gZ4+XthemqvpnYhXE3RxICIxgFYCsALwFvM/EKrx30BvAdgGIDzAO5m5nxXx3HX4mXIroxtWuqTEpyPTx5/RNG+zow5bfEyZDXrOzw4H2vs7NtW7WlMt8S65L/Iqoj+ecyQQqz54+/t6jt58VL8WNmnqe+Q4Dysf3yO7X5LFuHHir4/9wvJxfo/zrUv3kX/RlZV/5/j7XwQa+Y+ZVfftnr8nb9iW/RonKcwhPF53Fr4NRbf/0+b/bIO/Q8Vw29CLUWhgs8j69D/cMeQBYrGmpfzNcr7dUdtUHeUV1cgL+drYMg9io7pjH+N7iuJgLhqFLuUQEReAJYBuA1AEoAZRJTU6rDfArjIzH0ALAbwb1fHcdfiZfi+LLbFUp/vy2Jx1+JlivV1Zsxpi5dhb6u+e8tiMc2Ovm3VnsZ0S6xL/ou9pdEtxyyNxrQl/7XZd/LipdhX1qdF331lfTB58VLr/ZYswr7Svi37lfbF5CWLbMe76N/YW96/Zbzl/TFtkcv/eTV5/J2/Yl3M7TivigBIhfOqCKyLuR2Pv/NXq/3++sE8vN99fIt+73cfj79+ME+xWF9euQpLouJR2bkLQITKzl2wJCoeL69cpdiYQrQnSt5jcB2APGY+ycxaAB8BaH2icRKAlcbv1wJIIyKCC2VXxppd6pNdGatYX2fGzLLQN8uOvm3VnsZ0S6wV0ebHrIi22ffHyj5m+/5Y2cd6v4q+5vtV2P6tMauqv/l4q/rb7NtW26JHQ0t+Ldq05Idt0aOt9tsQdZPZfhuibnJ1iE3eDOkOvU/L5Yp6HzXeDOmu2JhCtCdKJgYaAKeb/VxkbDN7DDPrAVQCCGv9REQ0m4iyiSi7rKzMoSCcWerT1r7uGNMZ7WnM9hSrM33b23voPF3xz9Zqu7P9nFEZFOJQuxAdTbtYlcDMy5k5hZlTIiIiHOqr8nOs3RV93TGmM9rTmO0pVmf6trf3UBifd6jd2X7OCK6ucKhdiI5GycSgGEDPZj/3MLaZPYaIvAEEo/EmRJdJCc4Ht5olqxrblerrzJjDLfQdbkfftmpPY7ol1pBC82OGFNrsOyQ4z2zfIcF51vuF5JrvF5JrO97OB83H2/mgzb5tdWvh11Bzy1MSaq7DrYVfW+13x9n/M9vvjrP/5+oQmzxYcQbeOm2LNm+dFg9WnFFsTCHaEyUTgywA8UTUi4jUAKYDaL0B+iYAM43fTwXwFTO7dGeTTx5/BNdF5IP8AAZAfsB1EfatEGhrX2fGXPP4IxjRqu+ICGXvum9PY7ol1j/+HiO6FrYcs6t9qxLWPz4HwyLyWvQdFmF7VcL6P87FsK65Lft1tW9Vwpq5T2FE+MGW8YYruyph8f3/xJSCzxBmKAPYgDBDGaYUfGZzVcI/f70AvzmzpUW/35zZgn/+WrlVCU/MvAd/PHscwVUXAWYEV13EH88exxMzPXdVghBXE7n4c7jlkxONB7AEjcsVVzDzP4loAYBsZt5ERH4A3gcwBMAFANOZ2Wolk5SUFM7OzlYsZiHEtS/jZAaW/rAUJZdKENkpEnOGzkF673R3h6UoItrHzCnujkN4PkX3MWDmLQC2tGqb1+z7OgB3KRmDEB3Rsb0l2L3xBGou1CMw1BcjJ8UhYUSkomPm5OQgMzMTlZWVCA4ORlpaGgYOHGiz34pNO5H7w3fw43rUkS/6Dr0BD0xMVSzOjJMZ+PuuZ6Hjxi2Qz146i7/vehYAPDY5+PrtBfBZvgYhlQ2oCPaCbvY0jP6tcks6Rcem6BkDJcgZA9HeXPqxFFVb89FQUQ+vEF90HhuLTkO62ux3Yu0xGLLPwY8ZdURQpXRD3NQEm/2O7S3Bd+t2otTvJC5TPQLYF13reuOGKamKJQc5OTnYuGETGgz6pjYvlTcm3THRanKwYtNOnNq3E17N1lc2sAq9hqUqlhyM+jANtxy/Cf4Nvk2vT61XPbbH/x92/SpTkTGd8fXbC3DhWwPyevwcb5+ieoTeqHIoOZAzBsJe7WJVghDt1aUfS1Gx/jgaKhp/O22oqEfF+uO49GOp1X4n1h6DV1YJ/AEQEfwBeGWV4MTaYzbH3LvxG5z2z8VlVT1AwGVVPU7752Lvxm9cMCPzvtiyrUVSAAANBj2+2LLNar8T+75rkRQAgBcZcGLfdy6P0eSW4zdBZVC1eH1UBhVuOa7c3gnOKN1jwKGeLeM91FOF0j0G252FaANJDIRQUNXWfLCu5X/grDOgamu+1X6G7HPwbrXXlzcRDNnnbI551vsEGlp92DaQAWe9T9gXdBtcrq1xqN3EB+YrGlpqdwX/Bl+zr49/g69iYzojP8p8vPlRnhmvaP8kMRBCQaYzBfa2m/hZuMRnqb25y2T+uS21u0IAm/+QstTubD9nuOP1cUZ7i1e0f5IYCKEgrxDzH3CW2k3qLOwMbqm9uU5kficjS+2uMFwfB69Wmyd4sQrD9XGK9HOGO5IRZ7S3eEX7J4mBEArqPDYW5NPynxn5qNB5bKzVfqqUbtC3OjugZ4YqpZvNMUcPHWX2w3b00FH2Bd0Gcb49cZMuEYGGxs0TAg1+uEmXiDjfnor0c8aQ6KFmX58h0UMVG9MZmpBks/FqQpLdFJG41im6XFGIjs60+sDRVQlxUxNwAoCu+aqE4ZF2rUoYPrExAdj5wy7UcB0CyQ+pw0Y1tSshbGIcaG0D+mijmtrYixA60fpv/m3t54xbZo0F3gJ+LPwRl6kOAeyHIdFDGts90D1zJ2LVIqC44lDTqgRNSDLumTvR3aGJa5QsVxRCuERbl2W2tZ9wjCxXFPaSMwZCCJfoNKRrmz7Q29pPCKEMucdACCGEEE0kMRBCCCFEE0kMhBBCCNFEEgMhhBBCNJHEQAghhBBN2t1yRSIqA1DQxu7hAMpdGM61SF4j6+T1sU1eI+vc9frEMHOEG8YV7Uy7SwycQUTZso7XOnmNrJPXxzZ5jayT10d4OrmUIIQQQogmkhgIIYQQoklHSwyWuzuAdkBeI+vk9bFNXiPr5PURHq1D3WMghBBCCOs62hkDIYQQQlghiYEQQgghmnSYxICIxhFRLhHlEdFf3B2PJyKifCI6QEQ/EVGHr21NRCuIqJSIDjZrCyWi7UR03PhnF3fG6G4WXqP5RFRsfB/9RETj3RmjOxFRTyLaQUSHiegQEc0xtsv7SHisDpEYEJEXgGUAbgOQBGAGESW5NyqPdTMzD5Z11gCAdwGMa9X2FwCZzBwPINP4c0f2Lq58jQBgsfF9NJiZt1zlmDyJHsCfmDkJwPUAHjH+3yPvI+GxOkRiAOA6AHnMfJKZtQA+AjDJzTEJD8fM3wC40Kp5EoCVxu9XArjjasbkaSy8RsKImc8y8w/G76sBHAGggbyPhAfrKImBBsDpZj8XGdtESwxgGxHtI6LZ7g7GQ3Vj5rPG70sAdHNnMB7sUSLKMV5qkNPkAIgoFsAQAHsh7yPhwTpKYiDsM4qZh6LxkssjRPQLdwfkybhxra+s973SfwHEARgM4CyAV9wajQcgokAA6wD8kZmrmj8m7yPhaTpKYlAMoGezn3sY20QzzFxs/LMUwKdovAQjWjpHRFEAYPyz1M3xeBxmPsfMDcxsAPAmOvj7iIh80JgUrGLm9cZmeR8Jj9VREoMsAPFE1IuI1ACmA9jk5pg8ChF1IqIg0/cAbgVw0HqvDmkTgJnG72cC2OjGWDyS6QPP6E504PcRERGAtwEcYeZFzR6S95HwWB1m50PjkqklALwArGDmf7o3Is9CRL3ReJYAALwBfNjRXyMiWg1gNBrL5J4D8CyADQDWAIhGY/nvaczcYW++s/AajUbjZQQGkA/gd82up3coRDQKwP8BOADAYGx+Bo33Gcj7SHikDpMYCCGEEMK2jnIpQQghhBB2kMRACCGEEE0kMRBCCCFEE0kMhBBCCNFEEgMhhBBCNJHEQFxziOivxkp2OcbqfiPcGMsfiSjAwmMTiOhHItpvrL73O2P7Q0R079WNVAghGslyRXFNIaKRABYBGM3M9UQUDkDNzGfcEIsXgBMAUpi5vNVjPmhcv34dMxcRkS+AWGbOvdpxCiFEc3LGQFxrogCUM3M9ADBzuSkpIKJ8Y6IAIkohoq+N388noveJaDcRHSeiB43to4noGyLKIKJcInqDiFTGx2YQ0QEiOkhE/zYNTkQ1RPQKEe0H8FcA3QHsIKIdreIMQuNGUueNcdabkgJjPE8QUXfjGQ/TVwMRxRBRBBGtI6Is49eNSr2YQoiORxIDca3ZBqAnER0joteJKNXOfgMBjAEwEsA8IupubL8OwB8AJKGxMNBk42P/Nh4/GMBwIrrDeHwnAHuZeRAzLwBwBsDNzHxz88GMu9xtAlBARKuJ6B5T0tHsmDPMPJiZB6Ox5sA6Zi4AsBTAYmYeDmAKgLfsnKMQQtgkiYG4pjBzDYBhAGYDKAPwMRHdZ0fXjcxcazzlvwM/F/75nplPMnMDgNUARgEYDuBrZi5jZj2AVQBMlSgb0Fgwx55YZwFIA/A9gCcArDB3nPGMwIMAHjA2/RLAf4joJzQmF52N1fuEEMJp3u4OQAhXM36Ifw3gayI6gMYiNe8C0OPnZNivdTcLP1tqt6TOOL69sR4AcICI3gdwCsB9zR83FiR6G8BEY9IDNM7hemaus3ccIYSwl5wxENcUIupLRPHNmgaj8SY/oLGgzzDj91NadZ1ERH5EFIbGIkBZxvbrjFU5VQDuBrALjb/hpxJRuPEGwxkAdloIqRqN9xO0jjOQiEZbiNN0jA+ATwA8xczHmj20DY2XN0zHDbYwthBCOEwSA3GtCQSw0rj8LweN9wbMNz72HIClRJSNxlP+zeWg8RLCHgDPN1vFkAXgPwCOoPE3+k+NlQL/Yjx+P4B9zGypbO5yAF+YufmQAPzZeFPjT8bY7mt1zA0AUgA81+wGxO4AHgOQYlyOeRjAQ7ZeFCGEsJcsVxQdHhHNB1DDzC+3ah8N4AlmnuCGsIQQwi3kjIEQQgghmsgZAyGEEEI0kTMGQgghhGgiiYEQQgghmkhiIIQQQogmkhgIIYQQookkBkIIIYRo8v9hvEJ56o1JcwAAAABJRU5ErkJggg==\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ax = fit_model.plot(include_legend=True)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "The legend of the plot presents the variables in the order they entered the regularization path. For example, variable 7 is the first variable to enter the path, and variable 6 is the second to enter. Thus, roughly speaking, we can view the first $k$ variables in the legend as the best subset of size $k$. To show the lines connecting the points in the plot, we can set the parameter :code:`show_lines=True` in the `plot` function, i.e., call :code:`fit.plot(fit, gamma=0, show_lines=True)`. Moreover, we note that the plot function returns a [matplotlib.axes._subplots.AxesSubplot](https://pandas.pydata.org/pandas-docs/version/0.21/visualization.html) object, which can be further customized using the `matplotlib` package. In addition, both the [l0learn.models.FitModel.plot()](code.rst#l0learn.models.FitModel.plot) and [l0learn.models.CVFitModel.cv_plot()](code.rst#l0learn.models.CVFitModel.cv_plot) accept :code:`**kwargs` parameter to allow for customization of the plotting behavior.\n" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 11, + "outputs": [ + { + "data": { + "text/plain": "" + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fit_model.plot(show_lines=True)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "## Fitting L0L2 and L0L1 Regression Models\n", + "We have demonstrated the simple case of using an L0 penalty. We can also fit more elaborate models that combine L0 regularization with shrinkage-inducing penalties like the L1 norm or squared L2 norm. Adding shrinkage helps in avoiding overfitting and typically improves the predictive performance of the models. Next, we will discuss how to fit a model using the L0L2 penalty for a two-dimensional grid of :math:`\\lambda` and :math:`\\gamma` values. Recall that by default, `l0learn` automatically selects the :math:`\\lambda` sequence, so we only need to specify the :math:`\\gamma` sequence. Suppose we want to fit an L0L2 model with a maximum of 20 non-zeros and a sequence of 5 :math:`\\gamma` values ranging between 0.0001 and 10. We can do so by calling [l0learn.fit](code.rst#l0learn.fit) with :code:`penalty=\"L0L2\"`, :code:`num_gamma=5`, :code:`gamma_min=0.0001`, and :code:`gamma_max=10` as follows:" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 12, + "outputs": [], + "source": [ + "fit_model_2 = l0learn.fit(X, y, penalty=\"L0L2\", num_gamma = 5, gamma_min = 0.0001, gamma_max = 10, max_support_size=20)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "`l0learn` will generate a grid of 5 :math:`\\gamma` values equi-spaced on the logarithmic scale between 0.0001 and 10. Similar to the case for L0, we can display a summary of the regularization path using the [l0learn.models.FitModel.characteristics](code.rst#l0learn.models.FitModel.characteristics) function as follows:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 14, + "outputs": [ + { + "data": { + "text/plain": "FitModel({'loss': 'SquaredError', 'intercept': True, 'penalty': 'L0L2'})", + "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
l0support_sizeinterceptconvergedl2
00.0037880-0.156704True10.0000
10.0037501-0.156250True10.0000
20.0029112-0.148003True10.0000
30.0026543-0.148650True10.0000
40.0025973-0.148650True10.0000
..................
1280.000216100.002130True0.0001
1290.00017313-0.003684True0.0001
1300.00016713-0.003685True0.0001
1310.00013418-0.015724True0.0001
1320.00013021-0.012762True0.0001
\n

133 rows × 5 columns

\n
" + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fit_model_2 # Using ipython Rich Display\n", + "# fit_model_2.characteristics() # For non Rich Display" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "The sequence of $\\gamma$ values can be accessed using `fit_model_2.gamma`. To extract a solution we use the [l0learn.models.FitModel.coeff](code.rst#l0learn.models.FitModel.coeff) method. For example, extracting the solution at $\\lambda=0.0016$ and $\\gamma=10$ can be done using:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 40, + "outputs": [ + { + "data": { + "text/plain": "<1001x1 sparse matrix of type ''\n\twith 11 stored elements in Compressed Sparse Column format>" + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fit_model_2.coeff(lambda_0=0.0016, gamma=10)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Similarly, we can predict the response at this pair of $\\lambda$ and $\\gamma$ for the matrix X using" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 41, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[-0.31499242]\n", + " [-0.3474209 ]\n", + " [-0.23997924]\n", + " ...\n", + " [-0.06707991]\n", + " [-0.18562493]\n", + " [-0.25608131]]\n" + ] + } + ], + "source": [ + "with np.printoptions(threshold=10):\n", + " print(fit_model_2.predict(x=X, lambda_0=0.0016, gamma=10))" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "The regularization path can also be plotted at a specific $\\gamma$ using `fit_model_2.plot(gamma=10)`. Here we can see the influence of ratio of $\\gamma$ and $\\lambda$. Since $\\gamma$ is so large ($10$) maintaining sparisity, then $\\lambda$ can be quite small $0.0016$ which this results in a very stable estimate of the magnitude of the coeffs." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 44, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/tnonet/Documents/GitHub/L0Learn/python/l0learn/models.py:438: UserWarning: Duplicate solution seen at support size 3. Plotting only first solution\n", + " warnings.warn(f\"Duplicate solution seen at support size {support_size}. Plotting only first solution\")\n", + "/Users/tnonet/Documents/GitHub/L0Learn/python/l0learn/models.py:438: UserWarning: Duplicate solution seen at support size 10. Plotting only first solution\n", + " warnings.warn(f\"Duplicate solution seen at support size {support_size}. Plotting only first solution\")\n", + "/Users/tnonet/Documents/GitHub/L0Learn/python/l0learn/models.py:438: UserWarning: Duplicate solution seen at support size 11. Plotting only first solution\n", + " warnings.warn(f\"Duplicate solution seen at support size {support_size}. Plotting only first solution\")\n", + "/Users/tnonet/Documents/GitHub/L0Learn/python/l0learn/models.py:438: UserWarning: Duplicate solution seen at support size 12. Plotting only first solution\n", + " warnings.warn(f\"Duplicate solution seen at support size {support_size}. Plotting only first solution\")\n" + ] + }, + { + "data": { + "text/plain": "" + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fit_model_2.plot(gamma=10, show_lines=True)\n" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Finally, we note that fitting an L0L1 model can be done by just changing the `penalty` to \"L0L1\" in the above (in this case `gamma_max` will be ignored since it is automatically selected by the toolkit; see the reference manual for more details.)\n", + "\n", + "## Higher-quality Solutions using Local Search\n", + "By default, `l0learn` uses coordinate descent (CD) to fit models. Since the objective function is non-convex, the choice of the optimization algorithm can have a significant effect on the solution quality (different algorithms can lead to solutions with very different objective values). A more elaborate algorithm based on combinatorial search can be used by setting the parameter `algorithm=\"CDPSI\"` in the call to `l0learn.fit`. `CDPSI` typically leads to higher-quality solutions compared to CD, especially when the features are highly correlated. CDPSI is slower than CD, however, for typical applications it terminates in the order of seconds.\n", + "\n", + "## Cross-validation\n", + "We will demonstrate how to use K-fold cross-validation (CV) to select the optimal values of the tuning parameters $\\lambda$ and $\\gamma$. To perform CV, we use the [l0learn.cvfit](code.rst#l0learn.cvfit) function, which takes the same parameters as [l0learn.fit](code.rst#l0learn.fit), in addition to the number of folds using the `num_folds` parameter and a seed value using the `seed` parameter (this is used when randomly shuffling the data before performing CV).\n", + "\n", + "For example, to perform 5-fold CV using the `L0L2` penalty (over a range of 5 `gamma` values between 0.0001 and 0.1) with a maximum of 50 non-zeros, we run:" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 45, + "outputs": [], + "source": [ + "cv_fit_result = l0learn.cvfit(X, y, num_folds=5, seed=1, penalty=\"L0L2\", num_gamma=5, gamma_min=0.0001, gamma_max=0.1, max_support_size=50)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Note that the object returned during cross validation is [l0learn.models.CVFitModel](code.rst#l0learn.models.CVFitModel) which subclasses [l0learn.models.FitModel](code.rst#l0learn.models.FitModel) and thus has the same methods and underlinying structure. The cross-validation errors can be accessed using the `cv_means` attribute of a `CVFitModel`: `cv_fit_result.cv_means` is a list where the ith element, `cv_fit_result.cv_means[i]`, stores the cross-validation errors for the ith value of gamma `cv_fit_result.gamma[i]`). To find the minimum cross-validation error for every `gamma`, we apply the :code:`np.argmin` function for every element in the list :`cv_fit_result.cv_means`, as follows:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 52, + "outputs": [ + { + "data": { + "text/plain": "[(0, 8, 0.5313128699361661),\n (1, 8, 0.2669789604993652),\n (2, 8, 0.2558807301729078),\n (3, 20, 0.25555788170828786),\n (4, 19, 0.2555564968851251)]" + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gamma_mins = [(i, np.argmin(cv_mean), np.min(cv_mean)) for i, cv_mean in enumerate(cv_fit_result.cv_means)]\n", + "gamma_mins" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "The above output indicates that the 5th value of gamma achieves the lowest CV error (`=0.255`). We can plot the CV errors against the support size for the 5th value of gamma, i.e., `gamma = cv_fit_result.gamma[4]`, using:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 50, + "outputs": [ + { + "data": { + "text/plain": "" + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "cv_fit_result.cv_plot(gamma = cv_fit_result.gamma[4])\n", + "cv_fit_result.cv_sds" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "The above plot is produced using the [matplotlib](https://pandas.pydata.org/pandas-docs/version/0.21/visualization.html) package and returns a [matplotlib.axes._subplots.AxesSubplot](https://pandas.pydata.org/pandas-docs/version/0.21/visualization.html) which can be further customized by the user. We can also note that we have error bars in the cross validation error which is stored in `cv_sds` attribute and can be accessed with `cv_fit_result.cv_sds`. To extract the optimal $\\lambda$ (i.e., the one with minimum CV error) in this plot, we execute the following:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 57, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4 19 0.2555564968851251\n", + "Optimal lambda = 0.0016080760437896327\n" + ] + } + ], + "source": [ + "optimal_gamma_index, optimal_lambda_index, min_error = min(gamma_mins, key = lambda t: t[2])\n", + "print(optimal_gamma_index, optimal_lambda_index, min_error)\n", + "print(\"Optimal lambda = \", fit_model_2.lambda_0[optimal_gamma_index][optimal_lambda_index])" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "To print the solution corresponding to the optimal gamma/lambda pair:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 58, + "outputs": [ + { + "data": { + "text/plain": "<1001x1 sparse matrix of type ''\n\twith 11 stored elements in Compressed Sparse Column format>" + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cv_fit_result.coeff(lambda_0=fit_model_2.lambda_0[optimal_gamma_index][optimal_lambda_index],\n", + " gamma=fit_model_2.gamma[optimal_gamma_index])" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "The optimal solution (above) selected by cross-validation correctly recovers the support of the true vector of coefficients used to generate the model." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 70, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1.01994648 1. ]\n", + " [0.97317979 1. ]\n", + " [0.99813347 1. ]\n", + " [0.99669481 1. ]\n", + " [1.01128182 1. ]\n", + " [1.00190748 1. ]\n", + " [1.01272103 1. ]\n", + " [0.99204841 1. ]\n", + " [0.99607406 1. ]\n", + " [1.0266543 1. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " ...\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]]\n" + ] + } + ], + "source": [ + "beta_vector = cv_fit_result.coeff(lambda_0=fit_model_2.lambda_0[optimal_gamma_index][optimal_lambda_index],\n", + " gamma=fit_model_2.gamma[optimal_gamma_index],\n", + " include_intercept=False).toarray()\n", + "\n", + "with np.printoptions(threshold=30, edgeitems=15):\n", + " print(np.hstack([beta_vector, B.reshape(-1, 1)]))" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "## Fitting Classification Models\n", + "All the commands and plots we have seen in the case of regression extend to classification. We currently support logistic regression (using the parameter `loss=\"Logistic\"`) and a smoothed version of SVM (using the parameter `loss=\"SquaredHinge\"`). To give some examples, we first generate a synthetic classification dataset (similar to the one we generated in the case of regression):" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 72, + "outputs": [], + "source": [ + "import numpy as np\n", + "np.random.seed(4) # fix the seed to get a reproducible result\n", + "n, p, k = 500, 1000, 10\n", + "X = np.random.normal(size=(n, p))\n", + "B = np.zeros(p)\n", + "B[:k] = 1\n", + "e = np.random.normal(size=(n,))/2\n", + "y = np.sign(X@B + e)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "More expressive and complete functions for generating datasets can be found are available in [l0learn.models](code.rst#l0learn.models). The available functions are:\n", + "\n", + "* [l0learn.models.gen_synthetic()](code.rst#l0learn.models.gen_synthetic)\n", + "* [l0learn.models.gen_synthetic_high_corr()](code.rst#l0learn.models.gen_synthetic_high_corr)\n", + "* [l0learn.models.gen_synthetic_logistic()](code.rst#l0learn.models.gen_synthetic_logistic)\n", + "\n", + "An L0-regularized logistic regression model can be fit by specificying `loss = \"Logistic\"` as follows:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 117, + "outputs": [ + { + "data": { + "text/plain": "FitModel({'loss': 'Logistic', 'intercept': True, 'penalty': 'L0L2'})", + "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
l0support_sizeinterceptconvergedl2
025.2253361-0.036989True1.000000e-07
119.4320532-0.043199True1.000000e-07
218.9286032-0.043230True1.000000e-07
315.1428822-0.043245True1.000000e-07
412.11430690.004044True1.000000e-07
57.411211100.188422False1.000000e-07
67.188875100.219990False1.000000e-07
75.751100100.234899False1.000000e-07
84.600880100.242631False1.000000e-07
93.680704100.243655True1.000000e-07
102.944563100.243993True1.000000e-07
112.355651100.244295True1.000000e-07
121.884520100.244520True1.000000e-07
131.507616100.244716True1.000000e-07
141.206093100.244886True1.000000e-07
150.964874100.245011True1.000000e-07
160.771900100.245133True1.000000e-07
170.617520120.178144False1.000000e-07
180.598994120.196406False1.000000e-07
190.479195120.208883False1.000000e-07
200.383356150.192033False1.000000e-07
210.371856150.221470False1.000000e-07
220.297484150.246182False1.000000e-07
230.23798816-0.110626False1.000000e-07
240.23084816-0.118558False1.000000e-07
250.18467816-0.124533False1.000000e-07
260.14774321-0.211002False1.000000e-07
\n
" + }, + "execution_count": 117, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fit_model_3 = l0learn.fit(X,y,loss=\"Logistic\", max_support_size=20)\n", + "fit_model_3" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "The output above indicates that $\\gamma=10^{-7}$ by default we use a small ridge regularization (with $\\gamma=10^{-7}$) to ensure the existence of a unique solution. To extract the coefficients of the solution with $\\lambda = 8.69435$ we use the following code. Notice that we can ignore the specification of gamma as there is only one gamma used in L0 Logistic regression:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 83, + "outputs": [], + "source": [ + "np.where(fit_model_3.coeff(lambda_0=7.411211).toarray() > 0)[0]" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "The above indicates that the 10 non-zeros in the estimated model match those we used in generating the data (i.e, L0 regularization correctly recovered the true support). We can also make predictions at the latter $\\lambda$ using:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 84, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1.69583037e-04]\n", + " [4.92440655e-06]\n", + " [3.92195535e-03]\n", + " ...\n", + " [9.99161941e-01]\n", + " [1.69035746e-01]\n", + " [9.99171256e-04]]\n" + ] + } + ], + "source": [ + "with np.printoptions(threshold=10):\n", + " print(fit_model_3.predict(X, lambda_0=7.411211))" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Each row in the above is the probability that the corresponding sample belongs to class $1$. Other models (i.e., L0L2 and L0L1) can be similarly fit by specifying `loss = \"Logistic\"`.\n", + "\n", + "Finally, we note that L0Learn also supports a smoothed version of SVM by using squared hinge loss `loss = \"SquaredHinge\"`. The only difference from logistic regression is that the `predict` function returns $\\beta_0 + \\langle x, \\beta \\rangle$ (where $x$ is the testing sample), instead of returning probabilities. The latter predictions can be assigned to the appropriate classes by using a thresholding function (e.g., the sign function)." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "## Advanced Options\n", + "\n", + "### Sparse Matrix Support\n", + "Starting in version 2.0.0, L0Learn supports sparse matrices of type [scipy.sparse.csc_matrix](https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.csc_matrix.html). If your sparse matrix uses a different storage format, please convert it to `csc_matrix` before using it in `l0learn`. `l0learn` keeps the matrix sparse internally and thus is highly efficient if the matrix is sufficiently sparse. The API for sparse matrices is the same as that of dense matrices, so all the demonstrations in this vignette also apply for sparse matrices. For example, we can fit an L0-regularized model on a sparse matrix as follows:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 90, + "outputs": [ + { + "data": { + "text/plain": " l0 support_size intercept converged\n0 0.031892 0 0.009325 True\n1 0.031573 1 0.004882 True\n2 0.020606 2 -0.002187 True\n3 0.014442 3 -0.004111 True\n4 0.013932 4 -0.002556 True\n5 0.010854 5 0.002987 True\n6 0.009286 6 0.002048 True\n7 0.009191 7 -0.001371 True\n8 0.008771 8 -0.000533 True\n9 0.008151 9 0.000064 True\n10 0.006480 11 0.001587 True\n11 0.006364 12 -0.003636 True\n12 0.005760 13 -0.003866 True\n13 0.005560 15 -0.004211 True\n14 0.005264 17 0.001497 True\n15 0.004637 18 -0.000797 True\n16 0.004515 19 -0.002634 True\n17 0.004113 22 0.001419 True", + "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
l0support_sizeinterceptconverged
00.03189200.009325True
10.03157310.004882True
20.0206062-0.002187True
30.0144423-0.004111True
40.0139324-0.002556True
50.01085450.002987True
60.00928660.002048True
70.0091917-0.001371True
80.0087718-0.000533True
90.00815190.000064True
100.006480110.001587True
110.00636412-0.003636True
120.00576013-0.003866True
130.00556015-0.004211True
140.005264170.001497True
150.00463718-0.000797True
160.00451519-0.002634True
170.004113220.001419True
\n
" + }, + "execution_count": 90, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from scipy.sparse import random\n", + "from scipy.stats import norm\n", + "\n", + "\n", + "X_sparse = random(n, p, density=0.01, format='csc', data_rvs=norm().rvs)\n", + "y_sparse = (X_sparse@B + e)\n", + "\n", + "fit_model_sparse = l0learn.fit(X_sparse, y_sparse, penalty=\"L0\", max_support_size=20)\n", + "\n", + "fit_model_sparse.characteristics()" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "### Selection on Subset of Variables\n", + "In certain applications, it is desirable to always include some of the variables in the model and perform variable selection on others. `l0learn` supports this option through the `exclude_first_k` parameter. Specifically, setting `exclude_first_k = K` (where K is a non-negative integer) instructs `l0learn` to exclude the first K variables in the data matrix `X` from the L0-norm penalty (those K variables will still be penalized using the L2 or L1 norm penalties.). For example, below we fit an `L0` model and exclude the first 3 variables from selection by setting `excludeFirstK = 3`:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 94, + "outputs": [ + { + "data": { + "text/plain": " l0 support_size intercept converged\n0 0.050464 3 -0.017599 True\n1 0.044333 4 -0.021333 True\n2 0.032770 5 -0.027624 True\n3 0.029367 7 -0.029115 True\n4 0.024710 8 -0.021199 True\n5 0.021393 9 0.010249 True\n6 0.014785 10 0.016812 True", + "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
l0support_sizeinterceptconverged
00.0504643-0.017599True
10.0443334-0.021333True
20.0327705-0.027624True
30.0293677-0.029115True
40.0247108-0.021199True
50.02139390.010249True
60.014785100.016812True
\n
" + }, + "execution_count": 94, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fit_model_k = l0learn.fit(X, y, penalty=\"L0\", max_support_size=10, exclude_first_k=3)\n", + "fit_model_k.characteristics()" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Plotting the regularization path:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 93, + "outputs": [ + { + "data": { + "text/plain": "" + }, + "execution_count": 93, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fit_model_k.plot(show_lines=True)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "We can see in the plot above that first 3 variables, (0, 1, 2) are included in all the solutions of the path\n", + "\n", + "### Coefficient Bounds\n", + "Starting in version 2.0.0, `l0learn` supports bounds for CD algorithms for all losses and penalties. (We plan to support bound constraints for the CDPSI algorithm in the future). By default, `l0learn` does not apply bounds, i.e., it assumes $-\\infty <= \\beta_i <= \\infty$ for all i. Users can supply the same bounds for all coefficients by setting the parameters `lows` and `highs` to scalar values (these should satisfy: `lows <= 0`, `lows != highs`, and `highs >= 0`). To use different bounds for the coefficients, `lows` and `highs` can be both set to vectors of length `p` (where the i-th entry corresponds to the bound on coefficient i).\n", + "\n", + "All of the following examples are valid." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 107, + "outputs": [], + "source": [ + "l0learn.fit(X, y, penalty=\"L0\", lows=-0.5)\n", + "l0learn.fit(X, y, penalty=\"L0\", highs=0.5)\n", + "l0learn.fit(X, y, penalty=\"L0\", lows=-0.5, highs=0.5)\n", + "\n", + "max_value = 0.25\n", + "highs_array = max_value*np.ones(p)\n", + "highs_array[0] = 0.1\n", + "fit_model_bounds = l0learn.fit(X, y, penalty=\"L0\", lows=-0.1, highs=highs_array, max_support_size=20)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "We can see the coefficients are subject to the bounds." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 110, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/tnonet/Documents/GitHub/L0Learn/python/l0learn/models.py:438: UserWarning: Duplicate solution seen at support size 0. Plotting only first solution\n", + " warnings.warn(f\"Duplicate solution seen at support size {support_size}. Plotting only first solution\")\n", + "/Users/tnonet/Documents/GitHub/L0Learn/python/l0learn/models.py:438: UserWarning: Duplicate solution seen at support size 6. Plotting only first solution\n", + " warnings.warn(f\"Duplicate solution seen at support size {support_size}. Plotting only first solution\")\n", + "/Users/tnonet/Documents/GitHub/L0Learn/python/l0learn/models.py:438: UserWarning: Duplicate solution seen at support size 8. Plotting only first solution\n", + " warnings.warn(f\"Duplicate solution seen at support size {support_size}. Plotting only first solution\")\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "maximum value of coefficients = 0.25 <= 0.25\n", + "maximum value of first coefficient = 0.1 <= 0.1\n", + "minimum value of coefficient = -0.1 >= -0.1\n" + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fit_model_bounds.plot(show_lines=True)\n", + "\n", + "print(f\"maximum value of coefficients = {np.max(fit_model_bounds.coeffs[0])} <= {max_value}\")\n", + "print(f\"maximum value of first coefficient = {np.max(fit_model_bounds.coeffs[0][0, :])} <= 0.1\")\n", + "print(f\"minimum value of coefficient = {np.min(fit_model_bounds.coeffs[0])} >= -0.1\")\n" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "### User-specified Lambda Grids\n", + "By default, `l0learn` selects the sequence of lambda values in an efficient manner to avoid wasted computation (since close $\\lambda$ values can typically lead to the same solution). Advanced users of the toolkit can change this default behavior and supply their own sequence of $\\lambda$ values. This can be done supplying the $\\lambda$ values through the parameter `lambda_grid`. When `lambda_grid` is supplied, we require `num_gamma` and `num_lambda` to be `None` to ensure the is no ambiguity in the solution path requested.\n", + "\n", + "Specifically, the value assigned to `lambda_grid` should be a list of lists/arrays of decreasing positive values (floats). The length of `lambda_grid` (the number of lists stored) specifies the number of gamma parameters that will fill between `gamma_min`, and `gamma_max`. In the case of L0 penalty, `lambda_grid` must be a list of length 1. In case of L0L2/L0L1 `lambda_grid` can have any number of sub-lists stored. The ith element in `lambda_grid` should be a **strictly decreasing** sequence of positive lambda values which are used by the algorithm for the ith value of gamma. For example, to fit an L0 model with the sequence of user-specified lambda values: 1, 1e-1, 1e-2, 1e-3, 1e-4, we run the following:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 113, + "outputs": [], + "source": [ + "user_lambda_grid = [[1, 1e-1, 1e-2, 1e-3, 1e-4]]\n", + "fit_grid = l0learn.fit(X, y, penalty=\"L0\", lambda_grid=user_lambda_grid, max_support_size=1000, num_lambda=None, num_gamma=None)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "To verify the results we print the fit object:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 114, + "outputs": [ + { + "data": { + "text/plain": "FitModel({'loss': 'SquaredError', 'intercept': True, 'penalty': 'L0'})", + "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
l0support_sizeinterceptconverged
01.00000-0.016000True
10.10000-0.016000True
20.0100100.016811True
30.0010620.018729True
40.00012670.051675True
\n
" + }, + "execution_count": 114, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fit_grid\n", + "# Use fit_grid.characteristics() for those without rich dispalys" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Note that the $\\lambda$ values above are the desired values. For L0L2 and L0L1 penalties, the same can be done where the `lambda_grid` parameter." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 115, + "outputs": [], + "source": [ + "user_lambda_grid_L2 = [[1, 1e-1, 1e-2, 1e-3, 1e-4],\n", + " [10, 2, 1, 0.01, 0.002, 0.001, 1e-5],\n", + " [1e-4, 1e-5]]\n", + "\n", + "# user_lambda_grid_L2[[i]] must be a sequence of positive decreasing reals.\n", + "fit_grid_L2 = l0learn.fit(X, y, penalty=\"L0L2\", lambda_grid=user_lambda_grid_L2, max_support_size=1000, num_lambda=None, num_gamma=None)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 116, + "outputs": [ + { + "data": { + "text/plain": "FitModel({'loss': 'SquaredError', 'intercept': True, 'penalty': 'L0L2'})", + "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
l0support_sizeinterceptconvergedl2
01.000000-0.016000True10.000000
10.100000-0.016000True10.000000
20.010000-0.016000True10.000000
30.001009-0.014394True10.000000
40.00010134-0.012180True10.000000
510.000000-0.016000True0.031623
62.000000-0.016000True0.031623
71.000000-0.016000True0.031623
80.01000100.015045True0.031623
90.00200280.001483True0.031623
100.00100580.002821True0.031623
110.000015820.021913True0.031623
120.000103110.048700True0.000100
130.000014110.047991False0.000100
\n
" + }, + "execution_count": 116, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fit_grid_L2\n", + "# Use fit_grid_L2.characteristics() for those without rich dispalys" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "# More Details\n", + "For more details please inspect the doc strings of:\n", + "\n", + "* [l0learn.models.CVFitModel](code.rst#l0learn.models.CVFitModel)\n", + "* [l0learn.models.FitModel](code.rst#l0learn.models.FitModel)\n", + "* [l0learn.fit](code.rst#l0learn.fit)\n", + "* [l0learn.cvfit](code.rst#l0learn.cvfit)" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "# References\n", + "Hussein Hazimeh and Rahul Mazumder. [Fast Best Subset Selection: Coordinate Descent and Local Combinatorial Optimization Algorithms](https://pubsonline.informs.org/doi/10.1287/opre.2019.1919). Operations Research (2020).\n", + "\n", + "Antoine Dedieu, Hussein Hazimeh, and Rahul Mazumder. [Learning Sparse Classifiers: Continuous and Mixed Integer Optimization Perspectives](https://arxiv.org/abs/2001.06471). JMLR (to appear)." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/python/l0learn/cyarma.cpp b/python/l0learn/cyarma.cpp index 459ce89..f99f334 100644 --- a/python/l0learn/cyarma.cpp +++ b/python/l0learn/cyarma.cpp @@ -3,12 +3,6 @@ /* BEGIN: Cython Metadata { "distutils": { - "define_macros": [ - [ - "CYTHON_TRACE_NOGIL", - "1" - ] - ], "depends": [ "/Users/tnonet/opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/core/include/numpy/arrayobject.h", "/Users/tnonet/opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/core/include/numpy/arrayscalars.h", @@ -1277,255 +1271,6 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); -/* PyThreadStateGet.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; -#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; -#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type -#else -#define __Pyx_PyThreadState_declare -#define __Pyx_PyThreadState_assign -#define __Pyx_PyErr_Occurred() PyErr_Occurred() -#endif - -/* PyErrFetchRestore.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) -#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) -#else -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) -#endif -#else -#define __Pyx_PyErr_Clear() PyErr_Clear() -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) -#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) -#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) -#endif - -/* Profile.proto */ -#ifndef CYTHON_PROFILE -#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON - #define CYTHON_PROFILE 0 -#else - #define CYTHON_PROFILE 1 -#endif -#endif -#ifndef CYTHON_TRACE_NOGIL - #define CYTHON_TRACE_NOGIL 0 -#else - #if CYTHON_TRACE_NOGIL && !defined(CYTHON_TRACE) - #define CYTHON_TRACE 1 - #endif -#endif -#ifndef CYTHON_TRACE - #define CYTHON_TRACE 0 -#endif -#if CYTHON_TRACE - #undef CYTHON_PROFILE_REUSE_FRAME -#endif -#ifndef CYTHON_PROFILE_REUSE_FRAME - #define CYTHON_PROFILE_REUSE_FRAME 0 -#endif -#if CYTHON_PROFILE || CYTHON_TRACE - #include "compile.h" - #include "frameobject.h" - #include "traceback.h" - #if CYTHON_PROFILE_REUSE_FRAME - #define CYTHON_FRAME_MODIFIER static - #define CYTHON_FRAME_DEL(frame) - #else - #define CYTHON_FRAME_MODIFIER - #define CYTHON_FRAME_DEL(frame) Py_CLEAR(frame) - #endif - #define __Pyx_TraceDeclarations\ - static PyCodeObject *__pyx_frame_code = NULL;\ - CYTHON_FRAME_MODIFIER PyFrameObject *__pyx_frame = NULL;\ - int __Pyx_use_tracing = 0; - #define __Pyx_TraceFrameInit(codeobj)\ - if (codeobj) __pyx_frame_code = (PyCodeObject*) codeobj; -#if PY_VERSION_HEX >= 0x030a00b1 - #define __Pyx_IsTracing(tstate, check_tracing, check_funcs)\ - (unlikely((tstate)->cframe->use_tracing) &&\ - (!(check_tracing) || !(tstate)->tracing) &&\ - (!(check_funcs) || (tstate)->c_profilefunc || (CYTHON_TRACE && (tstate)->c_tracefunc))) - #define __Pyx_SetTracing(tstate, enable)\ - (tstate)->cframe->use_tracing = (enable) -#else - #define __Pyx_IsTracing(tstate, check_tracing, check_funcs)\ - (unlikely((tstate)->use_tracing) &&\ - (!(check_tracing) || !(tstate)->tracing) &&\ - (!(check_funcs) || (tstate)->c_profilefunc || (CYTHON_TRACE && (tstate)->c_tracefunc))) - #define __Pyx_SetTracing(tstate, enable)\ - (tstate)->use_tracing = (enable) -#endif - #ifdef WITH_THREAD - #define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error)\ - if (nogil) {\ - if (CYTHON_TRACE_NOGIL) {\ - PyThreadState *tstate;\ - PyGILState_STATE state = PyGILState_Ensure();\ - tstate = __Pyx_PyThreadState_Current;\ - if (__Pyx_IsTracing(tstate, 1, 1)) {\ - __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ - }\ - PyGILState_Release(state);\ - if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ - }\ - } else {\ - PyThreadState* tstate = PyThreadState_GET();\ - if (__Pyx_IsTracing(tstate, 1, 1)) {\ - __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ - if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ - }\ - } - #else - #define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error)\ - { PyThreadState* tstate = PyThreadState_GET();\ - if (__Pyx_IsTracing(tstate, 1, 1)) {\ - __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, tstate, funcname, srcfile, firstlineno);\ - if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ - }\ - } - #endif - #define __Pyx_TraceException()\ - if (likely(!__Pyx_use_tracing)); else {\ - PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (__Pyx_IsTracing(tstate, 0, 1)) {\ - tstate->tracing++;\ - __Pyx_SetTracing(tstate, 0);\ - PyObject *exc_info = __Pyx_GetExceptionTuple(tstate);\ - if (exc_info) {\ - if (CYTHON_TRACE && tstate->c_tracefunc)\ - tstate->c_tracefunc(\ - tstate->c_traceobj, __pyx_frame, PyTrace_EXCEPTION, exc_info);\ - tstate->c_profilefunc(\ - tstate->c_profileobj, __pyx_frame, PyTrace_EXCEPTION, exc_info);\ - Py_DECREF(exc_info);\ - }\ - __Pyx_SetTracing(tstate, 1);\ - tstate->tracing--;\ - }\ - } - static void __Pyx_call_return_trace_func(PyThreadState *tstate, PyFrameObject *frame, PyObject *result) { - PyObject *type, *value, *traceback; - __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); - tstate->tracing++; - __Pyx_SetTracing(tstate, 0); - if (CYTHON_TRACE && tstate->c_tracefunc) - tstate->c_tracefunc(tstate->c_traceobj, frame, PyTrace_RETURN, result); - if (tstate->c_profilefunc) - tstate->c_profilefunc(tstate->c_profileobj, frame, PyTrace_RETURN, result); - CYTHON_FRAME_DEL(frame); - __Pyx_SetTracing(tstate, 1); - tstate->tracing--; - __Pyx_ErrRestoreInState(tstate, type, value, traceback); - } - #ifdef WITH_THREAD - #define __Pyx_TraceReturn(result, nogil)\ - if (likely(!__Pyx_use_tracing)); else {\ - if (nogil) {\ - if (CYTHON_TRACE_NOGIL) {\ - PyThreadState *tstate;\ - PyGILState_STATE state = PyGILState_Ensure();\ - tstate = __Pyx_PyThreadState_Current;\ - if (__Pyx_IsTracing(tstate, 0, 0)) {\ - __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ - }\ - PyGILState_Release(state);\ - }\ - } else {\ - PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (__Pyx_IsTracing(tstate, 0, 0)) {\ - __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ - }\ - }\ - } - #else - #define __Pyx_TraceReturn(result, nogil)\ - if (likely(!__Pyx_use_tracing)); else {\ - PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (__Pyx_IsTracing(tstate, 0, 0)) {\ - __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ - }\ - } - #endif - static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno); - static int __Pyx_TraceSetupAndCall(PyCodeObject** code, PyFrameObject** frame, PyThreadState* tstate, const char *funcname, const char *srcfile, int firstlineno); -#else - #define __Pyx_TraceDeclarations - #define __Pyx_TraceFrameInit(codeobj) - #define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error) if ((1)); else goto_error; - #define __Pyx_TraceException() - #define __Pyx_TraceReturn(result, nogil) -#endif -#if CYTHON_TRACE - static int __Pyx_call_line_trace_func(PyThreadState *tstate, PyFrameObject *frame, int lineno) { - int ret; - PyObject *type, *value, *traceback; - __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); - __Pyx_PyFrame_SetLineNumber(frame, lineno); - tstate->tracing++; - __Pyx_SetTracing(tstate, 0); - ret = tstate->c_tracefunc(tstate->c_traceobj, frame, PyTrace_LINE, NULL); - __Pyx_SetTracing(tstate, 1); - tstate->tracing--; - if (likely(!ret)) { - __Pyx_ErrRestoreInState(tstate, type, value, traceback); - } else { - Py_XDECREF(type); - Py_XDECREF(value); - Py_XDECREF(traceback); - } - return ret; - } - #ifdef WITH_THREAD - #define __Pyx_TraceLine(lineno, nogil, goto_error)\ - if (likely(!__Pyx_use_tracing)); else {\ - if (nogil) {\ - if (CYTHON_TRACE_NOGIL) {\ - int ret = 0;\ - PyThreadState *tstate;\ - PyGILState_STATE state = PyGILState_Ensure();\ - tstate = __Pyx_PyThreadState_Current;\ - if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && __pyx_frame->f_trace) {\ - ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ - }\ - PyGILState_Release(state);\ - if (unlikely(ret)) goto_error;\ - }\ - } else {\ - PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && __pyx_frame->f_trace) {\ - int ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ - if (unlikely(ret)) goto_error;\ - }\ - }\ - } - #else - #define __Pyx_TraceLine(lineno, nogil, goto_error)\ - if (likely(!__Pyx_use_tracing)); else {\ - PyThreadState* tstate = __Pyx_PyThreadState_Current;\ - if (__Pyx_IsTracing(tstate, 0, 0) && tstate->c_tracefunc && __pyx_frame->f_trace) {\ - int ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ - if (unlikely(ret)) goto_error;\ - }\ - } - #endif -#else - #define __Pyx_TraceLine(lineno, nogil, goto_error) if ((1)); else goto_error; -#endif - /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS #define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) @@ -1646,6 +1391,42 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObjec PyObject_Format(s, f)) #endif +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() PyErr_Occurred() +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +#else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); @@ -2128,7 +1909,6 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_fiel Py_ssize_t __pyx_v_i; PyObject *__pyx_v_value = NULL; arma::field __pyx_r; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; PyObject *__pyx_t_2 = NULL; @@ -2143,7 +1923,6 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_fiel const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("list_to_sp_dmat_field", 0); - __Pyx_TraceCall("list_to_sp_dmat_field", __pyx_f[0], 87, 0, __PYX_ERR(0, 87, __pyx_L1_error)); /* "l0learn/cyarma.pyx":88 * @cython.boundscheck(False) @@ -2152,7 +1931,6 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_fiel * for i, value in enumerate(values): * if not isinstance(value, csc_matrix) or value.ndim != 2 or not np.isrealobj(value): */ - __Pyx_TraceLine(88,0,__PYX_ERR(0, 88, __pyx_L1_error)) if (unlikely(__pyx_v_values == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(0, 88, __pyx_L1_error) @@ -2167,7 +1945,6 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_fiel * if not isinstance(value, csc_matrix) or value.ndim != 2 or not np.isrealobj(value): * raise TypeError(f"expected each value in values to be a 2D real csc_matrix, but got {value}") */ - __Pyx_TraceLine(89,0,__PYX_ERR(0, 89, __pyx_L1_error)) __pyx_t_1 = 0; __pyx_t_2 = __pyx_v_values; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; for (;;) { @@ -2190,7 +1967,6 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_fiel * raise TypeError(f"expected each value in values to be a 2D real csc_matrix, but got {value}") * f[i] = numpy_to_sp_dmat_d(value) */ - __Pyx_TraceLine(90,0,__PYX_ERR(0, 90, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 90, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = PyObject_IsInstance(__pyx_v_value, __pyx_t_4); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 90, __pyx_L1_error) @@ -2247,7 +2023,6 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_fiel * f[i] = numpy_to_sp_dmat_d(value) * return f */ - __Pyx_TraceLine(91,0,__PYX_ERR(0, 91, __pyx_L1_error)) __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_value, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 91, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_each_value_in_values_to, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 91, __pyx_L1_error) @@ -2276,7 +2051,6 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_fiel * return f * */ - __Pyx_TraceLine(92,0,__PYX_ERR(0, 92, __pyx_L1_error)) (__pyx_v_f[__pyx_v_i]) = __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(__pyx_v_value); /* "l0learn/cyarma.pyx":89 @@ -2286,7 +2060,6 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_fiel * if not isinstance(value, csc_matrix) or value.ndim != 2 or not np.isrealobj(value): * raise TypeError(f"expected each value in values to be a 2D real csc_matrix, but got {value}") */ - __Pyx_TraceLine(89,0,__PYX_ERR(0, 89, __pyx_L1_error)) } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -2297,7 +2070,6 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_fiel * * */ - __Pyx_TraceLine(93,0,__PYX_ERR(0, 93, __pyx_L1_error)) __pyx_r = __pyx_v_f; goto __pyx_L0; @@ -2319,7 +2091,6 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_sp_dmat_fiel __Pyx_pretend_to_initialize(&__pyx_r); __pyx_L0:; __Pyx_XDECREF(__pyx_v_value); - __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2337,7 +2108,6 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_dvec_field(PyOb Py_ssize_t __pyx_v_i; PyObject *__pyx_v_value = NULL; arma::field __pyx_r; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations Py_ssize_t __pyx_t_1; PyObject *__pyx_t_2 = NULL; @@ -2352,7 +2122,6 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_dvec_field(PyOb const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("list_to_dvec_field", 0); - __Pyx_TraceCall("list_to_dvec_field", __pyx_f[0], 97, 0, __PYX_ERR(0, 97, __pyx_L1_error)); /* "l0learn/cyarma.pyx":98 * @cython.boundscheck(False) @@ -2361,7 +2130,6 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_dvec_field(PyOb * for i, value in enumerate(values): * if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isrealobj(value): */ - __Pyx_TraceLine(98,0,__PYX_ERR(0, 98, __pyx_L1_error)) if (unlikely(__pyx_v_values == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(0, 98, __pyx_L1_error) @@ -2376,7 +2144,6 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_dvec_field(PyOb * if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isrealobj(value): * raise TypeError(f"expected each value in values to be a 1D real numpy matrix, but got {value}") */ - __Pyx_TraceLine(99,0,__PYX_ERR(0, 99, __pyx_L1_error)) __pyx_t_1 = 0; __pyx_t_2 = __pyx_v_values; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; for (;;) { @@ -2399,7 +2166,6 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_dvec_field(PyOb * raise TypeError(f"expected each value in values to be a 1D real numpy matrix, but got {value}") * f[i] = numpy_to_dvec_d(value) */ - __Pyx_TraceLine(100,0,__PYX_ERR(0, 100, __pyx_L1_error)) __pyx_t_6 = __Pyx_TypeCheck(__pyx_v_value, __pyx_ptype_5numpy_ndarray); __pyx_t_7 = ((!(__pyx_t_6 != 0)) != 0); if (!__pyx_t_7) { @@ -2453,7 +2219,6 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_dvec_field(PyOb * f[i] = numpy_to_dvec_d(value) * return f */ - __Pyx_TraceLine(101,0,__PYX_ERR(0, 101, __pyx_L1_error)) __pyx_t_8 = __Pyx_PyObject_FormatSimple(__pyx_v_value, __pyx_empty_unicode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 101, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = __Pyx_PyUnicode_Concat(__pyx_kp_u_expected_each_value_in_values_to_2, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 101, __pyx_L1_error) @@ -2482,7 +2247,6 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_dvec_field(PyOb * return f * */ - __Pyx_TraceLine(102,0,__PYX_ERR(0, 102, __pyx_L1_error)) if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 102, __pyx_L1_error) (__pyx_v_f[__pyx_v_i]) = __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_value)); @@ -2493,7 +2257,6 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_dvec_field(PyOb * if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isrealobj(value): * raise TypeError(f"expected each value in values to be a 1D real numpy matrix, but got {value}") */ - __Pyx_TraceLine(99,0,__PYX_ERR(0, 99, __pyx_L1_error)) } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -2504,7 +2267,6 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_dvec_field(PyOb * * */ - __Pyx_TraceLine(103,0,__PYX_ERR(0, 103, __pyx_L1_error)) __pyx_r = __pyx_v_f; goto __pyx_L0; @@ -2526,7 +2288,6 @@ static arma::field __pyx_f_7l0learn_6cyarma_list_to_dvec_field(PyOb __Pyx_pretend_to_initialize(&__pyx_r); __pyx_L0:; __Pyx_XDECREF(__pyx_v_value); - __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2544,11 +2305,10 @@ static arma::dmat *__pyx_f_7l0learn_6cyarma_numpy_to_dmat(PyArrayObject *__pyx_v __Pyx_LocalBuf_ND __pyx_pybuffernd_X; __Pyx_Buffer __pyx_pybuffer_X; arma::dmat *__pyx_r; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations - int __pyx_t_1; + PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; + int __pyx_t_3; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyArrayObject *__pyx_t_6 = NULL; @@ -2560,7 +2320,6 @@ static arma::dmat *__pyx_f_7l0learn_6cyarma_numpy_to_dmat(PyArrayObject *__pyx_v const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("numpy_to_dmat", 0); - __Pyx_TraceCall("numpy_to_dmat", __pyx_f[0], 106, 0, __PYX_ERR(0, 106, __pyx_L1_error)); __Pyx_INCREF((PyObject *)__pyx_v_X); __pyx_pybuffer_X.pybuffer.buf = NULL; __pyx_pybuffer_X.refcount = 0; @@ -2575,52 +2334,36 @@ static arma::dmat *__pyx_f_7l0learn_6cyarma_numpy_to_dmat(PyArrayObject *__pyx_v /* "l0learn/cyarma.pyx":111 * # mat(ptr_aux_mem, n_rows, n_cols, copy_aux_mem = true, strict = false) * # TODO: raise Warning on copy or replication of data - * if not (X.flags.f_contiguous or X.flags.owndata): # <<<<<<<<<<<<<< + * if not X.flags.f_contiguous: # <<<<<<<<<<<<<< * X = X.copy(order="F") * cdef dmat *aR_p = new dmat( X.data, X.shape[0], X.shape[1], False, True) */ - __Pyx_TraceLine(111,0,__PYX_ERR(0, 111, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_X), __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 111, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_f_contiguous); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 111, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 111, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (!__pyx_t_4) { - } else { - __pyx_t_1 = __pyx_t_4; - goto __pyx_L4_bool_binop_done; - } - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_X), __pyx_n_s_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 111, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_owndata); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 111, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_X), __pyx_n_s_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_f_contiguous); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 111, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 111, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_1 = __pyx_t_4; - __pyx_L4_bool_binop_done:; - __pyx_t_4 = ((!__pyx_t_1) != 0); + __pyx_t_4 = ((!__pyx_t_3) != 0); if (__pyx_t_4) { /* "l0learn/cyarma.pyx":112 * # TODO: raise Warning on copy or replication of data - * if not (X.flags.f_contiguous or X.flags.owndata): + * if not X.flags.f_contiguous: * X = X.copy(order="F") # <<<<<<<<<<<<<< * cdef dmat *aR_p = new dmat( X.data, X.shape[0], X.shape[1], False, True) * return aR_p */ - __Pyx_TraceLine(112,0,__PYX_ERR(0, 112, __pyx_L1_error)) __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_X), __pyx_n_s_copy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 112, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 112, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_order, __pyx_n_u_F) < 0) __PYX_ERR(0, 112, __pyx_L1_error) - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 112, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_order, __pyx_n_u_F) < 0) __PYX_ERR(0, 112, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 112, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 112, __pyx_L1_error) __pyx_t_6 = ((PyArrayObject *)__pyx_t_5); { @@ -2647,20 +2390,19 @@ static arma::dmat *__pyx_f_7l0learn_6cyarma_numpy_to_dmat(PyArrayObject *__pyx_v /* "l0learn/cyarma.pyx":111 * # mat(ptr_aux_mem, n_rows, n_cols, copy_aux_mem = true, strict = false) * # TODO: raise Warning on copy or replication of data - * if not (X.flags.f_contiguous or X.flags.owndata): # <<<<<<<<<<<<<< + * if not X.flags.f_contiguous: # <<<<<<<<<<<<<< * X = X.copy(order="F") * cdef dmat *aR_p = new dmat( X.data, X.shape[0], X.shape[1], False, True) */ } /* "l0learn/cyarma.pyx":113 - * if not (X.flags.f_contiguous or X.flags.owndata): + * if not X.flags.f_contiguous: * X = X.copy(order="F") * cdef dmat *aR_p = new dmat( X.data, X.shape[0], X.shape[1], False, True) # <<<<<<<<<<<<<< * return aR_p * */ - __Pyx_TraceLine(113,0,__PYX_ERR(0, 113, __pyx_L1_error)) __pyx_v_aR_p = new arma::dmat(((double *)__pyx_v_X->data), (__pyx_v_X->dimensions[0]), (__pyx_v_X->dimensions[1]), 0, 1); /* "l0learn/cyarma.pyx":114 @@ -2670,7 +2412,6 @@ static arma::dmat *__pyx_f_7l0learn_6cyarma_numpy_to_dmat(PyArrayObject *__pyx_v * * cdef dmat numpy_to_dmat_d(np.ndarray[np.double_t, ndim=2] X): */ - __Pyx_TraceLine(114,0,__PYX_ERR(0, 114, __pyx_L1_error)) __pyx_r = __pyx_v_aR_p; goto __pyx_L0; @@ -2684,8 +2425,8 @@ static arma::dmat *__pyx_f_7l0learn_6cyarma_numpy_to_dmat(PyArrayObject *__pyx_v /* function exit code */ __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_5); { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; __Pyx_PyThreadState_declare @@ -2700,7 +2441,6 @@ static arma::dmat *__pyx_f_7l0learn_6cyarma_numpy_to_dmat(PyArrayObject *__pyx_v __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_X.rcbuffer->pybuffer); __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_X); - __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2719,13 +2459,11 @@ static arma::dmat __pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(PyArrayObject *__pyx_ __Pyx_LocalBuf_ND __pyx_pybuffernd_X; __Pyx_Buffer __pyx_pybuffer_X; arma::dmat __pyx_r; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("numpy_to_dmat_d", 0); - __Pyx_TraceCall("numpy_to_dmat_d", __pyx_f[0], 116, 0, __PYX_ERR(0, 116, __pyx_L1_error)); __pyx_pybuffer_X.pybuffer.buf = NULL; __pyx_pybuffer_X.refcount = 0; __pyx_pybuffernd_X.data = NULL; @@ -2743,7 +2481,6 @@ static arma::dmat __pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(PyArrayObject *__pyx_ * cdef dmat aR = deref(aR_p) * del aR_p */ - __Pyx_TraceLine(117,0,__PYX_ERR(0, 117, __pyx_L1_error)) __pyx_v_aR_p = __pyx_f_7l0learn_6cyarma_numpy_to_dmat(((PyArrayObject *)__pyx_v_X)); /* "l0learn/cyarma.pyx":118 @@ -2753,7 +2490,6 @@ static arma::dmat __pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(PyArrayObject *__pyx_ * del aR_p * return aR */ - __Pyx_TraceLine(118,0,__PYX_ERR(0, 118, __pyx_L1_error)) __pyx_v_aR = (*__pyx_v_aR_p); /* "l0learn/cyarma.pyx":119 @@ -2763,7 +2499,6 @@ static arma::dmat __pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(PyArrayObject *__pyx_ * return aR * */ - __Pyx_TraceLine(119,0,__PYX_ERR(0, 119, __pyx_L1_error)) delete __pyx_v_aR_p; /* "l0learn/cyarma.pyx":120 @@ -2773,7 +2508,6 @@ static arma::dmat __pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(PyArrayObject *__pyx_ * * cdef dvec * numpy_to_dvec(np.ndarray[np.double_t, ndim=1] x): */ - __Pyx_TraceLine(120,0,__PYX_ERR(0, 120, __pyx_L1_error)) __pyx_r = __pyx_v_aR; goto __pyx_L0; @@ -2799,7 +2533,6 @@ static arma::dmat __pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(PyArrayObject *__pyx_ __pyx_L0:; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_X.rcbuffer->pybuffer); __pyx_L2:; - __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2817,7 +2550,6 @@ static arma::dvec *__pyx_f_7l0learn_6cyarma_numpy_to_dvec(PyArrayObject *__pyx_v __Pyx_LocalBuf_ND __pyx_pybuffernd_x; __Pyx_Buffer __pyx_pybuffer_x; arma::dvec *__pyx_r; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; @@ -2833,7 +2565,6 @@ static arma::dvec *__pyx_f_7l0learn_6cyarma_numpy_to_dvec(PyArrayObject *__pyx_v const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("numpy_to_dvec", 0); - __Pyx_TraceCall("numpy_to_dvec", __pyx_f[0], 122, 0, __PYX_ERR(0, 122, __pyx_L1_error)); __Pyx_INCREF((PyObject *)__pyx_v_x); __pyx_pybuffer_x.pybuffer.buf = NULL; __pyx_pybuffer_x.refcount = 0; @@ -2852,7 +2583,6 @@ static arma::dvec *__pyx_f_7l0learn_6cyarma_numpy_to_dvec(PyArrayObject *__pyx_v * x = x.copy() * cdef dvec *ar_p = new dvec( x.data, x.shape[0], False, True) */ - __Pyx_TraceLine(123,0,__PYX_ERR(0, 123, __pyx_L1_error)) __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_x), __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_f_contiguous); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 123, __pyx_L1_error) @@ -2884,7 +2614,6 @@ static arma::dvec *__pyx_f_7l0learn_6cyarma_numpy_to_dvec(PyArrayObject *__pyx_v * cdef dvec *ar_p = new dvec( x.data, x.shape[0], False, True) * return ar_p */ - __Pyx_TraceLine(124,0,__PYX_ERR(0, 124, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_x), __pyx_n_s_copy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 124, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = NULL; @@ -2941,7 +2670,6 @@ static arma::dvec *__pyx_f_7l0learn_6cyarma_numpy_to_dvec(PyArrayObject *__pyx_v * return ar_p * */ - __Pyx_TraceLine(125,0,__PYX_ERR(0, 125, __pyx_L1_error)) __pyx_v_ar_p = new arma::dvec(((double *)__pyx_v_x->data), (__pyx_v_x->dimensions[0]), 0, 1); /* "l0learn/cyarma.pyx":126 @@ -2951,7 +2679,6 @@ static arma::dvec *__pyx_f_7l0learn_6cyarma_numpy_to_dvec(PyArrayObject *__pyx_v * * cdef dvec numpy_to_dvec_d(np.ndarray[np.double_t, ndim=1] x): */ - __Pyx_TraceLine(126,0,__PYX_ERR(0, 126, __pyx_L1_error)) __pyx_r = __pyx_v_ar_p; goto __pyx_L0; @@ -2981,7 +2708,6 @@ static arma::dvec *__pyx_f_7l0learn_6cyarma_numpy_to_dvec(PyArrayObject *__pyx_v __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_x); - __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3000,13 +2726,11 @@ static arma::dvec __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(PyArrayObject *__pyx_ __Pyx_LocalBuf_ND __pyx_pybuffernd_x; __Pyx_Buffer __pyx_pybuffer_x; arma::dvec __pyx_r; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("numpy_to_dvec_d", 0); - __Pyx_TraceCall("numpy_to_dvec_d", __pyx_f[0], 128, 0, __PYX_ERR(0, 128, __pyx_L1_error)); __pyx_pybuffer_x.pybuffer.buf = NULL; __pyx_pybuffer_x.refcount = 0; __pyx_pybuffernd_x.data = NULL; @@ -3024,7 +2748,6 @@ static arma::dvec __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(PyArrayObject *__pyx_ * cdef dvec ar = deref(ar_p) * del ar_p */ - __Pyx_TraceLine(129,0,__PYX_ERR(0, 129, __pyx_L1_error)) __pyx_v_ar_p = __pyx_f_7l0learn_6cyarma_numpy_to_dvec(((PyArrayObject *)__pyx_v_x)); /* "l0learn/cyarma.pyx":130 @@ -3034,7 +2757,6 @@ static arma::dvec __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(PyArrayObject *__pyx_ * del ar_p * return ar */ - __Pyx_TraceLine(130,0,__PYX_ERR(0, 130, __pyx_L1_error)) __pyx_v_ar = (*__pyx_v_ar_p); /* "l0learn/cyarma.pyx":131 @@ -3044,7 +2766,6 @@ static arma::dvec __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(PyArrayObject *__pyx_ * return ar * */ - __Pyx_TraceLine(131,0,__PYX_ERR(0, 131, __pyx_L1_error)) delete __pyx_v_ar_p; /* "l0learn/cyarma.pyx":132 @@ -3054,7 +2775,6 @@ static arma::dvec __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(PyArrayObject *__pyx_ * * cdef uvec * numpy_to_uvec(np.ndarray[np.uint64_t, ndim=1] x): */ - __Pyx_TraceLine(132,0,__PYX_ERR(0, 132, __pyx_L1_error)) __pyx_r = __pyx_v_ar; goto __pyx_L0; @@ -3080,7 +2800,6 @@ static arma::dvec __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(PyArrayObject *__pyx_ __pyx_L0:; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); __pyx_L2:; - __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3098,7 +2817,6 @@ static arma::uvec *__pyx_f_7l0learn_6cyarma_numpy_to_uvec(PyArrayObject *__pyx_v __Pyx_LocalBuf_ND __pyx_pybuffernd_x; __Pyx_Buffer __pyx_pybuffer_x; arma::uvec *__pyx_r; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; @@ -3114,7 +2832,6 @@ static arma::uvec *__pyx_f_7l0learn_6cyarma_numpy_to_uvec(PyArrayObject *__pyx_v const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("numpy_to_uvec", 0); - __Pyx_TraceCall("numpy_to_uvec", __pyx_f[0], 134, 0, __PYX_ERR(0, 134, __pyx_L1_error)); __Pyx_INCREF((PyObject *)__pyx_v_x); __pyx_pybuffer_x.pybuffer.buf = NULL; __pyx_pybuffer_x.refcount = 0; @@ -3133,7 +2850,6 @@ static arma::uvec *__pyx_f_7l0learn_6cyarma_numpy_to_uvec(PyArrayObject *__pyx_v * x = x.copy() * cdef uvec *ar_p = new uvec( x.data, x.shape[0], False, True) */ - __Pyx_TraceLine(135,0,__PYX_ERR(0, 135, __pyx_L1_error)) __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_x), __pyx_n_s_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 135, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_f_contiguous); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 135, __pyx_L1_error) @@ -3165,7 +2881,6 @@ static arma::uvec *__pyx_f_7l0learn_6cyarma_numpy_to_uvec(PyArrayObject *__pyx_v * cdef uvec *ar_p = new uvec( x.data, x.shape[0], False, True) * return ar_p */ - __Pyx_TraceLine(136,0,__PYX_ERR(0, 136, __pyx_L1_error)) __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_x), __pyx_n_s_copy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 136, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = NULL; @@ -3222,7 +2937,6 @@ static arma::uvec *__pyx_f_7l0learn_6cyarma_numpy_to_uvec(PyArrayObject *__pyx_v * return ar_p * */ - __Pyx_TraceLine(137,0,__PYX_ERR(0, 137, __pyx_L1_error)) __pyx_v_ar_p = new arma::uvec(((unsigned PY_LONG_LONG *)__pyx_v_x->data), (__pyx_v_x->dimensions[0]), 0, 1); /* "l0learn/cyarma.pyx":138 @@ -3232,7 +2946,6 @@ static arma::uvec *__pyx_f_7l0learn_6cyarma_numpy_to_uvec(PyArrayObject *__pyx_v * * cdef uvec numpy_to_uvec_d(np.ndarray[np.uint64_t, ndim=1] x): */ - __Pyx_TraceLine(138,0,__PYX_ERR(0, 138, __pyx_L1_error)) __pyx_r = __pyx_v_ar_p; goto __pyx_L0; @@ -3262,7 +2975,6 @@ static arma::uvec *__pyx_f_7l0learn_6cyarma_numpy_to_uvec(PyArrayObject *__pyx_v __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_x); - __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3281,13 +2993,11 @@ static arma::uvec __pyx_f_7l0learn_6cyarma_numpy_to_uvec_d(PyArrayObject *__pyx_ __Pyx_LocalBuf_ND __pyx_pybuffernd_x; __Pyx_Buffer __pyx_pybuffer_x; arma::uvec __pyx_r; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("numpy_to_uvec_d", 0); - __Pyx_TraceCall("numpy_to_uvec_d", __pyx_f[0], 140, 0, __PYX_ERR(0, 140, __pyx_L1_error)); __pyx_pybuffer_x.pybuffer.buf = NULL; __pyx_pybuffer_x.refcount = 0; __pyx_pybuffernd_x.data = NULL; @@ -3305,7 +3015,6 @@ static arma::uvec __pyx_f_7l0learn_6cyarma_numpy_to_uvec_d(PyArrayObject *__pyx_ * cdef uvec ar = deref(ar_p) * del ar_p */ - __Pyx_TraceLine(141,0,__PYX_ERR(0, 141, __pyx_L1_error)) __pyx_v_ar_p = __pyx_f_7l0learn_6cyarma_numpy_to_uvec(((PyArrayObject *)__pyx_v_x)); /* "l0learn/cyarma.pyx":142 @@ -3315,7 +3024,6 @@ static arma::uvec __pyx_f_7l0learn_6cyarma_numpy_to_uvec_d(PyArrayObject *__pyx_ * del ar_p * return ar */ - __Pyx_TraceLine(142,0,__PYX_ERR(0, 142, __pyx_L1_error)) __pyx_v_ar = (*__pyx_v_ar_p); /* "l0learn/cyarma.pyx":143 @@ -3325,7 +3033,6 @@ static arma::uvec __pyx_f_7l0learn_6cyarma_numpy_to_uvec_d(PyArrayObject *__pyx_ * return ar * */ - __Pyx_TraceLine(143,0,__PYX_ERR(0, 143, __pyx_L1_error)) delete __pyx_v_ar_p; /* "l0learn/cyarma.pyx":144 @@ -3335,7 +3042,6 @@ static arma::uvec __pyx_f_7l0learn_6cyarma_numpy_to_uvec_d(PyArrayObject *__pyx_ * * */ - __Pyx_TraceLine(144,0,__PYX_ERR(0, 144, __pyx_L1_error)) __pyx_r = __pyx_v_ar; goto __pyx_L0; @@ -3361,7 +3067,6 @@ static arma::uvec __pyx_f_7l0learn_6cyarma_numpy_to_uvec_d(PyArrayObject *__pyx_ __pyx_L0:; __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x.rcbuffer->pybuffer); __pyx_L2:; - __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3389,7 +3094,6 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ __Pyx_LocalBuf_ND __pyx_pybuffernd_indptr; __Pyx_Buffer __pyx_pybuffer_indptr; arma::sp_dmat *__pyx_r; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; @@ -3408,7 +3112,6 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("numpy_to_sp_dmat", 0); - __Pyx_TraceCall("numpy_to_sp_dmat", __pyx_f[0], 147, 0, __PYX_ERR(0, 147, __pyx_L1_error)); __pyx_pybuffer_data.pybuffer.buf = NULL; __pyx_pybuffer_data.refcount = 0; __pyx_pybuffernd_data.data = NULL; @@ -3429,7 +3132,6 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ * raise ValueError(f"expected x to be of type {csc_matrix}, but got {type(x)}") * */ - __Pyx_TraceLine(148,0,__PYX_ERR(0, 148, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 148, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyObject_IsInstance(__pyx_v_x, __pyx_t_1); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 148, __pyx_L1_error) @@ -3444,7 +3146,6 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ * * cdef np.ndarray[np.double_t, ndim=1] data = x.data */ - __Pyx_TraceLine(149,0,__PYX_ERR(0, 149, __pyx_L1_error)) __pyx_t_1 = PyTuple_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 149, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = 0; @@ -3500,7 +3201,6 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ * cdef dvec values = numpy_to_dvec_d(data) * */ - __Pyx_TraceLine(151,0,__PYX_ERR(0, 151, __pyx_L1_error)) __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 151, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 151, __pyx_L1_error) @@ -3524,7 +3224,6 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ * * cdef np.ndarray[np.uint64_t, ndim=1] indptr = x.indptr.astype(np.uint64) */ - __Pyx_TraceLine(152,0,__PYX_ERR(0, 152, __pyx_L1_error)) __pyx_v_values = __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_data)); /* "l0learn/cyarma.pyx":154 @@ -3534,7 +3233,6 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ * cdef uvec colptr = numpy_to_uvec_d(indptr) * */ - __Pyx_TraceLine(154,0,__PYX_ERR(0, 154, __pyx_L1_error)) __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_indptr); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 154, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_astype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 154, __pyx_L1_error) @@ -3582,7 +3280,6 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ * * cdef np.ndarray[np.uint64_t, ndim=1] indices = x.indices.astype(np.uint64) */ - __Pyx_TraceLine(155,0,__PYX_ERR(0, 155, __pyx_L1_error)) __pyx_v_colptr = __pyx_f_7l0learn_6cyarma_numpy_to_uvec_d(((PyArrayObject *)__pyx_v_indptr)); /* "l0learn/cyarma.pyx":157 @@ -3592,7 +3289,6 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ * cdef uvec rowind = numpy_to_uvec_d(indices) * */ - __Pyx_TraceLine(157,0,__PYX_ERR(0, 157, __pyx_L1_error)) __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_indices); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 157, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_astype); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 157, __pyx_L1_error) @@ -3640,7 +3336,6 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ * * cdef sp_dmat * ar = new sp_dmat(rowind, colptr, values, x.shape[0], x.shape[1]) */ - __Pyx_TraceLine(158,0,__PYX_ERR(0, 158, __pyx_L1_error)) __pyx_v_rowind = __pyx_f_7l0learn_6cyarma_numpy_to_uvec_d(((PyArrayObject *)__pyx_v_indices)); /* "l0learn/cyarma.pyx":160 @@ -3650,7 +3345,6 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ * * return ar */ - __Pyx_TraceLine(160,0,__PYX_ERR(0, 160, __pyx_L1_error)) __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 160, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 160, __pyx_L1_error) @@ -3674,7 +3368,6 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ * * */ - __Pyx_TraceLine(162,0,__PYX_ERR(0, 162, __pyx_L1_error)) __pyx_r = __pyx_v_ar; goto __pyx_L0; @@ -3711,7 +3404,6 @@ static arma::sp_dmat *__pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(PyObject *__pyx_ __Pyx_XDECREF((PyObject *)__pyx_v_data); __Pyx_XDECREF((PyObject *)__pyx_v_indptr); __Pyx_XDECREF((PyObject *)__pyx_v_indices); - __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3728,13 +3420,8 @@ static arma::sp_dmat __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(PyObject *__pyx arma::sp_dmat *__pyx_v_ar_p; arma::sp_dmat __pyx_v_ar; arma::sp_dmat __pyx_r; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("numpy_to_sp_dmat_d", 0); - __Pyx_TraceCall("numpy_to_sp_dmat_d", __pyx_f[0], 165, 0, __PYX_ERR(0, 165, __pyx_L1_error)); /* "l0learn/cyarma.pyx":166 * @@ -3743,7 +3430,6 @@ static arma::sp_dmat __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(PyObject *__pyx * cdef sp_dmat ar = deref(ar_p) * del ar_p */ - __Pyx_TraceLine(166,0,__PYX_ERR(0, 166, __pyx_L1_error)) __pyx_v_ar_p = __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat(__pyx_v_x); /* "l0learn/cyarma.pyx":167 @@ -3753,7 +3439,6 @@ static arma::sp_dmat __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(PyObject *__pyx * del ar_p * return ar */ - __Pyx_TraceLine(167,0,__PYX_ERR(0, 167, __pyx_L1_error)) __pyx_v_ar = (*__pyx_v_ar_p); /* "l0learn/cyarma.pyx":168 @@ -3763,7 +3448,6 @@ static arma::sp_dmat __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(PyObject *__pyx * return ar * */ - __Pyx_TraceLine(168,0,__PYX_ERR(0, 168, __pyx_L1_error)) delete __pyx_v_ar_p; /* "l0learn/cyarma.pyx":169 @@ -3773,7 +3457,6 @@ static arma::sp_dmat __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(PyObject *__pyx * * ##### Converting back to l0learn arrays, must pass preallocated memory or None */ - __Pyx_TraceLine(169,0,__PYX_ERR(0, 169, __pyx_L1_error)) __pyx_r = __pyx_v_ar; goto __pyx_L0; @@ -3786,11 +3469,7 @@ static arma::sp_dmat __pyx_f_7l0learn_6cyarma_numpy_to_sp_dmat_d(PyObject *__pyx */ /* function exit code */ - __pyx_L1_error:; - __Pyx_WriteUnraisable("l0learn.cyarma.numpy_to_sp_dmat_d", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); - __Pyx_pretend_to_initialize(&__pyx_r); __pyx_L0:; - __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3807,7 +3486,6 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(arma::field D.data */ - __Pyx_TraceLine(196,0,__PYX_ERR(0, 196, __pyx_L1_error)) __pyx_t_1 = (((PyObject *)__pyx_v_D) == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { @@ -4069,7 +3730,6 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dmat_to_numpy(arma::dmat const &_ * cdef double * Dptr = D.data * for i in range(X.n_rows*X.n_cols): */ - __Pyx_TraceLine(197,0,__PYX_ERR(0, 197, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 197, __pyx_L1_error) @@ -4146,7 +3806,6 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dmat_to_numpy(arma::dmat const &_ * for i in range(X.n_rows*X.n_cols): * Dptr[i] = Xptr[i] */ - __Pyx_TraceLine(198,0,__PYX_ERR(0, 198, __pyx_L1_error)) __pyx_v_Dptr = ((double *)__pyx_v_D->data); /* "l0learn/cyarma.pyx":199 @@ -4156,7 +3815,6 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dmat_to_numpy(arma::dmat const &_ * Dptr[i] = Xptr[i] * return D */ - __Pyx_TraceLine(199,0,__PYX_ERR(0, 199, __pyx_L1_error)) __pyx_t_9 = (__pyx_v_X.n_rows * __pyx_v_X.n_cols); __pyx_t_13 = __pyx_t_9; for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { @@ -4169,7 +3827,6 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dmat_to_numpy(arma::dmat const &_ * return D * */ - __Pyx_TraceLine(200,0,__PYX_ERR(0, 200, __pyx_L1_error)) (__pyx_v_Dptr[__pyx_v_i]) = (__pyx_v_Xptr[__pyx_v_i]); } @@ -4180,7 +3837,6 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dmat_to_numpy(arma::dmat const &_ * * @cython.boundscheck(False) */ - __Pyx_TraceLine(201,0,__PYX_ERR(0, 201, __pyx_L1_error)) __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v_D)); __pyx_r = ((PyArrayObject *)__pyx_v_D); @@ -4215,7 +3871,6 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dmat_to_numpy(arma::dmat const &_ __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_D); __Pyx_XGIVEREF((PyObject *)__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -4235,7 +3890,6 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &_ __Pyx_LocalBuf_ND __pyx_pybuffernd_D; __Pyx_Buffer __pyx_pybuffer_D; PyArrayObject *__pyx_r = NULL; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; @@ -4255,7 +3909,6 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &_ const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("dvec_to_numpy", 0); - __Pyx_TraceCall("dvec_to_numpy", __pyx_f[0], 204, 0, __PYX_ERR(0, 204, __pyx_L1_error)); __Pyx_INCREF((PyObject *)__pyx_v_D); __pyx_pybuffer_D.pybuffer.buf = NULL; __pyx_pybuffer_D.refcount = 0; @@ -4274,7 +3927,6 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &_ * * if D is None: */ - __Pyx_TraceLine(205,0,__PYX_ERR(0, 205, __pyx_L1_error)) __pyx_v_Xptr = __pyx_v_X.memptr(); /* "l0learn/cyarma.pyx":207 @@ -4284,7 +3936,6 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &_ * D = np.empty(X.n_elem, dtype=np.double) * cdef double * Dptr = D.data */ - __Pyx_TraceLine(207,0,__PYX_ERR(0, 207, __pyx_L1_error)) __pyx_t_1 = (((PyObject *)__pyx_v_D) == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { @@ -4296,7 +3947,6 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &_ * cdef double * Dptr = D.data * for i in range(X.n_elem): */ - __Pyx_TraceLine(208,0,__PYX_ERR(0, 208, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 208, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 208, __pyx_L1_error) @@ -4362,7 +4012,6 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &_ * for i in range(X.n_elem): * Dptr[i] = Xptr[i] */ - __Pyx_TraceLine(209,0,__PYX_ERR(0, 209, __pyx_L1_error)) __pyx_v_Dptr = ((double *)__pyx_v_D->data); /* "l0learn/cyarma.pyx":210 @@ -4372,7 +4021,6 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &_ * Dptr[i] = Xptr[i] * return D */ - __Pyx_TraceLine(210,0,__PYX_ERR(0, 210, __pyx_L1_error)) __pyx_t_9 = __pyx_v_X.n_elem; __pyx_t_13 = __pyx_t_9; for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { @@ -4385,7 +4033,6 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &_ * return D * */ - __Pyx_TraceLine(211,0,__PYX_ERR(0, 211, __pyx_L1_error)) (__pyx_v_Dptr[__pyx_v_i]) = (__pyx_v_Xptr[__pyx_v_i]); } @@ -4396,7 +4043,6 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &_ * * */ - __Pyx_TraceLine(212,0,__PYX_ERR(0, 212, __pyx_L1_error)) __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v_D)); __pyx_r = ((PyArrayObject *)__pyx_v_D); @@ -4431,7 +4077,6 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_dvec_to_numpy(arma::dvec const &_ __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_D); __Pyx_XGIVEREF((PyObject *)__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -4451,7 +4096,6 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &_ __Pyx_LocalBuf_ND __pyx_pybuffernd_D; __Pyx_Buffer __pyx_pybuffer_D; PyArrayObject *__pyx_r = NULL; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; @@ -4471,7 +4115,6 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &_ const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("uvec_to_numpy", 0); - __Pyx_TraceCall("uvec_to_numpy", __pyx_f[0], 216, 0, __PYX_ERR(0, 216, __pyx_L1_error)); __Pyx_INCREF((PyObject *)__pyx_v_D); __pyx_pybuffer_D.pybuffer.buf = NULL; __pyx_pybuffer_D.refcount = 0; @@ -4490,7 +4133,6 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &_ * * if D is None: */ - __Pyx_TraceLine(217,0,__PYX_ERR(0, 217, __pyx_L1_error)) __pyx_v_Xptr = __pyx_v_X.memptr(); /* "l0learn/cyarma.pyx":219 @@ -4500,7 +4142,6 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &_ * D = np.empty(X.n_elem, dtype=np.uint64) * cdef unsigned long long * Dptr = D.data */ - __Pyx_TraceLine(219,0,__PYX_ERR(0, 219, __pyx_L1_error)) __pyx_t_1 = (((PyObject *)__pyx_v_D) == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { @@ -4512,7 +4153,6 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &_ * cdef unsigned long long * Dptr = D.data * for i in range(X.n_elem): */ - __Pyx_TraceLine(220,0,__PYX_ERR(0, 220, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 220, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 220, __pyx_L1_error) @@ -4578,7 +4218,6 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &_ * for i in range(X.n_elem): * Dptr[i] = Xptr[i] */ - __Pyx_TraceLine(221,0,__PYX_ERR(0, 221, __pyx_L1_error)) __pyx_v_Dptr = ((unsigned PY_LONG_LONG *)__pyx_v_D->data); /* "l0learn/cyarma.pyx":222 @@ -4588,7 +4227,6 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &_ * Dptr[i] = Xptr[i] * return D */ - __Pyx_TraceLine(222,0,__PYX_ERR(0, 222, __pyx_L1_error)) __pyx_t_9 = __pyx_v_X.n_elem; __pyx_t_13 = __pyx_t_9; for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { @@ -4601,7 +4239,6 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &_ * return D * */ - __Pyx_TraceLine(223,0,__PYX_ERR(0, 223, __pyx_L1_error)) (__pyx_v_Dptr[__pyx_v_i]) = (__pyx_v_Xptr[__pyx_v_i]); } @@ -4612,7 +4249,6 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &_ * * */ - __Pyx_TraceLine(224,0,__PYX_ERR(0, 224, __pyx_L1_error)) __Pyx_XDECREF(((PyObject *)__pyx_r)); __Pyx_INCREF(((PyObject *)__pyx_v_D)); __pyx_r = ((PyArrayObject *)__pyx_v_D); @@ -4647,7 +4283,6 @@ static PyArrayObject *__pyx_f_7l0learn_6cyarma_uvec_to_numpy(arma::uvec const &_ __pyx_L2:; __Pyx_XDECREF((PyObject *)__pyx_v_D); __Pyx_XGIVEREF((PyObject *)__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -4670,7 +4305,6 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & __Pyx_LocalBuf_ND __pyx_pybuffernd_values; __Pyx_Buffer __pyx_pybuffer_values; PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; @@ -4694,7 +4328,6 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("sp_dmat_to_numpy", 0); - __Pyx_TraceCall("sp_dmat_to_numpy", __pyx_f[0], 228, 0, __PYX_ERR(0, 228, __pyx_L1_error)); __Pyx_INCREF((PyObject *)__pyx_v_rowind); __Pyx_INCREF((PyObject *)__pyx_v_colind); __Pyx_INCREF((PyObject *)__pyx_v_values); @@ -4733,7 +4366,6 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & * rowind = np.empty(X.n_nonzero, dtype=np.uint64) * if colind is None: */ - __Pyx_TraceLine(231,0,__PYX_ERR(0, 231, __pyx_L1_error)) __pyx_t_1 = (((PyObject *)__pyx_v_rowind) == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { @@ -4745,7 +4377,6 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & * if colind is None: * colind = np.empty(X.n_nonzero, dtype=np.uint64) */ - __Pyx_TraceLine(232,0,__PYX_ERR(0, 232, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 232, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 232, __pyx_L1_error) @@ -4811,7 +4442,6 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & * colind = np.empty(X.n_nonzero, dtype=np.uint64) * if values is None: */ - __Pyx_TraceLine(233,0,__PYX_ERR(0, 233, __pyx_L1_error)) __pyx_t_2 = (((PyObject *)__pyx_v_colind) == Py_None); __pyx_t_1 = (__pyx_t_2 != 0); if (__pyx_t_1) { @@ -4823,7 +4453,6 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & * if values is None: * values = np.empty(X.n_nonzero, dtype=np.double) */ - __Pyx_TraceLine(234,0,__PYX_ERR(0, 234, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_empty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 234, __pyx_L1_error) @@ -4889,7 +4518,6 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & * values = np.empty(X.n_nonzero, dtype=np.double) * */ - __Pyx_TraceLine(235,0,__PYX_ERR(0, 235, __pyx_L1_error)) __pyx_t_1 = (((PyObject *)__pyx_v_values) == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { @@ -4901,7 +4529,6 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & * * cdef sp_dmat.const_iterator it = X.begin() */ - __Pyx_TraceLine(236,0,__PYX_ERR(0, 236, __pyx_L1_error)) __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 236, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_empty); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 236, __pyx_L1_error) @@ -4967,7 +4594,6 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & * * for i in range(X.n_nonzero): */ - __Pyx_TraceLine(238,0,__PYX_ERR(0, 238, __pyx_L1_error)) __pyx_v_it = __pyx_v_X.begin(); /* "l0learn/cyarma.pyx":240 @@ -4977,7 +4603,6 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & * # TODO: Double check the following comment... * # Arma is column major so rows are columns and columns are rows when converting back to l0learn (row major) */ - __Pyx_TraceLine(240,0,__PYX_ERR(0, 240, __pyx_L1_error)) __pyx_t_9 = __pyx_v_X.n_nonzero; __pyx_t_15 = __pyx_t_9; for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_15; __pyx_t_16+=1) { @@ -4990,7 +4615,6 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & * colind[i] = it.row() * values[i] = deref(it) */ - __Pyx_TraceLine(243,0,__PYX_ERR(0, 243, __pyx_L1_error)) __pyx_t_17 = __pyx_v_i; if (__pyx_t_17 < 0) __pyx_t_17 += __pyx_pybuffernd_rowind.diminfo[0].shape; *__Pyx_BufPtrStrided1d(__pyx_t_5numpy_uint64_t *, __pyx_pybuffernd_rowind.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_rowind.diminfo[0].strides) = __pyx_v_it.col(); @@ -5002,7 +4626,6 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & * values[i] = deref(it) * inc(it) */ - __Pyx_TraceLine(244,0,__PYX_ERR(0, 244, __pyx_L1_error)) __pyx_t_17 = __pyx_v_i; if (__pyx_t_17 < 0) __pyx_t_17 += __pyx_pybuffernd_colind.diminfo[0].shape; *__Pyx_BufPtrStrided1d(__pyx_t_5numpy_uint64_t *, __pyx_pybuffernd_colind.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_colind.diminfo[0].strides) = __pyx_v_it.row(); @@ -5014,7 +4637,6 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & * inc(it) * */ - __Pyx_TraceLine(245,0,__PYX_ERR(0, 245, __pyx_L1_error)) __pyx_t_17 = __pyx_v_i; if (__pyx_t_17 < 0) __pyx_t_17 += __pyx_pybuffernd_values.diminfo[0].shape; *__Pyx_BufPtrStrided1d(__pyx_t_5numpy_double_t *, __pyx_pybuffernd_values.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_values.diminfo[0].strides) = (*__pyx_v_it); @@ -5026,7 +4648,6 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & * * return csc_matrix((values, (colind, rowind)), shape=(X.n_rows, X.n_cols)) */ - __Pyx_TraceLine(246,0,__PYX_ERR(0, 246, __pyx_L1_error)) (void)((++__pyx_v_it)); } @@ -5035,7 +4656,6 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & * * return csc_matrix((values, (colind, rowind)), shape=(X.n_rows, X.n_cols)) # <<<<<<<<<<<<<< */ - __Pyx_TraceLine(248,0,__PYX_ERR(0, 248, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_csc_matrix); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 248, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); @@ -5121,7 +4741,6 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & __Pyx_XDECREF((PyObject *)__pyx_v_colind); __Pyx_XDECREF((PyObject *)__pyx_v_values); __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5136,14 +4755,12 @@ static PyObject *__pyx_f_7l0learn_6cyarma_sp_dmat_to_numpy(arma::sp_dmat const & static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); - __Pyx_TraceCall("PyArray_MultiIterNew1", __pyx_f[1], 735, 0, __PYX_ERR(1, 735, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":736 * @@ -5152,7 +4769,6 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ * * cdef inline object PyArray_MultiIterNew2(a, b): */ - __Pyx_TraceLine(736,0,__PYX_ERR(1, 736, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 736, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -5175,7 +4791,6 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5190,14 +4805,12 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); - __Pyx_TraceCall("PyArray_MultiIterNew2", __pyx_f[1], 738, 0, __PYX_ERR(1, 738, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":739 * @@ -5206,7 +4819,6 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ * * cdef inline object PyArray_MultiIterNew3(a, b, c): */ - __Pyx_TraceLine(739,0,__PYX_ERR(1, 739, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 739, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -5229,7 +4841,6 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5244,14 +4855,12 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); - __Pyx_TraceCall("PyArray_MultiIterNew3", __pyx_f[1], 741, 0, __PYX_ERR(1, 741, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":742 * @@ -5260,7 +4869,6 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ * * cdef inline object PyArray_MultiIterNew4(a, b, c, d): */ - __Pyx_TraceLine(742,0,__PYX_ERR(1, 742, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 742, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -5283,7 +4891,6 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5298,14 +4905,12 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); - __Pyx_TraceCall("PyArray_MultiIterNew4", __pyx_f[1], 744, 0, __PYX_ERR(1, 744, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":745 * @@ -5314,7 +4919,6 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ * * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): */ - __Pyx_TraceLine(745,0,__PYX_ERR(1, 745, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 745, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -5337,7 +4941,6 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5352,14 +4955,12 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); - __Pyx_TraceCall("PyArray_MultiIterNew5", __pyx_f[1], 747, 0, __PYX_ERR(1, 747, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":748 * @@ -5368,7 +4969,6 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ * * cdef inline tuple PyDataType_SHAPE(dtype d): */ - __Pyx_TraceLine(748,0,__PYX_ERR(1, 748, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 748, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); @@ -5391,7 +4991,6 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5406,14 +5005,9 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations int __pyx_t_1; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); - __Pyx_TraceCall("PyDataType_SHAPE", __pyx_f[1], 750, 0, __PYX_ERR(1, 750, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":751 * @@ -5422,7 +5016,6 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ * return d.subarray.shape * else: */ - __Pyx_TraceLine(751,0,__PYX_ERR(1, 751, __pyx_L1_error)) __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0); if (__pyx_t_1) { @@ -5433,7 +5026,6 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ * else: * return () */ - __Pyx_TraceLine(752,0,__PYX_ERR(1, 752, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape)); __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape); @@ -5455,7 +5047,6 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ * * */ - __Pyx_TraceLine(754,0,__PYX_ERR(1, 754, __pyx_L1_error)) /*else*/ { __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_empty_tuple); @@ -5472,12 +5063,8 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ */ /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("numpy.PyDataType_SHAPE", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5491,13 +5078,8 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__ */ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("set_array_base", 0); - __Pyx_TraceCall("set_array_base", __pyx_f[1], 929, 0, __PYX_ERR(1, 929, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":930 * @@ -5506,7 +5088,6 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a * PyArray_SetBaseObject(arr, base) * */ - __Pyx_TraceLine(930,0,__PYX_ERR(1, 930, __pyx_L1_error)) Py_INCREF(__pyx_v_base); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":931 @@ -5516,7 +5097,6 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a * * cdef inline object get_array_base(ndarray arr): */ - __Pyx_TraceLine(931,0,__PYX_ERR(1, 931, __pyx_L1_error)) (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":929 @@ -5528,11 +5108,6 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a */ /* function exit code */ - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_WriteUnraisable("numpy.set_array_base", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); - __pyx_L0:; - __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); } @@ -5547,14 +5122,9 @@ static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_a static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { PyObject *__pyx_v_base; PyObject *__pyx_r = NULL; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations int __pyx_t_1; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_array_base", 0); - __Pyx_TraceCall("get_array_base", __pyx_f[1], 933, 0, __PYX_ERR(1, 933, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":934 * @@ -5563,7 +5133,6 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py * if base is NULL: * return None */ - __Pyx_TraceLine(934,0,__PYX_ERR(1, 934, __pyx_L1_error)) __pyx_v_base = PyArray_BASE(__pyx_v_arr); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":935 @@ -5573,7 +5142,6 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py * return None * return base */ - __Pyx_TraceLine(935,0,__PYX_ERR(1, 935, __pyx_L1_error)) __pyx_t_1 = ((__pyx_v_base == NULL) != 0); if (__pyx_t_1) { @@ -5584,7 +5152,6 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py * return base * */ - __Pyx_TraceLine(936,0,__PYX_ERR(1, 936, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; @@ -5605,7 +5172,6 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py * * # Versions of the import_* functions which are more suitable for */ - __Pyx_TraceLine(937,0,__PYX_ERR(1, 937, __pyx_L1_error)) __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_base)); __pyx_r = ((PyObject *)__pyx_v_base); @@ -5620,12 +5186,8 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py */ /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("numpy.get_array_base", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); - __Pyx_TraceReturn(__pyx_r, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5640,7 +5202,6 @@ static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__py static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { int __pyx_r; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; @@ -5654,7 +5215,6 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_array", 0); - __Pyx_TraceCall("import_array", __pyx_f[1], 941, 0, __PYX_ERR(1, 941, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":942 * # Cython code. @@ -5663,7 +5223,6 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { * __pyx_import_array() * except Exception: */ - __Pyx_TraceLine(942,0,__PYX_ERR(1, 942, __pyx_L1_error)) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign @@ -5680,7 +5239,6 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { * except Exception: * raise ImportError("numpy.core.multiarray failed to import") */ - __Pyx_TraceLine(943,0,__PYX_ERR(1, 943, __pyx_L3_error)) __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 943, __pyx_L3_error) /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":942 @@ -5704,7 +5262,6 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { * raise ImportError("numpy.core.multiarray failed to import") * */ - __Pyx_TraceLine(944,0,__PYX_ERR(1, 944, __pyx_L5_except_error)) __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); @@ -5720,7 +5277,6 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { * * cdef inline int import_umath() except -1: */ - __Pyx_TraceLine(945,0,__PYX_ERR(1, 945, __pyx_L5_except_error)) __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 945, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); @@ -5764,7 +5320,6 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; - __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5779,7 +5334,6 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { int __pyx_r; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; @@ -5793,7 +5347,6 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_umath", 0); - __Pyx_TraceCall("import_umath", __pyx_f[1], 947, 0, __PYX_ERR(1, 947, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":948 * @@ -5802,7 +5355,6 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { * _import_umath() * except Exception: */ - __Pyx_TraceLine(948,0,__PYX_ERR(1, 948, __pyx_L1_error)) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign @@ -5819,7 +5371,6 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { * except Exception: * raise ImportError("numpy.core.umath failed to import") */ - __Pyx_TraceLine(949,0,__PYX_ERR(1, 949, __pyx_L3_error)) __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 949, __pyx_L3_error) /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":948 @@ -5843,7 +5394,6 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { * raise ImportError("numpy.core.umath failed to import") * */ - __Pyx_TraceLine(950,0,__PYX_ERR(1, 950, __pyx_L5_except_error)) __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); @@ -5859,7 +5409,6 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { * * cdef inline int import_ufunc() except -1: */ - __Pyx_TraceLine(951,0,__PYX_ERR(1, 951, __pyx_L5_except_error)) __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 951, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); @@ -5903,7 +5452,6 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; - __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5918,7 +5466,6 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { int __pyx_r; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; @@ -5932,7 +5479,6 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("import_ufunc", 0); - __Pyx_TraceCall("import_ufunc", __pyx_f[1], 953, 0, __PYX_ERR(1, 953, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":954 * @@ -5941,7 +5487,6 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { * _import_umath() * except Exception: */ - __Pyx_TraceLine(954,0,__PYX_ERR(1, 954, __pyx_L1_error)) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign @@ -5958,7 +5503,6 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { * except Exception: * raise ImportError("numpy.core.umath failed to import") */ - __Pyx_TraceLine(955,0,__PYX_ERR(1, 955, __pyx_L3_error)) __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 955, __pyx_L3_error) /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":954 @@ -5982,7 +5526,6 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { * raise ImportError("numpy.core.umath failed to import") * */ - __Pyx_TraceLine(956,0,__PYX_ERR(1, 956, __pyx_L5_except_error)) __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_4) { __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); @@ -5998,7 +5541,6 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { * * cdef extern from *: */ - __Pyx_TraceLine(957,0,__PYX_ERR(1, 957, __pyx_L5_except_error)) __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 957, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_Raise(__pyx_t_8, 0, 0, 0); @@ -6042,7 +5584,6 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; - __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -6057,13 +5598,8 @@ static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_obj) { int __pyx_r; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("is_timedelta64_object", 0); - __Pyx_TraceCall("is_timedelta64_object", __pyx_f[1], 967, 0, __PYX_ERR(1, 967, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":979 * bool @@ -6072,7 +5608,6 @@ static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_ * * */ - __Pyx_TraceLine(979,0,__PYX_ERR(1, 979, __pyx_L1_error)) __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyTimedeltaArrType_Type)); goto __pyx_L0; @@ -6085,11 +5620,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_ */ /* function exit code */ - __pyx_L1_error:; - __Pyx_WriteUnraisable("numpy.is_timedelta64_object", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); - __pyx_r = 0; __pyx_L0:; - __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -6104,13 +5635,8 @@ static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_ static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_obj) { int __pyx_r; - __Pyx_TraceDeclarations __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; __Pyx_RefNannySetupContext("is_datetime64_object", 0); - __Pyx_TraceCall("is_datetime64_object", __pyx_f[1], 982, 0, __PYX_ERR(1, 982, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":994 * bool @@ -6119,7 +5645,6 @@ static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_o * * */ - __Pyx_TraceLine(994,0,__PYX_ERR(1, 994, __pyx_L1_error)) __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyDatetimeArrType_Type)); goto __pyx_L0; @@ -6132,11 +5657,7 @@ static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_o */ /* function exit code */ - __pyx_L1_error:; - __Pyx_WriteUnraisable("numpy.is_datetime64_object", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); - __pyx_r = 0; __pyx_L0:; - __Pyx_TraceReturn(Py_None, 0); __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -6151,11 +5672,6 @@ static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_o static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject *__pyx_v_obj) { npy_datetime __pyx_r; - __Pyx_TraceDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_TraceCall("get_datetime64_value", __pyx_f[1], 997, 1, __PYX_ERR(1, 997, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1004 * also needed. That can be found using `get_datetime64_unit`. @@ -6164,7 +5680,6 @@ static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject * * * */ - __Pyx_TraceLine(1004,1,__PYX_ERR(1, 1004, __pyx_L1_error)) __pyx_r = ((PyDatetimeScalarObject *)__pyx_v_obj)->obval; goto __pyx_L0; @@ -6177,11 +5692,7 @@ static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject * */ /* function exit code */ - __pyx_L1_error:; - __Pyx_WriteUnraisable("numpy.get_datetime64_value", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1); - __pyx_r = 0; __pyx_L0:; - __Pyx_TraceReturn(Py_None, 1); return __pyx_r; } @@ -6195,11 +5706,6 @@ static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject * static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject *__pyx_v_obj) { npy_timedelta __pyx_r; - __Pyx_TraceDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_TraceCall("get_timedelta64_value", __pyx_f[1], 1007, 1, __PYX_ERR(1, 1007, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1011 * returns the int64 value underlying scalar numpy timedelta64 object @@ -6208,7 +5714,6 @@ static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject * * */ - __Pyx_TraceLine(1011,1,__PYX_ERR(1, 1011, __pyx_L1_error)) __pyx_r = ((PyTimedeltaScalarObject *)__pyx_v_obj)->obval; goto __pyx_L0; @@ -6221,11 +5726,7 @@ static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject */ /* function exit code */ - __pyx_L1_error:; - __Pyx_WriteUnraisable("numpy.get_timedelta64_value", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1); - __pyx_r = 0; __pyx_L0:; - __Pyx_TraceReturn(Py_None, 1); return __pyx_r; } @@ -6239,18 +5740,12 @@ static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject static CYTHON_INLINE NPY_DATETIMEUNIT __pyx_f_5numpy_get_datetime64_unit(PyObject *__pyx_v_obj) { NPY_DATETIMEUNIT __pyx_r; - __Pyx_TraceDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_TraceCall("get_datetime64_unit", __pyx_f[1], 1014, 1, __PYX_ERR(1, 1014, __pyx_L1_error)); /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1018 * returns the unit part of the dtype for a numpy datetime64 object. * """ * return (obj).obmeta.base # <<<<<<<<<<<<<< */ - __Pyx_TraceLine(1018,1,__PYX_ERR(1, 1018, __pyx_L1_error)) __pyx_r = ((NPY_DATETIMEUNIT)((PyDatetimeScalarObject *)__pyx_v_obj)->obmeta.base); goto __pyx_L0; @@ -6263,11 +5758,7 @@ static CYTHON_INLINE NPY_DATETIMEUNIT __pyx_f_5numpy_get_datetime64_unit(PyObjec */ /* function exit code */ - __pyx_L1_error:; - __Pyx_WriteUnraisable("numpy.get_datetime64_unit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 1); - __pyx_r = (NPY_DATETIMEUNIT) 0; __pyx_L0:; - __Pyx_TraceReturn(Py_None, 1); return __pyx_r; } @@ -6640,7 +6131,6 @@ static CYTHON_SMALL_CODE int __pyx_pymod_exec_cyarma(PyObject *__pyx_pyinit_modu #endif #endif { - __Pyx_TraceDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; @@ -6747,7 +6237,6 @@ if (!__Pyx_RefNanny) { #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) #endif - __Pyx_TraceCall("__Pyx_PyMODINIT_FUNC PyInit_cyarma(void)", __pyx_f[0], 1, 0, __PYX_ERR(0, 1, __pyx_L1_error)); /* "l0learn/cyarma.pyx":2 * cimport cython @@ -6755,7 +6244,6 @@ if (!__Pyx_RefNanny) { * cimport numpy as np * */ - __Pyx_TraceLine(2,0,__PYX_ERR(0, 2, __pyx_L1_error)) __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 2, __pyx_L1_error) @@ -6768,7 +6256,6 @@ if (!__Pyx_RefNanny) { * from cython.operator cimport dereference as deref, preincrement as inc * */ - __Pyx_TraceLine(5,0,__PYX_ERR(0, 5, __pyx_L1_error)) __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_csc_matrix); @@ -6783,362 +6270,48 @@ if (!__Pyx_RefNanny) { __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "l0learn/cyarma.pyx":87 - * ##### Tools to convert numpy arrays to armadillo arrays ###### - * @cython.boundscheck(False) - * cdef field[sp_dmat] list_to_sp_dmat_field(list values): # <<<<<<<<<<<<<< - * cdef field[sp_dmat] f = field[sp_dmat](len(values)) - * for i, value in enumerate(values): - */ - __Pyx_TraceLine(87,0,__PYX_ERR(0, 87, __pyx_L1_error)) - - - /* "l0learn/cyarma.pyx":97 - * - * @cython.boundscheck(False) - * cdef field[dvec] list_to_dvec_field(list values): # <<<<<<<<<<<<<< - * cdef field[dvec] f = field[dvec](len(values)) - * for i, value in enumerate(values): + /* "l0learn/cyarma.pyx":1 + * cimport cython # <<<<<<<<<<<<<< + * import numpy as np + * cimport numpy as np */ - __Pyx_TraceLine(97,0,__PYX_ERR(0, 97, __pyx_L1_error)) - + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "l0learn/cyarma.pyx":106 - * + /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1014 * - * cdef dmat * numpy_to_dmat(np.ndarray[np.double_t, ndim=2] X): # <<<<<<<<<<<<<< - * # TODO: Add checks on X (Size, ...) - * # TODO: Add flags for new dmat. See: Advanced constructors in http://arma.sourceforge.net/docs.html#Mat - */ - __Pyx_TraceLine(106,0,__PYX_ERR(0, 106, __pyx_L1_error)) - - - /* "l0learn/cyarma.pyx":116 - * return aR_p * - * cdef dmat numpy_to_dmat_d(np.ndarray[np.double_t, ndim=2] X): # <<<<<<<<<<<<<< - * cdef dmat * aR_p = numpy_to_dmat(X) - * cdef dmat aR = deref(aR_p) + * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< + * """ + * returns the unit part of the dtype for a numpy datetime64 object. */ - __Pyx_TraceLine(116,0,__PYX_ERR(0, 116, __pyx_L1_error)) + /*--- Wrapped vars code ---*/ - /* "l0learn/cyarma.pyx":122 - * return aR - * - * cdef dvec * numpy_to_dvec(np.ndarray[np.double_t, ndim=1] x): # <<<<<<<<<<<<<< - * if not (x.flags.f_contiguous or x.flags.owndata): - * x = x.copy() - */ - __Pyx_TraceLine(122,0,__PYX_ERR(0, 122, __pyx_L1_error)) - - - /* "l0learn/cyarma.pyx":128 - * return ar_p - * - * cdef dvec numpy_to_dvec_d(np.ndarray[np.double_t, ndim=1] x): # <<<<<<<<<<<<<< - * cdef dvec *ar_p = numpy_to_dvec(x) - * cdef dvec ar = deref(ar_p) - */ - __Pyx_TraceLine(128,0,__PYX_ERR(0, 128, __pyx_L1_error)) - - - /* "l0learn/cyarma.pyx":134 - * return ar - * - * cdef uvec * numpy_to_uvec(np.ndarray[np.uint64_t, ndim=1] x): # <<<<<<<<<<<<<< - * if not (x.flags.f_contiguous or x.flags.owndata): - * x = x.copy() - */ - __Pyx_TraceLine(134,0,__PYX_ERR(0, 134, __pyx_L1_error)) - - - /* "l0learn/cyarma.pyx":140 - * return ar_p - * - * cdef uvec numpy_to_uvec_d(np.ndarray[np.uint64_t, ndim=1] x): # <<<<<<<<<<<<<< - * cdef uvec *ar_p = numpy_to_uvec(x) - * cdef uvec ar = deref(ar_p) - */ - __Pyx_TraceLine(140,0,__PYX_ERR(0, 140, __pyx_L1_error)) - - - /* "l0learn/cyarma.pyx":147 - * - * - * cdef sp_dmat * numpy_to_sp_dmat(x): # <<<<<<<<<<<<<< - * if not isinstance(x, csc_matrix): - * raise ValueError(f"expected x to be of type {csc_matrix}, but got {type(x)}") - */ - __Pyx_TraceLine(147,0,__PYX_ERR(0, 147, __pyx_L1_error)) - - - /* "l0learn/cyarma.pyx":165 - * - * - * cdef sp_dmat numpy_to_sp_dmat_d(x): # <<<<<<<<<<<<<< - * cdef sp_dmat *ar_p = numpy_to_sp_dmat(x) - * cdef sp_dmat ar = deref(ar_p) - */ - __Pyx_TraceLine(165,0,__PYX_ERR(0, 165, __pyx_L1_error)) - - - /* "l0learn/cyarma.pyx":177 - * - * @cython.boundscheck(False) - * cdef list sp_dmat_field_to_list(field[sp_dmat] f): # <<<<<<<<<<<<<< - * cdef list lst = [] - * for i in range(f.n_elem): - */ - __Pyx_TraceLine(177,0,__PYX_ERR(0, 177, __pyx_L1_error)) - - - /* "l0learn/cyarma.pyx":185 - * - * @cython.boundscheck(False) - * cdef list dvec_field_to_list(field[dvec] f): # <<<<<<<<<<<<<< - * cdef list lst = [] - * for i in range(f.n_elem): - */ - __Pyx_TraceLine(185,0,__PYX_ERR(0, 185, __pyx_L1_error)) - - - /* "l0learn/cyarma.pyx":192 - * - * @cython.boundscheck(False) - * cdef np.ndarray[np.double_t, ndim=2] dmat_to_numpy(const dmat & X, np.ndarray[np.double_t, ndim=2] D): # <<<<<<<<<<<<<< - * # TODO: Check order of X and D - * cdef const double * Xptr = X.memptr() - */ - __Pyx_TraceLine(192,0,__PYX_ERR(0, 192, __pyx_L1_error)) - - - /* "l0learn/cyarma.pyx":204 - * - * @cython.boundscheck(False) - * cdef np.ndarray[np.double_t, ndim=1] dvec_to_numpy(const dvec & X, np.ndarray[np.double_t, ndim=1] D): # <<<<<<<<<<<<<< - * cdef const double * Xptr = X.memptr() - * - */ - __Pyx_TraceLine(204,0,__PYX_ERR(0, 204, __pyx_L1_error)) - - - /* "l0learn/cyarma.pyx":216 - * - * @cython.boundscheck(False) - * cdef np.ndarray[np.uint64_t, ndim=1] uvec_to_numpy(const uvec & X, np.ndarray[np.uint64_t, ndim=1] D): # <<<<<<<<<<<<<< - * cdef const unsigned long long * Xptr = X.memptr() - * - */ - __Pyx_TraceLine(216,0,__PYX_ERR(0, 216, __pyx_L1_error)) - - - /* "l0learn/cyarma.pyx":228 - * - * @cython.boundscheck(False) - * cdef sp_dmat_to_numpy(const sp_dmat & X, np.ndarray[np.uint64_t, ndim=1] rowind, # <<<<<<<<<<<<<< - * np.ndarray[np.uint64_t, ndim=1] colind, np.ndarray[np.double_t, ndim=1] values): - * # TODO: Check order of X and D - */ - __Pyx_TraceLine(228,0,__PYX_ERR(0, 228, __pyx_L1_error)) - - - /* "l0learn/cyarma.pyx":1 - * cimport cython # <<<<<<<<<<<<<< - * import numpy as np - * cimport numpy as np - */ - __Pyx_TraceLine(1,0,__PYX_ERR(0, 1, __pyx_L1_error)) - __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":735 - * ctypedef npy_cdouble complex_t - * - * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(1, a) - * - */ - __Pyx_TraceLine(735,0,__PYX_ERR(1, 735, __pyx_L1_error)) - - - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":738 - * return PyArray_MultiIterNew(1, a) - * - * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(2, a, b) - * - */ - __Pyx_TraceLine(738,0,__PYX_ERR(1, 738, __pyx_L1_error)) - - - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":741 - * return PyArray_MultiIterNew(2, a, b) - * - * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(3, a, b, c) - * - */ - __Pyx_TraceLine(741,0,__PYX_ERR(1, 741, __pyx_L1_error)) - - - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":744 - * return PyArray_MultiIterNew(3, a, b, c) - * - * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(4, a, b, c, d) - * - */ - __Pyx_TraceLine(744,0,__PYX_ERR(1, 744, __pyx_L1_error)) - - - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":747 - * return PyArray_MultiIterNew(4, a, b, c, d) - * - * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< - * return PyArray_MultiIterNew(5, a, b, c, d, e) - * - */ - __Pyx_TraceLine(747,0,__PYX_ERR(1, 747, __pyx_L1_error)) - - - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":750 - * return PyArray_MultiIterNew(5, a, b, c, d, e) - * - * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< - * if PyDataType_HASSUBARRAY(d): - * return d.subarray.shape - */ - __Pyx_TraceLine(750,0,__PYX_ERR(1, 750, __pyx_L1_error)) - - - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":929 - * int _import_umath() except -1 - * - * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< - * Py_INCREF(base) # important to do this before stealing the reference below! - * PyArray_SetBaseObject(arr, base) - */ - __Pyx_TraceLine(929,0,__PYX_ERR(1, 929, __pyx_L1_error)) - - - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":933 - * PyArray_SetBaseObject(arr, base) - * - * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< - * base = PyArray_BASE(arr) - * if base is NULL: - */ - __Pyx_TraceLine(933,0,__PYX_ERR(1, 933, __pyx_L1_error)) - - - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":941 - * # Versions of the import_* functions which are more suitable for - * # Cython code. - * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< - * try: - * __pyx_import_array() - */ - __Pyx_TraceLine(941,0,__PYX_ERR(1, 941, __pyx_L1_error)) - - - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":947 - * raise ImportError("numpy.core.multiarray failed to import") - * - * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() - */ - __Pyx_TraceLine(947,0,__PYX_ERR(1, 947, __pyx_L1_error)) - - - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":953 - * raise ImportError("numpy.core.umath failed to import") - * - * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< - * try: - * _import_umath() - */ - __Pyx_TraceLine(953,0,__PYX_ERR(1, 953, __pyx_L1_error)) - - - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":967 - * - * - * cdef inline bint is_timedelta64_object(object obj): # <<<<<<<<<<<<<< - * """ - * Cython equivalent of `isinstance(obj, np.timedelta64)` - */ - __Pyx_TraceLine(967,0,__PYX_ERR(1, 967, __pyx_L1_error)) - - - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":982 - * - * - * cdef inline bint is_datetime64_object(object obj): # <<<<<<<<<<<<<< - * """ - * Cython equivalent of `isinstance(obj, np.datetime64)` - */ - __Pyx_TraceLine(982,0,__PYX_ERR(1, 982, __pyx_L1_error)) - - - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":997 - * - * - * cdef inline npy_datetime get_datetime64_value(object obj) nogil: # <<<<<<<<<<<<<< - * """ - * returns the int64 value underlying scalar numpy datetime64 object - */ - __Pyx_TraceLine(997,0,__PYX_ERR(1, 997, __pyx_L1_error)) - - - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1007 - * - * - * cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: # <<<<<<<<<<<<<< - * """ - * returns the int64 value underlying scalar numpy timedelta64 object - */ - __Pyx_TraceLine(1007,0,__PYX_ERR(1, 1007, __pyx_L1_error)) - - - /* "../../../../opt/anaconda3/envs/l0learn-test2/lib/python3.9/site-packages/numpy/__init__.pxd":1014 - * - * - * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: # <<<<<<<<<<<<<< - * """ - * returns the unit part of the dtype for a numpy datetime64 object. - */ - __Pyx_TraceLine(1014,0,__PYX_ERR(1, 1014, __pyx_L1_error)) - - __Pyx_TraceReturn(Py_None, 0); - - /*--- Wrapped vars code ---*/ - - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - if (__pyx_m) { - if (__pyx_d) { - __Pyx_AddTraceback("init l0learn.cyarma", __pyx_clineno, __pyx_lineno, __pyx_filename); - } - Py_CLEAR(__pyx_m); - } else if (!PyErr_Occurred()) { - PyErr_SetString(PyExc_ImportError, "init l0learn.cyarma"); - } - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - #if CYTHON_PEP489_MULTI_PHASE_INIT - return (__pyx_m != NULL) ? 0 : -1; - #elif PY_MAJOR_VERSION >= 3 - return __pyx_m; - #else - return; - #endif -} + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init l0learn.cyarma", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_CLEAR(__pyx_m); + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init l0learn.cyarma"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if CYTHON_PEP489_MULTI_PHASE_INIT + return (__pyx_m != NULL) ? 0 : -1; + #elif PY_MAJOR_VERSION >= 3 + return __pyx_m; + #else + return; + #endif +} /* --- Runtime support code --- */ /* Refnanny */ @@ -7186,122 +6359,6 @@ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { return result; } -/* PyErrFetchRestore */ -#if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { - PyObject *tmp_type, *tmp_value, *tmp_tb; - tmp_type = tstate->curexc_type; - tmp_value = tstate->curexc_value; - tmp_tb = tstate->curexc_traceback; - tstate->curexc_type = type; - tstate->curexc_value = value; - tstate->curexc_traceback = tb; - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); -} -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { - *type = tstate->curexc_type; - *value = tstate->curexc_value; - *tb = tstate->curexc_traceback; - tstate->curexc_type = 0; - tstate->curexc_value = 0; - tstate->curexc_traceback = 0; -} -#endif - -/* Profile */ -#if CYTHON_PROFILE -static int __Pyx_TraceSetupAndCall(PyCodeObject** code, - PyFrameObject** frame, - PyThreadState* tstate, - const char *funcname, - const char *srcfile, - int firstlineno) { - PyObject *type, *value, *traceback; - int retval; - if (*frame == NULL || !CYTHON_PROFILE_REUSE_FRAME) { - if (*code == NULL) { - *code = __Pyx_createFrameCodeObject(funcname, srcfile, firstlineno); - if (*code == NULL) return 0; - } - *frame = PyFrame_New( - tstate, /*PyThreadState *tstate*/ - *code, /*PyCodeObject *code*/ - __pyx_d, /*PyObject *globals*/ - 0 /*PyObject *locals*/ - ); - if (*frame == NULL) return 0; - if (CYTHON_TRACE && (*frame)->f_trace == NULL) { - Py_INCREF(Py_None); - (*frame)->f_trace = Py_None; - } -#if PY_VERSION_HEX < 0x030400B1 - } else { - (*frame)->f_tstate = tstate; -#endif - } - __Pyx_PyFrame_SetLineNumber(*frame, firstlineno); - retval = 1; - tstate->tracing++; - __Pyx_SetTracing(tstate, 0); - __Pyx_ErrFetchInState(tstate, &type, &value, &traceback); - #if CYTHON_TRACE - if (tstate->c_tracefunc) - retval = tstate->c_tracefunc(tstate->c_traceobj, *frame, PyTrace_CALL, NULL) == 0; - if (retval && tstate->c_profilefunc) - #endif - retval = tstate->c_profilefunc(tstate->c_profileobj, *frame, PyTrace_CALL, NULL) == 0; - __Pyx_SetTracing(tstate, (tstate->c_profilefunc || (CYTHON_TRACE && tstate->c_tracefunc))); - tstate->tracing--; - if (retval) { - __Pyx_ErrRestoreInState(tstate, type, value, traceback); - return __Pyx_IsTracing(tstate, 0, 0) && retval; - } else { - Py_XDECREF(type); - Py_XDECREF(value); - Py_XDECREF(traceback); - return -1; - } -} -static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno) { - PyCodeObject *py_code = 0; -#if PY_MAJOR_VERSION >= 3 - py_code = PyCode_NewEmpty(srcfile, funcname, firstlineno); - if (likely(py_code)) { - py_code->co_flags |= CO_OPTIMIZED | CO_NEWLOCALS; - } -#else - PyObject *py_srcfile = 0; - PyObject *py_funcname = 0; - py_funcname = PyString_FromString(funcname); - if (unlikely(!py_funcname)) goto bad; - py_srcfile = PyString_FromString(srcfile); - if (unlikely(!py_srcfile)) goto bad; - py_code = PyCode_New( - 0, - 0, - 0, - CO_OPTIMIZED | CO_NEWLOCALS, - __pyx_empty_bytes, /*PyObject *code,*/ - __pyx_empty_tuple, /*PyObject *consts,*/ - __pyx_empty_tuple, /*PyObject *names,*/ - __pyx_empty_tuple, /*PyObject *varnames,*/ - __pyx_empty_tuple, /*PyObject *freevars,*/ - __pyx_empty_tuple, /*PyObject *cellvars,*/ - py_srcfile, /*PyObject *filename,*/ - py_funcname, /*PyObject *name,*/ - firstlineno, - __pyx_empty_bytes /*PyObject *lnotab*/ - ); -bad: - Py_XDECREF(py_srcfile); - Py_XDECREF(py_funcname); -#endif - return py_code; -} -#endif - /* PyDictVersioning */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { @@ -7681,6 +6738,30 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObjec } #endif +/* PyErrFetchRestore */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +} +#endif + /* RaiseException */ #if PY_MAJOR_VERSION < 3 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, diff --git a/python/l0learn/cyarma.pyx b/python/l0learn/cyarma.pyx index 4d61597..b2618da 100644 --- a/python/l0learn/cyarma.pyx +++ b/python/l0learn/cyarma.pyx @@ -108,7 +108,7 @@ cdef dmat * numpy_to_dmat(np.ndarray[np.double_t, ndim=2] X): # TODO: Add flags for new dmat. See: Advanced constructors in http://arma.sourceforge.net/docs.html#Mat # mat(ptr_aux_mem, n_rows, n_cols, copy_aux_mem = true, strict = false) # TODO: raise Warning on copy or replication of data - if not (X.flags.f_contiguous or X.flags.owndata): + if not X.flags.f_contiguous: X = X.copy(order="F") cdef dmat *aR_p = new dmat( X.data, X.shape[0], X.shape[1], False, True) return aR_p diff --git a/python/l0learn/interface.cpp b/python/l0learn/interface.cpp index 65e66b7..5c77b16 100644 --- a/python/l0learn/interface.cpp +++ b/python/l0learn/interface.cpp @@ -1912,6 +1912,7 @@ static const char __pyx_k_results[] = "results"; static const char __pyx_k_FitModel[] = "FitModel"; static const char __pyx_k_Logistic[] = "Logistic"; static const char __pyx_k_Optional[] = "Optional"; +static const char __pyx_k_Sequence[] = "Sequence"; static const char __pyx_k_argwhere[] = "argwhere"; static const char __pyx_k_cv_means[] = "cv_means"; static const char __pyx_k_lambda_0[] = "lambda_0"; @@ -1947,6 +1948,7 @@ static const char __pyx_k_with_bounds[] = "with_bounds"; static const char __pyx_k_SquaredError[] = "SquaredError"; static const char __pyx_k_SquaredHinge[] = "SquaredHinge"; static const char __pyx_k_c_algorithim[] = "c_algorithim"; +static const char __pyx_k_fit_line_261[] = "fit (line 261)"; static const char __pyx_k_partial_sort[] = "partial_sort"; static const char __pyx_k_scipy_sparse[] = "scipy.sparse"; static const char __pyx_k_second_value[] = "second_value"; @@ -1955,6 +1957,7 @@ static const char __pyx_k_unique_items[] = "unique_items"; static const char __pyx_k_c_lambda_grid[] = "c_lambda_grid"; static const char __pyx_k_SUPPORTED_LOSS[] = "SUPPORTED_LOSS"; static const char __pyx_k_active_set_num[] = "active_set_num"; +static const char __pyx_k_cvfit_line_549[] = "cvfit (line 549)"; static const char __pyx_k_l0learn_models[] = "l0learn.models"; static const char __pyx_k_bad_lambda_grid[] = "bad_lambda_grid"; static const char __pyx_k_exclude_first_k[] = "exclude_first_k"; @@ -1978,6 +1981,7 @@ static const char __pyx_k_expected_X_to_be_2D_but_got[] = "expected X to be 2D, static const char __pyx_k_containing_an_increasing_value[] = "] containing an increasing value."; static const char __pyx_k_expected_y_vector_to_have_type[] = "expected y vector to have type "; static const char __pyx_k_of_non_negative_floats_but_got[] = " of non-negative floats, but got "; +static const char __pyx_k_Computes_the_regularization_pat[] = "\n Computes the regularization path for the specified loss function and penalty function.\n\n Parameters\n ----------\n X : np.ndarray or csc_matrix of shape (N, P)\n Data Matrix where rows of X are observations and columns of X are features\n\n y : np.ndarray of shape (P)\n The response vector where y[i] corresponds to X[i, :]\n For classification, a binary vector (-1, 1) is requried .\n\n loss : str\n The loss function. Currently supports the choices:\n \"SquaredError\" (for regression),\n \"Logistic\" (for logistic regression), and\n \"SquaredHinge\" (for smooth SVM).\n\n penalty : str\n The type of regularization.\n This can take either one of the following choices:\n \"L0\",\n \"L0L2\", and\n \"L0L1\"\n\n algorithm : str\n The type of algorithm used to minimize the objective function. Currently \"CD\" and \"CDPSI\" are are supported.\n \"CD\" is a variant of cyclic coordinate descent and runs very fast. \"CDPSI\" performs local combinatorial search\n on top of CD and typically achieves higher quality solutions (at the expense of increased running time).\n\n max_support_size : int\n Must be greater than 0.\n The maximum support size at which to terminate the regularization path. We recommend setting this to a small\n fraction of min(n,p) (e.g. 0.05 * min(n,p)) as L0 regularization typically selects a small portion of non-zeros.\n\n num_lambda : int, optional\n The number of lambda values to select in the regularization path.\n This value must be None if lambda_grid is supplied.When supplied, must be greater than 0.\n Note: lambda is the regularization parameter corresponding to the L0 norm.\n\n num_gamma: int, optional\n The number of gamma values to select in the regularization path.\n This value must be None if lambda_grid is supplied. When suppl""ied, must be greater than 0.\n Note: gamma is the regularization parameter corresponding to L1 or L2, depending on the chosen penalty).\n\n gamma_max : float\n The maximum value of gamma when using the L0L2 penalty.\n This value must be greater than 0.\n\n Note: For the L0L1 penalty this is automatically selected.\n\n gamma_min : float\n The minimum value of Gamma when using the L0L2 penalty.\n This value must be greater than 0 but less than gamma_max.\n Note: For the L0L1 penalty, the minimum value of gamma in the grid is set to gammaMin * gammaMax.\n\n partial_sort : bool\n If TRUE partial sorting will be used for sorting the coordinates to do greedy cycling (see our paper for\n for details). Otherwise, full sorting is used. #TODO: Add link for paper\n\n max_iter : int\n The maximum number of iterations (full cycles) for CD per grid point. The algorithm may not use the full number\n of iteration per grid point if convergence is found (defined by rtol and atol parameter)\n Must be greater than 0\n\n rtol : float\n The relative tolerance which decides when to terminate optimization as based on the relative change in the\n objective between iterations.\n Must be greater than 0 and less than 1.\n\n atol : float\n The absolute tolerance which decides when to terminate optimization as based on the absolute L2 norm of the\n residuals\n Must be greater than 0\n\n active_set : bool\n If TRUE, performs active set updates. (see our paper for for details). #TODO: Add link for paper\n\n active_set_num : int\n The number of consecutive times a support should appear before declaring support stabilization.\n (see our paper for for details). #TODO: Add link for paper\n\n Must be greater than 0.\n\n max_swaps : int\n The maximum number of swaps used by CDPSI for each grid point.\n Must be ""greater than 0. Ignored by CD algorithims.\n\n scale_down_factor : float\n Roughly amount each lambda value is scaled by between grid points. Larger values lead to closer lambdas and\n typically to smaller gaps between the support sizes.\n\n For details, see our paper - Section 5 on Adaptive Selection of Tuning Parameters). #TODO: Add link for paper\n\n Must be greater than 0 and less than 1 (strictly for both.)\n\n screen_size : int\n The number of coordinates to cycle over when performing initial correlation screening. #TODO: Add link for paper\n\n Must be greater than 0 and less than number of columns of X.\n\n lambda_grid : list of list of floats\n A grid of lambda values to use in computing the regularization path. This is by default an empty list\n and is ignored. When specified, lambda_grid should be a list of list of floats, where the ith element\n (corresponding to the ith gamma) should be a decreasing sequence of lambda values. The length of this sequence\n is directly the number of lambdas to be tried for that gamma.\n\n In the the \"L0\" penalty case, lambda_grid should be a list of 1.\n In the \"L0LX\" penalty cases, lambda_grid can be a list of any length. The length of lambda_grid will be the\n number of gamma values tried.\n\n See the example notebook for more details.\n\n Note: When lambda_grid is supplied, num_gamma and num_lambda must be None.\n\n exclude_first_k : int\n The first exclude_first_k features in X will be excluded from variable selection. In other words, the first\n exclude_first_k variables will not be included in the L0-norm penalty however they will be included in the\n L1 or L2 norm penalties, if they are specified.\n\n Must be a positive integer less than the columns of X.\n\n intercept : bool\n If False, no intercept term is included or fit in the regularization path\n "" Intercept terms are not regularized by L0 or L1/L2.\n\n lows : np array or float\n Lower bounds for coefficients. Either a scalar for all coefficients to have the same bound or a vector of\n size p (number of columns of X) where lows[i] is the lower bound for coefficient i.\n\n Lower bounds can not be above 0 (i.e. we can not specify that all coefficients must be larger than a > 0).\n Lower bounds can be set to 0 iff the corresponding upper bound for that coefficient is also not 0.\n\n highs : np array or float\n Upper bounds for coefficients. Either a scalar for all coefficients to have the same bound or a vector of\n size p (number of columns of X) where highs[i] is the upper bound for coefficient i.\n\n Upper bounds can not be below 0 (i.e. we can not specify that all coefficients must be smaller than a < 0).\n Upper bounds can be set to 0 iff the corresponding lower bound for that coefficient is also not 0.\n\n Returns\n -------\n fit_model : l0learn.models.FitModel\n FitModel instance containing all relevant information from the solution path.\n\n See Also\n -------\n l0learn.cvfit\n l0learn.models.FitModel\n\n Examples\n --------\n >>>fit_model = l0learn.fit(X, y, penalty=\"L0\", max_support_size=20)\n "; static const char __pyx_k_Expected_each_element_of_lambda[] = "Expected each element of lambda_grid to be a list of decreasing value, but got lambda_grid["; static const char __pyx_k_L0_Penalty_requires_lambda_grid[] = "L0 Penalty requires 'lambda_grid' to be a list of length 1, but got "; static const char __pyx_k_expected_algorithm_parameter_to[] = "expected algorithm parameter to be on of "; @@ -2013,6 +2017,7 @@ static const char __pyx_k_expected_to_be_high_to_be_elemen[] = "expected to be h static const char __pyx_k_expected_y_to_be_a_1D_real_numpy[] = "expected y to be a 1D real numpy, but got "; static const char __pyx_k_expected_y_vector_to_only_have_t[] = "expected y vector to only have two unique values (Binary Classification), but got "; static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import"; +static const char __pyx_k_Computes_the_regularization_pat_2[] = " Computes the regularization path for the specified loss function and penalty function and performs K-fold\n cross-validation.\n\n Parameters\n ----------\n X : np.ndarray or csc_matrix of shape (N, P)\n Data Matrix where rows of X are observations and columns of X are features\n\n y : np.ndarray of shape (P)\n The response vector where y[i] corresponds to X[i, :]\n For classification, a binary vector (-1, 1) is requried .\n\n loss : str\n The loss function. Currently supports the choices:\n \"SquaredError\" (for regression),\n \"Logistic\" (for logistic regression), and\n \"SquaredHinge\" (for smooth SVM).\n\n penalty : str\n The type of regularization.\n This can take either one of the following choices:\n \"L0\",\n \"L0L2\", and\n \"L0L1\"\n\n algorithm : str\n The type of algorithm used to minimize the objective function. Currently \"CD\" and \"CDPSI\" are are supported.\n \"CD\" is a variant of cyclic coordinate descent and runs very fast. \"CDPSI\" performs local combinatorial search\n on top of CD and typically achieves higher quality solutions (at the expense of increased running time).\n\n num_folds : int\n Must be greater than 1 and less than N (number of .\n The number of folds for cross-validation.\n\n max_support_size : int\n Must be greater than 0.\n The maximum support size at which to terminate the regularization path. We recommend setting this to a small\n fraction of min(n,p) (e.g. 0.05 * min(n,p)) as L0 regularization typically selects a small portion of non-zeros.\n\n num_lambda : int, optional\n The number of lambda values to select in the regularization path.\n This value must be None if lambda_grid is supplied.When supplied, must be greater than 0.\n Note: lambda is the regularization parameter corresponding to the L0 norm.\n""\n num_gamma: int, optional\n The number of gamma values to select in the regularization path.\n This value must be None if lambda_grid is supplied. When supplied, must be greater than 0.\n Note: gamma is the regularization parameter corresponding to L1 or L2, depending on the chosen penalty).\n\n gamma_max : float\n The maximum value of gamma when using the L0L2 penalty.\n This value must be greater than 0.\n\n Note: For the L0L1 penalty this is automatically selected.\n\n gamma_min : float\n The minimum value of Gamma when using the L0L2 penalty.\n This value must be greater than 0 but less than gamma_max.\n Note: For the L0L1 penalty, the minimum value of gamma in the grid is set to gammaMin * gammaMax.\n\n partial_sort : bool\n If TRUE partial sorting will be used for sorting the coordinates to do greedy cycling (see our paper for\n for details). Otherwise, full sorting is used. #TODO: Add link for paper\n\n max_iter : int\n The maximum number of iterations (full cycles) for CD per grid point. The algorithm may not use the full number\n of iteration per grid point if convergence is found (defined by rtol and atol parameter)\n Must be greater than 0\n\n rtol : float\n The relative tolerance which decides when to terminate optimization as based on the relative change in the\n objective between iterations.\n Must be greater than 0 and less than 1.\n\n atol : float\n The absolute tolerance which decides when to terminate optimization as based on the absolute L2 norm of the\n residuals\n Must be greater than 0\n\n active_set : bool\n If TRUE, performs active set updates. (see our paper for for details). #TODO: Add link for paper\n\n active_set_num : int\n The number of consecutive times a support should appear before declaring support stabilization.\n (see our paper for for details""). #TODO: Add link for paper\n\n Must be greater than 0.\n\n max_swaps : int\n The maximum number of swaps used by CDPSI for each grid point.\n Must be greater than 0. Ignored by CD algorithims.\n\n scale_down_factor : float\n Roughly amount each lambda value is scaled by between grid points. Larger values lead to closer lambdas and\n typically to smaller gaps between the support sizes.\n\n For details, see our paper - Section 5 on Adaptive Selection of Tuning Parameters). #TODO: Add link for paper\n\n Must be greater than 0 and less than 1 (strictly for both.)\n\n screen_size : int\n The number of coordinates to cycle over when performing initial correlation screening. #TODO: Add link for paper\n\n Must be greater than 0 and less than number of columns of X.\n\n lambda_grid : list of list of floats\n A grid of lambda values to use in computing the regularization path. This is by default an empty list\n and is ignored. When specified, lambda_grid should be a list of list of floats, where the ith element\n (corresponding to the ith gamma) should be a decreasing sequence of lambda values. The length of this sequence\n is directly the number of lambdas to be tried for that gamma.\n\n In the the \"L0\" penalty case, lambda_grid should be a list of 1.\n In the \"L0LX\" penalty cases, lambda_grid can be a list of any length. The length of lambda_grid will be the\n number of gamma values tried.\n\n See the example notebook for more details.\n\n Note: When lambda_grid is supplied, num_gamma and num_lambda must be None.\n\n exclude_first_k : int\n The first exclude_first_k features in X will be excluded from variable selection. In other words, the first\n exclude_first_k variables will not be included in the L0-norm penalty however they will be included in the\n L1 or L2 norm penalties, if they are specified.""\n\n Must be a positive integer less than the columns of X.\n\n intercept : bool\n If False, no intercept term is included or fit in the regularization path\n Intercept terms are not regularized by L0 or L1/L2.\n\n lows : np array or float\n Lower bounds for coefficients. Either a scalar for all coefficients to have the same bound or a vector of\n size p (number of columns of X) where lows[i] is the lower bound for coefficient i.\n\n Lower bounds can not be above 0 (i.e. we can not specify that all coefficients must be larger than a > 0).\n Lower bounds can be set to 0 iff the corresponding upper bound for that coefficient is also not 0.\n\n highs : np array or float\n Upper bounds for coefficients. Either a scalar for all coefficients to have the same bound or a vector of\n size p (number of columns of X) where highs[i] is the upper bound for coefficient i.\n\n Upper bounds can not be below 0 (i.e. we can not specify that all coefficients must be smaller than a < 0).\n Upper bounds can be set to 0 iff the corresponding lower bound for that coefficient is also not 0.\n\n Returns\n -------\n fit_model : l0learn.models.FitModel\n FitModel instance containing all relevant information from the solution path.\n\n See Also\n -------\n l0learn.cvfit\n l0learn.models.FitModel\n\n Examples\n --------\n >>>fit_model = l0learn.fit(X, y, penalty=\"L0\", max_support_size=20)\n "; static const char __pyx_k_expected_gamma_max_parameter_to_2[] = "expected gamma_max parameter to be a positive float less than gamma_max, but got "; static const char __pyx_k_expected_highs_to_be_a_non_negat_2[] = "expected highs to be a non-negative float, or a 1D numpy array of length "; static const char __pyx_k_expected_lows_to_be_a_non_positi_2[] = "expected lows to be a non-positive float, or a 1D numpy array of length "; @@ -2022,6 +2027,8 @@ static PyObject *__pyx_n_u_CD; static PyObject *__pyx_n_u_CDPSI; static PyObject *__pyx_n_s_CLASSIFICATION_LOSS; static PyObject *__pyx_n_s_CVFitModel; +static PyObject *__pyx_kp_u_Computes_the_regularization_pat; +static PyObject *__pyx_kp_u_Computes_the_regularization_pat_2; static PyObject *__pyx_n_u_D; static PyObject *__pyx_n_s_Dict; static PyObject *__pyx_kp_u_Expected_all_values_of_lambda_gr; @@ -2039,6 +2046,7 @@ static PyObject *__pyx_n_s_Optional; static PyObject *__pyx_n_s_SUPPORTED_ALGORITHM; static PyObject *__pyx_n_s_SUPPORTED_LOSS; static PyObject *__pyx_n_s_SUPPORTED_PENALTY; +static PyObject *__pyx_n_s_Sequence; static PyObject *__pyx_n_u_SquaredError; static PyObject *__pyx_n_u_SquaredHinge; static PyObject *__pyx_n_s_Union; @@ -2077,6 +2085,7 @@ static PyObject *__pyx_n_s_current; static PyObject *__pyx_n_s_cv_means; static PyObject *__pyx_n_s_cv_sds; static PyObject *__pyx_n_s_cvfit; +static PyObject *__pyx_kp_u_cvfit_line_549; static PyObject *__pyx_n_s_diff; static PyObject *__pyx_n_s_dtype; static PyObject *__pyx_n_s_enumerate; @@ -2120,6 +2129,7 @@ static PyObject *__pyx_kp_u_expected_y_vector_to_only_have_t; static PyObject *__pyx_n_s_first_value; static PyObject *__pyx_n_s_fit; static PyObject *__pyx_n_s_fit_check; +static PyObject *__pyx_kp_u_fit_line_261; static PyObject *__pyx_n_s_float64; static PyObject *__pyx_n_s_gamma; static PyObject *__pyx_n_s_gamma_max; @@ -2241,7 +2251,7 @@ static PyObject *__pyx_codeobj__17; /* Python wrapper */ static PyObject *__pyx_pw_7l0learn_9interface_1_fit_check(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_7l0learn_9interface__fit_check[] = "_fit_check(X: Union[np.ndarray, csc_matrix], y: np.ndarray, unicode loss: str, unicode penalty: str, unicode algorithm: str, max_support_size: int, num_lambda: Union[int, None], num_gamma: Union[int, None], double gamma_max: float, double gamma_min: float, partial_sort: bool, max_iter: int, double rtol: float, double atol: float, active_set: bool, active_set_num: int, max_swaps: int, double scale_down_factor: float, screen_size: int, lambda_grid: Union[List[List[float]], None], exclude_first_k: int, intercept: bool, lows: Union[np.ndarray, float], highs: Union[np.ndarray, float]) -> Dict[str, Any]"; +static char __pyx_doc_7l0learn_9interface__fit_check[] = "_fit_check(X: Union[np.ndarray, csc_matrix], y: np.ndarray, unicode loss: str, unicode penalty: str, unicode algorithm: str, max_support_size: int, num_lambda: Union[int, None], num_gamma: Union[int, None], double gamma_max: float, double gamma_min: float, partial_sort: bool, max_iter: int, double rtol: float, double atol: float, active_set: bool, active_set_num: int, max_swaps: int, double scale_down_factor: float, screen_size: int, lambda_grid: Union[List[Sequence[float]], None], exclude_first_k: int, intercept: bool, lows: Union[np.ndarray, float], highs: Union[np.ndarray, float]) -> Dict[str, Any]"; static PyMethodDef __pyx_mdef_7l0learn_9interface_1_fit_check = {"_fit_check", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7l0learn_9interface_1_fit_check, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7l0learn_9interface__fit_check}; static PyObject *__pyx_pw_7l0learn_9interface_1_fit_check(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_X = 0; @@ -6351,7 +6361,7 @@ static PyObject *__pyx_pf_7l0learn_9interface__fit_check(CYTHON_UNUSED PyObject /* Python wrapper */ static PyObject *__pyx_pw_7l0learn_9interface_3fit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_7l0learn_9interface_2fit[] = "fit(X: Union[np.ndarray, csc_matrix], y: np.ndarray, unicode loss: str = u'SquaredError', unicode penalty: str = u'L0', unicode algorithm: str = u'CD', max_support_size: int = 100, num_lambda: Optional[int] = 100, num_gamma: Optional[int] = 1, double gamma_max: float = 10., double gamma_min: float = .0001, partial_sort: bool = True, max_iter: int = 200, double rtol: float = 1e-6, double atol: float = 1e-9, active_set: bool = True, active_set_num: int = 3, max_swaps: int = 100, double scale_down_factor: float = 0.8, screen_size: int = 1000, lambda_grid: Optional[List[List[float]]] = None, exclude_first_k: int = 0, intercept: bool = True, lows: Union[np.ndarray, float] = -float(u'inf'), highs: Union[np.ndarray, float] = +float(u'inf')) -> l0learn.models.FitModel\n\n Computes the regularization path for the specified loss function and penalty function.\n\n Parameters\n ----------\n X : np.ndarray or csc_matrix of shape (N, P)\n Data Matrix where rows of X are observations and columns of X are features\n\n y : np.ndarray of shape (P)\n The response vector where y[i] corresponds to X[i, :]\n For classification, a binary vector (-1, 1) is requried .\n\n loss : str\n The loss function. Currently supports the choices:\n \"SquaredError\" (for regression),\n \"Logistic\" (for logistic regression), and\n \"SquaredHinge\" (for smooth SVM).\n\n penalty : str\n The type of regularization.\n This can take either one of the following choices:\n \"L0\",\n \"L0L2\", and\n \"L0L1\"\n\n algorithm : str\n The type of algorithm used to minimize the objective function. Currently \"CD\" and \"CDPSI\" are are supported.\n \"CD\" is a variant of cyclic coordinate descent and runs very fast. \"CDPSI\" performs local combinatorial search\n on top of CD and typically achieves higher quality solutions (at the expense of increased running time).""\n\n max_support_size : int\n Must be greater than 0.\n The maximum support size at which to terminate the regularization path. We recommend setting this to a small\n fraction of min(n,p) (e.g. 0.05 * min(n,p)) as L0 regularization typically selects a small portion of non-zeros.\n\n num_lambda : int, optional\n The number of lambda values to select in the regularization path.\n This value must be None if lambda_grid is supplied.When supplied, must be greater than 0.\n Note: lambda is the regularization parameter corresponding to the L0 norm.\n\n num_gamma: int, optional\n The number of gamma values to select in the regularization path.\n This value must be None if lambda_grid is supplied. When supplied, must be greater than 0.\n Note: gamma is the regularization parameter corresponding to L1 or L2, depending on the chosen penalty).\n\n gamma_max : float\n The maximum value of gamma when using the L0L2 penalty.\n This value must be greater than 0.\n\n Note: For the L0L1 penalty this is automatically selected.\n\n gamma_min : float\n The minimum value of Gamma when using the L0L2 penalty.\n This value must be greater than 0 but less than gamma_max.\n Note: For the L0L1 penalty, the minimum value of gamma in the grid is set to gammaMin * gammaMax.\n\n partial_sort : bool\n If TRUE partial sorting will be used for sorting the coordinates to do greedy cycling (see our paper for\n for details). Otherwise, full sorting is used. #TODO: Add link for paper\n\n max_iter : int\n The maximum number of iterations (full cycles) for CD per grid point. The algorithm may not use the full number\n of iteration per grid point if convergence is found (defined by rtol and atol parameter)\n Must be greater than 0\n\n rtol : float\n The relative tolerance which decides when to terminate optimization as based on the relat""ive change in the\n objective between iterations.\n Must be greater than 0 and less than 1.\n\n atol : float\n The absolute tolerance which decides when to terminate optimization as based on the absolute L2 norm of the\n residuals\n Must be greater than 0\n\n active_set : bool\n If TRUE, performs active set updates. (see our paper for for details). #TODO: Add link for paper\n\n active_set_num : int\n The number of consecutive times a support should appear before declaring support stabilization.\n (see our paper for for details). #TODO: Add link for paper\n\n Must be greater than 0.\n\n max_swaps : int\n The maximum number of swaps used by CDPSI for each grid point.\n Must be greater than 0. Ignored by CD algorithims.\n\n scale_down_factor : float\n Roughly amount each lambda value is scaled by between grid points. Larger values lead to closer lambdas and\n typically to smaller gaps between the support sizes.\n\n For details, see our paper - Section 5 on Adaptive Selection of Tuning Parameters). #TODO: Add link for paper\n\n Must be greater than 0 and less than 1 (strictly for both.)\n\n screen_size : int\n The number of coordinates to cycle over when performing initial correlation screening. #TODO: Add link for paper\n\n Must be greater than 0 and less than number of columns of X.\n\n lambda_grid : list of list of floats\n A grid of lambda values to use in computing the regularization path. This is by default an empty list\n and is ignored. When specified, lambda_grid should be a list of list of floats, where the ith element\n (corresponding to the ith gamma) should be a decreasing sequence of lambda values. The length of this sequence\n is directly the number of lambdas to be tried for that gamma.\n\n In the the \"L0\" penalty case, lambda_grid should be a list of 1.\n In the \"L0LX""\" penalty cases, lambda_grid can be a list of any length. The length of lambda_grid will be the\n number of gamma values tried.\n\n See the example notebook for more details.\n\n Note: When lambda_grid is supplied, num_gamma and num_lambda must be None.\n\n exclude_first_k : int\n The first exclude_first_k features in X will be excluded from variable selection. In other words, the first\n exclude_first_k variables will not be included in the L0-norm penalty however they will be included in the\n L1 or L2 norm penalties, if they are specified.\n\n Must be a positive integer less than the columns of X.\n\n intercept : bool\n If False, no intercept term is included or fit in the regularization path\n Intercept terms are not regularized by L0 or L1/L2.\n\n lows : np array or float\n Lower bounds for coefficients. Either a scalar for all coefficients to have the same bound or a vector of\n size p (number of columns of X) where lows[i] is the lower bound for coefficient i.\n\n Lower bounds can not be above 0 (i.e. we can not specify that all coefficients must be larger than a > 0).\n Lower bounds can be set to 0 iff the corresponding upper bound for that coefficient is also not 0.\n\n highs : np array or float\n Upper bounds for coefficients. Either a scalar for all coefficients to have the same bound or a vector of\n size p (number of columns of X) where highs[i] is the upper bound for coefficient i.\n\n Upper bounds can not be below 0 (i.e. we can not specify that all coefficients must be smaller than a < 0).\n Upper bounds can be set to 0 iff the corresponding lower bound for that coefficient is also not 0.\n\n Returns\n -------\n\n\n Examples\n --------\n "; +static char __pyx_doc_7l0learn_9interface_2fit[] = "fit(X: Union[np.ndarray, csc_matrix], y: np.ndarray, unicode loss: str = u'SquaredError', unicode penalty: str = u'L0', unicode algorithm: str = u'CD', max_support_size: int = 100, num_lambda: Optional[int] = 100, num_gamma: Optional[int] = 1, double gamma_max: float = 10., double gamma_min: float = .0001, partial_sort: bool = True, max_iter: int = 200, double rtol: float = 1e-6, double atol: float = 1e-9, active_set: bool = True, active_set_num: int = 3, max_swaps: int = 100, double scale_down_factor: float = 0.8, screen_size: int = 1000, lambda_grid: Optional[List[Sequence[float]]] = None, exclude_first_k: int = 0, intercept: bool = True, lows: Union[np.ndarray, float] = -float(u'inf'), highs: Union[np.ndarray, float] = +float(u'inf')) -> l0learn.models.FitModel\n\n Computes the regularization path for the specified loss function and penalty function.\n\n Parameters\n ----------\n X : np.ndarray or csc_matrix of shape (N, P)\n Data Matrix where rows of X are observations and columns of X are features\n\n y : np.ndarray of shape (P)\n The response vector where y[i] corresponds to X[i, :]\n For classification, a binary vector (-1, 1) is requried .\n\n loss : str\n The loss function. Currently supports the choices:\n \"SquaredError\" (for regression),\n \"Logistic\" (for logistic regression), and\n \"SquaredHinge\" (for smooth SVM).\n\n penalty : str\n The type of regularization.\n This can take either one of the following choices:\n \"L0\",\n \"L0L2\", and\n \"L0L1\"\n\n algorithm : str\n The type of algorithm used to minimize the objective function. Currently \"CD\" and \"CDPSI\" are are supported.\n \"CD\" is a variant of cyclic coordinate descent and runs very fast. \"CDPSI\" performs local combinatorial search\n on top of CD and typically achieves higher quality solutions (at the expense of increased running tim""e).\n\n max_support_size : int\n Must be greater than 0.\n The maximum support size at which to terminate the regularization path. We recommend setting this to a small\n fraction of min(n,p) (e.g. 0.05 * min(n,p)) as L0 regularization typically selects a small portion of non-zeros.\n\n num_lambda : int, optional\n The number of lambda values to select in the regularization path.\n This value must be None if lambda_grid is supplied.When supplied, must be greater than 0.\n Note: lambda is the regularization parameter corresponding to the L0 norm.\n\n num_gamma: int, optional\n The number of gamma values to select in the regularization path.\n This value must be None if lambda_grid is supplied. When supplied, must be greater than 0.\n Note: gamma is the regularization parameter corresponding to L1 or L2, depending on the chosen penalty).\n\n gamma_max : float\n The maximum value of gamma when using the L0L2 penalty.\n This value must be greater than 0.\n\n Note: For the L0L1 penalty this is automatically selected.\n\n gamma_min : float\n The minimum value of Gamma when using the L0L2 penalty.\n This value must be greater than 0 but less than gamma_max.\n Note: For the L0L1 penalty, the minimum value of gamma in the grid is set to gammaMin * gammaMax.\n\n partial_sort : bool\n If TRUE partial sorting will be used for sorting the coordinates to do greedy cycling (see our paper for\n for details). Otherwise, full sorting is used. #TODO: Add link for paper\n\n max_iter : int\n The maximum number of iterations (full cycles) for CD per grid point. The algorithm may not use the full number\n of iteration per grid point if convergence is found (defined by rtol and atol parameter)\n Must be greater than 0\n\n rtol : float\n The relative tolerance which decides when to terminate optimization as based on the re""lative change in the\n objective between iterations.\n Must be greater than 0 and less than 1.\n\n atol : float\n The absolute tolerance which decides when to terminate optimization as based on the absolute L2 norm of the\n residuals\n Must be greater than 0\n\n active_set : bool\n If TRUE, performs active set updates. (see our paper for for details). #TODO: Add link for paper\n\n active_set_num : int\n The number of consecutive times a support should appear before declaring support stabilization.\n (see our paper for for details). #TODO: Add link for paper\n\n Must be greater than 0.\n\n max_swaps : int\n The maximum number of swaps used by CDPSI for each grid point.\n Must be greater than 0. Ignored by CD algorithims.\n\n scale_down_factor : float\n Roughly amount each lambda value is scaled by between grid points. Larger values lead to closer lambdas and\n typically to smaller gaps between the support sizes.\n\n For details, see our paper - Section 5 on Adaptive Selection of Tuning Parameters). #TODO: Add link for paper\n\n Must be greater than 0 and less than 1 (strictly for both.)\n\n screen_size : int\n The number of coordinates to cycle over when performing initial correlation screening. #TODO: Add link for paper\n\n Must be greater than 0 and less than number of columns of X.\n\n lambda_grid : list of list of floats\n A grid of lambda values to use in computing the regularization path. This is by default an empty list\n and is ignored. When specified, lambda_grid should be a list of list of floats, where the ith element\n (corresponding to the ith gamma) should be a decreasing sequence of lambda values. The length of this sequence\n is directly the number of lambdas to be tried for that gamma.\n\n In the the \"L0\" penalty case, lambda_grid should be a list of 1.\n In the \"L0L""X\" penalty cases, lambda_grid can be a list of any length. The length of lambda_grid will be the\n number of gamma values tried.\n\n See the example notebook for more details.\n\n Note: When lambda_grid is supplied, num_gamma and num_lambda must be None.\n\n exclude_first_k : int\n The first exclude_first_k features in X will be excluded from variable selection. In other words, the first\n exclude_first_k variables will not be included in the L0-norm penalty however they will be included in the\n L1 or L2 norm penalties, if they are specified.\n\n Must be a positive integer less than the columns of X.\n\n intercept : bool\n If False, no intercept term is included or fit in the regularization path\n Intercept terms are not regularized by L0 or L1/L2.\n\n lows : np array or float\n Lower bounds for coefficients. Either a scalar for all coefficients to have the same bound or a vector of\n size p (number of columns of X) where lows[i] is the lower bound for coefficient i.\n\n Lower bounds can not be above 0 (i.e. we can not specify that all coefficients must be larger than a > 0).\n Lower bounds can be set to 0 iff the corresponding upper bound for that coefficient is also not 0.\n\n highs : np array or float\n Upper bounds for coefficients. Either a scalar for all coefficients to have the same bound or a vector of\n size p (number of columns of X) where highs[i] is the upper bound for coefficient i.\n\n Upper bounds can not be below 0 (i.e. we can not specify that all coefficients must be smaller than a < 0).\n Upper bounds can be set to 0 iff the corresponding lower bound for that coefficient is also not 0.\n\n Returns\n -------\n fit_model : l0learn.models.FitModel\n FitModel instance containing all relevant information from the solution path.\n\n See Also\n -------\n l0learn.cvfit\n l0learn.models.FitModel""\n\n Examples\n --------\n >>>fit_model = l0learn.fit(X, y, penalty=\"L0\", max_support_size=20)\n "; static PyMethodDef __pyx_mdef_7l0learn_9interface_3fit = {"fit", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7l0learn_9interface_3fit, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7l0learn_9interface_2fit}; static PyObject *__pyx_pw_7l0learn_9interface_3fit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_X = 0; @@ -6419,7 +6429,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_3fit(PyObject *__pyx_self, PyObjec /* "l0learn/interface.pyx":280 * scale_down_factor: float = 0.8, * screen_size: int = 1000, - * lambda_grid: Optional[List[List[float]]] = None, # <<<<<<<<<<<<<< + * lambda_grid: Optional[List[Sequence[float]]] = None, # <<<<<<<<<<<<<< * exclude_first_k: int = 0, * intercept: bool = True, */ @@ -6427,7 +6437,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_3fit(PyObject *__pyx_self, PyObjec values[20] = ((PyObject *)__pyx_int_0); /* "l0learn/interface.pyx":282 - * lambda_grid: Optional[List[List[float]]] = None, + * lambda_grid: Optional[List[Sequence[float]]] = None, * exclude_first_k: int = 0, * intercept: bool = True, # <<<<<<<<<<<<<< * lows: Union[np.ndarray, float] = -float('inf'), @@ -6811,425 +6821,425 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx __Pyx_INCREF(__pyx_v_lows); __Pyx_INCREF(__pyx_v_highs); - /* "l0learn/interface.pyx":432 - * -------- + /* "l0learn/interface.pyx":439 + * >>>fit_model = l0learn.fit(X, y, penalty="L0", max_support_size=20) * """ * check = _fit_check(X=X, # <<<<<<<<<<<<<< * y=y, * loss=loss, */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_fit_check); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 432, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_fit_check); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 439, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyDict_NewPresized(24); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 432, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyDict_NewPresized(24); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 439, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_X, __pyx_v_X) < 0) __PYX_ERR(0, 432, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_X, __pyx_v_X) < 0) __PYX_ERR(0, 439, __pyx_L1_error) - /* "l0learn/interface.pyx":433 + /* "l0learn/interface.pyx":440 * """ * check = _fit_check(X=X, * y=y, # <<<<<<<<<<<<<< * loss=loss, * penalty=penalty, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_y, __pyx_v_y) < 0) __PYX_ERR(0, 432, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_y, __pyx_v_y) < 0) __PYX_ERR(0, 439, __pyx_L1_error) - /* "l0learn/interface.pyx":434 + /* "l0learn/interface.pyx":441 * check = _fit_check(X=X, * y=y, * loss=loss, # <<<<<<<<<<<<<< * penalty=penalty, * algorithm=algorithm, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 432, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 439, __pyx_L1_error) - /* "l0learn/interface.pyx":435 + /* "l0learn/interface.pyx":442 * y=y, * loss=loss, * penalty=penalty, # <<<<<<<<<<<<<< * algorithm=algorithm, * max_support_size=max_support_size, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 432, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 439, __pyx_L1_error) - /* "l0learn/interface.pyx":436 + /* "l0learn/interface.pyx":443 * loss=loss, * penalty=penalty, * algorithm=algorithm, # <<<<<<<<<<<<<< * max_support_size=max_support_size, * num_lambda=num_lambda, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_algorithm, __pyx_v_algorithm) < 0) __PYX_ERR(0, 432, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_algorithm, __pyx_v_algorithm) < 0) __PYX_ERR(0, 439, __pyx_L1_error) - /* "l0learn/interface.pyx":437 + /* "l0learn/interface.pyx":444 * penalty=penalty, * algorithm=algorithm, * max_support_size=max_support_size, # <<<<<<<<<<<<<< * num_lambda=num_lambda, * num_gamma=num_gamma, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_support_size, __pyx_v_max_support_size) < 0) __PYX_ERR(0, 432, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_support_size, __pyx_v_max_support_size) < 0) __PYX_ERR(0, 439, __pyx_L1_error) - /* "l0learn/interface.pyx":438 + /* "l0learn/interface.pyx":445 * algorithm=algorithm, * max_support_size=max_support_size, * num_lambda=num_lambda, # <<<<<<<<<<<<<< * num_gamma=num_gamma, * gamma_max=gamma_max, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_lambda, __pyx_v_num_lambda) < 0) __PYX_ERR(0, 432, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_lambda, __pyx_v_num_lambda) < 0) __PYX_ERR(0, 439, __pyx_L1_error) - /* "l0learn/interface.pyx":439 + /* "l0learn/interface.pyx":446 * max_support_size=max_support_size, * num_lambda=num_lambda, * num_gamma=num_gamma, # <<<<<<<<<<<<<< * gamma_max=gamma_max, * gamma_min=gamma_min, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_gamma, __pyx_v_num_gamma) < 0) __PYX_ERR(0, 432, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_gamma, __pyx_v_num_gamma) < 0) __PYX_ERR(0, 439, __pyx_L1_error) - /* "l0learn/interface.pyx":440 + /* "l0learn/interface.pyx":447 * num_lambda=num_lambda, * num_gamma=num_gamma, * gamma_max=gamma_max, # <<<<<<<<<<<<<< * gamma_min=gamma_min, * partial_sort=partial_sort, */ - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 440, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 447, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma_max, __pyx_t_3) < 0) __PYX_ERR(0, 432, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma_max, __pyx_t_3) < 0) __PYX_ERR(0, 439, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":441 + /* "l0learn/interface.pyx":448 * num_gamma=num_gamma, * gamma_max=gamma_max, * gamma_min=gamma_min, # <<<<<<<<<<<<<< * partial_sort=partial_sort, * max_iter=max_iter, */ - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 441, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 448, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma_min, __pyx_t_3) < 0) __PYX_ERR(0, 432, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma_min, __pyx_t_3) < 0) __PYX_ERR(0, 439, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":442 + /* "l0learn/interface.pyx":449 * gamma_max=gamma_max, * gamma_min=gamma_min, * partial_sort=partial_sort, # <<<<<<<<<<<<<< * max_iter=max_iter, * rtol=rtol, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_partial_sort, __pyx_v_partial_sort) < 0) __PYX_ERR(0, 432, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_partial_sort, __pyx_v_partial_sort) < 0) __PYX_ERR(0, 439, __pyx_L1_error) - /* "l0learn/interface.pyx":443 + /* "l0learn/interface.pyx":450 * gamma_min=gamma_min, * partial_sort=partial_sort, * max_iter=max_iter, # <<<<<<<<<<<<<< * rtol=rtol, * atol=atol, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_iter, __pyx_v_max_iter) < 0) __PYX_ERR(0, 432, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_iter, __pyx_v_max_iter) < 0) __PYX_ERR(0, 439, __pyx_L1_error) - /* "l0learn/interface.pyx":444 + /* "l0learn/interface.pyx":451 * partial_sort=partial_sort, * max_iter=max_iter, * rtol=rtol, # <<<<<<<<<<<<<< * atol=atol, * active_set=active_set, */ - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_rtol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 444, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_rtol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 451, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_rtol, __pyx_t_3) < 0) __PYX_ERR(0, 432, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_rtol, __pyx_t_3) < 0) __PYX_ERR(0, 439, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":445 + /* "l0learn/interface.pyx":452 * max_iter=max_iter, * rtol=rtol, * atol=atol, # <<<<<<<<<<<<<< * active_set=active_set, * active_set_num=active_set_num, */ - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_atol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 445, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_atol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 452, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_atol, __pyx_t_3) < 0) __PYX_ERR(0, 432, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_atol, __pyx_t_3) < 0) __PYX_ERR(0, 439, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":446 + /* "l0learn/interface.pyx":453 * rtol=rtol, * atol=atol, * active_set=active_set, # <<<<<<<<<<<<<< * active_set_num=active_set_num, * max_swaps=max_swaps, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_active_set, __pyx_v_active_set) < 0) __PYX_ERR(0, 432, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_active_set, __pyx_v_active_set) < 0) __PYX_ERR(0, 439, __pyx_L1_error) - /* "l0learn/interface.pyx":447 + /* "l0learn/interface.pyx":454 * atol=atol, * active_set=active_set, * active_set_num=active_set_num, # <<<<<<<<<<<<<< * max_swaps=max_swaps, * scale_down_factor=scale_down_factor, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_active_set_num, __pyx_v_active_set_num) < 0) __PYX_ERR(0, 432, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_active_set_num, __pyx_v_active_set_num) < 0) __PYX_ERR(0, 439, __pyx_L1_error) - /* "l0learn/interface.pyx":448 + /* "l0learn/interface.pyx":455 * active_set=active_set, * active_set_num=active_set_num, * max_swaps=max_swaps, # <<<<<<<<<<<<<< * scale_down_factor=scale_down_factor, * screen_size=screen_size, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_swaps, __pyx_v_max_swaps) < 0) __PYX_ERR(0, 432, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_swaps, __pyx_v_max_swaps) < 0) __PYX_ERR(0, 439, __pyx_L1_error) - /* "l0learn/interface.pyx":449 + /* "l0learn/interface.pyx":456 * active_set_num=active_set_num, * max_swaps=max_swaps, * scale_down_factor=scale_down_factor, # <<<<<<<<<<<<<< * screen_size=screen_size, * lambda_grid=lambda_grid, */ - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_scale_down_factor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 449, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_scale_down_factor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 456, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_scale_down_factor, __pyx_t_3) < 0) __PYX_ERR(0, 432, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_scale_down_factor, __pyx_t_3) < 0) __PYX_ERR(0, 439, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":450 + /* "l0learn/interface.pyx":457 * max_swaps=max_swaps, * scale_down_factor=scale_down_factor, * screen_size=screen_size, # <<<<<<<<<<<<<< * lambda_grid=lambda_grid, * exclude_first_k=exclude_first_k, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_screen_size, __pyx_v_screen_size) < 0) __PYX_ERR(0, 432, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_screen_size, __pyx_v_screen_size) < 0) __PYX_ERR(0, 439, __pyx_L1_error) - /* "l0learn/interface.pyx":451 + /* "l0learn/interface.pyx":458 * scale_down_factor=scale_down_factor, * screen_size=screen_size, * lambda_grid=lambda_grid, # <<<<<<<<<<<<<< * exclude_first_k=exclude_first_k, * intercept=intercept, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lambda_grid, __pyx_v_lambda_grid) < 0) __PYX_ERR(0, 432, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lambda_grid, __pyx_v_lambda_grid) < 0) __PYX_ERR(0, 439, __pyx_L1_error) - /* "l0learn/interface.pyx":452 + /* "l0learn/interface.pyx":459 * screen_size=screen_size, * lambda_grid=lambda_grid, * exclude_first_k=exclude_first_k, # <<<<<<<<<<<<<< * intercept=intercept, * lows=lows, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_exclude_first_k, __pyx_v_exclude_first_k) < 0) __PYX_ERR(0, 432, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_exclude_first_k, __pyx_v_exclude_first_k) < 0) __PYX_ERR(0, 439, __pyx_L1_error) - /* "l0learn/interface.pyx":453 + /* "l0learn/interface.pyx":460 * lambda_grid=lambda_grid, * exclude_first_k=exclude_first_k, * intercept=intercept, # <<<<<<<<<<<<<< * lows=lows, * highs=highs) */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 432, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 439, __pyx_L1_error) - /* "l0learn/interface.pyx":454 + /* "l0learn/interface.pyx":461 * exclude_first_k=exclude_first_k, * intercept=intercept, * lows=lows, # <<<<<<<<<<<<<< * highs=highs) * */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lows, __pyx_v_lows) < 0) __PYX_ERR(0, 432, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lows, __pyx_v_lows) < 0) __PYX_ERR(0, 439, __pyx_L1_error) - /* "l0learn/interface.pyx":455 + /* "l0learn/interface.pyx":462 * intercept=intercept, * lows=lows, * highs=highs) # <<<<<<<<<<<<<< * * max_support_size = check["max_support_size"] */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_highs, __pyx_v_highs) < 0) __PYX_ERR(0, 432, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_highs, __pyx_v_highs) < 0) __PYX_ERR(0, 439, __pyx_L1_error) - /* "l0learn/interface.pyx":432 - * -------- + /* "l0learn/interface.pyx":439 + * >>>fit_model = l0learn.fit(X, y, penalty="L0", max_support_size=20) * """ * check = _fit_check(X=X, # <<<<<<<<<<<<<< * y=y, * loss=loss, */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 432, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 439, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_check = __pyx_t_3; __pyx_t_3 = 0; - /* "l0learn/interface.pyx":457 + /* "l0learn/interface.pyx":464 * highs=highs) * * max_support_size = check["max_support_size"] # <<<<<<<<<<<<<< * screen_size = check["screen_size"] * y = check['y'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_max_support_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 457, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_max_support_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 464, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_max_support_size, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":458 + /* "l0learn/interface.pyx":465 * * max_support_size = check["max_support_size"] * screen_size = check["screen_size"] # <<<<<<<<<<<<<< * y = check['y'] * penalty = check['penalty'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_screen_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 458, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_screen_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 465, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_screen_size, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":459 + /* "l0learn/interface.pyx":466 * max_support_size = check["max_support_size"] * screen_size = check["screen_size"] * y = check['y'] # <<<<<<<<<<<<<< * penalty = check['penalty'] * gamma_max = check['gamma_max'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_y); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 459, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_y); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 466, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_y, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":460 + /* "l0learn/interface.pyx":467 * screen_size = check["screen_size"] * y = check['y'] * penalty = check['penalty'] # <<<<<<<<<<<<<< * gamma_max = check['gamma_max'] * gamma_min = check['gamma_min'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_penalty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 460, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_penalty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 467, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (!(likely(PyUnicode_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(0, 460, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(0, 467, __pyx_L1_error) __Pyx_DECREF_SET(__pyx_v_penalty, ((PyObject*)__pyx_t_3)); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":461 + /* "l0learn/interface.pyx":468 * y = check['y'] * penalty = check['penalty'] * gamma_max = check['gamma_max'] # <<<<<<<<<<<<<< * gamma_min = check['gamma_min'] * lambda_grid = check['lambda_grid'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 461, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 468, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 461, __pyx_L1_error) + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 468, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_gamma_max = __pyx_t_4; - /* "l0learn/interface.pyx":462 + /* "l0learn/interface.pyx":469 * penalty = check['penalty'] * gamma_max = check['gamma_max'] * gamma_min = check['gamma_min'] # <<<<<<<<<<<<<< * lambda_grid = check['lambda_grid'] * num_gamma = check['num_gamma'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_gamma_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 462, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_gamma_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 469, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 462, __pyx_L1_error) + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 469, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_gamma_min = __pyx_t_4; - /* "l0learn/interface.pyx":463 + /* "l0learn/interface.pyx":470 * gamma_max = check['gamma_max'] * gamma_min = check['gamma_min'] * lambda_grid = check['lambda_grid'] # <<<<<<<<<<<<<< * num_gamma = check['num_gamma'] * num_lambda = check['num_lambda'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_lambda_grid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 463, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_lambda_grid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 470, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_lambda_grid, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":464 + /* "l0learn/interface.pyx":471 * gamma_min = check['gamma_min'] * lambda_grid = check['lambda_grid'] * num_gamma = check['num_gamma'] # <<<<<<<<<<<<<< * num_lambda = check['num_lambda'] * auto_lambda = check['auto_lambda'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_num_gamma); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 464, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_num_gamma); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 471, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_num_gamma, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":465 + /* "l0learn/interface.pyx":472 * lambda_grid = check['lambda_grid'] * num_gamma = check['num_gamma'] * num_lambda = check['num_lambda'] # <<<<<<<<<<<<<< * auto_lambda = check['auto_lambda'] * with_bounds = check['with_bounds'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_num_lambda); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 465, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_num_lambda); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 472, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_num_lambda, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":466 + /* "l0learn/interface.pyx":473 * num_gamma = check['num_gamma'] * num_lambda = check['num_lambda'] * auto_lambda = check['auto_lambda'] # <<<<<<<<<<<<<< * with_bounds = check['with_bounds'] * lows = check['lows'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_auto_lambda); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 466, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_auto_lambda); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 473, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_auto_lambda = __pyx_t_3; __pyx_t_3 = 0; - /* "l0learn/interface.pyx":467 + /* "l0learn/interface.pyx":474 * num_lambda = check['num_lambda'] * auto_lambda = check['auto_lambda'] * with_bounds = check['with_bounds'] # <<<<<<<<<<<<<< * lows = check['lows'] * highs = check['highs'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_with_bounds); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 467, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_with_bounds); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_with_bounds = __pyx_t_3; __pyx_t_3 = 0; - /* "l0learn/interface.pyx":468 + /* "l0learn/interface.pyx":475 * auto_lambda = check['auto_lambda'] * with_bounds = check['with_bounds'] * lows = check['lows'] # <<<<<<<<<<<<<< * highs = check['highs'] * */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_lows); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 468, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_lows); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 475, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":469 + /* "l0learn/interface.pyx":476 * with_bounds = check['with_bounds'] * lows = check['lows'] * highs = check['highs'] # <<<<<<<<<<<<<< * * cdef vector[vector[double]] c_lambda_grid = lambda_grid */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_highs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 469, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_highs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 476, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":471 + /* "l0learn/interface.pyx":478 * highs = check['highs'] * * cdef vector[vector[double]] c_lambda_grid = lambda_grid # <<<<<<<<<<<<<< * cdef string c_loss = loss.encode('UTF-8') * cdef string c_penalty = penalty.encode('UTF-8') */ - __pyx_t_5 = __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_lambda_grid); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 471, __pyx_L1_error) + __pyx_t_5 = __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_lambda_grid); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 478, __pyx_L1_error) __pyx_v_c_lambda_grid = __pyx_t_5; - /* "l0learn/interface.pyx":472 + /* "l0learn/interface.pyx":479 * * cdef vector[vector[double]] c_lambda_grid = lambda_grid * cdef string c_loss = loss.encode('UTF-8') # <<<<<<<<<<<<<< @@ -7238,15 +7248,15 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ if (unlikely(__pyx_v_loss == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 472, __pyx_L1_error) + __PYX_ERR(0, 479, __pyx_L1_error) } - __pyx_t_3 = PyUnicode_AsUTF8String(__pyx_v_loss); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 472, __pyx_L1_error) + __pyx_t_3 = PyUnicode_AsUTF8String(__pyx_v_loss); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 479, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_6 = __pyx_convert_string_from_py_std__in_string(__pyx_t_3); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 472, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_string_from_py_std__in_string(__pyx_t_3); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 479, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_c_loss = __pyx_t_6; - /* "l0learn/interface.pyx":473 + /* "l0learn/interface.pyx":480 * cdef vector[vector[double]] c_lambda_grid = lambda_grid * cdef string c_loss = loss.encode('UTF-8') * cdef string c_penalty = penalty.encode('UTF-8') # <<<<<<<<<<<<<< @@ -7255,15 +7265,15 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ if (unlikely(__pyx_v_penalty == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 473, __pyx_L1_error) + __PYX_ERR(0, 480, __pyx_L1_error) } - __pyx_t_3 = PyUnicode_AsUTF8String(__pyx_v_penalty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 473, __pyx_L1_error) + __pyx_t_3 = PyUnicode_AsUTF8String(__pyx_v_penalty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 480, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_6 = __pyx_convert_string_from_py_std__in_string(__pyx_t_3); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 473, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_string_from_py_std__in_string(__pyx_t_3); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 480, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_c_penalty = __pyx_t_6; - /* "l0learn/interface.pyx":474 + /* "l0learn/interface.pyx":481 * cdef string c_loss = loss.encode('UTF-8') * cdef string c_penalty = penalty.encode('UTF-8') * cdef string c_algorithim = algorithm.encode('UTF-8') # <<<<<<<<<<<<<< @@ -7272,185 +7282,185 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ if (unlikely(__pyx_v_algorithm == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 474, __pyx_L1_error) + __PYX_ERR(0, 481, __pyx_L1_error) } - __pyx_t_3 = PyUnicode_AsUTF8String(__pyx_v_algorithm); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 474, __pyx_L1_error) + __pyx_t_3 = PyUnicode_AsUTF8String(__pyx_v_algorithm); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 481, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_6 = __pyx_convert_string_from_py_std__in_string(__pyx_t_3); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 474, __pyx_L1_error) + __pyx_t_6 = __pyx_convert_string_from_py_std__in_string(__pyx_t_3); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 481, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_c_algorithim = __pyx_t_6; - /* "l0learn/interface.pyx":477 + /* "l0learn/interface.pyx":484 * * cdef fitmodel c_results * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), * y=numpy_to_dvec_d(y), */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 477, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 484, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 477, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 484, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_7 = PyObject_IsInstance(__pyx_v_X, __pyx_t_2); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 477, __pyx_L1_error) + __pyx_t_7 = PyObject_IsInstance(__pyx_v_X, __pyx_t_2); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 484, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_8 = (__pyx_t_7 != 0); if (__pyx_t_8) { - /* "l0learn/interface.pyx":478 + /* "l0learn/interface.pyx":485 * cdef fitmodel c_results * if isinstance(X, np.ndarray): * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< * y=numpy_to_dvec_d(y), * Loss=c_loss, */ - if (!(likely(((__pyx_v_X) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_X, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 478, __pyx_L1_error) + if (!(likely(((__pyx_v_X) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_X, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 485, __pyx_L1_error) - /* "l0learn/interface.pyx":479 + /* "l0learn/interface.pyx":486 * if isinstance(X, np.ndarray): * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), * y=numpy_to_dvec_d(y), # <<<<<<<<<<<<<< * Loss=c_loss, * Penalty=c_penalty, */ - if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 479, __pyx_L1_error) + if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 486, __pyx_L1_error) - /* "l0learn/interface.pyx":483 + /* "l0learn/interface.pyx":490 * Penalty=c_penalty, * Algorithm=c_algorithim, * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< * G_ncols=num_lambda, * G_nrows=num_gamma, */ - __pyx_t_9 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_9 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 483, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_9 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 490, __pyx_L1_error) - /* "l0learn/interface.pyx":484 + /* "l0learn/interface.pyx":491 * Algorithm=c_algorithim, * NnzStopNum=max_support_size, * G_ncols=num_lambda, # <<<<<<<<<<<<<< * G_nrows=num_gamma, * Lambda2Max=gamma_max, */ - __pyx_t_10 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_10 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 484, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_10 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 491, __pyx_L1_error) - /* "l0learn/interface.pyx":485 + /* "l0learn/interface.pyx":492 * NnzStopNum=max_support_size, * G_ncols=num_lambda, * G_nrows=num_gamma, # <<<<<<<<<<<<<< * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, */ - __pyx_t_11 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_11 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 485, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_11 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 492, __pyx_L1_error) - /* "l0learn/interface.pyx":488 + /* "l0learn/interface.pyx":495 * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, * PartialSort=partial_sort, # <<<<<<<<<<<<<< * MaxIters=max_iter, * rtol=rtol, */ - __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_12 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 488, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_12 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 495, __pyx_L1_error) - /* "l0learn/interface.pyx":489 + /* "l0learn/interface.pyx":496 * Lambda2Min=gamma_min, * PartialSort=partial_sort, * MaxIters=max_iter, # <<<<<<<<<<<<<< * rtol=rtol, * atol=atol, */ - __pyx_t_13 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_13 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 489, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_13 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 496, __pyx_L1_error) - /* "l0learn/interface.pyx":492 + /* "l0learn/interface.pyx":499 * rtol=rtol, * atol=atol, * ActiveSet=active_set, # <<<<<<<<<<<<<< * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, */ - __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_14 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 492, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_14 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 499, __pyx_L1_error) - /* "l0learn/interface.pyx":493 + /* "l0learn/interface.pyx":500 * atol=atol, * ActiveSet=active_set, * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, */ - __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 493, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 500, __pyx_L1_error) - /* "l0learn/interface.pyx":494 + /* "l0learn/interface.pyx":501 * ActiveSet=active_set, * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, */ - __pyx_t_16 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_16 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 494, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_16 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 501, __pyx_L1_error) - /* "l0learn/interface.pyx":496 + /* "l0learn/interface.pyx":503 * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, # <<<<<<<<<<<<<< * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, */ - __pyx_t_17 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_17 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 496, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_17 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 503, __pyx_L1_error) - /* "l0learn/interface.pyx":497 + /* "l0learn/interface.pyx":504 * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, * LambdaU=not auto_lambda, # <<<<<<<<<<<<<< * Lambdas=c_lambda_grid, * ExcludeFirstK=exclude_first_k, */ - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 497, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 504, __pyx_L1_error) - /* "l0learn/interface.pyx":499 + /* "l0learn/interface.pyx":506 * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< * Intercept=intercept, * withBounds=with_bounds, */ - __pyx_t_18 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_18 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 499, __pyx_L1_error) + __pyx_t_18 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_18 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 506, __pyx_L1_error) - /* "l0learn/interface.pyx":500 + /* "l0learn/interface.pyx":507 * Lambdas=c_lambda_grid, * ExcludeFirstK=exclude_first_k, * Intercept=intercept, # <<<<<<<<<<<<<< * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), */ - __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_19 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 500, __pyx_L1_error) + __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_19 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 507, __pyx_L1_error) - /* "l0learn/interface.pyx":501 + /* "l0learn/interface.pyx":508 * ExcludeFirstK=exclude_first_k, * Intercept=intercept, * withBounds=with_bounds, # <<<<<<<<<<<<<< * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) */ - __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_20 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 501, __pyx_L1_error) + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_20 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 508, __pyx_L1_error) - /* "l0learn/interface.pyx":502 + /* "l0learn/interface.pyx":509 * Intercept=intercept, * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< * Highs=numpy_to_dvec_d(highs)) * else: # isinstance(X, csc_matrix) */ - if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 502, __pyx_L1_error) + if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 509, __pyx_L1_error) - /* "l0learn/interface.pyx":503 + /* "l0learn/interface.pyx":510 * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< * else: # isinstance(X, csc_matrix) * c_results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), */ - if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 503, __pyx_L1_error) + if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 510, __pyx_L1_error) - /* "l0learn/interface.pyx":478 + /* "l0learn/interface.pyx":485 * cdef fitmodel c_results * if isinstance(X, np.ndarray): * c_results = _L0LearnFit_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< @@ -7459,7 +7469,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnFit_dense(__pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_X)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_9, __pyx_t_10, __pyx_t_11, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_12, __pyx_t_13, __pyx_v_rtol, __pyx_v_atol, __pyx_t_14, __pyx_t_15, __pyx_t_16, __pyx_v_scale_down_factor, __pyx_t_17, (!__pyx_t_8), __pyx_v_c_lambda_grid, __pyx_t_18, __pyx_t_19, __pyx_t_20, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); - /* "l0learn/interface.pyx":477 + /* "l0learn/interface.pyx":484 * * cdef fitmodel c_results * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< @@ -7469,7 +7479,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx goto __pyx_L3; } - /* "l0learn/interface.pyx":505 + /* "l0learn/interface.pyx":512 * Highs=numpy_to_dvec_d(highs)) * else: # isinstance(X, csc_matrix) * c_results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< @@ -7478,151 +7488,151 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx */ /*else*/ { - /* "l0learn/interface.pyx":506 + /* "l0learn/interface.pyx":513 * else: # isinstance(X, csc_matrix) * c_results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), * y=numpy_to_dvec_d(y), # <<<<<<<<<<<<<< * Loss=c_loss, * Penalty=c_penalty, */ - if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 506, __pyx_L1_error) + if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 513, __pyx_L1_error) - /* "l0learn/interface.pyx":510 + /* "l0learn/interface.pyx":517 * Penalty=c_penalty, * Algorithm=c_algorithim, * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< * G_ncols=num_lambda, * G_nrows=num_gamma, */ - __pyx_t_18 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_18 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 510, __pyx_L1_error) + __pyx_t_18 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_18 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 517, __pyx_L1_error) - /* "l0learn/interface.pyx":511 + /* "l0learn/interface.pyx":518 * Algorithm=c_algorithim, * NnzStopNum=max_support_size, * G_ncols=num_lambda, # <<<<<<<<<<<<<< * G_nrows=num_gamma, * Lambda2Max=gamma_max, */ - __pyx_t_17 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_17 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 511, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_17 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 518, __pyx_L1_error) - /* "l0learn/interface.pyx":512 + /* "l0learn/interface.pyx":519 * NnzStopNum=max_support_size, * G_ncols=num_lambda, * G_nrows=num_gamma, # <<<<<<<<<<<<<< * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, */ - __pyx_t_16 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_16 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 512, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_16 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 519, __pyx_L1_error) - /* "l0learn/interface.pyx":515 + /* "l0learn/interface.pyx":522 * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, * PartialSort=partial_sort, # <<<<<<<<<<<<<< * MaxIters=max_iter, * rtol=rtol, */ - __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_20 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 515, __pyx_L1_error) + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_20 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 522, __pyx_L1_error) - /* "l0learn/interface.pyx":516 + /* "l0learn/interface.pyx":523 * Lambda2Min=gamma_min, * PartialSort=partial_sort, * MaxIters=max_iter, # <<<<<<<<<<<<<< * rtol=rtol, * atol=atol, */ - __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 516, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 523, __pyx_L1_error) - /* "l0learn/interface.pyx":519 + /* "l0learn/interface.pyx":526 * rtol=rtol, * atol=atol, * ActiveSet=active_set, # <<<<<<<<<<<<<< * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, */ - __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_19 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 519, __pyx_L1_error) + __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_19 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 526, __pyx_L1_error) - /* "l0learn/interface.pyx":520 + /* "l0learn/interface.pyx":527 * atol=atol, * ActiveSet=active_set, * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, */ - __pyx_t_13 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_13 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 520, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_13 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 527, __pyx_L1_error) - /* "l0learn/interface.pyx":521 + /* "l0learn/interface.pyx":528 * ActiveSet=active_set, * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, */ - __pyx_t_11 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_11 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 521, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_11 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 528, __pyx_L1_error) - /* "l0learn/interface.pyx":523 + /* "l0learn/interface.pyx":530 * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, # <<<<<<<<<<<<<< * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, */ - __pyx_t_10 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_10 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 523, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_10 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 530, __pyx_L1_error) - /* "l0learn/interface.pyx":524 + /* "l0learn/interface.pyx":531 * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, * LambdaU=not auto_lambda, # <<<<<<<<<<<<<< * Lambdas=c_lambda_grid, * ExcludeFirstK=exclude_first_k, */ - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 524, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 531, __pyx_L1_error) - /* "l0learn/interface.pyx":526 + /* "l0learn/interface.pyx":533 * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< * Intercept=intercept, * withBounds=with_bounds, */ - __pyx_t_9 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_9 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 526, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_9 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 533, __pyx_L1_error) - /* "l0learn/interface.pyx":527 + /* "l0learn/interface.pyx":534 * Lambdas=c_lambda_grid, * ExcludeFirstK=exclude_first_k, * Intercept=intercept, # <<<<<<<<<<<<<< * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), */ - __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_14 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 527, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_14 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 534, __pyx_L1_error) - /* "l0learn/interface.pyx":528 + /* "l0learn/interface.pyx":535 * ExcludeFirstK=exclude_first_k, * Intercept=intercept, * withBounds=with_bounds, # <<<<<<<<<<<<<< * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) */ - __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_12 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 528, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_12 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 535, __pyx_L1_error) - /* "l0learn/interface.pyx":529 + /* "l0learn/interface.pyx":536 * Intercept=intercept, * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< * Highs=numpy_to_dvec_d(highs)) * */ - if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 529, __pyx_L1_error) + if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 536, __pyx_L1_error) - /* "l0learn/interface.pyx":530 + /* "l0learn/interface.pyx":537 * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< * * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, */ - if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 530, __pyx_L1_error) + if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 537, __pyx_L1_error) - /* "l0learn/interface.pyx":505 + /* "l0learn/interface.pyx":512 * Highs=numpy_to_dvec_d(highs)) * else: # isinstance(X, csc_matrix) * c_results = _L0LearnFit_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< @@ -7633,112 +7643,112 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx } __pyx_L3:; - /* "l0learn/interface.pyx":532 + /* "l0learn/interface.pyx":539 * Highs=numpy_to_dvec_d(highs)) * * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, # <<<<<<<<<<<<<< * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_FitModel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 532, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_FitModel); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 539, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 532, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 539, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 532, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 539, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_t_1, __pyx_n_u_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 532, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_1, __pyx_n_u_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 532, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_1, __pyx_n_u_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 532, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_settings, __pyx_t_1) < 0) __PYX_ERR(0, 532, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_n_u_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 539, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_n_u_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 539, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_n_u_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 539, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_settings, __pyx_t_1) < 0) __PYX_ERR(0, 539, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":533 + /* "l0learn/interface.pyx":540 * * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, * lambda_0=c_results.Lambda0, # <<<<<<<<<<<<<< * gamma=c_results.Lambda12, * support_size=c_results.NnzCount, */ - __pyx_t_1 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Lambda0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 533, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Lambda0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 540, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_lambda_0, __pyx_t_1) < 0) __PYX_ERR(0, 532, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_lambda_0, __pyx_t_1) < 0) __PYX_ERR(0, 539, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":534 + /* "l0learn/interface.pyx":541 * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, # <<<<<<<<<<<<<< * support_size=c_results.NnzCount, * coeffs=sp_dmat_field_to_list(c_results.Beta), */ - __pyx_t_1 = __pyx_convert_vector_to_py_double(__pyx_v_c_results.Lambda12); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 534, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_vector_to_py_double(__pyx_v_c_results.Lambda12); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 541, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_gamma, __pyx_t_1) < 0) __PYX_ERR(0, 532, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_gamma, __pyx_t_1) < 0) __PYX_ERR(0, 539, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":535 + /* "l0learn/interface.pyx":542 * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, * support_size=c_results.NnzCount, # <<<<<<<<<<<<<< * coeffs=sp_dmat_field_to_list(c_results.Beta), * intercepts=c_results.Intercept, */ - __pyx_t_1 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(__pyx_v_c_results.NnzCount); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 535, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(__pyx_v_c_results.NnzCount); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 542, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_support_size, __pyx_t_1) < 0) __PYX_ERR(0, 532, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_support_size, __pyx_t_1) < 0) __PYX_ERR(0, 539, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":536 + /* "l0learn/interface.pyx":543 * gamma=c_results.Lambda12, * support_size=c_results.NnzCount, * coeffs=sp_dmat_field_to_list(c_results.Beta), # <<<<<<<<<<<<<< * intercepts=c_results.Intercept, * converged=c_results.Converged) */ - __pyx_t_1 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_c_results.Beta); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 536, __pyx_L1_error) + __pyx_t_1 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_c_results.Beta); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 543, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_coeffs, __pyx_t_1) < 0) __PYX_ERR(0, 532, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_coeffs, __pyx_t_1) < 0) __PYX_ERR(0, 539, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":537 + /* "l0learn/interface.pyx":544 * support_size=c_results.NnzCount, * coeffs=sp_dmat_field_to_list(c_results.Beta), * intercepts=c_results.Intercept, # <<<<<<<<<<<<<< * converged=c_results.Converged) * return results */ - __pyx_t_1 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Intercept); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 537, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Intercept); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 544, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_intercepts, __pyx_t_1) < 0) __PYX_ERR(0, 532, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_intercepts, __pyx_t_1) < 0) __PYX_ERR(0, 539, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":538 + /* "l0learn/interface.pyx":545 * coeffs=sp_dmat_field_to_list(c_results.Beta), * intercepts=c_results.Intercept, * converged=c_results.Converged) # <<<<<<<<<<<<<< * return results * */ - __pyx_t_1 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(__pyx_v_c_results.Converged); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 538, __pyx_L1_error) + __pyx_t_1 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(__pyx_v_c_results.Converged); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 545, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_converged, __pyx_t_1) < 0) __PYX_ERR(0, 532, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_converged, __pyx_t_1) < 0) __PYX_ERR(0, 539, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":532 + /* "l0learn/interface.pyx":539 * Highs=numpy_to_dvec_d(highs)) * * results = FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, # <<<<<<<<<<<<<< * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 532, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 539, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_results = __pyx_t_1; __pyx_t_1 = 0; - /* "l0learn/interface.pyx":539 + /* "l0learn/interface.pyx":546 * intercepts=c_results.Intercept, * converged=c_results.Converged) * return results # <<<<<<<<<<<<<< @@ -7784,7 +7794,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx return __pyx_r; } -/* "l0learn/interface.pyx":542 +/* "l0learn/interface.pyx":549 * * * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< @@ -7794,7 +7804,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_2fit(CYTHON_UNUSED PyObject *__pyx /* Python wrapper */ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_7l0learn_9interface_4cvfit[] = "cvfit(X: Union[np.ndarray, csc_matrix], y: np.ndarray, unicode loss: str = u'SquaredError', unicode penalty: str = u'L0', unicode algorithm: str = u'CD', num_folds: int = 10, seed: int = 1, max_support_size: int = 100, num_lambda: Optional[int] = 100, num_gamma: Optional[int] = 1, double gamma_max: float = 10., double gamma_min: float = .0001, partial_sort: bool = True, max_iter: int = 200, double rtol: float = 1e-6, double atol: float = 1e-9, active_set: bool = True, active_set_num: int = 3, max_swaps: int = 100, double scale_down_factor: float = 0.8, screen_size: int = 1000, lambda_grid: Optional[List[List[float]]] = None, exclude_first_k: int = 0, intercept: bool = True, lows: Union[np.ndarray, float] = -float(u'inf'), highs: Union[np.ndarray, float] = +float(u'inf')) -> l0learn.models.CVFitModel"; +static char __pyx_doc_7l0learn_9interface_4cvfit[] = "cvfit(X: Union[np.ndarray, csc_matrix], y: np.ndarray, unicode loss: str = u'SquaredError', unicode penalty: str = u'L0', unicode algorithm: str = u'CD', num_folds: int = 10, seed: int = 1, max_support_size: int = 100, num_lambda: Optional[int] = 100, num_gamma: Optional[int] = 1, double gamma_max: float = 10., double gamma_min: float = .0001, partial_sort: bool = True, max_iter: int = 200, double rtol: float = 1e-6, double atol: float = 1e-9, active_set: bool = True, active_set_num: int = 3, max_swaps: int = 100, double scale_down_factor: float = 0.8, screen_size: int = 1000, lambda_grid: Optional[List[Sequence[float]]] = None, exclude_first_k: int = 0, intercept: bool = True, lows: Union[np.ndarray, float] = -float(u'inf'), highs: Union[np.ndarray, float] = +float(u'inf')) -> l0learn.models.CVFitModel\n Computes the regularization path for the specified loss function and penalty function and performs K-fold\n cross-validation.\n\n Parameters\n ----------\n X : np.ndarray or csc_matrix of shape (N, P)\n Data Matrix where rows of X are observations and columns of X are features\n\n y : np.ndarray of shape (P)\n The response vector where y[i] corresponds to X[i, :]\n For classification, a binary vector (-1, 1) is requried .\n\n loss : str\n The loss function. Currently supports the choices:\n \"SquaredError\" (for regression),\n \"Logistic\" (for logistic regression), and\n \"SquaredHinge\" (for smooth SVM).\n\n penalty : str\n The type of regularization.\n This can take either one of the following choices:\n \"L0\",\n \"L0L2\", and\n \"L0L1\"\n\n algorithm : str\n The type of algorithm used to minimize the objective function. Currently \"CD\" and \"CDPSI\" are are supported.\n \"CD\" is a variant of cyclic coordinate descent and runs very fast. \"CDPSI\" performs local combinatorial search\n on top of CD and typical""ly achieves higher quality solutions (at the expense of increased running time).\n\n num_folds : int\n Must be greater than 1 and less than N (number of .\n The number of folds for cross-validation.\n\n max_support_size : int\n Must be greater than 0.\n The maximum support size at which to terminate the regularization path. We recommend setting this to a small\n fraction of min(n,p) (e.g. 0.05 * min(n,p)) as L0 regularization typically selects a small portion of non-zeros.\n\n num_lambda : int, optional\n The number of lambda values to select in the regularization path.\n This value must be None if lambda_grid is supplied.When supplied, must be greater than 0.\n Note: lambda is the regularization parameter corresponding to the L0 norm.\n\n num_gamma: int, optional\n The number of gamma values to select in the regularization path.\n This value must be None if lambda_grid is supplied. When supplied, must be greater than 0.\n Note: gamma is the regularization parameter corresponding to L1 or L2, depending on the chosen penalty).\n\n gamma_max : float\n The maximum value of gamma when using the L0L2 penalty.\n This value must be greater than 0.\n\n Note: For the L0L1 penalty this is automatically selected.\n\n gamma_min : float\n The minimum value of Gamma when using the L0L2 penalty.\n This value must be greater than 0 but less than gamma_max.\n Note: For the L0L1 penalty, the minimum value of gamma in the grid is set to gammaMin * gammaMax.\n\n partial_sort : bool\n If TRUE partial sorting will be used for sorting the coordinates to do greedy cycling (see our paper for\n for details). Otherwise, full sorting is used. #TODO: Add link for paper\n\n max_iter : int\n The maximum number of iterations (full cycles) for CD per grid point. The algorithm may not use the full number\n of iteration per grid po""int if convergence is found (defined by rtol and atol parameter)\n Must be greater than 0\n\n rtol : float\n The relative tolerance which decides when to terminate optimization as based on the relative change in the\n objective between iterations.\n Must be greater than 0 and less than 1.\n\n atol : float\n The absolute tolerance which decides when to terminate optimization as based on the absolute L2 norm of the\n residuals\n Must be greater than 0\n\n active_set : bool\n If TRUE, performs active set updates. (see our paper for for details). #TODO: Add link for paper\n\n active_set_num : int\n The number of consecutive times a support should appear before declaring support stabilization.\n (see our paper for for details). #TODO: Add link for paper\n\n Must be greater than 0.\n\n max_swaps : int\n The maximum number of swaps used by CDPSI for each grid point.\n Must be greater than 0. Ignored by CD algorithims.\n\n scale_down_factor : float\n Roughly amount each lambda value is scaled by between grid points. Larger values lead to closer lambdas and\n typically to smaller gaps between the support sizes.\n\n For details, see our paper - Section 5 on Adaptive Selection of Tuning Parameters). #TODO: Add link for paper\n\n Must be greater than 0 and less than 1 (strictly for both.)\n\n screen_size : int\n The number of coordinates to cycle over when performing initial correlation screening. #TODO: Add link for paper\n\n Must be greater than 0 and less than number of columns of X.\n\n lambda_grid : list of list of floats\n A grid of lambda values to use in computing the regularization path. This is by default an empty list\n and is ignored. When specified, lambda_grid should be a list of list of floats, where the ith element\n (corresponding to the ith gamma) should be a decreasing sequence of la""mbda values. The length of this sequence\n is directly the number of lambdas to be tried for that gamma.\n\n In the the \"L0\" penalty case, lambda_grid should be a list of 1.\n In the \"L0LX\" penalty cases, lambda_grid can be a list of any length. The length of lambda_grid will be the\n number of gamma values tried.\n\n See the example notebook for more details.\n\n Note: When lambda_grid is supplied, num_gamma and num_lambda must be None.\n\n exclude_first_k : int\n The first exclude_first_k features in X will be excluded from variable selection. In other words, the first\n exclude_first_k variables will not be included in the L0-norm penalty however they will be included in the\n L1 or L2 norm penalties, if they are specified.\n\n Must be a positive integer less than the columns of X.\n\n intercept : bool\n If False, no intercept term is included or fit in the regularization path\n Intercept terms are not regularized by L0 or L1/L2.\n\n lows : np array or float\n Lower bounds for coefficients. Either a scalar for all coefficients to have the same bound or a vector of\n size p (number of columns of X) where lows[i] is the lower bound for coefficient i.\n\n Lower bounds can not be above 0 (i.e. we can not specify that all coefficients must be larger than a > 0).\n Lower bounds can be set to 0 iff the corresponding upper bound for that coefficient is also not 0.\n\n highs : np array or float\n Upper bounds for coefficients. Either a scalar for all coefficients to have the same bound or a vector of\n size p (number of columns of X) where highs[i] is the upper bound for coefficient i.\n\n Upper bounds can not be below 0 (i.e. we can not specify that all coefficients must be smaller than a < 0).\n Upper bounds can be set to 0 iff the corresponding lower bound for that coefficient is also not 0.\n\n Returns\n --""-----\n fit_model : l0learn.models.FitModel\n FitModel instance containing all relevant information from the solution path.\n\n See Also\n -------\n l0learn.cvfit\n l0learn.models.FitModel\n\n Examples\n --------\n >>>fit_model = l0learn.fit(X, y, penalty=\"L0\", max_support_size=20)\n "; static PyMethodDef __pyx_mdef_7l0learn_9interface_5cvfit = {"cvfit", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7l0learn_9interface_5cvfit, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7l0learn_9interface_4cvfit}; static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_X = 0; @@ -7841,7 +7851,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj values[8] = ((PyObject *)__pyx_int_100); values[9] = ((PyObject *)__pyx_int_1); - /* "l0learn/interface.pyx":554 + /* "l0learn/interface.pyx":561 * gamma_max: float = 10., * gamma_min: float = .0001, * partial_sort: bool = True, # <<<<<<<<<<<<<< @@ -7851,7 +7861,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj values[12] = ((PyObject *)Py_True); values[13] = ((PyObject *)__pyx_int_200); - /* "l0learn/interface.pyx":558 + /* "l0learn/interface.pyx":565 * rtol: float = 1e-6, * atol: float = 1e-9, * active_set: bool = True, # <<<<<<<<<<<<<< @@ -7863,18 +7873,18 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj values[18] = ((PyObject *)__pyx_int_100); values[20] = ((PyObject *)__pyx_int_1000); - /* "l0learn/interface.pyx":563 + /* "l0learn/interface.pyx":570 * scale_down_factor: float = 0.8, * screen_size: int = 1000, - * lambda_grid: Optional[List[List[float]]] = None, # <<<<<<<<<<<<<< + * lambda_grid: Optional[List[Sequence[float]]] = None, # <<<<<<<<<<<<<< * exclude_first_k: int = 0, * intercept: bool = True, */ values[21] = ((PyObject *)Py_None); values[22] = ((PyObject *)__pyx_int_0); - /* "l0learn/interface.pyx":565 - * lambda_grid: Optional[List[List[float]]] = None, + /* "l0learn/interface.pyx":572 + * lambda_grid: Optional[List[Sequence[float]]] = None, * exclude_first_k: int = 0, * intercept: bool = True, # <<<<<<<<<<<<<< * lows: Union[np.ndarray, float] = -float('inf'), @@ -7951,7 +7961,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("cvfit", 0, 2, 26, 1); __PYX_ERR(0, 542, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("cvfit", 0, 2, 26, 1); __PYX_ERR(0, 549, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: @@ -8099,7 +8109,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "cvfit") < 0)) __PYX_ERR(0, 542, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "cvfit") < 0)) __PYX_ERR(0, 549, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -8168,24 +8178,24 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj __pyx_v_num_lambda = values[8]; __pyx_v_num_gamma = values[9]; if (values[10]) { - __pyx_v_gamma_max = __pyx_PyFloat_AsDouble(values[10]); if (unlikely((__pyx_v_gamma_max == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 552, __pyx_L3_error) + __pyx_v_gamma_max = __pyx_PyFloat_AsDouble(values[10]); if (unlikely((__pyx_v_gamma_max == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 559, __pyx_L3_error) } else { __pyx_v_gamma_max = ((double)10.); } if (values[11]) { - __pyx_v_gamma_min = __pyx_PyFloat_AsDouble(values[11]); if (unlikely((__pyx_v_gamma_min == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 553, __pyx_L3_error) + __pyx_v_gamma_min = __pyx_PyFloat_AsDouble(values[11]); if (unlikely((__pyx_v_gamma_min == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 560, __pyx_L3_error) } else { __pyx_v_gamma_min = ((double).0001); } __pyx_v_partial_sort = values[12]; __pyx_v_max_iter = values[13]; if (values[14]) { - __pyx_v_rtol = __pyx_PyFloat_AsDouble(values[14]); if (unlikely((__pyx_v_rtol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 556, __pyx_L3_error) + __pyx_v_rtol = __pyx_PyFloat_AsDouble(values[14]); if (unlikely((__pyx_v_rtol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 563, __pyx_L3_error) } else { __pyx_v_rtol = ((double)1e-6); } if (values[15]) { - __pyx_v_atol = __pyx_PyFloat_AsDouble(values[15]); if (unlikely((__pyx_v_atol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 557, __pyx_L3_error) + __pyx_v_atol = __pyx_PyFloat_AsDouble(values[15]); if (unlikely((__pyx_v_atol == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 564, __pyx_L3_error) } else { __pyx_v_atol = ((double)1e-9); } @@ -8193,7 +8203,7 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj __pyx_v_active_set_num = values[17]; __pyx_v_max_swaps = values[18]; if (values[19]) { - __pyx_v_scale_down_factor = __pyx_PyFloat_AsDouble(values[19]); if (unlikely((__pyx_v_scale_down_factor == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 561, __pyx_L3_error) + __pyx_v_scale_down_factor = __pyx_PyFloat_AsDouble(values[19]); if (unlikely((__pyx_v_scale_down_factor == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 568, __pyx_L3_error) } else { __pyx_v_scale_down_factor = ((double)0.8); } @@ -8206,18 +8216,18 @@ static PyObject *__pyx_pw_7l0learn_9interface_5cvfit(PyObject *__pyx_self, PyObj } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("cvfit", 0, 2, 26, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 542, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("cvfit", 0, 2, 26, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 549, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("l0learn.interface.cvfit", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loss), (&PyUnicode_Type), 1, "loss", 1))) __PYX_ERR(0, 544, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_penalty), (&PyUnicode_Type), 1, "penalty", 1))) __PYX_ERR(0, 545, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_algorithm), (&PyUnicode_Type), 1, "algorithm", 1))) __PYX_ERR(0, 546, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_loss), (&PyUnicode_Type), 1, "loss", 1))) __PYX_ERR(0, 551, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_penalty), (&PyUnicode_Type), 1, "penalty", 1))) __PYX_ERR(0, 552, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_algorithm), (&PyUnicode_Type), 1, "algorithm", 1))) __PYX_ERR(0, 553, __pyx_L1_error) __pyx_r = __pyx_pf_7l0learn_9interface_4cvfit(__pyx_self, __pyx_v_X, __pyx_v_y, __pyx_v_loss, __pyx_v_penalty, __pyx_v_algorithm, __pyx_v_num_folds, __pyx_v_seed, __pyx_v_max_support_size, __pyx_v_num_lambda, __pyx_v_num_gamma, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_v_partial_sort, __pyx_v_max_iter, __pyx_v_rtol, __pyx_v_atol, __pyx_v_active_set, __pyx_v_active_set_num, __pyx_v_max_swaps, __pyx_v_scale_down_factor, __pyx_v_screen_size, __pyx_v_lambda_grid, __pyx_v_exclude_first_k, __pyx_v_intercept, __pyx_v_lows, __pyx_v_highs); - /* "l0learn/interface.pyx":542 + /* "l0learn/interface.pyx":549 * * * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< @@ -8238,8 +8248,8 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p PyObject *__pyx_v_check = NULL; PyObject *__pyx_v_auto_lambda = NULL; PyObject *__pyx_v_with_bounds = NULL; - CYTHON_UNUSED PyObject *__pyx_v__ = NULL; - PyObject *__pyx_v_p = NULL; + PyObject *__pyx_v_n = NULL; + CYTHON_UNUSED PyObject *__pyx_v_p = NULL; std::vector > __pyx_v_c_lambda_grid; std::string __pyx_v_c_loss; std::string __pyx_v_c_penalty; @@ -8288,422 +8298,422 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_INCREF(__pyx_v_lows); __Pyx_INCREF(__pyx_v_highs); - /* "l0learn/interface.pyx":569 - * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.CVFitModel: + /* "l0learn/interface.pyx":734 + * """ * * check = _fit_check(X=X, # <<<<<<<<<<<<<< * y=y, * loss=loss, */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_fit_check); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 569, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_fit_check); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 734, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyDict_NewPresized(24); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 569, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyDict_NewPresized(24); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 734, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_X, __pyx_v_X) < 0) __PYX_ERR(0, 569, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_X, __pyx_v_X) < 0) __PYX_ERR(0, 734, __pyx_L1_error) - /* "l0learn/interface.pyx":570 + /* "l0learn/interface.pyx":735 * * check = _fit_check(X=X, * y=y, # <<<<<<<<<<<<<< * loss=loss, * penalty=penalty, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_y, __pyx_v_y) < 0) __PYX_ERR(0, 569, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_y, __pyx_v_y) < 0) __PYX_ERR(0, 734, __pyx_L1_error) - /* "l0learn/interface.pyx":571 + /* "l0learn/interface.pyx":736 * check = _fit_check(X=X, * y=y, * loss=loss, # <<<<<<<<<<<<<< * penalty=penalty, * algorithm=algorithm, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 569, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 734, __pyx_L1_error) - /* "l0learn/interface.pyx":572 + /* "l0learn/interface.pyx":737 * y=y, * loss=loss, * penalty=penalty, # <<<<<<<<<<<<<< * algorithm=algorithm, * max_support_size=max_support_size, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 569, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 734, __pyx_L1_error) - /* "l0learn/interface.pyx":573 + /* "l0learn/interface.pyx":738 * loss=loss, * penalty=penalty, * algorithm=algorithm, # <<<<<<<<<<<<<< * max_support_size=max_support_size, * num_lambda=num_lambda, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_algorithm, __pyx_v_algorithm) < 0) __PYX_ERR(0, 569, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_algorithm, __pyx_v_algorithm) < 0) __PYX_ERR(0, 734, __pyx_L1_error) - /* "l0learn/interface.pyx":574 + /* "l0learn/interface.pyx":739 * penalty=penalty, * algorithm=algorithm, * max_support_size=max_support_size, # <<<<<<<<<<<<<< * num_lambda=num_lambda, * num_gamma=num_gamma, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_support_size, __pyx_v_max_support_size) < 0) __PYX_ERR(0, 569, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_support_size, __pyx_v_max_support_size) < 0) __PYX_ERR(0, 734, __pyx_L1_error) - /* "l0learn/interface.pyx":575 + /* "l0learn/interface.pyx":740 * algorithm=algorithm, * max_support_size=max_support_size, * num_lambda=num_lambda, # <<<<<<<<<<<<<< * num_gamma=num_gamma, * gamma_max=gamma_max, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_lambda, __pyx_v_num_lambda) < 0) __PYX_ERR(0, 569, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_lambda, __pyx_v_num_lambda) < 0) __PYX_ERR(0, 734, __pyx_L1_error) - /* "l0learn/interface.pyx":576 + /* "l0learn/interface.pyx":741 * max_support_size=max_support_size, * num_lambda=num_lambda, * num_gamma=num_gamma, # <<<<<<<<<<<<<< * gamma_max=gamma_max, * gamma_min=gamma_min, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_gamma, __pyx_v_num_gamma) < 0) __PYX_ERR(0, 569, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_num_gamma, __pyx_v_num_gamma) < 0) __PYX_ERR(0, 734, __pyx_L1_error) - /* "l0learn/interface.pyx":577 + /* "l0learn/interface.pyx":742 * num_lambda=num_lambda, * num_gamma=num_gamma, * gamma_max=gamma_max, # <<<<<<<<<<<<<< * gamma_min=gamma_min, * partial_sort=partial_sort, */ - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 577, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 742, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma_max, __pyx_t_3) < 0) __PYX_ERR(0, 569, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma_max, __pyx_t_3) < 0) __PYX_ERR(0, 734, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":578 + /* "l0learn/interface.pyx":743 * num_gamma=num_gamma, * gamma_max=gamma_max, * gamma_min=gamma_min, # <<<<<<<<<<<<<< * partial_sort=partial_sort, * max_iter=max_iter, */ - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 578, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_gamma_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 743, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma_min, __pyx_t_3) < 0) __PYX_ERR(0, 569, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_gamma_min, __pyx_t_3) < 0) __PYX_ERR(0, 734, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":579 + /* "l0learn/interface.pyx":744 * gamma_max=gamma_max, * gamma_min=gamma_min, * partial_sort=partial_sort, # <<<<<<<<<<<<<< * max_iter=max_iter, * rtol=rtol, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_partial_sort, __pyx_v_partial_sort) < 0) __PYX_ERR(0, 569, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_partial_sort, __pyx_v_partial_sort) < 0) __PYX_ERR(0, 734, __pyx_L1_error) - /* "l0learn/interface.pyx":580 + /* "l0learn/interface.pyx":745 * gamma_min=gamma_min, * partial_sort=partial_sort, * max_iter=max_iter, # <<<<<<<<<<<<<< * rtol=rtol, * atol=atol, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_iter, __pyx_v_max_iter) < 0) __PYX_ERR(0, 569, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_iter, __pyx_v_max_iter) < 0) __PYX_ERR(0, 734, __pyx_L1_error) - /* "l0learn/interface.pyx":581 + /* "l0learn/interface.pyx":746 * partial_sort=partial_sort, * max_iter=max_iter, * rtol=rtol, # <<<<<<<<<<<<<< * atol=atol, * active_set=active_set, */ - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_rtol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 581, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_rtol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 746, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_rtol, __pyx_t_3) < 0) __PYX_ERR(0, 569, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_rtol, __pyx_t_3) < 0) __PYX_ERR(0, 734, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":582 + /* "l0learn/interface.pyx":747 * max_iter=max_iter, * rtol=rtol, * atol=atol, # <<<<<<<<<<<<<< * active_set=active_set, * active_set_num=active_set_num, */ - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_atol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 582, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_atol); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 747, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_atol, __pyx_t_3) < 0) __PYX_ERR(0, 569, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_atol, __pyx_t_3) < 0) __PYX_ERR(0, 734, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":583 + /* "l0learn/interface.pyx":748 * rtol=rtol, * atol=atol, * active_set=active_set, # <<<<<<<<<<<<<< * active_set_num=active_set_num, * max_swaps=max_swaps, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_active_set, __pyx_v_active_set) < 0) __PYX_ERR(0, 569, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_active_set, __pyx_v_active_set) < 0) __PYX_ERR(0, 734, __pyx_L1_error) - /* "l0learn/interface.pyx":584 + /* "l0learn/interface.pyx":749 * atol=atol, * active_set=active_set, * active_set_num=active_set_num, # <<<<<<<<<<<<<< * max_swaps=max_swaps, * scale_down_factor=scale_down_factor, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_active_set_num, __pyx_v_active_set_num) < 0) __PYX_ERR(0, 569, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_active_set_num, __pyx_v_active_set_num) < 0) __PYX_ERR(0, 734, __pyx_L1_error) - /* "l0learn/interface.pyx":585 + /* "l0learn/interface.pyx":750 * active_set=active_set, * active_set_num=active_set_num, * max_swaps=max_swaps, # <<<<<<<<<<<<<< * scale_down_factor=scale_down_factor, * screen_size=screen_size, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_swaps, __pyx_v_max_swaps) < 0) __PYX_ERR(0, 569, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_max_swaps, __pyx_v_max_swaps) < 0) __PYX_ERR(0, 734, __pyx_L1_error) - /* "l0learn/interface.pyx":586 + /* "l0learn/interface.pyx":751 * active_set_num=active_set_num, * max_swaps=max_swaps, * scale_down_factor=scale_down_factor, # <<<<<<<<<<<<<< * screen_size=screen_size, * lambda_grid=lambda_grid, */ - __pyx_t_3 = PyFloat_FromDouble(__pyx_v_scale_down_factor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 586, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_scale_down_factor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 751, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_scale_down_factor, __pyx_t_3) < 0) __PYX_ERR(0, 569, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_scale_down_factor, __pyx_t_3) < 0) __PYX_ERR(0, 734, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":587 + /* "l0learn/interface.pyx":752 * max_swaps=max_swaps, * scale_down_factor=scale_down_factor, * screen_size=screen_size, # <<<<<<<<<<<<<< * lambda_grid=lambda_grid, * exclude_first_k=exclude_first_k, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_screen_size, __pyx_v_screen_size) < 0) __PYX_ERR(0, 569, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_screen_size, __pyx_v_screen_size) < 0) __PYX_ERR(0, 734, __pyx_L1_error) - /* "l0learn/interface.pyx":588 + /* "l0learn/interface.pyx":753 * scale_down_factor=scale_down_factor, * screen_size=screen_size, * lambda_grid=lambda_grid, # <<<<<<<<<<<<<< * exclude_first_k=exclude_first_k, * intercept=intercept, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lambda_grid, __pyx_v_lambda_grid) < 0) __PYX_ERR(0, 569, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lambda_grid, __pyx_v_lambda_grid) < 0) __PYX_ERR(0, 734, __pyx_L1_error) - /* "l0learn/interface.pyx":589 + /* "l0learn/interface.pyx":754 * screen_size=screen_size, * lambda_grid=lambda_grid, * exclude_first_k=exclude_first_k, # <<<<<<<<<<<<<< * intercept=intercept, * lows=lows, */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_exclude_first_k, __pyx_v_exclude_first_k) < 0) __PYX_ERR(0, 569, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_exclude_first_k, __pyx_v_exclude_first_k) < 0) __PYX_ERR(0, 734, __pyx_L1_error) - /* "l0learn/interface.pyx":590 + /* "l0learn/interface.pyx":755 * lambda_grid=lambda_grid, * exclude_first_k=exclude_first_k, * intercept=intercept, # <<<<<<<<<<<<<< * lows=lows, * highs=highs) */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 569, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 734, __pyx_L1_error) - /* "l0learn/interface.pyx":591 + /* "l0learn/interface.pyx":756 * exclude_first_k=exclude_first_k, * intercept=intercept, * lows=lows, # <<<<<<<<<<<<<< * highs=highs) * */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lows, __pyx_v_lows) < 0) __PYX_ERR(0, 569, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_lows, __pyx_v_lows) < 0) __PYX_ERR(0, 734, __pyx_L1_error) - /* "l0learn/interface.pyx":592 + /* "l0learn/interface.pyx":757 * intercept=intercept, * lows=lows, * highs=highs) # <<<<<<<<<<<<<< * * max_support_size = check["max_support_size"] */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_highs, __pyx_v_highs) < 0) __PYX_ERR(0, 569, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_highs, __pyx_v_highs) < 0) __PYX_ERR(0, 734, __pyx_L1_error) - /* "l0learn/interface.pyx":569 - * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.CVFitModel: + /* "l0learn/interface.pyx":734 + * """ * * check = _fit_check(X=X, # <<<<<<<<<<<<<< * y=y, * loss=loss, */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 569, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 734, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_check = __pyx_t_3; __pyx_t_3 = 0; - /* "l0learn/interface.pyx":594 + /* "l0learn/interface.pyx":759 * highs=highs) * * max_support_size = check["max_support_size"] # <<<<<<<<<<<<<< * screen_size = check["screen_size"] * y = check['y'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_max_support_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 594, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_max_support_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 759, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_max_support_size, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":595 + /* "l0learn/interface.pyx":760 * * max_support_size = check["max_support_size"] * screen_size = check["screen_size"] # <<<<<<<<<<<<<< * y = check['y'] * penalty = check['penalty'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_screen_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 595, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_screen_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 760, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_screen_size, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":596 + /* "l0learn/interface.pyx":761 * max_support_size = check["max_support_size"] * screen_size = check["screen_size"] * y = check['y'] # <<<<<<<<<<<<<< * penalty = check['penalty'] * gamma_max = check['gamma_max'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_y); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 596, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_y); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 761, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_y, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":597 + /* "l0learn/interface.pyx":762 * screen_size = check["screen_size"] * y = check['y'] * penalty = check['penalty'] # <<<<<<<<<<<<<< * gamma_max = check['gamma_max'] * gamma_min = check['gamma_min'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_penalty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 597, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_penalty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 762, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (!(likely(PyUnicode_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(0, 597, __pyx_L1_error) + if (!(likely(PyUnicode_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(0, 762, __pyx_L1_error) __Pyx_DECREF_SET(__pyx_v_penalty, ((PyObject*)__pyx_t_3)); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":598 + /* "l0learn/interface.pyx":763 * y = check['y'] * penalty = check['penalty'] * gamma_max = check['gamma_max'] # <<<<<<<<<<<<<< * gamma_min = check['gamma_min'] * lambda_grid = check['lambda_grid'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 598, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_gamma_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 763, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 598, __pyx_L1_error) + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 763, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_gamma_max = __pyx_t_4; - /* "l0learn/interface.pyx":599 + /* "l0learn/interface.pyx":764 * penalty = check['penalty'] * gamma_max = check['gamma_max'] * gamma_min = check['gamma_min'] # <<<<<<<<<<<<<< * lambda_grid = check['lambda_grid'] * num_gamma = check['num_gamma'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_gamma_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 599, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_gamma_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 764, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 599, __pyx_L1_error) + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 764, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_gamma_min = __pyx_t_4; - /* "l0learn/interface.pyx":600 + /* "l0learn/interface.pyx":765 * gamma_max = check['gamma_max'] * gamma_min = check['gamma_min'] * lambda_grid = check['lambda_grid'] # <<<<<<<<<<<<<< * num_gamma = check['num_gamma'] * num_lambda = check['num_lambda'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_lambda_grid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 600, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_lambda_grid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 765, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_lambda_grid, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":601 + /* "l0learn/interface.pyx":766 * gamma_min = check['gamma_min'] * lambda_grid = check['lambda_grid'] * num_gamma = check['num_gamma'] # <<<<<<<<<<<<<< * num_lambda = check['num_lambda'] * auto_lambda = check['auto_lambda'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_num_gamma); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 601, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_num_gamma); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 766, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_num_gamma, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":602 + /* "l0learn/interface.pyx":767 * lambda_grid = check['lambda_grid'] * num_gamma = check['num_gamma'] * num_lambda = check['num_lambda'] # <<<<<<<<<<<<<< * auto_lambda = check['auto_lambda'] * with_bounds = check['with_bounds'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_num_lambda); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 602, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_num_lambda); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 767, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_num_lambda, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":603 + /* "l0learn/interface.pyx":768 * num_gamma = check['num_gamma'] * num_lambda = check['num_lambda'] * auto_lambda = check['auto_lambda'] # <<<<<<<<<<<<<< * with_bounds = check['with_bounds'] * lows = check['lows'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_auto_lambda); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 603, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_auto_lambda); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 768, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_auto_lambda = __pyx_t_3; __pyx_t_3 = 0; - /* "l0learn/interface.pyx":604 + /* "l0learn/interface.pyx":769 * num_lambda = check['num_lambda'] * auto_lambda = check['auto_lambda'] * with_bounds = check['with_bounds'] # <<<<<<<<<<<<<< * lows = check['lows'] * highs = check['highs'] */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_with_bounds); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 604, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_with_bounds); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 769, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_with_bounds = __pyx_t_3; __pyx_t_3 = 0; - /* "l0learn/interface.pyx":605 + /* "l0learn/interface.pyx":770 * auto_lambda = check['auto_lambda'] * with_bounds = check['with_bounds'] * lows = check['lows'] # <<<<<<<<<<<<<< * highs = check['highs'] * */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_lows); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 605, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_lows); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 770, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_lows, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":606 + /* "l0learn/interface.pyx":771 * with_bounds = check['with_bounds'] * lows = check['lows'] * highs = check['highs'] # <<<<<<<<<<<<<< * - * _, p = X.shape + * n, p = X.shape */ - __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_highs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 606, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Dict_GetItem(__pyx_v_check, __pyx_n_u_highs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 771, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_highs, __pyx_t_3); __pyx_t_3 = 0; - /* "l0learn/interface.pyx":608 + /* "l0learn/interface.pyx":773 * highs = check['highs'] * - * _, p = X.shape # <<<<<<<<<<<<<< + * n, p = X.shape # <<<<<<<<<<<<<< * - * if not isinstance(num_folds, int) or num_folds < 2 or num_folds > p: + * if not isinstance(num_folds, int) or num_folds < 2 or num_folds > n: */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 608, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_X, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 773, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { PyObject* sequence = __pyx_t_3; @@ -8711,7 +8721,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(0, 608, __pyx_L1_error) + __PYX_ERR(0, 773, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { @@ -8724,15 +8734,15 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(__pyx_t_1); #else - __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 608, __pyx_L1_error) + __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 773, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 608, __pyx_L1_error) + __pyx_t_1 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 773, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { Py_ssize_t index = -1; - __pyx_t_5 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 608, __pyx_L1_error) + __pyx_t_5 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 773, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext; @@ -8740,7 +8750,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_GOTREF(__pyx_t_2); index = 1; __pyx_t_1 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_1)) goto __pyx_L3_unpacking_failed; __Pyx_GOTREF(__pyx_t_1); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 2) < 0) __PYX_ERR(0, 608, __pyx_L1_error) + if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 2) < 0) __PYX_ERR(0, 773, __pyx_L1_error) __pyx_t_6 = NULL; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L4_unpacking_done; @@ -8748,19 +8758,19 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_6 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(0, 608, __pyx_L1_error) + __PYX_ERR(0, 773, __pyx_L1_error) __pyx_L4_unpacking_done:; } - __pyx_v__ = __pyx_t_2; + __pyx_v_n = __pyx_t_2; __pyx_t_2 = 0; __pyx_v_p = __pyx_t_1; __pyx_t_1 = 0; - /* "l0learn/interface.pyx":610 - * _, p = X.shape + /* "l0learn/interface.pyx":775 + * n, p = X.shape * - * if not isinstance(num_folds, int) or num_folds < 2 or num_folds > p: # <<<<<<<<<<<<<< - * raise ValueError(f"expected num_folds parameter to be a positive integer less than {p}, but got {num_folds}") + * if not isinstance(num_folds, int) or num_folds < 2 or num_folds > n: # <<<<<<<<<<<<<< + * raise ValueError(f"expected num_folds parameter to be a positive integer less than {n}, but got {num_folds}") * */ __pyx_t_8 = PyInt_Check(__pyx_v_num_folds); @@ -8770,29 +8780,29 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_7 = __pyx_t_9; goto __pyx_L6_bool_binop_done; } - __pyx_t_3 = PyObject_RichCompare(__pyx_v_num_folds, __pyx_int_2, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 610, __pyx_L1_error) - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 610, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_num_folds, __pyx_int_2, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 775, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 775, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (!__pyx_t_9) { } else { __pyx_t_7 = __pyx_t_9; goto __pyx_L6_bool_binop_done; } - __pyx_t_3 = PyObject_RichCompare(__pyx_v_num_folds, __pyx_v_p, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 610, __pyx_L1_error) - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 610, __pyx_L1_error) + __pyx_t_3 = PyObject_RichCompare(__pyx_v_num_folds, __pyx_v_n, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 775, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 775, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_7 = __pyx_t_9; __pyx_L6_bool_binop_done:; if (unlikely(__pyx_t_7)) { - /* "l0learn/interface.pyx":611 + /* "l0learn/interface.pyx":776 * - * if not isinstance(num_folds, int) or num_folds < 2 or num_folds > p: - * raise ValueError(f"expected num_folds parameter to be a positive integer less than {p}, but got {num_folds}") # <<<<<<<<<<<<<< + * if not isinstance(num_folds, int) or num_folds < 2 or num_folds > n: + * raise ValueError(f"expected num_folds parameter to be a positive integer less than {n}, but got {num_folds}") # <<<<<<<<<<<<<< * * */ - __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 611, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 776, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_10 = 0; __pyx_t_11 = 127; @@ -8800,7 +8810,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_10 += 64; __Pyx_GIVEREF(__pyx_kp_u_expected_num_folds_parameter_to); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_expected_num_folds_parameter_to); - __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_p, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 611, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_n, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 776, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_11 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) > __pyx_t_11) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) : __pyx_t_11; __pyx_t_10 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1); @@ -8811,43 +8821,43 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_t_10 += 10; __Pyx_GIVEREF(__pyx_kp_u_but_got); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u_but_got); - __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_num_folds, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 611, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_FormatSimple(__pyx_v_num_folds, __pyx_empty_unicode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 776, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_11 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) > __pyx_t_11) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_1) : __pyx_t_11; __pyx_t_10 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_10, __pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 611, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_3, 4, __pyx_t_10, __pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 776, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 611, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 776, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(0, 611, __pyx_L1_error) + __PYX_ERR(0, 776, __pyx_L1_error) - /* "l0learn/interface.pyx":610 - * _, p = X.shape + /* "l0learn/interface.pyx":775 + * n, p = X.shape * - * if not isinstance(num_folds, int) or num_folds < 2 or num_folds > p: # <<<<<<<<<<<<<< - * raise ValueError(f"expected num_folds parameter to be a positive integer less than {p}, but got {num_folds}") + * if not isinstance(num_folds, int) or num_folds < 2 or num_folds > n: # <<<<<<<<<<<<<< + * raise ValueError(f"expected num_folds parameter to be a positive integer less than {n}, but got {num_folds}") * */ } - /* "l0learn/interface.pyx":614 + /* "l0learn/interface.pyx":779 * * * cdef vector[vector[double]] c_lambda_grid = lambda_grid # <<<<<<<<<<<<<< * cdef string c_loss = loss.encode('UTF-8') * cdef string c_penalty = penalty.encode('UTF-8') */ - __pyx_t_12 = __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_lambda_grid); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 614, __pyx_L1_error) + __pyx_t_12 = __pyx_convert_vector_from_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_lambda_grid); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 779, __pyx_L1_error) __pyx_v_c_lambda_grid = __pyx_t_12; - /* "l0learn/interface.pyx":615 + /* "l0learn/interface.pyx":780 * * cdef vector[vector[double]] c_lambda_grid = lambda_grid * cdef string c_loss = loss.encode('UTF-8') # <<<<<<<<<<<<<< @@ -8856,15 +8866,15 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ if (unlikely(__pyx_v_loss == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 615, __pyx_L1_error) + __PYX_ERR(0, 780, __pyx_L1_error) } - __pyx_t_3 = PyUnicode_AsUTF8String(__pyx_v_loss); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 615, __pyx_L1_error) + __pyx_t_3 = PyUnicode_AsUTF8String(__pyx_v_loss); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 780, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_13 = __pyx_convert_string_from_py_std__in_string(__pyx_t_3); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 615, __pyx_L1_error) + __pyx_t_13 = __pyx_convert_string_from_py_std__in_string(__pyx_t_3); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 780, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_c_loss = __pyx_t_13; - /* "l0learn/interface.pyx":616 + /* "l0learn/interface.pyx":781 * cdef vector[vector[double]] c_lambda_grid = lambda_grid * cdef string c_loss = loss.encode('UTF-8') * cdef string c_penalty = penalty.encode('UTF-8') # <<<<<<<<<<<<<< @@ -8873,15 +8883,15 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ if (unlikely(__pyx_v_penalty == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 616, __pyx_L1_error) + __PYX_ERR(0, 781, __pyx_L1_error) } - __pyx_t_3 = PyUnicode_AsUTF8String(__pyx_v_penalty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 616, __pyx_L1_error) + __pyx_t_3 = PyUnicode_AsUTF8String(__pyx_v_penalty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 781, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_13 = __pyx_convert_string_from_py_std__in_string(__pyx_t_3); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 616, __pyx_L1_error) + __pyx_t_13 = __pyx_convert_string_from_py_std__in_string(__pyx_t_3); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 781, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_c_penalty = __pyx_t_13; - /* "l0learn/interface.pyx":617 + /* "l0learn/interface.pyx":782 * cdef string c_loss = loss.encode('UTF-8') * cdef string c_penalty = penalty.encode('UTF-8') * cdef string c_algorithim = algorithm.encode('UTF-8') # <<<<<<<<<<<<<< @@ -8890,203 +8900,203 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ if (unlikely(__pyx_v_algorithm == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode"); - __PYX_ERR(0, 617, __pyx_L1_error) + __PYX_ERR(0, 782, __pyx_L1_error) } - __pyx_t_3 = PyUnicode_AsUTF8String(__pyx_v_algorithm); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 617, __pyx_L1_error) + __pyx_t_3 = PyUnicode_AsUTF8String(__pyx_v_algorithm); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 782, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_13 = __pyx_convert_string_from_py_std__in_string(__pyx_t_3); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 617, __pyx_L1_error) + __pyx_t_13 = __pyx_convert_string_from_py_std__in_string(__pyx_t_3); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 782, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_c_algorithim = __pyx_t_13; - /* "l0learn/interface.pyx":620 + /* "l0learn/interface.pyx":785 * * cdef cvfitmodel c_results * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), * y=numpy_to_dvec_d(y), */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 620, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 785, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 620, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_ndarray); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 785, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_7 = PyObject_IsInstance(__pyx_v_X, __pyx_t_1); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 620, __pyx_L1_error) + __pyx_t_7 = PyObject_IsInstance(__pyx_v_X, __pyx_t_1); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 785, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_9 = (__pyx_t_7 != 0); if (__pyx_t_9) { - /* "l0learn/interface.pyx":621 + /* "l0learn/interface.pyx":786 * cdef cvfitmodel c_results * if isinstance(X, np.ndarray): * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< * y=numpy_to_dvec_d(y), * Loss=c_loss, */ - if (!(likely(((__pyx_v_X) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_X, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 621, __pyx_L1_error) + if (!(likely(((__pyx_v_X) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_X, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 786, __pyx_L1_error) - /* "l0learn/interface.pyx":622 + /* "l0learn/interface.pyx":787 * if isinstance(X, np.ndarray): * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), * y=numpy_to_dvec_d(y), # <<<<<<<<<<<<<< * Loss=c_loss, * Penalty=c_penalty, */ - if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 622, __pyx_L1_error) + if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 787, __pyx_L1_error) - /* "l0learn/interface.pyx":626 + /* "l0learn/interface.pyx":791 * Penalty=c_penalty, * Algorithm=c_algorithim, * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< * G_ncols=num_lambda, * G_nrows=num_gamma, */ - __pyx_t_14 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_14 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 626, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_14 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 791, __pyx_L1_error) - /* "l0learn/interface.pyx":627 + /* "l0learn/interface.pyx":792 * Algorithm=c_algorithim, * NnzStopNum=max_support_size, * G_ncols=num_lambda, # <<<<<<<<<<<<<< * G_nrows=num_gamma, * Lambda2Max=gamma_max, */ - __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 627, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 792, __pyx_L1_error) - /* "l0learn/interface.pyx":628 + /* "l0learn/interface.pyx":793 * NnzStopNum=max_support_size, * G_ncols=num_lambda, * G_nrows=num_gamma, # <<<<<<<<<<<<<< * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, */ - __pyx_t_16 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_16 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 628, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_16 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 793, __pyx_L1_error) - /* "l0learn/interface.pyx":631 + /* "l0learn/interface.pyx":796 * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, * PartialSort=partial_sort, # <<<<<<<<<<<<<< * MaxIters=max_iter, * rtol=rtol, */ - __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_17 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 631, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_17 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 796, __pyx_L1_error) - /* "l0learn/interface.pyx":632 + /* "l0learn/interface.pyx":797 * Lambda2Min=gamma_min, * PartialSort=partial_sort, * MaxIters=max_iter, # <<<<<<<<<<<<<< * rtol=rtol, * atol=atol, */ - __pyx_t_18 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_18 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 632, __pyx_L1_error) + __pyx_t_18 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_18 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 797, __pyx_L1_error) - /* "l0learn/interface.pyx":635 + /* "l0learn/interface.pyx":800 * rtol=rtol, * atol=atol, * ActiveSet=active_set, # <<<<<<<<<<<<<< * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, */ - __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_19 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 635, __pyx_L1_error) + __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_19 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 800, __pyx_L1_error) - /* "l0learn/interface.pyx":636 + /* "l0learn/interface.pyx":801 * atol=atol, * ActiveSet=active_set, * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, */ - __pyx_t_20 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_20 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 636, __pyx_L1_error) + __pyx_t_20 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_20 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 801, __pyx_L1_error) - /* "l0learn/interface.pyx":637 + /* "l0learn/interface.pyx":802 * ActiveSet=active_set, * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, */ - __pyx_t_21 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_21 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 637, __pyx_L1_error) + __pyx_t_21 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_21 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 802, __pyx_L1_error) - /* "l0learn/interface.pyx":639 + /* "l0learn/interface.pyx":804 * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, # <<<<<<<<<<<<<< * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, */ - __pyx_t_22 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_22 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 639, __pyx_L1_error) + __pyx_t_22 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_22 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 804, __pyx_L1_error) - /* "l0learn/interface.pyx":640 + /* "l0learn/interface.pyx":805 * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, * LambdaU=not auto_lambda, # <<<<<<<<<<<<<< * Lambdas=c_lambda_grid, * nfolds=num_folds, */ - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 640, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 805, __pyx_L1_error) - /* "l0learn/interface.pyx":642 + /* "l0learn/interface.pyx":807 * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, * nfolds=num_folds, # <<<<<<<<<<<<<< * seed=seed, * ExcludeFirstK=exclude_first_k, */ - __pyx_t_23 = __Pyx_PyInt_As_unsigned_int(__pyx_v_num_folds); if (unlikely((__pyx_t_23 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 642, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyInt_As_unsigned_int(__pyx_v_num_folds); if (unlikely((__pyx_t_23 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 807, __pyx_L1_error) - /* "l0learn/interface.pyx":643 + /* "l0learn/interface.pyx":808 * Lambdas=c_lambda_grid, * nfolds=num_folds, * seed=seed, # <<<<<<<<<<<<<< * ExcludeFirstK=exclude_first_k, * Intercept=intercept, */ - __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_seed); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 643, __pyx_L1_error) + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_seed); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 808, __pyx_L1_error) - /* "l0learn/interface.pyx":644 + /* "l0learn/interface.pyx":809 * nfolds=num_folds, * seed=seed, * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< * Intercept=intercept, * withBounds=with_bounds, */ - __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 644, __pyx_L1_error) + __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 809, __pyx_L1_error) - /* "l0learn/interface.pyx":645 + /* "l0learn/interface.pyx":810 * seed=seed, * ExcludeFirstK=exclude_first_k, * Intercept=intercept, # <<<<<<<<<<<<<< * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), */ - __pyx_t_25 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_25 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 645, __pyx_L1_error) + __pyx_t_25 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_25 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 810, __pyx_L1_error) - /* "l0learn/interface.pyx":646 + /* "l0learn/interface.pyx":811 * ExcludeFirstK=exclude_first_k, * Intercept=intercept, * withBounds=with_bounds, # <<<<<<<<<<<<<< * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) */ - __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 646, __pyx_L1_error) + __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 811, __pyx_L1_error) - /* "l0learn/interface.pyx":647 + /* "l0learn/interface.pyx":812 * Intercept=intercept, * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< * Highs=numpy_to_dvec_d(highs)) * else: # isinstance(X, csc_matrix) */ - if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 647, __pyx_L1_error) + if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 812, __pyx_L1_error) - /* "l0learn/interface.pyx":648 + /* "l0learn/interface.pyx":813 * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< * else: # isinstance(X, csc_matrix) * c_results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), */ - if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 648, __pyx_L1_error) + if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 813, __pyx_L1_error) - /* "l0learn/interface.pyx":621 + /* "l0learn/interface.pyx":786 * cdef cvfitmodel c_results * if isinstance(X, np.ndarray): * c_results = _L0LearnCV_dense(X=numpy_to_dmat_d(X), # <<<<<<<<<<<<<< @@ -9095,7 +9105,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ __pyx_v_c_results = __pyx_f_7l0learn_9interface__L0LearnCV_dense(__pyx_f_7l0learn_6cyarma_numpy_to_dmat_d(((PyArrayObject *)__pyx_v_X)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_y)), __pyx_v_c_loss, __pyx_v_c_penalty, __pyx_v_c_algorithim, __pyx_t_14, __pyx_t_15, __pyx_t_16, __pyx_v_gamma_max, __pyx_v_gamma_min, __pyx_t_17, __pyx_t_18, __pyx_v_rtol, __pyx_v_atol, __pyx_t_19, __pyx_t_20, __pyx_t_21, __pyx_v_scale_down_factor, __pyx_t_22, (!__pyx_t_9), __pyx_v_c_lambda_grid, __pyx_t_23, __pyx_t_4, __pyx_t_24, __pyx_t_25, __pyx_t_26, __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_lows)), __pyx_f_7l0learn_6cyarma_numpy_to_dvec_d(((PyArrayObject *)__pyx_v_highs))); - /* "l0learn/interface.pyx":620 + /* "l0learn/interface.pyx":785 * * cdef cvfitmodel c_results * if isinstance(X, np.ndarray): # <<<<<<<<<<<<<< @@ -9105,7 +9115,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p goto __pyx_L9; } - /* "l0learn/interface.pyx":650 + /* "l0learn/interface.pyx":815 * Highs=numpy_to_dvec_d(highs)) * else: # isinstance(X, csc_matrix) * c_results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< @@ -9114,169 +9124,169 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p */ /*else*/ { - /* "l0learn/interface.pyx":651 + /* "l0learn/interface.pyx":816 * else: # isinstance(X, csc_matrix) * c_results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), * y=numpy_to_dvec_d(y), # <<<<<<<<<<<<<< * Loss=c_loss, * Penalty=c_penalty, */ - if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 651, __pyx_L1_error) + if (!(likely(((__pyx_v_y) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_y, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 816, __pyx_L1_error) - /* "l0learn/interface.pyx":655 + /* "l0learn/interface.pyx":820 * Penalty=c_penalty, * Algorithm=c_algorithim, * NnzStopNum=max_support_size, # <<<<<<<<<<<<<< * G_ncols=num_lambda, * G_nrows=num_gamma, */ - __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 655, __pyx_L1_error) + __pyx_t_24 = __Pyx_PyInt_As_size_t(__pyx_v_max_support_size); if (unlikely((__pyx_t_24 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 820, __pyx_L1_error) - /* "l0learn/interface.pyx":656 + /* "l0learn/interface.pyx":821 * Algorithm=c_algorithim, * NnzStopNum=max_support_size, * G_ncols=num_lambda, # <<<<<<<<<<<<<< * G_nrows=num_gamma, * Lambda2Max=gamma_max, */ - __pyx_t_22 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_22 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 656, __pyx_L1_error) + __pyx_t_22 = __Pyx_PyInt_As_size_t(__pyx_v_num_lambda); if (unlikely((__pyx_t_22 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 821, __pyx_L1_error) - /* "l0learn/interface.pyx":657 + /* "l0learn/interface.pyx":822 * NnzStopNum=max_support_size, * G_ncols=num_lambda, * G_nrows=num_gamma, # <<<<<<<<<<<<<< * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, */ - __pyx_t_21 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_21 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 657, __pyx_L1_error) + __pyx_t_21 = __Pyx_PyInt_As_size_t(__pyx_v_num_gamma); if (unlikely((__pyx_t_21 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 822, __pyx_L1_error) - /* "l0learn/interface.pyx":660 + /* "l0learn/interface.pyx":825 * Lambda2Max=gamma_max, * Lambda2Min=gamma_min, * PartialSort=partial_sort, # <<<<<<<<<<<<<< * MaxIters=max_iter, * rtol=rtol, */ - __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 660, __pyx_L1_error) + __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_v_partial_sort); if (unlikely((__pyx_t_26 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 825, __pyx_L1_error) - /* "l0learn/interface.pyx":661 + /* "l0learn/interface.pyx":826 * Lambda2Min=gamma_min, * PartialSort=partial_sort, * MaxIters=max_iter, # <<<<<<<<<<<<<< * rtol=rtol, * atol=atol, */ - __pyx_t_20 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_20 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 661, __pyx_L1_error) + __pyx_t_20 = __Pyx_PyInt_As_size_t(__pyx_v_max_iter); if (unlikely((__pyx_t_20 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 826, __pyx_L1_error) - /* "l0learn/interface.pyx":664 + /* "l0learn/interface.pyx":829 * rtol=rtol, * atol=atol, * ActiveSet=active_set, # <<<<<<<<<<<<<< * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, */ - __pyx_t_25 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_25 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 664, __pyx_L1_error) + __pyx_t_25 = __Pyx_PyObject_IsTrue(__pyx_v_active_set); if (unlikely((__pyx_t_25 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 829, __pyx_L1_error) - /* "l0learn/interface.pyx":665 + /* "l0learn/interface.pyx":830 * atol=atol, * ActiveSet=active_set, * ActiveSetNum=active_set_num, # <<<<<<<<<<<<<< * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, */ - __pyx_t_18 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_18 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 665, __pyx_L1_error) + __pyx_t_18 = __Pyx_PyInt_As_size_t(__pyx_v_active_set_num); if (unlikely((__pyx_t_18 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 830, __pyx_L1_error) - /* "l0learn/interface.pyx":666 + /* "l0learn/interface.pyx":831 * ActiveSet=active_set, * ActiveSetNum=active_set_num, * MaxNumSwaps=max_swaps, # <<<<<<<<<<<<<< * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, */ - __pyx_t_16 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_16 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 666, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyInt_As_size_t(__pyx_v_max_swaps); if (unlikely((__pyx_t_16 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 831, __pyx_L1_error) - /* "l0learn/interface.pyx":668 + /* "l0learn/interface.pyx":833 * MaxNumSwaps=max_swaps, * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, # <<<<<<<<<<<<<< * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, */ - __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 668, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_v_screen_size); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 833, __pyx_L1_error) - /* "l0learn/interface.pyx":669 + /* "l0learn/interface.pyx":834 * ScaleDownFactor=scale_down_factor, * ScreenSize=screen_size, * LambdaU=not auto_lambda, # <<<<<<<<<<<<<< * Lambdas=c_lambda_grid, * nfolds=num_folds, */ - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 669, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_auto_lambda); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 834, __pyx_L1_error) - /* "l0learn/interface.pyx":671 + /* "l0learn/interface.pyx":836 * LambdaU=not auto_lambda, * Lambdas=c_lambda_grid, * nfolds=num_folds, # <<<<<<<<<<<<<< * seed=seed, * ExcludeFirstK=exclude_first_k, */ - __pyx_t_23 = __Pyx_PyInt_As_unsigned_int(__pyx_v_num_folds); if (unlikely((__pyx_t_23 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 671, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyInt_As_unsigned_int(__pyx_v_num_folds); if (unlikely((__pyx_t_23 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 836, __pyx_L1_error) - /* "l0learn/interface.pyx":672 + /* "l0learn/interface.pyx":837 * Lambdas=c_lambda_grid, * nfolds=num_folds, * seed=seed, # <<<<<<<<<<<<<< * ExcludeFirstK=exclude_first_k, * Intercept=intercept, */ - __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_seed); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 672, __pyx_L1_error) + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_seed); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 837, __pyx_L1_error) - /* "l0learn/interface.pyx":673 + /* "l0learn/interface.pyx":838 * nfolds=num_folds, * seed=seed, * ExcludeFirstK=exclude_first_k, # <<<<<<<<<<<<<< * Intercept=intercept, * withBounds=with_bounds, */ - __pyx_t_14 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_14 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 673, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyInt_As_size_t(__pyx_v_exclude_first_k); if (unlikely((__pyx_t_14 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 838, __pyx_L1_error) - /* "l0learn/interface.pyx":674 + /* "l0learn/interface.pyx":839 * seed=seed, * ExcludeFirstK=exclude_first_k, * Intercept=intercept, # <<<<<<<<<<<<<< * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), */ - __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_19 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 674, __pyx_L1_error) + __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_v_intercept); if (unlikely((__pyx_t_19 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 839, __pyx_L1_error) - /* "l0learn/interface.pyx":675 + /* "l0learn/interface.pyx":840 * ExcludeFirstK=exclude_first_k, * Intercept=intercept, * withBounds=with_bounds, # <<<<<<<<<<<<<< * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) */ - __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_17 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 675, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_v_with_bounds); if (unlikely((__pyx_t_17 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 840, __pyx_L1_error) - /* "l0learn/interface.pyx":676 + /* "l0learn/interface.pyx":841 * Intercept=intercept, * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), # <<<<<<<<<<<<<< * Highs=numpy_to_dvec_d(highs)) * */ - if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 676, __pyx_L1_error) + if (!(likely(((__pyx_v_lows) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_lows, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 841, __pyx_L1_error) - /* "l0learn/interface.pyx":677 + /* "l0learn/interface.pyx":842 * withBounds=with_bounds, * Lows=numpy_to_dvec_d(lows), * Highs=numpy_to_dvec_d(highs)) # <<<<<<<<<<<<<< * * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, */ - if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 677, __pyx_L1_error) + if (!(likely(((__pyx_v_highs) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_highs, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 842, __pyx_L1_error) - /* "l0learn/interface.pyx":650 + /* "l0learn/interface.pyx":815 * Highs=numpy_to_dvec_d(highs)) * else: # isinstance(X, csc_matrix) * c_results = _L0LearnCV_sparse(X=numpy_to_sp_dmat_d(X), # <<<<<<<<<<<<<< @@ -9287,136 +9297,136 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p } __pyx_L9:; - /* "l0learn/interface.pyx":679 + /* "l0learn/interface.pyx":844 * Highs=numpy_to_dvec_d(highs)) * * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, # <<<<<<<<<<<<<< * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_CVFitModel); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 679, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_CVFitModel); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 844, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyDict_NewPresized(9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 679, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 844, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 679, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 844, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 679, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 679, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 679, __pyx_L1_error) - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_settings, __pyx_t_2) < 0) __PYX_ERR(0, 679, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_loss, __pyx_v_loss) < 0) __PYX_ERR(0, 844, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_intercept, __pyx_v_intercept) < 0) __PYX_ERR(0, 844, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_u_penalty, __pyx_v_penalty) < 0) __PYX_ERR(0, 844, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_settings, __pyx_t_2) < 0) __PYX_ERR(0, 844, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "l0learn/interface.pyx":680 + /* "l0learn/interface.pyx":845 * * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, * lambda_0=c_results.Lambda0, # <<<<<<<<<<<<<< * gamma=c_results.Lambda12, * support_size=c_results.NnzCount, */ - __pyx_t_2 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Lambda0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 680, __pyx_L1_error) + __pyx_t_2 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Lambda0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 845, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_lambda_0, __pyx_t_2) < 0) __PYX_ERR(0, 679, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_lambda_0, __pyx_t_2) < 0) __PYX_ERR(0, 844, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "l0learn/interface.pyx":681 + /* "l0learn/interface.pyx":846 * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, # <<<<<<<<<<<<<< * support_size=c_results.NnzCount, * coeffs=sp_dmat_field_to_list(c_results.Beta), */ - __pyx_t_2 = __pyx_convert_vector_to_py_double(__pyx_v_c_results.Lambda12); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 681, __pyx_L1_error) + __pyx_t_2 = __pyx_convert_vector_to_py_double(__pyx_v_c_results.Lambda12); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 846, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_gamma, __pyx_t_2) < 0) __PYX_ERR(0, 679, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_gamma, __pyx_t_2) < 0) __PYX_ERR(0, 844, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "l0learn/interface.pyx":682 + /* "l0learn/interface.pyx":847 * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, * support_size=c_results.NnzCount, # <<<<<<<<<<<<<< * coeffs=sp_dmat_field_to_list(c_results.Beta), * intercepts=c_results.Intercept, */ - __pyx_t_2 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(__pyx_v_c_results.NnzCount); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 682, __pyx_L1_error) + __pyx_t_2 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_size_t_3e___(__pyx_v_c_results.NnzCount); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 847, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_support_size, __pyx_t_2) < 0) __PYX_ERR(0, 679, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_support_size, __pyx_t_2) < 0) __PYX_ERR(0, 844, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "l0learn/interface.pyx":683 + /* "l0learn/interface.pyx":848 * gamma=c_results.Lambda12, * support_size=c_results.NnzCount, * coeffs=sp_dmat_field_to_list(c_results.Beta), # <<<<<<<<<<<<<< * intercepts=c_results.Intercept, * converged=c_results.Converged, */ - __pyx_t_2 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_c_results.Beta); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 683, __pyx_L1_error) + __pyx_t_2 = __pyx_f_7l0learn_6cyarma_sp_dmat_field_to_list(__pyx_v_c_results.Beta); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 848, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_coeffs, __pyx_t_2) < 0) __PYX_ERR(0, 679, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_coeffs, __pyx_t_2) < 0) __PYX_ERR(0, 844, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "l0learn/interface.pyx":684 + /* "l0learn/interface.pyx":849 * support_size=c_results.NnzCount, * coeffs=sp_dmat_field_to_list(c_results.Beta), * intercepts=c_results.Intercept, # <<<<<<<<<<<<<< * converged=c_results.Converged, * cv_means=dvec_field_to_list(c_results.CVMeans), */ - __pyx_t_2 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Intercept); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 684, __pyx_L1_error) + __pyx_t_2 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_double_3e___(__pyx_v_c_results.Intercept); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 849, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_intercepts, __pyx_t_2) < 0) __PYX_ERR(0, 679, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_intercepts, __pyx_t_2) < 0) __PYX_ERR(0, 844, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "l0learn/interface.pyx":685 + /* "l0learn/interface.pyx":850 * coeffs=sp_dmat_field_to_list(c_results.Beta), * intercepts=c_results.Intercept, * converged=c_results.Converged, # <<<<<<<<<<<<<< * cv_means=dvec_field_to_list(c_results.CVMeans), * cv_sds=dvec_field_to_list(c_results.CVSDs)) */ - __pyx_t_2 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(__pyx_v_c_results.Converged); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 685, __pyx_L1_error) + __pyx_t_2 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_bool_3e___(__pyx_v_c_results.Converged); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 850, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_converged, __pyx_t_2) < 0) __PYX_ERR(0, 679, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_converged, __pyx_t_2) < 0) __PYX_ERR(0, 844, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "l0learn/interface.pyx":686 + /* "l0learn/interface.pyx":851 * intercepts=c_results.Intercept, * converged=c_results.Converged, * cv_means=dvec_field_to_list(c_results.CVMeans), # <<<<<<<<<<<<<< * cv_sds=dvec_field_to_list(c_results.CVSDs)) * return results */ - __pyx_t_2 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_c_results.CVMeans); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 686, __pyx_L1_error) + __pyx_t_2 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_c_results.CVMeans); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 851, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_cv_means, __pyx_t_2) < 0) __PYX_ERR(0, 679, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_cv_means, __pyx_t_2) < 0) __PYX_ERR(0, 844, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "l0learn/interface.pyx":687 + /* "l0learn/interface.pyx":852 * converged=c_results.Converged, * cv_means=dvec_field_to_list(c_results.CVMeans), * cv_sds=dvec_field_to_list(c_results.CVSDs)) # <<<<<<<<<<<<<< * return results * */ - __pyx_t_2 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_c_results.CVSDs); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 687, __pyx_L1_error) + __pyx_t_2 = __pyx_f_7l0learn_6cyarma_dvec_field_to_list(__pyx_v_c_results.CVSDs); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 852, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_cv_sds, __pyx_t_2) < 0) __PYX_ERR(0, 679, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_cv_sds, __pyx_t_2) < 0) __PYX_ERR(0, 844, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "l0learn/interface.pyx":679 + /* "l0learn/interface.pyx":844 * Highs=numpy_to_dvec_d(highs)) * * results = CVFitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty}, # <<<<<<<<<<<<<< * lambda_0=c_results.Lambda0, * gamma=c_results.Lambda12, */ - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 679, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 844, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_results = __pyx_t_2; __pyx_t_2 = 0; - /* "l0learn/interface.pyx":688 + /* "l0learn/interface.pyx":853 * cv_means=dvec_field_to_list(c_results.CVMeans), * cv_sds=dvec_field_to_list(c_results.CVSDs)) * return results # <<<<<<<<<<<<<< @@ -9428,7 +9438,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __pyx_r = __pyx_v_results; goto __pyx_L0; - /* "l0learn/interface.pyx":542 + /* "l0learn/interface.pyx":549 * * * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< @@ -9448,7 +9458,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p __Pyx_XDECREF(__pyx_v_check); __Pyx_XDECREF(__pyx_v_auto_lambda); __Pyx_XDECREF(__pyx_v_with_bounds); - __Pyx_XDECREF(__pyx_v__); + __Pyx_XDECREF(__pyx_v_n); __Pyx_XDECREF(__pyx_v_p); __Pyx_XDECREF(__pyx_v_results); __Pyx_XDECREF(__pyx_v_y); @@ -9465,7 +9475,7 @@ static PyObject *__pyx_pf_7l0learn_9interface_4cvfit(CYTHON_UNUSED PyObject *__p return __pyx_r; } -/* "l0learn/interface.pyx":691 +/* "l0learn/interface.pyx":856 * * * cdef fitmodel _L0LearnFit_dense(const dmat& X, # <<<<<<<<<<<<<< @@ -9478,7 +9488,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_dense(arma::dmat const & __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_L0LearnFit_dense", 0); - /* "l0learn/interface.pyx":717 + /* "l0learn/interface.pyx":882 * const dvec &Lows, * const dvec &Highs): * return L0LearnFit[dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< @@ -9488,7 +9498,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_dense(arma::dmat const & __pyx_r = L0LearnFit(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); goto __pyx_L0; - /* "l0learn/interface.pyx":691 + /* "l0learn/interface.pyx":856 * * * cdef fitmodel _L0LearnFit_dense(const dmat& X, # <<<<<<<<<<<<<< @@ -9502,7 +9512,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_dense(arma::dmat const & return __pyx_r; } -/* "l0learn/interface.pyx":722 +/* "l0learn/interface.pyx":887 * * * cdef fitmodel _L0LearnFit_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< @@ -9515,7 +9525,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_sparse(arma::sp_dmat con __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_L0LearnFit_sparse", 0); - /* "l0learn/interface.pyx":748 + /* "l0learn/interface.pyx":913 * const dvec &Lows, * const dvec &Highs): * return L0LearnFit[sp_dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< @@ -9525,7 +9535,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_sparse(arma::sp_dmat con __pyx_r = L0LearnFit(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); goto __pyx_L0; - /* "l0learn/interface.pyx":722 + /* "l0learn/interface.pyx":887 * * * cdef fitmodel _L0LearnFit_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< @@ -9539,7 +9549,7 @@ static fitmodel __pyx_f_7l0learn_9interface__L0LearnFit_sparse(arma::sp_dmat con return __pyx_r; } -/* "l0learn/interface.pyx":753 +/* "l0learn/interface.pyx":918 * * * cdef cvfitmodel _L0LearnCV_dense(const dmat& X, # <<<<<<<<<<<<<< @@ -9552,7 +9562,7 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_dense(arma::dmat const __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_L0LearnCV_dense", 0); - /* "l0learn/interface.pyx":781 + /* "l0learn/interface.pyx":946 * const dvec &Lows, * const dvec &Highs): * return L0LearnCV[dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< @@ -9562,7 +9572,7 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_dense(arma::dmat const __pyx_r = L0LearnCV(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_nfolds, __pyx_v_seed, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); goto __pyx_L0; - /* "l0learn/interface.pyx":753 + /* "l0learn/interface.pyx":918 * * * cdef cvfitmodel _L0LearnCV_dense(const dmat& X, # <<<<<<<<<<<<<< @@ -9576,7 +9586,7 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_dense(arma::dmat const return __pyx_r; } -/* "l0learn/interface.pyx":786 +/* "l0learn/interface.pyx":951 * * * cdef cvfitmodel _L0LearnCV_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< @@ -9589,7 +9599,7 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_sparse(arma::sp_dmat co __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_L0LearnCV_sparse", 0); - /* "l0learn/interface.pyx":814 + /* "l0learn/interface.pyx":979 * const dvec &Lows, * const dvec &Highs): * return L0LearnCV[sp_dmat](X, y, Loss, Penalty, Algorithm, NnzStopNum, G_ncols, G_nrows, Lambda2Max, Lambda2Min, PartialSort, # <<<<<<<<<<<<<< @@ -9599,7 +9609,7 @@ static cvfitmodel __pyx_f_7l0learn_9interface__L0LearnCV_sparse(arma::sp_dmat co __pyx_r = L0LearnCV(__pyx_v_X, __pyx_v_y, __pyx_v_Loss, __pyx_v_Penalty, __pyx_v_Algorithm, __pyx_v_NnzStopNum, __pyx_v_G_ncols, __pyx_v_G_nrows, __pyx_v_Lambda2Max, __pyx_v_Lambda2Min, __pyx_v_PartialSort, __pyx_v_MaxIters, __pyx_v_rtol, __pyx_v_atol, __pyx_v_ActiveSet, __pyx_v_ActiveSetNum, __pyx_v_MaxNumSwaps, __pyx_v_ScaleDownFactor, __pyx_v_ScreenSize, __pyx_v_LambdaU, __pyx_v_Lambdas, __pyx_v_nfolds, __pyx_v_seed, __pyx_v_ExcludeFirstK, __pyx_v_Intercept, __pyx_v_withBounds, __pyx_v_Lows, __pyx_v_Highs); goto __pyx_L0; - /* "l0learn/interface.pyx":786 + /* "l0learn/interface.pyx":951 * * * cdef cvfitmodel _L0LearnCV_sparse(const sp_dmat& X, # <<<<<<<<<<<<<< @@ -11333,6 +11343,8 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_u_CDPSI, __pyx_k_CDPSI, sizeof(__pyx_k_CDPSI), 0, 1, 0, 1}, {&__pyx_n_s_CLASSIFICATION_LOSS, __pyx_k_CLASSIFICATION_LOSS, sizeof(__pyx_k_CLASSIFICATION_LOSS), 0, 0, 1, 1}, {&__pyx_n_s_CVFitModel, __pyx_k_CVFitModel, sizeof(__pyx_k_CVFitModel), 0, 0, 1, 1}, + {&__pyx_kp_u_Computes_the_regularization_pat, __pyx_k_Computes_the_regularization_pat, sizeof(__pyx_k_Computes_the_regularization_pat), 0, 1, 0, 0}, + {&__pyx_kp_u_Computes_the_regularization_pat_2, __pyx_k_Computes_the_regularization_pat_2, sizeof(__pyx_k_Computes_the_regularization_pat_2), 0, 1, 0, 0}, {&__pyx_n_u_D, __pyx_k_D, sizeof(__pyx_k_D), 0, 1, 0, 1}, {&__pyx_n_s_Dict, __pyx_k_Dict, sizeof(__pyx_k_Dict), 0, 0, 1, 1}, {&__pyx_kp_u_Expected_all_values_of_lambda_gr, __pyx_k_Expected_all_values_of_lambda_gr, sizeof(__pyx_k_Expected_all_values_of_lambda_gr), 0, 1, 0, 0}, @@ -11350,6 +11362,7 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_SUPPORTED_ALGORITHM, __pyx_k_SUPPORTED_ALGORITHM, sizeof(__pyx_k_SUPPORTED_ALGORITHM), 0, 0, 1, 1}, {&__pyx_n_s_SUPPORTED_LOSS, __pyx_k_SUPPORTED_LOSS, sizeof(__pyx_k_SUPPORTED_LOSS), 0, 0, 1, 1}, {&__pyx_n_s_SUPPORTED_PENALTY, __pyx_k_SUPPORTED_PENALTY, sizeof(__pyx_k_SUPPORTED_PENALTY), 0, 0, 1, 1}, + {&__pyx_n_s_Sequence, __pyx_k_Sequence, sizeof(__pyx_k_Sequence), 0, 0, 1, 1}, {&__pyx_n_u_SquaredError, __pyx_k_SquaredError, sizeof(__pyx_k_SquaredError), 0, 1, 0, 1}, {&__pyx_n_u_SquaredHinge, __pyx_k_SquaredHinge, sizeof(__pyx_k_SquaredHinge), 0, 1, 0, 1}, {&__pyx_n_s_Union, __pyx_k_Union, sizeof(__pyx_k_Union), 0, 0, 1, 1}, @@ -11388,6 +11401,7 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_cv_means, __pyx_k_cv_means, sizeof(__pyx_k_cv_means), 0, 0, 1, 1}, {&__pyx_n_s_cv_sds, __pyx_k_cv_sds, sizeof(__pyx_k_cv_sds), 0, 0, 1, 1}, {&__pyx_n_s_cvfit, __pyx_k_cvfit, sizeof(__pyx_k_cvfit), 0, 0, 1, 1}, + {&__pyx_kp_u_cvfit_line_549, __pyx_k_cvfit_line_549, sizeof(__pyx_k_cvfit_line_549), 0, 1, 0, 0}, {&__pyx_n_s_diff, __pyx_k_diff, sizeof(__pyx_k_diff), 0, 0, 1, 1}, {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1}, {&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1}, @@ -11431,6 +11445,7 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_first_value, __pyx_k_first_value, sizeof(__pyx_k_first_value), 0, 0, 1, 1}, {&__pyx_n_s_fit, __pyx_k_fit, sizeof(__pyx_k_fit), 0, 0, 1, 1}, {&__pyx_n_s_fit_check, __pyx_k_fit_check, sizeof(__pyx_k_fit_check), 0, 0, 1, 1}, + {&__pyx_kp_u_fit_line_261, __pyx_k_fit_line_261, sizeof(__pyx_k_fit_line_261), 0, 1, 0, 0}, {&__pyx_n_s_float64, __pyx_k_float64, sizeof(__pyx_k_float64), 0, 0, 1, 1}, {&__pyx_n_s_gamma, __pyx_k_gamma, sizeof(__pyx_k_gamma), 0, 0, 1, 1}, {&__pyx_n_s_gamma_max, __pyx_k_gamma_max, sizeof(__pyx_k_gamma_max), 0, 0, 1, 1}, @@ -11608,17 +11623,17 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_GIVEREF(__pyx_tuple__14); __pyx_codeobj__15 = (PyObject*)__Pyx_PyCode_New(24, 0, 33, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__14, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_fit, 261, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__15)) __PYX_ERR(0, 261, __pyx_L1_error) - /* "l0learn/interface.pyx":542 + /* "l0learn/interface.pyx":549 * * * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< * y: np.ndarray, * loss: str = "SquaredError", */ - __pyx_tuple__16 = PyTuple_Pack(37, __pyx_n_s_X, __pyx_n_s_y, __pyx_n_s_loss, __pyx_n_s_penalty, __pyx_n_s_algorithm, __pyx_n_s_num_folds, __pyx_n_s_seed, __pyx_n_s_max_support_size, __pyx_n_s_num_lambda, __pyx_n_s_num_gamma, __pyx_n_s_gamma_max, __pyx_n_s_gamma_min, __pyx_n_s_partial_sort, __pyx_n_s_max_iter, __pyx_n_s_rtol, __pyx_n_s_atol, __pyx_n_s_active_set, __pyx_n_s_active_set_num, __pyx_n_s_max_swaps, __pyx_n_s_scale_down_factor, __pyx_n_s_screen_size, __pyx_n_s_lambda_grid, __pyx_n_s_exclude_first_k, __pyx_n_s_intercept, __pyx_n_s_lows, __pyx_n_s_highs, __pyx_n_s_check, __pyx_n_s_auto_lambda, __pyx_n_s_with_bounds, __pyx_n_s__11, __pyx_n_s_p, __pyx_n_s_c_lambda_grid, __pyx_n_s_c_loss, __pyx_n_s_c_penalty, __pyx_n_s_c_algorithim, __pyx_n_s_c_results, __pyx_n_s_results); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 542, __pyx_L1_error) + __pyx_tuple__16 = PyTuple_Pack(37, __pyx_n_s_X, __pyx_n_s_y, __pyx_n_s_loss, __pyx_n_s_penalty, __pyx_n_s_algorithm, __pyx_n_s_num_folds, __pyx_n_s_seed, __pyx_n_s_max_support_size, __pyx_n_s_num_lambda, __pyx_n_s_num_gamma, __pyx_n_s_gamma_max, __pyx_n_s_gamma_min, __pyx_n_s_partial_sort, __pyx_n_s_max_iter, __pyx_n_s_rtol, __pyx_n_s_atol, __pyx_n_s_active_set, __pyx_n_s_active_set_num, __pyx_n_s_max_swaps, __pyx_n_s_scale_down_factor, __pyx_n_s_screen_size, __pyx_n_s_lambda_grid, __pyx_n_s_exclude_first_k, __pyx_n_s_intercept, __pyx_n_s_lows, __pyx_n_s_highs, __pyx_n_s_check, __pyx_n_s_auto_lambda, __pyx_n_s_with_bounds, __pyx_n_s_n, __pyx_n_s_p, __pyx_n_s_c_lambda_grid, __pyx_n_s_c_loss, __pyx_n_s_c_penalty, __pyx_n_s_c_algorithim, __pyx_n_s_c_results, __pyx_n_s_results); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 549, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__16); __Pyx_GIVEREF(__pyx_tuple__16); - __pyx_codeobj__17 = (PyObject*)__Pyx_PyCode_New(26, 0, 37, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_cvfit, 542, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__17)) __PYX_ERR(0, 542, __pyx_L1_error) + __pyx_codeobj__17 = (PyObject*)__Pyx_PyCode_New(26, 0, 37, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_l0learn_interface_pyx, __pyx_n_s_cvfit, 549, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__17)) __PYX_ERR(0, 549, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; @@ -12027,7 +12042,7 @@ if (!__Pyx_RefNanny) { * from scipy.sparse import csc_matrix * from warnings import warn # <<<<<<<<<<<<<< * - * from typing import Union, Optional, List, Dict, Any + * from typing import Union, Optional, List, Dict, Any, Sequence */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); @@ -12046,11 +12061,11 @@ if (!__Pyx_RefNanny) { /* "l0learn/interface.pyx":8 * from warnings import warn * - * from typing import Union, Optional, List, Dict, Any # <<<<<<<<<<<<<< + * from typing import Union, Optional, List, Dict, Any, Sequence # <<<<<<<<<<<<<< * * from l0learn.cyarma cimport dmat, sp_dmat, numpy_to_sp_dmat_d, numpy_to_dmat_d, dvec, numpy_to_dvec_d, \ */ - __pyx_t_1 = PyList_New(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) + __pyx_t_1 = PyList_New(6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_Union); __Pyx_GIVEREF(__pyx_n_s_Union); @@ -12067,6 +12082,9 @@ if (!__Pyx_RefNanny) { __Pyx_INCREF(__pyx_n_s_Any); __Pyx_GIVEREF(__pyx_n_s_Any); PyList_SET_ITEM(__pyx_t_1, 4, __pyx_n_s_Any); + __Pyx_INCREF(__pyx_n_s_Sequence); + __Pyx_GIVEREF(__pyx_n_s_Sequence); + PyList_SET_ITEM(__pyx_t_1, 5, __pyx_n_s_Sequence); __pyx_t_2 = __Pyx_Import(__pyx_n_s_typing, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -12090,6 +12108,10 @@ if (!__Pyx_RefNanny) { __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_Any, __pyx_t_1) < 0) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Sequence); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Sequence, __pyx_t_1) < 0) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "l0learn/interface.pyx":13 @@ -12239,44 +12261,44 @@ if (!__Pyx_RefNanny) { if (PyDict_SetItem(__pyx_d, __pyx_n_s_fit, __pyx_t_1) < 0) __PYX_ERR(0, 261, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":566 + /* "l0learn/interface.pyx":573 * exclude_first_k: int = 0, * intercept: bool = True, * lows: Union[np.ndarray, float] = -float('inf'), # <<<<<<<<<<<<<< * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.CVFitModel: - * + * """ Computes the regularization path for the specified loss function and penalty function and performs K-fold */ - __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 566, __pyx_L1_error) - __pyx_t_1 = PyFloat_FromDouble((-__pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 566, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 573, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble((-__pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 573, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_k__4 = __pyx_t_1; __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":567 + /* "l0learn/interface.pyx":574 * intercept: bool = True, * lows: Union[np.ndarray, float] = -float('inf'), * highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.CVFitModel: # <<<<<<<<<<<<<< - * - * check = _fit_check(X=X, + * """ Computes the regularization path for the specified loss function and penalty function and performs K-fold + * cross-validation. */ - __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 567, __pyx_L1_error) - __pyx_t_1 = PyFloat_FromDouble(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 567, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 574, __pyx_L1_error) + __pyx_t_1 = PyFloat_FromDouble(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 574, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_k__5 = __pyx_t_1; __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; - /* "l0learn/interface.pyx":542 + /* "l0learn/interface.pyx":549 * * * def cvfit(X: Union[np.ndarray, csc_matrix], # <<<<<<<<<<<<<< * y: np.ndarray, * loss: str = "SquaredError", */ - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_5cvfit, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 542, __pyx_L1_error) + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7l0learn_9interface_5cvfit, NULL, __pyx_n_s_l0learn_interface); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 549, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_cvfit, __pyx_t_1) < 0) __PYX_ERR(0, 542, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_cvfit, __pyx_t_1) < 0) __PYX_ERR(0, 549, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "l0learn/interface.pyx":1 @@ -12284,8 +12306,10 @@ if (!__Pyx_RefNanny) { * from libcpp.string cimport string * from libcpp cimport bool as cppbool */ - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_kp_u_fit_line_261, __pyx_kp_u_Computes_the_regularization_pat) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_kp_u_cvfit_line_549, __pyx_kp_u_Computes_the_regularization_pat_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; diff --git a/python/l0learn/interface.pyx b/python/l0learn/interface.pyx index f980add..0c7ea9a 100644 --- a/python/l0learn/interface.pyx +++ b/python/l0learn/interface.pyx @@ -5,7 +5,7 @@ import numpy as np from scipy.sparse import csc_matrix from warnings import warn -from typing import Union, Optional, List, Dict, Any +from typing import Union, Optional, List, Dict, Any, Sequence from l0learn.cyarma cimport dmat, sp_dmat, numpy_to_sp_dmat_d, numpy_to_dmat_d, dvec, numpy_to_dvec_d, \ sp_dmat_field_to_list, dvec_field_to_list @@ -68,7 +68,7 @@ def _fit_check(X: Union[np.ndarray, csc_matrix], max_swaps: int, scale_down_factor: float, screen_size: int, - lambda_grid: Union[List[List[float]], None], + lambda_grid: Union[List[Sequence[float]], None], exclude_first_k: int, intercept: bool, lows: Union[np.ndarray, float], @@ -277,7 +277,7 @@ def fit(X: Union[np.ndarray, csc_matrix], max_swaps: int = 100, scale_down_factor: float = 0.8, screen_size: int = 1000, - lambda_grid: Optional[List[List[float]]] = None, + lambda_grid: Optional[List[Sequence[float]]] = None, exclude_first_k: int = 0, intercept: bool = True, lows: Union[np.ndarray, float] = -float('inf'), @@ -424,10 +424,17 @@ def fit(X: Union[np.ndarray, csc_matrix], Returns ------- + fit_model : l0learn.models.FitModel + FitModel instance containing all relevant information from the solution path. + See Also + ------- + l0learn.cvfit + l0learn.models.FitModel Examples -------- + >>>fit_model = l0learn.fit(X, y, penalty="L0", max_support_size=20) """ check = _fit_check(X=X, y=y, @@ -560,11 +567,169 @@ def cvfit(X: Union[np.ndarray, csc_matrix], max_swaps: int = 100, scale_down_factor: float = 0.8, screen_size: int = 1000, - lambda_grid: Optional[List[List[float]]] = None, + lambda_grid: Optional[List[Sequence[float]]] = None, exclude_first_k: int = 0, intercept: bool = True, lows: Union[np.ndarray, float] = -float('inf'), highs: Union[np.ndarray, float] = +float('inf'),) -> l0learn.models.CVFitModel: + """ Computes the regularization path for the specified loss function and penalty function and performs K-fold + cross-validation. + + Parameters + ---------- + X : np.ndarray or csc_matrix of shape (N, P) + Data Matrix where rows of X are observations and columns of X are features + + y : np.ndarray of shape (P) + The response vector where y[i] corresponds to X[i, :] + For classification, a binary vector (-1, 1) is requried . + + loss : str + The loss function. Currently supports the choices: + "SquaredError" (for regression), + "Logistic" (for logistic regression), and + "SquaredHinge" (for smooth SVM). + + penalty : str + The type of regularization. + This can take either one of the following choices: + "L0", + "L0L2", and + "L0L1" + + algorithm : str + The type of algorithm used to minimize the objective function. Currently "CD" and "CDPSI" are are supported. + "CD" is a variant of cyclic coordinate descent and runs very fast. "CDPSI" performs local combinatorial search + on top of CD and typically achieves higher quality solutions (at the expense of increased running time). + + num_folds : int + Must be greater than 1 and less than N (number of . + The number of folds for cross-validation. + + max_support_size : int + Must be greater than 0. + The maximum support size at which to terminate the regularization path. We recommend setting this to a small + fraction of min(n,p) (e.g. 0.05 * min(n,p)) as L0 regularization typically selects a small portion of non-zeros. + + num_lambda : int, optional + The number of lambda values to select in the regularization path. + This value must be None if lambda_grid is supplied.When supplied, must be greater than 0. + Note: lambda is the regularization parameter corresponding to the L0 norm. + + num_gamma: int, optional + The number of gamma values to select in the regularization path. + This value must be None if lambda_grid is supplied. When supplied, must be greater than 0. + Note: gamma is the regularization parameter corresponding to L1 or L2, depending on the chosen penalty). + + gamma_max : float + The maximum value of gamma when using the L0L2 penalty. + This value must be greater than 0. + + Note: For the L0L1 penalty this is automatically selected. + + gamma_min : float + The minimum value of Gamma when using the L0L2 penalty. + This value must be greater than 0 but less than gamma_max. + Note: For the L0L1 penalty, the minimum value of gamma in the grid is set to gammaMin * gammaMax. + + partial_sort : bool + If TRUE partial sorting will be used for sorting the coordinates to do greedy cycling (see our paper for + for details). Otherwise, full sorting is used. #TODO: Add link for paper + + max_iter : int + The maximum number of iterations (full cycles) for CD per grid point. The algorithm may not use the full number + of iteration per grid point if convergence is found (defined by rtol and atol parameter) + Must be greater than 0 + + rtol : float + The relative tolerance which decides when to terminate optimization as based on the relative change in the + objective between iterations. + Must be greater than 0 and less than 1. + + atol : float + The absolute tolerance which decides when to terminate optimization as based on the absolute L2 norm of the + residuals + Must be greater than 0 + + active_set : bool + If TRUE, performs active set updates. (see our paper for for details). #TODO: Add link for paper + + active_set_num : int + The number of consecutive times a support should appear before declaring support stabilization. + (see our paper for for details). #TODO: Add link for paper + + Must be greater than 0. + + max_swaps : int + The maximum number of swaps used by CDPSI for each grid point. + Must be greater than 0. Ignored by CD algorithims. + + scale_down_factor : float + Roughly amount each lambda value is scaled by between grid points. Larger values lead to closer lambdas and + typically to smaller gaps between the support sizes. + + For details, see our paper - Section 5 on Adaptive Selection of Tuning Parameters). #TODO: Add link for paper + + Must be greater than 0 and less than 1 (strictly for both.) + + screen_size : int + The number of coordinates to cycle over when performing initial correlation screening. #TODO: Add link for paper + + Must be greater than 0 and less than number of columns of X. + + lambda_grid : list of list of floats + A grid of lambda values to use in computing the regularization path. This is by default an empty list + and is ignored. When specified, lambda_grid should be a list of list of floats, where the ith element + (corresponding to the ith gamma) should be a decreasing sequence of lambda values. The length of this sequence + is directly the number of lambdas to be tried for that gamma. + + In the the "L0" penalty case, lambda_grid should be a list of 1. + In the "L0LX" penalty cases, lambda_grid can be a list of any length. The length of lambda_grid will be the + number of gamma values tried. + + See the example notebook for more details. + + Note: When lambda_grid is supplied, num_gamma and num_lambda must be None. + + exclude_first_k : int + The first exclude_first_k features in X will be excluded from variable selection. In other words, the first + exclude_first_k variables will not be included in the L0-norm penalty however they will be included in the + L1 or L2 norm penalties, if they are specified. + + Must be a positive integer less than the columns of X. + + intercept : bool + If False, no intercept term is included or fit in the regularization path + Intercept terms are not regularized by L0 or L1/L2. + + lows : np array or float + Lower bounds for coefficients. Either a scalar for all coefficients to have the same bound or a vector of + size p (number of columns of X) where lows[i] is the lower bound for coefficient i. + + Lower bounds can not be above 0 (i.e. we can not specify that all coefficients must be larger than a > 0). + Lower bounds can be set to 0 iff the corresponding upper bound for that coefficient is also not 0. + + highs : np array or float + Upper bounds for coefficients. Either a scalar for all coefficients to have the same bound or a vector of + size p (number of columns of X) where highs[i] is the upper bound for coefficient i. + + Upper bounds can not be below 0 (i.e. we can not specify that all coefficients must be smaller than a < 0). + Upper bounds can be set to 0 iff the corresponding lower bound for that coefficient is also not 0. + + Returns + ------- + fit_model : l0learn.models.FitModel + FitModel instance containing all relevant information from the solution path. + + See Also + ------- + l0learn.cvfit + l0learn.models.FitModel + + Examples + -------- + >>>fit_model = l0learn.fit(X, y, penalty="L0", max_support_size=20) + """ check = _fit_check(X=X, y=y, @@ -605,10 +770,10 @@ def cvfit(X: Union[np.ndarray, csc_matrix], lows = check['lows'] highs = check['highs'] - _, p = X.shape + n, p = X.shape - if not isinstance(num_folds, int) or num_folds < 2 or num_folds > p: - raise ValueError(f"expected num_folds parameter to be a positive integer less than {p}, but got {num_folds}") + if not isinstance(num_folds, int) or num_folds < 2 or num_folds > n: + raise ValueError(f"expected num_folds parameter to be a positive integer less than {n}, but got {num_folds}") cdef vector[vector[double]] c_lambda_grid = lambda_grid diff --git a/python/l0learn/models.py b/python/l0learn/models.py index 90c97e2..a690a73 100644 --- a/python/l0learn/models.py +++ b/python/l0learn/models.py @@ -105,7 +105,7 @@ def squared_error(y_true: np.ndarray, coeffs: Optional[csc_matrix] = None, l0: Union[float, Sequence[float]] = 0, l1: Union[float, Sequence[float]] = 0, - l2: Union[float, Sequence[float]] = 0) -> Tuple[np.ndarray, np.ndarray]: + l2: Union[float, Sequence[float]] = 0) -> np.ndarray: """ Calculates Squared Error loss of solution with optional regularization @@ -120,7 +120,8 @@ def squared_error(y_true: np.ndarray, Returns ------- - squared_error = (m, k) + squared_error : np.ndarray + Shape (,) if y_pred is 1D or = (k,) if y_pred is 2D """ reg_loss = 0 @@ -141,7 +142,28 @@ def logistic_loss(y_true: np.ndarray, l0: float = 0, l1: float = 0, l2: float = 0, - eps: float = 1e-15) -> Union[float, np.ndarray]: + eps: float = 1e-15) -> np.ndarray: + """ + Calculates Logistic Loss of solution with optional regularization + + Parameters + ---------- + y_true : np.ndarray of shape (m, ) + y_pred : np.ndarray of shape (m, ) or (m, k) + coeffs : np.ndarray of shape (p, k), optional + l0 : float or sequence of floats of shape (l) + l1 : float or sequence of floats of shape (l) + l2 : float or sequence of floats of shape (l) + eps: float, default=1e-15 + Logistic loss is undefined for p=0 or p=1, so probabilities are clipped to max(eps, min(1 - eps, p)). + + + Returns + ------- + logistic_loss : np.ndarray + Shape (,) if y_pred is 1D or = (k,) if y_pred is 2D + + """ # TODO: Check this formula. If there is an error here, there might be an error in the C++ code for Logistic. reg_loss = 0 @@ -167,7 +189,25 @@ def squared_hinge_loss(y_true: np.ndarray, coeffs: Optional[csc_matrix] = None, l0: float = 0, l1: float = 0, - l2: float = 0, ) -> Union[float, np.ndarray]: + l2: float = 0, ) -> np.ndarray: + """ + Calculates Logistic Loss of solution with optional regularization + + Parameters + ---------- + y_true : np.ndarray of shape (m, ) + y_pred : np.ndarray of shape (m, ) or (m, k) + coeffs : np.ndarray of shape (p, k), optional + l0 : float or sequence of floats of shape (l) + l1 : float or sequence of floats of shape (l) + l2 : float or sequence of floats of shape (l) + + Returns + ------- + squared_hinge_loss : np.ndarray + Shape (,) if y_pred is 1D or = (k,) if y_pred is 2D + + """ # TODO: Check this formula. If there is an error here, there might be an error in the C++ code for Logistic. reg_loss = 0 @@ -320,9 +360,8 @@ def coeff(self, def characteristics(self, lambda_0: Optional[float] = None, gamma: Optional[float] = None) -> pd.DataFrame: - """ Formats the characteristics of the solutions that correspond to the specificed `lambda_0` and `gamma` as a + """ Formats the characteristics of the solutions that correspond to the specified `lambda_0` and `gamma` as a pandas DataFrame where each row is a solution in the regularization path. - The DataFrame is in of solutions being found. Parameters ---------- @@ -395,7 +434,7 @@ def characteristics(self, return self._characteristics_as_pandas_table(new_data=(gamma, lambda_0, support_size, intercepts, converged)) - def plot(self, gamma: float = 0, show_lines: bool = False, **kwargs): + def plot(self, gamma: float = 0, show_lines: bool = False, include_legend: bool = True, **kwargs): """ Plots the regularization path for a given gamma. Parameters @@ -411,6 +450,12 @@ def plot(self, gamma: float = 0, show_lines: bool = False, **kwargs): Key Word arguments passed to matplotlib.pyplot + Defaults for legends: + bbox_to_anchor -> (1.05, 1) + loc -> 2 + borderaxespad -> 0. + ncol -> Size of largest support divided by 10 + Notes ----- If the solutions with the same support size exist in a regularization path, the first support size is plotted. @@ -429,9 +474,10 @@ def plot(self, gamma: float = 0, show_lines: bool = False, **kwargs): for col in range(p): rows, cols, values = find(gamma_to_plot[:, col]) support_size = len(rows) - if support_size in seen_supports or not support_size: + if support_size in seen_supports: warnings.warn(f"Duplicate solution seen at support size {support_size}. Plotting only first solution") continue + seen_supports.add(support_size) seen_coeffs.update(rows) # For each coefficient seen in regularization path, record value of each coefficient over @@ -454,6 +500,9 @@ def plot(self, gamma: float = 0, show_lines: bool = False, **kwargs): plt.ylabel("Coefficient Value") plt.xlabel("Support Size") + if include_legend: + plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0., ncol=len(seen_coeffs)//10) + return ax def score(self, @@ -689,7 +738,7 @@ def gen_synthetic(n: int, else: sd_e = np.sqrt(np.var(X @ B) / snr) - e = np.random.normal(n, scale=sd_e) + e = np.random.normal(size=n, scale=sd_e) y = X @ B + e + b0 return {"X": X, "y": y, "B": B, "e": e, "b0": b0} @@ -733,7 +782,7 @@ def gen_synthetic_high_corr(n: int, seed : int The seed used for randomly generating the data rho : float - The threshold for setting values to 0. if |X(i, j)| < rho => X(i, j) <- 0 + The threshold for setting values to 0. if |X[i, j]| < rho => X[i, j] <- 0 b0 : float intercept value to scale y by. snr : float @@ -776,7 +825,7 @@ def gen_synthetic_high_corr(n: int, else: sd_e = np.sqrt(np.var(X @ B) / snr) - e = np.random.normal(n, scale=sd_e) + e = np.random.normal(size=n, scale=sd_e) y = X @ B + e + b0 return {"X": X, "y": y, "B": B, "e": e, "b0": b0} @@ -807,28 +856,37 @@ def gen_synthetic_logistic(n: int, ---------- n : int Number of samples + p : int Number of features + k : int Number of non-zeros in true vector of coefficients + seed : int The seed used for randomly generating the data + rho : float - The threshold for setting values to 0. if |X(i, j)| > rho => X(i, j) <- 0 + The threshold for setting values to 0. if |X[i, j]| > rho => X[i, j] <- 0 + b0 : float The intercept value to scale the log odds of y by. As b0 -> +inf, y will contain more 1s As b0 -> -inf, y will contain more 0s + s : float Signal-to-noise parameter. As s -> +Inf, the data generated becomes linearly separable. + mu : float, optional The mean for drawing from the Multivariate Normal Distribution. A scalar of vector of length p. If mu and base_cor are not specified, will be drawn from N(0, 1) using gen_synthetic. If mu and base_cor are specified will be drawn from multivariate_normal(mu, sigma) see gen_synthetic_high_corr - base_cor + + base_cor : float The base correlation, A in [i, j] = A^|i-j|. If mu and base_cor are not specified, will be drawn from N(0, 1) If mu and base_cor are specified will be drawn from multivariate_normal(mu, sigma) see gen_synthetic_high_corr + Returns ------- data : dict diff --git a/python/sparse.ipynb b/python/sparse.ipynb index e502f46..6c166d1 100644 --- a/python/sparse.ipynb +++ b/python/sparse.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 6, + "execution_count": 1, "metadata": { "pycharm": { "is_executing": false @@ -12,218 +12,934 @@ "source": [ "import numpy as np\n", "from scipy.sparse import csc_matrix\n", - "from l0learn.models import FitModel" + "import l0learn" ] }, { "cell_type": "code", - "execution_count": 7, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "pycharm": { - "is_executing": false, - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "def sample_FitModel(loss: str = 'SquaredError', intercept: bool = True, penalty: str = 'L0L1'):\n", - " i = intercept\n", - " beta1 = csc_matrix([[0, 0],\n", - " [1, 2]])\n", - " beta2 = csc_matrix([[0],\n", - " [3]])\n", - " beta3 = csc_matrix([[0, 0, 0],\n", - " [4, 5, 6]])\n", - "\n", - " return FitModel(settings={'loss': loss, 'intercept': intercept, 'penalty': penalty},\n", - " lambda_0=[[10, 5], [10], [10, 5, 0]],\n", - " gamma=[2, 1, 0],\n", - " support_size=[[0, 1], [3], [4, 5, 6]],\n", - " coeffs=[beta1, beta2, beta3],\n", - " intercepts=[[-1*i, -2*i], [-3*i], [-4*i, -5*i, -6*i]],\n", - " converged=[[True, True], [False], [True, False, True]])" - ] - }, - { - "cell_type": "code", - "execution_count": 9, + "execution_count": 56, "metadata": {}, "outputs": [], "source": [ - "f = sample_FitModel()" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[1, 2, 3, 4, 5, 6],\n", - " [1, 2, 3, 4, 5, 6]])" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.tile(np.arange(1, 7), (2, 1))" + "\n", + "np.random.seed(4) # fix the seed to get a reproducible result\n", + "n, p, k = 500, 1000, 10\n", + "X = np.random.normal(size=(n, p))\n", + "B = np.zeros(p)\n", + "B[:k] = 1\n", + "e = np.random.normal(size=(n,))/2\n", + "y = X@B + e" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 53, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([[-1, -2, -3, -4, -5, -6],\n", - " [ 0, 0, 0, 0, 0, 0],\n", - " [ 1, 2, 3, 4, 5, 6]])" + "(0, 500)" ] }, - "execution_count": 19, + "execution_count": 53, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "f.coeff().toarray()" + "np.unravel_index(np.argmin(np.abs(X + 1.7194)), X.shape)" ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 49, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([[1., 2., 3., 4., 5., 6.]])" + "False" ] }, - "execution_count": 25, + "execution_count": 49, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "f.predict(np.array([[1, 2]]))" + "not (X.flags.f_contiguous or X.flags.owndata)" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 58, "metadata": {}, "outputs": [ { "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
l0support_sizeinterceptconverged
00.0795460-0.156704True
10.0787501-0.147182True
20.0658622-0.161024True
30.0504643-0.002500True
40.0445175-0.041058True
50.0416727-0.058013True
60.0397058-0.061685True
70.032715100.002157True
80.00021211-0.000857True
90.00018712-0.002161True
100.00017813-0.001199True
110.00015915-0.007959True
120.00014116-0.009603True
130.00013318-0.015697True
140.00013221-0.012732True
\n", + "
" + ], "text/plain": [ - "array([[0., 0., 0., 0., 0., 0.],\n", - " [0., 0., 0., 0., 0., 0.]])" + "FitModel({'loss': 'SquaredError', 'intercept': True, 'penalty': 'L0'})" ] }, - "execution_count": 11, + "execution_count": 58, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "f.predict(np.ones([2,2]))" + "fit_model" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 57, "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "X at column 1 = 0.5000\n", + " -1.8889\n", + " -0.5859\n", + " 0.8286\n", + " -0.2622\n", + " -0.7380\n", + " 0.2591\n", + " 0.1908\n", + " 0.2588\n", + " -2.5680\n", + " 1.1428\n", + " -1.7766\n", + " -0.3098\n", + " 0.5666\n", + " 1.0566\n", + " 1.2307\n", + " 0.0474\n", + " -0.1998\n", + " -0.7337\n", + " 0.1452\n", + " 0.4838\n", + " 0.5324\n", + " 0.8432\n", + " 0.4499\n", + " -1.8477\n", + " -0.5379\n", + " -1.0892\n", + " 0.1596\n", + " 0.2531\n", + " 1.5462\n", + " 1.5877\n", + " 1.2362\n", + " 0.7071\n", + " 0.0398\n", + " -0.2925\n", + " 0.5104\n", + " -0.4558\n", + " 2.3242\n", + " 1.5085\n", + " 1.1496\n", + " 0.1538\n", + " 1.0296\n", + " 1.0332\n", + " -0.9911\n", + " -0.6222\n", + " 1.6301\n", + " -1.6879\n", + " 0.6994\n", + " 0.5250\n", + " -0.7482\n", + " 2.1634\n", + " -1.2182\n", + " -0.3143\n", + " -0.1359\n", + " 0.0358\n", + " 1.6373\n", + " 0.5623\n", + " -0.1503\n", + " 1.0821\n", + " 0.0880\n", + " -1.4195\n", + " -0.9476\n", + " 1.2908\n", + " -0.1857\n", + " -0.6444\n", + " 1.2578\n", + " 0.9470\n", + " -2.0210\n", + " -1.0287\n", + " 1.4844\n", + " -0.6175\n", + " 0.9521\n", + " 1.3697\n", + " -0.1475\n", + " 0.2178\n", + " 0.1435\n", + " 1.2622\n", + " -0.6379\n", + " 0.4418\n", + " 2.5668\n", + " -0.8739\n", + " -0.0836\n", + " 0.7807\n", + " -1.4666\n", + " 0.3183\n", + " 0.9187\n", + " -0.0080\n", + " 0.8404\n", + " 0.3050\n", + " -0.2181\n", + " -0.4265\n", + " -1.0178\n", + " -1.6794\n", + " 0.4758\n", + " -0.4668\n", + " 0.4159\n", + " 0.3365\n", + " 0.2947\n", + " 0.7806\n", + " -1.3214\n", + " 0.2648\n", + " -0.9103\n", + " 0.2739\n", + " -0.6863\n", + " 0.6278\n", + " -0.7779\n", + " 1.6019\n", + " -2.1517\n", + " 0.7428\n", + " -0.4263\n", + " 0.3456\n", + " -0.9314\n", + " -1.6319\n", + " 0.7414\n", + " -0.7167\n", + " -0.4755\n", + " -0.2003\n", + " 0.9763\n", + " 0.2781\n", + " -0.0792\n", + " -0.1558\n", + " 1.5288\n", + " -0.1590\n", + " -1.6623\n", + " -2.3574\n", + " -0.9667\n", + " -0.1357\n", + " 1.3221\n", + " -0.9303\n", + " 1.0448\n", + " 1.2577\n", + " -0.4005\n", + " 0.2230\n", + " 1.7486\n", + " -0.2355\n", + " 0.6986\n", + " -0.1379\n", + " -0.2243\n", + " 0.7646\n", + " 1.2902\n", + " 0.6031\n", + " 1.2509\n", + " -0.7641\n", + " 0.3928\n", + " -1.0471\n", + " 1.6325\n", + " -0.1716\n", + " -0.8323\n", + " -1.4190\n", + " 0.0444\n", + " 1.0159\n", + " -0.7294\n", + " -0.2728\n", + " -1.0811\n", + " 1.1715\n", + " 1.5101\n", + " -0.4544\n", + " 0.7426\n", + " -0.5534\n", + " 0.7377\n", + " 0.0630\n", + " 0.0929\n", + " 0.3204\n", + " 0.3148\n", + " -1.0520\n", + " -0.2410\n", + " 1.7144\n", + " -0.0958\n", + " -0.7845\n", + " 0.5091\n", + " -0.7293\n", + " -1.4166\n", + " -1.4303\n", + " -1.0545\n", + " 1.3686\n", + " 0.6150\n", + " -0.7779\n", + " -0.0787\n", + " 0.6675\n", + " -0.2162\n", + " -0.1038\n", + " 1.5616\n", + " -0.3338\n", + " -0.4212\n", + " -0.6214\n", + " -1.2782\n", + " 1.4457\n", + " -0.4670\n", + " 0.2427\n", + " -1.0694\n", + " 0.9614\n", + " 1.4707\n", + " -0.2979\n", + " 0.7881\n", + " 1.6846\n", + " 1.7765\n", + " -0.8942\n", + " -1.4393\n", + " 2.5469\n", + " 0.6866\n", + " 0.9250\n", + " -0.1550\n", + " -0.2935\n", + " -1.1473\n", + " -0.4607\n", + " 0.7399\n", + " 1.1199\n", + " 1.4736\n", + " 0.9349\n", + " -0.2786\n", + " -0.6606\n", + " -0.4544\n", + " 0.2700\n", + " 1.0996\n", + " -1.1453\n", + " -0.1624\n", + " -0.2379\n", + " -1.5148\n", + " -0.4477\n", + " 0.4786\n", + " 0.2882\n", + " -0.1786\n", + " 0.8847\n", + " -0.9459\n", + " 1.6703\n", + " -1.4216\n", + " 0.6008\n", + " 0.3946\n", + " -1.5668\n", + " 0.9338\n", + " -0.7770\n", + " 1.1549\n", + " 1.1032\n", + " -1.5046\n", + " -0.3785\n", + " -0.5927\n", + " -1.1602\n", + " 0.3997\n", + " 0.5879\n", + " -0.3723\n", + " -2.0234\n", + " -1.4964\n", + " 0.7040\n", + " -1.4460\n", + " -0.4611\n", + " -1.7708\n", + " -0.4558\n", + " -0.4998\n", + " 0.8435\n", + " 0.5242\n", + " -2.1870\n", + " 1.2325\n", + " 1.1520\n", + " -0.5316\n", + " -0.1897\n", + " 1.2699\n", + " -0.4812\n", + " 0.2390\n", + " -0.2685\n", + " 1.9363\n", + " 1.3044\n", + " 0.2275\n", + " 0.9217\n", + " -1.5408\n", + " -0.5082\n", + " 0.5022\n", + " 0.3041\n", + " -0.0455\n", + " -1.3367\n", + " 0.2646\n", + " -0.1962\n", + " -0.9274\n", + " 0.9223\n", + " 0.5121\n", + " 0.1100\n", + " 0.3363\n", + " -0.4371\n", + " 0.5857\n", + " -0.4663\n", + " -0.9203\n", + " 0.4568\n", + " 0.1511\n", + " 1.0236\n", + " 0.2822\n", + " 0.1780\n", + " -0.6013\n", + " -0.7013\n", + " -0.5320\n", + " 1.0928\n", + " 0.3758\n", + " 2.4104\n", + " -4.1451\n", + " -0.2888\n", + " -3.8551\n", + " 0.7568\n", + " 0.3756\n", + " 0.3861\n", + " 0.1014\n", + " -0.1255\n", + " 0.4443\n", + " -0.6165\n", + " -0.2394\n", + " -0.7020\n", + " -0.2927\n", + " 1.5096\n", + " 0.1202\n", + " -0.4189\n", + " -1.2244\n", + " 0.2963\n", + " 1.8693\n", + " -0.9340\n", + " 1.5663\n", + " -0.0747\n", + " 0.3265\n", + " -0.6769\n", + " -0.4813\n", + " -1.3764\n", + " -1.2413\n", + " -0.1362\n", + " -0.2609\n", + " 0.1758\n", + " -0.0325\n", + " -0.7772\n", + " -0.7084\n", + " -0.1339\n", + " -0.8516\n", + " -0.5234\n", + " -0.5122\n", + " 0.5784\n", + " -0.4658\n", + " -0.8313\n", + " -0.7572\n", + " 0.4142\n", + " 1.3081\n", + " -0.4885\n", + " -1.8294\n", + " 0.8008\n", + " -0.6806\n", + " 0.9877\n", + " -0.4658\n", + " -0.5152\n", + " -2.2519\n", + " -0.9184\n", + " 0.0452\n", + " 0.6234\n", + " 0.4417\n", + " -0.4270\n", + " -0.9116\n", + " 1.2123\n", + " 1.9425\n", + " 2.7714\n", + " -0.3023\n", + " -1.4019\n", + " -0.9243\n", + " -1.9179\n", + " 0.8465\n", + " 0.1831\n", + " 0.6253\n", + " 1.0873\n", + " -0.1138\n", + " 0.5737\n", + " -0.0160\n", + " -0.3136\n", + " 0.6287\n", + " 0.4997\n", + " -1.0553\n", + " 1.5128\n", + " -0.7724\n", + " -0.8117\n", + " 0.4409\n", + " 0.5041\n", + " -2.1216\n", + " -0.8234\n", + " -1.2071\n", + " 1.6990\n", + " 0.1539\n", + " -1.5476\n", + " 0.1917\n", + " 1.0442\n", + " -1.3003\n", + " -0.7363\n", + " -1.2590\n", + " 0.6875\n", + " 0.2634\n", + " 0.6787\n", + " 0.7348\n", + " 0.5719\n", + " 0.1611\n", + " 0.6663\n", + " 0.7529\n", + " -1.1562\n", + " -0.2304\n", + " 0.6477\n", + " -0.2201\n", + " 1.3055\n", + " -0.1141\n", + " -0.5299\n", + " -0.4522\n", + " -1.9043\n", + " 0.8776\n", + " 1.9302\n", + " 1.1516\n", + " -0.6075\n", + " 2.3531\n", + " -0.7080\n", + " 0.4949\n", + " 0.0472\n", + " -1.7398\n", + " 2.7106\n", + " 0.4589\n", + " -0.8962\n", + " -2.4618\n", + " 0.4810\n", + " 2.8438\n", + " -1.6133\n", + " 0.3117\n", + " 0.0361\n", + " -0.3038\n", + " 1.5661\n", + " -0.4900\n", + " -1.9978\n", + " 1.7319\n", + " 2.1458\n", + " -0.9193\n", + " 1.0363\n", + " 0.8575\n", + " 0.8833\n", + " 0.8168\n", + " -1.2229\n", + " 0.1438\n", + " -1.0943\n", + " 1.0756\n", + " -0.0651\n", + " -0.1466\n", + " -0.4549\n", + " 0.1315\n", + " 0.0567\n", + " -1.6938\n", + " -0.2960\n", + " -0.0285\n", + " -1.5097\n", + " -0.6940\n", + " -0.6508\n", + " -1.6149\n", + " -1.0484\n", + " 0.5908\n", + " -0.7661\n", + " 0.1657\n", + " -0.1332\n", + " -1.6022\n", + " -0.3147\n", + " -0.9328\n", + " -0.5750\n", + " 2.1529\n", + " 3.2324\n", + " 0.3846\n", + " -0.7117\n", + " -0.3512\n", + " -0.3957\n", + " 1.2097\n", + " 0.0667\n", + " 0.5044\n", + " 0.5186\n", + " 0.8504\n", + " 0.0150\n", + " -0.2528\n", + " 0.1668\n", + " 0.0921\n", + " 0.0315\n", + " -1.0027\n", + " 0.0170\n", + " 0.4593\n", + " -1.3572\n", + " 1.6892\n", + " 0.7206\n", + " -0.6786\n", + " 1.5432\n", + " 0.1526\n", + " 0.4065\n", + " -1.8494\n", + " 1.5476\n", + " -0.0046\n", + " -1.1916\n", + " 0.5081\n", + " 2.0424\n", + " 0.6191\n", + " -0.9728\n", + " -0.1111\n", + " 0.1431\n", + " -1.0241\n", + " -1.7796\n", + " -0.6147\n", + " 1.2153\n", + " -0.6740\n", + " 0.4614\n", + " 0.3792\n", + " -0.0326\n", + " 1.0495\n", + " -0.3696\n", + " 1.6860\n", + "X at row 1 = -0.1303 -1.8889 -1.8943 -0.7641 0.8248 0.8346 -0.1940 -1.2710 1.1092 -0.3537 -0.9102 -0.3909 -0.2594 1.6956 -0.0247 -0.5292 -0.4512 -1.5525 1.2297 -0.9600 0.1138 -0.9826 -0.7896 -2.1680 0.0735 2.1952 1.7877 0.4093 1.4068 -0.7727 -1.1346 1.1528 -0.6630 2.1216 1.3934 -1.1337 -0.3597 -0.3541 0.7632 -0.3796 -0.0305 -1.5087 1.6120 0.8809 0.0749 -1.5934 0.1615 2.9833 0.4106 1.2373 -2.1477 -0.3035 -0.2331 1.0815 -0.9824 0.8464 1.0854 0.0905 -0.1758 0.4472 -1.0333 -1.6160 -1.7218 0.1391 -0.3146 -0.1687 -0.5959 -0.1425 1.8204 -0.3562 -0.9599 -1.2752 -1.0133 0.4999 -0.2816 -0.4540 -0.2762 -1.5043 -0.9698 -0.4773 -0.4899 0.1741 0.8084 -0.7487 0.2317 0.3013 -0.6859 0.4594 0.8885 -1.7017 0.3351 0.3276 0.2349 -1.6038 0.9208 -0.2154 -0.8873 -1.6463 0.3400 -0.2532 -1.4465 1.5566 -1.3078 0.5931 -1.0350 -0.2642 0.6000 -0.3168 0.4864 -0.0245 1.4653 0.6982 0.4726 -0.7308 -0.4193 0.2034 1.7011 1.5083 0.1936 1.1821 0.1794 0.2560 0.1005 -0.2652 0.5479 3.1340 -0.2358 1.1982 0.9420 0.1006 0.8255 -0.3822 0.1978 1.5097 1.6373 0.0431 -0.1129 -1.2686 0.8054 -0.4961 -0.8063 0.2664 0.0069 -1.3997 1.2121 -1.6549 -1.6258 0.9492 -0.3033 -1.7251 1.0179 0.8703 -0.2136 -0.1070 0.1601 0.7922 -0.1611 -1.1424 -0.1301 -0.5462 -1.6649 -0.5373 -1.0936 0.0651 1.1558 0.4532 2.7863 0.4111 0.1179 -0.9391 0.8304 0.3314 -1.6710 -0.6781 0.6208 -0.4852 0.3932 0.1969 2.0448 -1.5095 -0.1868 -1.3593 -0.9128 1.9446 0.9201 0.5928 -0.0625 0.0299 2.0419 -1.0426 1.2962 1.1168 -0.9104 0.2406 -0.6990 0.0609 0.8988 0.3169 1.2566 0.7810 -2.2314 0.8412 -1.2644 -2.9319 -0.3245 -0.5170 2.1046 1.0606 0.8861 0.0856 0.9396 -0.6322 1.1533 -0.4309 -0.1291 0.3175 -0.6852 3.0213 0.2461 -0.3835 -0.9106 -0.6247 -0.0162 0.5834 -1.4655 -0.4383 1.8640 0.3467 0.0492 -0.3549 -0.1978 0.1766 1.4384 1.3914 -0.5123 -0.8472 0.5280 -0.5381 1.0141 1.1520 -0.7202 -2.0949 -1.3701 -0.0942 -1.1858 0.3153 0.2089 0.0400 -0.1543 -0.7056 0.5936 -1.9365 0.4321 2.3047 1.2961 0.0102 -0.2855 0.3889 -0.1387 1.6600 -0.5668 -0.1872 -1.1931 0.5835 -1.5910 0.8203 0.5441 -1.2831 0.4048 -0.2641 -0.5522 -1.3442 -1.6359 -1.4626 -1.6930 0.0279 -1.0272 2.1113 0.3575 1.1408 -0.6979 1.5549 -0.4504 0.9850 0.3416 0.7010 -1.1694 -0.9518 0.9355 0.4494 -0.5949 0.5880 0.0933 -0.5871 2.0428 -2.3030 -0.2917 0.8635 0.4134 1.9696 0.5869 0.5109 -0.6359 1.6277 -0.6014 -0.3479 -0.3488 0.6429 -0.5888 -0.0647 -0.5147 -1.7515 -0.6798 2.0559 -0.3951 0.1686 2.5886 -0.7805 0.7106 1.2175 -0.9543 1.5560 0.9034 -1.1940 0.0754 -1.2196 2.8129 2.1289 0.0210 -0.6777 0.4525 -1.1427 -0.2391 -1.1154 -0.2574 0.4185 0.3286 0.7284 -0.5076 0.8819 0.0942 0.3560 1.5036 0.0449 -0.9635 0.6887 -1.0330 0.0872 -0.0501 -2.1020 -1.4337 -0.9257 0.3425 0.9070 0.0722 2.3275 0.8198 -1.5429 0.6366 -1.0006 -0.7866 -0.2862 -0.2392 0.3370 0.7633 1.1114 -0.5599 0.0947 1.1797 -1.1000 1.0090 0.7367 -0.3539 1.2207 0.4190 0.7183 1.6049 -0.0837 -1.1266 -0.4496 -1.0850 1.0135 -0.3688 -0.4396 -0.6355 1.1079 0.3006 0.7692 0.2293 -0.7408 -0.9206 1.1963 -0.2899 0.6682 -1.1477 -0.3087 -0.5710 -0.8685 0.5535 0.8530 -0.2707 2.0816 -0.0427 -1.6252 0.5045 -1.3051 -0.3969 0.2542 1.1368 0.5439 -0.7348 1.2657 0.2403 1.2683 1.2973 0.0072 -0.7310 0.6890 0.0616 -0.0828 0.1312 -0.8594 -1.0277 -0.5403 0.1421 -0.3251 0.6137 0.7264 0.4142 -1.0199 -1.4757 -0.9888 -1.1946 0.7967 0.7680 -1.6643 -0.4378 -0.1735 -0.9022 -0.3338 -0.8859 -0.4636 -0.0393 0.3110 -0.8364 0.6814 -0.8818 -0.3938 -0.2424 -0.9607 0.4192 -0.6948 -0.9700 1.6247 -0.3068 -0.4554 -2.3321 -0.2029 1.4800 -0.3986 -0.3510 0.7297 0.8157 1.1313 0.6526 -0.2743 -0.7319 0.5434 0.4993 0.4788 -0.6852 -0.5029 1.5120 -0.3975 0.5953 -0.0040 -1.6946 0.5412 -1.0569 1.5897 -0.4021 -0.6620 -0.2189 -0.0788 -0.4391 -0.3756 1.0283 0.1207 0.7142 0.0609 0.5808 -0.6671 1.5082 -0.9241 -1.7482 -1.3749 -1.0201 -0.3169 1.6518 -1.2610 0.6662 -0.9701 1.3008 0.5260 1.7987 -0.3011 0.7496 0.8225 -0.4573 -0.1228 -0.6626 -0.8160 -0.6457 -1.2092 0.7843 -0.1486 -0.9408 -0.0216 0.2489 -0.3920 0.9855 -0.2958 0.0864 2.1242 -0.6019 -0.0168 0.2337 -1.2911 -0.4708 0.7310 1.5578 -0.7311 0.4221 -0.3300 -0.4875 -1.2506 0.3472 -2.1284 0.5914 0.1862 0.2549 -0.2563 -1.3353 -1.5943 0.0710 0.4695 0.1217 -0.9617 0.8348 2.2675 -0.4620 -0.9975 -0.4232 1.7423 -0.8411 -0.5181 -0.1982 -0.3315 0.6473 -0.4850 -1.2316 0.1319 0.0068 1.9731 1.1936 1.7843 0.0455 0.4089 0.4818 0.0050 -1.6032 0.5682 0.2087 1.6447 1.0798 -0.5055 0.3588 -1.0928 1.1815 -0.1790 -1.3245 -2.1736 0.7826 0.5969 -0.9311 2.3017 -0.5934 1.5801 -0.7191 0.2348 -0.5762 2.0757 0.9789 0.2594 0.3832 0.1516 0.1950 -1.3627 0.4390 1.3800 -0.7068 -1.3057 -1.4113 -0.9749 0.9718 0.4244 -1.3514 1.4114 -0.3652 0.6211 -0.3572 -1.0582 0.1297 -0.4077 0.2258 0.0350 -1.1996 0.4340 -0.4507 0.4769 0.8807 0.4588 0.9047 1.6949 -0.3244 -0.6571 -1.0580 1.0078 -0.9006 0.6270 1.4200 -0.8754 1.4353 -1.0162 0.7245 0.0132 -1.5419 -0.0709 1.5211 -0.2002 -1.2329 0.9319 0.9392 -1.1274 0.1109 -1.3233 -1.4660 0.6924 0.7260 1.5430 0.7486 -0.2156 1.1025 -0.8867 -0.4322 0.1090 -0.4704 -0.1856 -0.8473 0.9206 1.4661 1.1225 1.8906 0.9805 0.8283 -1.3156 0.1768 -1.4570 1.0890 0.2154 -0.1140 -0.4136 -0.6786 -0.1035 -0.3162 0.3441 -1.2909 -0.4467 1.4900 -1.9820 -0.4664 -1.2786 0.3676 0.7329 -0.3929 -0.7365 -0.2747 0.9056 -0.7859 -0.2956 1.0680 -1.0719 -1.3234 0.6934 1.2849 0.7435 2.3218 -1.0324 -0.6139 0.3953 -2.2905 -0.5012 2.0438 1.2503 -1.0526 2.1789 1.5080 0.2720 -0.5432 0.7212 1.4434 0.1203 -0.7942 0.5545 0.4358 -1.4950 -1.3790 -1.0028 0.7541 -1.1814 -0.2463 0.2507 -1.0173 -1.0405 -0.8867 -0.3166 -1.0032 1.7837 0.4660 1.0115 -1.0576 -1.0503 -1.2691 -0.9969 0.6017 1.1066 1.0629 0.8304 -2.1412 -0.4744 0.3403 0.6981 -0.2230 0.3195 -0.1354 -0.2387 0.5058 -0.8588 -0.6456 0.2905 0.2384 0.0323 0.7997 -0.5590 0.2237 1.0920 -0.7261 -0.3966 1.2628 -0.3463 0.6499 -0.8623 -0.6873 -1.2582 -1.3649 1.1135 -0.1239 -0.6870 0.9076 0.1912 0.4151 0.0974 0.7719 -1.4241 -1.4873 -0.4365 0.0903 0.0109 -0.6919 0.4479 0.2771 -0.1120 -0.1478 1.2252 -0.2829 -1.2783 -1.1165 0.9661 -0.2791 0.2517 0.3617 -0.0298 -0.7508 -0.1293 0.6322 -0.9279 0.0107 0.0431 -1.2497 -0.3207 0.3729 0.0378 -0.8449 1.2685 -0.6131 0.8045 0.5319 0.0397 1.3639 2.4420 0.9601 0.5330 0.2731 0.1203 -1.3857 0.8220 -0.7880 -2.3870 0.1022 -0.3642 -1.4525 0.8016 0.2126 1.0889 -0.3641 -0.3100 0.3088 0.9449 0.2051 1.6871 -0.3313 -0.2810 -0.6349 -0.8021 -1.1781 -1.4312 -0.3652 0.4600 1.5668 -0.0133 -1.6548 0.8254 -0.8026 0.7557 0.1951 -0.5060 -0.3632 -0.5389 0.6426 -0.7309 -0.2953 -0.6089 -0.6251 0.7391 1.1973 -0.3344 0.1649 0.9641 0.7885 -0.4885 0.8268 0.1011 -1.2578 -0.3759 -0.9399 0.5553 0.7497 0.9535 -0.2177 -0.5243 -0.2782 0.0437 -0.6773 0.3488 0.9226 -1.7426 0.8475 0.8574 -1.2473 4.2163 0.8636 0.3285 -1.5353 0.1917 0.0582 0.5318 -0.4769 -1.0342 -1.1038 0.2288 -0.7653 0.2579 1.6202 -1.6433 -0.2785 2.1554 0.4466 1.7524 0.1536 1.5707 1.0376 1.1222 -1.1420 1.3743 0.0680 -0.4519 0.8247 -0.5629 -1.1361 0.1096 1.0499 -0.3424 0.6436 1.4140 -0.0269 -0.0982 -0.7024 -0.5683 -0.1053 -2.5014 0.1795 1.8151 0.1059 0.0383 -0.6801 0.6451 -0.3206 1.8594 0.4789 0.5867 0.3746 -0.3948 -2.5526 -0.4541 0.7067 -1.9336 0.4456 0.4308 0.5824 0.1896 0.2485 -0.3686 1.1640 -1.3761 -1.1453 -0.9871 -0.9182 0.6855 -0.2783 0.8357 -1.3133 -0.4625 -0.8105 0.0411 0.1895 0.2088 -0.6791 1.2506 -0.3479 0.7949 1.6892 1.3242 -1.3077 1.7444 -0.1910 0.6751 0.1102 -0.0098 0.0822 0.5126 0.8483 -0.9459 -1.6989 -0.4744 -1.3666 -0.9707 1.1305 0.5723 -0.8086 -0.6741 -0.6032 -0.4959 -0.2727 0.0663 0.8952 -0.2796 -1.8718 -0.0125 -0.2311 -0.5582 0.7608 -1.9581 -1.1854 -0.8694 1.5049 -0.9910 -0.4829 0.3583 0.0323 -2.2564\n", + "soluton at column 0 = [matrix size: 1000x1; n_nonzero: 0; density: 0%]\n", + "\n", + "soluton at column 1 = [matrix size: 1000x1; n_nonzero: 1; density: 0.10%]\n", + "\n", + " (2, 0) 1.3478\n", + "\n", + "soluton at column 2 = [matrix size: 1000x1; n_nonzero: 2; density: 0.20%]\n", + "\n", + " (2, 0) 1.4386\n", + " (4, 0) 1.1724\n", + "\n", + "soluton at column 3 = [matrix size: 1000x1; n_nonzero: 3; density: 0.30%]\n", + "\n", + " (2, 0) 1.3930\n", + " (4, 0) 1.1254\n", + " (9, 0) 1.0608\n", + "\n", + "soluton at column 4 = [matrix size: 1000x1; n_nonzero: 5; density: 0.50%]\n", + "\n", + " (1, 0) 0.9976\n", + " (2, 0) 1.3135\n", + " (4, 0) 1.1826\n", + " (7, 0) 0.9941\n", + " (9, 0) 1.0887\n", + "\n", + "soluton at column 5 = [matrix size: 1000x1; n_nonzero: 7; density: 0.70%]\n", + "\n", + " (1, 0) 1.0195\n", + " (2, 0) 1.2185\n", + " (4, 0) 1.0848\n", + " (5, 0) 1.0042\n", + " (6, 0) 1.0029\n", + " (7, 0) 1.0397\n", + " (9, 0) 0.9992\n", + "\n", + "soluton at column 6 = [matrix size: 1000x1; n_nonzero: 8; density: 0.80%]\n", + "\n", + " (0, 0) 0.8908\n", + " (1, 0) 1.0186\n", + " (2, 0) 1.1519\n", + " (4, 0) 1.0353\n", + " (5, 0) 1.0185\n", + " (6, 0) 1.0207\n", + " (7, 0) 1.0407\n", + " (9, 0) 0.9614\n", + "\n", + "soluton at column 7 = [matrix size: 1000x1; n_nonzero: 10; density: 1.00%]\n", + "\n", + " (0, 0) 1.0201\n", + " (1, 0) 0.9734\n", + " (2, 0) 0.9983\n", + " (3, 0) 0.9969\n", + " (4, 0) 1.0115\n", + " (5, 0) 1.0021\n", + " (6, 0) 1.0129\n", + " (7, 0) 0.9923\n", + " (8, 0) 0.9962\n", + " (9, 0) 1.0268\n", + "\n", + "soluton at column 8 = [matrix size: 1000x1; n_nonzero: 11; density: 1.10%]\n", + "\n", + " (0, 0) 1.0168\n", + " (1, 0) 0.9820\n", + " (2, 0) 0.9996\n", + " (3, 0) 0.9966\n", + " (4, 0) 1.0130\n", + " (5, 0) 1.0038\n", + " (6, 0) 1.0150\n", + " (7, 0) 1.0024\n", + " (8, 0) 0.9947\n", + " (9, 0) 1.0246\n", + " (530, 0) -0.0691\n", + "\n", + "soluton at column 9 = [matrix size: 1000x1; n_nonzero: 12; density: 1.20%]\n", + "\n", + " (0, 0) 1.0185\n", + " (1, 0) 0.9864\n", + " (2, 0) 0.9972\n", + " (3, 0) 0.9934\n", + " (4, 0) 1.0187\n", + " (5, 0) 1.0021\n", + " (6, 0) 1.0153\n", + " (7, 0) 1.0063\n", + " (8, 0) 0.9939\n", + " (9, 0) 1.0224\n", + " (380, 0) -0.0631\n", + " (530, 0) -0.0693\n", + "\n", + "soluton at column 10 = [matrix size: 1000x1; n_nonzero: 13; density: 1.30%]\n", + "\n", + " (0, 0) 1.0198\n", + " (1, 0) 0.9869\n", + " (2, 0) 0.9942\n", + " (3, 0) 0.9968\n", + " (4, 0) 1.0195\n", + " (5, 0) 0.9979\n", + " (6, 0) 1.0123\n", + " (7, 0) 1.0077\n", + " (8, 0) 0.9934\n", + " (9, 0) 1.0228\n", + " (380, 0) -0.0622\n", + " (530, 0) -0.0701\n", + " (676, 0) -0.0629\n", + "\n", + "soluton at column 11 = [matrix size: 1000x1; n_nonzero: 15; density: 1.50%]\n", + "\n", + " (0, 0) 1.0201\n", + " (1, 0) 0.9840\n", + " (2, 0) 0.9957\n", + " (3, 0) 0.9897\n", + " (4, 0) 1.0237\n", + " (5, 0) 0.9964\n", + " (6, 0) 1.0112\n", + " (7, 0) 1.0112\n", + " (8, 0) 0.9934\n", + " (9, 0) 1.0165\n", + " (91, 0) 0.0606\n", + " (380, 0) -0.0625\n", + " (530, 0) -0.0732\n", + " (676, 0) -0.0606\n", + " (974, 0) 0.0608\n", + "\n", + "soluton at column 12 = [matrix size: 1000x1; n_nonzero: 16; density: 1.60%]\n", + "\n", + " (0, 0) 1.0180\n", + " (1, 0) 0.9807\n", + " (2, 0) 0.9936\n", + " (3, 0) 0.9918\n", + " (4, 0) 1.0215\n", + " (5, 0) 0.9941\n", + " (6, 0) 1.0092\n", + " (7, 0) 1.0097\n", + " (8, 0) 0.9958\n", + " (9, 0) 1.0156\n", + " (20, 0) -0.0552\n", + " (91, 0) 0.0626\n", + " (380, 0) -0.0638\n", + " (530, 0) -0.0733\n", + " (676, 0) -0.0608\n", + " (974, 0) 0.0596\n", + "\n", + "soluton at column 13 = [matrix size: 1000x1; n_nonzero: 18; density: 1.80%]\n", + "\n", + " (0, 0) 1.0152\n", + " (1, 0) 0.9813\n", + " (2, 0) 0.9909\n", + " (3, 0) 0.9925\n", + " (4, 0) 1.0160\n", + " (5, 0) 0.9951\n", + " (6, 0) 1.0128\n", + " (7, 0) 1.0086\n", + " (8, 0) 0.9992\n", + " (9, 0) 1.0188\n", + " (20, 0) -0.0580\n", + " (91, 0) 0.0648\n", + " (304, 0) -0.0548\n", + " (380, 0) -0.0666\n", + " (530, 0) -0.0664\n", + " (676, 0) -0.0627\n", + " (779, 0) 0.0650\n", + " (974, 0) 0.0546\n", + "\n", + "soluton at column 14 = [matrix size: 1000x1; n_nonzero: 21; density: 2.10%]\n", + "\n", + " (0, 0) 1.0074\n", + " (1, 0) 0.9804\n", + " (2, 0) 0.9900\n", + " (3, 0) 0.9884\n", + " (4, 0) 1.0201\n", + " (5, 0) 0.9867\n", + " (6, 0) 1.0184\n", + " (7, 0) 1.0056\n", + " (8, 0) 1.0003\n", + " (9, 0) 1.0254\n", + " (20, 0) -0.0627\n", + " (91, 0) 0.0709\n", + " (304, 0) -0.0554\n", + " (346, 0) -0.0606\n", + " (380, 0) -0.0666\n", + " (429, 0) 0.0608\n", + " (530, 0) -0.0634\n", + " (676, 0) -0.0669\n", + " (779, 0) 0.0686\n", + " (972, 0) 0.0584\n", + " (974, 0) 0.0536\n", + "\n" + ] } ], "source": [ - "np.isrealobj(values[0])" + "fit_model = l0learn.fit(X, y, max_support_size=20)" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [], - "source": [ - "for i, value in enumerate(values):\n", - " if not isinstance(value, np.ndarray) or value.ndim != 1 or not np.isrealobj(value):\n", - " print(value)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "pycharm": { - "is_executing": false, - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "# csc_arr = csc_matrix((data, indices, indptr), shape=(5, 5)).toarray()\n", - "csc_arr = csc_matrix(arr)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - }, - "pycharm": { - "is_executing": false, - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0.76355643, 0.99015561, 0.96518113, 0.9159315 , 0.76160812])" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "csc_arr.data" - ] + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -237,7 +953,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.7" + "version": "3.9.7" }, "pycharm": { "stem_cell": { From 890072408cce4f8818059548eae443a9e6382e12 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 3 Dec 2021 09:57:23 -0600 Subject: [PATCH 077/125] Updating Documentation for Github Pages --- python/_github_pages_docs/html/.buildinfo | 4 + .../html/_images/tutorial_18_0.png | Bin 0 -> 19069 bytes .../html/_images/tutorial_20_1.png | Bin 0 -> 38668 bytes .../html/_images/tutorial_30_2.png | Bin 0 -> 42644 bytes .../html/_images/tutorial_36_1.png | Bin 0 -> 8462 bytes .../html/_images/tutorial_57_1.png | Bin 0 -> 36559 bytes .../html/_images/tutorial_61_2.png | Bin 0 -> 51505 bytes .../html/_sources/code.rst.txt | 39 + .../html/_sources/index.rst.txt | 21 + .../html/_sources/tutorial.ipynb.txt | 1338 ++ .../html/_static/alabaster.css | 701 + .../_github_pages_docs/html/_static/basic.css | 905 ++ .../html/_static/custom.css | 1 + .../html/_static/doctools.js | 323 + .../html/_static/documentation_options.js | 12 + .../_github_pages_docs/html/_static/file.png | Bin 0 -> 286 bytes .../html/_static/jquery-3.5.1.js | 10872 ++++++++++++++++ .../_github_pages_docs/html/_static/jquery.js | 2 + .../html/_static/language_data.js | 297 + .../_github_pages_docs/html/_static/minus.png | Bin 0 -> 90 bytes .../_github_pages_docs/html/_static/plus.png | Bin 0 -> 90 bytes .../html/_static/pygments.css | 82 + .../html/_static/searchtools.js | 529 + .../html/_static/underscore-1.13.1.js | 2042 +++ .../html/_static/underscore.js | 6 + python/_github_pages_docs/html/code.html | 639 + python/_github_pages_docs/html/genindex.html | 186 + python/_github_pages_docs/html/index.html | 148 + python/_github_pages_docs/html/objects.inv | Bin 0 -> 1048 bytes python/_github_pages_docs/html/search.html | 133 + python/_github_pages_docs/html/searchindex.js | 1 + python/_github_pages_docs/html/tutorial.html | 2132 +++ python/_github_pages_docs/html/tutorial.ipynb | 2358 ++++ python/doc/.nojekyll | 0 34 files changed, 22771 insertions(+) create mode 100644 python/_github_pages_docs/html/.buildinfo create mode 100644 python/_github_pages_docs/html/_images/tutorial_18_0.png create mode 100644 python/_github_pages_docs/html/_images/tutorial_20_1.png create mode 100644 python/_github_pages_docs/html/_images/tutorial_30_2.png create mode 100644 python/_github_pages_docs/html/_images/tutorial_36_1.png create mode 100644 python/_github_pages_docs/html/_images/tutorial_57_1.png create mode 100644 python/_github_pages_docs/html/_images/tutorial_61_2.png create mode 100644 python/_github_pages_docs/html/_sources/code.rst.txt create mode 100644 python/_github_pages_docs/html/_sources/index.rst.txt create mode 100644 python/_github_pages_docs/html/_sources/tutorial.ipynb.txt create mode 100644 python/_github_pages_docs/html/_static/alabaster.css create mode 100644 python/_github_pages_docs/html/_static/basic.css create mode 100644 python/_github_pages_docs/html/_static/custom.css create mode 100644 python/_github_pages_docs/html/_static/doctools.js create mode 100644 python/_github_pages_docs/html/_static/documentation_options.js create mode 100644 python/_github_pages_docs/html/_static/file.png create mode 100644 python/_github_pages_docs/html/_static/jquery-3.5.1.js create mode 100644 python/_github_pages_docs/html/_static/jquery.js create mode 100644 python/_github_pages_docs/html/_static/language_data.js create mode 100644 python/_github_pages_docs/html/_static/minus.png create mode 100644 python/_github_pages_docs/html/_static/plus.png create mode 100644 python/_github_pages_docs/html/_static/pygments.css create mode 100644 python/_github_pages_docs/html/_static/searchtools.js create mode 100644 python/_github_pages_docs/html/_static/underscore-1.13.1.js create mode 100644 python/_github_pages_docs/html/_static/underscore.js create mode 100644 python/_github_pages_docs/html/code.html create mode 100644 python/_github_pages_docs/html/genindex.html create mode 100644 python/_github_pages_docs/html/index.html create mode 100644 python/_github_pages_docs/html/objects.inv create mode 100644 python/_github_pages_docs/html/search.html create mode 100644 python/_github_pages_docs/html/searchindex.js create mode 100644 python/_github_pages_docs/html/tutorial.html create mode 100644 python/_github_pages_docs/html/tutorial.ipynb create mode 100644 python/doc/.nojekyll diff --git a/python/_github_pages_docs/html/.buildinfo b/python/_github_pages_docs/html/.buildinfo new file mode 100644 index 0000000..f22a669 --- /dev/null +++ b/python/_github_pages_docs/html/.buildinfo @@ -0,0 +1,4 @@ +# Sphinx build info version 1 +# This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done. +config: 821a7001e95886892bae70fb345cf85d +tags: 645f666f9bcd5a90fca523b33c5a78b7 diff --git a/python/_github_pages_docs/html/_images/tutorial_18_0.png b/python/_github_pages_docs/html/_images/tutorial_18_0.png new file mode 100644 index 0000000000000000000000000000000000000000..69d21753c22f028827b0e063a29ec4bea3ec99ab GIT binary patch literal 19069 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 z zISSI2%1B2x^dCMTb^S-f{O=o-|A%$xIU(1JI}}_+IyQV+rm4GusHVBagdDjp&pc^Y z(0D9naxM#Z-W`c}iQf0@DCeNWl<^Uw{Qt%%arVqt7ZE;(vuD!p2y}}#2r~rD*tzFw zvRy{Z{yJG>alwiD4H0SQ_TDPwQgkUUI_40Qy@+9oaj`9fLGeyaO@&1@$%`12yc8F$ z@4bIsebM*M40AzQ^+oKxZx?sIkXAaSuqZ~Us<|WN*zq)hi;PNE9xngQc>P>VUA}M$ zzGeRq&TyCUjlv??wU2n59=ioS?=8GGdlFN!jlV!(`D01`%i+v|M+E{|1lKAr(s_Kn z*K6+#r;a{%A?CuhH`x}b3(6`ly56aA^;{h@V-KT&&;c8zS9v-6`3}f4s4U!Qa3SS! z@_#cqdx--DO1lnM)TlF5&#V+M)@LYSJ8*dsg0DOr=WtfJ^cvW|MOd ztJ2nOE|&oge@vfaC~#dw>6N$3$FsB8fX!9=1sfNfH+cL#II46muyN%g(soSAA@bO_ z*FB+@p$zZXHgNauf4E#IaK}fs!;%bTQ5-9!dcO;A=`)_t;TGL-xul1`!JonA=$YfQ zY`5_CPB-^C&b!TE8?Za<1Bw_ zdWM%Fh{5Li8@40w8045IB*pYqN*r+B7AFGo8?ZW&l@mP69&q@K{`M?+-Upm%^B%Nq z00yD%lOD*?NWiuhqz(bqI#`ZOLK`3X^gnTrQ{}5(Pv8+yz;mBm{an^LB{Ts51X)kl literal 0 HcmV?d00001 diff --git a/python/_github_pages_docs/html/_images/tutorial_20_1.png b/python/_github_pages_docs/html/_images/tutorial_20_1.png new file mode 100644 index 0000000000000000000000000000000000000000..9e9aeadf3ec5bb2081cd282b23ef3628006c6b30 GIT binary patch literal 38668 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 literal 0 HcmV?d00001 diff --git a/python/_github_pages_docs/html/_images/tutorial_30_2.png b/python/_github_pages_docs/html/_images/tutorial_30_2.png new file mode 100644 index 0000000000000000000000000000000000000000..93e1854427928605894bb7481c02d318a921b76e GIT binary patch literal 42644 zcmX_n1yCF9_jQ2cPJvP&NO8B~S}0a16n7}@?(SOLi@Up9&;rGRySqbhhcA79|M{Mo zOfs9D-Mi1;-Fwct=L!EICy9vYnKMBLIN<{@(`%kd{FJ02IMUfBmBDmT{8l>ZUw97rO3URB*S38Z_al_BD;H zAC~^s<7R2O@oo)o1f*LX;iJl^j*W|rCGHU?SAtAQUT|l0^!l3mJ2r^Y2uw-Y?Ve2| zzn8ISnZhxY;e4y>`4W_fgZ{q}HJ9V$g!uV?Lyq|K;1{v~M*gf>bYRGTL!x|=81eu1 zR?X+dApGB`lvtkx@?-^thK}s)>_nga+jjuD|MBJ+wJ;HzWI^)i=JC#d%?z`G2G-?g z`K-muV9uAoOQJ6KZ@d^oLqio>%~kpBxzJ%RN*?t0@{exyd>1JYxJvQqQ{GnvTqZ;j znn9c9UjYFDS?=!c=WzRH2A~RrtT) zib*2&K4+-&2v<{kzZ+ zC0tII8r3v4HLK01iwc$1)P8*lL@0DUUjv!movnIGNJ!iQg?+qInk>!}QKD!59r@td ztBs!FdaS>F8--qWAPm5Ab-F#}z)YH@d?KBxTAtK?*2ZAJ*&E!hsHDX70-Yf?!-2>t z=y7M8RJydpv|_B^USC37*S)#vDJTrfySlnE1l%2tp3b{S+k9Rg(bRs2zo&8e&1J1= zo{k0>vo}-QJ5L`cB3dJ>rjIe}GCL!1LsU{MCQfO}*0@2_JAWi>Z^%aqMs3&mOVLNl z%WQ3FW@c8hJFTLTEC1FYIAqkw0C>Qo-kuh=mWPGxAUr|O^h8BP_1ok2#2g`2$lK#$ zrPVPI5uGq`o=Z@e>y(o#eT=%StPGchg+=T8_b41vQd@hFnznXDg?20ZPjCkBlOU-- z95gbTf04as$jX`9vopa|0d9rk$padO-64Mt-AraVynbI8uh!};9Y@Qn?&nfueun1N z9nanR$aK1=?NhFU@UQO?kNdK!?U!3D{O|wGV1}MIXNpmf^FI??w?VpE11>;hKA%Ch=Ym-qI z4n1S9S)=Su@O_$Oh_Gm5VVWMhul|o2vUu18T8^YzW?P_#c#Pa6uMa8^q2EvL;0P@F zB>vtE?T;0Qk_A200s}!lIBeFY-=cYL5t%&AstW{}k#?NTox6a{3{9JaeEu9gaX)aB zmpA9pyI#FyXax@s-}Z2|k9fXVZz`j%o@zauNLOmx_2P0c#=WkM2ANgU3)b~KZG^Wt zwvBlI8hB8#qrxfpw9DsvWy|fTdZ{76{)}xkHP9-Yv25T?ogS`nY-(?R_p4Thf1bG` zc^P440NvX*XGVEgY=o50B>RMi7`(M)K%#fSGoEpaChaeM!mvD;*|qL2`&2CNnReBd zHQ1DAt^IJ7^lbb5M(~k4o(eG;Qf>TJ#!&nL9f$?WldL{)x1afi7ELl5v4Yo8cZO$@ z$@{CIo6=|OIceP0M^{ab;T; z>(PCbivv2HpKz%uzjv2#)Kxo?@+R>{Mv%gHhiVD$tP{OOEuOg%*z;N#7qL?p%MO%q zY!zOK79T{nQD^ZmWr5M$kDScpMuy}~Gs7(p={yeVyKaW6Sw9kG$Dl#j;l3hxXlZfu zO{4||y>pb4lhXk$E-s>*kS#@Q3pTl5?ZH!1Q>Pgi8dd`KGhKBLBk&lWZ95+F5+JW&149Udl@ zBp$qC?g->SoYLeD{8_(DNPLHK4lg1q0vi+KmNB!T3}_2++Ku*iok?n5v{pY=WpqL1 zI&`y6;1cZ+13+e<;t68IQo!X^wy^#~7I~Vg+^d-FNtPZua3T`Y2#zk`O;YbS7!d_) zg@pO?QSAXk29k1q5O0w4L?S*Ax%kE62<^@%TzDeLVs^dgYqR~s)k2Luh&`~i`jU2 z7cWnn*F$`67fqi8&h3xQV``~rXwtc@7B=)06mst$9u`v=HE>wXCUPwNZ3JnSA61w1&PwmgKrN{!c2TXQKXOo zv`T*4A83^CsAqtB3#YvZ@^v@kfqfTY7cr&$=avvE!G=ZS)_kNpQ1Ggu?hG zn#S4N7mBAVkDX)ZK~t*ievKj1#--QzvlKh&JDH7L{X&D#EPSFr!?KaFP|K>hiEr{vuZ#GSEjnW0)A4a$M&53r>`0 z=HJ%{Po~xi91+Rl1ZpqC5%xpAVr~Y8lLG9Xrk023ZTa9JuAW`n?Vxp_vya2Dk*>hD zI6%TnD9`3&1)H9U*HCkNm*AEglD~+ZM$AZy_r|Gm8pH4FQ%W0BJN^%adS6xD@zvfO zI8jiLqInqPLi<(5g&&^-ucpEKKl{Jf=y)-_5k9kk!-NBw;I-Twb`zZCDo1p&!H;&= zn|rU^90Ddh{1GmY;Wo7v+rQogp+)sa6ZAqWkNSa4gw0G?D|{QOZSP$5`!>#e|XtAU*SApj^v||!DKWxd>ugW zuB@+gWqO_5Cnaz~P~EFCQX68fI&#JXj9@TR)C*jd9P4yh2O4ZVH(UXI`9tS^*f5)V zO}PP7cPergl)aRfVS9dA>RQ>iHq>vS;8-2&;2{M1tLb^)bQee`v@Ke3F@vtBdZERO zbRLLz%GOkCIH>wPovX6IcD+;Z+CvcJaZ}d$bk>dv*aK%0d8~Wi0bh0x$kVnbF# zDbQQxv2?Av=;H|H{(gHmR%;78alY*{21a{ffB7)#;;6F{(F|@sdkGB@`XlW7WSZa% zx5B;C+2(ON75z1y(CJU@lWCXl(-@YMT5cU#CW@GyY9^$7vwX=eYcO!5~1%IN*R`0tm&xuHr1)?3E_XuZkUa3-gvs?GM5AKu`bZ_3uHaOHBtpE}hm=@#UtPc{3ohWH0CY4b3J;rs-Kt%i5(%XE`M$IZTnD zYO&P1f~I%BRz(YJDL3q3Eh-z)Gw@TcZpOvm3TlcVB|`o8{g7jLCVqw}Y|)AoMGRF> zAeZ%0;$pR4S3ZCKWa(mqxsqF#&r3W}_Ph!4Qe1$ABw6`!_8JfhXeNo_xgk3qttT@) zBv}g{>>N%NyCt_x(15Cp;XXjiX6M>`Rr6XqUA>8YKXPk{u;W~+C&K#nW>xz3`_QYJ1tLs_RRbqhkjRA4Mtoiv0e$=6n=l($94U{vLm@Pe z{$w(}+;_fJ#b7K^#An1*fDxQ!FqZH)y5@NX7vPUig(vhuEd*}ZsdPaTaM`eGQgqzN z{Ks*kF!CvYp*$NuLEBdQt<)n@bd@3>u@Ic# z3a|`vu?zySwmSC+u|-$Ng4Ah()YX1W6lrkB3_-E@#!~Q7=qvbs3ihY#mxe*~V;KSHnu^1RD}e$Hy04i)wM zvV9)u$jHcYx?~)lvOLei&0B->c@+XFZn_VcYyl z(g-e+bdFk;+r#2)T^&WmJTwBeROhFk_X-)$nrk0QLrD&oT;k>dm4{PT%JqYLD} zW=Ed|{EIBS|6gQYtjOg=VQGcLk-pfj2Bhm z3U!d%HzfP$`UNX8S)^LT79zK9b1m48kiLg|q6M2?fDAv>hh9H_-@4!vAXl| z$jC2_LQ>V(*w`BU_wRzw2vhUUcq&_ddAqeaUGZ|bxA7Ct-IJrc{tT*SFCO$X@6)!^ z1~-#zyh{YUuHyrI6MuWUSSu_e+6lzTXYz4cLkaM*K&d3>>1VElAJ(Vv*M8K*I4J)gih_UhRz(5m}s(H^fx-fU%Zxz_Aw#~L>AozuaA&msU zqrw9A#?n8;CMGJQ+HG{hfL6~AdZ!9yyiZ;Dq0=tOi_T=fCI8~2cv%iSETZsQnJ@jv z(RqyR;gOpzsv`ce`U=fP`kaD-ucUZ*vv>Z8B!5B2RqfHXTq7<7%X#9zo}qdERMXJV zkao7(e)rDpa)`$9^=bXhWYzm_75VLPzAFgIE?+WT*M?y4uczh3gzh&2r84DcKp@a5 zsqgcJkhr}q#uu$JGa8|VN0|D#af8{yatOzLtM%J=UAFOa{;$zPq8Tavh)Ra3*uW)= zrzZ{!h`9|L7x6;}OAPvM|Ml1Ar+-34ZefNH=b;l_vAhdP87lM$r7nbLLp)MZtD7^% z>5MB0n}3sL3HLW&BjLOfJ^%POep$U3IudX@GIKXL53i)b$SMZs?rB><+5eY+SoQhH zYjy+|8i4Zt=a!OMnX~nzv8G|oYgi}IoDTu0d16wR7Y2Hb;Z*&*vN0%|(Y3<|WVkvG|T!YVztFF7)BN z$FTTdjk65X-vc;)GPawr@`+u7H(qx G0<=f=EBfC==!k`ada5jQ7+(zT5fQ#Df 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 BGoAnd literal 0 HcmV?d00001 diff --git a/python/_github_pages_docs/html/_images/tutorial_36_1.png b/python/_github_pages_docs/html/_images/tutorial_36_1.png new file mode 100644 index 0000000000000000000000000000000000000000..0974195a7d240dc15dfbd45ffb070a0312ddf454 GIT binary patch literal 8462 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 L#yVAhJd652qhJiS literal 0 HcmV?d00001 diff --git a/python/_github_pages_docs/html/_images/tutorial_57_1.png b/python/_github_pages_docs/html/_images/tutorial_57_1.png new file mode 100644 index 0000000000000000000000000000000000000000..2513307222a118e16d3c20d200d346d5638f1b93 GIT binary patch literal 36559 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 literal 0 HcmV?d00001 diff --git a/python/_github_pages_docs/html/_images/tutorial_61_2.png b/python/_github_pages_docs/html/_images/tutorial_61_2.png new file mode 100644 index 0000000000000000000000000000000000000000..09e6089d2bc642bebb8c981534151e769cf3a92e GIT binary patch literal 51505 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 literal 0 HcmV?d00001 diff --git a/python/_github_pages_docs/html/_sources/code.rst.txt b/python/_github_pages_docs/html/_sources/code.rst.txt new file mode 100644 index 0000000..fe9f1e0 --- /dev/null +++ b/python/_github_pages_docs/html/_sources/code.rst.txt @@ -0,0 +1,39 @@ +`fit` function +---------------- + +.. autofunction:: l0learn.fit + + +`cvfit` function +---------------- + +.. autofunction:: l0learn.cvfit + + +FitModels +--------- +.. autoclass:: l0learn.models.FitModel + + +CVFitModels +----------- +.. autoclass:: l0learn.models.CVFitModel + + +Generating Functions +-------------------- +.. autofunction:: l0learn.models.gen_synthetic +.. autofunction:: l0learn.models.gen_synthetic_high_corr +.. autofunction:: l0learn.models.gen_synthetic_logistic + +Scoring Functions +-------------------- +These functions are called by :py:meth:`l0learn.models.FitModel.score` and :py:meth:`l0learn.models.CVFitModel.score`. + +.. autofunction:: l0learn.models.regularization_loss +.. autofunction:: l0learn.models.squared_error +.. autofunction:: l0learn.models.logistic_loss +.. autofunction:: l0learn.models.squared_hinge_loss + + + diff --git a/python/_github_pages_docs/html/_sources/index.rst.txt b/python/_github_pages_docs/html/_sources/index.rst.txt new file mode 100644 index 0000000..18e9975 --- /dev/null +++ b/python/_github_pages_docs/html/_sources/index.rst.txt @@ -0,0 +1,21 @@ +.. l0learn documentation master file, created by + sphinx-quickstart on Wed Nov 17 07:46:32 2021. + You can adapt this file completely to your liking, but it should at least + contain the root `toctree` directive. + +Welcome to l0learn's documentation! +=================================== + +.. toctree:: + :maxdepth: 2 + + tutorial.ipynb + code + + +Indices and tables +================== + +* :ref:`genindex` +* :ref:`modindex` +* :ref:`search` diff --git a/python/_github_pages_docs/html/_sources/tutorial.ipynb.txt b/python/_github_pages_docs/html/_sources/tutorial.ipynb.txt new file mode 100644 index 0000000..fce1fac --- /dev/null +++ b/python/_github_pages_docs/html/_sources/tutorial.ipynb.txt @@ -0,0 +1,1338 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Introduction\n", + "`l0learn` is a fast toolkit for L0-regularized learning. L0 regularization selects the best subset of features and can outperform commonly used feature selection methods (e.g., L1 and MCP) under many sparse learning regimes. The toolkit can (approximately) solve the following three problems\n", + "\n", + "\\begin{equation}\n", + "\\min_{\\beta_0, \\beta} \\sum_{i=1}^{n} \\ell(y_i, \\beta_0+ \\langle x_i, \\beta \\rangle) + \\lambda ||\\beta||_0 \\quad \\quad (L0) \n", + "\\end{equation}\n", + "\n", + "\n", + "\\begin{equation}\n", + "\\min_{\\beta_0, \\beta} \\sum_{i=1}^{n} \\ell(y_i, \\beta_0+ \\langle x_i, \\beta \\rangle) + \\lambda ||\\beta||_0 + \\gamma||\\beta||_1 \\quad (L0L1) \n", + "\\end{equation}\n", + "\n", + "\n", + "\\begin{equation}\n", + "\\min_{\\beta_0, \\beta} \\sum_{i=1}^{n} \\ell(y_i, \\beta_0+ \\langle x_i, \\beta \\rangle) + \\lambda ||\\beta||_0 + \\gamma||\\beta||_2^2 \\quad (L0L2)\n", + "\\end{equation}\n", + "\n", + "where $\\ell$ is the loss function, $\\beta_0$ is the intercept, $\\beta$ is the vector of coefficients, and $||\\beta||_0$ denotes the L0 norm of $\\beta$, i.e., the number of non-zeros in $\\beta$. We support both regression and classification using either one of the following loss functions:\n", + "\n", + "* Squared error loss\n", + "* Logistic loss (logistic regression)\n", + "* Squared hinge loss (smoothed version of SVM).\n", + "\n", + "The parameter $\\lambda$ controls the strength of the L0 regularization (larger $\\lambda$ leads to less non-zeros). The parameter $\\gamma$ controls the strength of the shrinkage component (which is the L1 norm in case of L0L1 or squared L2 norm in case of L0L2); adding a shrinkage term to L0 can be very effective in avoiding overfitting and typically leads to better predictive models. The fitting is done over a grid of $\\lambda$ and $\\gamma$ values to generate a regularization path. \n", + "\n", + "The algorithms provided in l0learn` are based on cyclic coordinate descent and local combinatorial search. Many computational tricks and heuristics are used to speed up the algorithms and improve the solution quality. These heuristics include warm starts, active set convergence, correlation screening, greedy cycling order, and efficient methods for updating the residuals through exploiting sparsity and problem dimensions. Moreover, we employed a new computationally efficient method for dynamically selecting the regularization parameter $\\lambda$ in the path. For more details on the algorithms used, please refer to our paper [Fast Best Subset Selection: Coordinate Descent and Local Combinatorial Optimization Algorithms](https://pubsonline.informs.org/doi/10.1287/opre.2019.1919).\n", + "\n", + "The toolkit is implemented in C++ along with an easy-to-use Python interface. In this vignette, we provide a tutorial on using the Python interface. Particularly, we will demonstrate how use L0Learn's main functions for fitting models, cross-validation, and visualization.\n", + "\n", + "# Installation\n", + "L0Learn can be installed directly from pip by executing:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "```console\n", + "pip install l0learn\n", + "```" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "If you face installation issues, please refer to the [Installation Troubleshooting Wiki](https://github.com/hazimehh/L0Learn/wiki/Installation-Troubleshooting). If the issue is not resolved, you can submit an issue on [L0Learn's Github Repo](https://github.com/hazimehh/L0Learn).\n", + "\n", + "# Tutorial\n", + "To demonstrate how `l0learn` works, we will first generate a synthetic dataset and then proceed to fitting L0-regularized models. The synthetic dataset (y,X) will be generated from a sparse linear model as follows:\n", + "\n", + "* X is a 500x1000 design matrix with iid standard normal entries\n", + "* B is a 1000x1 vector with the first 10 entries set to 1 and the rest are zeros.\n", + "* e is a 500x1 vector with iid standard normal entries\n", + "* y is a 500x1 response vector such that y = XB + e\n", + "\n", + "This dataset can be generated in python as follows:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 1, + "outputs": [], + "source": [ + "import numpy as np\n", + "np.random.seed(4) # fix the seed to get a reproducible result\n", + "n, p, k = 500, 1000, 10\n", + "X = np.random.normal(size=(n, p))\n", + "B = np.zeros(p)\n", + "B[:k] = 1\n", + "e = np.random.normal(size=(n,))/2\n", + "y = X@B + e" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "More expressive and complete functions for generating datasets can be found are available in [l0learn.models](code.rst#l0learn.models). The available functions are:\n", + "\n", + "* [l0learn.models.gen_synthetic()](code.rst#l0learn.models.gen_synthetic)\n", + "* [l0learn.models.gen_synthetic_high_corr()](code.rst#l0learn.models.gen_synthetic_high_corr)\n", + "* [l0learn.models.gen_synthetic_logistic()](code.rst#l0learn.models.gen_synthetic_logistic)" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "We will use `l0learn` to estimate B from the data (y,X). First we load L0Learn:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 2, + "outputs": [], + "source": [ + "import l0learn" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "We will start by fitting a simple L0 model and then proceed to the case of L0L2 and L0L1.\n", + "\n", + "## Fitting L0 Regression Models\n", + "To fit a path of solutions for the L0-regularized model with at most 20 non-zeros using coordinate descent (CD), we use the [l0learn.fit](code.rst#l0learn.models.gen_synthetic) function as follows:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 3, + "outputs": [], + "source": [ + "fit_model = l0learn.fit(X, y, penalty=\"L0\", max_support_size=20)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "This will generate solutions for a sequence of $\\lambda$ values (chosen automatically by the algorithm). To view the sequence of $\\lambda$ along with the associated support sizes (i.e., the number of non-zeros), we use the built-in rich display from [ipython Rich Display](https://ipython.readthedocs.io/en/stable/config/integrating.html+) for iPython Notebooks. When running this tutorial in a more standard python environment, use the function [l0learn.models.FitModel.characteristics](code.rst#l0learn.models.FitModel.characteristics) to display the sequence of solutions." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 4, + "outputs": [ + { + "data": { + "text/plain": "FitModel({'loss': 'SquaredError', 'intercept': True, 'penalty': 'L0'})", + "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
l0support_sizeinterceptconverged
00.0795460-0.156704True
10.0787501-0.147182True
20.0658622-0.161024True
30.0504643-0.002500True
40.0445175-0.041058True
50.0416727-0.058013True
60.0397058-0.061685True
70.032715100.002157True
80.00021211-0.000857True
90.00018712-0.002161True
100.00017813-0.001199True
110.00015915-0.007959True
120.00014116-0.009603True
130.00013318-0.015697True
140.00013221-0.012732True
\n
" + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fit_model\n", + "# fit_model.characteristics()" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "To extract the estimated B for particular values of $\\lambda$ and $\\gamma$, we use the function [l0learn.models.FitModel.coeff](code.rst#l0learn.models.FitModel.coeff). For example, the solution at $\\lambda = 0.032715$ (which corresponds to a support size of 10 + plus an intercept term) can be extracted using:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 6, + "outputs": [ + { + "data": { + "text/plain": "<1001x1 sparse matrix of type ''\n\twith 11 stored elements in Compressed Sparse Column format>" + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fit_model.coeff(lambda_0=0.032715, gamma=0)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "The output is a sparse matrix of type [scipy.sparse.csc_matrix](https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.csc_matrix.html). Depending on the `include_intercept` parameter of [l0learn.models.FitModel.coeff](code.rst#l0learn.models.FitModel.coeff), The first element in the vector is the intercept and the rest are the B coefficients. Aside from the intercept, the only non-zeros in the above solution are coordinates 0, 1, 2, 3, ..., 9, which are the non-zero coordinates in the true support (used to generated the data). Thus, this solution successfully recovers the true support. Note that on some BLAS implementations, the `lambda` value we used above (i.e., `0.032715`) might be slightly different due to the limitations of numerical precision. Moreover, all the solutions in the regularization path can be extracted at once by calling [l0learn.models.FitModel.coeff](code.rst#l0learn.models.FitModel.coeff) without specifying a `lambda_0` or `gamma` value.\n", + "\n", + "The sequence of $\\lambda$ generated by `L0Learn` is stored in the object `fit_model`. Specifically, `fit_model.lambda_0` is a list, where each element of the list is a sequence of $\\lambda$ values corresponding to a single value of $\\gamma$. When using an L0 penalty , which has only one value of $\\gamma$ (i.e., 0), we can access the sequence of $\\lambda$ values using `fit.lambda_0[0]`. Thus, $\\lambda=0.032715$ we used previously can be accessed using `fit_model.lambda_0[0][7]` (since it is the 8th value in the output of :code:`fit.characteristics()`). The previous solution can also be extracted using `fit_model.coeff(lambda_0=0.032, gamma=0)`." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 8, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fit_model.lambda_0[0][7] = 0.03271533058913737\n" + ] + }, + { + "data": { + "text/plain": "array([[0.00215713],\n [1.02014176],\n [0.97338278],\n ...,\n [0. ],\n [0. ],\n [0. ]])" + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(f\"fit_model.lambda_0[0][7] = {fit_model.lambda_0[0][7]}\")\n", + "fit_model.coeff(lambda_0=0.032715, gamma=0).toarray()" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "We can make predictions using a specific solution in the grid using the function `fit_model.predict(newx, lambda, gamma)` where `newx` is a testing sample (vector or matrix). For example, to predict the response for the samples in the data matrix X using the solution with $\\lambda=0.0058037$, we call the prediction function as follows:" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 10, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[-2.68272239]\n", + " [-3.667317 ]\n", + " [-1.77309853]\n", + " ...\n", + " [ 2.25545111]\n", + " [-0.77364234]\n", + " [-2.15002055]]\n" + ] + } + ], + "source": [ + "with np.printoptions(threshold=10):\n", + " print(fit_model.predict(x=X, lambda_0=0.032715, gamma=0))" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "We can also visualize the regularization path by plotting the coefficients of the estimated B versus the support size (i.e., the number of non-zeros) using the [l0learn.models.FitModel.plot()](code.rst#l0learn.models.FitModel.plot) method as follows:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 9, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ax = fit_model.plot(include_legend=True)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "The legend of the plot presents the variables in the order they entered the regularization path. For example, variable 7 is the first variable to enter the path, and variable 6 is the second to enter. Thus, roughly speaking, we can view the first $k$ variables in the legend as the best subset of size $k$. To show the lines connecting the points in the plot, we can set the parameter :code:`show_lines=True` in the `plot` function, i.e., call :code:`fit.plot(fit, gamma=0, show_lines=True)`. Moreover, we note that the plot function returns a [matplotlib.axes._subplots.AxesSubplot](https://pandas.pydata.org/pandas-docs/version/0.21/visualization.html) object, which can be further customized using the `matplotlib` package. In addition, both the [l0learn.models.FitModel.plot()](code.rst#l0learn.models.FitModel.plot) and [l0learn.models.CVFitModel.cv_plot()](code.rst#l0learn.models.CVFitModel.cv_plot) accept :code:`**kwargs` parameter to allow for customization of the plotting behavior.\n" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 11, + "outputs": [ + { + "data": { + "text/plain": "" + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fit_model.plot(show_lines=True)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "## Fitting L0L2 and L0L1 Regression Models\n", + "We have demonstrated the simple case of using an L0 penalty. We can also fit more elaborate models that combine L0 regularization with shrinkage-inducing penalties like the L1 norm or squared L2 norm. Adding shrinkage helps in avoiding overfitting and typically improves the predictive performance of the models. Next, we will discuss how to fit a model using the L0L2 penalty for a two-dimensional grid of :math:`\\lambda` and :math:`\\gamma` values. Recall that by default, `l0learn` automatically selects the :math:`\\lambda` sequence, so we only need to specify the :math:`\\gamma` sequence. Suppose we want to fit an L0L2 model with a maximum of 20 non-zeros and a sequence of 5 :math:`\\gamma` values ranging between 0.0001 and 10. We can do so by calling [l0learn.fit](code.rst#l0learn.fit) with :code:`penalty=\"L0L2\"`, :code:`num_gamma=5`, :code:`gamma_min=0.0001`, and :code:`gamma_max=10` as follows:" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 12, + "outputs": [], + "source": [ + "fit_model_2 = l0learn.fit(X, y, penalty=\"L0L2\", num_gamma = 5, gamma_min = 0.0001, gamma_max = 10, max_support_size=20)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "`l0learn` will generate a grid of 5 :math:`\\gamma` values equi-spaced on the logarithmic scale between 0.0001 and 10. Similar to the case for L0, we can display a summary of the regularization path using the [l0learn.models.FitModel.characteristics](code.rst#l0learn.models.FitModel.characteristics) function as follows:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 14, + "outputs": [ + { + "data": { + "text/plain": "FitModel({'loss': 'SquaredError', 'intercept': True, 'penalty': 'L0L2'})", + "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
l0support_sizeinterceptconvergedl2
00.0037880-0.156704True10.0000
10.0037501-0.156250True10.0000
20.0029112-0.148003True10.0000
30.0026543-0.148650True10.0000
40.0025973-0.148650True10.0000
..................
1280.000216100.002130True0.0001
1290.00017313-0.003684True0.0001
1300.00016713-0.003685True0.0001
1310.00013418-0.015724True0.0001
1320.00013021-0.012762True0.0001
\n

133 rows × 5 columns

\n
" + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fit_model_2 # Using ipython Rich Display\n", + "# fit_model_2.characteristics() # For non Rich Display" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "The sequence of $\\gamma$ values can be accessed using `fit_model_2.gamma`. To extract a solution we use the [l0learn.models.FitModel.coeff](code.rst#l0learn.models.FitModel.coeff) method. For example, extracting the solution at $\\lambda=0.0016$ and $\\gamma=10$ can be done using:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 40, + "outputs": [ + { + "data": { + "text/plain": "<1001x1 sparse matrix of type ''\n\twith 11 stored elements in Compressed Sparse Column format>" + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fit_model_2.coeff(lambda_0=0.0016, gamma=10)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Similarly, we can predict the response at this pair of $\\lambda$ and $\\gamma$ for the matrix X using" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 41, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[-0.31499242]\n", + " [-0.3474209 ]\n", + " [-0.23997924]\n", + " ...\n", + " [-0.06707991]\n", + " [-0.18562493]\n", + " [-0.25608131]]\n" + ] + } + ], + "source": [ + "with np.printoptions(threshold=10):\n", + " print(fit_model_2.predict(x=X, lambda_0=0.0016, gamma=10))" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "The regularization path can also be plotted at a specific $\\gamma$ using `fit_model_2.plot(gamma=10)`. Here we can see the influence of ratio of $\\gamma$ and $\\lambda$. Since $\\gamma$ is so large ($10$) maintaining sparisity, then $\\lambda$ can be quite small $0.0016$ which this results in a very stable estimate of the magnitude of the coeffs." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 44, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/tnonet/Documents/GitHub/L0Learn/python/l0learn/models.py:438: UserWarning: Duplicate solution seen at support size 3. Plotting only first solution\n", + " warnings.warn(f\"Duplicate solution seen at support size {support_size}. Plotting only first solution\")\n", + "/Users/tnonet/Documents/GitHub/L0Learn/python/l0learn/models.py:438: UserWarning: Duplicate solution seen at support size 10. Plotting only first solution\n", + " warnings.warn(f\"Duplicate solution seen at support size {support_size}. Plotting only first solution\")\n", + "/Users/tnonet/Documents/GitHub/L0Learn/python/l0learn/models.py:438: UserWarning: Duplicate solution seen at support size 11. Plotting only first solution\n", + " warnings.warn(f\"Duplicate solution seen at support size {support_size}. Plotting only first solution\")\n", + "/Users/tnonet/Documents/GitHub/L0Learn/python/l0learn/models.py:438: UserWarning: Duplicate solution seen at support size 12. Plotting only first solution\n", + " warnings.warn(f\"Duplicate solution seen at support size {support_size}. Plotting only first solution\")\n" + ] + }, + { + "data": { + "text/plain": "" + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fit_model_2.plot(gamma=10, show_lines=True)\n" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Finally, we note that fitting an L0L1 model can be done by just changing the `penalty` to \"L0L1\" in the above (in this case `gamma_max` will be ignored since it is automatically selected by the toolkit; see the reference manual for more details.)\n", + "\n", + "## Higher-quality Solutions using Local Search\n", + "By default, `l0learn` uses coordinate descent (CD) to fit models. Since the objective function is non-convex, the choice of the optimization algorithm can have a significant effect on the solution quality (different algorithms can lead to solutions with very different objective values). A more elaborate algorithm based on combinatorial search can be used by setting the parameter `algorithm=\"CDPSI\"` in the call to `l0learn.fit`. `CDPSI` typically leads to higher-quality solutions compared to CD, especially when the features are highly correlated. CDPSI is slower than CD, however, for typical applications it terminates in the order of seconds.\n", + "\n", + "## Cross-validation\n", + "We will demonstrate how to use K-fold cross-validation (CV) to select the optimal values of the tuning parameters $\\lambda$ and $\\gamma$. To perform CV, we use the [l0learn.cvfit](code.rst#l0learn.cvfit) function, which takes the same parameters as [l0learn.fit](code.rst#l0learn.fit), in addition to the number of folds using the `num_folds` parameter and a seed value using the `seed` parameter (this is used when randomly shuffling the data before performing CV).\n", + "\n", + "For example, to perform 5-fold CV using the `L0L2` penalty (over a range of 5 `gamma` values between 0.0001 and 0.1) with a maximum of 50 non-zeros, we run:" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 45, + "outputs": [], + "source": [ + "cv_fit_result = l0learn.cvfit(X, y, num_folds=5, seed=1, penalty=\"L0L2\", num_gamma=5, gamma_min=0.0001, gamma_max=0.1, max_support_size=50)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Note that the object returned during cross validation is [l0learn.models.CVFitModel](code.rst#l0learn.models.CVFitModel) which subclasses [l0learn.models.FitModel](code.rst#l0learn.models.FitModel) and thus has the same methods and underlinying structure. The cross-validation errors can be accessed using the `cv_means` attribute of a `CVFitModel`: `cv_fit_result.cv_means` is a list where the ith element, `cv_fit_result.cv_means[i]`, stores the cross-validation errors for the ith value of gamma `cv_fit_result.gamma[i]`). To find the minimum cross-validation error for every `gamma`, we apply the :code:`np.argmin` function for every element in the list :`cv_fit_result.cv_means`, as follows:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 52, + "outputs": [ + { + "data": { + "text/plain": "[(0, 8, 0.5313128699361661),\n (1, 8, 0.2669789604993652),\n (2, 8, 0.2558807301729078),\n (3, 20, 0.25555788170828786),\n (4, 19, 0.2555564968851251)]" + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gamma_mins = [(i, np.argmin(cv_mean), np.min(cv_mean)) for i, cv_mean in enumerate(cv_fit_result.cv_means)]\n", + "gamma_mins" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "The above output indicates that the 5th value of gamma achieves the lowest CV error (`=0.255`). We can plot the CV errors against the support size for the 5th value of gamma, i.e., `gamma = cv_fit_result.gamma[4]`, using:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 50, + "outputs": [ + { + "data": { + "text/plain": "" + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "cv_fit_result.cv_plot(gamma = cv_fit_result.gamma[4])\n", + "cv_fit_result.cv_sds" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "The above plot is produced using the [matplotlib](https://pandas.pydata.org/pandas-docs/version/0.21/visualization.html) package and returns a [matplotlib.axes._subplots.AxesSubplot](https://pandas.pydata.org/pandas-docs/version/0.21/visualization.html) which can be further customized by the user. We can also note that we have error bars in the cross validation error which is stored in `cv_sds` attribute and can be accessed with `cv_fit_result.cv_sds`. To extract the optimal $\\lambda$ (i.e., the one with minimum CV error) in this plot, we execute the following:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 57, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4 19 0.2555564968851251\n", + "Optimal lambda = 0.0016080760437896327\n" + ] + } + ], + "source": [ + "optimal_gamma_index, optimal_lambda_index, min_error = min(gamma_mins, key = lambda t: t[2])\n", + "print(optimal_gamma_index, optimal_lambda_index, min_error)\n", + "print(\"Optimal lambda = \", fit_model_2.lambda_0[optimal_gamma_index][optimal_lambda_index])" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "To print the solution corresponding to the optimal gamma/lambda pair:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 58, + "outputs": [ + { + "data": { + "text/plain": "<1001x1 sparse matrix of type ''\n\twith 11 stored elements in Compressed Sparse Column format>" + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cv_fit_result.coeff(lambda_0=fit_model_2.lambda_0[optimal_gamma_index][optimal_lambda_index],\n", + " gamma=fit_model_2.gamma[optimal_gamma_index])" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "The optimal solution (above) selected by cross-validation correctly recovers the support of the true vector of coefficients used to generate the model." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 70, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1.01994648 1. ]\n", + " [0.97317979 1. ]\n", + " [0.99813347 1. ]\n", + " [0.99669481 1. ]\n", + " [1.01128182 1. ]\n", + " [1.00190748 1. ]\n", + " [1.01272103 1. ]\n", + " [0.99204841 1. ]\n", + " [0.99607406 1. ]\n", + " [1.0266543 1. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " ...\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]]\n" + ] + } + ], + "source": [ + "beta_vector = cv_fit_result.coeff(lambda_0=fit_model_2.lambda_0[optimal_gamma_index][optimal_lambda_index],\n", + " gamma=fit_model_2.gamma[optimal_gamma_index],\n", + " include_intercept=False).toarray()\n", + "\n", + "with np.printoptions(threshold=30, edgeitems=15):\n", + " print(np.hstack([beta_vector, B.reshape(-1, 1)]))" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "## Fitting Classification Models\n", + "All the commands and plots we have seen in the case of regression extend to classification. We currently support logistic regression (using the parameter `loss=\"Logistic\"`) and a smoothed version of SVM (using the parameter `loss=\"SquaredHinge\"`). To give some examples, we first generate a synthetic classification dataset (similar to the one we generated in the case of regression):" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 72, + "outputs": [], + "source": [ + "import numpy as np\n", + "np.random.seed(4) # fix the seed to get a reproducible result\n", + "n, p, k = 500, 1000, 10\n", + "X = np.random.normal(size=(n, p))\n", + "B = np.zeros(p)\n", + "B[:k] = 1\n", + "e = np.random.normal(size=(n,))/2\n", + "y = np.sign(X@B + e)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "More expressive and complete functions for generating datasets can be found are available in [l0learn.models](code.rst#l0learn.models). The available functions are:\n", + "\n", + "* [l0learn.models.gen_synthetic()](code.rst#l0learn.models.gen_synthetic)\n", + "* [l0learn.models.gen_synthetic_high_corr()](code.rst#l0learn.models.gen_synthetic_high_corr)\n", + "* [l0learn.models.gen_synthetic_logistic()](code.rst#l0learn.models.gen_synthetic_logistic)\n", + "\n", + "An L0-regularized logistic regression model can be fit by specificying `loss = \"Logistic\"` as follows:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 117, + "outputs": [ + { + "data": { + "text/plain": "FitModel({'loss': 'Logistic', 'intercept': True, 'penalty': 'L0L2'})", + "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
l0support_sizeinterceptconvergedl2
025.2253361-0.036989True1.000000e-07
119.4320532-0.043199True1.000000e-07
218.9286032-0.043230True1.000000e-07
315.1428822-0.043245True1.000000e-07
412.11430690.004044True1.000000e-07
57.411211100.188422False1.000000e-07
67.188875100.219990False1.000000e-07
75.751100100.234899False1.000000e-07
84.600880100.242631False1.000000e-07
93.680704100.243655True1.000000e-07
102.944563100.243993True1.000000e-07
112.355651100.244295True1.000000e-07
121.884520100.244520True1.000000e-07
131.507616100.244716True1.000000e-07
141.206093100.244886True1.000000e-07
150.964874100.245011True1.000000e-07
160.771900100.245133True1.000000e-07
170.617520120.178144False1.000000e-07
180.598994120.196406False1.000000e-07
190.479195120.208883False1.000000e-07
200.383356150.192033False1.000000e-07
210.371856150.221470False1.000000e-07
220.297484150.246182False1.000000e-07
230.23798816-0.110626False1.000000e-07
240.23084816-0.118558False1.000000e-07
250.18467816-0.124533False1.000000e-07
260.14774321-0.211002False1.000000e-07
\n
" + }, + "execution_count": 117, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fit_model_3 = l0learn.fit(X,y,loss=\"Logistic\", max_support_size=20)\n", + "fit_model_3" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "The output above indicates that $\\gamma=10^{-7}$ by default we use a small ridge regularization (with $\\gamma=10^{-7}$) to ensure the existence of a unique solution. To extract the coefficients of the solution with $\\lambda = 8.69435$ we use the following code. Notice that we can ignore the specification of gamma as there is only one gamma used in L0 Logistic regression:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 83, + "outputs": [], + "source": [ + "np.where(fit_model_3.coeff(lambda_0=7.411211).toarray() > 0)[0]" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "The above indicates that the 10 non-zeros in the estimated model match those we used in generating the data (i.e, L0 regularization correctly recovered the true support). We can also make predictions at the latter $\\lambda$ using:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 84, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1.69583037e-04]\n", + " [4.92440655e-06]\n", + " [3.92195535e-03]\n", + " ...\n", + " [9.99161941e-01]\n", + " [1.69035746e-01]\n", + " [9.99171256e-04]]\n" + ] + } + ], + "source": [ + "with np.printoptions(threshold=10):\n", + " print(fit_model_3.predict(X, lambda_0=7.411211))" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Each row in the above is the probability that the corresponding sample belongs to class $1$. Other models (i.e., L0L2 and L0L1) can be similarly fit by specifying `loss = \"Logistic\"`.\n", + "\n", + "Finally, we note that L0Learn also supports a smoothed version of SVM by using squared hinge loss `loss = \"SquaredHinge\"`. The only difference from logistic regression is that the `predict` function returns $\\beta_0 + \\langle x, \\beta \\rangle$ (where $x$ is the testing sample), instead of returning probabilities. The latter predictions can be assigned to the appropriate classes by using a thresholding function (e.g., the sign function)." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "## Advanced Options\n", + "\n", + "### Sparse Matrix Support\n", + "Starting in version 2.0.0, L0Learn supports sparse matrices of type [scipy.sparse.csc_matrix](https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.csc_matrix.html). If your sparse matrix uses a different storage format, please convert it to `csc_matrix` before using it in `l0learn`. `l0learn` keeps the matrix sparse internally and thus is highly efficient if the matrix is sufficiently sparse. The API for sparse matrices is the same as that of dense matrices, so all the demonstrations in this vignette also apply for sparse matrices. For example, we can fit an L0-regularized model on a sparse matrix as follows:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 90, + "outputs": [ + { + "data": { + "text/plain": " l0 support_size intercept converged\n0 0.031892 0 0.009325 True\n1 0.031573 1 0.004882 True\n2 0.020606 2 -0.002187 True\n3 0.014442 3 -0.004111 True\n4 0.013932 4 -0.002556 True\n5 0.010854 5 0.002987 True\n6 0.009286 6 0.002048 True\n7 0.009191 7 -0.001371 True\n8 0.008771 8 -0.000533 True\n9 0.008151 9 0.000064 True\n10 0.006480 11 0.001587 True\n11 0.006364 12 -0.003636 True\n12 0.005760 13 -0.003866 True\n13 0.005560 15 -0.004211 True\n14 0.005264 17 0.001497 True\n15 0.004637 18 -0.000797 True\n16 0.004515 19 -0.002634 True\n17 0.004113 22 0.001419 True", + "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
l0support_sizeinterceptconverged
00.03189200.009325True
10.03157310.004882True
20.0206062-0.002187True
30.0144423-0.004111True
40.0139324-0.002556True
50.01085450.002987True
60.00928660.002048True
70.0091917-0.001371True
80.0087718-0.000533True
90.00815190.000064True
100.006480110.001587True
110.00636412-0.003636True
120.00576013-0.003866True
130.00556015-0.004211True
140.005264170.001497True
150.00463718-0.000797True
160.00451519-0.002634True
170.004113220.001419True
\n
" + }, + "execution_count": 90, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from scipy.sparse import random\n", + "from scipy.stats import norm\n", + "\n", + "\n", + "X_sparse = random(n, p, density=0.01, format='csc', data_rvs=norm().rvs)\n", + "y_sparse = (X_sparse@B + e)\n", + "\n", + "fit_model_sparse = l0learn.fit(X_sparse, y_sparse, penalty=\"L0\", max_support_size=20)\n", + "\n", + "fit_model_sparse.characteristics()" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "### Selection on Subset of Variables\n", + "In certain applications, it is desirable to always include some of the variables in the model and perform variable selection on others. `l0learn` supports this option through the `exclude_first_k` parameter. Specifically, setting `exclude_first_k = K` (where K is a non-negative integer) instructs `l0learn` to exclude the first K variables in the data matrix `X` from the L0-norm penalty (those K variables will still be penalized using the L2 or L1 norm penalties.). For example, below we fit an `L0` model and exclude the first 3 variables from selection by setting `excludeFirstK = 3`:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 94, + "outputs": [ + { + "data": { + "text/plain": " l0 support_size intercept converged\n0 0.050464 3 -0.017599 True\n1 0.044333 4 -0.021333 True\n2 0.032770 5 -0.027624 True\n3 0.029367 7 -0.029115 True\n4 0.024710 8 -0.021199 True\n5 0.021393 9 0.010249 True\n6 0.014785 10 0.016812 True", + "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
l0support_sizeinterceptconverged
00.0504643-0.017599True
10.0443334-0.021333True
20.0327705-0.027624True
30.0293677-0.029115True
40.0247108-0.021199True
50.02139390.010249True
60.014785100.016812True
\n
" + }, + "execution_count": 94, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fit_model_k = l0learn.fit(X, y, penalty=\"L0\", max_support_size=10, exclude_first_k=3)\n", + "fit_model_k.characteristics()" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Plotting the regularization path:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 93, + "outputs": [ + { + "data": { + "text/plain": "" + }, + "execution_count": 93, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fit_model_k.plot(show_lines=True)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "We can see in the plot above that first 3 variables, (0, 1, 2) are included in all the solutions of the path\n", + "\n", + "### Coefficient Bounds\n", + "Starting in version 2.0.0, `l0learn` supports bounds for CD algorithms for all losses and penalties. (We plan to support bound constraints for the CDPSI algorithm in the future). By default, `l0learn` does not apply bounds, i.e., it assumes $-\\infty <= \\beta_i <= \\infty$ for all i. Users can supply the same bounds for all coefficients by setting the parameters `lows` and `highs` to scalar values (these should satisfy: `lows <= 0`, `lows != highs`, and `highs >= 0`). To use different bounds for the coefficients, `lows` and `highs` can be both set to vectors of length `p` (where the i-th entry corresponds to the bound on coefficient i).\n", + "\n", + "All of the following examples are valid." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 107, + "outputs": [], + "source": [ + "l0learn.fit(X, y, penalty=\"L0\", lows=-0.5)\n", + "l0learn.fit(X, y, penalty=\"L0\", highs=0.5)\n", + "l0learn.fit(X, y, penalty=\"L0\", lows=-0.5, highs=0.5)\n", + "\n", + "max_value = 0.25\n", + "highs_array = max_value*np.ones(p)\n", + "highs_array[0] = 0.1\n", + "fit_model_bounds = l0learn.fit(X, y, penalty=\"L0\", lows=-0.1, highs=highs_array, max_support_size=20)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "We can see the coefficients are subject to the bounds." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 110, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/tnonet/Documents/GitHub/L0Learn/python/l0learn/models.py:438: UserWarning: Duplicate solution seen at support size 0. Plotting only first solution\n", + " warnings.warn(f\"Duplicate solution seen at support size {support_size}. Plotting only first solution\")\n", + "/Users/tnonet/Documents/GitHub/L0Learn/python/l0learn/models.py:438: UserWarning: Duplicate solution seen at support size 6. Plotting only first solution\n", + " warnings.warn(f\"Duplicate solution seen at support size {support_size}. Plotting only first solution\")\n", + "/Users/tnonet/Documents/GitHub/L0Learn/python/l0learn/models.py:438: UserWarning: Duplicate solution seen at support size 8. Plotting only first solution\n", + " warnings.warn(f\"Duplicate solution seen at support size {support_size}. Plotting only first solution\")\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "maximum value of coefficients = 0.25 <= 0.25\n", + "maximum value of first coefficient = 0.1 <= 0.1\n", + "minimum value of coefficient = -0.1 >= -0.1\n" + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhUAAAEGCAYAAADSTmfWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAADInklEQVR4nOyddZxU5f7H38+Z3tnuYItcusMgBIMQE/vaP70GV69e8+pVMa7d3ddAULHAAEERFQEB6W62u3f6PL8/ZnfZZmYbPe/Xa3ZmzjznPM8zOzPnc77PN4SUEg0NDQ0NDQ2NtqJ09QA0NDQ0NDQ0/hxookJDQ0NDQ0OjXdBEhYaGhoaGhka7oIkKDQ0NDQ0NjXZBExUaGhoaGhoa7YK+qwfQmURGRsqUlJSuHoaGhobGMcX69esLpJRRbdg/Wq/XvwUMQruYPZZRga1ut/v/Ro4cmddUg7+UqEhJSWHdunVdPQwNDQ2NYwohxKG27K/X69+KjY3tHxUVVawoipbH4BhFVVWRn58/ICcn5y3gjKbaaIpRQ0NDQ6OjGRQVFVWmCYpjG0VRZFRUVClei1PTbTpxPBoaGhoaf00UTVD8Oaj+PzarHTRRoaGhoaGhodEuaKJCQ0NDQ+MvwYIFC4JTUlIGJSUlDfr3v/8d29Xj6QzmzJkT3bt374F9+vQZOHPmzNSqqiqxc+dO45AhQ9KSkpIGzZgxo6fdbhft1Z8mKjQ0NDQ0uhUfrj4UPuaRZYNT7/pm5JhHlg3+cPWh8LYe0+12c8sttyR9++23u3fv3r3ts88+C1+/fr25PcbbHhTNmx++Z/yEwTv6Dxi5Z/yEwUXz5rd5zgcOHDC88cYbMRs3bty+Z8+ebR6PR7z11lvht956a4/Zs2fnHj58eGtISIj7+eefj2yPOUAXR38IIaYCzwM64C0p5WMNXr8V+D/ADeQDV0kpD1W/5gG2VDc9LKVs0hO1u/Px14s5vMyGxR6MzVxG0skWLjh9alcPyy8euu02PFZr7XNdZSX/eeqpZtu/8OA9FDskUm9AuF2EmQQ33fdI88e/8y48ZtOR49sd/Ofxx5pt/8KTT1BcUnLk+KGh3HT7HS3O4ZW77yVfUWv3iVIVbnj04XZr7y/+Hv+dR54m02bHo3Oh8xhIsJi56p5/dXkf/tDR7+lfkdZ8F7qaD1cfCn/o6+3JDreqAOSVO4wPfb09GeBv45KLWnvcn376yZqcnOwYMGCAE+Ccc84pWrBgQejIkSNz2mfkrado3vzwvMceS5YOhwLgzs835j32WDJA+EUXtnrOAB6PR1RWViomk8ljs9mUhIQE16pVq4K++uqr/QBXXXVV4QMPPBB/55135rd9JiC6qkqpEEIH7AZOATKAtcBFUsrtddqcBKyRUlYJIa4HJkkpL6h+rUJKGehPn6NGjZLdKaT0468Xk/Mt6FVj7Ta34iR2OseMsPAKikCoazyToKusaFJYvPDgPRS5daDUMZKpKuF6T5PColZQiDodSNmssHjhyScoKq9ofPygwGZ/TF+5+17yDEqjfaJdapMnNX/b+4u/x3/nkac57Civb3dUIckU1OxJvzP68IeOfk//irTmu9AcQoj1UspRrR3Lpk2bDg4dOrSg5vmZL/3ar7m227PLrC6PbGSODzLr3VseOG1TXpldf83763rVfe2r2SfuOtoY3n333bDFixcHf/zxx4cAXn755fA1a9YEvv/++4f9m03rOHDe+c3O2b5zpxWXq9GclaAgd7+1v29y5+fr02+4sd6cUz/95KhzBnjooYeiH3300QSTyaSOHz++7PXXX08fO3Zs2uHDh7cC7N271zBt2rS+e/bs2ebrXDZt2hQ5dOjQlKZe60pLxRhgr5RyP4AQYj5wJlArKqSUy+u0Xw38rVNH2MEcXmYjQA2pt02vGsn6zsZLWR83ah8VH1IrNl5/bwHxPSKYOeUkPB4Pr7694Kj9JfeKrte+/+Akphx3HIWlxcz7+Puj7t+w/ahx/RoLCgABHmsgj951e73NQSaVItUCugarbopCscPDS298TMXhrdQVuo0EBYAQeMwmDudk8csXX4DZRLErCNXjpqisHHS6RscvKivnjWeexGQ0ordaKXYFccG5U/h23lzydbL+D2/1Pnl6yZO3HPnxDe8Rid5karZ9vuKp174h0T3jQQh0FW4MhXDc389g+eJv0RW7EIUKlWo5pbpKKgNNzY5n0eefUbEzE4NNZfzsi9i2bRsZtorG32QF0u3lvHDXf5ESdEZJrzFDcDsdlG1JJ19pfs7P3v4AQugQQgEEQkCxwem1JzbRx4e3PotQJeUGF06dBwDvv1ACEikl5mADSUP6A1D0034SBkVjTI4mP7+AytXZ5FubH89T/7oLU5CJsLgYjEYTtl1V9DuxF/nlhVTZ7Nj2u5ACiuwZeJr4LAJYQwIICQ/DYDJTlgPjThvOzo3rUYWO0gKBKiWlxfuQiPqfZ+H9ExoWiNVqxWgNpKDSxPQZx/Hbt9+gBAVRWGlCddqpzNnb7P8+MjIUs9GIPiSEwkoT58w4gWVffYE+JJSiSiOeylKqCtOb3T8mOhy9TocuNIySKiOzph7HkoVfIkIjKK3U4yrLx16Se2QHKXEoosnvQnFJSbP9dAeaEhQA5Xb3nzevUhOCAkAtL2/TnPPz83XffPNN6N69e7dERER4ZsyY0fOLL74Ibssxj0ZX/pMSgLrfogxgbAvtrwa+q/PcLIRYh3dp5DEp5ZdN7SSEuBa4FiApKakt4213LPam/7cGjxn+MDXafjA3F073Pq5Yb2R3UTZMAVVK+CPiqP3trqzffpcunSnHHUdpeYVP+zdsvzcyo8X2DlNA/efQrBeP1OvhjwjsUTT+IWyG3IJC9mbnYJYSa/4kkHaIbaYDRSGrtAIAS24+1vxJlJ5awoH8ItA18zVQFCqDLbVPK8sqgcpm20u9nsrg5r9SBwqKAQgpchFYMYLczAwO5BcRlqtDL4+nSr+JyjC1+QkrCus3bSYsV0dQVSKbV/3Kyg2bQQd7onqwpudAKkwWAh02xu7fRp+8DIpMjtrdC6qtdJFZUch4PXuiEprcpzRA4v1aNaTx755UJKWVgwEoUX7AFWBs1AYAl5uc9X8gkERWTkC3cQM56Tup9ECYbSIy5Jdm51wRaKJCQmFWLnqpElY8kew1W9gl85BCR3D+JAAqww+jGht/bwCqHC7ys/MwqR6C8yaR9ct6dubuxyQE1oLJSOnCFrMflKY/eznlVVBeRYA7C2vBZHLCf2dPZjaBrkwsxZNBLcIR37yLWmZxGQCB6TlYik4iv9cO9ucWEHQwF3PpJCRlOJr77AKHC0u8+x8uwFIynvwBB9mfV0jQ/lLMFcfhEVk4YnxzkZN6g0/tOpKWLAtjHlk2OK/c0eiDFB1kcgJEB5vdvlgmGpKYmOjMzMysPW5GRoYxISHB6e9xWktLloU94ycMdufnN5qzPirKWX3v9tUyUZdFixYFJyUlOeLj490AZ511VsnKlSsDy8vLdS6XC4PBwMGDB40xMTHt9j4cE8pPCPE3YBQwsc7mZCllphCiJ/CjEGKLlHJfw32llG8Ab4B3+aNTBuwjNnMZAfaQJrff/tzZLe77rxeOuJAY9Hpmv3ayz/02bN+zRyKzX0v0ef+67edsWkdTb6oA7p8zp9H2Off8G2lofOIRbhezH+8PL18OPSdBn1Ohzyk88PTrzY5j9KDBjB40uMHxf2v2+Pc/8t9G2x+YM6fFMTW1z5x7/s3u+NRGJ+S+WQe4/6KREBAJ1kjvfUBE86IFGD3xpDrPTm75+JkHuOTsM0hIG4AlKJis3TuReVm8Z9ezot9w3NX9VJgD+KnfcDyqyhUWFWtgIAFBQZgDgzAHBpI0aChXvP5uo31W9BsOHjf3jR6EvaICR1Ul9soKHBUV/HYwE9nECVu4nNz4unfcf3xnozQ3G53RiN5gQGcwojcY0Ru9j3UGA2ZrIKnDRgInU5iRDgIiEhKZc8+Pzf4P7rz1X6DXoZhMIEGprEQJOB6PTgGXG1lYiPSouOzxSI8KqgcpVVBVhEdFqiqG+Hj0MdFgs+PYvBlTvzOZHBqCWlyCY+MmpEficY3x7ltzDI8HVBXp8RB4/HEYklPwZGdTvmQJweNnMObcs3Hs3kPF0qVItwepWpEe2eAY3vvwK67AlJqKbcMflHw0n+jBdzL4pMmUL11G2RefoXrckK4iVQ946txL732PF1/EEBtLyWefUfTOc6SO/IwHTphA/ksvU7LgEfB4kFtU773qvZ8/9dRm39PuzE1T+mTW9akAMOkV9aYpfTLbctyJEydWHjx40Lxz505jSkqK6/PPPw+fO3fu/raPuO1E3HBDZl2fCgBhMqkRN9zQpjmnpKQ4//jjj8Dy8nLFarWqP/74Y9DIkSOrioqKyt99992wa6+9tvidd96JOP3000vaPIlqulJUZAJ1z2Q9qrfVQwhxMnAPMFFKWXvZJaXMrL7fL4T4CRgONBIV3Zmkky3kfOts5FORdLKlhb26F/088ezUZTXyqejniW+yfZhJUORWG63zhpkESA8MOR92fw87vwZAV3EVnsDgxj4VlZX+H78Bti1bMQ8cQJSqkKc23ieq5jetshAOrPDe4oaSExTc5Ak5uLwAFlzVeFDmUK+4sEbCSf/2iqaSdNixEAaeDcHxYC8FexlYI8mJiGv6+HYbvUeM4rcyO64dq5l4eBHx1zzMlcvW4WkgXDw6PT8NGstP1c9PLV7D+9tvh1u2cfKGA+xOG1F7/BrcOj1rew6kX6QDUntAUBxYwkFR2PD3q6iKSah/Ja96sBQeMbmPmDazyf9Jc0T0OPL1b+l/YI5oYEWzeL8fCoAJCPS6VjVto2iA0YRh/Pgjz2NiMJ12qs9j1iclYbrmmtrnAQMGEDBggM/7W0eNxjpqdO3zkNNOI+S003zeP2zWLMJmzap9HjX7RqJm39hk27grricrKarRexqXWexzf11BjTPmCz/sScgvdxijgkzOm6b0yWyLkyaAwWDg6aefPjx16tS+Ho+Hiy++uGDUqFH29hl126hxxix85ZUEd0GBUR8Z6Yy44YbMtjppTp48uXLmzJnFQ4YM6a/X6xk4cGDVrbfemn/22WeXXHDBBb0efvjhhIEDB1bdfPPNBUc/mm90paOmHq+j5hS8YmItcLGUcludNsOBBcBUKeWeOtvDgCoppUMIEQmsAs6s6+TZFN3NURPg/QULKV8WiEQek9EfRV/u4ft1y9mly0Li1Rb9PPGcqPYn8qrBmHuHNtrnqNEfUkLedti9BH6Yw0Pl1cKiGl1FGf8Jfg/OeBFWvQRXLwVTIKx7BxbfzQsl0yg2xR85viOLm6JWwKy3wRoN0f2xbdvBwfPPJ/a+/xA2UMcrry8mPzT2SORBSQ43HF8O5dmQUx1kZAyCcdcxyjWWDGPj2kpG1cVQqxFFdSFUF8LjQlFdKB4nisfJx9lvwqS7eUvfl40Ze3lp8VT4vx95zp3A5vRdiOwNCOCH8LHYdI2FZQ97DutGpXJOhg5nWTZf/3Ie3Lqd2NWHGvudVL+Pd8qduKQkxVPK+c6dcPpzPLgvm1cO5za7z5iyLYws28aosm2MrNhDrFHPjkwPj4ddyq8jJlFhDiDQXsWJf/zEnVUL6f/fNS1/SHxEi/5oX0oXLeLTjxeSmRxV+54mHMrnvAvOIGSmfwKwvR01NY5tWnLU7DJRASCEmA48h9cF7B0p5SNCiAeBdVLKhUKIZcBgILt6l8NSyjOEEMcDr+OtmKYAz0kp3z5af91RVNgdDlb+8Qc94mPpl5za1cPxm7KcdJwrq7Cvy6NGVZiHRuLOqsRdYCN0Zi8Cj2vaauETDzReHqrlwo9g40cw6x3Qm2D1q7D4rqMf854cpN5MyUNXERKdhWLLhNJmnORSxkPqRK91IX446PTELt9AU/4FIBkfFoQqvW+FKmW1q6JXJy0a2QeAZw/m8HtJJfP6hYMxkLv35bKqoAjpqkRVVfbIgCZP+EKqZI9N4qASRAAq0WYzCMGoJUubFDk9nPmsO+2UJqfV3D6BnirSAsxsdgic1XNMUMuZmrmED+NOx6E/EtZvctt5ZveTnHvjZ7DqZa9gixkIkX1A5/+6/Wc5RTy6P5tMh4sEk4G7e8ZxbmybQ/X/0pQuWkTes8/hzs5GHxdH9C3/9FtQgCYqNOrTbUVFZ9MdRcWxzuv33o9TWLnuX//AEHrk6lq1uymavwv7ziKsY2MJPaMXomHUhy/MCfcuizRE6OD+JiyDzw6isrAnZe7L8RCJjgKC9e9hDduN++TnyH7idaIfehpTz56w7l3IXA8bPoTmPEMeKAHgQJWDMo+HoUEBjPhtG1mOxuvSPUwG1h0/0P85NsBfkfDZ799xW1kYNt2RE77FY+ep4GLOHTOtyT6Oto9DVdlabmN9WSXryqpYlXmQfENoo+NEuMroER5D+OFfCHcWEeYqI9xdTpjZQlhgOBGhMYRFJNE7IQ1zcGzT1hG8guK2XenY1CP/B4sieKpfoiYsugGaqNCoS3cNKdUAvvlpBRLJ6ZMmdfVQ/KaqKI88nUJPTwD6kPqJ6RSznojLBlC65CAVKzJw59sIv6Q/OqufV7Ajr6BopZ4qOR2vUUolQHxL+AlNRSdAZc//UpJrQeIdj4doStz/wBWaQ8EtT+IuLMR58JBXVIy60nvb/1PTloqQHmTanTx7MJd5OYUMDwrg65F9uadnXJMnwLt7xvk3t2a4O8zNbWX2Rif8u8OanvO5Y6bB79/xaLGeTEMECa5C7g5zNysofNnHpCiMDLEyMsTKtUBcXtPr8IWGIIYY9BQlnsg+h51it4dyWcfvwg3kwg/fzGDgkGnMHXwrTx/IZplpM+G9T2ShM5iVxeV8nltc7/0EsKmSR/Znc05MGKIZMaKhodG90ERFF7NlaSaoCqdP6uqR+M/Kj9/DIyS9o8Ob/NEXiiB0WiqGWCvFn+0m7+WNRF83BF2wTy51ABS5r6dKZnNkuUFHlTwdaY8hAlCrXFRtKUCtcqNWuahcH4GkflimxEzZ5hCk203yhx9iGdygau+U+/hs1ec8mnQFmaZoEhx5zM78lH0D/8Z7q3cggcvjI7k5OQag9sq5o0z1rRUJ57aiH1/3STAZyWjSOmNk3tB6OXlwqZISt5tCl5vi8mKKCw+RMv56iO1PD7ORCQGSoIWz4axX2BM8iUW5hZS7ZZNWjCyHix4rNrH7xMFY9TrezSxgdUkFrw9MAeD7glLynW7CDDrCDHrCDDrC9XpCDTqMDfNeaGhodDiaqOhCVFXFWBqEmlrW1UNpFXsyKgnQGxlyTvMnOwDr8Gj0EWaq1uWiBBqp3JBH2ZKDeEoc6EJNBJ+WgnV4dL19PJUuXNmVVK3JoansWrZ1eTCrH6rNTckX3qRDwqAgXZ4m2oMwh5Ly6aco1lAc+0swJgUj9N6TzmfRJ3Nbn97YhPd5hjmWu3rORtgFF8aFcWtKLInm+qF558aGd6hZvjUioSO52w/rjEERRBkNRBkNYLVAbDxwHOCNCZ8YOhCS1kJAOP+yhPEvuYuRu2xkmhvXdwpxlXFlwTICXr8OzniRSjWJkooSWPxvOOFm/pdZwY9F5U2OOVCnEGbQk2ox8smw3gDMzSrEKSVXJnhLHfxRWokQgvBqURKkUzSriIZGG9BERReSmZ+LyW3FEt+0Wbs7U5p9kAK9oK8nGEuPsKO2NyUFY0oKpnJDHsWf7QG315rgKXFQ/NlunIdKUUx6nNmVuHIqUct8y8WiCzUTe/cYdAF6hEHH4VsWoZhCG7WTzjIMMdFU/J5Nyed7ibl1JIboAFx5VTyyI6NWUNQiBFFC4dm07pUwratoV+uMokBEHetGz4n8+7tzua3f7Y2WfP675znO7REPSi8wBTE7OobZ5b/CD+/B2Gt5e1AqRStfpXjNOxQbgikyhFCsD6bYEEyxOYoiUwQmRYFNt8LZr/NdgY3KymKuPPAhHHcjN+88zJ6qIwnC9AJC9dUWj2rLx7CgAP6Z4hU83+WXEG00MDLEW+um0OkmWK/DoGhCREMDNFHRpWzf402rkVhtVj+WWPnpfFQh6dvDv7GXLTlYKyhqcUsqV+eATmCICsDcKxRDnBVDnJWCd7Y260MJIHQCfciR5RTHlgWYh12K0B/ZJt0OHFs+BU4nYEgUuiAj+iivU2n5T+lkR3qaNL3nq004iP6F6UjrzLnOXbDrCR7teW3tEtTd+9/gXOduOPPz+o0Hneu9ARYgYcR5JKSOBltx9a3Ee28vAVsmVJWAywY6Ix8OiUMu/y+seAKOv4kX+ieT/8vLFB1e5xUihhCKDaEUmSIoNoZxyBBMoKcQ1v8MZ7/OvXsyOUFfxciAw8iB5zBi1TYcqiRIJ6qXX/TVYkRPmN5r/RgZHMBJEd6Q6C3lVcSbjEQYO+en1xer4F+F8847L+WHH34IiYiIcPtT5+JYpqk5v/POO2H//e9/4/fv32/+6aefdkyYMKGqpv3dd98dO3fu3EhFUXj66acPn3vuuX6b0TVR0YWkH8oDQhnQu2dXD8Vv9uc6CNSbGTRrul/7eUocfBer5+W+JnLNghi75MbdDqbluEmYc3ztkkQNAWNjua+kmM8TDagCFAnnpLt4MPSIdURKSdXatVgGDQI1A/uGDzANPBthCUfainBs+wKkN6W4YtZj6e9NpvRtfgmvpUBMgSTH0lhUxNgl0qUiDNrafIcz5T7OXXQT56754cg2gwVmvnD0fQOjvTcfEZPuhhNuBkVheHAAjD4deqY1ECO7vY+Lq7e5HaAoLBzRB+XbOyB9OXLgOdzfK57idR9QXF7ktZQYwyg2hrHfEEKxPpAyxcLlju2cZMnEPf42Tlm3m9tCndwWKciNHsYp63YRphOEGY21lpEjwsRrLelvNZNkMaFKiSpB76NVpHJDHvN+2ctLQ8zkmg3E2CWzf9nLRdD9hcXat8NZ8XgCFXlGAqOdTLwzk9FXtykR1FVXXVVw880351155ZXdMnZ/y4qM8HXfHkyoKnUaA0KMzlHTUzIHT+zR7nMeNmyY7bPPPtt7zTXXpNRtu379evPnn38evmvXrm2HDh0ynHLKKX3PPPPMrXq9fzJBExVdSEm2DWEwkBDdeC25O1NwYCeFeskANRBjpPXoO9RhSS8Lj6TqsOu8P4w5FsEjg8woVg9X6xufvB/vb2JBprHWMqEKWJBkxJpg4vHqNvZt2zl82eXEPnA/0bf8k+z/3Efl97/XHkOYzcQ99CAAHilxqJIAnYJJUZA6hctyVV5IFLVjAjB7vGIna81qAk+IJ+TUlHrj0q4A25kh53vvf3gQSjMgpAdMue/I9vZECDDW+dxG9/fefCDBbITpD4KjHEUIruoRBfahUHyg2kpyEOwboaIEbCW4bKW4HBUQGA7jb+N/g1JJ/fYGoBzlos84JSKY4p3fUyT17DOGeS0l+kBc4shP833qVm6INnOo10yOW7ODV2M9nB0bwXZDDA/tzSJMKIQKQagqCFUh1A3hViOrNhzgrQEWHHW+aw8PsCBW7+bq7vxZXft2OEvuTsZdnbK6ItfIkruTAdoiLKZNm1axa9euZorTdC1bVmSEr/x0b7KnOjV5VanTuPLTvckAbREWTc15xIgRTWYRXbBgQeg555xTZLFYZFpamjM5Odnx008/WU8++eSm0xc3gyYquhB3gQ5CmnYy686s/uJzpID+vXyvF1LDy31M2BvknbDrBE/1MXB19fM7dqVT6vbgVCXfFZQ2WQX1g8xCbvt+IVH/mI154AASnnuOwEkTUczeNfmGCX+CTj+dhXklPHkgm1MjQ/hPr3gmhwcxOTyIKiWf4JX7eamnsdZ6Mnu/k1n9YpFVbnSB3u+k6vRQ8tU+dJFmKn5MR7qO+IWUfO5N+KoJizYw5PyOERHtjTnYe6uh95Rmmxqqb+D9sZ0aFQIzHwLVQ5TRwNNpSchyHWpRHrLiIGqhA0+Vkwp3FVX6AxR7JAFFA6gMCyOw35n8KyWGmPkryLblcyg4h5zeBnYZBKVGQaW+zhelEkgNaDQeu07wYnJA7Xety3jjpGbLgJOzxYraoGqn26Gw7IFERl9dRHmOnnkX1Q85una538W2OptPH13b7JwLMiqsaoPqrB63qqz+cl/i4Ik9iipLHfpvX9lcb87n3T26XeecmZlpHDduXEXN8/j4eGd6eroR76fJZzRR0UV4PB7M5SHIft07D39TnHbDLcR+soB+Z/les6CG7KYSWQHFdZKw/VFWhc2jYlSENxVlE/4OKmDfuhVVVXkzs4CTxk+kb7WgWDb6BB59uGetQ+HpUSGsXLebLRU2+gSYGB3svUqt8fK3Do/mImBGPctDz0YCwZ1XhW17IUInagVFDdKlUrbk4DElKjRrS/shVYm0u1Ft3pt0q5hSvNlgqzbmodrdBI7zZpYt+tGNK6sC1fY7apUb6egN9K53PEOPQJKvG04ykPfKRhwRJqKMBm5PjaMoJgH0Jo4Li+Ark0DJ/BFFLcWlFlNGJaWyijJZyTl9/tXkdyfX3M2dShsKihocZX/a81VDQVGD0+Y55uZ8zA34z8KBzAwMHhNB8UFdPRS/MZgtjLrs0lbtm2AyNJPv4EhSrGWjjwj6+GXrUZsoha6oKomvv0a63cn9e7Ow9FXoazXzxuE85uzPwlOtUTIcLl7LKCBCr+PF/kmcExOGrokfWuvw6KOeUI09goi/ZyyZ965s8nVPiYPKdbmYUoPRhZu7dWhi5YY8Sj7fo1lb6iClRDo83pwnNjeGeCtCCBz7S3HlVtammy/7KR3H3pJaAaHa3Ei7u55DsRKgJ/4+bxitbUsB7iJ7ragQOoEu2IQhxopi0SMsehSLHiWg+t6ir7WOAUTfMKzeOMOvGk99jvhkhXCkSmP8dz+TVdeiUk2coxtYR1uyLDzVdzAVuY2XKQKry3MHxbqPBctEQ1qyLLx756+Dq0qdjeYcEGJ0AlhDTO72tkw0JCEhocYyAUBWVpYxMTHR75LomqjoInonJRPwsAWTwf8aCV3Jt889TnGRYNZN12GKbPyDdTT8yXcAMPOXpXw18bRGVUpn/rIUTh5JotnIthMG1Yb0vXA4r1ZQ1MWsUzivHSIXhF5BF2rCU+Jo4kUoXrAbACXIiCk1GFNqCNaxcYhuFnJYtuRgt7O2tIflREqJdHpQbd5lK6FXcOVV4TxURsCIaIROoWpzPratBfVFQfV9XWEQP+c4hEmPbWchlauya0WFtLmRTg+6QAOGKMsRUWAxHBEGAUd+WsMv7o+o468Tdnaftr1RPnJPRCW3lZmx6Y6cqyweJ/dE+GXN7nwm3plZz6cCQG9SmXhnm8qAd2dGTU/JrOtTAaDTK+qo6SmdNudzzz235JJLLul533335R46dMhw8OBB86RJk/z+sGiioguJjzz2rgiLip2UYMEQ0Lry7DUhif/YcRgVr4WipXwH/1zwIQCLxp+CqigoqsrMX5Z6t8/xFg+rG55X6Go650dTtTpaS/BpKfWu8sGbeCvkrN6YegTiOFCG42ApzgOlONPLa09G5SvSERY9gWPaJ513XY52QpZuFXeJA0Ok9//WpCiq3m7bUYixRxC6oPoXTh25XNKS5cTcOxTn4TJMqSEoAQYch8qo2pDXSBCoNheqzQPVgjX6puEY4wNx7Cuh5Kt9mNPC0QUZ8RQ7cGVVesVAgAF9hKXWQqDUsRrU1KoJnpJE8JTk2rGGTPMveKCuoOhMWpOZtVtQ44zZztEfM2fOTF29enVQcXGxPiYmZshdd92Vdcstt3SLeiQ1zpjtHf3R1JwjIiLct99+e1JxcbH+7LPP7tO/f/+qX3/9dc+oUaPsZ511VlHfvn0H6nQ6nnnmmUP+Rn6AVlCsy3hn/pcoQnDFBWd29VD8xllRiTHQv6iPevurKkkrNnN7Siz/Sm058iV7zhxK5s1vtD30oguJu//+RttH/bat2eWV9ij2VYMvJ1gpJdLmRgnwWqPyXt+MPsRI+IVpSCkp+mgn+ugATKnBGJOCUYw6v45ft21DkYNe8RZym9EToQiKv9hD1aYC4u8bh1AEmXNWIW0tJ12zDI4k4hJvVETpsoNUrMhsJKRCz+lDwJAor3XA6UE6PN7HDg/6cDP6MDOeShdVf+RiTgvHEBWAK6eS8hUZ9do7MypqxUBddKEmQs/uTeG724i6fiim5GAq/8il9Ov99ZcO6loLqh+bB4SjCzR6BYfdjS7E1O0sRscKWkExjbpoBcW6IXk7K5uunt2NqSzKxxoe1SZBAZDv9J7MYkxHX/qpEQ61wkKnI/T885oUFOD/8kpr8cUHQwiBCDgyx+i/D0F6vCdlaffgLrRh21pAuQQUgSEhEFNqMFKVVK3JadHfQa1y4SqwoVa6KF20r9FSBm6VypVZBI6JxRBjJWBkDKZeobXm/dAzejVtbZnZC0OUBWdGea2lQrpUypc1LrgmXSrFH++i+OOml3pDZqQSNL4HapWL0m8OoAsyYogKQHV4cBwsRRh1KCYdwqRrUlDUzN2UHEz0P4bXJiyzjojBOsL3pGs1IkNDQ6Pj0b5pXcRdD1yCy31sped+7ZnXiBGBXPLgP9vkhJjr9FoSon3MKhh3//2YUlPRhYYScsYZLbbt6GJfbaXGpK5Y9MTcNALV7sZ5qKx2yaRiZRZNOYVIl0rxJ7swRFowJgZh215I8YI9R+1PH+E9EZuSgqFOxvEacdKcNcSUGlJn0C33EXxKMsKoQ5gUFKOu+rGudqlFH2Eh/oHjENWWGFNyMHF3jql3jOzHfm9ySUYXakIx6zEmBB51rhoaGl2PJiq6EEMr1qu6it0rvqFc76GfMLU5qiHP4RVT0UbfnVTDL7vM57YdXeyrPVHMesz9wjH3845XulQy/9N0dAkS71U9YOodRsQVA9FZDRR8sL3JWim6UFOjDKV18cXaAi07p+pCTQRPabk+ilAEwtzyZ705P5Xg01KOOj4NDY3ug5Z/uAv4dsXPPDZnLum52V09FJ9Z+9NahIRhJ7R6WbWWPD8tFdLlwpWXh/T8+WtxCIP3BN4UulAThmhvQiN9qAlLWjjGxCBCpqU2SiXe3ifk4NNSOrQP6/BoQs/pUzt3XaiJ0HP6/GXDWzU0jlWOnUvlPxEHdmdjzY4hPCS0q4fiE6rHQ6ZbRyyBJExqu6ioWf6I8tFS4di7lwNnn0PCC88TfOqpbe6/u+PvVfvRljLag87qQxMRGhrHNpqo6AIqctxgLcFqbl1YZmezbennVOk8DNFZWjSn+8ql8ZGMDwvyuVy0PiqK2Pvv8xYM+wvQmhN4Z5yQtZO+hobG0ejS5Q8hxFQhxC4hxF4hxF1NvH6rEGK7EGKzEOIHIURyndcuF0Lsqb5d3rkjbxui2AxhTecJ6I5sWL0NIQXDJx/fLseLNRkYF+q7450+MpKwiy7CEB/fLv0fC1iHRxN31xh6PDaeuLvGaCdzDY02snfvXsPYsWP79urVa2Dv3r0HPvTQQ3/6L9V5552XEh4ePrRPnz618fS33nprfHR09JC0tLQBaWlpAz7++OMQgFdffTW8ZltaWtoARVFG/vbbb35f+XaZpUIIoQNeBk4BMoC1QoiFUsrtdZptAEZJKauEENcDTwAXCCHCgfuBUXiD5NZX79vtC2lUVFUSUBWC6H9s+AeoLhdZqo4EGUT0cYPb5Zhf5hYTbTRwfJhvwsKZkYFaWYm5X/M1iDQ0NP48fLzr4/DXNr2WUGgrNEZYIpzXDb0u84J+F7QpEZTBYODpp5/OOPHEE6uKi4uV4cOHD5g+fXrZyJEjm6za2dlsXPpt+OoF8xIqS4qN1tAw57hZF2UOO2V6h5R7v+6663IffPDB3Lrbrr/++qLrr7++COD333+3nHvuub2OP/54m799dqWlYgywV0q5X0rpBOYD9TJBSSmXSymrqp+uBnpUPz4NWCqlLKoWEkuBqZ007jaxbe9eBApxSWFdPRSf+GPRR9gVDykBAe2WOOihfVnMyyn0uX3RO+9y6FLfoz80NDSOXT7e9XH4E2ufSC6wFRglkgJbgfGJtU8kf7zr4zaFdCUnJ7tOPPHEKoCwsDC1V69etsOHD3eLUugbl34b/tN7byZXlhQbASpLio0/vfdm8sal37ZpztOmTauIioryO3fB+++/H37WWWe16iK9K30qEoC6GXUygLEttL8a+K6FfROa2kkIcS1wLUBSUsuhb53B/gOZgJk+vbp+LL6wdeNBdEJh5NTJ7XbMZaP74fYjk6s7Px99VFS79a+hodG1XPT1Rc2aHXcW77S6VXe9Kxinx6k8t/65xAv6XVCUX5Wvv+nHm+qVAZ93+jy/im3t2rXLuH379oCJEydWHL11+zD337c0O+e8gwesqqf+nD0ul/LLR/9LHHbK9KKK4iL9V08+VG/Ol/z32VYXGHv77bej58+fHzF06NCqV155JT0qKqqe6fyrr74K+/zzz/e25tjHREipEOJveJc6nvR3XynlG1LKUVLKUVHd4MSUl1GKW7jol9zz6I27AWdfcyVTE3sSOqzX0Rv7SJhB73PkB1SLisjIdutfQ0Oj+9JQUNRQ4apol4vg0tJS5Zxzzun12GOPpYeHh6tH36PjaSgoanBWVbX7hf8tt9ySd+jQoS07duzYHhsb67rhhhsS677+448/Wi0Wizp69OhWLQt1paUikyNVesG7tNGoIpsQ4mTgHmCilNJRZ99JDfb9qUNG2c7Y8lQIKsF4jFQnDUlMYvT//a3djpdld/JeViEXxIbTM6DpfAwNcefnYxk+vN3GoKGh0bW0ZFk46ZOTBhfYChotS0RaIp0AUQFRbn8tEzU4HA4xY8aMXuedd17R5ZdfXtKaY7SWliwLr/390sE1Sx91sYaGOQECw8LdbbFM1CUxMbF2OWT27Nn5p59+er2yuXPnzg0/55xzWu3L0ZWWirVAHyFEqhDCCFwILKzbQAgxHHgdOENKmVfnpSXAqUKIMCFEGHBq9bZujz4IzEndQhwflU8efpivH3kW2VQt8Vayr8rB84dyyfGxaqiUEndBgbb8oaHxF+G6oddlGnXGej+SRp1RvW7odW0qA66qKhdeeGFy37597Q888EDu0ffoPMbNuihTZzDUm7POYFDHzbqo3UufHzp0qPaKdv78+aH9+vWrdcb0eDwsWrQo7LLLLmu1qOgyS4WU0i2EmI1XDOiAd6SU24QQDwLrpJQL8S53BAKfVqeGPiylPENKWSSEeAivMAF4UErZJi/ZzuK22y7p6iH4TJ4dglDaVXrWJL6KMfn20VPLy5EOhyYqNDT+ItREebR39MfSpUsDv/zyy4g+ffrY0tLSBgDMmTMn84ILLihtj3G3hZooj/aO/miq9PmKFSuCtm/fbgHo0aOH89133z1U0/67774LiouLcw4YMKBx3n8f0UqfdyKqqqIox4QbSy324lLMYSFHb+gjLx/O46F9WewZP5ggve6o7R379rF/xunEP/kkITNPb7dxaGho+I5W+lyjLi2VPj+2znDHOB9+/jVP3PI52QX5XT2Uo+Io94r39hQU4K37YVEUAnW+ffTc+d73Sh+lOWpqaGhodHc0UdGJREaFImJtxIRHdPVQWqSqKI+nn3yBbx5+od2PnedwEW3U+1zp9Iio0JY/NDQ0NLo7Wu2PTmT6xAlMn9jVozg6K+e9j1PxEBnW/uXD85xuYky+R75Yho8g7tFH/1IpujU0NDSOVTRR0UmoqkpuUSFxkd3/intvVhUBeiPDzp/Z7sfOc7roazX73N7YIwFjjybzmmloaGhodDO05Y9OIjM/l8/v3cJ7nyw8euMupCTrIPl6SaInEFNU+/pTQLWlwo/EV7YtW7Bv3370hhoaGhoaXY5mqegktu/ZB0B8j+7tcPjbJx+jCkm/lNh2P7bdo1Lq9hBt9P1jl/fU00ink5R5H7X7eNpCds5X7N/3FHZHNmZTHD173UZc7JlH31FDQ0PjT4wmKjqJ9EN5QCgD+/bu6qG0yIECJ4GKmcHnndHuxzbrFA5MGIKK72HMsff9B+no+DLx/oiE7Jyv2LnzHlTVmzPG7shi5857ADRhoaHRTamqqhJjx45NczqdwuPxiJkzZxY/++yzWV09ro6kuTmfe+65KatXrw4KCgryALzzzjsHaiqSfv3110G33XZbotvtFmFhYe61a9f6lclTExWdREm2DWHQEx8Z3dVDaZb8/Tso0Hnor4ZgCPHd78EfLD6GktZg6tV+NUeaoyWREB01Fbs9A5vtMGZzPIGB/di39/HatjWoqo1du+5Dqg7MlkQs5iTM5liEOHouDg0NjfoUzZsfXvjKKwnuggKjPjLSGXHDDZnhF13YpkRQZrNZ/vrrr7tCQkJUh8MhRo8e3e+HH34onTJlSmV7jbstVKzOCi/7IT1BLXcalSCjM3hKYmbguPgOmTPAww8/nHHllVfWq0RaUFCgu/nmm5MWL168p0+fPs7MzEy/NYImKjoJd4EOQjutIF6rWPXZF0gBA/old8jxN5RV8UVuMf9IjvapoJjqdFL6+RcEjB2DKTW1Q8YEsH/fU02KhO3bb2M7t9ZuS076O71734HDmdfwEAB4PBXs2Hl37XMh9JjN8VjMSVgsifTocSmBgf3weGyoqhODoXmfFX+XV1qzHNPdlnC623g0uoaiefPD8x57LFk6HAqAOz/fmPfYY8kAbREWiqIQEhKiAjidTuF2u4Wvoe0dTcXqrPCSrw8k41YVALXcaSz5+kAyQFuEhb9zfuutt8JnzJhR3KdPHydAQkKC32XTNVHRCXg8HsxlIci0VpWn7zQOlnoIUQJIO3tqhxx/X5WdudmF3Jjkm7XGnZdPzgMPEPfIwx0qKuyO7GZeUemZ+k8sFq8oCAjwVpY1m+KwOxpbTU2meEaOmIfNdrjWumGzpWOzp5OXv4SYGO+SUkHBD2zddjNjx3xLYGA/Cot+pajoV28/5kQqKnax/8CzqKq9enwtL6+0Zjmmuy3hdLfxaHQsB847v9ky4PadO624XPXOfNLhUPKfeSYx/KILi9z5+fr0G26sZ8JM/fQTn0z0brebQYMGDTh8+LDp8ssvz5s8eXKnWSlyX9rQ7Jxd2ZVWPLL+2d6tKqWLDyYGjosv8pQ59QXvb6s355jZw1s955dffjlqzpw5CY8++mjc+PHjy1966aUMi8Uid+/ebXa5XGLMmDH9Kisrleuvvz5v9uzZhf7MUxMVncDejMMYVBNB8UFdPZQWOXvmFPJ3HkJv9a16qL/Mig1nVmw4vqaGd+d7LQIdnfiqOZFgNsWTmvqPRtt79rqt3gkQQFEs9Op1GxZLDyyWHk32UzPvwMAB9O59NxZLEgAV5dtIT38PKZtPt6+qNvbte5K42DM5cOBFsrM/5/jjlwM0GktN++3bb2Xnzn8jhB69zsqJJ/4GwK7dD5KZOa9Rf6pqY/++pzr8JC6lrE1+VlKyjuLiVRw89HqTc9ix4w4yMt5jxPC56HQWsrM/p6R0Hf3T/gtAbt632KoOoihmFJ0ZnWJBp7NUPzaj6CzodAEEWr2FGD0eB0LoUBTtp6/b0kBQ1KCWl7f5n6bX69m5c+f2goIC3YwZM3qtXbvW3NoS3+1KQ0FRjbR7OmTOzzzzTGZiYqLL4XCISy65JPk///lP7FNPPZXtdrvF5s2bA3755ZfdlZWVyrhx49ImTJhQMWTIEJ8d27RvViewe+9BAFI6IKKiPUkcezyJY4/v8H66WzbN5kRCz163Ndm+5qTrr6m+Zt5Wa0+s1p6125OT/05S0jU4HLnYbOn8seGiJvd3OHIACLD2JiLiSBa1hifjuvTocSlSehDiiC+L1dq7WQFjd2Sxa9cDhIUfR1joWAyG0NrX/FmeUFUndnum11JjO0x09FSMxkiysz9j1+45nHD8LxgMIRQW/czBgy83O34p3Rj0IQjhXS6z2zMpL99W+3pu7tfk57dcoFivD2XihPUAbNt+C1VV+xk3djEAmzb/ncrK3SiK2StGqu91igVFZ0KnWDBbEklJ/nt1f9+g01mIjJwMQHHxGkCg05mPHENn8Qoaxdzl4qW7Lim1ZFnYM37CYHd+fqMy4PqoKGf1vdtXy0RzREZGesaPH1++aNGikM4SFS1ZFrIeWTNYLXc2mrMSZHQC6IKNbl8tE81Rd84PPvhgLoDFYpFXXXVV4dNPPx0D3gJjERER7uDgYDU4OFgdO3Zs+bp16wI0UdHNyEwvBMIZ1KdvVw+lWT6472FSY2M58Yb/67A+Ht+fjQTu6hnnU/taURHZsWG4rREJcbFntuuPsxAKZnOc92aKb8Zy4n3fYqKnERM9rc725trH06f3XY2290i4mEMHX21yH0UxkZW9gIzMDwBBUNAAwsKOQ6cEcOjwm42WJ9yuMozGsFrxYLMdxmZPx27PBo5UcrZYkomIGE9AQE/i4mYhpXepNjnpGlKSb2D16lOancOwYe/WPk9N/Uc969GQwa+gqi5U1Y7HY6v2V6l+rNpQPXZknXHExpyJy11S+zw4aBB6nRWPakf12PCodpzOwnrHswb0rBUVhw6/jtEYXSsqtm77J85mfGwAhDAQFXkygwe/BMCGDZcRGjaW1JQbkVKyddvN6BTTESFSbW2pe28N6EVw8GAAyso2YzLHYzJGIqWKx1OFTmdp0iH4WF1Sirjhhsy6PhUAwmRSI264oU1lwLOysvRGo1FGRkZ6KioqxPLly4Nvu+22nLaPuO0ET0nMrOtTAYBeUYOnJHbInA8dOmRITk52qarK559/Htq/f38bwKxZs0puvPHGJJfLhd1uVzZs2BB4++23+1UmXhMVncCQYb3Ypt9PeEj7J5NqD0qzD5GNICiv+Sve9uCHojIiDL5/5Nz5+aAo6MLbP114Q1SPjYSES0hJua7D+zoa/lpO/G3f0j5paY8QEz2NsrLNFBWvorh4Fenp76MoxiaXJw4cfBGXy7vkajBEEGBJIjRkFJZYrx+K2ZJEgCUJo9FrbQoJGU5IyPDaY+j1Qa2ew5F2BhTFUHusloiOPq3e86aWt1pixPC5SOmpfT50yOu43RVeEVIjTDz2akHjFSkBlpTa9kZTFHp9MOC1wlRU7EJV64shGoRcJyT8jeDgwaiqi7XrzqZn6i2kps7G4chh5W/jARDCiK6uINFZqKzch5SuesfqrCWutlDjjNne0R/p6emGK664ItXj8SClFGeeeWbRRRdd1OVlz+GIM2Z7R380N+dx48b1LSoq0kspxYABA6ref//9QwAjRoywn3zyyaVpaWkDFUXh0ksvzffXkqOVPtcAwONw4igrJyCq44qdDf9tGxPDgniuf5JP7bPuvZfKFT/T55efO2xMNWzb/i/stkxGjpzf4X35QneK/vB4bPy0YjANT3ZeBGPHfIPZ3AO93urnLNs+hz8bUkqkdNYTJjpdACZTDFJ6KCj8iQBLKlZrT1yuMrKyP8bjqbGyeC0zNeImv2BpM70Ipkze69e4tNLnGnVpqfS5ZqnoYJwuF7+sW8ewAWlEhIR19XCaxOWwYTBZOlRQqFKS73T5lU3TnZ/fadVJBw542mcH0s7A3+WV1izH+LqPTmdpwZk1jsDAZp3aO2Q8f2aEEAhhQlFMGAhp8JqOqMgptc8NhmCSk65p9lgrV45vcRlNQ6Mj0Gp/dDA7D+xj53s2lq5Y1dVDaZKdP33NU488ze9vftCh/RS5PLglRPtRobQzRQX47kD6V6Rnr9tQFEu9bb4uT2h0Ddr/TKMr0ERFB5Mcn0Cviw2cMHb40Rt3AX+s+AOncJPQt3+H9pPn9K7tRvtRTMydn48uquNrpTicBWzYeEW1J79GU8TFnkla2iOYTfGAwGyKJy3tkb+8ZaE7o/3PNLoCbfmjgwkJDGLqhPFdPYwmUT0eMt0KMQQSP35kh/aV6/CKihg/lj9SPvgA9L6LkNZisx2iqOgXEhOv6PC+jmW05YljD+1/ptHZaKKig/ni+2WEBAcyedy4rh5KI7YtXkClzs0gvQmhdKzpP8/pDSH0x1JhTEnpoNHUx27zRm2ZzQmd0p+GhobGn5UuXf4QQkwVQuwSQuwVQjQKqBdCTBBC/CGEcAshZjV4zSOE2Fh9W9h5o/aPPYtLWbtsX1cPo0k2/r4LRQpGTp149MZt5Mjyh2861pWTQ+H//ocrp+PDyO12r6iwaKJCQ0NDo010magQ3mwtLwPTgAHARUKIAQ2aHQauAD5q4hA2KeWw6lv71+luByqqKgmoCiEwpuNN+P6iulxkSUGcGkTUyIEd3p8Aks1GrHrfqnY6du8m77HHcWU3V5ej/bDZMzAYwtHpAjq8Lw0Nja7F7XbTv3//ASeddFLvrh5LZ9BwviNHjuyXlpY2IC0tbUB0dPSQk08+uRfAhx9+GNq3b98BaWlpAwYNGtR/yZIlga3pryuXP8YAe6WU+wGEEPOBM4HtNQ2klAerX1ObOkB3Z9vevQgUYhO7XyjpH1/Nw6Z4SLEEdErUw+zkGGYnx/jc3jp+PH1Xr0IJ6PgTvd2eicXcdL0ODQ2NzmfLiozwdd8eTKgqdRoDQozOUdNTMgdP7NGmRFA1PPzwwzG9e/e2VVRU+HaF00msXbs2fMWKFQkVFRXGwMBA58SJEzNHjx7d5jk3nO/69etr032fdtppvWbOnFkCMHPmzLKLL764RFEU1qxZY7nwwgt7HjhwYFszh22Wrlz+SADS6zzPqN7mK2YhxDohxGohxFnNNRJCXFvdbl1+ddrnzmL/Aa9ZvW9v35I9dSZbNx1EJxVGzTylq4fSJEIIdKGhCGOjdPjtjt2egbmZImAaGhqdy5YVGeErP92bXFXqrYVRVeo0rvx0b/KWFRltTq27b98+w5IlS0KuueaabpWIa+3ateFLlixJrqioMAJUVFQYlyxZkrx27do2zbml+RYVFSmrVq0Kuvjii4sBQkJCVEXxSoLy8nKltRebPlsqhBABUsqqVvXSMSRLKTOFED2BH4UQW6SUjZwXpJRvAG+AN6NmZw4wL6MUhI5+yT2P3rgTcdttZAtBgieQsAG9jr5DO3DttoMMCwrgBh/LnpcuXIgrK5vI6/7eoeOSUsVuzySyTlIhDQ2NjuXTR9c2mzGtIKPCqjao2ulxq8rqL/clDp7Yo6iy1KH/9pXN9X64zrt7tE/Ftm688cbEJ554IqO0tLTTrRRvvPFGs3POycmxqqpab85ut1tZtmxZ4ujRo4vKy8v18+bNqzfna6+99qhzbmm+H330Udjxxx9fFh4eXrsS8P7774fef//9CUVFRYbPPvtsj28zq89RLRVCiOOFENuBndXPhwohXmlNZw3IBBLrPO9Rvc0npJSZ1ff7gZ+AbpcIwpanYgsqwWjoXj4VisHI6UPTGDMstdP6dKkSjx8ZK8uXLqX060UdOCIv3uJRTsza8oeGRregoaCowWlrWxnwefPmhURGRrrHjx/fnS6OAWgoKGpwOBytnvPR5vvJJ5+EX3hh/Xoql112WcmBAwe2zZ8/f+99993XKs91Xwb8LHAasBBASrlJCDGhNZ01YC3QRwiRildMXAhc7MuOQogwoEpK6RBCRAInAE+0w5jaFV2JFRlX0dXDaISi0zH43PM6tc93B/snYNx5nZNN0+0ux2rtU6/ok4aGRsfSkmXh3Tt/HVyz9FGXgBBvGXBriMntq2WiLr/++mvg0qVLQxMSEkIcDodSWVmpnHnmmalfffXVAX+P1Rpasiw89dRTg2uWPuoSGBjoBAgKCnL7YpmoS0vzzc7O1m/evNl6/vnnN1kEZtq0aRXXXHONKTs7Wx8XF+f2p1+ffCqklOkNNnmabOgH0lv7eDawBNgBfCKl3CaEeFAIcQaAEGK0ECIDOA94XQhR4zTSH1gnhNgELAcek1Jub9xL11FQUkSAI5iQOHNXD6Ue9vIS3vvPf9n+VbeNwgXAXVDQKaLCau3JuLGLiYjongnKNDT+aoyanpKp0yv1nPN1ekUdNT2lTWXAX3755czc3NzNmZmZW/73v//tHzduXHlnCYqjMXHixEy9Xl9vznq9Xp04cWKr59zSfD/44IOwyZMnlwQEBNSaj7du3WpSVe8Qfv311wCn0yliYmL8EhTgm6UiXQhxPCCFEAbgZrwioM1IKb8Fvm2w7b46j9fiXRZpuN9vwOD2GENHsX2v170jIanj00z7w95ffiBd8dD7UGGn9flHaSU37DjEK/2TGRFy9EqWUspOr/uhoaHRPaiJ8uio6I/uSE2UR0dEfzTFggULwu+444568frz5s0L+/jjjyP0er00m83qBx98sL/GcdMfjlr6vHp54XngZLzpBr4HbpZSdt5ZqZ3ozNLnqqpyOCeLiNBQggJaFe7bYVQW5GEwBmAM7pxxLcor4ZptB/lxdD8GBFqO2t5TWsruseOIvutOIq64okPHtm//M1RU7GLokNc7tB8NjWMZrfS5Rl3aVPpcSlkAXNLeg/qzoygKKfHdy/nP43SiMxqxRvoWgdFe1GTTjPIxm6a7OvRXH9nxlgq9PhijseNKvmtoaGj8lTjqr7wQ4l2gkTlDSnlVh4zoT8Jr735KWFQQF5w+tauHUsvyN15iS66Dc0+ZSNKE4zut3zynG52ACIOfoqITlj+Sk/6vw/vQ0NDQ+Kvgy6/813Uem4GzgayOGc6fh5LtkorYQji9q0dyhD05VTh1CrFDhnRqv7kOF1EGA4qPyVTcBV4raUeLipqlv87IKKqhoaHxV8CX5Y/P6j4XQswDfu2wEf1JuOvJ83G6XF09jFpKsg6Sr/PQWw3EGNq5Ph55ThfRJt/DrT3FJQDooztWVDhdhaxaNZm0fg8Rq5WH1tDQ0GgzrUnT3Qfo3EX5Y5TulPRq1fxPUYUkrVd8p/ed53T7VfI8/LJL6bdxA4r16JEibcFuy8DjqUSvD+rQfjQ0NDT+KviSUbNcCFFWcw8sAu7s+KEdu8xf+B2PPzyXSrutq4dSy/4iJ4GqiSHnn9Xpfec5XcT46KRZg2I2d/iyRE3Jc7NW8lxDQ0OjXfBl+UO7jPOTjF1F6HODsJqPHj7ZGeTv2UaBzkWaDEUf0PEFuurikZICPy0V+S+/jC4omPDLLu3AkXkLiQGYzZ1vvdHQ0Oh8EhISBlutVo+iKOj1erl169Z2ybnUnXG73QwePHhAbGysc/ny5XtHjhzZr7KyUgdQVFSkHzJkSOWyZcv25efn6y6++OKUQ4cOmUwmk3znnXcOjB492u5vf82KCiHEiJZ2lFL+4W9nfxXchToI7T7puVd9sQgpYGD/lE7v2+ZROSUy2Kf8FLX7bNqEPrzjwzxt9kz0+lBt+UNDo5uxcem34asXzEuoLCk2WkPDnONmXZQ57JTp7ZIIasWKFbv9TT3dGWRkzA0/cPClBKcz32g0RjlTU2Zn9uhxSaeVPr/33nvjhgwZUrV06dJ9GzZsMN9www1Jq1at2u1vfy1ZKp5u4TUJTPa3s78CHo8Hc1kIMq24q4dSy8EyDyGKhf5nz+j0vgP1Ot4b7F+V1qQ33uig0dTHbs/AYtGWPjQ0uhMbl34b/tN7byZ7XC4FoLKk2PjTe28mA7SXsOhuZGTMDd+z95FkVXUoAE5nnnHP3keSAdoiLGpKn999993Zzz77bEzd12pKn8+bN+8AwK5du8x33XVXDsDw4cPtGRkZxvT0dH1iYqJfAqxZUSGlPKk1k/irszfjMAbVRFB897j6zdy0hiKdi0FY0Zm6j+Nod8Bmy8Rq7ZzS7xoaGkeY++9bmi0DnnfwgFX1uOuXPne5lF8++l/isFOmF1UUF+m/evKhel/cS/77rM/FtqZMmdJHCMGVV16Zf9ttt3Vals+1a89uds7lFTusUrrqzVlVHcrefU8m9uhxSZHDkaffvPnv9eY8evQX7Vr6fNCgQbZPP/00bOrUqRXLly8PyM7ONh08eNDor6jwKfpDCDFICHG+EOKymps/nfyV2L33IAApKbFdO5BqIlPTmBIbx+gprc6w2yY+ySli6Mqt5Dh8C6915eRw6PIrqPz99w4dl5QSuz1Tc9LU0OhmNBQUNTirqtpU+hzg119/3bl9+/Yd33///Z4333wz+rvvvusWNRQaCooaPJ7yTit9/uCDD2aXlpbq0tLSBjz//PMxaWlpVTqdruU6Hk3gS0bN+4FJwAC8xb+m4c1T8b6/nf0VyEwvBMIZ1KdvVw8FAFNwCOOv/3uX9d/DZGRKRDAh+kZCuUlcWdlUrVmD/L+rO3RcLlcRqmrDookKDY1OpyXLwmt/v3RwZUlxI49ya2iYEyAwLNztj2WiLqmpqS6AhIQE94wZM0pWrVplnTZtWqc4wLVkWfjl1+MGO515jeZsNEY7AUymaLcvlom6+Fv6PDw8XF2wYMFB8NauSkxMHJyWlubwp0/wzVIxC5gC5EgprwSGAiH+dvRXoSzbTpW5lPCQrn+LDv2+gvn3P0HOH13nU3t8WCDPpCVh0fmWEuVI3Y+Ore4qpUp8/AUEB3dudlENDY2WGTfrokydwVC/9LnBoI6bdVGbSp+XlZUpxcXFSs3j5cuXBw8ZMqRbxP2npszOVBRTvTkriklNTZndaaXPCwoKdHa7XQA8++yzkWPGjCmvWRrxB19MKzYppSqEcAshgoE8INHfjv4qqEVGCGvS2tTp7PxtPbuwcVxxZZeNodLtwaJTfE/R3Ul1P0ymKPqn/bdD++hMdvyynF/mv095YQFBEZGMv/Ay+o/X3KI0jj1qnDHbO/ojIyNDf/bZZ/cG8Hg84txzzy2cNWtWWXuMua3UOGN2RPRHUzRV+nzjxo3m//u//0sF6Nu3r23u3LkHW3NsX0TFOiFEKPAmsB6oAFa1prM/O6qqQqCLsBRTVw8FgNP+eSujd+8mrHefLhvDxZv3Y1QEnw7r7VN7d0E+6HTowsM7dFwejw1FMSFEa5LKdi92/LKc7994CbfTa6ksL8jn+zdeAmhRWGhCRKO7MuyU6UXtHekxYMAA565du7a35zHbkx49LinqKBFx+umnl59++unlNc9///33RkspJ598cuXBgwe3trWvlvJUvAx8JKW8oXrTa0KIxUCwlHJzWzv+M6IoCnfd3z2qxKseD4pOR3jfrvXtyHW6GB4U4HN7d34++ogIhNKxJ/u9ex8nN+9bJozvWIfQzuCX+e/XCooa3E4HK+a+i6LX02vkWPRGIx63G0WnQwjRaiHSkWgiR0Pj2KclS8Vu4CkhRBzwCTBPSrmhc4al0VY+efgxil16rv7XDRjDuia8VUpJrsNNdITvoazu/PxOKXkeETkJS0Byh/fTkdgqytmzZiXlBflNvl5ZXMTXzz3OP977FIBf5r3HxiVfExASSmVJMaq7fqSY2+ng54/+R9qJk5pMkd6RJ/3uKHL+DGhCTaOzaSlPxfPA80KIZOBC4B0hhAWYh1dg+J1p68/OK299QvlOwa2PnY1B3+bop1ajejykuyFI6DB0ckXSulR6VGyqSrQf+THc+QUYYmKO3rCNREZMgohJHd5Pa2nuZOBy2Nm3/nd2rlzBgQ3rUT1uFEWHqnoaHSMoIpKz73oAY3W6+ORBQ1EUharSErat+KHJfiuKClE9bnR6A5uWfkdpfi4TLr7Ce9J//UXcLidQc9J/EYetil6jxiI9Kp7qsYREe/9/BYcPIhQdET28LliHt27G5bChejyNbj/PfadJa8tP779VexLc+P23gLdUvRACqu/rPg6Liye+b38Adv72MxE9kohKSsHtdLJ/w9ojbREIRUD1vcC7f0hsHGGx8XjcLjJ37iAsPp6g8Eicdht5B/cjhIL3EApU39cIMKEoBIZHEBAcgtvppDQvh6CISIyWAFx2OxUlRU3uX/c4pgBrtVXJhdNmwxRgRdHp8LhdeNxuBKLOfkfmX/c9qPsZ0oSaRmfjS+2PQ8DjwONCiOHAO8B9gG8xgi0ghJgKPF99rLeklI81eH0C8BwwBLhQSrmgzmuXA/dWP31YSvleW8fTVqLiQrBVFHSpoADY9u1nVOpcDDKGdHhRrpbIdXpzU0T7UUzMnZ+PZdDANvX75YZMnlyyi6wSG/GhFm4/rR9nDT8SOiqlpLJyNxZLIjpdgE/7+NtHW9jxy3K+e+1FpPvICfy7117E5XSy4oO3cdqqCAwLZ/jU0+l/4iQKM9NZXKc9gNAbGX/R5UQlpdRuSx0+itTh3nwlh7dtbtLCYQ4MQqf3isDCjMPkHzoAVC+xuJz12rqdTn54+1V+ePvV2m1Ryalc9sSLACx+9XkCgoM55+45AHz3yjNUFPqXa6iqrLT28Q/vvAqy5bD5QSedUisqvnnhScadfT5RSSk4qipZ9MyjR+1v3DkXcMIFl2KvqODTh/7NlKtvYNip0ynOzuLj+49eR7GmfWFmOh/edTNn3HYPfUYfR/r2LXzx+Jyj7l/T/tDmjXzx+BwufuRp4nr3Y9uKH1haLQhaoqb9lh+/5/vXX2j0utvp4Jf572uiQqPD8CVPhR5vbooL8YaW/gQ80NaOhRA64GXgFCADWCuEWCilrOtIcxi4Aritwb7hwP3AKLwpw9dX79ulubHPm3FaV3Zfy8Z1u1EQjJrRtZnU85xe83qMj8XEpJQYYmIwpqS2us8vN2Ry9+dbsLm8V+6ZJTbu/nwLQO1J3+0uYc3v0+nT516SEq/0aZ+Gfbz5vwWcnL+KIE8F5bpA3sw+DpjVJmHhctixlZWx5N036wkEAOl2snz+XI4/5wJievahx4CBKIpX168qtfBD5ERG1RnPusjj6BnYl/7N9GU5biZFX7+PQR5ZAnEJPdEnnVf7fPKVR/KbNLfEAnDKNbNRdDoUnQ5LUHDt9pOuuBa94cj//qzb7kVKWdtW0elrH79z1y14yksaHVsXFFb7+LrXvKlxpJRIqYKk3r2UYDSba9tf8dQrWIK8S3/mwCAue+LF6n1lrTiRqopEIlUJSAKra86YAwM5/77/EhrnLTYXGhPHufc8BHX2l3VuSIlEEpXk/eyGRMUw4+Y7iO3pdZKOSkll2o231m/fxOPoZO/+ET2SOOmKawmOjAYgrnc/JvztKqSq1r4HR/Y78h7UjL+umGxIS/9LDY220pKj5inARcB04HdgPnCtlLK94hPHAHullPur+5sPnAnUigop5cHq1xrGyp4GLJVSFlW/vhSYindppktwulyUVZYTGdqxUQtHQ3W5yJIQKwOJGjqgS8eSW51FM8pHS4UQgtTPFhy9YQs8uWRXrTioweby8OSSXWzPLmPN/kKizAe4qCc8+2MZ+8t/ZXt2GS6PbLTPvV9uZfmuPJ6/cDgAt3+6id255Th3rWNi/k+1J+RgTwXjc5fz+juS5SdMrNfeipPrR4YRndqL/3tvHZ7D2wktPYzBVeW9OaswVj/WqS1nHXWVFfHw4Rg4XAY/HQnA2p5dhsvSm21J9SNsbl+wiXKHm0vHJVNa5eKyd9bU2cdMSsREji9eUytEfgsbS96+QC6F2vbXTujFjCFxVOiDCHSX05AyXSB3bwtAUQSKEFx1QhyB5Q6KKh3csbSQW0/phyizsymjlGeXZtXu19Dg4DGNZHLFikYiZ0XgKP4JLN2ey0s/7mnx/QF4fNYQ0kJq2h/izctHEQB8tiGbuWuOHvL/5uWpBAOfbchh7poyPrt+EADvrs3muy1H/+n7bIRXBPxvfS4r95r44HhvvpUXV+ezZn/LFYKDLQY+ONWbiffldUXkliXyfKhXVD3xexm7c6Nb3D8l0srx4d7+nt5gI1AfxKiAfZwYdZBgg4Myl4lf81NYb9NS02t0HC392t8NfAT8q4MsAAlAep3nGcDYNuzb5CWiEOJa4FqApKQk/0fpI3/s2Mb6V4pIOk8wc0rXmRb/+HweNsXNiICuL7ueV738EdOJNUeySprOZZNVYiPQpCfMaiQ+oMS7URdLmNXYSFDUUOFwE2w+MvYgs4Ewq5HkwtX1Tn4ABulmYv5yxM+7eGulk/P+81+CzAasu37jwwXf8I/3PiUkwICxMp2IzHW4TVY8xgDcpgBswZFUGAJwG63ExkRS9dtCAtTGFYfLdYGEWRufmJobv8sjCTB4rRlCod6+Lo9kT1Bf9gQ1iA6yueq1F8DPu/P5NXQMUwobn/R/CxvLnuxyBsQFERFs4nBRFTc/sowXLhxOmNXI+sNFXP6uDxE2QX2R0Ejk7DH3ZtD9S9ApAofbg04IFEWgU8SRxwJ6RgVi1Cvszqlgxa58+kR736u9eRVsySjlUFElOqWm/ZH9asRQDTWPTQbFO//q51ajrsn3viF124dYjnx2aj57LRFo0td7bGvis9cSDT+r+hgzpwbuwaB4r8lCjA5OjdvD5oq2LS8eyxQUFOj+9re/Je/atcsihOCNN944ePLJJ3ddIp9OoLly74888kj0W2+9FaXT6Tj55JNLX3vttYyaffbs2WMcOnTowNtuuy3rwQcfzPWnv5YcNf8UVUillG8AbwCMGjXK7zzmvrJ/fyZgISU5vqO68ImtW9PRKQpjzj29S8cB3uUPgxCE+Ziiu3L1GvKefYb4xx7DlNq6JZD4UAuZTQiL+FALN03xmqIPH97Cnr3wxAVTMRhCOOGxH5vcJyHUwkNnDap9ft9Mr+XnqcVNZ/XVSw8pCZEEhIQiFMF9MwdQNDKEokkjUHR6njl/GJ5zBtWGdTbHBenlDD+8tNEJfGeP8Xx85ZhG7YfN+Z4SW2MrR6jFwLkjewDeE87/6uzb3JzjQ8ys3l9IiMXbfkd2GdOe/wWqxUejk35QX+acMZAJfaNIjbSSU2on1GpkbM9wzhgWz4GCSmKCvUsSgmqHxuqp17wDQsCdn21pWuQA549KxObyYHO6vfcuFbvTQ5XLjc3pwe5Sefr8ocSFWHjpxz089f1u9jwyjcn9Y7jvq628v+pQs+81gFGnsPmBUzEbdLz04x5+3l3AJ9cdx5nDEnhtxT62ZZURYNCREmHFbNARYNRhMegwG3UEGHQEmfWcOtBrYThcWIUqJZcel8Klx6Vgd3kw6pTaz56vNGxf89nzlftmDiBn/S8YqG/kNSgqVwb/4texuoKK1VnhZT+kJ6jlTqMSZHQGT0nMDBwX3+YcDtdee23iqaeeWrZ48eL9drtdVFRUdJtENe9lFoQ/czAnIc/pNkYb9c5bU2IzL0+I7JBy74sWLQr65ptvQrdv377dYrHIzMzMelrgH//4R4+JEyeWNj7S0elKj8JM6mfm7FG9zdd9JzXY96d2GVUryc8sA6EnLaXrTItuu41soRLvsRLSq+OsMr4yJsSKoYFHeosoAp01ECXA97wWDbn9tH71/CMALAYdt592pECgzZ6BTheIXh/s8z51MQSH4y5r/F03BIcz656H6m0Lj08gPP6IEU3ngxPvRRedxZv/c9f3kYg6jmsuOqvJ9s29vTXbM4qrUFXv1bdJr2DUK0zqG8nc39Mb7XNSvyiueX8dpw+J49FzhtAvJoj3rxrDTfM2sIfGJ/2wAAOXH59S+zw2xMyl446E6qZGWkmNtB51zo99t5PiqsbCKCzA4NcJ9YZJvbnyhFQM1Wnhb5jUm3NH9KgWJZ7a+yqXB3v18yqnB5Pe2z7caiIp4sjnL7vExtbMUqqcRwSM01P/RB0VZKoVFQ9+vY3sUjvf3DQegPNfX8XmjFJMegVLtQgxG+sIE4OOvjFB/Od07xzf+mU/oQFGZlWLwa82ZiIlmA067/519qt5bDF6nzckRuYfUW4Nt3djKlZnhZd8fSAZt6oAqOVOY8nXB5IB2iIsCgsLdWvWrAmqqW9hNpul2WxuHDbVBbyXWRB+397MZIcqFYBcp9t4397MZID2EhZ1efXVV6PuuOOObIvFIsFbC6XmtQ8++CA0OTnZabVa/U7RDV0rKtYCfYQQqXhFwoXAxT7uuwT4rxCixovrVLzLNV2GLU+FoJIujfz4ff4HOBQPvcK6ReE9To0M4dRI32ugWMeMwTqm8ZW4P5w1PAG7y81dn3sTwyU0EZlht2disfSoFTs1r/kazXHqZVfy7SvPQZ0wTqE3cuplV7Zp7HXnALN4csngFsdjd3lYe7CoyZMxQEn19ls+3sjag76tYP60u4D3rxpDzyjvZ0hRBBP6RvHAGQO5fcGmekstBp3g/pntY0q/f2b7HF9RBNY6ywixIWZiQ8wt7FGfi8cmcfHYI4J8zpmDGrVxe9Rqi4kHu1PFpR757b3hpN7YnEc+F38bl0xWia1ZQVNud1NUecQp9+vN2SSEWmpFxQMLtzX7/63hlAExvHmZN6pn+hNLOSvMwcVpoRhsekwBjatWO2wGfH9HOobclzY0WwbclV1pxSPryyG3qpQuPpgYOC6+yFPm1Be8v63e1VvM7OFHLba1a9cuY3h4uPu8885L2b59e8CQIUMq33zzzfTg4OBWnTz9Zeq63c3OeVuFzeqS9efsUKXyyL6sxMsTIotyHS795VsO1Jvz4lF9W13uff/+/eYVK1YE3XfffQkmk0k+9dRT6RMnTqwqLS1Vnn766dgVK1bsnjNnTqtKbfsS/fG4lPLOo23zFymlWwgxG69A0AHvSCm3CSEeBNZJKRcKIUYDXwBhwEwhxBwp5UApZZEQ4iG8wgTgwRqnza5CV2KF+K5dmkubMJmS3EWMvuCsLh1HDbkOF6EGHaYOzo7ZkMRw75Xxe1eNYWLfxom07LYMzJb65WvOGp7gc+RG//EnUZh5mD+++xqXw95pSYWklOwvqOTn3fms2J3P6v2F2F3N/x7Gh3r9am6a0oe8MgcOt4rD7cHhVnnsu51N7pNVYmN4Ulij7f4KL3/p6OO3J3qdQpBOIcjc2FdoRIP37vxR/pVJ+uKG41ErK3FmZOIpKWHRcUbsRZU4i4pxlZTgKSlFLS2ldMgoCkZPwJWfz7AHbqTEejuh557LGQFFXLjqJko+sSBEIHFjSlH0R4Sa6hbkb7R27+JNDQVFNdLuadMVm9vtFjt27Ah4/vnnD0+ePLnyyiuvTPzPf/4T+/zzz2cdfe+OpaGgqKHMo7ZLuffU1FRXZmamfvLkyX0HDhxo93g8oqioSLdx48adK1asCLj44ot7paenb7n99tvjZ8+enRsSEtJqoeXLgE8BGgqIaU1s8xsp5bd4y6nX3XZfncdr8S5tNLXvO3hzZnQ5BSVFBDiC0cc1viroTMJ79mb6nbd06RjqMnntLmZEhfBEP99+wjJvux1PaSlJb77Rpn43ppcAMKxHaKPXpJTY7JmEho1rUx8nXng5J154eZuO0RxNhbj+69NNzFl05Kq1Z6SVC0cnMbFvFPnldu5fuL3Z5ZvxfRoLqw9WHWrW96Q5/BFeraFfxW4uT/+gNuFXv4rLaMb/utsjpURWVeEpLcVTUuK9r3lcUooxKZHg6dMBOHTZ5QRNmUz45Zejlpaye9xxjY4nACOgBASgCw0ldfQQIkYnodqjyf19KsZqJ/RrLpuKdKZinnEK6x5eCr9D1NByDAEeXFU68jcFcbAwoctFRUuWhaxH1gxWy52NvFKVIKMTQBdsdPtimWhISkqKMyYmxjl58uRKgAsuuKD4sccea9XVeGtoybIwdOXWwblOd6M5xxj1ToAYk8Htj2WiLk2Ve4+NjXXOmjWrRFEUTjrppCpFUWROTo5+/fr11m+++Sbs/vvv71FWVqZTFAWz2az++9//9nnNrKWQ0uuBG4CeQoi6tT6CgJWtmdyfla27vSXpE5I6tlx3S6yb9wFZ+/OYfM3fCIzu+IyUvnBPrzhSLb4XV3Olp6NYW+9PUcOGwyX0jLQSEtD4StLtLsPjqcBibkM+Cbud8qJCwuLiOyS5WFNhsR5VYnN6ePisQUzsG0VieP33yajX+XWV768fCcCSj95j63eLkE47wmhm0LSZnHZx+wirHb8sZ/FrL6C6vaKpvCCfxa95kzd1ZaImKSXSZmskDITRSNBkry973rPPoQsOJuLqqwDYN206rowMpKv5ZYugqVNrRYUuJARh8i5IKMHBRN9+O7rQUHShId77kJDamzDWP+8oZjNxsy+BZQ/AwBfRBYfDP38DRcGW1YeNfywl0zUTV24EBnMhCQmLMM88pQPeqfYjeEpiZl2fCgD0iho8JbFNpc+TkpLcsbGxzk2bNpmGDh3q+P7774P79evXOMyqC7g1JTazrk8FgEkR6q0psW0u9+7xeAgLC1Nryr3fc889WYGBgeoPP/wQNHPmzPLNmzebXC6XEhsb616/fn2tcLn11lvjAwMDPf4ICmjZUvER8B3wKHBXne3lXb3U0N04dDAHCKR/r55dNoadO9NJR+VUXfeokApwcVyEX+3d+fkEpIxqU59SSjamlzChT9MCTwg9/fs/TnDw0Fb3kb5jC188Nofz73+UxAGDW32c5mguLNbhVvlbHSfIuvTUFTLLtIlScykhphB66iJp6Sr/rOEJZP+8kPLfl6G4Hah6E0FjTuas4VObbL/ko/fYsvAzhFS9vn9OO1sWfgbQrLCQqorH40F1u6rv3XjcblS3G1NgIJbAINxOJ3kH9/PDe2/WCooaVLeLZe++TlhcAopej06vr02aFRAcgsFsRlU9eJwudEZDbTKw5lDt9lpxoFZWETDCm0+kbPFi3Hn5hF92KQBZ996LfdMmPCVeAdGUODD161crKhx796KPOPJZDzr5ZEDWCgIlJAR9aChKyBGRoJiOfE97vHgk86VQlFpxclTcTlj5PPz8JBjMkLcdUk6E6uXGwH4RbNs4ClfuF6CWY1eC2BcwjrH9/PtedjY1zpgdEf3x4osvHr7kkkt6Op1OkZSU5Jg3b97BNg+4Hahxxmzv6I/myr3b7XZxwQUXpPTp02egwWBQ33jjjQNKOy1TtxRSWgqUAhdVZ7+MqW4fKIQIlFIebpcR/AkozKpA6PSkJjS5UtMp/G3Ov8nZuBFzRGiXjaEupS43B2xO+lrNBOiO/mGVUrZLMbGMYhsFFQ6GJYU2+bpebyU+blab+ohO6cUp1/6jNltie9NSWGxTbN68mUWLFuGqPvmVlpayaNEiAIYMGdLkPks+eo/KVd+hk96lU53bQeWq7/g61MjgSSdTWVZKaV4e5YX5VBQVsn/FUoSsv8wqpMqWbxey4/tvOf7cCxgz8xzW/LyCX199BlQVb7Lbphl77kWceP4lrPxpOevefrHZds7KCubec2uj7VMuupKhZ5zN+hU/8fNrz3LapKkMun42vy/5lpX/ex0hJYqU3ntVIjweFFWt3gaDC8sZ99tqMnZu4+d57zKosJLwyy7l4Mb1/FGQBeFWdHHh6EwmdGaL9xZgQW8JQG+1MniKN3tuweGDFJ8zkwHV1pSCwwcpnXBctQDSo6vJHKrXebc5bCiFLkJjY1EUHS67HY/bjTnQ6xgrpfTN+pW+Fhbd5BUSA8+GqY9DUH0L5drPt+OqWAlUL8uq5bgqlrP2cydjT51x9D66kMBx8UXtISIacvzxx9tq8jR0Ny5PiCxq70iP5sq9m81m+dVXXx1oad9nnnmmVb4mvjhqzsabljsXaoOeJd56HBrAkDEpZCYU0F5Kr7XEDhvWpf3XZU1pJZdtOcC3I/swIvjoIYVqaSnS5UIX2bYlpBp/iuGJjZ0NAaqqDuB2lxMUNLjVSxeBYeEMmdJxKdn9XZr44YcfagVFDS6Xiy+++IJly5YhpURV1dpU0KqqYti+rkmRsHPpt+xcvBDRRIGyJnE5kOGRBEZ4/28eBIYeKQhF8Zavry6UJRSltmiXUBRircF4KioJjogkfNQJFGz8HcXd2CKg6vQYInvgkR5UCR4BSBX3fXPwTJzMgcwsiEnE8dqbyL/fwNY9e7GHRlKdtxqqhUXdxwZFIe6aGwFY+fPPFAUEkPTE8wCs+uVn8pxVoEikowrslchijzedt6rWpgJNm+bNA7P1t19Y/8XH9B17Anqjkc3Ll7Lh26+O+rbd+PZ8zIGBrPpsHn98t5B/fvgFAItffoYdK1egqxYiit5QT5goioLRWcTfopdBcDyr42+nMNvEjGpB8dunH1GYmY5Op8NRXEdQ1OLGUfqHb/9bDY1W4Iuj5j+BflLKwg4eyzHLyccf36X9v3XvfwlQDFz84O1dOo665FfX/Yj2se6HO9+7bNdWS8XG9BJMeoW0uKbLvadnfEB29mdMnLCxVcdXVQ87fvmJ5MHDausstDdjUsP579mDeOr73T75SJSWNp2jRkpJz549EUKgKEptNUtFUdi2sRm3KJeDfpNOwRIYTHBUFGExsYTFxPG/22aDpwkfAZ2Bv1/6f94lg+ejOX7CBAYUFpF9333Qgk+Ba/5nOD+ez/CRI0k9cIA39x9AFufUEzpSKBASzVmFJUf8Cmp8DE6cjGI0csas87BPnIT1bj0IwYzzLqBy+um4XK56N7fbXfvYaDSSPGECAJG9+hKe2pvQGK+/nhoeDUOPq7evWidkFClJSkokPN5rldyUnU/CjPMwVedWWX0wE3fqAJAqekVBr9Ohq75XhECnKMTGRGOorlGS43DT72Sv1cDtduO0hpAw6jjvElO1CBLVAklXkYMubyuKxw5jrkVOvhf162+QmUfyjZTmZ5G7fwfen/ZmHMfVxunWNTTaC19ERTreZRCNJigpL2Pzrl0MH9CfoIDOzw9RfHgfWToXvdXu40sBRyqU+lr3w13grV7ZVlFhNek5uX9MbfKjhiQlXkFU5MmttlIUZqSz+JVnmXbjrQyY0P5JZ+0uD2e8tJKZQ+NYeZdvxw8JCWlSWISEhHDWWWc1uc/2j94GZ2MfNWE0M/P6mxtt71FmIyPQ4L3qr0YKQY8yG0pwMJbBQxDVfgKm3r2JuOIKhMmEMBlRTCaE0YQwmVBMRu92owljddbUoFNOYej8j1kX3wNDYQ7C7UTqjbgiYhmVW0TKx/ObnbsZMCceiWWIifHPSXnKlCn1nl9yySWN2ng8nnqipMbaAnDm2edgNBprn588bTpOp7NFUROZklKbBC27vIqYaguj0+lkw6GMRv0DRFDMbOVD8mIjODTkXzD9Ruw2G99v3cXUqVOR0sPu3f+jKmAdImgynkQPSv4SVLWxsNApXVtFWePPjS+frv3AT0KIbwBHzUYp5TMdNqpjiNUbN7FvrgvnZZu7xGKx6pMvUYVkgI9hm51FntNNmN73HBXtZam49ZTGaZ7rYrEkYbG0Ptto9h5vfoe4Ps1HSbSFeb8fpqDCwbRBcT7vM2XKFBYuXIjbfeQEYjAYGp0w6zJo2ky2fPVpvYSLUigMnjazyfYjq1wgISPEDB436PT0KLUz0ubC3K8fCU89WdvWMngQlsGNk0Y1hy4khLGXX4b62utsHtCfyoAAAqqqGLF9B2Ov+/vRD9DB6HQ6dDodJlNj4Z6SklLv+Rg/k7fdfPMRAWexWLj33nuPiBGnE9LXUBU5BJfLRebhEZRFDCUxMqZ2XJMnTyYsLJvl3/4fh1aPpir/WnQBdgKUcmKzctkbHYGs8xUUKvTM8auUg4aGX/giKg5X34zVN406jBg0ANf5WxgxsGuK9BwscRComBh83tld0n9z5DlcRPtRSOyIqGi5EmNLqKpEUVq2QGRlfUJwyHACra1zsszavRNLUDChse1f48Xu8vDain2M6xnOmFTfq90OGTIEt9vN0qVLsdlshISEMGXKlGadNAEmzDybrV99Cjo90uNGGM0MbiFENPqWfzL0zrsYWmcpQJjNRD/0oO8TbIGQmTM5Duj17HO4s7PRx8URfcs/CZnZtMj5MyKEQK/Xo9frsVgssOZ1+O4OIv7+MyQOhZ71o8ucrkMYxaf8/lk8ZYcvxRggmXBhXwaMj8exaRMHnykhwOFmV1w4doMes8tNv+wi4kuarl2jodEeHFVUSCnnAAghAqSUVR0/pGOL6LAIZk6e1CV95+/aSr7OSZoMRteJlUB9IdfpItrHpQ8AQ49EgqZNbVOeirlrDvHqT/v45qbxTVfzdJWxY+fd9O59d6tFRfaeXcT16dch+Sk+XZdObpmDZy8Y5ve+I0aMYMSIET63T9/mTT1z4f2PktCv/1HbB516Ktz9bxSLBbWqqkNO+iEzZ/6lRESTuJ1QngVhKTDsEjAFQ0z9sGWns4BdO15m63IbxbtPRyg6hp/Wg5FTe6Lu3UnmdQ9S+csv2IyQUFJBQgMRkR/cifPR+MvhS/THccDbQCCQJIQYCvxdSnlDRw/uWODjrxeTnBTLuCHDOr3vVV98hxQweGjvTu/7aOQ53YwNOXrURw3Bp51K8GmntqnPpAgrE/tFEdpE0isAu927Xm0xty70115RQVFmOv1PnNTaITaL063y6k/7GJUcxnE9/XMAlVKyYcMGevbsSWhoqE/7HN66CaPFQmwv38SVbcNGcLuJf+EFgiZ3XTKqPzUZ62DhP8DjhBtWgykQhl3UqNmKRc+zb8VoPE4rfcaEc9xZ/THkHyLv9n9SsewHHFYjn5+kp8Ti4crvJeY6bhV2PXx3ajgTOnFa3YVNmzaZLrjggtr6GRkZGaY77rgj87777svrynF1JM3NubCwUP/dd9+FKopCRESEa+7cuQdTUlJchYWFuvPOOy81MzPT6PF4xD/+8Y+cm2++2a8gDV8uJZ8DTgMWAkgpNwkh/oqfyUZ4PB6yv5VkpW3vElFxqMJFiGKh38zpnd53S0gpyXO6fHbSrNmnrVf/E/tGNVnro4YaUWE2t27pInuvN9lcfN+0Vu3fEp/9kUFWqZ3Hzh3i9/tQVFTEwoULmT59us9r+oe2bKTHgME+VU0FqPztN9DrCWhjwTeNJnCUww8Pwe9vQHA8zHgadEeEsZSSnJxFhAQfR4A1ip59Z1F+sJLx5w8m2JlH/kN3U/7dYlwWA19O0LN4jGD6oAsYE5zCu8anmPWjg4gyKAyGBZNNnHbVv7twsr6xdu3a8BUrViRUVFQYAwMDnRMnTswcPXp0m3I4DB061LFz587t4I20iY2NHXrhhReWtMuA24EPVx8Kf+GHPQn55Q5jVJDJedOUPpl/G5fcIXOOjIx019Q8efjhh6P//e9/x3300UeHn3zyyah+/frZfvzxx71ZWVn6/v37D/r73/9eZDabm0860wCfflGklOkNfui6RbnYrmZvxmEMqonghKbDFzuSzA1rKNQ5GSSC0Rm6lzd3mduDQ5U+h5MC7J85E8uwYcQ//HCr+rS7PBRXOYkLab52hc3uzXhrbqWlInvPToRQfL669xWXR+Xl5XsZlhjK+GYygbbEgQPeHDY9e/qW0bUsP4+SnGyGn3a6z31Ihx3r2LHoAn23Pmn4wK7F8M2/oCwTxlwDk/8D5vrrE5WVh1j8ShaRiSuYee0seg0eSlJEFvnPP8L+RYtwGxQWnaDj27EKU4fM4rNBVxMX6HX0Dbs2jIdHPU9OZQ6x1lhuHnEzM3p278RXa9euDV+yZEmy2+1WACoqKoxLlixJBmirsKhh4cKFwUlJSY6+ffs6j9664/lw9aHwh77enuyoTk2eV+4wPvT19mSAtgqLGpqbc2VlpVJzfhdCUF5erlNVlbKyMiUkJMRtMBh8FhTgY0ipEOJ4QAohDMDNQLfMSNbZ7Nrj/TFPSfXdU7+9+P2bn0DA0DG+e9l3FgZF4dUByQwMbP4E35CQM87EkNB658fV+wu54t21zL92HOOaWT6w2zPR6QIwGJpOjHU0snbvJDIxCaOl7fVJ6vLFhkwyim08eObAVllr9u/fT1BQEBERvi2bHNq6EYCkwcN87iPm7ruR0q/fFo2WKM+FxXfCti8gqj9c/T0kHrECVVUdIuPgcvoOuILAwBR6DR1CZFxyrUXPXV5G4eJvWDxG8PU4PacMO5cFg/+PWGv9+lgzes7oliLijTfeaDZ8Kicnx6qqar0vgtvtVpYtW5Y4evToovLycv28efPqlQG/9tpr/Sq2NW/evPBZs2Z1au6lM1/6tdk5b88us7oaVGd1uFXl8cU7E/82Lrkor8yuv+b9dfXm/NXsE9s053/84x8Jn376aURQUJBnxYoVuwDuuOOOvKlTp/aOiYkZUllZqXvnnXf263Qtp79viC/xftcBN+ItJJAJDKt+/pcnK937/xnYzleuvjB84lhGm0LpPa37FQcK0CmcHRNGX6vZ530ir72GkBmt//HbmF6CEDAwvnkvNLstA7M5oVUnbikleQf2Eden/Zc+BDCpXxQn9fM/8kVVVQ4cOFCb5MoXDm/ZhDU0jIgevoXWyuqIj45wTv1LsmUBvDwadn4DJ90Lf/+5VlC4XGVs2/QEX776Fsteiufg9v0ATJh1PJGr53PojtsAsPRLY8ETU3FcdyEfX/od9467t5GgOFZpKChqcDgc7WKStdvtYtmyZSGXXnppcXscrz1oKChqKLe7O2zOL774YmZOTs7mWbNmFT755JPRAF9++WXIoEGDbLm5uZt///337f/617+SioqK/EoV7Uv0RwHQOCOMBmU5DoS5lPCQkE7vO2X8JFLGT+r0fn0hw+4k3e5kZHAARh/yVKhOJ2pFBbrQ0NokQv6yMb2EPtGBBJmbX3Kx2TNbvfQhhOCal9/B5XAcvbGfnDcqkfNGtS7PSG5uLjabjdTqRFJHQ0rJ4a2bSB48zGeRkPPggzj3HyDpvf9pwqI9UPQQMwhmPg+R3gsSVXVx+NBHrF+ymbxtJ6G6LaQdF054YGCtdeKgLZM1mUuZWribPhF9eeDUJ47Z/0dLloWnnnpqcEVFRaPwrcDAQCdAUFCQ21/LRF0WLFgQMmDAgKrExMRmUo52DC1ZFsY8smxwXrmj0Zyjg0xOgOhgs9tfy0RdWprzVVddVTR9+vQ+zz77bNZ7770Xcdddd+UoisKgQYMciYmJjk2bNplPOukknyM/m/0FF0LcUX3/ohDihYa31k3tz4VaZMQT1vlRtstfepnlL7yCVLunOfrrvBLO3rAXm0c9emPAvnUre44/gcqVzaSOPgpSSjallzAsMbTlfuxeS0VrMZjMBAS3n4D0qJJvt2Tj9vF9agp//SmkqjLpsv9jyCnTfO7DnNYfy4jhx+wJrMtRVfj5KVj1svf5gDPhim8gso/XApa7jO/m3caSFwPI2TiD+N5hnP/PAQwu+InMM09j59dzAeh7231U3HwxIZZQ4M9rOZo4cWKmXq+v96XQ6/XqxIkT21QGvIb58+eHn3/++d2q0vZNU/pkmvRKvTmb9Ip605Q+HTLnLVu21GZy++STT0J79eplA0hISHB+//33wQDp6en6/fv3m9PS0vzyO2nJUlHjN7HOnwP+VXC4HARUhELPzv9sbs8pQwodk7rpb8pZMWEMCLQQrPdtLc6d17ZsmocKqyiucjGsmSJiAG53OW53GZZWiop1iz7H43Yz9uzzW7V/UyzfmccNc//g9UtHctrA1pmu9+/fT0REBMHBviUfUHQ6v0Niwy68oBUj06hFUSBrA5iCvAXJqsVAefk21q14l30rB+IoPpOweDjhb30JWPklBRffjKyqZFV/hU1FX/ECfyPUHMrdY+/u4sl0PDXOmO0d/QFQVlam/Prrr8HvvffeobaPtP2occZs7+gPaHrOt912W4/9+/ebhRCyR48ezrfffvsQwCOPPJJ9ySWXpPTt23eAlFI88MADGXFxcX5ZdFoqfb6o+v691k7mz8yOffvQST0RCZ2fSebau28mf8e2bnulEmsyEOtPNs021v2oqUzakqVCpwvguHHL0OlbF6mTe2Bfuy99TE6L5t0rRzOxT+vm7Xa7OXToEMP8qE67Z+0qIhKSCI/3TVy5srJQgkO0qA9/cZTD8v/CqKshsjfMegf09dN8//HDarYvno4l2M3ki1KI3PkDhdfdRVVZOb/3U/h8gonRJ8zi34P/r4sm0XWMHj26qL0iPeoSHByslpSUbGzv47YHfxuXXNRekR51aWrOS5Ys2ddU25SUFNfKlSv3tKU/X5JfLQXOk1KWVD8PA+ZLKTuu9vMxwN79GYCeXj07v+aGwRpA/KjRnd6vryzOLyVIr3BCmG8ncHd+Puj16MJaF5WxMb2EAKOOvjHNF3QTQkdAgG9+B00x46bb2zX6QUpvSvHWOGfWUFhYiJTSZ38Kj9vNdy8+zYCJUzj56ut92if3scexb99O72VLWz3Ovxx1w0TDe3pFhd6Ex2Nn97a3MegG03vgBEZNORerPoukvN8puut+CopL2NBLYcEsEyMmzOL1JqI5NDS6O754lkbVCAoAKWWxEKL1v4R1EEJMBZ4HdMBbUsrHGrxuAt4HRgKFwAVSyoNCiBS8yzM1jiurpZTXtceYfOXs06awd+BhUuLbvwZEc6geD6/c/wQ9Ay1Mv+ufndavvzx6IJteFpNfokIfEdFqJ80N6SUMTghB30xlUoDikrWUl2+lR8LfUJTWpTRvL8uQlJIL31jN6UPiuPS4lFYfJyYmhrvuusvn9jq9niuefsVncSQ9HirXrCGohcJkGnWoyIPv7oRtnzcZJgqCVfPD0OvL6DVHYg0KJb5gAYVPPM3WFIVPzzAy5KTzeEUTExrHML78inuEELWxZ0KIZKDNl2xCCB3wMjANGABcJIQY0KDZ1UCxlLI38CzweJ3X9kkph1XfOlVQgLdCYL/kVEyGzis5vnXhZxToHQif/m1dR57Dv2ya7vz8Vi99ONwedmSVMSwptMV2BQU/sG/fUwjhf4TW2kWf8/Gcu1A97ZPzbdmOPNYcKCLAj/eoOWoKUPlKcFQ0IdG+lQe3b9+OWlqKtQuq7x5TSAl/fAAvjYadX8NJ99SGiRYU/Mr3Hz+Mvaocnc7EKZdNYFJvJyXfLwEgdNYsXrw6ml0PXMQLNy35U4WGavw18eXX6B7gVyHECrwh9eOBa9uh7zHAXinlfgAhxHzgTGB7nTZnAg9UP14AvCS6iSPBC6/Op2f/WE6fNKnT+ty8YR+KEIw5u/uuPDlUlWK3hxg/K5QaYlv3QyoQvHHZSBJCW0601bvXnaQkX98qa0P61k3YyspQ/EwC0xRSSl74YQ9J4QGcOaz1Vi6n08l7773HpEmT6NPHtzwpKz/+gJiefeg9epxP7StX/gaA9Tjf2v8lKdwHi26Gg79A0vHeMNGovlRU7GXd8vfZ+2tvHKXHExmxhxEnj6BHvwTW3foCvwVWcu4pUwgIDOW5W5di1GkFoDX+HBz1kldKuRgYAXwMzAdGSimXtEPfCUB6necZ1duabCOldAOlQE3awFQhxAYhxAohxPjmOhFCXCuEWCeEWJdfXV67rThcDlw7Aji8t/Pq0HicTjJRifUEENGv2cRsXU6+0+so7E+K7rZYKox6hUn9oukT0/JSixACg8H/cFCpqmTv2dVu9T5+2p3PlsxSbjypV4vLNUejoqICnU6Hr9nuHFVVrPny09r6Jb5Q+dtvmNLS0PuYqfMvh7MS3joZsjfD6c/BFd/gDIlg3S9PsuDJJWz7ZhI6Ec34kTasrz1Ece5hhBA4nriDfbecicPtdfzVBIXGn4lmLRVCiDQp5U4hRE095azq+yQhRJKU8o+OH16zZANJUspCIcRI4EshxEApZVnDhlLKN4A3AEaNGtUunnYmg4l/vXAGTperPQ7nExsWzMemuBjRBYm2/CHP6X1PfC17Lt1uPEVFrRYVS7blEGE1MiolvMV2O3f9h8iIk4iMnOzX8YtzsrBXVrRLJk0pJc8v20NCqIWzh7cuCVcN4eHhXHXVVT63z9ixFamqJPuYmlutqsK2YQNhl17ayhH+icnfBZF9wWiFs16F+GGo1jB2b3uX9d/mU3JgFHqzhxGD7YQufhW+3MvhSMHKVW9z1VlzOHHQdE6kexUB1NBoL1r65b8V7zLH0028JgH/fp0bkwnUDZ3oUb2tqTYZwrsYHgIUSq+nmQNASrleCLEP6Esn59QwGlrn8Ncatu3IRKcojD3vzE7rszXkOfyzVEiPh6hbbiFg1MhW9ffINzsYEBfcoqhwuyvIzPwIs7mH36Iia/dOoH0qk/66t4CN6SU8cvYgjPq2+cW4XC4Mfnz+Dm/dhN5gJL5vf5/aV61fj3S5NH+KhhxcCf+b4Q0RHXQO9JtKTubP/Pr+cvK2jwWSSOtrJ2ble+gWbyUnTPDZmQbizzqfq4b89UJDuxtz5syJ/uCDD6KEEKSlpVV9/PHHBwMCArpnFsF2oLnS56ecckr59ddfn1xVVaX06NHDuWDBgv3h4eGqw+EQF110UfLWrVsD3G63uOCCCwofffTRHH/6bElU1MSQXV3j99DOrAX6CCFS8YqHC4GLG7RZCFwOrAJmAT9KKaUQIgooklJ6hBA9gT5AR4yxSd6a+znFWTZuv71zspe7qqrIEh7iPBaCkzo/hNUfaiwVMSbfLBWKyUTktde0ur9F/ziRcnvLFiN7dXXS1iS+yt6zE1OAlfD4tlkWanwp4kLMzBrZtmNVVVXx9NNPM2PGDEaMGHH0HYDDWzYSnzYAvdE3U3vlyt8QBgMBI307/p+eijwIjIakcXDy/dD7ZKRUEUKhMEMld8t4EhMrSNryOaYf1pAfAp+fbiDmnPO5d6gWzeEvGRlzww8cfCnB6cw3Go1RztSU2Zk9elzSphwOBw4cMLzxxhsxu3bt2hoYGCinT5/e86233gq/6aabOrWwWLOsfTucFY8nUJFnJDDaycQ7Mxl9dYeUPj/nnHN6Pf744+kzZsyoeO655yLmzJkT+/zzz2e9++67YU6nU9m9e/f28vJyJS0tbeAVV1xR1K9fP5+zarZ0uVSTum1BWybVHNU+ErOBJXjDQz+RUm4TQjwohDijutnbQIQQYi9ey0lN/NwEYLMQYmP1+K6TUnZaasuC3TY8+Z1Xbvz3eXNxKG56RzWfh6G7kOt0IYBIH6+iPaWlODMyka2MrAixGOgR1nLVUHsbSp5n795JbO++rQ53rWH1/iLWHizmuom9MPmYabQ5Dhw4gMfjITLStzLplSXFFKQf8nnpA6By1SosI0eiWHyvNPunpCIPPr0SXhkHlQWg6JAn3MRPS1/hx0/eB2Dg2EmMj19Hnw/upGLfGt6ZamDlMxdz15zvuft4LZrDXzIy5obv2ftIstOZZwSJ05ln3LP3keSMjLktr3H6gMfjEZWVlYrL5cJmsyk9evTovDXsllj7djhL7k6mItcIEipyjSy5O5m1b7d5zjXULX1+6NAh07Rp0yoATj/99LKvv/46DLy+Z1VVVYrL5aKyslIYDAYZGhrq149zS2fGIiHE90BPIcTChi9KKc9oYh+/kFJ+C3zbYNt9dR7bgfOa2O8z4LO29t9a9CVWZHxlp/W360AhBp2OMRfN6rQ+W0ue0024QY9B8S3KomzJEnLuu5/eP/6Awc+cH19uyCSzxMaNJ/VusZ2tVlT4Z6lw2qooSD/MuDHH+bVfU6zYnU90kIkLRrfd0nTgwAGMRiMJCb7N5/DWTQB+iYrE11/DU9rIRemvg5Sw4UP4/l5wVcH421ANRhS8idSKDiRRmWnFfmIW5oR4mNSbD/INBJ9/Hv8acY0mJI7C2rVnN+ttXl6xwyqlq94PiKo6lL37nkzs0eOSIocjT79589/rlQEfPfqLo3ogp6amum688cac1NTUISaTSR0/fnzZOeec03kf8jdOat7DPmeLFbX+nHE7FJY9kMjoq4soz9Ez76J6c+ba5a0ufd67d2/73LlzQy+99NKSDz/8MDwnJ8cIcMUVVxQvWrQoNDo6eqjdblceeuih9JiYGL9ERUuXX9OB+4B8vH4VDW9/SfKKC7E4ggmO67z8FCMGpTAqMISA6NY5M3Ymt6XE8vFQ34pbAVjHjCHu4YfQ+3jVXZfP/sjgm83ZR21nt2egKCaMRv/6yNm3BynVdnHSvGtaGt/dPB6zoe1hqfv37yc5OdnnyI9DWzZitgYSleJ7RlFDbCzmfn1bO8Rjm8J98N5MWDgbogeg/n0FuyKS+ejptzmwYwMAp513KsO+uZel//VmJh0y4Rxuf3IFd43/jyYo2khDQVGDx1PeJvNwfn6+7ptvvgndu3fvlpycnM1VVVXKK6+80m6WgDbRUFDU4CjrkNLn77zzzsHXXnstauDAgf3Ly8sVg8EgAVasWBGgKIrMycnZvHfv3i0vvfRS7Pbt2/0KT2ppwG9LKS8VQrwppVzRhvn8qdi+x5syPSHJ/5Ngaxl24YWd1ldbiTEZ/MpRYUxJwZiS4nc/qirZmF7CzKFHt27YbZmYzQl+56gwWgLoP/4k4nq3LYS3sMJBRKCJiMC2C9HS0lKKiooYPdq3NO1SSg5v2UTioCEoim8ipGjuXBSrldCzzmrDSI9BPC747QVY8QTojMgZz5IVncxvHy8kf8dwBGEcnv8rqXOGY42L5I9bplDUJ6q2NHmYuXVp5v+KtGRZ+OXX4wZ7lz7qYzRGOwFMpmi3L5aJhixatCg4KSnJER8f7wY466yzSn777bfAG264oXOWzluyLDzVd7B36aMBgTFeX4agWLe/lom6NCx9Pnz4cHtNjY/Nmzebvv/++1CADz74IOK0004rNZlMMiEhwT169OiK3377zTpgwIB28akYKYSIBy4RQoQJIcLr3lo7uWOdQwe9jrD9e/l+Nd4WvnvyWTZ+PL9T+moP3s0s4PeSCp/b27Zswb57t9/97C+opNzuPmq5cwBbK0uex/bqw/TZ/8Ic2Hpflg2Hiznu0R9Zsbt9cqTs3+/1R/a13ofTZiMsLo7U4aN87qPs62+o+Okvdh2RvQnemAQ/PAh9TqH00rl8uz2PhU9XkbdtNDFyH2NX3k/w56+wbtN3AFx+9XPcMuGeblvY71glNWV2pqKY6pUBVxSTmpoyu01lwFNSUpx//PFHYHl5uaKqKj/++GNQ//797W0bbTsx8c5M9PXnjN6kMvHODil9npmZqQfweDzcf//9cVdffXUeQFJSknP58uXB4K1u+scff1gHDx7s13vUkqXiNeAHoCewHm82zRpk9fa/HIVZFQidntSEtnnw+4KjopyNFZXkb01n2DFQfVpKyX17Mvl7YhRjQn07Eec8/DA6ayBJ77ztV18bDhcDMNwHUWG3ZxIcNMiv40spKcvPIzgquk0njdgQM5cel8yo5Pa5ij1w4AABAQFER/tWfscUEMB5//mvX30kfzQXae8ev7WdhscFthKc57zCbwfy2f1sNq7KMYSKQ/RePxezLZOlo/SIS87n0j6tC3/W8I2aKI/2jv6YPHly5cyZM4uHDBnSX6/XM3DgwKpbb721fdR+W6mJ8mjn6A9ouvT5O++8E/72229HA0yfPr24JgLmjjvuyLvwwgtTevfuPVBKycUXX1wwduxYmz/9iaMVFxJCvCql9K2kYTdn1KhRct26tqWyeOyej0AV3PXoRe00qpYpTT+EraCQ2OHHRmhfpduDBwj2McJhz+TJWEePIf7xx47euA73fLGFhRuz2HT/qSgtOIV6PA5W/nYCSYlXk5Li+8e4OCeLd26+ltOuu5lBJ53i19g6CiklTz/9NMnJyZx3XiP/5SZxu1zoOzGfyjHFnqWQuR4meYPKDmxfxvK5h7EVphAg8ui15VNCi7fz43A96qVnccmJs4mx+lY35c+GEGK9lNJ3c1cDNm3adHDo0KEF7Tkmja5j06ZNkUOHDk1p6rWjOoFIKa8XQpwI9JFSviuEiASCpJQH2nmc3R5VVTGWBqH27DyH4ZDEZEISkzutv7Zi9SNcUkqJJ78AfZT//ikb00sYmhjaoqAA0OlMTBi/DinVFts1xBRgZcrVN5A4cIjfY6vhxR/2cHzvSEa2k5WioKCAiooKn5c+VNXDGzdcwYipMxl3rm9+OVn33IM+LIzo225ry1CPDfYtR+77AfuIi7EEJxEROwRZUkTfPR8Sk72aX4bqcP37XC6a+I+/rJjQ0PCXowbfCyHuB+7kSN4KI/BhRw6qu1JeVYkztJy4lI5PlV18YC8v/ucx1rzzvw7vq73YUWFjzt5Msuy++fR4SkqQLpffKbptTg87c8p98qeoQQj/8kwEBIcw7NTpPlf0bMiO7DKeXrqbX/a0n3U1MDCQM888k759fYvK8DhdDD1lGrF9fHM0lS4X5YuX4Knw3SfmmEJK2DAXDnkLpf1/e/cd33S1P378dZI03YOWlpZORhllT0GQrSIqIIqIKCAu9KKA29/9usCBC8GJqFzhigIXURTuRYYgsgvIkk0ZpXS3dLdZ5/dHUiilI23TppTzfDx4NPn0fD6fcxJt3jnrzeBXWO06lmXvbcZsNOLjH0Rw4zXEBexi47sjuefr9Uwb9qYKKBSlCuxZrnIX0AXYCyClvCCEqDh7UwPl6+XNS2+W3vSzduxY/ivp2kJcPa6dzYf+zi3gi/hUHmhqXwIqc5q1N7SqQcWhC1mYLdKuoCIl5TeSU1YR0/ZdtNqKN8kqKW5vLIGRzfAOqN4qn09/P4m3q46HbrR/GWdl3N3d6dKli93lXdzc6HPvA3aXLzhwAEteHp69G+DW3OmnYNV0OP0HhW1Hog3pgoveHV99EEWHTrD1+7n0m/Ac/f/5MXnGPBVIKEo12fP1zWDLtSEBhBCetVslBeB0VhFeFlc63H23s6tit+QqZig12bLGVjWoyMgzEOjtSucIv0rLGo2Z5OWdQKNxs/v6xsJCfn5/JgfW/69K9Sp2PDmH/x5KZGKfKHw9HDOfwWKxsHv3brKz7R96Szp1AmOR/RMu87ZtB40Gz143VKeK9ZPZCH/Ohi9uxJLwF7uCp7Bw+51snG/tbO099h6yA9aS2MQ6jOal91IBhaLUgD09FcuEEF8CfkKIR4FJwFe1W6366cOPvseYAS/NrN3eiuS/D5KqLaQ1nmhd6m478JpKMRhx12jwsjOld3WDilvbBXNLTBO7VmWEht5HaGjV9vlIijuBtFgIqWYSsU9/P4mHi5ZJfRzXS5GUlMSqVau4++676dChQ6XlTQYDS197kU633MaA8fblVsnbtg239u3R1vNMuHZL2AO/TIXkg5z0G8nmC4MpOBeGZ95ZtHtXkjvhbry8/Rn/1Wa0du7hoShKxeyZqPmBEOJmIBtoDbwqpVxXyWkNUkBTT3Lcq7S6plp2/bIWKaBj15ptulTXUoqMBOl1di/BLA4qtI2rvlNobe4NUJyZtDqbXp1KzWXVgQs81q8FjTyrtBFdhUJCQnjqqafw9LSvo/DC8SOYjAYi2ne2q7w5J4eCAwcIeLQBZNIsyoWNbyF3ziNNG8MG49ukH22La1E67U4tINlzHycfv4XuemsgoQIKRXEce78GHwCKtwPcX0t1qfcmjqmbtONn84z4CjdaDxtWJ/dzlGSDqUq7aZpSUxEeHmi97B9RS84uZPS87bwxvB0D21S+V0Ps7rtpEnQ7ERGT7L5H4omjNAoJxd3bx+5zin228SSuOi2P3OS4XgqwBlEBAfbNVQHr1twarZawtu3sKp+/axeYzdf+fAop4btR5J05zh/yWU4n9kJrKqTlmRXkiT85+cgght/zO0Ee9u3zoTQsM2fODFq0aFGglJLx48envvrqqynOrlNtKyvd+7p167xefvnlMIvFIjw9Pc0LFy480759+6KHH344fOvWrd4AhYWFmvT0dF1OTs6+qtyv0qBCCHEv8D6wCesGWJ8IIZ6XUtZK9tL6Kq+wAJPJhK9X7c5RPR+7gzRdIe2EJ1rdtTP0AZBqMNLK0/65C36jR+NxQ68q3aPAYCYmxIfGdmx5bTYXkJ29j8DGg+2+vpSSxBPHiOpU9X1BzqTlsXLfBSb1ibKrfvYymUz8+uuv9OjRg7Aw+zZdO3dwHyHRrdG72zc5NW/bdoS7O+5dOtegpk6UmwrufqB1IaHFWFbGBoNFS3jCRixFa0kY25vb71ur5ktcIxYmpPnPPpMUmmIw6YP0OsMzUcEJE0Ib12gjqNjYWLdFixYF7t2794ibm5ulf//+rUaNGpXVvn37IkfVuyaWHlvqP2//vND0gnR9gHuAYXKnyQljWo+plXTvs2fPDlmxYsXJrl27Fs6aNSvwtddeC/nxxx/PfPPNN/HF57711ltB+/bts392u409g9//BHpIKSdIKccDPYFXqnqja92GLdv593M72XFgX63eJ3bNnwB07dO5Vu9TG5INRprYOUkTwLVlS7wHDazSPaIaezLvwW50CKt83L86Kc+zUpLJz7pI02rMp/jqzzh0GsGj/Ry72Wx8fDz79+8nL8++zLiFubkkx50ion0nu++Rt20bHj26o9E7bsimzmRfwPxpT84tnwlA8E3jaZS5ibC4N8kYnkXvlauY9PDHKqC4RixMSPN/9WRCZLLBpJdAssGkf/VkQuTChLQapYc4ePCge5cuXXK9vb0tLi4u9OnTJ2fJkiV+jql1zSw9ttT/vdj3ItMK0vQSSVpBmv692Pcilx5bWmvp3i9evKgFyMrK0oaEhFyVAn758uX+999/f5WDGnu+CmuklCW7iNKxLxhpUC7EpyMIoFWkY7u1S4s3mGmEGy2G1I9dHO1VYLaQbbIQpLe/dyVn40b04eG4tqw4dXlJ2YVGfNzsC1wKCs8D4OZuf96PxBO2+RTVyEz6wq1tGBLThCBv+3tr7HH69GmEEERG2rcJWvzhA0hpIcLOVOfSbMbnjttxbdGi8sL1SVEOuHqDT1NWXZxEwobu3NZhD81iutFj1hh8Ap8hyEsFEvXR0N3Hy52w9HdugadRyismTRVZpOatUxfCJ4Q2zkguMuomHDx9xX+sa7q3qjTZVufOnQtmzJgRmpSUpPX09JTr1q3z7dSpk32RugOMXTW23DYfzTzqabKYrmizwWzQzNkzJ3xM6zEZqfmpuqd/f/qKNv9wxw/VTvfu4eFxZtSoUdGurq4WLy8vc2xs7JGS5x0/flx//vx5/Z133lnlnR7tCQ7WCCF+E0JMFEJMBFYD1Vtrdw3LTioi3y0L/1qcGW8xm2kf6E3nJn61do/akmY0IYCgKsypuPDc82QuXWZ3ebNF0vvtDXy41r5kfYWFFwCqlEzswvGjuLi60bgau5j6ergwsLXjx+rj4uIIDQ3Fzc2+YOXswf24uLoR0tK+TbKEVkvgP/6Bz9ChNalm3TEbYctHJL1zK+d3/BeA8Fs7EhK/kHMJ1ilfLZt1VQHFNap0QFEs22yp0Xhw165dC6dOnZo0ePDgVgMHDoxu165dvlZbPybplg4oiuUac2sl3fvs2bObrFix4kRycvKB+++/P+2JJ54IL3newoUL/YcNG5apq8YQvD2rP54XQowC+toOzZdS/lTlO13jLBl6aJRfq/fQaLUMevoftXqP2hLupudc/05IKs4lU1LU0iVo3O3f3OtESg55BjPNA+2b2FlYcB4hXHDV2/9Bn3TyGMEtotFU4Y/NhYsFPLl4L2+ObE/7UMcGnYWFhSQkJNC3b9/KC9ucO7SfsJj2aHX2BXiFR46gj4hAY+fKEqdK2MvFZS+w8fhNXJBv4jFvDw/1GkbXgSNo1WcwXvrqZ5RV6k5FPQudth7qkGwwXTUO10SvMwA0cXUx2dMzUZbp06enTZ8+PQ1gypQpoWFhYXan9K6pinoWBi4b2CGtIO2qNjd2b2wACPQINNnTM1FaWenet27d6nXkyBH3QYMG5QGMHz8+c+jQodElz1uxYoX/xx9/fLasa1am3J4KIURLIUQfACnlCinlM1LKZ4BUIcQ11k9aM0XGIjxy/fAIqt2o9td3ZnPmz021eo/a5KIR6DX2j4y5tmyJS6j9vQj7zl0EoHO4fbk0rCnPm1Zpi+7Rr7zFrU9Mtbs8QFJ2IfkGE34O2uiqpLNnzyKlpHlz++Zp5Gakk3nhPJH2Dn1YLJx7+BGSZsyoQS3rQFEueSuf539vL+L7I8+TZLqBoMTfcG11HLPFDKACigbimajgBFeNuCJZj6tGWJ6JCq5xGvDilN8nTpzQr1692u+RRx6pcRZQR5jcaXKCXqu/os16rd4yudNkh6d7j4mJKczNzdUeOHDAFWDVqlU+LVu2vLRL3l9//eWWnZ2tHTx4cLWGhirqqZjD5XwfJWXZfndndW54LToaF4dW6giwY3JgdZ3+YyN7irKRm/cQddOAWrtPbfk9PZvf0rJ4rWUoHnZsfmU4f57cjZvwuW0ousb2bYW9L/4ifh4uRAXYNyG5sDAB9ypM0gTQu3vYvWKiWNeIRvw2rV+t7J1x+vRpdDqd3as+vPwDeOSTr3Fxs78HKPTDD9BUY/lsXTEc/i9/frWCE7nDMWs88M+IRcacpv97rxLUqGrvr1L/Fa/ycPTqD4Dhw4e3uHjxok6n08k5c+aca9y4sbnmNa654lUejl79UV669/DwcMM999zTQgiBr6+v+dtvv72UIPTf//63/4gRIzI0VfiCWFK5qc+FELFSyh7l/O6glLLybf0qu7kQQ4G5gBb4Wko5q9TvXYFFQDesE0THSCnP2H73MvAwYAaellL+Vtn9qpP6fM59EzHLdKy7lAu0IoBpS76t0jUq8tGkicj8AqTMQwhPhIc706+hJGJQ9deoqm2u7etXq06TJmIpUV7j4c40B75vVb3+nEmTsOTnlSjvybQFCyq8x6dPTkVf0Bej3h8XQwYG9y1M+Xxu+eX/MRV9fonyHluY8ln55atq/pQpkNf/0vWFxybaBJo5Ej8Ao0sQ3lnH0EYe4ObnXyYoIMJh923Iju9MYvvKU+RmFOHl70rvES1odUNwla+jUp8rJVWU+ryiUMSvgt/VOMuVEEILfAbcBsQAY4UQMaWKPQxkSilbAh8B79rOjQHuA9oBQ4HPbddzKOuHWRpcmicgMcs05tw30SHX/2jSRCx5F5HS2sskZR6WvIt8NMkx168LVX2Nqtrm2r5+teo0aSLmUuXNeReZ46D3rarXnzNpEua8jFLlM5gzqfwNvz59cipa41CMrgEgBEbXALTGoXz6ZNlDP5/+YypaQ6nyhqF8+o+qDRWVZ/6UKZiLbr/i+ibDnRy4MAqd0YSf+0/cMmco42Z9oQIKOx3fmcTGxUfJzbBuw5CbUcTGxUc5vjPJyTVTGrKKhj92CyEelVJekedDCPEIsMcB9+4JnJRSxtmuuwQYARwuUWYE8Lrt8XLgU2HtYx4BLJFSFgGnhRAnbdfb7oB6XWL9dlz28Y8efeiq4xYvHc9+9BWbVv/EXz//gqWRO8++9zn//vht0g6euLp8Xi5gKnXUhMzP56NHH8IlojFTXnmfee/8PwriEiutb+nyjTq0YOLT/8ecf05FplS+Mqh0+ba3DWHoqHHMfm4yIqvs/WEsFbxGyefP0SQsgtnTH0XkmipssyUvl5QL5wlqGsbs6Y8h8k1M/3JBxe/BYyXeAyGY/uUCZH5Bude/onzJNpT7Pli3ZP9o8sMIy+UePXN5bbCVn/PEI2i93Hjq/U+tzx97uMz7lqT1db9Uvrzrm/Ny+fixq7fRNudll1OfPLasX8X+X67eVd+laBAmlys36LJoXdEX3sQn06YTdkMH7ho7iVUrvuP05j3oC8su71I4iG+eeYrm/bozcOQE/vzfEo6v20rnkUPp1u921vzwGQmxRyttP/kDsehLX1+PzpDFbe/0IiTU/myritX2lacwGa4YpsdksLB95alq9VYoij0qCiqmAT8JIcZxOYjoDuixpkOvqVAgvsTz80Dp9IiXykgpTUKILCDAdnxHqXPLnPEnhHgMeAwgIqKq33DKW8kgsWSnXnVUX2BdZXDkrx1YslNxMVifJ5+KQ5RRvty7ynxkdj7Gc9bn+WeTkHacX7p8+glrR5S4kI05v/LzS5c/tjeWoaPGoUs2YDTYX39bK0hJvkCTsAh0yWaM5srOLyQlNZGgpmHokk0YzcVBUAXvQVbJa1qXWxZ/Wy/r+pYs+zN2lryWvJiLpdzrXl3ekpmDJuvyH3NzVipgKecsK01uyRUq5dWzEGOW/d8ypczj723bwHD19vKmcuaUGl0aoSm8k4Sdv8BYOL1tD5rCO8stb3LxxpR/F3Gbf2bgyAmc2LSdwvy7OLx5Dd363U78lmMYzHb8uXAp+302ufgQEmr/PibKZcU9FPYeVxRHKDeokFImAzcKIQYC7W2HV0spf6+TmjmIlHI+MB+scyqqdrag7A81gQy+OtIX3tYleX1vG8lvqRm4BFo3Q2vXpy9/b916VXlN0kUkVycoE8ITGexD49bWvVLCenQh/uCBSmtbunyr3tZliD4dWpBxrvL1xqXL9xk2HABd2yCMKeWMLiUmUd5rFBZlXaWkjW6EMct6vkgsp824ExZuXVSkbdMYc5b+0m/Ku76madPLTzXWSZJCeJYZWAjc0YSWnTvDkpBe7vsA4BIViMV0+VxzfGqF5d1ahOLpf3lSrz4yqsz7luTT5PL1Be7lvkZuzZpedbzw9IVy69N3+F1s+fnHq2947gZM+qsnHrsYMpHR+4m50bpnRY+Rd7J/80Y42bXM8jpDFr7t9tL2Rut/KzeMuZuDG9fRbei9AHS6ZwhxezeW0+rLsv/uhFF/9eaBLoYMFm/8hdH9hqLXXoO7fTqB2Wjh7y0JCGFNhVKal7/jtpBXlNLKnahZ6zcWojfwupTyVtvzlwGklO+UKPObrcx2IYQOSAICgZdKli1ZrqJ7VnWi5uXx/CtpRWOHTNYsHsu/sutah8bT75qZrFnV16iqba7t61erTrY5D6XLaz39HDJZs6rXL55TcXV5/3InaxbPqbBoL3/AaMxFmF3WlDlZs3hOxVXl9WscMlmzeE5F6etni3V85T+YG1yz6X+TiTE3DcfXtYGkZncwi0VybEcSsatOk5NRiF+wOzlphZhNl//G6/QaBo5rU+XhDzVRUympuhM1a1ssEC2EaCaE0GOdePlLqTK/ABNsj+8BfpfWKOgX4D4hhKsQohkQDexydAWnLfkWrWiM9dsyWFceOCagAJi+4Fs0nn6XvuEK4XlNBRRQ9deoqm2u7etXq04LvkVbqryjAorqXH/aggVoPf1LlS8/oACY8vlczC5rcClKBylxKUovN6AAmPLZXMz6K8sb9L85bPXHY59+itZ19RXX17quZuxrrzOksZ7tRT58uN6fp97+lQ/XfML5nPMOuW9DUZhnZMmMnfy+6Aju3i4Mn9qZ+1/rxaAH217qmfDyd61WQKEoVeG0ngoAIcQwrHteaIEFUsq3hBAzgN1Syl+EEG7Av4EuQAZwX4mJnf8EJmH9ejZNSlnp1uHVWVKqKHYxm0B7bWWVra7UPAM9tv5Ny1zJuru61Mr+HKWdOneRd5buYUN6IR7ADa6phHU7y7033k37xu0rPb8hklKSlVKAXxPrviqbFh8lIiaAZp0bO/w9aQg9FSdPnnQZN25cs7S0NBchBBMmTEh95ZVXUp555pmm3333XWN/f38TwBtvvJEwZsyYLGfW1ZHKSn2+fv16r5deeinMaDRqOnTokLd06dIzLi7WiVOrVq3yfu6558JNJpNo1KiRKTY29qqdPCvqqXBqUFHXVFCh1Iojq+C/z8HkLeBp30Ze17qPd5zBT6vhwe7hdRJUFDscl8Gs/+xjc2YBvsANbom89cIIAj0C66wO9cXe386y69fTjJvRC29/xyaxK62ug4rvdpz1/3jDidDUnCJ9oLer4enB0QkP9Iqs0UZQZ8+edYmPj3fp27dvfmZmpqZLly4xP/7448nFixf7e3l5mWfMmJFck+vXVMYPS/zTP/881JSWptc1bmwIePLJBP+x99U49Xnfvn3blEx9fsstt2TNmjUrdO3atcc6duxYNG3atKaRkZGG6dOnp6WlpWlvuOGGNmvWrDkRHR1tSEhI0IWGhpZeWlZvhz8UpWFo3ArCuoOhzhIeOt3TvaIY3yOiTgMKgJjm/ix6cRA/PdSTtr7uWNzCLwUU7216l/+dbti5DtPO55BxwfrfWcvuQdx4d0s8vBvWBNbvdpz1n7nqcGRKTpFeAik5RfqZqw5HfrfjbI3SgEdGRhr79u2bD9CoUSNLixYtCs6dO1cvXryMH5b4p8yaFWlKTdUjJabUVH3KrFmRGT8scXjqc09PT4uLi4ulY8eORQBDhw7N/vnnn/0Avv76a//bb789Mzo62gBQVkBRmeujv1ZRalNgKxjznbNrUedyDSb+3+/H6enlwQN9o+r03l1aB7Lk5UEYTNalujt2n+XnNR3w7JoNzcBkMZFjyKGRm315Yuq7i8n57Fp1mhOxyTTvEshtj3fAJ8CdjgOvzW3KR3y6pdw04IcTsz2N5lKpz00WzbtrjoY/0CsyIyW7UPfoot1X5J9aOaVvlZJtHTt2TH/48GGP/v375/75559e33zzTdCSJUsCOnXqlP/555/HBwYGOnz77tOj7y23zYVHj3piNF7RZllUpEmdPTvcf+x9GabUVF38k/+4os3N/rOsWqnPH3744czXXnstbPPmzR79+vXLX7p0aaPExEQ9wPHjx92MRqPo2bNn67y8PM0TTzyRMmXKlLI3CyqH6qlQFEdJOwEnNzi7FnVGpxVsoIjtF3OdVge9zvonzMXTg3Bfd+67eRgAq/5cz32L7+XNHW9yNrtayRbrhdzMQjZ+d5Tv39jJ6f2pdBsaycAH2ji7WrWqdEBRLKfQ5JAvwVlZWZpRo0a1mDVrVry/v79l+vTpKWfPnj145MiRw8HBwcYnn3wyvPKrOFipgKKYJSfH4anP582b579o0aK46dOnh3fo0KGtt7e3uTjPh8lkEgcOHPBYv379ifXr1594//33Q4oTj9lL9VQoiqOsfhbSjsPU/aBr+HsBuGm1bOvfHl93x2dnrapubQNZ2nYgAGaLZO460JueITvxJBMOPkjnll2Z2G4inYM6O7eidirINbBnzVkObUpASkn7/qF0vy0KD5960VtfYxX1LPR8a32HlJyiqxoa5O1qAAjycTNVtWeiWFFRkbj99ttbjB49OmPChAkXAcLDwy918U+ZMiX1jjvuiC73AjVQUc/CiZv6dTClpl7VZl1goMH202RPz0RpZaU+37Ztm9eTTz6ZsWfPnmMAK1as8Dl58qQbQFhYmCEgIMDk4+Nj8fHxsdxwww05u3fv9igeKrGH6qlQFEfpOw1yEuHAMmfXpM4UBxSxpzPILmcrd2eYfEsrsvUaluU2x+fUy3jvaMHUX6Yw7r/jWHd23aV06fWNodDErl/j+Pc/t3NgQzzRPYIY90Yv+o1p1WACiso8PTg6wVWnuTL1uU5jeXpwdI3SgFssFu67777IVq1aFb7++uuXJmWePXv2UlS8ZMkSv9atW1+9k1wtC3jyyQTh6npFm4WrqyXgyScdnvq8bdu2hcUp4AsKCsT7778fPHny5FSAe+655+KOHTu8jEYjOTk5mr/++surQ4cOVXo9VE+FojhK84EQ0gm2zoXO94PG4Tnu6qUdSVmMPH2WJ/breW1kO2dXB61GMKZfc0beGMn3m+L47I9THMhqTs+s/6NdxklmJr7ObL/ZTO02laFRQ51d3SuYTRb2b4gnIsafnnc2x7+pp7OrVOeKV3k4evXHunXrvH7++eeA6OjogjZt2sSAdfnoDz/84H/48GF3sH5T/9e//lXn42XFqzwcvfqjvNTn06ZNC123bp2vxWIRkyZNShk+fHgOQNeuXQuHDBmS1aZNm3YajYYHH3wwtUePHlXKb6CWlCqKI/39E/xnItz7b4gZ7uza1AkpJX3WHiDdaOLPbq0JCvFydpWuUGAw86/1J/hy62myzBb6o6Nz0Bma3RrEyHZ3kW/MJ9+UT2N35ywHPrE7mROxydw2uQNCCPKzDfWuV6Ih7FOhOI5aUqoodaXtcPBvDltml514oQESQvBau3CyPLW8u/mUs6tzFXe9lieHteHPV4bwVO8oYjVmlqVFMKzlHQCsOLaCW5bfQkJujXqaq0RaJGaztbfbZLBQkGOgMM8IUO8CCkWpChVUKIojabTQZypc+AtO/+Hs2tSZW0Ib0cGs5WcfM3EnM51dnTL5uLnw7Ih2bPnnED57pCd6VxcKC40cWR7CS/p/EuplTXS85OgSYpNiqY1eXCklZw6ksfStWA5utG413qZXMKOe74a7lwomlGufCioUxdE6jQWvYNjykbNrUmeEEMzsFEmem4Z3dpyulQ9kR/H31NO1uTUr7O5TGSwpLCQwuCsARTkFLNm3mEm/TWLs6rGsOb0Gk6XK+/+UKeF4Jive38vqzw9gNJjxaewOgNCIOt9ETFFqi5qoqSiOpnOF3k/CulchYS+EdnV2jepEr0AfeqNnbWAh+/en0rlzkLOrVKm+7Zqw9eXBBPtat7n+cNEBulyYytMxBr4sWMDzm5+nqWdTHoh5gFHRo/B0qfrEyZSz2exYGUf84Qw8/VwZMK41bW4MQatV3+mUhkcFFYpSG7o9BNkXwKv+f7A60sxukdy8+zjv7T/Hdx0ao7kGPjiLAwopJcmeWlaai/jxoOAB3ZM811HDN67f817se3yx7wtGtx7N/W3up4lnk0qvm5GYx65f4jj1Vypuni7ceHdLOvQPRae/PlYFKden+v9/vKJci9x84LZ3wffa3Ea5utr7eHKz3oPNTbVs3VZ3Ex8dQQjB3IndWfVUXzpHNuJzUwGT9+bTdudYlvh+w4Cgfnz797fc/tPtXCy8WOG1Us/lsGTGTs4dzqDH7VE8+GZvutwcoQIKpcFTQYWi1KZzO2HXV86uRZ16o2sktwhXItrWOBeSU7QP9WXRE735z+TeNGvqw0emfB7ekUbU5qGsbPwdr3T5P/zc/AD4Yt8XxCbFApCfbeDMQeuqycbhXvS5J5oH3+pNzzubo3dXncLOlp+fLzp06NC2devWMS1btmw3ffr0pgB33313VGhoaIc2bdrEtGnTJmbbtm3uzq6rI82cOTMoOjq6XcuWLdvNmDHjiq7T1157rYkQoltiYqIOID09XTto0KCWxa/R3LlzA6p6P/VfuqLUpoPL4Oh/ocuD4FK76anri2YebiwYEuPsatRYjyh//vNUHzafSOP9Xw/zdmouizcXsPIJ63bguYZclh9fjkTSI7gHW5Yf5+zBdCbO6ouLq5ZOg+s+hUSDEfuNP3+8G0puih6vIAP9X0ygx8M12gjKzc1Nbtmy5Zivr6+lqKhI9OjRo/WGDRuyAN58883zDz30kFOXLR3847z/7v+eCc3PMug9fPWG7sOiEjr0D6tRm2NjY90WLVoUuHfv3iNubm6W/v37txo1alRW+/bti06ePOmyYcMGn5CQEENx+ffffz+wdevWBb///vvJCxcu6Nq2bdv+8ccfz3Bzc7N75rXqqVCU2jTwn/DUnusmoChp/clU/vHDPgpyDJUXrqeEEPRvFcivz/Rj3gNdubVnGH6RvgAc+s8Z5lyczQj/ewEwd0vi186f8N2JReQYcpxZ7Wtb7Df+/PZyJLnJepCQm6znt5cjif2mRl1fGo0GX19fC4DBYBAmk0nUl1U3B/8477/1Pycj87MMeoD8LIN+639ORh7843yN2nzw4EH3Ll265Hp7e1tcXFzo06dPzpIlS/wApkyZEv7++++fL/kaCCHIycnRWiwWsrOzNb6+viYXF5cqLeVSPRWKUps8bH8TLGYwG6+r4GJjfj7r/CycT8wl2vvaHAopJoRgaPsQhrYPwWyysGb1KZ46cJb7THrujvClaXgAIY0DCArxY/ae2Xx54Evujr6bB9o+QIhXiLOrX//MH1huGnCSDnpiKZW101SkYf3r4fR4OIOcJB0/jL0iDTiPbbQr2ZbJZKJ9+/Yx586dc50wYULKoEGD8j777LPAN954I/Sdd94Juemmm3I+/fTT8+7u7g5fE/2fd2LLbXPa+VxPS6nsrGaTRbPj51PhHfqHZeRlFen++/mBK9o8+uUelba5c+fOBTNmzAhNSkrSenp6ynXr1vl26tQp77vvvvMLCQkx9u7d+4q8Hi+88ELK0KFDWzZp0qRjXl6edsGCBXFabdXmAameCkWpbUW58GkP2PaJs2tSp16OCWPv4I5Et7q2A4piFovk6PZEFr+2g1P/O8fd3r48MLEz3YZGEbstnrRv8vjI4w2W3bqUAeEDWHxkMbetuI0XN7/I4fTDzq7+taN0QFGsKLvGX4J1Oh1Hjx49fO7cuQN79+71jI2NdZs9e3ZCXFzcof379x/JzMzUvvLKK8E1vU9VlQ4oihkKzDVqc9euXQunTp2aNHjw4FYDBw6MbteuXb7BYNC89957wR988MGF0uV//vln3/bt2xckJycf2LVr1+Fnn302IiMjo0pxgsr9oSh1YfG9kLAbph0CvYeza1OnCo1mDh9Np2uHa3N5rZSSuH2p7FwZR2ZSPoER3vQa2Zzwtv6XNq168PNt/Hkuk5vQ8ZiHF10GR5HdDr4/8QPLTywnz5hHz+CeTO40mR7BPZzcoqqr09wfH7TqYB36KMWriYHnjh+sbh1Ke+6550I8PDwsM2bMuJSxdNWqVd4ffvhhk40bN5501H3s8a8Xt3QoHvooycNXb3jo3b4Oa/OUKVNCmzRpYvzoo49C3N3dLQDJycn6wMBAw86dO4+MHz8+6qWXXkoaOnRoLkCvXr1avfPOO+cHDhyYX/I6KveHojhb3+mQnw5/fefsmtQpKSXDNh/hyb/PknQ6y9nVqbL0hFyWz9rNmi8PATD0sfaMfrk7ETEBV+yC+cXDPXn25lb85SIZn3+R6b8e4vynZ5lsup+1I3/j2W7Pcib7DKezTgNgMBsoMtefVPH1Sv8XE9BdmQYcnauF/i/WaI3yhQsXdGlpaVqA3NxcsXHjRp+2bdsWFqc+t1gsrFixwq9t27Z1nvq8+7CoBG2pdO9ancbSfVhUjddlF6c5P3HihH716tV+TzzxRHpGRsb+hISEgwkJCQebNGli2Lt375GIiAhTaGioYe3atT4A8fHxuri4OLc2bdpUaVKUU+ZUCCH8gaVAFHAGuFdKedXMWyHEBOD/bE/flFIutB3fBIQAxW/+LVLKlNqttaLUQGRvCO9lHQLp/hBoXZxdozohhODeZoG8rknkX+tP8dIjXa6JLalNBjM6vRY3TxeMRWYGjW9L6xualLuZl5erjqcGR/Ng70i+/OMU/9pyht9zMxm2MpeHf/fmniG3cv/wsQid9fwVJ1Ywb/88lt25jCCPa7MHp9YUr/Jw8OqP+Ph4l4kTJzYzm81IKcWIESMyxo4dm9WrV69WGRkZOimliImJyV+0aFGdpz4vXuXh6NUfAMOHD29x8eJFnU6nk3PmzDnXuHFjc3ll33rrrcRx48ZFtWrVKkZKKV5//fXzISEhVdqn3inDH0KI94AMKeUsIcRLQCMp5YulyvgDu4HugAT2AN2klJm2oOI5KWWVxjLU8IfiVMfWwA9j4K750GmMs2tTZ4osFnr8cQhduoEfW0XSrGOgs6tUoY3fHeVicj4jn7EGQFLKKgdCKTmFfPb7Sb7feQ5hkYxEz/ShrQkZEAHAXyl/sfbMWl7o8QJCCNacWUO7gHaEe9fPZagq9blSUn0c/hgBLLQ9XgiMLKPMrcA6KWWGrRdjHTC0bqqnKLUg+hYIirEmGrNYKi/fQLhqNLwU3ZQLATrm/3kGi6X+zePKSi24lIo8uLkP4TH+SFs9q9OzEuTtxhsj2rPx+QGM7B7GJg/w7m7d2jv/7zRanQ3hhe7WgKLQVMiMbTO446c7eGbTMxxIPeC4hilKHXNWUNFESploe5wElLWRfigQX+L5eduxYv8SQuwTQrxS0WJjIcRjQojdQojdqampNa64olSbRgN9pkHqETix1tm1qVP3Ng0gUqPl11ANh7cnVn5CHcnNLGLT4qN8/9oOjm6z1qvtjU3pfluUQ/KWhDXy4L17OrHppYF4ebliNFsYvXwfS9dfngfopnPj55E/81C7h9hxYQfj/juO8f8bz4ZzGzBbyu2pVpR6qdaCCiHEeiHEoTL+jShZTlrHX6r61WWclLIDcJPt34PlFZRSzpdSdpdSdg8MrN/drsp1oP0o8I2ALbPhOlp5pdMI/q9NGGm+WubvjcdkcO6HZWGuka0/nuS7V7dzZFsi7W5qSlTHxrV2Pw+9dfpadoGR4ChfQm+NQmgEuRcLOPfJXjyPSqZ2mcq60et4sceLJOclM23jNEasHMGyY8soMNX53EFFqZZam6gppRxS3u+EEMlCiBApZaIQIgQoa5JlAjCgxPMwYJPt2gm2nzlCiO+BnsAiB1VdUWqP1gVufAp2fmFdDeJZex9k9c0dQX60PZHIb83M7NkYzw23RtV5HQyFJvZviOevdecwFplpfUMwPe9ohk/jukn3EODlyjcTLi8p/XzjKX5MTGbiskzu/N0H/yGRjOs4jvva3Mf6c+v59tC3zNwxk8/2fcaqu1bhrfeuk3oqSnU5a0fNX4AJwCzbz5VllPkNeFsI0cj2/BbgZSGEDvCTUqYJIVyAO4D1dVBnRXGMbhOhx8Ogub4yVgoheLVtGGMPxDH/QCKd+obi5lk3q2BMRjOH/khgz5qzFOYaad4lkJ53NiOgqVed3L88N3UMYduFLN6Nv8j3mUYmLcnh1g3e+A2J4tYOt3Jr5K3sSd7DXyl/XQoolh1bRs/gnkT5Rjm17opSFmfNqZgF3CyEOAEMsT1HCNFdCPE1gJQyA5gJxNr+zbAdcwV+E0IcAPZh7dG4vtJAKtc2nd4aUBjyIff6Wgk9wN+bu3x86NOzKa51mLnzzIF0ti4/SWC4F/e81J3bHu/g9IACoHeLAH568ka+Ht8dj0AP3qCA8ZkZ/PLDQZLm7KHgUBrdgrrxaMdHAcgqyuKD3R/wy6lfAOs+INfTBoZK/ad21FQUZ7CY4ZOuENYD7v7a2bVpkE7sTsZYZCamT1OkRZIUl0VISz9nV6tcFotk1cFEZq89xpn0fNrpXHjU5EL/nmE0GhV9qVx6QTo6jQ5fV182xW9i/oH5TGg3gcERg9FpaidQayhLStPS0rQPPPBA5LFjx9yFEMyfP//MkCFD8t56662gr7/+OlCr1TJkyJCsefPmnXd2XR1l5syZQYsWLQqUUjJ+/PjUV199NWX79u3uTzzxRGR+fr4mLCzMsHz58jh/f3/LsWPH9J06dWofFRVVCNC1a9fc77///lzpa1a0pFQlFFMUZ9Bood8L4N/c2TVxijyzmbc3neLGVAu339emVu5xfGcSRQUm2t4YgtCIeh1QAGg0guGdmjKsfTA/7j3P3PUnmJaVz8pmXjQCTFlFGM/n4h9zeXtwKSVZRVk898dzhHqF8mDMg9zV8i48XK7treCXHlvqP2//vND0gnR9gHuAYXKnyQljWo+p8UZQjz32WPgtt9ySvWbNmrjCwkKRm5ur+fXXX71Xr17td/jw4cPu7u6yeAfKurZv3X/9dyz/ITTvYqbe06+Rodc9YxM63zysVlKfP/roo1Hvvvtu/O233547Z86cgDfeeCN47ty5FwDCw8OLjh49Wu1kNSqoUBRn6TLO2TVwmrMFBhaIfCwWwW1mi0OWb144kcmuX08z4IE2+AV5MHhiDHp33TWxg2dJOq2GMT0iGNkllI1HU+nU3prf6tsf/6bFyRxuerEXOl9XAAZGDKRfWD82xW/i27+/ZdauWXy+73PGtB7D2DZj2ZW0i7l755KUl0SwZzBTu07l9ua3O7F1lVt6bKn/e7HvRRrMBg1AWkGa/r3Y9yIBahJYpKena3fu3Om9fPnyMwBubm7Szc3N/MUXXwS+8MILicWZSUNDQ6u0g6Qj7Fv3X/9NC7+KNBuNGoC8i5n6TQu/igSoSWBRMvU5cCn1+dmzZ11vu+22XIA77rgj+9Zbb21VHFTUlAoqFMWZsi/An7Oh/wvgdf1s1xzj5c7mnm2I9qp5KvjUczns+PkU5w5n4OGrJyejEL8gjzqbBFpbXHVahtoCinyDiS8S0rmlbQADbQHFxVVxuLb0w611IwZHDmZw5GD2pexj4d8L+frg13xz8BuEEJildfluYl4ir297HcDpgcXYVWPLTQN+NPOop8liuiISNJgNmjl75oSPaT0mIzU/Vff0709fkQb8hzt+qDQN+LFjx/T+/v6m0aNHRx0+fNijY8eOeV999VV8XFyc2x9//OH96quvhrq6usoPPvggvn///vmVXa+qFv+/6eW2OeXMaU+L+co2m41GzZ/ffxve+eZhGbmZGbqV78+8os3j3v6o2qnPW7ZsWbh48WK/Bx988OJ3333nn5SUdCmZ2fnz5/Vt27aN8fLyMs+cOTOhOLmYvVRQoSjOZMiD2K/BzQcGv+rs2tSp4oDiXGIO7kYIjKjacsnMpDx2/hLHqb2puHrquHFUSzoMCEWnb3irajz0On5/bsCl3Uh3HU1h0a7TTNyiIyLcF5+bI3GN9qNzUGc6B3XmXPY5Rv86mnzTlZ+NheZC5u6d6/SgoiKlA4piucbcGn1emUwmceTIEY+5c+eeGzRoUN5DDz0U/sorrwSbzWaRkZGh3bdv39E//vjD4/77728RHx9/UKOpu3UMpQOKYob8fIelPnd3d7e0a9cuX6vVsmDBgjNTpkwJnzVrVsjQoUMvuri4SICIiAjj6dOnDwQHB5v//PNPj9GjR7c8fPjwIX9/f7u3AFZBhaI4U+NoiBkOu7627rbp5uPsGtWpFUkZTPv7LC/tM/LEMz0QmsqHKrLTC4hdfYZj2xPR6bV0vz2KzkMi6nQ1iTP4ul/ueTmRVcBai4HfNEWMTDbzwIIsQiJswUVLPyJ8IsrdMCspL6muqlyuinoWBi4b2CGtIO2qNOCN3RsbAAI9Ak329EyUFhUVZWjSpIlh0KBBeQBjxozJnDVrVnBwcLDhnnvuuajRaBg4cGC+RqORSUlJuqZNmzp0GKSinoV5jz/YIe9i5lVt9vRrZADwauRvsqdnoizTp09Pmz59ehpYU5+HhYUZunTpUrh169YTAAcOHHBdu3atH4C7u7t0d3c3A9x00035ERERRYcOHXLr16+f3T03KvW5ojhbn2lQlAW7Fzi7JnWudyMv0Ap+9pccj02utPzxXUksfm0HJ3Yl03FQOA++2Zsb7mze4AOK0sbdEMkfzw/gnu7hrDAVcp82n0+SM4j75iCpXx6g8ORFgj2CGZDVnW9PzGT1kc/49sRMBmR1J9gz2NnVr9DkTpMT9Fr9Fd+M9Vq9ZXKnyTVKAx4REWEKDg427N+/3xVg7dq1Pq1bty688847L27YsMEbrB+wRqNRExwcXKfzKnrdMzZB6+JyZepzFxdLr3vGOjz1+SOPPJJRfMxsNvPaa6+FPPzwwylgTQ9vMlmbfvjwYf2ZM2dcW7duXVSV+11f/ycqSn0U2hWaD4Adn8MNk8Gl5vMMrhUhrnoeDgtknkzh5/VxPNs1EJ3LlcMXRflGDIVmvP3dCG7uS5teIXQfFoW3//XzOpUlxNedd0Z14PF+zZmz/jjf7b/ATzoNYxPNjP46i0/9X0aTacFNWr8ANzEFMDXxAZJb1/k8xCopnoxZG6s/Pvnkk3Pjxo1rbjAYRERERNEPP/xwxtvb2zJmzJio6Ojodi4uLpb58+efrsuhD7g8GdPRqz+g7NTnM2fODPrmm2+CAIYNG5b59NNPpwOsXbvW68033wzV6XRSo9HIOXPmnG3SpEmV9tRX+1QoSn0QtwkWjYA75kD3h5xdmzqVYTTRY+vfhMUX8eDeQooKTHj5u9J7RAuiezRh8Ws78A3y4M6nOjm7qvXasaQcPlx7jLWHk2mk1/I2HiQajHxJESlIghA8jiu3+XkT8lLPKl27oexToTiG2qdCUeq7Zv2haRfYOhe6jr+utvD2d9ExRufJgjBJ3JECQgsgN6OIjYuPAnDjqJZ4B1zfvRL2aB3szfzx3dkXf5F5m04R93cmH1FEcb9EMpK3KYSLMMmZFVUaNDWnQlHqAyGg73TIPA2Hy0qF07BF/ZaMi8HCwoE+zLy3ER/f4ctfwTq2rzxF8y6BVV4Z0pBJKTFLicFiocBsIddkJstoIt1gItVgpEWIN/Me7MZ8nZHSAx0mYK7O4IxqK9cJ1VOhKPVFmzshINraW9F+lLNrU6f2ukvMWoFFa139keWpZXUPT8x78rjDYCLAljo8zWAi12zGLCUmCRbbB2zxY5NtOLennzWvx6GcfLJMZvo0sgYlWzJzSDGYMNnOs0guPTZLMEuJt07LuKYBACxJTMcC3B9iff7J2WRSDEZMtrLF55mkxIL1WAsPV15oFgLAM0fP0czdlacimwBw776T5JotV9zPZKuHGevjWwJ8ebtVGADdtv3N6GB/XmoeQq7JTOstBzFXMmL9eHggb7QMJctU9irA8o7XMovFYhEajeb6GW9voCwWiwDK/Y9IBRWKUl9oNDD8Y/AMdHZN6tymzh6XAopiRp1gbTdP1m8/zOn+HQF49WQCK5IzK7yWu0ZzqfwX8ansyc5jR68YAD46k8zWixXv5RPlrr8UVPwnKROzlJeCil9TLnKmsAgtAq0QaAXohEBT4rFLiR08c0wW8syX//66azVoSpxb8qf1OtDK8/JQz4igRnTwtqZl12sEUyKaoMF6n8vnC3QCNLZrtPOylpduWkTh1XPspJtThtYOpaamxgQGBmapwOLaZbFYRGpqqi9wqLwyaqKmoihOF7JxH+X9JZrVKoyJoY0B2H4xl/hCg/UDGC59oBZ/uBZ/sPe19Uyczi8i32K59EEbX2igyGK5dL7u0nmXz9UKgYdt23Ap5TW3zXex9st2krMvHWG5/MpKjcC7cwCH7r2hSteq6UTNPXv2BOl0uq+B9qhh92uZBThkMpke6datW5kpllVPhaLUN9kX4H8vQp+pEFbtv+PXlFBXF84XGa86HubqcimgAOjt50XvKly3mYfrFc/D3a7aX6hC12pAAfBGv2ieNZmxHM9GFJqRblo0rXx4o1905Sc7mO0DaHid31ipcyqoUJT6xtUbzm6DM1uhIAN8w6xbeHe819k1qzUvNw/huWPxFJT4Vu2uEbzcPMSJtbq23R3sD4Pa8E5UIglFRkJdXXi5eYj1uKLUEhVUKEp9c+x/YMwDo22b5ax4+PVp62NHBhYHlsGGGZB13r7Aparlq6D4g+6dOPUB6Eh3B/ur11CpU2pOhaLUNx+1twYSpfmGw/Ry5kdVJ0D49enLgQuAizvc+XHZ51W1vNKg1HROhXL9UD0VilLfZJ0v53g8zB8A/i0goMXlnylH4H/Pl92z0W4U5KdDXirkp0FemvXxxreuDBDA+nzlPy4HCauegb9XgMlg7TkpzVgA/3sBOoy27rOhKMp1TwUVilLf+IaV3VOh9wI3Pzi/y/phL21LFT0Dyw4QVj8LKx6t2r3NJTZGCu0KQgM6V9j+adnlCzIvBxS/TrM+vuMj6/P0U+DT1NqjoSjKdcEpQYUQwh9YCkQBZ4B7pZRXLT4XQqwBegFbpJR3lDjeDFgCBAB7gAellGqbOKVhGPxq2UMNd3x0uRfBVASZZ6wf3EvuL/s6RTnQ/yXwbGwNPC79DIQvbyq7R8Q3/PLjLg9Y/4F1l8+yAh2fppcfu5ba9fJfwyAvBfybQ1BbCIq5/M+/OWhL/fmpxTkb1y31mip1zClzKoQQ7wEZUspZQoiXgEZSyhfLKDcY8AAeLxVULANWSCmXCCHmAfullF9Udl81p0K5ZlTlw6C6czBqc06FlHD4Z+vQTMphSD4MGXFQvBuF1hUCW0HnB6DXZOv1f3kKTIX2XV+pnAPnwag5FYq9nBVUHAMGSCkThRAhwCYpZetyyg4AnisOKoR14XgqECylNAkhegOvSylvrey+KqhQGqTqfnjU9eoPQz6kHbcGGSmHrQFHyyHQ6wmYHQPZCVefo9FBQMvyrzngJWh3lzVoWf4QDPsAmt0EpzfDf5+vvE6ly4/+1tqrcmgF/PFu5eeXLj9xtbVHaOd82P1N5eeXLv+PndbjG9+2LwdMyfJntsJDq63PVz0DexeCpYw05xUFm+VQQYViL2fNqWgipUy0PU4CmlTh3ADgopSy+P+W80BoeYWFEI8BjwFERERUo6qKUs8Vf7BX9QO/471VCwqqWr40vQc07Wz9V1r2hbLPsZggsMzvG1ZuvtafLm7Wcq5etnt5VXxesdLldbbNstz97Du/dPni7LKeAfadX15572D7zi9ZPqDF5ee+oWUHFFD+RGBFcYBa66kQQqwHgsv41T+BhVJKvxJlM6WUjcq5zgCu7KloDOyQUra0PQ8H/ielbF9ZnVRPhaLUU9UZwlEq5sDXVPVUKPaqtT3YpZRDpJTty/i3Eki2DXtg+1nmHuLlSAf8hBDFvSxhQBn9poqiXDMGv3r1KhEXd+txpXrUa6o4gbMSu/wCTLA9ngDYMXhoJa1dKxuBe6pzvqIo9VDHe61zQHzDAWH9qSZp1ox6TRUncNZEzQBgGRABnMW6pDRDCNEdmCylfMRW7k+gDeCFtYfiYSnlb0KI5liXlPoDfwEPSCmLKruvGv5QFEWpOjX8odjLKRM1pZTpwOAyju8GHinx/KZyzo8DetZaBRVFURRFqTKV115RFEVRFIdQQYWiKIqiKA6hggpFURRFURxCBRWKoiiKojiEU1Z/OIsQIhXrapPqaAykObA61wLV5uvD9dbm6629UPM2R0opAx1VGaXhuq6CipoQQuy+3pZUqTZfH663Nl9v7YXrs82Kc6jhD0VRFEVRHEIFFYqiKIqiOIQKKuw339kVcALV5uvD9dbm6629cH22WXECNadCURRFURSHUD0ViqIoiqI4hAoqFEVRFEVxCBVUVEIIMVQIcUwIcVII8ZKz61MXhBBnhBAHhRD7hBANMq2rEGKBECJFCHGoxDF/IcQ6IcQJ289Gzqyjo5XT5teFEAm293qfEGKYM+voaEKIcCHERiHEYSHE30KIqbbjDfa9rqDNDfq9VuoHNaeiAkIILXAcuBk4D8QCY6WUh51asVomhDgDdJdSNtgNgoQQ/YBcYJGUsr3t2HtAhpRyli2AbCSlfNGZ9XSkctr8OpArpfzAmXWrLUKIECBESrlXCOEN7AFGAhNpoO91BW2+lwb8Xiv1g+qpqFhP4KSUMk5KaQCWACOcXCfFAaSUm4GMUodHAAttjxdi/UPcYJTT5gZNSpkopdxre5wDHAFCacDvdQVtVpRap4KKioUC8SWen+f6+J9TAmuFEHuEEI85uzJ1qImUMtH2OAlo4szK1KEpQogDtuGRBjMMUJoQIgroAuzkOnmvS7UZrpP3WnEeFVQoZekrpewK3Ab8w9Ztfl2R1nHB62Fs8AugBdAZSAQ+dGptaokQwgv4EZgmpcwu+buG+l6X0ebr4r1WnEsFFRVLAMJLPA+zHWvQpJQJtp8pwE9Yh4GuB8m28ejicekUJ9en1kkpk6WUZimlBfiKBvheCyFcsH64LpZSrrAdbtDvdVltvh7ea8X5VFBRsVggWgjRTAihB+4DfnFynWqVEMLTNrkLIYQncAtwqOKzGoxfgAm2xxOAlU6sS50o/mC1uYsG9l4LIQTwDXBESjm7xK8a7HtdXpsb+nut1A9q9UclbMuu5gBaYIGU8i3n1qh2CSGaY+2dANAB3zfENgshfgAGYE0JnQy8BvwMLAMigLPAvVLKBjOxsZw2D8DaHS6BM8DjJeYaXPOEEH2BP4GDgMV2+P9hnWPQIN/rCto8lgb8Xiv1gwoqFEVRFEVxCDX8oSiKoiiKQ6igQlEURVEUh1BBhaIoiqIoDqGCCkVRFEVRHEIFFYqiKIqiOIQKKhSlBCHEP22ZHQ/YMjne4MS6TBNCeJTzuzuEEH8JIfbbslE+bjs+WQgxvm5rqiiKYqWWlCqKjRCiNzAbGCClLBJCNAb0UsoLTqiLFjhFGdlibbslngV6SinPCyFcgSgp5bG6rqeiKEpJqqdCUS4LAdKklEUAUsq04oBCCHHGFmQghOguhNhke/y6EOLfQojtQogTQohHbccHCCE2CyFWCyGOCSHmCSE0tt+NFUIcFEIcEkK8W3xzIUSuEOJDIcR+4J9AU2CjEGJjqXp6Y92YLN1Wz6LigMJWn+eEEE1tPS3F/8xCiEghRKAQ4kchRKztX5/aejEVRbn+qKBCUS5bC4QLIY4LIT4XQvS387yOwCCgN/CqEKKp7XhP4CkgBmsip1G2371rK98Z6CGEGGkr7wnslFJ2klLOAC4AA6WUA0vezLbz4y/AWSHED0KIccUBS4kyF6SUnaWUnbHmefhRSnkWmAt8JKXsAdwNfG1nGxVFUSqlggpFsZFS5gLdgMeAVGCpEGKiHaeulFIW2IYpNnI5UdMuKWWclNIM/AD0BXoAm6SUqVJKE7AYKM4Ca8aaBMqeuj4CDAZ2Ac8BC8oqZ+uJeBSYZDs0BPhUCLEPa2DiY8tmqSiKUmM6Z1dAUeoTWwCwCdgkhDiINdnUt4CJy0G4W+nTynle3vHyFNrub29dDwIHhRD/Bk4DE0v+3pZA6htguC1gAmsbekkpC+29j6Ioir1UT4Wi2AghWgshoksc6ox1QiRYEzB1sz2+u9SpI4QQbkKIAKwJumJtx3vaMtxqgDHAFqw9C/2FEI1tkzHHAn+UU6UcrPMnStfTSwgxoJx6FpdxAf4DvCilPF7iV2uxDskUl+tczr0VRVGqTAUVinKZF7DQtkTzANa5EK/bfvcGMFcIsRvrMEVJB7AOe+wAZpZYLRILfAocwdqT8JMtK+RLtvL7gT1SyvLSbs8H1pQxUVMAL9gmgO6z1W1iqTI3At2BN0pM1mwKPA10ty2ZPQxMruxFURRFsZdaUqooNSCEeB3IlVJ+UOr4AOA5KeUdTqiWoiiKU6ieCkVRFEVRHEL1VCiKoiiK4hCqp0JRFEVRFIdQQYWiKIqiKA6hggpFURRFURxCBRWKoiiKojiECioURVEURXGI/w8iD650JcyH/AAAAABJRU5ErkJggg==\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fit_model_bounds.plot(show_lines=True)\n", + "\n", + "print(f\"maximum value of coefficients = {np.max(fit_model_bounds.coeffs[0])} <= {max_value}\")\n", + "print(f\"maximum value of first coefficient = {np.max(fit_model_bounds.coeffs[0][0, :])} <= 0.1\")\n", + "print(f\"minimum value of coefficient = {np.min(fit_model_bounds.coeffs[0])} >= -0.1\")\n" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "### User-specified Lambda Grids\n", + "By default, `l0learn` selects the sequence of lambda values in an efficient manner to avoid wasted computation (since close $\\lambda$ values can typically lead to the same solution). Advanced users of the toolkit can change this default behavior and supply their own sequence of $\\lambda$ values. This can be done supplying the $\\lambda$ values through the parameter `lambda_grid`. When `lambda_grid` is supplied, we require `num_gamma` and `num_lambda` to be `None` to ensure the is no ambiguity in the solution path requested.\n", + "\n", + "Specifically, the value assigned to `lambda_grid` should be a list of lists/arrays of decreasing positive values (floats). The length of `lambda_grid` (the number of lists stored) specifies the number of gamma parameters that will fill between `gamma_min`, and `gamma_max`. In the case of L0 penalty, `lambda_grid` must be a list of length 1. In case of L0L2/L0L1 `lambda_grid` can have any number of sub-lists stored. The ith element in `lambda_grid` should be a **strictly decreasing** sequence of positive lambda values which are used by the algorithm for the ith value of gamma. For example, to fit an L0 model with the sequence of user-specified lambda values: 1, 1e-1, 1e-2, 1e-3, 1e-4, we run the following:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 113, + "outputs": [], + "source": [ + "user_lambda_grid = [[1, 1e-1, 1e-2, 1e-3, 1e-4]]\n", + "fit_grid = l0learn.fit(X, y, penalty=\"L0\", lambda_grid=user_lambda_grid, max_support_size=1000, num_lambda=None, num_gamma=None)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "To verify the results we print the fit object:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 114, + "outputs": [ + { + "data": { + "text/plain": "FitModel({'loss': 'SquaredError', 'intercept': True, 'penalty': 'L0'})", + "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
l0support_sizeinterceptconverged
01.00000-0.016000True
10.10000-0.016000True
20.0100100.016811True
30.0010620.018729True
40.00012670.051675True
\n
" + }, + "execution_count": 114, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fit_grid\n", + "# Use fit_grid.characteristics() for those without rich dispalys" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "Note that the $\\lambda$ values above are the desired values. For L0L2 and L0L1 penalties, the same can be done where the `lambda_grid` parameter." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 115, + "outputs": [], + "source": [ + "user_lambda_grid_L2 = [[1, 1e-1, 1e-2, 1e-3, 1e-4],\n", + " [10, 2, 1, 0.01, 0.002, 0.001, 1e-5],\n", + " [1e-4, 1e-5]]\n", + "\n", + "# user_lambda_grid_L2[[i]] must be a sequence of positive decreasing reals.\n", + "fit_grid_L2 = l0learn.fit(X, y, penalty=\"L0L2\", lambda_grid=user_lambda_grid_L2, max_support_size=1000, num_lambda=None, num_gamma=None)" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "code", + "execution_count": 116, + "outputs": [ + { + "data": { + "text/plain": "FitModel({'loss': 'SquaredError', 'intercept': True, 'penalty': 'L0L2'})", + "text/html": "
\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
l0support_sizeinterceptconvergedl2
01.000000-0.016000True10.000000
10.100000-0.016000True10.000000
20.010000-0.016000True10.000000
30.001009-0.014394True10.000000
40.00010134-0.012180True10.000000
510.000000-0.016000True0.031623
62.000000-0.016000True0.031623
71.000000-0.016000True0.031623
80.01000100.015045True0.031623
90.00200280.001483True0.031623
100.00100580.002821True0.031623
110.000015820.021913True0.031623
120.000103110.048700True0.000100
130.000014110.047991False0.000100
\n
" + }, + "execution_count": 116, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fit_grid_L2\n", + "# Use fit_grid_L2.characteristics() for those without rich dispalys" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, + { + "cell_type": "markdown", + "source": [ + "# More Details\n", + "For more details please inspect the doc strings of:\n", + "\n", + "* [l0learn.models.CVFitModel](code.rst#l0learn.models.CVFitModel)\n", + "* [l0learn.models.FitModel](code.rst#l0learn.models.FitModel)\n", + "* [l0learn.fit](code.rst#l0learn.fit)\n", + "* [l0learn.cvfit](code.rst#l0learn.cvfit)" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "# References\n", + "Hussein Hazimeh and Rahul Mazumder. [Fast Best Subset Selection: Coordinate Descent and Local Combinatorial Optimization Algorithms](https://pubsonline.informs.org/doi/10.1287/opre.2019.1919). Operations Research (2020).\n", + "\n", + "Antoine Dedieu, Hussein Hazimeh, and Rahul Mazumder. [Learning Sparse Classifiers: Continuous and Mixed Integer Optimization Perspectives](https://arxiv.org/abs/2001.06471). JMLR (to appear)." + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + } + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/python/_github_pages_docs/html/_static/alabaster.css b/python/_github_pages_docs/html/_static/alabaster.css new file mode 100644 index 0000000..0eddaeb --- /dev/null +++ b/python/_github_pages_docs/html/_static/alabaster.css @@ -0,0 +1,701 @@ +@import url("basic.css"); + +/* -- page layout ----------------------------------------------------------- */ + +body { + font-family: Georgia, serif; + font-size: 17px; + background-color: #fff; + color: #000; + margin: 0; + padding: 0; +} + + +div.document { + width: 940px; + margin: 30px auto 0 auto; +} + +div.documentwrapper { + float: left; + width: 100%; +} + +div.bodywrapper { + margin: 0 0 0 220px; +} + +div.sphinxsidebar { + width: 220px; + font-size: 14px; + line-height: 1.5; +} + +hr { + border: 1px solid #B1B4B6; +} + +div.body { + background-color: #fff; + color: #3E4349; + padding: 0 30px 0 30px; +} + +div.body > .section { + text-align: left; +} + +div.footer { + width: 940px; + margin: 20px auto 30px auto; + font-size: 14px; + color: #888; + text-align: right; +} + +div.footer a { + color: #888; +} + +p.caption { + font-family: inherit; + font-size: inherit; +} + + +div.relations { + display: none; +} + + +div.sphinxsidebar a { + color: #444; + text-decoration: none; + border-bottom: 1px dotted #999; +} + +div.sphinxsidebar a:hover { + border-bottom: 1px solid #999; +} + +div.sphinxsidebarwrapper { + padding: 18px 10px; +} + +div.sphinxsidebarwrapper p.logo { + padding: 0; + margin: -10px 0 0 0px; + text-align: center; +} + +div.sphinxsidebarwrapper h1.logo { + margin-top: -10px; + text-align: center; + margin-bottom: 5px; + text-align: left; +} + +div.sphinxsidebarwrapper h1.logo-name { + margin-top: 0px; +} + +div.sphinxsidebarwrapper p.blurb { + margin-top: 0; + font-style: normal; +} + +div.sphinxsidebar h3, +div.sphinxsidebar h4 { + font-family: Georgia, serif; + color: #444; + font-size: 24px; + font-weight: normal; + margin: 0 0 5px 0; + padding: 0; +} + +div.sphinxsidebar h4 { + font-size: 20px; +} + +div.sphinxsidebar h3 a { + color: #444; +} + +div.sphinxsidebar p.logo a, +div.sphinxsidebar h3 a, +div.sphinxsidebar p.logo a:hover, +div.sphinxsidebar h3 a:hover { + border: none; +} + +div.sphinxsidebar p { + color: #555; + margin: 10px 0; +} + +div.sphinxsidebar ul { + margin: 10px 0; + padding: 0; + color: #000; +} + +div.sphinxsidebar ul li.toctree-l1 > a { + font-size: 120%; +} + +div.sphinxsidebar ul li.toctree-l2 > a { + font-size: 110%; +} + +div.sphinxsidebar input { + border: 1px solid #CCC; + font-family: Georgia, serif; + font-size: 1em; +} + +div.sphinxsidebar hr { + border: none; + height: 1px; + color: #AAA; + background: #AAA; + + text-align: left; + margin-left: 0; + width: 50%; +} + +div.sphinxsidebar .badge { + border-bottom: none; +} + +div.sphinxsidebar .badge:hover { + border-bottom: none; +} + +/* To address an issue with donation coming after search */ +div.sphinxsidebar h3.donation { + margin-top: 10px; +} + +/* -- body styles ----------------------------------------------------------- */ + +a { + color: #004B6B; + text-decoration: underline; +} + +a:hover { + color: #6D4100; + text-decoration: underline; +} + +div.body h1, +div.body h2, +div.body h3, +div.body h4, +div.body h5, +div.body h6 { + font-family: Georgia, serif; + font-weight: normal; + margin: 30px 0px 10px 0px; + padding: 0; +} + +div.body h1 { margin-top: 0; padding-top: 0; font-size: 240%; } +div.body h2 { font-size: 180%; } +div.body h3 { font-size: 150%; } +div.body h4 { font-size: 130%; } +div.body h5 { font-size: 100%; } +div.body h6 { font-size: 100%; } + +a.headerlink { + color: #DDD; + padding: 0 4px; + text-decoration: none; +} + +a.headerlink:hover { + color: #444; + background: #EAEAEA; +} + +div.body p, div.body dd, div.body li { + line-height: 1.4em; +} + +div.admonition { + margin: 20px 0px; + padding: 10px 30px; + background-color: #EEE; + border: 1px solid #CCC; +} + +div.admonition tt.xref, div.admonition code.xref, div.admonition a tt { + background-color: #FBFBFB; + border-bottom: 1px solid #fafafa; +} + +div.admonition p.admonition-title { + font-family: Georgia, serif; + font-weight: normal; + font-size: 24px; + margin: 0 0 10px 0; + padding: 0; + line-height: 1; +} + +div.admonition p.last { + margin-bottom: 0; +} + +div.highlight { + background-color: #fff; +} + +dt:target, .highlight { + background: #FAF3E8; +} + +div.warning { + background-color: #FCC; + border: 1px solid #FAA; +} + +div.danger { + background-color: #FCC; + border: 1px solid #FAA; + -moz-box-shadow: 2px 2px 4px #D52C2C; + -webkit-box-shadow: 2px 2px 4px #D52C2C; + box-shadow: 2px 2px 4px #D52C2C; +} + +div.error { + background-color: #FCC; + border: 1px solid #FAA; + -moz-box-shadow: 2px 2px 4px #D52C2C; + -webkit-box-shadow: 2px 2px 4px #D52C2C; + box-shadow: 2px 2px 4px #D52C2C; +} + +div.caution { + background-color: #FCC; + border: 1px solid #FAA; +} + +div.attention { + background-color: #FCC; + border: 1px solid #FAA; +} + +div.important { + background-color: #EEE; + border: 1px solid #CCC; +} + +div.note { + background-color: #EEE; + border: 1px solid #CCC; +} + +div.tip { + background-color: #EEE; + border: 1px solid #CCC; +} + +div.hint { + background-color: #EEE; + border: 1px solid #CCC; +} + +div.seealso { + background-color: #EEE; + border: 1px solid #CCC; +} + +div.topic { + background-color: #EEE; +} + +p.admonition-title { + display: inline; +} + +p.admonition-title:after { + content: ":"; +} + +pre, tt, code { + font-family: 'Consolas', 'Menlo', 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', monospace; + font-size: 0.9em; +} + +.hll { + background-color: #FFC; + margin: 0 -12px; + padding: 0 12px; + display: block; +} + +img.screenshot { +} + +tt.descname, tt.descclassname, code.descname, code.descclassname { + font-size: 0.95em; +} + +tt.descname, code.descname { + padding-right: 0.08em; +} + +img.screenshot { + -moz-box-shadow: 2px 2px 4px #EEE; + -webkit-box-shadow: 2px 2px 4px #EEE; + box-shadow: 2px 2px 4px #EEE; +} + +table.docutils { + border: 1px solid #888; + -moz-box-shadow: 2px 2px 4px #EEE; + -webkit-box-shadow: 2px 2px 4px #EEE; + box-shadow: 2px 2px 4px #EEE; +} + +table.docutils td, table.docutils th { + border: 1px solid #888; + padding: 0.25em 0.7em; +} + +table.field-list, table.footnote { + border: none; + -moz-box-shadow: none; + -webkit-box-shadow: none; + box-shadow: none; +} + +table.footnote { + margin: 15px 0; + width: 100%; + border: 1px solid #EEE; + background: #FDFDFD; + font-size: 0.9em; +} + +table.footnote + table.footnote { + margin-top: -15px; + border-top: none; +} + +table.field-list th { + padding: 0 0.8em 0 0; +} + +table.field-list td { + padding: 0; +} + +table.field-list p { + margin-bottom: 0.8em; +} + +/* Cloned from + * https://github.com/sphinx-doc/sphinx/commit/ef60dbfce09286b20b7385333d63a60321784e68 + */ +.field-name { + -moz-hyphens: manual; + -ms-hyphens: manual; + -webkit-hyphens: manual; + hyphens: manual; +} + +table.footnote td.label { + width: .1px; + padding: 0.3em 0 0.3em 0.5em; +} + +table.footnote td { + padding: 0.3em 0.5em; +} + +dl { + margin: 0; + padding: 0; +} + +dl dd { + margin-left: 30px; +} + +blockquote { + margin: 0 0 0 30px; + padding: 0; +} + +ul, ol { + /* Matches the 30px from the narrow-screen "li > ul" selector below */ + margin: 10px 0 10px 30px; + padding: 0; +} + +pre { + background: #EEE; + padding: 7px 30px; + margin: 15px 0px; + line-height: 1.3em; +} + +div.viewcode-block:target { + background: #ffd; +} + +dl pre, blockquote pre, li pre { + margin-left: 0; + padding-left: 30px; +} + +tt, code { + background-color: #ecf0f3; + color: #222; + /* padding: 1px 2px; */ +} + +tt.xref, code.xref, a tt { + background-color: #FBFBFB; + border-bottom: 1px solid #fff; +} + +a.reference { + text-decoration: none; + border-bottom: 1px dotted #004B6B; +} + +/* Don't put an underline on images */ +a.image-reference, a.image-reference:hover { + border-bottom: none; +} + +a.reference:hover { + border-bottom: 1px solid #6D4100; +} + +a.footnote-reference { + text-decoration: none; + font-size: 0.7em; + vertical-align: top; + border-bottom: 1px dotted #004B6B; +} + +a.footnote-reference:hover { + border-bottom: 1px solid #6D4100; +} + +a:hover tt, a:hover code { + background: #EEE; +} + + +@media screen and (max-width: 870px) { + + div.sphinxsidebar { + display: none; + } + + div.document { + width: 100%; + + } + + div.documentwrapper { + margin-left: 0; + margin-top: 0; + margin-right: 0; + margin-bottom: 0; + } + + div.bodywrapper { + margin-top: 0; + margin-right: 0; + margin-bottom: 0; + margin-left: 0; + } + + ul { + margin-left: 0; + } + + li > ul { + /* Matches the 30px from the "ul, ol" selector above */ + margin-left: 30px; + } + + .document { + width: auto; + } + + .footer { + width: auto; + } + + .bodywrapper { + margin: 0; + } + + .footer { + width: auto; + } + + .github { + display: none; + } + + + +} + + + +@media screen and (max-width: 875px) { + + body { + margin: 0; + padding: 20px 30px; + } + + div.documentwrapper { + float: none; + background: #fff; + } + + div.sphinxsidebar { + display: block; + float: none; + width: 102.5%; + margin: 50px -30px -20px -30px; + padding: 10px 20px; + background: #333; + color: #FFF; + } + + div.sphinxsidebar h3, div.sphinxsidebar h4, div.sphinxsidebar p, + div.sphinxsidebar h3 a { + color: #fff; + } + + div.sphinxsidebar a { + color: #AAA; + } + + div.sphinxsidebar p.logo { + display: none; + } + + div.document { + width: 100%; + margin: 0; + } + + div.footer { + display: none; + } + + div.bodywrapper { + margin: 0; + } + + div.body { + min-height: 0; + padding: 0; + } + + .rtd_doc_footer { + display: none; + } + + .document { + width: auto; + } + + .footer { + width: auto; + } + + .footer { + width: auto; + } + + .github { + display: none; + } +} + + +/* misc. */ + +.revsys-inline { + display: none!important; +} + +/* Make nested-list/multi-paragraph items look better in Releases changelog + * pages. Without this, docutils' magical list fuckery causes inconsistent + * formatting between different release sub-lists. + */ +div#changelog > div.section > ul > li > p:only-child { + margin-bottom: 0; +} + +/* Hide fugly table cell borders in ..bibliography:: directive output */ +table.docutils.citation, table.docutils.citation td, table.docutils.citation th { + border: none; + /* Below needed in some edge cases; if not applied, bottom shadows appear */ + -moz-box-shadow: none; + -webkit-box-shadow: none; + box-shadow: none; +} + + +/* relbar */ + +.related { + line-height: 30px; + width: 100%; + font-size: 0.9rem; +} + +.related.top { + border-bottom: 1px solid #EEE; + margin-bottom: 20px; +} + +.related.bottom { + border-top: 1px solid #EEE; +} + +.related ul { + padding: 0; + margin: 0; + list-style: none; +} + +.related li { + display: inline; +} + +nav#rellinks { + float: right; +} + +nav#rellinks li+li:before { + content: "|"; +} + +nav#breadcrumbs li+li:before { + content: "\00BB"; +} + +/* Hide certain items when printing */ +@media print { + div.related { + display: none; + } +} \ No newline at end of file diff --git a/python/_github_pages_docs/html/_static/basic.css b/python/_github_pages_docs/html/_static/basic.css new file mode 100644 index 0000000..603f6a8 --- /dev/null +++ b/python/_github_pages_docs/html/_static/basic.css @@ -0,0 +1,905 @@ +/* + * basic.css + * ~~~~~~~~~ + * + * Sphinx stylesheet -- basic theme. + * + * :copyright: Copyright 2007-2021 by the Sphinx team, see AUTHORS. + * :license: BSD, see LICENSE for details. + * + */ + +/* -- main layout ----------------------------------------------------------- */ + +div.clearer { + clear: both; +} + +div.section::after { + display: block; + content: ''; + clear: left; +} + +/* -- relbar ---------------------------------------------------------------- */ + +div.related { + width: 100%; + font-size: 90%; +} + +div.related h3 { + display: none; +} + +div.related ul { + margin: 0; + padding: 0 0 0 10px; + list-style: none; +} + +div.related li { + display: inline; +} + +div.related li.right { + float: right; + margin-right: 5px; +} + +/* -- sidebar --------------------------------------------------------------- */ + +div.sphinxsidebarwrapper { + padding: 10px 5px 0 10px; +} + +div.sphinxsidebar { + float: left; + width: 230px; + margin-left: -100%; + font-size: 90%; + word-wrap: break-word; + overflow-wrap : break-word; +} + +div.sphinxsidebar ul { + list-style: none; +} + +div.sphinxsidebar ul ul, +div.sphinxsidebar ul.want-points { + margin-left: 20px; + list-style: square; +} + +div.sphinxsidebar ul ul { + margin-top: 0; + margin-bottom: 0; +} + +div.sphinxsidebar form { + margin-top: 10px; +} + +div.sphinxsidebar input { + border: 1px solid #98dbcc; + font-family: sans-serif; + font-size: 1em; +} + +div.sphinxsidebar #searchbox form.search { + overflow: hidden; +} + +div.sphinxsidebar #searchbox input[type="text"] { + float: left; + width: 80%; + padding: 0.25em; + box-sizing: border-box; +} + +div.sphinxsidebar #searchbox input[type="submit"] { + float: left; + width: 20%; + border-left: none; + padding: 0.25em; + box-sizing: border-box; +} + + +img { + border: 0; + max-width: 100%; +} + +/* -- search page ----------------------------------------------------------- */ + +ul.search { + margin: 10px 0 0 20px; + padding: 0; +} + +ul.search li { + padding: 5px 0 5px 20px; + background-image: url(file.png); + background-repeat: no-repeat; + background-position: 0 7px; +} + +ul.search li a { + font-weight: bold; +} + +ul.search li p.context { + color: #888; + margin: 2px 0 0 30px; + text-align: left; +} + +ul.keywordmatches li.goodmatch a { + font-weight: bold; +} + +/* -- index page ------------------------------------------------------------ */ + +table.contentstable { + width: 90%; + margin-left: auto; + margin-right: auto; +} + +table.contentstable p.biglink { + line-height: 150%; +} + +a.biglink { + font-size: 1.3em; +} + +span.linkdescr { + font-style: italic; + padding-top: 5px; + font-size: 90%; +} + +/* -- general index --------------------------------------------------------- */ + +table.indextable { + width: 100%; +} + +table.indextable td { + text-align: left; + vertical-align: top; +} + +table.indextable ul { + margin-top: 0; + margin-bottom: 0; + list-style-type: none; +} + +table.indextable > tbody > tr > td > ul { + padding-left: 0em; +} + +table.indextable tr.pcap { + height: 10px; +} + +table.indextable tr.cap { + margin-top: 10px; + background-color: #f2f2f2; +} + +img.toggler { + margin-right: 3px; + margin-top: 3px; + cursor: pointer; +} + +div.modindex-jumpbox { + border-top: 1px solid #ddd; + border-bottom: 1px solid #ddd; + margin: 1em 0 1em 0; + padding: 0.4em; +} + +div.genindex-jumpbox { + border-top: 1px solid #ddd; + border-bottom: 1px solid #ddd; + margin: 1em 0 1em 0; + padding: 0.4em; +} + +/* -- domain module index --------------------------------------------------- */ + +table.modindextable td { + padding: 2px; + border-collapse: collapse; +} + +/* -- general body styles --------------------------------------------------- */ + +div.body { + min-width: 450px; + max-width: 800px; +} + +div.body p, div.body dd, div.body li, div.body blockquote { + -moz-hyphens: auto; + -ms-hyphens: auto; + -webkit-hyphens: auto; + hyphens: auto; +} + +a.headerlink { + visibility: hidden; +} + +a.brackets:before, +span.brackets > a:before{ + content: "["; +} + +a.brackets:after, +span.brackets > a:after { + content: "]"; +} + +h1:hover > a.headerlink, +h2:hover > a.headerlink, +h3:hover > a.headerlink, +h4:hover > a.headerlink, +h5:hover > a.headerlink, +h6:hover > a.headerlink, +dt:hover > a.headerlink, +caption:hover > a.headerlink, +p.caption:hover > a.headerlink, +div.code-block-caption:hover > a.headerlink { + visibility: visible; +} + +div.body p.caption { + text-align: inherit; +} + +div.body td { + text-align: left; +} + +.first { + margin-top: 0 !important; +} + +p.rubric { + margin-top: 30px; + font-weight: bold; +} + +img.align-left, figure.align-left, .figure.align-left, object.align-left { + clear: left; + float: left; + margin-right: 1em; +} + +img.align-right, figure.align-right, .figure.align-right, object.align-right { + clear: right; + float: right; + margin-left: 1em; +} + +img.align-center, figure.align-center, .figure.align-center, object.align-center { + display: block; + margin-left: auto; + margin-right: auto; +} + +img.align-default, figure.align-default, .figure.align-default { + display: block; + margin-left: auto; + margin-right: auto; +} + +.align-left { + text-align: left; +} + +.align-center { + text-align: center; +} + +.align-default { + text-align: center; +} + +.align-right { + text-align: right; +} + +/* -- sidebars -------------------------------------------------------------- */ + +div.sidebar, +aside.sidebar { + margin: 0 0 0.5em 1em; + border: 1px solid #ddb; + padding: 7px; + background-color: #ffe; + width: 40%; + float: right; + clear: right; + overflow-x: auto; +} + +p.sidebar-title { + font-weight: bold; +} + +div.admonition, div.topic, blockquote { + clear: left; +} + +/* -- topics ---------------------------------------------------------------- */ + +div.topic { + border: 1px solid #ccc; + padding: 7px; + margin: 10px 0 10px 0; +} + +p.topic-title { + font-size: 1.1em; + font-weight: bold; + margin-top: 10px; +} + +/* -- admonitions ----------------------------------------------------------- */ + +div.admonition { + margin-top: 10px; + margin-bottom: 10px; + padding: 7px; +} + +div.admonition dt { + font-weight: bold; +} + +p.admonition-title { + margin: 0px 10px 5px 0px; + font-weight: bold; +} + +div.body p.centered { + text-align: center; + margin-top: 25px; +} + +/* -- content of sidebars/topics/admonitions -------------------------------- */ + +div.sidebar > :last-child, +aside.sidebar > :last-child, +div.topic > :last-child, +div.admonition > :last-child { + margin-bottom: 0; +} + +div.sidebar::after, +aside.sidebar::after, +div.topic::after, +div.admonition::after, +blockquote::after { + display: block; + content: ''; + clear: both; +} + +/* -- tables ---------------------------------------------------------------- */ + +table.docutils { + margin-top: 10px; + margin-bottom: 10px; + border: 0; + border-collapse: collapse; +} + +table.align-center { + margin-left: auto; + margin-right: auto; +} + +table.align-default { + margin-left: auto; + margin-right: auto; +} + +table caption span.caption-number { + font-style: italic; +} + +table caption span.caption-text { +} + +table.docutils td, table.docutils th { + padding: 1px 8px 1px 5px; + border-top: 0; + border-left: 0; + border-right: 0; + border-bottom: 1px solid #aaa; +} + +table.footnote td, table.footnote th { + border: 0 !important; +} + +th { + text-align: left; + padding-right: 5px; +} + +table.citation { + border-left: solid 1px gray; + margin-left: 1px; +} + +table.citation td { + border-bottom: none; +} + +th > :first-child, +td > :first-child { + margin-top: 0px; +} + +th > :last-child, +td > :last-child { + margin-bottom: 0px; +} + +/* -- figures --------------------------------------------------------------- */ + +div.figure, figure { + margin: 0.5em; + padding: 0.5em; +} + +div.figure p.caption, figcaption { + padding: 0.3em; +} + +div.figure p.caption span.caption-number, +figcaption span.caption-number { + font-style: italic; +} + +div.figure p.caption span.caption-text, +figcaption span.caption-text { +} + +/* -- field list styles ----------------------------------------------------- */ + +table.field-list td, table.field-list th { + border: 0 !important; +} + +.field-list ul { + margin: 0; + padding-left: 1em; +} + +.field-list p { + margin: 0; +} + +.field-name { + -moz-hyphens: manual; + -ms-hyphens: manual; + -webkit-hyphens: manual; + hyphens: manual; +} + +/* -- hlist styles ---------------------------------------------------------- */ + +table.hlist { + margin: 1em 0; +} + +table.hlist td { + vertical-align: top; +} + +/* -- object description styles --------------------------------------------- */ + +.sig { + font-family: 'Consolas', 'Menlo', 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', monospace; +} + +.sig-name, code.descname { + background-color: transparent; + font-weight: bold; +} + +.sig-name { + font-size: 1.1em; +} + +code.descname { + font-size: 1.2em; +} + +.sig-prename, code.descclassname { + background-color: transparent; +} + +.optional { + font-size: 1.3em; +} + +.sig-paren { + font-size: larger; +} + +.sig-param.n { + font-style: italic; +} + +/* C++ specific styling */ + +.sig-inline.c-texpr, +.sig-inline.cpp-texpr { + font-family: unset; +} + +.sig.c .k, .sig.c .kt, +.sig.cpp .k, .sig.cpp .kt { + color: #0033B3; +} + +.sig.c .m, +.sig.cpp .m { + color: #1750EB; +} + +.sig.c .s, .sig.c .sc, +.sig.cpp .s, .sig.cpp .sc { + color: #067D17; +} + + +/* -- other body styles ----------------------------------------------------- */ + +ol.arabic { + list-style: decimal; +} + +ol.loweralpha { + list-style: lower-alpha; +} + +ol.upperalpha { + list-style: upper-alpha; +} + +ol.lowerroman { + list-style: lower-roman; +} + +ol.upperroman { + list-style: upper-roman; +} + +:not(li) > ol > li:first-child > :first-child, +:not(li) > ul > li:first-child > :first-child { + margin-top: 0px; +} + +:not(li) > ol > li:last-child > :last-child, +:not(li) > ul > li:last-child > :last-child { + margin-bottom: 0px; +} + +ol.simple ol p, +ol.simple ul p, +ul.simple ol p, +ul.simple ul p { + margin-top: 0; +} + +ol.simple > li:not(:first-child) > p, +ul.simple > li:not(:first-child) > p { + margin-top: 0; +} + +ol.simple p, +ul.simple p { + margin-bottom: 0; +} + +dl.footnote > dt, +dl.citation > dt { + float: left; + margin-right: 0.5em; +} + +dl.footnote > dd, +dl.citation > dd { + margin-bottom: 0em; +} + +dl.footnote > dd:after, +dl.citation > dd:after { + content: ""; + clear: both; +} + +dl.field-list { + display: grid; + grid-template-columns: fit-content(30%) auto; +} + +dl.field-list > dt { + font-weight: bold; + word-break: break-word; + padding-left: 0.5em; + padding-right: 5px; +} + +dl.field-list > dt:after { + content: ":"; +} + +dl.field-list > dd { + padding-left: 0.5em; + margin-top: 0em; + margin-left: 0em; + margin-bottom: 0em; +} + +dl { + margin-bottom: 15px; +} + +dd > :first-child { + margin-top: 0px; +} + +dd ul, dd table { + margin-bottom: 10px; +} + +dd { + margin-top: 3px; + margin-bottom: 10px; + margin-left: 30px; +} + +dl > dd:last-child, +dl > dd:last-child > :last-child { + margin-bottom: 0; +} + +dt:target, span.highlighted { + background-color: #fbe54e; +} + +rect.highlighted { + fill: #fbe54e; +} + +dl.glossary dt { + font-weight: bold; + font-size: 1.1em; +} + +.versionmodified { + font-style: italic; +} + +.system-message { + background-color: #fda; + padding: 5px; + border: 3px solid red; +} + +.footnote:target { + background-color: #ffa; +} + +.line-block { + display: block; + margin-top: 1em; + margin-bottom: 1em; +} + +.line-block .line-block { + margin-top: 0; + margin-bottom: 0; + margin-left: 1.5em; +} + +.guilabel, .menuselection { + font-family: sans-serif; +} + +.accelerator { + text-decoration: underline; +} + +.classifier { + font-style: oblique; +} + +.classifier:before { + font-style: normal; + margin: 0 0.5em; + content: ":"; + display: inline-block; +} + +abbr, acronym { + border-bottom: dotted 1px; + cursor: help; +} + +/* -- code displays --------------------------------------------------------- */ + +pre { + overflow: auto; + overflow-y: hidden; /* fixes display issues on Chrome browsers */ +} + +pre, div[class*="highlight-"] { + clear: both; +} + +span.pre { + -moz-hyphens: none; + -ms-hyphens: none; + -webkit-hyphens: none; + hyphens: none; +} + +div[class*="highlight-"] { + margin: 1em 0; +} + +td.linenos pre { + border: 0; + background-color: transparent; + color: #aaa; +} + +table.highlighttable { + display: block; +} + +table.highlighttable tbody { + display: block; +} + +table.highlighttable tr { + display: flex; +} + +table.highlighttable td { + margin: 0; + padding: 0; +} + +table.highlighttable td.linenos { + padding-right: 0.5em; +} + +table.highlighttable td.code { + flex: 1; + overflow: hidden; +} + +.highlight .hll { + display: block; +} + +div.highlight pre, +table.highlighttable pre { + margin: 0; +} + +div.code-block-caption + div { + margin-top: 0; +} + +div.code-block-caption { + margin-top: 1em; + padding: 2px 5px; + font-size: small; +} + +div.code-block-caption code { + background-color: transparent; +} + +table.highlighttable td.linenos, +span.linenos, +div.highlight span.gp { /* gp: Generic.Prompt */ + user-select: none; + -webkit-user-select: text; /* Safari fallback only */ + -webkit-user-select: none; /* Chrome/Safari */ + -moz-user-select: none; /* Firefox */ + -ms-user-select: none; /* IE10+ */ +} + +div.code-block-caption span.caption-number { + padding: 0.1em 0.3em; + font-style: italic; +} + +div.code-block-caption span.caption-text { +} + +div.literal-block-wrapper { + margin: 1em 0; +} + +code.xref, a code { + background-color: transparent; + font-weight: bold; +} + +h1 code, h2 code, h3 code, h4 code, h5 code, h6 code { + background-color: transparent; +} + +.viewcode-link { + float: right; +} + +.viewcode-back { + float: right; + font-family: sans-serif; +} + +div.viewcode-block:target { + margin: -1px -10px; + padding: 0 10px; +} + +/* -- math display ---------------------------------------------------------- */ + +img.math { + vertical-align: middle; +} + +div.body div.math p { + text-align: center; +} + +span.eqno { + float: right; +} + +span.eqno a.headerlink { + position: absolute; + z-index: 1; +} + +div.math:hover a.headerlink { + visibility: visible; +} + +/* -- printout stylesheet --------------------------------------------------- */ + +@media print { + div.document, + div.documentwrapper, + div.bodywrapper { + margin: 0 !important; + width: 100%; + } + + div.sphinxsidebar, + div.related, + div.footer, + #top-link { + display: none; + } +} \ No newline at end of file diff --git a/python/_github_pages_docs/html/_static/custom.css b/python/_github_pages_docs/html/_static/custom.css new file mode 100644 index 0000000..2a924f1 --- /dev/null +++ b/python/_github_pages_docs/html/_static/custom.css @@ -0,0 +1 @@ +/* This file intentionally left blank. */ diff --git a/python/_github_pages_docs/html/_static/doctools.js b/python/_github_pages_docs/html/_static/doctools.js new file mode 100644 index 0000000..8cbf1b1 --- /dev/null +++ b/python/_github_pages_docs/html/_static/doctools.js @@ -0,0 +1,323 @@ +/* + * doctools.js + * ~~~~~~~~~~~ + * + * Sphinx JavaScript utilities for all documentation. + * + * :copyright: Copyright 2007-2021 by the Sphinx team, see AUTHORS. + * :license: BSD, see LICENSE for details. + * + */ + +/** + * select a different prefix for underscore + */ +$u = _.noConflict(); + +/** + * make the code below compatible with browsers without + * an installed firebug like debugger +if (!window.console || !console.firebug) { + var names = ["log", "debug", "info", "warn", "error", "assert", "dir", + "dirxml", "group", "groupEnd", "time", "timeEnd", "count", "trace", + "profile", "profileEnd"]; + window.console = {}; + for (var i = 0; i < names.length; ++i) + window.console[names[i]] = function() {}; +} + */ + +/** + * small helper function to urldecode strings + * + * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURIComponent#Decoding_query_parameters_from_a_URL + */ +jQuery.urldecode = function(x) { + if (!x) { + return x + } + return decodeURIComponent(x.replace(/\+/g, ' ')); +}; + +/** + * small helper function to urlencode strings + */ +jQuery.urlencode = encodeURIComponent; + +/** + * This function returns the parsed url parameters of the + * current request. Multiple values per key are supported, + * it will always return arrays of strings for the value parts. + */ +jQuery.getQueryParameters = function(s) { + if (typeof s === 'undefined') + s = document.location.search; + var parts = s.substr(s.indexOf('?') + 1).split('&'); + var result = {}; + for (var i = 0; i < parts.length; i++) { + var tmp = parts[i].split('=', 2); + var key = jQuery.urldecode(tmp[0]); + var value = jQuery.urldecode(tmp[1]); + if (key in result) + result[key].push(value); + else + result[key] = [value]; + } + return result; +}; + +/** + * highlight a given string on a jquery object by wrapping it in + * span elements with the given class name. + */ +jQuery.fn.highlightText = function(text, className) { + function highlight(node, addItems) { + if (node.nodeType === 3) { + var val = node.nodeValue; + var pos = val.toLowerCase().indexOf(text); + if (pos >= 0 && + !jQuery(node.parentNode).hasClass(className) && + !jQuery(node.parentNode).hasClass("nohighlight")) { + var span; + var isInSVG = jQuery(node).closest("body, svg, foreignObject").is("svg"); + if (isInSVG) { + span = document.createElementNS("http://www.w3.org/2000/svg", "tspan"); + } else { + span = document.createElement("span"); + span.className = className; + } + span.appendChild(document.createTextNode(val.substr(pos, text.length))); + node.parentNode.insertBefore(span, node.parentNode.insertBefore( + document.createTextNode(val.substr(pos + text.length)), + node.nextSibling)); + node.nodeValue = val.substr(0, pos); + if (isInSVG) { + var rect = document.createElementNS("http://www.w3.org/2000/svg", "rect"); + var bbox = node.parentElement.getBBox(); + rect.x.baseVal.value = bbox.x; + rect.y.baseVal.value = bbox.y; + rect.width.baseVal.value = bbox.width; + rect.height.baseVal.value = bbox.height; + rect.setAttribute('class', className); + addItems.push({ + "parent": node.parentNode, + "target": rect}); + } + } + } + else if (!jQuery(node).is("button, select, textarea")) { + jQuery.each(node.childNodes, function() { + highlight(this, addItems); + }); + } + } + var addItems = []; + var result = this.each(function() { + highlight(this, addItems); + }); + for (var i = 0; i < addItems.length; ++i) { + jQuery(addItems[i].parent).before(addItems[i].target); + } + return result; +}; + +/* + * backward compatibility for jQuery.browser + * This will be supported until firefox bug is fixed. + */ +if (!jQuery.browser) { + jQuery.uaMatch = function(ua) { + ua = ua.toLowerCase(); + + var match = /(chrome)[ \/]([\w.]+)/.exec(ua) || + /(webkit)[ \/]([\w.]+)/.exec(ua) || + /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) || + /(msie) ([\w.]+)/.exec(ua) || + ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) || + []; + + return { + browser: match[ 1 ] || "", + version: match[ 2 ] || "0" + }; + }; + jQuery.browser = {}; + jQuery.browser[jQuery.uaMatch(navigator.userAgent).browser] = true; +} + +/** + * Small JavaScript module for the documentation. + */ +var Documentation = { + + init : function() { + this.fixFirefoxAnchorBug(); + this.highlightSearchWords(); + this.initIndexTable(); + if (DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) { + this.initOnKeyListeners(); + } + }, + + /** + * i18n support + */ + TRANSLATIONS : {}, + PLURAL_EXPR : function(n) { return n === 1 ? 0 : 1; }, + LOCALE : 'unknown', + + // gettext and ngettext don't access this so that the functions + // can safely bound to a different name (_ = Documentation.gettext) + gettext : function(string) { + var translated = Documentation.TRANSLATIONS[string]; + if (typeof translated === 'undefined') + return string; + return (typeof translated === 'string') ? translated : translated[0]; + }, + + ngettext : function(singular, plural, n) { + var translated = Documentation.TRANSLATIONS[singular]; + if (typeof translated === 'undefined') + return (n == 1) ? singular : plural; + return translated[Documentation.PLURALEXPR(n)]; + }, + + addTranslations : function(catalog) { + for (var key in catalog.messages) + this.TRANSLATIONS[key] = catalog.messages[key]; + this.PLURAL_EXPR = new Function('n', 'return +(' + catalog.plural_expr + ')'); + this.LOCALE = catalog.locale; + }, + + /** + * add context elements like header anchor links + */ + addContextElements : function() { + $('div[id] > :header:first').each(function() { + $('\u00B6'). + attr('href', '#' + this.id). + attr('title', _('Permalink to this headline')). + appendTo(this); + }); + $('dt[id]').each(function() { + $('\u00B6'). + attr('href', '#' + this.id). + attr('title', _('Permalink to this definition')). + appendTo(this); + }); + }, + + /** + * workaround a firefox stupidity + * see: https://bugzilla.mozilla.org/show_bug.cgi?id=645075 + */ + fixFirefoxAnchorBug : function() { + if (document.location.hash && $.browser.mozilla) + window.setTimeout(function() { + document.location.href += ''; + }, 10); + }, + + /** + * highlight the search words provided in the url in the text + */ + highlightSearchWords : function() { + var params = $.getQueryParameters(); + var terms = (params.highlight) ? params.highlight[0].split(/\s+/) : []; + if (terms.length) { + var body = $('div.body'); + if (!body.length) { + body = $('body'); + } + window.setTimeout(function() { + $.each(terms, function() { + body.highlightText(this.toLowerCase(), 'highlighted'); + }); + }, 10); + $('

' + _('Hide Search Matches') + '

') + .appendTo($('#searchbox')); + } + }, + + /** + * init the domain index toggle buttons + */ + initIndexTable : function() { + var togglers = $('img.toggler').click(function() { + var src = $(this).attr('src'); + var idnum = $(this).attr('id').substr(7); + $('tr.cg-' + idnum).toggle(); + if (src.substr(-9) === 'minus.png') + $(this).attr('src', src.substr(0, src.length-9) + 'plus.png'); + else + $(this).attr('src', src.substr(0, src.length-8) + 'minus.png'); + }).css('display', ''); + if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) { + togglers.click(); + } + }, + + /** + * helper function to hide the search marks again + */ + hideSearchWords : function() { + $('#searchbox .highlight-link').fadeOut(300); + $('span.highlighted').removeClass('highlighted'); + }, + + /** + * make the url absolute + */ + makeURL : function(relativeURL) { + return DOCUMENTATION_OPTIONS.URL_ROOT + '/' + relativeURL; + }, + + /** + * get the current relative url + */ + getCurrentURL : function() { + var path = document.location.pathname; + var parts = path.split(/\//); + $.each(DOCUMENTATION_OPTIONS.URL_ROOT.split(/\//), function() { + if (this === '..') + parts.pop(); + }); + var url = parts.join('/'); + return path.substring(url.lastIndexOf('/') + 1, path.length - 1); + }, + + initOnKeyListeners: function() { + $(document).keydown(function(event) { + var activeElementType = document.activeElement.tagName; + // don't navigate when in search box, textarea, dropdown or button + if (activeElementType !== 'TEXTAREA' && activeElementType !== 'INPUT' && activeElementType !== 'SELECT' + && activeElementType !== 'BUTTON' && !event.altKey && !event.ctrlKey && !event.metaKey + && !event.shiftKey) { + switch (event.keyCode) { + case 37: // left + var prevHref = $('link[rel="prev"]').prop('href'); + if (prevHref) { + window.location.href = prevHref; + return false; + } + break; + case 39: // right + var nextHref = $('link[rel="next"]').prop('href'); + if (nextHref) { + window.location.href = nextHref; + return false; + } + break; + } + } + }); + } +}; + +// quick alias for translations +_ = Documentation.gettext; + +$(document).ready(function() { + Documentation.init(); +}); diff --git a/python/_github_pages_docs/html/_static/documentation_options.js b/python/_github_pages_docs/html/_static/documentation_options.js new file mode 100644 index 0000000..2fa8c97 --- /dev/null +++ b/python/_github_pages_docs/html/_static/documentation_options.js @@ -0,0 +1,12 @@ +var DOCUMENTATION_OPTIONS = { + URL_ROOT: document.getElementById("documentation_options").getAttribute('data-url_root'), + VERSION: '', + LANGUAGE: 'None', + COLLAPSE_INDEX: false, + BUILDER: 'html', + FILE_SUFFIX: '.html', + LINK_SUFFIX: '.html', + HAS_SOURCE: true, + SOURCELINK_SUFFIX: '.txt', + NAVIGATION_WITH_KEYS: false +}; \ No newline at end of file diff --git a/python/_github_pages_docs/html/_static/file.png b/python/_github_pages_docs/html/_static/file.png new file mode 100644 index 0000000000000000000000000000000000000000..a858a410e4faa62ce324d814e4b816fff83a6fb3 GIT binary patch literal 286 zcmV+(0pb3MP)s`hMrGg#P~ix$^RISR_I47Y|r1 z_CyJOe}D1){SET-^Amu_i71Lt6eYfZjRyw@I6OQAIXXHDfiX^GbOlHe=Ae4>0m)d(f|Me07*qoM6N<$f}vM^LjV8( literal 0 HcmV?d00001 diff --git a/python/_github_pages_docs/html/_static/jquery-3.5.1.js b/python/_github_pages_docs/html/_static/jquery-3.5.1.js new file mode 100644 index 0000000..5093733 --- /dev/null +++ b/python/_github_pages_docs/html/_static/jquery-3.5.1.js @@ -0,0 +1,10872 @@ +/*! + * jQuery JavaScript Library v3.5.1 + * https://jquery.com/ + * + * Includes Sizzle.js + * https://sizzlejs.com/ + * + * Copyright JS Foundation and other contributors + * Released under the MIT license + * https://jquery.org/license + * + * Date: 2020-05-04T22:49Z + */ +( function( global, factory ) { + + "use strict"; + + if ( typeof module === "object" && typeof module.exports === "object" ) { + + // For CommonJS and CommonJS-like environments where a proper `window` + // is present, execute the factory and get jQuery. + // For environments that do not have a `window` with a `document` + // (such as Node.js), expose a factory as module.exports. + // This accentuates the need for the creation of a real `window`. + // e.g. var jQuery = require("jquery")(window); + // See ticket #14549 for more info. + module.exports = global.document ? + factory( global, true ) : + function( w ) { + if ( !w.document ) { + throw new Error( "jQuery requires a window with a document" ); + } + return factory( w ); + }; + } else { + factory( global ); + } + +// Pass this if window is not defined yet +} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) { + +// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1 +// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode +// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common +// enough that all such attempts are guarded in a try block. +"use strict"; + +var arr = []; + +var getProto = Object.getPrototypeOf; + +var slice = arr.slice; + +var flat = arr.flat ? function( array ) { + return arr.flat.call( array ); +} : function( array ) { + return arr.concat.apply( [], array ); +}; + + +var push = arr.push; + +var indexOf = arr.indexOf; + +var class2type = {}; + +var toString = class2type.toString; + +var hasOwn = class2type.hasOwnProperty; + +var fnToString = hasOwn.toString; + +var ObjectFunctionString = fnToString.call( Object ); + +var support = {}; + +var isFunction = function isFunction( obj ) { + + // Support: Chrome <=57, Firefox <=52 + // In some browsers, typeof returns "function" for HTML elements + // (i.e., `typeof document.createElement( "object" ) === "function"`). + // We don't want to classify *any* DOM node as a function. + return typeof obj === "function" && typeof obj.nodeType !== "number"; + }; + + +var isWindow = function isWindow( obj ) { + return obj != null && obj === obj.window; + }; + + +var document = window.document; + + + + var preservedScriptAttributes = { + type: true, + src: true, + nonce: true, + noModule: true + }; + + function DOMEval( code, node, doc ) { + doc = doc || document; + + var i, val, + script = doc.createElement( "script" ); + + script.text = code; + if ( node ) { + for ( i in preservedScriptAttributes ) { + + // Support: Firefox 64+, Edge 18+ + // Some browsers don't support the "nonce" property on scripts. + // On the other hand, just using `getAttribute` is not enough as + // the `nonce` attribute is reset to an empty string whenever it + // becomes browsing-context connected. + // See https://github.com/whatwg/html/issues/2369 + // See https://html.spec.whatwg.org/#nonce-attributes + // The `node.getAttribute` check was added for the sake of + // `jQuery.globalEval` so that it can fake a nonce-containing node + // via an object. + val = node[ i ] || node.getAttribute && node.getAttribute( i ); + if ( val ) { + script.setAttribute( i, val ); + } + } + } + doc.head.appendChild( script ).parentNode.removeChild( script ); + } + + +function toType( obj ) { + if ( obj == null ) { + return obj + ""; + } + + // Support: Android <=2.3 only (functionish RegExp) + return typeof obj === "object" || typeof obj === "function" ? + class2type[ toString.call( obj ) ] || "object" : + typeof obj; +} +/* global Symbol */ +// Defining this global in .eslintrc.json would create a danger of using the global +// unguarded in another place, it seems safer to define global only for this module + + + +var + version = "3.5.1", + + // Define a local copy of jQuery + jQuery = function( selector, context ) { + + // The jQuery object is actually just the init constructor 'enhanced' + // Need init if jQuery is called (just allow error to be thrown if not included) + return new jQuery.fn.init( selector, context ); + }; + +jQuery.fn = jQuery.prototype = { + + // The current version of jQuery being used + jquery: version, + + constructor: jQuery, + + // The default length of a jQuery object is 0 + length: 0, + + toArray: function() { + return slice.call( this ); + }, + + // Get the Nth element in the matched element set OR + // Get the whole matched element set as a clean array + get: function( num ) { + + // Return all the elements in a clean array + if ( num == null ) { + return slice.call( this ); + } + + // Return just the one element from the set + return num < 0 ? this[ num + this.length ] : this[ num ]; + }, + + // Take an array of elements and push it onto the stack + // (returning the new matched element set) + pushStack: function( elems ) { + + // Build a new jQuery matched element set + var ret = jQuery.merge( this.constructor(), elems ); + + // Add the old object onto the stack (as a reference) + ret.prevObject = this; + + // Return the newly-formed element set + return ret; + }, + + // Execute a callback for every element in the matched set. + each: function( callback ) { + return jQuery.each( this, callback ); + }, + + map: function( callback ) { + return this.pushStack( jQuery.map( this, function( elem, i ) { + return callback.call( elem, i, elem ); + } ) ); + }, + + slice: function() { + return this.pushStack( slice.apply( this, arguments ) ); + }, + + first: function() { + return this.eq( 0 ); + }, + + last: function() { + return this.eq( -1 ); + }, + + even: function() { + return this.pushStack( jQuery.grep( this, function( _elem, i ) { + return ( i + 1 ) % 2; + } ) ); + }, + + odd: function() { + return this.pushStack( jQuery.grep( this, function( _elem, i ) { + return i % 2; + } ) ); + }, + + eq: function( i ) { + var len = this.length, + j = +i + ( i < 0 ? len : 0 ); + return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] ); + }, + + end: function() { + return this.prevObject || this.constructor(); + }, + + // For internal use only. + // Behaves like an Array's method, not like a jQuery method. + push: push, + sort: arr.sort, + splice: arr.splice +}; + +jQuery.extend = jQuery.fn.extend = function() { + var options, name, src, copy, copyIsArray, clone, + target = arguments[ 0 ] || {}, + i = 1, + length = arguments.length, + deep = false; + + // Handle a deep copy situation + if ( typeof target === "boolean" ) { + deep = target; + + // Skip the boolean and the target + target = arguments[ i ] || {}; + i++; + } + + // Handle case when target is a string or something (possible in deep copy) + if ( typeof target !== "object" && !isFunction( target ) ) { + target = {}; + } + + // Extend jQuery itself if only one argument is passed + if ( i === length ) { + target = this; + i--; + } + + for ( ; i < length; i++ ) { + + // Only deal with non-null/undefined values + if ( ( options = arguments[ i ] ) != null ) { + + // Extend the base object + for ( name in options ) { + copy = options[ name ]; + + // Prevent Object.prototype pollution + // Prevent never-ending loop + if ( name === "__proto__" || target === copy ) { + continue; + } + + // Recurse if we're merging plain objects or arrays + if ( deep && copy && ( jQuery.isPlainObject( copy ) || + ( copyIsArray = Array.isArray( copy ) ) ) ) { + src = target[ name ]; + + // Ensure proper type for the source value + if ( copyIsArray && !Array.isArray( src ) ) { + clone = []; + } else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) { + clone = {}; + } else { + clone = src; + } + copyIsArray = false; + + // Never move original objects, clone them + target[ name ] = jQuery.extend( deep, clone, copy ); + + // Don't bring in undefined values + } else if ( copy !== undefined ) { + target[ name ] = copy; + } + } + } + } + + // Return the modified object + return target; +}; + +jQuery.extend( { + + // Unique for each copy of jQuery on the page + expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ), + + // Assume jQuery is ready without the ready module + isReady: true, + + error: function( msg ) { + throw new Error( msg ); + }, + + noop: function() {}, + + isPlainObject: function( obj ) { + var proto, Ctor; + + // Detect obvious negatives + // Use toString instead of jQuery.type to catch host objects + if ( !obj || toString.call( obj ) !== "[object Object]" ) { + return false; + } + + proto = getProto( obj ); + + // Objects with no prototype (e.g., `Object.create( null )`) are plain + if ( !proto ) { + return true; + } + + // Objects with prototype are plain iff they were constructed by a global Object function + Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor; + return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString; + }, + + isEmptyObject: function( obj ) { + var name; + + for ( name in obj ) { + return false; + } + return true; + }, + + // Evaluates a script in a provided context; falls back to the global one + // if not specified. + globalEval: function( code, options, doc ) { + DOMEval( code, { nonce: options && options.nonce }, doc ); + }, + + each: function( obj, callback ) { + var length, i = 0; + + if ( isArrayLike( obj ) ) { + length = obj.length; + for ( ; i < length; i++ ) { + if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { + break; + } + } + } else { + for ( i in obj ) { + if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { + break; + } + } + } + + return obj; + }, + + // results is for internal usage only + makeArray: function( arr, results ) { + var ret = results || []; + + if ( arr != null ) { + if ( isArrayLike( Object( arr ) ) ) { + jQuery.merge( ret, + typeof arr === "string" ? + [ arr ] : arr + ); + } else { + push.call( ret, arr ); + } + } + + return ret; + }, + + inArray: function( elem, arr, i ) { + return arr == null ? -1 : indexOf.call( arr, elem, i ); + }, + + // Support: Android <=4.0 only, PhantomJS 1 only + // push.apply(_, arraylike) throws on ancient WebKit + merge: function( first, second ) { + var len = +second.length, + j = 0, + i = first.length; + + for ( ; j < len; j++ ) { + first[ i++ ] = second[ j ]; + } + + first.length = i; + + return first; + }, + + grep: function( elems, callback, invert ) { + var callbackInverse, + matches = [], + i = 0, + length = elems.length, + callbackExpect = !invert; + + // Go through the array, only saving the items + // that pass the validator function + for ( ; i < length; i++ ) { + callbackInverse = !callback( elems[ i ], i ); + if ( callbackInverse !== callbackExpect ) { + matches.push( elems[ i ] ); + } + } + + return matches; + }, + + // arg is for internal usage only + map: function( elems, callback, arg ) { + var length, value, + i = 0, + ret = []; + + // Go through the array, translating each of the items to their new values + if ( isArrayLike( elems ) ) { + length = elems.length; + for ( ; i < length; i++ ) { + value = callback( elems[ i ], i, arg ); + + if ( value != null ) { + ret.push( value ); + } + } + + // Go through every key on the object, + } else { + for ( i in elems ) { + value = callback( elems[ i ], i, arg ); + + if ( value != null ) { + ret.push( value ); + } + } + } + + // Flatten any nested arrays + return flat( ret ); + }, + + // A global GUID counter for objects + guid: 1, + + // jQuery.support is not used in Core but other projects attach their + // properties to it so it needs to exist. + support: support +} ); + +if ( typeof Symbol === "function" ) { + jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ]; +} + +// Populate the class2type map +jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ), +function( _i, name ) { + class2type[ "[object " + name + "]" ] = name.toLowerCase(); +} ); + +function isArrayLike( obj ) { + + // Support: real iOS 8.2 only (not reproducible in simulator) + // `in` check used to prevent JIT error (gh-2145) + // hasOwn isn't used here due to false negatives + // regarding Nodelist length in IE + var length = !!obj && "length" in obj && obj.length, + type = toType( obj ); + + if ( isFunction( obj ) || isWindow( obj ) ) { + return false; + } + + return type === "array" || length === 0 || + typeof length === "number" && length > 0 && ( length - 1 ) in obj; +} +var Sizzle = +/*! + * Sizzle CSS Selector Engine v2.3.5 + * https://sizzlejs.com/ + * + * Copyright JS Foundation and other contributors + * Released under the MIT license + * https://js.foundation/ + * + * Date: 2020-03-14 + */ +( function( window ) { +var i, + support, + Expr, + getText, + isXML, + tokenize, + compile, + select, + outermostContext, + sortInput, + hasDuplicate, + + // Local document vars + setDocument, + document, + docElem, + documentIsHTML, + rbuggyQSA, + rbuggyMatches, + matches, + contains, + + // Instance-specific data + expando = "sizzle" + 1 * new Date(), + preferredDoc = window.document, + dirruns = 0, + done = 0, + classCache = createCache(), + tokenCache = createCache(), + compilerCache = createCache(), + nonnativeSelectorCache = createCache(), + sortOrder = function( a, b ) { + if ( a === b ) { + hasDuplicate = true; + } + return 0; + }, + + // Instance methods + hasOwn = ( {} ).hasOwnProperty, + arr = [], + pop = arr.pop, + pushNative = arr.push, + push = arr.push, + slice = arr.slice, + + // Use a stripped-down indexOf as it's faster than native + // https://jsperf.com/thor-indexof-vs-for/5 + indexOf = function( list, elem ) { + var i = 0, + len = list.length; + for ( ; i < len; i++ ) { + if ( list[ i ] === elem ) { + return i; + } + } + return -1; + }, + + booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|" + + "ismap|loop|multiple|open|readonly|required|scoped", + + // Regular expressions + + // http://www.w3.org/TR/css3-selectors/#whitespace + whitespace = "[\\x20\\t\\r\\n\\f]", + + // https://www.w3.org/TR/css-syntax-3/#ident-token-diagram + identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace + + "?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+", + + // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors + attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace + + + // Operator (capture 2) + "*([*^$|!~]?=)" + whitespace + + + // "Attribute values must be CSS identifiers [capture 5] + // or strings [capture 3 or capture 4]" + "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + + whitespace + "*\\]", + + pseudos = ":(" + identifier + ")(?:\\((" + + + // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments: + // 1. quoted (capture 3; capture 4 or capture 5) + "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" + + + // 2. simple (capture 6) + "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" + + + // 3. anything else (capture 2) + ".*" + + ")\\)|)", + + // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter + rwhitespace = new RegExp( whitespace + "+", "g" ), + rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + + whitespace + "+$", "g" ), + + rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ), + rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + + "*" ), + rdescend = new RegExp( whitespace + "|>" ), + + rpseudo = new RegExp( pseudos ), + ridentifier = new RegExp( "^" + identifier + "$" ), + + matchExpr = { + "ID": new RegExp( "^#(" + identifier + ")" ), + "CLASS": new RegExp( "^\\.(" + identifier + ")" ), + "TAG": new RegExp( "^(" + identifier + "|[*])" ), + "ATTR": new RegExp( "^" + attributes ), + "PSEUDO": new RegExp( "^" + pseudos ), + "CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + + whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + + whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ), + "bool": new RegExp( "^(?:" + booleans + ")$", "i" ), + + // For use in libraries implementing .is() + // We use this for POS matching in `select` + "needsContext": new RegExp( "^" + whitespace + + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" ) + }, + + rhtml = /HTML$/i, + rinputs = /^(?:input|select|textarea|button)$/i, + rheader = /^h\d$/i, + + rnative = /^[^{]+\{\s*\[native \w/, + + // Easily-parseable/retrievable ID or TAG or CLASS selectors + rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, + + rsibling = /[+~]/, + + // CSS escapes + // http://www.w3.org/TR/CSS21/syndata.html#escaped-characters + runescape = new RegExp( "\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\([^\\r\\n\\f])", "g" ), + funescape = function( escape, nonHex ) { + var high = "0x" + escape.slice( 1 ) - 0x10000; + + return nonHex ? + + // Strip the backslash prefix from a non-hex escape sequence + nonHex : + + // Replace a hexadecimal escape sequence with the encoded Unicode code point + // Support: IE <=11+ + // For values outside the Basic Multilingual Plane (BMP), manually construct a + // surrogate pair + high < 0 ? + String.fromCharCode( high + 0x10000 ) : + String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 ); + }, + + // CSS string/identifier serialization + // https://drafts.csswg.org/cssom/#common-serializing-idioms + rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g, + fcssescape = function( ch, asCodePoint ) { + if ( asCodePoint ) { + + // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER + if ( ch === "\0" ) { + return "\uFFFD"; + } + + // Control characters and (dependent upon position) numbers get escaped as code points + return ch.slice( 0, -1 ) + "\\" + + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " "; + } + + // Other potentially-special ASCII characters get backslash-escaped + return "\\" + ch; + }, + + // Used for iframes + // See setDocument() + // Removing the function wrapper causes a "Permission Denied" + // error in IE + unloadHandler = function() { + setDocument(); + }, + + inDisabledFieldset = addCombinator( + function( elem ) { + return elem.disabled === true && elem.nodeName.toLowerCase() === "fieldset"; + }, + { dir: "parentNode", next: "legend" } + ); + +// Optimize for push.apply( _, NodeList ) +try { + push.apply( + ( arr = slice.call( preferredDoc.childNodes ) ), + preferredDoc.childNodes + ); + + // Support: Android<4.0 + // Detect silently failing push.apply + // eslint-disable-next-line no-unused-expressions + arr[ preferredDoc.childNodes.length ].nodeType; +} catch ( e ) { + push = { apply: arr.length ? + + // Leverage slice if possible + function( target, els ) { + pushNative.apply( target, slice.call( els ) ); + } : + + // Support: IE<9 + // Otherwise append directly + function( target, els ) { + var j = target.length, + i = 0; + + // Can't trust NodeList.length + while ( ( target[ j++ ] = els[ i++ ] ) ) {} + target.length = j - 1; + } + }; +} + +function Sizzle( selector, context, results, seed ) { + var m, i, elem, nid, match, groups, newSelector, + newContext = context && context.ownerDocument, + + // nodeType defaults to 9, since context defaults to document + nodeType = context ? context.nodeType : 9; + + results = results || []; + + // Return early from calls with invalid selector or context + if ( typeof selector !== "string" || !selector || + nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) { + + return results; + } + + // Try to shortcut find operations (as opposed to filters) in HTML documents + if ( !seed ) { + setDocument( context ); + context = context || document; + + if ( documentIsHTML ) { + + // If the selector is sufficiently simple, try using a "get*By*" DOM method + // (excepting DocumentFragment context, where the methods don't exist) + if ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) { + + // ID selector + if ( ( m = match[ 1 ] ) ) { + + // Document context + if ( nodeType === 9 ) { + if ( ( elem = context.getElementById( m ) ) ) { + + // Support: IE, Opera, Webkit + // TODO: identify versions + // getElementById can match elements by name instead of ID + if ( elem.id === m ) { + results.push( elem ); + return results; + } + } else { + return results; + } + + // Element context + } else { + + // Support: IE, Opera, Webkit + // TODO: identify versions + // getElementById can match elements by name instead of ID + if ( newContext && ( elem = newContext.getElementById( m ) ) && + contains( context, elem ) && + elem.id === m ) { + + results.push( elem ); + return results; + } + } + + // Type selector + } else if ( match[ 2 ] ) { + push.apply( results, context.getElementsByTagName( selector ) ); + return results; + + // Class selector + } else if ( ( m = match[ 3 ] ) && support.getElementsByClassName && + context.getElementsByClassName ) { + + push.apply( results, context.getElementsByClassName( m ) ); + return results; + } + } + + // Take advantage of querySelectorAll + if ( support.qsa && + !nonnativeSelectorCache[ selector + " " ] && + ( !rbuggyQSA || !rbuggyQSA.test( selector ) ) && + + // Support: IE 8 only + // Exclude object elements + ( nodeType !== 1 || context.nodeName.toLowerCase() !== "object" ) ) { + + newSelector = selector; + newContext = context; + + // qSA considers elements outside a scoping root when evaluating child or + // descendant combinators, which is not what we want. + // In such cases, we work around the behavior by prefixing every selector in the + // list with an ID selector referencing the scope context. + // The technique has to be used as well when a leading combinator is used + // as such selectors are not recognized by querySelectorAll. + // Thanks to Andrew Dupont for this technique. + if ( nodeType === 1 && + ( rdescend.test( selector ) || rcombinators.test( selector ) ) ) { + + // Expand context for sibling selectors + newContext = rsibling.test( selector ) && testContext( context.parentNode ) || + context; + + // We can use :scope instead of the ID hack if the browser + // supports it & if we're not changing the context. + if ( newContext !== context || !support.scope ) { + + // Capture the context ID, setting it first if necessary + if ( ( nid = context.getAttribute( "id" ) ) ) { + nid = nid.replace( rcssescape, fcssescape ); + } else { + context.setAttribute( "id", ( nid = expando ) ); + } + } + + // Prefix every selector in the list + groups = tokenize( selector ); + i = groups.length; + while ( i-- ) { + groups[ i ] = ( nid ? "#" + nid : ":scope" ) + " " + + toSelector( groups[ i ] ); + } + newSelector = groups.join( "," ); + } + + try { + push.apply( results, + newContext.querySelectorAll( newSelector ) + ); + return results; + } catch ( qsaError ) { + nonnativeSelectorCache( selector, true ); + } finally { + if ( nid === expando ) { + context.removeAttribute( "id" ); + } + } + } + } + } + + // All others + return select( selector.replace( rtrim, "$1" ), context, results, seed ); +} + +/** + * Create key-value caches of limited size + * @returns {function(string, object)} Returns the Object data after storing it on itself with + * property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength) + * deleting the oldest entry + */ +function createCache() { + var keys = []; + + function cache( key, value ) { + + // Use (key + " ") to avoid collision with native prototype properties (see Issue #157) + if ( keys.push( key + " " ) > Expr.cacheLength ) { + + // Only keep the most recent entries + delete cache[ keys.shift() ]; + } + return ( cache[ key + " " ] = value ); + } + return cache; +} + +/** + * Mark a function for special use by Sizzle + * @param {Function} fn The function to mark + */ +function markFunction( fn ) { + fn[ expando ] = true; + return fn; +} + +/** + * Support testing using an element + * @param {Function} fn Passed the created element and returns a boolean result + */ +function assert( fn ) { + var el = document.createElement( "fieldset" ); + + try { + return !!fn( el ); + } catch ( e ) { + return false; + } finally { + + // Remove from its parent by default + if ( el.parentNode ) { + el.parentNode.removeChild( el ); + } + + // release memory in IE + el = null; + } +} + +/** + * Adds the same handler for all of the specified attrs + * @param {String} attrs Pipe-separated list of attributes + * @param {Function} handler The method that will be applied + */ +function addHandle( attrs, handler ) { + var arr = attrs.split( "|" ), + i = arr.length; + + while ( i-- ) { + Expr.attrHandle[ arr[ i ] ] = handler; + } +} + +/** + * Checks document order of two siblings + * @param {Element} a + * @param {Element} b + * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b + */ +function siblingCheck( a, b ) { + var cur = b && a, + diff = cur && a.nodeType === 1 && b.nodeType === 1 && + a.sourceIndex - b.sourceIndex; + + // Use IE sourceIndex if available on both nodes + if ( diff ) { + return diff; + } + + // Check if b follows a + if ( cur ) { + while ( ( cur = cur.nextSibling ) ) { + if ( cur === b ) { + return -1; + } + } + } + + return a ? 1 : -1; +} + +/** + * Returns a function to use in pseudos for input types + * @param {String} type + */ +function createInputPseudo( type ) { + return function( elem ) { + var name = elem.nodeName.toLowerCase(); + return name === "input" && elem.type === type; + }; +} + +/** + * Returns a function to use in pseudos for buttons + * @param {String} type + */ +function createButtonPseudo( type ) { + return function( elem ) { + var name = elem.nodeName.toLowerCase(); + return ( name === "input" || name === "button" ) && elem.type === type; + }; +} + +/** + * Returns a function to use in pseudos for :enabled/:disabled + * @param {Boolean} disabled true for :disabled; false for :enabled + */ +function createDisabledPseudo( disabled ) { + + // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable + return function( elem ) { + + // Only certain elements can match :enabled or :disabled + // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled + // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled + if ( "form" in elem ) { + + // Check for inherited disabledness on relevant non-disabled elements: + // * listed form-associated elements in a disabled fieldset + // https://html.spec.whatwg.org/multipage/forms.html#category-listed + // https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled + // * option elements in a disabled optgroup + // https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled + // All such elements have a "form" property. + if ( elem.parentNode && elem.disabled === false ) { + + // Option elements defer to a parent optgroup if present + if ( "label" in elem ) { + if ( "label" in elem.parentNode ) { + return elem.parentNode.disabled === disabled; + } else { + return elem.disabled === disabled; + } + } + + // Support: IE 6 - 11 + // Use the isDisabled shortcut property to check for disabled fieldset ancestors + return elem.isDisabled === disabled || + + // Where there is no isDisabled, check manually + /* jshint -W018 */ + elem.isDisabled !== !disabled && + inDisabledFieldset( elem ) === disabled; + } + + return elem.disabled === disabled; + + // Try to winnow out elements that can't be disabled before trusting the disabled property. + // Some victims get caught in our net (label, legend, menu, track), but it shouldn't + // even exist on them, let alone have a boolean value. + } else if ( "label" in elem ) { + return elem.disabled === disabled; + } + + // Remaining elements are neither :enabled nor :disabled + return false; + }; +} + +/** + * Returns a function to use in pseudos for positionals + * @param {Function} fn + */ +function createPositionalPseudo( fn ) { + return markFunction( function( argument ) { + argument = +argument; + return markFunction( function( seed, matches ) { + var j, + matchIndexes = fn( [], seed.length, argument ), + i = matchIndexes.length; + + // Match elements found at the specified indexes + while ( i-- ) { + if ( seed[ ( j = matchIndexes[ i ] ) ] ) { + seed[ j ] = !( matches[ j ] = seed[ j ] ); + } + } + } ); + } ); +} + +/** + * Checks a node for validity as a Sizzle context + * @param {Element|Object=} context + * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value + */ +function testContext( context ) { + return context && typeof context.getElementsByTagName !== "undefined" && context; +} + +// Expose support vars for convenience +support = Sizzle.support = {}; + +/** + * Detects XML nodes + * @param {Element|Object} elem An element or a document + * @returns {Boolean} True iff elem is a non-HTML XML node + */ +isXML = Sizzle.isXML = function( elem ) { + var namespace = elem.namespaceURI, + docElem = ( elem.ownerDocument || elem ).documentElement; + + // Support: IE <=8 + // Assume HTML when documentElement doesn't yet exist, such as inside loading iframes + // https://bugs.jquery.com/ticket/4833 + return !rhtml.test( namespace || docElem && docElem.nodeName || "HTML" ); +}; + +/** + * Sets document-related variables once based on the current document + * @param {Element|Object} [doc] An element or document object to use to set the document + * @returns {Object} Returns the current document + */ +setDocument = Sizzle.setDocument = function( node ) { + var hasCompare, subWindow, + doc = node ? node.ownerDocument || node : preferredDoc; + + // Return early if doc is invalid or already selected + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + if ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) { + return document; + } + + // Update global variables + document = doc; + docElem = document.documentElement; + documentIsHTML = !isXML( document ); + + // Support: IE 9 - 11+, Edge 12 - 18+ + // Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936) + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + if ( preferredDoc != document && + ( subWindow = document.defaultView ) && subWindow.top !== subWindow ) { + + // Support: IE 11, Edge + if ( subWindow.addEventListener ) { + subWindow.addEventListener( "unload", unloadHandler, false ); + + // Support: IE 9 - 10 only + } else if ( subWindow.attachEvent ) { + subWindow.attachEvent( "onunload", unloadHandler ); + } + } + + // Support: IE 8 - 11+, Edge 12 - 18+, Chrome <=16 - 25 only, Firefox <=3.6 - 31 only, + // Safari 4 - 5 only, Opera <=11.6 - 12.x only + // IE/Edge & older browsers don't support the :scope pseudo-class. + // Support: Safari 6.0 only + // Safari 6.0 supports :scope but it's an alias of :root there. + support.scope = assert( function( el ) { + docElem.appendChild( el ).appendChild( document.createElement( "div" ) ); + return typeof el.querySelectorAll !== "undefined" && + !el.querySelectorAll( ":scope fieldset div" ).length; + } ); + + /* Attributes + ---------------------------------------------------------------------- */ + + // Support: IE<8 + // Verify that getAttribute really returns attributes and not properties + // (excepting IE8 booleans) + support.attributes = assert( function( el ) { + el.className = "i"; + return !el.getAttribute( "className" ); + } ); + + /* getElement(s)By* + ---------------------------------------------------------------------- */ + + // Check if getElementsByTagName("*") returns only elements + support.getElementsByTagName = assert( function( el ) { + el.appendChild( document.createComment( "" ) ); + return !el.getElementsByTagName( "*" ).length; + } ); + + // Support: IE<9 + support.getElementsByClassName = rnative.test( document.getElementsByClassName ); + + // Support: IE<10 + // Check if getElementById returns elements by name + // The broken getElementById methods don't pick up programmatically-set names, + // so use a roundabout getElementsByName test + support.getById = assert( function( el ) { + docElem.appendChild( el ).id = expando; + return !document.getElementsByName || !document.getElementsByName( expando ).length; + } ); + + // ID filter and find + if ( support.getById ) { + Expr.filter[ "ID" ] = function( id ) { + var attrId = id.replace( runescape, funescape ); + return function( elem ) { + return elem.getAttribute( "id" ) === attrId; + }; + }; + Expr.find[ "ID" ] = function( id, context ) { + if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { + var elem = context.getElementById( id ); + return elem ? [ elem ] : []; + } + }; + } else { + Expr.filter[ "ID" ] = function( id ) { + var attrId = id.replace( runescape, funescape ); + return function( elem ) { + var node = typeof elem.getAttributeNode !== "undefined" && + elem.getAttributeNode( "id" ); + return node && node.value === attrId; + }; + }; + + // Support: IE 6 - 7 only + // getElementById is not reliable as a find shortcut + Expr.find[ "ID" ] = function( id, context ) { + if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { + var node, i, elems, + elem = context.getElementById( id ); + + if ( elem ) { + + // Verify the id attribute + node = elem.getAttributeNode( "id" ); + if ( node && node.value === id ) { + return [ elem ]; + } + + // Fall back on getElementsByName + elems = context.getElementsByName( id ); + i = 0; + while ( ( elem = elems[ i++ ] ) ) { + node = elem.getAttributeNode( "id" ); + if ( node && node.value === id ) { + return [ elem ]; + } + } + } + + return []; + } + }; + } + + // Tag + Expr.find[ "TAG" ] = support.getElementsByTagName ? + function( tag, context ) { + if ( typeof context.getElementsByTagName !== "undefined" ) { + return context.getElementsByTagName( tag ); + + // DocumentFragment nodes don't have gEBTN + } else if ( support.qsa ) { + return context.querySelectorAll( tag ); + } + } : + + function( tag, context ) { + var elem, + tmp = [], + i = 0, + + // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too + results = context.getElementsByTagName( tag ); + + // Filter out possible comments + if ( tag === "*" ) { + while ( ( elem = results[ i++ ] ) ) { + if ( elem.nodeType === 1 ) { + tmp.push( elem ); + } + } + + return tmp; + } + return results; + }; + + // Class + Expr.find[ "CLASS" ] = support.getElementsByClassName && function( className, context ) { + if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) { + return context.getElementsByClassName( className ); + } + }; + + /* QSA/matchesSelector + ---------------------------------------------------------------------- */ + + // QSA and matchesSelector support + + // matchesSelector(:active) reports false when true (IE9/Opera 11.5) + rbuggyMatches = []; + + // qSa(:focus) reports false when true (Chrome 21) + // We allow this because of a bug in IE8/9 that throws an error + // whenever `document.activeElement` is accessed on an iframe + // So, we allow :focus to pass through QSA all the time to avoid the IE error + // See https://bugs.jquery.com/ticket/13378 + rbuggyQSA = []; + + if ( ( support.qsa = rnative.test( document.querySelectorAll ) ) ) { + + // Build QSA regex + // Regex strategy adopted from Diego Perini + assert( function( el ) { + + var input; + + // Select is set to empty string on purpose + // This is to test IE's treatment of not explicitly + // setting a boolean content attribute, + // since its presence should be enough + // https://bugs.jquery.com/ticket/12359 + docElem.appendChild( el ).innerHTML = "" + + ""; + + // Support: IE8, Opera 11-12.16 + // Nothing should be selected when empty strings follow ^= or $= or *= + // The test attribute must be unknown in Opera but "safe" for WinRT + // https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section + if ( el.querySelectorAll( "[msallowcapture^='']" ).length ) { + rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" ); + } + + // Support: IE8 + // Boolean attributes and "value" are not treated correctly + if ( !el.querySelectorAll( "[selected]" ).length ) { + rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" ); + } + + // Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+ + if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) { + rbuggyQSA.push( "~=" ); + } + + // Support: IE 11+, Edge 15 - 18+ + // IE 11/Edge don't find elements on a `[name='']` query in some cases. + // Adding a temporary attribute to the document before the selection works + // around the issue. + // Interestingly, IE 10 & older don't seem to have the issue. + input = document.createElement( "input" ); + input.setAttribute( "name", "" ); + el.appendChild( input ); + if ( !el.querySelectorAll( "[name='']" ).length ) { + rbuggyQSA.push( "\\[" + whitespace + "*name" + whitespace + "*=" + + whitespace + "*(?:''|\"\")" ); + } + + // Webkit/Opera - :checked should return selected option elements + // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked + // IE8 throws error here and will not see later tests + if ( !el.querySelectorAll( ":checked" ).length ) { + rbuggyQSA.push( ":checked" ); + } + + // Support: Safari 8+, iOS 8+ + // https://bugs.webkit.org/show_bug.cgi?id=136851 + // In-page `selector#id sibling-combinator selector` fails + if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) { + rbuggyQSA.push( ".#.+[+~]" ); + } + + // Support: Firefox <=3.6 - 5 only + // Old Firefox doesn't throw on a badly-escaped identifier. + el.querySelectorAll( "\\\f" ); + rbuggyQSA.push( "[\\r\\n\\f]" ); + } ); + + assert( function( el ) { + el.innerHTML = "" + + ""; + + // Support: Windows 8 Native Apps + // The type and name attributes are restricted during .innerHTML assignment + var input = document.createElement( "input" ); + input.setAttribute( "type", "hidden" ); + el.appendChild( input ).setAttribute( "name", "D" ); + + // Support: IE8 + // Enforce case-sensitivity of name attribute + if ( el.querySelectorAll( "[name=d]" ).length ) { + rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" ); + } + + // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled) + // IE8 throws error here and will not see later tests + if ( el.querySelectorAll( ":enabled" ).length !== 2 ) { + rbuggyQSA.push( ":enabled", ":disabled" ); + } + + // Support: IE9-11+ + // IE's :disabled selector does not pick up the children of disabled fieldsets + docElem.appendChild( el ).disabled = true; + if ( el.querySelectorAll( ":disabled" ).length !== 2 ) { + rbuggyQSA.push( ":enabled", ":disabled" ); + } + + // Support: Opera 10 - 11 only + // Opera 10-11 does not throw on post-comma invalid pseudos + el.querySelectorAll( "*,:x" ); + rbuggyQSA.push( ",.*:" ); + } ); + } + + if ( ( support.matchesSelector = rnative.test( ( matches = docElem.matches || + docElem.webkitMatchesSelector || + docElem.mozMatchesSelector || + docElem.oMatchesSelector || + docElem.msMatchesSelector ) ) ) ) { + + assert( function( el ) { + + // Check to see if it's possible to do matchesSelector + // on a disconnected node (IE 9) + support.disconnectedMatch = matches.call( el, "*" ); + + // This should fail with an exception + // Gecko does not error, returns false instead + matches.call( el, "[s!='']:x" ); + rbuggyMatches.push( "!=", pseudos ); + } ); + } + + rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( "|" ) ); + rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join( "|" ) ); + + /* Contains + ---------------------------------------------------------------------- */ + hasCompare = rnative.test( docElem.compareDocumentPosition ); + + // Element contains another + // Purposefully self-exclusive + // As in, an element does not contain itself + contains = hasCompare || rnative.test( docElem.contains ) ? + function( a, b ) { + var adown = a.nodeType === 9 ? a.documentElement : a, + bup = b && b.parentNode; + return a === bup || !!( bup && bup.nodeType === 1 && ( + adown.contains ? + adown.contains( bup ) : + a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16 + ) ); + } : + function( a, b ) { + if ( b ) { + while ( ( b = b.parentNode ) ) { + if ( b === a ) { + return true; + } + } + } + return false; + }; + + /* Sorting + ---------------------------------------------------------------------- */ + + // Document order sorting + sortOrder = hasCompare ? + function( a, b ) { + + // Flag for duplicate removal + if ( a === b ) { + hasDuplicate = true; + return 0; + } + + // Sort on method existence if only one input has compareDocumentPosition + var compare = !a.compareDocumentPosition - !b.compareDocumentPosition; + if ( compare ) { + return compare; + } + + // Calculate position if both inputs belong to the same document + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + compare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ? + a.compareDocumentPosition( b ) : + + // Otherwise we know they are disconnected + 1; + + // Disconnected nodes + if ( compare & 1 || + ( !support.sortDetached && b.compareDocumentPosition( a ) === compare ) ) { + + // Choose the first element that is related to our preferred document + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + if ( a == document || a.ownerDocument == preferredDoc && + contains( preferredDoc, a ) ) { + return -1; + } + + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + if ( b == document || b.ownerDocument == preferredDoc && + contains( preferredDoc, b ) ) { + return 1; + } + + // Maintain original order + return sortInput ? + ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) : + 0; + } + + return compare & 4 ? -1 : 1; + } : + function( a, b ) { + + // Exit early if the nodes are identical + if ( a === b ) { + hasDuplicate = true; + return 0; + } + + var cur, + i = 0, + aup = a.parentNode, + bup = b.parentNode, + ap = [ a ], + bp = [ b ]; + + // Parentless nodes are either documents or disconnected + if ( !aup || !bup ) { + + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + /* eslint-disable eqeqeq */ + return a == document ? -1 : + b == document ? 1 : + /* eslint-enable eqeqeq */ + aup ? -1 : + bup ? 1 : + sortInput ? + ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) : + 0; + + // If the nodes are siblings, we can do a quick check + } else if ( aup === bup ) { + return siblingCheck( a, b ); + } + + // Otherwise we need full lists of their ancestors for comparison + cur = a; + while ( ( cur = cur.parentNode ) ) { + ap.unshift( cur ); + } + cur = b; + while ( ( cur = cur.parentNode ) ) { + bp.unshift( cur ); + } + + // Walk down the tree looking for a discrepancy + while ( ap[ i ] === bp[ i ] ) { + i++; + } + + return i ? + + // Do a sibling check if the nodes have a common ancestor + siblingCheck( ap[ i ], bp[ i ] ) : + + // Otherwise nodes in our document sort first + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + /* eslint-disable eqeqeq */ + ap[ i ] == preferredDoc ? -1 : + bp[ i ] == preferredDoc ? 1 : + /* eslint-enable eqeqeq */ + 0; + }; + + return document; +}; + +Sizzle.matches = function( expr, elements ) { + return Sizzle( expr, null, null, elements ); +}; + +Sizzle.matchesSelector = function( elem, expr ) { + setDocument( elem ); + + if ( support.matchesSelector && documentIsHTML && + !nonnativeSelectorCache[ expr + " " ] && + ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) && + ( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) { + + try { + var ret = matches.call( elem, expr ); + + // IE 9's matchesSelector returns false on disconnected nodes + if ( ret || support.disconnectedMatch || + + // As well, disconnected nodes are said to be in a document + // fragment in IE 9 + elem.document && elem.document.nodeType !== 11 ) { + return ret; + } + } catch ( e ) { + nonnativeSelectorCache( expr, true ); + } + } + + return Sizzle( expr, document, null, [ elem ] ).length > 0; +}; + +Sizzle.contains = function( context, elem ) { + + // Set document vars if needed + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + if ( ( context.ownerDocument || context ) != document ) { + setDocument( context ); + } + return contains( context, elem ); +}; + +Sizzle.attr = function( elem, name ) { + + // Set document vars if needed + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + if ( ( elem.ownerDocument || elem ) != document ) { + setDocument( elem ); + } + + var fn = Expr.attrHandle[ name.toLowerCase() ], + + // Don't get fooled by Object.prototype properties (jQuery #13807) + val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ? + fn( elem, name, !documentIsHTML ) : + undefined; + + return val !== undefined ? + val : + support.attributes || !documentIsHTML ? + elem.getAttribute( name ) : + ( val = elem.getAttributeNode( name ) ) && val.specified ? + val.value : + null; +}; + +Sizzle.escape = function( sel ) { + return ( sel + "" ).replace( rcssescape, fcssescape ); +}; + +Sizzle.error = function( msg ) { + throw new Error( "Syntax error, unrecognized expression: " + msg ); +}; + +/** + * Document sorting and removing duplicates + * @param {ArrayLike} results + */ +Sizzle.uniqueSort = function( results ) { + var elem, + duplicates = [], + j = 0, + i = 0; + + // Unless we *know* we can detect duplicates, assume their presence + hasDuplicate = !support.detectDuplicates; + sortInput = !support.sortStable && results.slice( 0 ); + results.sort( sortOrder ); + + if ( hasDuplicate ) { + while ( ( elem = results[ i++ ] ) ) { + if ( elem === results[ i ] ) { + j = duplicates.push( i ); + } + } + while ( j-- ) { + results.splice( duplicates[ j ], 1 ); + } + } + + // Clear input after sorting to release objects + // See https://github.com/jquery/sizzle/pull/225 + sortInput = null; + + return results; +}; + +/** + * Utility function for retrieving the text value of an array of DOM nodes + * @param {Array|Element} elem + */ +getText = Sizzle.getText = function( elem ) { + var node, + ret = "", + i = 0, + nodeType = elem.nodeType; + + if ( !nodeType ) { + + // If no nodeType, this is expected to be an array + while ( ( node = elem[ i++ ] ) ) { + + // Do not traverse comment nodes + ret += getText( node ); + } + } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) { + + // Use textContent for elements + // innerText usage removed for consistency of new lines (jQuery #11153) + if ( typeof elem.textContent === "string" ) { + return elem.textContent; + } else { + + // Traverse its children + for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { + ret += getText( elem ); + } + } + } else if ( nodeType === 3 || nodeType === 4 ) { + return elem.nodeValue; + } + + // Do not include comment or processing instruction nodes + + return ret; +}; + +Expr = Sizzle.selectors = { + + // Can be adjusted by the user + cacheLength: 50, + + createPseudo: markFunction, + + match: matchExpr, + + attrHandle: {}, + + find: {}, + + relative: { + ">": { dir: "parentNode", first: true }, + " ": { dir: "parentNode" }, + "+": { dir: "previousSibling", first: true }, + "~": { dir: "previousSibling" } + }, + + preFilter: { + "ATTR": function( match ) { + match[ 1 ] = match[ 1 ].replace( runescape, funescape ); + + // Move the given value to match[3] whether quoted or unquoted + match[ 3 ] = ( match[ 3 ] || match[ 4 ] || + match[ 5 ] || "" ).replace( runescape, funescape ); + + if ( match[ 2 ] === "~=" ) { + match[ 3 ] = " " + match[ 3 ] + " "; + } + + return match.slice( 0, 4 ); + }, + + "CHILD": function( match ) { + + /* matches from matchExpr["CHILD"] + 1 type (only|nth|...) + 2 what (child|of-type) + 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...) + 4 xn-component of xn+y argument ([+-]?\d*n|) + 5 sign of xn-component + 6 x of xn-component + 7 sign of y-component + 8 y of y-component + */ + match[ 1 ] = match[ 1 ].toLowerCase(); + + if ( match[ 1 ].slice( 0, 3 ) === "nth" ) { + + // nth-* requires argument + if ( !match[ 3 ] ) { + Sizzle.error( match[ 0 ] ); + } + + // numeric x and y parameters for Expr.filter.CHILD + // remember that false/true cast respectively to 0/1 + match[ 4 ] = +( match[ 4 ] ? + match[ 5 ] + ( match[ 6 ] || 1 ) : + 2 * ( match[ 3 ] === "even" || match[ 3 ] === "odd" ) ); + match[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === "odd" ); + + // other types prohibit arguments + } else if ( match[ 3 ] ) { + Sizzle.error( match[ 0 ] ); + } + + return match; + }, + + "PSEUDO": function( match ) { + var excess, + unquoted = !match[ 6 ] && match[ 2 ]; + + if ( matchExpr[ "CHILD" ].test( match[ 0 ] ) ) { + return null; + } + + // Accept quoted arguments as-is + if ( match[ 3 ] ) { + match[ 2 ] = match[ 4 ] || match[ 5 ] || ""; + + // Strip excess characters from unquoted arguments + } else if ( unquoted && rpseudo.test( unquoted ) && + + // Get excess from tokenize (recursively) + ( excess = tokenize( unquoted, true ) ) && + + // advance to the next closing parenthesis + ( excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length ) ) { + + // excess is a negative index + match[ 0 ] = match[ 0 ].slice( 0, excess ); + match[ 2 ] = unquoted.slice( 0, excess ); + } + + // Return only captures needed by the pseudo filter method (type and argument) + return match.slice( 0, 3 ); + } + }, + + filter: { + + "TAG": function( nodeNameSelector ) { + var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase(); + return nodeNameSelector === "*" ? + function() { + return true; + } : + function( elem ) { + return elem.nodeName && elem.nodeName.toLowerCase() === nodeName; + }; + }, + + "CLASS": function( className ) { + var pattern = classCache[ className + " " ]; + + return pattern || + ( pattern = new RegExp( "(^|" + whitespace + + ")" + className + "(" + whitespace + "|$)" ) ) && classCache( + className, function( elem ) { + return pattern.test( + typeof elem.className === "string" && elem.className || + typeof elem.getAttribute !== "undefined" && + elem.getAttribute( "class" ) || + "" + ); + } ); + }, + + "ATTR": function( name, operator, check ) { + return function( elem ) { + var result = Sizzle.attr( elem, name ); + + if ( result == null ) { + return operator === "!="; + } + if ( !operator ) { + return true; + } + + result += ""; + + /* eslint-disable max-len */ + + return operator === "=" ? result === check : + operator === "!=" ? result !== check : + operator === "^=" ? check && result.indexOf( check ) === 0 : + operator === "*=" ? check && result.indexOf( check ) > -1 : + operator === "$=" ? check && result.slice( -check.length ) === check : + operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 : + operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" : + false; + /* eslint-enable max-len */ + + }; + }, + + "CHILD": function( type, what, _argument, first, last ) { + var simple = type.slice( 0, 3 ) !== "nth", + forward = type.slice( -4 ) !== "last", + ofType = what === "of-type"; + + return first === 1 && last === 0 ? + + // Shortcut for :nth-*(n) + function( elem ) { + return !!elem.parentNode; + } : + + function( elem, _context, xml ) { + var cache, uniqueCache, outerCache, node, nodeIndex, start, + dir = simple !== forward ? "nextSibling" : "previousSibling", + parent = elem.parentNode, + name = ofType && elem.nodeName.toLowerCase(), + useCache = !xml && !ofType, + diff = false; + + if ( parent ) { + + // :(first|last|only)-(child|of-type) + if ( simple ) { + while ( dir ) { + node = elem; + while ( ( node = node[ dir ] ) ) { + if ( ofType ? + node.nodeName.toLowerCase() === name : + node.nodeType === 1 ) { + + return false; + } + } + + // Reverse direction for :only-* (if we haven't yet done so) + start = dir = type === "only" && !start && "nextSibling"; + } + return true; + } + + start = [ forward ? parent.firstChild : parent.lastChild ]; + + // non-xml :nth-child(...) stores cache data on `parent` + if ( forward && useCache ) { + + // Seek `elem` from a previously-cached index + + // ...in a gzip-friendly way + node = parent; + outerCache = node[ expando ] || ( node[ expando ] = {} ); + + // Support: IE <9 only + // Defend against cloned attroperties (jQuery gh-1709) + uniqueCache = outerCache[ node.uniqueID ] || + ( outerCache[ node.uniqueID ] = {} ); + + cache = uniqueCache[ type ] || []; + nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; + diff = nodeIndex && cache[ 2 ]; + node = nodeIndex && parent.childNodes[ nodeIndex ]; + + while ( ( node = ++nodeIndex && node && node[ dir ] || + + // Fallback to seeking `elem` from the start + ( diff = nodeIndex = 0 ) || start.pop() ) ) { + + // When found, cache indexes on `parent` and break + if ( node.nodeType === 1 && ++diff && node === elem ) { + uniqueCache[ type ] = [ dirruns, nodeIndex, diff ]; + break; + } + } + + } else { + + // Use previously-cached element index if available + if ( useCache ) { + + // ...in a gzip-friendly way + node = elem; + outerCache = node[ expando ] || ( node[ expando ] = {} ); + + // Support: IE <9 only + // Defend against cloned attroperties (jQuery gh-1709) + uniqueCache = outerCache[ node.uniqueID ] || + ( outerCache[ node.uniqueID ] = {} ); + + cache = uniqueCache[ type ] || []; + nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; + diff = nodeIndex; + } + + // xml :nth-child(...) + // or :nth-last-child(...) or :nth(-last)?-of-type(...) + if ( diff === false ) { + + // Use the same loop as above to seek `elem` from the start + while ( ( node = ++nodeIndex && node && node[ dir ] || + ( diff = nodeIndex = 0 ) || start.pop() ) ) { + + if ( ( ofType ? + node.nodeName.toLowerCase() === name : + node.nodeType === 1 ) && + ++diff ) { + + // Cache the index of each encountered element + if ( useCache ) { + outerCache = node[ expando ] || + ( node[ expando ] = {} ); + + // Support: IE <9 only + // Defend against cloned attroperties (jQuery gh-1709) + uniqueCache = outerCache[ node.uniqueID ] || + ( outerCache[ node.uniqueID ] = {} ); + + uniqueCache[ type ] = [ dirruns, diff ]; + } + + if ( node === elem ) { + break; + } + } + } + } + } + + // Incorporate the offset, then check against cycle size + diff -= last; + return diff === first || ( diff % first === 0 && diff / first >= 0 ); + } + }; + }, + + "PSEUDO": function( pseudo, argument ) { + + // pseudo-class names are case-insensitive + // http://www.w3.org/TR/selectors/#pseudo-classes + // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters + // Remember that setFilters inherits from pseudos + var args, + fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] || + Sizzle.error( "unsupported pseudo: " + pseudo ); + + // The user may use createPseudo to indicate that + // arguments are needed to create the filter function + // just as Sizzle does + if ( fn[ expando ] ) { + return fn( argument ); + } + + // But maintain support for old signatures + if ( fn.length > 1 ) { + args = [ pseudo, pseudo, "", argument ]; + return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ? + markFunction( function( seed, matches ) { + var idx, + matched = fn( seed, argument ), + i = matched.length; + while ( i-- ) { + idx = indexOf( seed, matched[ i ] ); + seed[ idx ] = !( matches[ idx ] = matched[ i ] ); + } + } ) : + function( elem ) { + return fn( elem, 0, args ); + }; + } + + return fn; + } + }, + + pseudos: { + + // Potentially complex pseudos + "not": markFunction( function( selector ) { + + // Trim the selector passed to compile + // to avoid treating leading and trailing + // spaces as combinators + var input = [], + results = [], + matcher = compile( selector.replace( rtrim, "$1" ) ); + + return matcher[ expando ] ? + markFunction( function( seed, matches, _context, xml ) { + var elem, + unmatched = matcher( seed, null, xml, [] ), + i = seed.length; + + // Match elements unmatched by `matcher` + while ( i-- ) { + if ( ( elem = unmatched[ i ] ) ) { + seed[ i ] = !( matches[ i ] = elem ); + } + } + } ) : + function( elem, _context, xml ) { + input[ 0 ] = elem; + matcher( input, null, xml, results ); + + // Don't keep the element (issue #299) + input[ 0 ] = null; + return !results.pop(); + }; + } ), + + "has": markFunction( function( selector ) { + return function( elem ) { + return Sizzle( selector, elem ).length > 0; + }; + } ), + + "contains": markFunction( function( text ) { + text = text.replace( runescape, funescape ); + return function( elem ) { + return ( elem.textContent || getText( elem ) ).indexOf( text ) > -1; + }; + } ), + + // "Whether an element is represented by a :lang() selector + // is based solely on the element's language value + // being equal to the identifier C, + // or beginning with the identifier C immediately followed by "-". + // The matching of C against the element's language value is performed case-insensitively. + // The identifier C does not have to be a valid language name." + // http://www.w3.org/TR/selectors/#lang-pseudo + "lang": markFunction( function( lang ) { + + // lang value must be a valid identifier + if ( !ridentifier.test( lang || "" ) ) { + Sizzle.error( "unsupported lang: " + lang ); + } + lang = lang.replace( runescape, funescape ).toLowerCase(); + return function( elem ) { + var elemLang; + do { + if ( ( elemLang = documentIsHTML ? + elem.lang : + elem.getAttribute( "xml:lang" ) || elem.getAttribute( "lang" ) ) ) { + + elemLang = elemLang.toLowerCase(); + return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0; + } + } while ( ( elem = elem.parentNode ) && elem.nodeType === 1 ); + return false; + }; + } ), + + // Miscellaneous + "target": function( elem ) { + var hash = window.location && window.location.hash; + return hash && hash.slice( 1 ) === elem.id; + }, + + "root": function( elem ) { + return elem === docElem; + }, + + "focus": function( elem ) { + return elem === document.activeElement && + ( !document.hasFocus || document.hasFocus() ) && + !!( elem.type || elem.href || ~elem.tabIndex ); + }, + + // Boolean properties + "enabled": createDisabledPseudo( false ), + "disabled": createDisabledPseudo( true ), + + "checked": function( elem ) { + + // In CSS3, :checked should return both checked and selected elements + // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked + var nodeName = elem.nodeName.toLowerCase(); + return ( nodeName === "input" && !!elem.checked ) || + ( nodeName === "option" && !!elem.selected ); + }, + + "selected": function( elem ) { + + // Accessing this property makes selected-by-default + // options in Safari work properly + if ( elem.parentNode ) { + // eslint-disable-next-line no-unused-expressions + elem.parentNode.selectedIndex; + } + + return elem.selected === true; + }, + + // Contents + "empty": function( elem ) { + + // http://www.w3.org/TR/selectors/#empty-pseudo + // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5), + // but not by others (comment: 8; processing instruction: 7; etc.) + // nodeType < 6 works because attributes (2) do not appear as children + for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { + if ( elem.nodeType < 6 ) { + return false; + } + } + return true; + }, + + "parent": function( elem ) { + return !Expr.pseudos[ "empty" ]( elem ); + }, + + // Element/input types + "header": function( elem ) { + return rheader.test( elem.nodeName ); + }, + + "input": function( elem ) { + return rinputs.test( elem.nodeName ); + }, + + "button": function( elem ) { + var name = elem.nodeName.toLowerCase(); + return name === "input" && elem.type === "button" || name === "button"; + }, + + "text": function( elem ) { + var attr; + return elem.nodeName.toLowerCase() === "input" && + elem.type === "text" && + + // Support: IE<8 + // New HTML5 attribute values (e.g., "search") appear with elem.type === "text" + ( ( attr = elem.getAttribute( "type" ) ) == null || + attr.toLowerCase() === "text" ); + }, + + // Position-in-collection + "first": createPositionalPseudo( function() { + return [ 0 ]; + } ), + + "last": createPositionalPseudo( function( _matchIndexes, length ) { + return [ length - 1 ]; + } ), + + "eq": createPositionalPseudo( function( _matchIndexes, length, argument ) { + return [ argument < 0 ? argument + length : argument ]; + } ), + + "even": createPositionalPseudo( function( matchIndexes, length ) { + var i = 0; + for ( ; i < length; i += 2 ) { + matchIndexes.push( i ); + } + return matchIndexes; + } ), + + "odd": createPositionalPseudo( function( matchIndexes, length ) { + var i = 1; + for ( ; i < length; i += 2 ) { + matchIndexes.push( i ); + } + return matchIndexes; + } ), + + "lt": createPositionalPseudo( function( matchIndexes, length, argument ) { + var i = argument < 0 ? + argument + length : + argument > length ? + length : + argument; + for ( ; --i >= 0; ) { + matchIndexes.push( i ); + } + return matchIndexes; + } ), + + "gt": createPositionalPseudo( function( matchIndexes, length, argument ) { + var i = argument < 0 ? argument + length : argument; + for ( ; ++i < length; ) { + matchIndexes.push( i ); + } + return matchIndexes; + } ) + } +}; + +Expr.pseudos[ "nth" ] = Expr.pseudos[ "eq" ]; + +// Add button/input type pseudos +for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) { + Expr.pseudos[ i ] = createInputPseudo( i ); +} +for ( i in { submit: true, reset: true } ) { + Expr.pseudos[ i ] = createButtonPseudo( i ); +} + +// Easy API for creating new setFilters +function setFilters() {} +setFilters.prototype = Expr.filters = Expr.pseudos; +Expr.setFilters = new setFilters(); + +tokenize = Sizzle.tokenize = function( selector, parseOnly ) { + var matched, match, tokens, type, + soFar, groups, preFilters, + cached = tokenCache[ selector + " " ]; + + if ( cached ) { + return parseOnly ? 0 : cached.slice( 0 ); + } + + soFar = selector; + groups = []; + preFilters = Expr.preFilter; + + while ( soFar ) { + + // Comma and first run + if ( !matched || ( match = rcomma.exec( soFar ) ) ) { + if ( match ) { + + // Don't consume trailing commas as valid + soFar = soFar.slice( match[ 0 ].length ) || soFar; + } + groups.push( ( tokens = [] ) ); + } + + matched = false; + + // Combinators + if ( ( match = rcombinators.exec( soFar ) ) ) { + matched = match.shift(); + tokens.push( { + value: matched, + + // Cast descendant combinators to space + type: match[ 0 ].replace( rtrim, " " ) + } ); + soFar = soFar.slice( matched.length ); + } + + // Filters + for ( type in Expr.filter ) { + if ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] || + ( match = preFilters[ type ]( match ) ) ) ) { + matched = match.shift(); + tokens.push( { + value: matched, + type: type, + matches: match + } ); + soFar = soFar.slice( matched.length ); + } + } + + if ( !matched ) { + break; + } + } + + // Return the length of the invalid excess + // if we're just parsing + // Otherwise, throw an error or return tokens + return parseOnly ? + soFar.length : + soFar ? + Sizzle.error( selector ) : + + // Cache the tokens + tokenCache( selector, groups ).slice( 0 ); +}; + +function toSelector( tokens ) { + var i = 0, + len = tokens.length, + selector = ""; + for ( ; i < len; i++ ) { + selector += tokens[ i ].value; + } + return selector; +} + +function addCombinator( matcher, combinator, base ) { + var dir = combinator.dir, + skip = combinator.next, + key = skip || dir, + checkNonElements = base && key === "parentNode", + doneName = done++; + + return combinator.first ? + + // Check against closest ancestor/preceding element + function( elem, context, xml ) { + while ( ( elem = elem[ dir ] ) ) { + if ( elem.nodeType === 1 || checkNonElements ) { + return matcher( elem, context, xml ); + } + } + return false; + } : + + // Check against all ancestor/preceding elements + function( elem, context, xml ) { + var oldCache, uniqueCache, outerCache, + newCache = [ dirruns, doneName ]; + + // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching + if ( xml ) { + while ( ( elem = elem[ dir ] ) ) { + if ( elem.nodeType === 1 || checkNonElements ) { + if ( matcher( elem, context, xml ) ) { + return true; + } + } + } + } else { + while ( ( elem = elem[ dir ] ) ) { + if ( elem.nodeType === 1 || checkNonElements ) { + outerCache = elem[ expando ] || ( elem[ expando ] = {} ); + + // Support: IE <9 only + // Defend against cloned attroperties (jQuery gh-1709) + uniqueCache = outerCache[ elem.uniqueID ] || + ( outerCache[ elem.uniqueID ] = {} ); + + if ( skip && skip === elem.nodeName.toLowerCase() ) { + elem = elem[ dir ] || elem; + } else if ( ( oldCache = uniqueCache[ key ] ) && + oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) { + + // Assign to newCache so results back-propagate to previous elements + return ( newCache[ 2 ] = oldCache[ 2 ] ); + } else { + + // Reuse newcache so results back-propagate to previous elements + uniqueCache[ key ] = newCache; + + // A match means we're done; a fail means we have to keep checking + if ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) { + return true; + } + } + } + } + } + return false; + }; +} + +function elementMatcher( matchers ) { + return matchers.length > 1 ? + function( elem, context, xml ) { + var i = matchers.length; + while ( i-- ) { + if ( !matchers[ i ]( elem, context, xml ) ) { + return false; + } + } + return true; + } : + matchers[ 0 ]; +} + +function multipleContexts( selector, contexts, results ) { + var i = 0, + len = contexts.length; + for ( ; i < len; i++ ) { + Sizzle( selector, contexts[ i ], results ); + } + return results; +} + +function condense( unmatched, map, filter, context, xml ) { + var elem, + newUnmatched = [], + i = 0, + len = unmatched.length, + mapped = map != null; + + for ( ; i < len; i++ ) { + if ( ( elem = unmatched[ i ] ) ) { + if ( !filter || filter( elem, context, xml ) ) { + newUnmatched.push( elem ); + if ( mapped ) { + map.push( i ); + } + } + } + } + + return newUnmatched; +} + +function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) { + if ( postFilter && !postFilter[ expando ] ) { + postFilter = setMatcher( postFilter ); + } + if ( postFinder && !postFinder[ expando ] ) { + postFinder = setMatcher( postFinder, postSelector ); + } + return markFunction( function( seed, results, context, xml ) { + var temp, i, elem, + preMap = [], + postMap = [], + preexisting = results.length, + + // Get initial elements from seed or context + elems = seed || multipleContexts( + selector || "*", + context.nodeType ? [ context ] : context, + [] + ), + + // Prefilter to get matcher input, preserving a map for seed-results synchronization + matcherIn = preFilter && ( seed || !selector ) ? + condense( elems, preMap, preFilter, context, xml ) : + elems, + + matcherOut = matcher ? + + // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results, + postFinder || ( seed ? preFilter : preexisting || postFilter ) ? + + // ...intermediate processing is necessary + [] : + + // ...otherwise use results directly + results : + matcherIn; + + // Find primary matches + if ( matcher ) { + matcher( matcherIn, matcherOut, context, xml ); + } + + // Apply postFilter + if ( postFilter ) { + temp = condense( matcherOut, postMap ); + postFilter( temp, [], context, xml ); + + // Un-match failing elements by moving them back to matcherIn + i = temp.length; + while ( i-- ) { + if ( ( elem = temp[ i ] ) ) { + matcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem ); + } + } + } + + if ( seed ) { + if ( postFinder || preFilter ) { + if ( postFinder ) { + + // Get the final matcherOut by condensing this intermediate into postFinder contexts + temp = []; + i = matcherOut.length; + while ( i-- ) { + if ( ( elem = matcherOut[ i ] ) ) { + + // Restore matcherIn since elem is not yet a final match + temp.push( ( matcherIn[ i ] = elem ) ); + } + } + postFinder( null, ( matcherOut = [] ), temp, xml ); + } + + // Move matched elements from seed to results to keep them synchronized + i = matcherOut.length; + while ( i-- ) { + if ( ( elem = matcherOut[ i ] ) && + ( temp = postFinder ? indexOf( seed, elem ) : preMap[ i ] ) > -1 ) { + + seed[ temp ] = !( results[ temp ] = elem ); + } + } + } + + // Add elements to results, through postFinder if defined + } else { + matcherOut = condense( + matcherOut === results ? + matcherOut.splice( preexisting, matcherOut.length ) : + matcherOut + ); + if ( postFinder ) { + postFinder( null, results, matcherOut, xml ); + } else { + push.apply( results, matcherOut ); + } + } + } ); +} + +function matcherFromTokens( tokens ) { + var checkContext, matcher, j, + len = tokens.length, + leadingRelative = Expr.relative[ tokens[ 0 ].type ], + implicitRelative = leadingRelative || Expr.relative[ " " ], + i = leadingRelative ? 1 : 0, + + // The foundational matcher ensures that elements are reachable from top-level context(s) + matchContext = addCombinator( function( elem ) { + return elem === checkContext; + }, implicitRelative, true ), + matchAnyContext = addCombinator( function( elem ) { + return indexOf( checkContext, elem ) > -1; + }, implicitRelative, true ), + matchers = [ function( elem, context, xml ) { + var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || ( + ( checkContext = context ).nodeType ? + matchContext( elem, context, xml ) : + matchAnyContext( elem, context, xml ) ); + + // Avoid hanging onto element (issue #299) + checkContext = null; + return ret; + } ]; + + for ( ; i < len; i++ ) { + if ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) { + matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ]; + } else { + matcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches ); + + // Return special upon seeing a positional matcher + if ( matcher[ expando ] ) { + + // Find the next relative operator (if any) for proper handling + j = ++i; + for ( ; j < len; j++ ) { + if ( Expr.relative[ tokens[ j ].type ] ) { + break; + } + } + return setMatcher( + i > 1 && elementMatcher( matchers ), + i > 1 && toSelector( + + // If the preceding token was a descendant combinator, insert an implicit any-element `*` + tokens + .slice( 0, i - 1 ) + .concat( { value: tokens[ i - 2 ].type === " " ? "*" : "" } ) + ).replace( rtrim, "$1" ), + matcher, + i < j && matcherFromTokens( tokens.slice( i, j ) ), + j < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ), + j < len && toSelector( tokens ) + ); + } + matchers.push( matcher ); + } + } + + return elementMatcher( matchers ); +} + +function matcherFromGroupMatchers( elementMatchers, setMatchers ) { + var bySet = setMatchers.length > 0, + byElement = elementMatchers.length > 0, + superMatcher = function( seed, context, xml, results, outermost ) { + var elem, j, matcher, + matchedCount = 0, + i = "0", + unmatched = seed && [], + setMatched = [], + contextBackup = outermostContext, + + // We must always have either seed elements or outermost context + elems = seed || byElement && Expr.find[ "TAG" ]( "*", outermost ), + + // Use integer dirruns iff this is the outermost matcher + dirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ), + len = elems.length; + + if ( outermost ) { + + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + outermostContext = context == document || context || outermost; + } + + // Add elements passing elementMatchers directly to results + // Support: IE<9, Safari + // Tolerate NodeList properties (IE: "length"; Safari: ) matching elements by id + for ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) { + if ( byElement && elem ) { + j = 0; + + // Support: IE 11+, Edge 17 - 18+ + // IE/Edge sometimes throw a "Permission denied" error when strict-comparing + // two documents; shallow comparisons work. + // eslint-disable-next-line eqeqeq + if ( !context && elem.ownerDocument != document ) { + setDocument( elem ); + xml = !documentIsHTML; + } + while ( ( matcher = elementMatchers[ j++ ] ) ) { + if ( matcher( elem, context || document, xml ) ) { + results.push( elem ); + break; + } + } + if ( outermost ) { + dirruns = dirrunsUnique; + } + } + + // Track unmatched elements for set filters + if ( bySet ) { + + // They will have gone through all possible matchers + if ( ( elem = !matcher && elem ) ) { + matchedCount--; + } + + // Lengthen the array for every element, matched or not + if ( seed ) { + unmatched.push( elem ); + } + } + } + + // `i` is now the count of elements visited above, and adding it to `matchedCount` + // makes the latter nonnegative. + matchedCount += i; + + // Apply set filters to unmatched elements + // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount` + // equals `i`), unless we didn't visit _any_ elements in the above loop because we have + // no element matchers and no seed. + // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that + // case, which will result in a "00" `matchedCount` that differs from `i` but is also + // numerically zero. + if ( bySet && i !== matchedCount ) { + j = 0; + while ( ( matcher = setMatchers[ j++ ] ) ) { + matcher( unmatched, setMatched, context, xml ); + } + + if ( seed ) { + + // Reintegrate element matches to eliminate the need for sorting + if ( matchedCount > 0 ) { + while ( i-- ) { + if ( !( unmatched[ i ] || setMatched[ i ] ) ) { + setMatched[ i ] = pop.call( results ); + } + } + } + + // Discard index placeholder values to get only actual matches + setMatched = condense( setMatched ); + } + + // Add matches to results + push.apply( results, setMatched ); + + // Seedless set matches succeeding multiple successful matchers stipulate sorting + if ( outermost && !seed && setMatched.length > 0 && + ( matchedCount + setMatchers.length ) > 1 ) { + + Sizzle.uniqueSort( results ); + } + } + + // Override manipulation of globals by nested matchers + if ( outermost ) { + dirruns = dirrunsUnique; + outermostContext = contextBackup; + } + + return unmatched; + }; + + return bySet ? + markFunction( superMatcher ) : + superMatcher; +} + +compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) { + var i, + setMatchers = [], + elementMatchers = [], + cached = compilerCache[ selector + " " ]; + + if ( !cached ) { + + // Generate a function of recursive functions that can be used to check each element + if ( !match ) { + match = tokenize( selector ); + } + i = match.length; + while ( i-- ) { + cached = matcherFromTokens( match[ i ] ); + if ( cached[ expando ] ) { + setMatchers.push( cached ); + } else { + elementMatchers.push( cached ); + } + } + + // Cache the compiled function + cached = compilerCache( + selector, + matcherFromGroupMatchers( elementMatchers, setMatchers ) + ); + + // Save selector and tokenization + cached.selector = selector; + } + return cached; +}; + +/** + * A low-level selection function that works with Sizzle's compiled + * selector functions + * @param {String|Function} selector A selector or a pre-compiled + * selector function built with Sizzle.compile + * @param {Element} context + * @param {Array} [results] + * @param {Array} [seed] A set of elements to match against + */ +select = Sizzle.select = function( selector, context, results, seed ) { + var i, tokens, token, type, find, + compiled = typeof selector === "function" && selector, + match = !seed && tokenize( ( selector = compiled.selector || selector ) ); + + results = results || []; + + // Try to minimize operations if there is only one selector in the list and no seed + // (the latter of which guarantees us context) + if ( match.length === 1 ) { + + // Reduce context if the leading compound selector is an ID + tokens = match[ 0 ] = match[ 0 ].slice( 0 ); + if ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === "ID" && + context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) { + + context = ( Expr.find[ "ID" ]( token.matches[ 0 ] + .replace( runescape, funescape ), context ) || [] )[ 0 ]; + if ( !context ) { + return results; + + // Precompiled matchers will still verify ancestry, so step up a level + } else if ( compiled ) { + context = context.parentNode; + } + + selector = selector.slice( tokens.shift().value.length ); + } + + // Fetch a seed set for right-to-left matching + i = matchExpr[ "needsContext" ].test( selector ) ? 0 : tokens.length; + while ( i-- ) { + token = tokens[ i ]; + + // Abort if we hit a combinator + if ( Expr.relative[ ( type = token.type ) ] ) { + break; + } + if ( ( find = Expr.find[ type ] ) ) { + + // Search, expanding context for leading sibling combinators + if ( ( seed = find( + token.matches[ 0 ].replace( runescape, funescape ), + rsibling.test( tokens[ 0 ].type ) && testContext( context.parentNode ) || + context + ) ) ) { + + // If seed is empty or no tokens remain, we can return early + tokens.splice( i, 1 ); + selector = seed.length && toSelector( tokens ); + if ( !selector ) { + push.apply( results, seed ); + return results; + } + + break; + } + } + } + } + + // Compile and execute a filtering function if one is not provided + // Provide `match` to avoid retokenization if we modified the selector above + ( compiled || compile( selector, match ) )( + seed, + context, + !documentIsHTML, + results, + !context || rsibling.test( selector ) && testContext( context.parentNode ) || context + ); + return results; +}; + +// One-time assignments + +// Sort stability +support.sortStable = expando.split( "" ).sort( sortOrder ).join( "" ) === expando; + +// Support: Chrome 14-35+ +// Always assume duplicates if they aren't passed to the comparison function +support.detectDuplicates = !!hasDuplicate; + +// Initialize against the default document +setDocument(); + +// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27) +// Detached nodes confoundingly follow *each other* +support.sortDetached = assert( function( el ) { + + // Should return 1, but returns 4 (following) + return el.compareDocumentPosition( document.createElement( "fieldset" ) ) & 1; +} ); + +// Support: IE<8 +// Prevent attribute/property "interpolation" +// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx +if ( !assert( function( el ) { + el.innerHTML = ""; + return el.firstChild.getAttribute( "href" ) === "#"; +} ) ) { + addHandle( "type|href|height|width", function( elem, name, isXML ) { + if ( !isXML ) { + return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 ); + } + } ); +} + +// Support: IE<9 +// Use defaultValue in place of getAttribute("value") +if ( !support.attributes || !assert( function( el ) { + el.innerHTML = ""; + el.firstChild.setAttribute( "value", "" ); + return el.firstChild.getAttribute( "value" ) === ""; +} ) ) { + addHandle( "value", function( elem, _name, isXML ) { + if ( !isXML && elem.nodeName.toLowerCase() === "input" ) { + return elem.defaultValue; + } + } ); +} + +// Support: IE<9 +// Use getAttributeNode to fetch booleans when getAttribute lies +if ( !assert( function( el ) { + return el.getAttribute( "disabled" ) == null; +} ) ) { + addHandle( booleans, function( elem, name, isXML ) { + var val; + if ( !isXML ) { + return elem[ name ] === true ? name.toLowerCase() : + ( val = elem.getAttributeNode( name ) ) && val.specified ? + val.value : + null; + } + } ); +} + +return Sizzle; + +} )( window ); + + + +jQuery.find = Sizzle; +jQuery.expr = Sizzle.selectors; + +// Deprecated +jQuery.expr[ ":" ] = jQuery.expr.pseudos; +jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort; +jQuery.text = Sizzle.getText; +jQuery.isXMLDoc = Sizzle.isXML; +jQuery.contains = Sizzle.contains; +jQuery.escapeSelector = Sizzle.escape; + + + + +var dir = function( elem, dir, until ) { + var matched = [], + truncate = until !== undefined; + + while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) { + if ( elem.nodeType === 1 ) { + if ( truncate && jQuery( elem ).is( until ) ) { + break; + } + matched.push( elem ); + } + } + return matched; +}; + + +var siblings = function( n, elem ) { + var matched = []; + + for ( ; n; n = n.nextSibling ) { + if ( n.nodeType === 1 && n !== elem ) { + matched.push( n ); + } + } + + return matched; +}; + + +var rneedsContext = jQuery.expr.match.needsContext; + + + +function nodeName( elem, name ) { + + return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase(); + +}; +var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i ); + + + +// Implement the identical functionality for filter and not +function winnow( elements, qualifier, not ) { + if ( isFunction( qualifier ) ) { + return jQuery.grep( elements, function( elem, i ) { + return !!qualifier.call( elem, i, elem ) !== not; + } ); + } + + // Single element + if ( qualifier.nodeType ) { + return jQuery.grep( elements, function( elem ) { + return ( elem === qualifier ) !== not; + } ); + } + + // Arraylike of elements (jQuery, arguments, Array) + if ( typeof qualifier !== "string" ) { + return jQuery.grep( elements, function( elem ) { + return ( indexOf.call( qualifier, elem ) > -1 ) !== not; + } ); + } + + // Filtered directly for both simple and complex selectors + return jQuery.filter( qualifier, elements, not ); +} + +jQuery.filter = function( expr, elems, not ) { + var elem = elems[ 0 ]; + + if ( not ) { + expr = ":not(" + expr + ")"; + } + + if ( elems.length === 1 && elem.nodeType === 1 ) { + return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : []; + } + + return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) { + return elem.nodeType === 1; + } ) ); +}; + +jQuery.fn.extend( { + find: function( selector ) { + var i, ret, + len = this.length, + self = this; + + if ( typeof selector !== "string" ) { + return this.pushStack( jQuery( selector ).filter( function() { + for ( i = 0; i < len; i++ ) { + if ( jQuery.contains( self[ i ], this ) ) { + return true; + } + } + } ) ); + } + + ret = this.pushStack( [] ); + + for ( i = 0; i < len; i++ ) { + jQuery.find( selector, self[ i ], ret ); + } + + return len > 1 ? jQuery.uniqueSort( ret ) : ret; + }, + filter: function( selector ) { + return this.pushStack( winnow( this, selector || [], false ) ); + }, + not: function( selector ) { + return this.pushStack( winnow( this, selector || [], true ) ); + }, + is: function( selector ) { + return !!winnow( + this, + + // If this is a positional/relative selector, check membership in the returned set + // so $("p:first").is("p:last") won't return true for a doc with two "p". + typeof selector === "string" && rneedsContext.test( selector ) ? + jQuery( selector ) : + selector || [], + false + ).length; + } +} ); + + +// Initialize a jQuery object + + +// A central reference to the root jQuery(document) +var rootjQuery, + + // A simple way to check for HTML strings + // Prioritize #id over to avoid XSS via location.hash (#9521) + // Strict HTML recognition (#11290: must start with <) + // Shortcut simple #id case for speed + rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/, + + init = jQuery.fn.init = function( selector, context, root ) { + var match, elem; + + // HANDLE: $(""), $(null), $(undefined), $(false) + if ( !selector ) { + return this; + } + + // Method init() accepts an alternate rootjQuery + // so migrate can support jQuery.sub (gh-2101) + root = root || rootjQuery; + + // Handle HTML strings + if ( typeof selector === "string" ) { + if ( selector[ 0 ] === "<" && + selector[ selector.length - 1 ] === ">" && + selector.length >= 3 ) { + + // Assume that strings that start and end with <> are HTML and skip the regex check + match = [ null, selector, null ]; + + } else { + match = rquickExpr.exec( selector ); + } + + // Match html or make sure no context is specified for #id + if ( match && ( match[ 1 ] || !context ) ) { + + // HANDLE: $(html) -> $(array) + if ( match[ 1 ] ) { + context = context instanceof jQuery ? context[ 0 ] : context; + + // Option to run scripts is true for back-compat + // Intentionally let the error be thrown if parseHTML is not present + jQuery.merge( this, jQuery.parseHTML( + match[ 1 ], + context && context.nodeType ? context.ownerDocument || context : document, + true + ) ); + + // HANDLE: $(html, props) + if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) { + for ( match in context ) { + + // Properties of context are called as methods if possible + if ( isFunction( this[ match ] ) ) { + this[ match ]( context[ match ] ); + + // ...and otherwise set as attributes + } else { + this.attr( match, context[ match ] ); + } + } + } + + return this; + + // HANDLE: $(#id) + } else { + elem = document.getElementById( match[ 2 ] ); + + if ( elem ) { + + // Inject the element directly into the jQuery object + this[ 0 ] = elem; + this.length = 1; + } + return this; + } + + // HANDLE: $(expr, $(...)) + } else if ( !context || context.jquery ) { + return ( context || root ).find( selector ); + + // HANDLE: $(expr, context) + // (which is just equivalent to: $(context).find(expr) + } else { + return this.constructor( context ).find( selector ); + } + + // HANDLE: $(DOMElement) + } else if ( selector.nodeType ) { + this[ 0 ] = selector; + this.length = 1; + return this; + + // HANDLE: $(function) + // Shortcut for document ready + } else if ( isFunction( selector ) ) { + return root.ready !== undefined ? + root.ready( selector ) : + + // Execute immediately if ready is not present + selector( jQuery ); + } + + return jQuery.makeArray( selector, this ); + }; + +// Give the init function the jQuery prototype for later instantiation +init.prototype = jQuery.fn; + +// Initialize central reference +rootjQuery = jQuery( document ); + + +var rparentsprev = /^(?:parents|prev(?:Until|All))/, + + // Methods guaranteed to produce a unique set when starting from a unique set + guaranteedUnique = { + children: true, + contents: true, + next: true, + prev: true + }; + +jQuery.fn.extend( { + has: function( target ) { + var targets = jQuery( target, this ), + l = targets.length; + + return this.filter( function() { + var i = 0; + for ( ; i < l; i++ ) { + if ( jQuery.contains( this, targets[ i ] ) ) { + return true; + } + } + } ); + }, + + closest: function( selectors, context ) { + var cur, + i = 0, + l = this.length, + matched = [], + targets = typeof selectors !== "string" && jQuery( selectors ); + + // Positional selectors never match, since there's no _selection_ context + if ( !rneedsContext.test( selectors ) ) { + for ( ; i < l; i++ ) { + for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) { + + // Always skip document fragments + if ( cur.nodeType < 11 && ( targets ? + targets.index( cur ) > -1 : + + // Don't pass non-elements to Sizzle + cur.nodeType === 1 && + jQuery.find.matchesSelector( cur, selectors ) ) ) { + + matched.push( cur ); + break; + } + } + } + } + + return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched ); + }, + + // Determine the position of an element within the set + index: function( elem ) { + + // No argument, return index in parent + if ( !elem ) { + return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1; + } + + // Index in selector + if ( typeof elem === "string" ) { + return indexOf.call( jQuery( elem ), this[ 0 ] ); + } + + // Locate the position of the desired element + return indexOf.call( this, + + // If it receives a jQuery object, the first element is used + elem.jquery ? elem[ 0 ] : elem + ); + }, + + add: function( selector, context ) { + return this.pushStack( + jQuery.uniqueSort( + jQuery.merge( this.get(), jQuery( selector, context ) ) + ) + ); + }, + + addBack: function( selector ) { + return this.add( selector == null ? + this.prevObject : this.prevObject.filter( selector ) + ); + } +} ); + +function sibling( cur, dir ) { + while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {} + return cur; +} + +jQuery.each( { + parent: function( elem ) { + var parent = elem.parentNode; + return parent && parent.nodeType !== 11 ? parent : null; + }, + parents: function( elem ) { + return dir( elem, "parentNode" ); + }, + parentsUntil: function( elem, _i, until ) { + return dir( elem, "parentNode", until ); + }, + next: function( elem ) { + return sibling( elem, "nextSibling" ); + }, + prev: function( elem ) { + return sibling( elem, "previousSibling" ); + }, + nextAll: function( elem ) { + return dir( elem, "nextSibling" ); + }, + prevAll: function( elem ) { + return dir( elem, "previousSibling" ); + }, + nextUntil: function( elem, _i, until ) { + return dir( elem, "nextSibling", until ); + }, + prevUntil: function( elem, _i, until ) { + return dir( elem, "previousSibling", until ); + }, + siblings: function( elem ) { + return siblings( ( elem.parentNode || {} ).firstChild, elem ); + }, + children: function( elem ) { + return siblings( elem.firstChild ); + }, + contents: function( elem ) { + if ( elem.contentDocument != null && + + // Support: IE 11+ + // elements with no `data` attribute has an object + // `contentDocument` with a `null` prototype. + getProto( elem.contentDocument ) ) { + + return elem.contentDocument; + } + + // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only + // Treat the template element as a regular one in browsers that + // don't support it. + if ( nodeName( elem, "template" ) ) { + elem = elem.content || elem; + } + + return jQuery.merge( [], elem.childNodes ); + } +}, function( name, fn ) { + jQuery.fn[ name ] = function( until, selector ) { + var matched = jQuery.map( this, fn, until ); + + if ( name.slice( -5 ) !== "Until" ) { + selector = until; + } + + if ( selector && typeof selector === "string" ) { + matched = jQuery.filter( selector, matched ); + } + + if ( this.length > 1 ) { + + // Remove duplicates + if ( !guaranteedUnique[ name ] ) { + jQuery.uniqueSort( matched ); + } + + // Reverse order for parents* and prev-derivatives + if ( rparentsprev.test( name ) ) { + matched.reverse(); + } + } + + return this.pushStack( matched ); + }; +} ); +var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g ); + + + +// Convert String-formatted options into Object-formatted ones +function createOptions( options ) { + var object = {}; + jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) { + object[ flag ] = true; + } ); + return object; +} + +/* + * Create a callback list using the following parameters: + * + * options: an optional list of space-separated options that will change how + * the callback list behaves or a more traditional option object + * + * By default a callback list will act like an event callback list and can be + * "fired" multiple times. + * + * Possible options: + * + * once: will ensure the callback list can only be fired once (like a Deferred) + * + * memory: will keep track of previous values and will call any callback added + * after the list has been fired right away with the latest "memorized" + * values (like a Deferred) + * + * unique: will ensure a callback can only be added once (no duplicate in the list) + * + * stopOnFalse: interrupt callings when a callback returns false + * + */ +jQuery.Callbacks = function( options ) { + + // Convert options from String-formatted to Object-formatted if needed + // (we check in cache first) + options = typeof options === "string" ? + createOptions( options ) : + jQuery.extend( {}, options ); + + var // Flag to know if list is currently firing + firing, + + // Last fire value for non-forgettable lists + memory, + + // Flag to know if list was already fired + fired, + + // Flag to prevent firing + locked, + + // Actual callback list + list = [], + + // Queue of execution data for repeatable lists + queue = [], + + // Index of currently firing callback (modified by add/remove as needed) + firingIndex = -1, + + // Fire callbacks + fire = function() { + + // Enforce single-firing + locked = locked || options.once; + + // Execute callbacks for all pending executions, + // respecting firingIndex overrides and runtime changes + fired = firing = true; + for ( ; queue.length; firingIndex = -1 ) { + memory = queue.shift(); + while ( ++firingIndex < list.length ) { + + // Run callback and check for early termination + if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false && + options.stopOnFalse ) { + + // Jump to end and forget the data so .add doesn't re-fire + firingIndex = list.length; + memory = false; + } + } + } + + // Forget the data if we're done with it + if ( !options.memory ) { + memory = false; + } + + firing = false; + + // Clean up if we're done firing for good + if ( locked ) { + + // Keep an empty list if we have data for future add calls + if ( memory ) { + list = []; + + // Otherwise, this object is spent + } else { + list = ""; + } + } + }, + + // Actual Callbacks object + self = { + + // Add a callback or a collection of callbacks to the list + add: function() { + if ( list ) { + + // If we have memory from a past run, we should fire after adding + if ( memory && !firing ) { + firingIndex = list.length - 1; + queue.push( memory ); + } + + ( function add( args ) { + jQuery.each( args, function( _, arg ) { + if ( isFunction( arg ) ) { + if ( !options.unique || !self.has( arg ) ) { + list.push( arg ); + } + } else if ( arg && arg.length && toType( arg ) !== "string" ) { + + // Inspect recursively + add( arg ); + } + } ); + } )( arguments ); + + if ( memory && !firing ) { + fire(); + } + } + return this; + }, + + // Remove a callback from the list + remove: function() { + jQuery.each( arguments, function( _, arg ) { + var index; + while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) { + list.splice( index, 1 ); + + // Handle firing indexes + if ( index <= firingIndex ) { + firingIndex--; + } + } + } ); + return this; + }, + + // Check if a given callback is in the list. + // If no argument is given, return whether or not list has callbacks attached. + has: function( fn ) { + return fn ? + jQuery.inArray( fn, list ) > -1 : + list.length > 0; + }, + + // Remove all callbacks from the list + empty: function() { + if ( list ) { + list = []; + } + return this; + }, + + // Disable .fire and .add + // Abort any current/pending executions + // Clear all callbacks and values + disable: function() { + locked = queue = []; + list = memory = ""; + return this; + }, + disabled: function() { + return !list; + }, + + // Disable .fire + // Also disable .add unless we have memory (since it would have no effect) + // Abort any pending executions + lock: function() { + locked = queue = []; + if ( !memory && !firing ) { + list = memory = ""; + } + return this; + }, + locked: function() { + return !!locked; + }, + + // Call all callbacks with the given context and arguments + fireWith: function( context, args ) { + if ( !locked ) { + args = args || []; + args = [ context, args.slice ? args.slice() : args ]; + queue.push( args ); + if ( !firing ) { + fire(); + } + } + return this; + }, + + // Call all the callbacks with the given arguments + fire: function() { + self.fireWith( this, arguments ); + return this; + }, + + // To know if the callbacks have already been called at least once + fired: function() { + return !!fired; + } + }; + + return self; +}; + + +function Identity( v ) { + return v; +} +function Thrower( ex ) { + throw ex; +} + +function adoptValue( value, resolve, reject, noValue ) { + var method; + + try { + + // Check for promise aspect first to privilege synchronous behavior + if ( value && isFunction( ( method = value.promise ) ) ) { + method.call( value ).done( resolve ).fail( reject ); + + // Other thenables + } else if ( value && isFunction( ( method = value.then ) ) ) { + method.call( value, resolve, reject ); + + // Other non-thenables + } else { + + // Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer: + // * false: [ value ].slice( 0 ) => resolve( value ) + // * true: [ value ].slice( 1 ) => resolve() + resolve.apply( undefined, [ value ].slice( noValue ) ); + } + + // For Promises/A+, convert exceptions into rejections + // Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in + // Deferred#then to conditionally suppress rejection. + } catch ( value ) { + + // Support: Android 4.0 only + // Strict mode functions invoked without .call/.apply get global-object context + reject.apply( undefined, [ value ] ); + } +} + +jQuery.extend( { + + Deferred: function( func ) { + var tuples = [ + + // action, add listener, callbacks, + // ... .then handlers, argument index, [final state] + [ "notify", "progress", jQuery.Callbacks( "memory" ), + jQuery.Callbacks( "memory" ), 2 ], + [ "resolve", "done", jQuery.Callbacks( "once memory" ), + jQuery.Callbacks( "once memory" ), 0, "resolved" ], + [ "reject", "fail", jQuery.Callbacks( "once memory" ), + jQuery.Callbacks( "once memory" ), 1, "rejected" ] + ], + state = "pending", + promise = { + state: function() { + return state; + }, + always: function() { + deferred.done( arguments ).fail( arguments ); + return this; + }, + "catch": function( fn ) { + return promise.then( null, fn ); + }, + + // Keep pipe for back-compat + pipe: function( /* fnDone, fnFail, fnProgress */ ) { + var fns = arguments; + + return jQuery.Deferred( function( newDefer ) { + jQuery.each( tuples, function( _i, tuple ) { + + // Map tuples (progress, done, fail) to arguments (done, fail, progress) + var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ]; + + // deferred.progress(function() { bind to newDefer or newDefer.notify }) + // deferred.done(function() { bind to newDefer or newDefer.resolve }) + // deferred.fail(function() { bind to newDefer or newDefer.reject }) + deferred[ tuple[ 1 ] ]( function() { + var returned = fn && fn.apply( this, arguments ); + if ( returned && isFunction( returned.promise ) ) { + returned.promise() + .progress( newDefer.notify ) + .done( newDefer.resolve ) + .fail( newDefer.reject ); + } else { + newDefer[ tuple[ 0 ] + "With" ]( + this, + fn ? [ returned ] : arguments + ); + } + } ); + } ); + fns = null; + } ).promise(); + }, + then: function( onFulfilled, onRejected, onProgress ) { + var maxDepth = 0; + function resolve( depth, deferred, handler, special ) { + return function() { + var that = this, + args = arguments, + mightThrow = function() { + var returned, then; + + // Support: Promises/A+ section 2.3.3.3.3 + // https://promisesaplus.com/#point-59 + // Ignore double-resolution attempts + if ( depth < maxDepth ) { + return; + } + + returned = handler.apply( that, args ); + + // Support: Promises/A+ section 2.3.1 + // https://promisesaplus.com/#point-48 + if ( returned === deferred.promise() ) { + throw new TypeError( "Thenable self-resolution" ); + } + + // Support: Promises/A+ sections 2.3.3.1, 3.5 + // https://promisesaplus.com/#point-54 + // https://promisesaplus.com/#point-75 + // Retrieve `then` only once + then = returned && + + // Support: Promises/A+ section 2.3.4 + // https://promisesaplus.com/#point-64 + // Only check objects and functions for thenability + ( typeof returned === "object" || + typeof returned === "function" ) && + returned.then; + + // Handle a returned thenable + if ( isFunction( then ) ) { + + // Special processors (notify) just wait for resolution + if ( special ) { + then.call( + returned, + resolve( maxDepth, deferred, Identity, special ), + resolve( maxDepth, deferred, Thrower, special ) + ); + + // Normal processors (resolve) also hook into progress + } else { + + // ...and disregard older resolution values + maxDepth++; + + then.call( + returned, + resolve( maxDepth, deferred, Identity, special ), + resolve( maxDepth, deferred, Thrower, special ), + resolve( maxDepth, deferred, Identity, + deferred.notifyWith ) + ); + } + + // Handle all other returned values + } else { + + // Only substitute handlers pass on context + // and multiple values (non-spec behavior) + if ( handler !== Identity ) { + that = undefined; + args = [ returned ]; + } + + // Process the value(s) + // Default process is resolve + ( special || deferred.resolveWith )( that, args ); + } + }, + + // Only normal processors (resolve) catch and reject exceptions + process = special ? + mightThrow : + function() { + try { + mightThrow(); + } catch ( e ) { + + if ( jQuery.Deferred.exceptionHook ) { + jQuery.Deferred.exceptionHook( e, + process.stackTrace ); + } + + // Support: Promises/A+ section 2.3.3.3.4.1 + // https://promisesaplus.com/#point-61 + // Ignore post-resolution exceptions + if ( depth + 1 >= maxDepth ) { + + // Only substitute handlers pass on context + // and multiple values (non-spec behavior) + if ( handler !== Thrower ) { + that = undefined; + args = [ e ]; + } + + deferred.rejectWith( that, args ); + } + } + }; + + // Support: Promises/A+ section 2.3.3.3.1 + // https://promisesaplus.com/#point-57 + // Re-resolve promises immediately to dodge false rejection from + // subsequent errors + if ( depth ) { + process(); + } else { + + // Call an optional hook to record the stack, in case of exception + // since it's otherwise lost when execution goes async + if ( jQuery.Deferred.getStackHook ) { + process.stackTrace = jQuery.Deferred.getStackHook(); + } + window.setTimeout( process ); + } + }; + } + + return jQuery.Deferred( function( newDefer ) { + + // progress_handlers.add( ... ) + tuples[ 0 ][ 3 ].add( + resolve( + 0, + newDefer, + isFunction( onProgress ) ? + onProgress : + Identity, + newDefer.notifyWith + ) + ); + + // fulfilled_handlers.add( ... ) + tuples[ 1 ][ 3 ].add( + resolve( + 0, + newDefer, + isFunction( onFulfilled ) ? + onFulfilled : + Identity + ) + ); + + // rejected_handlers.add( ... ) + tuples[ 2 ][ 3 ].add( + resolve( + 0, + newDefer, + isFunction( onRejected ) ? + onRejected : + Thrower + ) + ); + } ).promise(); + }, + + // Get a promise for this deferred + // If obj is provided, the promise aspect is added to the object + promise: function( obj ) { + return obj != null ? jQuery.extend( obj, promise ) : promise; + } + }, + deferred = {}; + + // Add list-specific methods + jQuery.each( tuples, function( i, tuple ) { + var list = tuple[ 2 ], + stateString = tuple[ 5 ]; + + // promise.progress = list.add + // promise.done = list.add + // promise.fail = list.add + promise[ tuple[ 1 ] ] = list.add; + + // Handle state + if ( stateString ) { + list.add( + function() { + + // state = "resolved" (i.e., fulfilled) + // state = "rejected" + state = stateString; + }, + + // rejected_callbacks.disable + // fulfilled_callbacks.disable + tuples[ 3 - i ][ 2 ].disable, + + // rejected_handlers.disable + // fulfilled_handlers.disable + tuples[ 3 - i ][ 3 ].disable, + + // progress_callbacks.lock + tuples[ 0 ][ 2 ].lock, + + // progress_handlers.lock + tuples[ 0 ][ 3 ].lock + ); + } + + // progress_handlers.fire + // fulfilled_handlers.fire + // rejected_handlers.fire + list.add( tuple[ 3 ].fire ); + + // deferred.notify = function() { deferred.notifyWith(...) } + // deferred.resolve = function() { deferred.resolveWith(...) } + // deferred.reject = function() { deferred.rejectWith(...) } + deferred[ tuple[ 0 ] ] = function() { + deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments ); + return this; + }; + + // deferred.notifyWith = list.fireWith + // deferred.resolveWith = list.fireWith + // deferred.rejectWith = list.fireWith + deferred[ tuple[ 0 ] + "With" ] = list.fireWith; + } ); + + // Make the deferred a promise + promise.promise( deferred ); + + // Call given func if any + if ( func ) { + func.call( deferred, deferred ); + } + + // All done! + return deferred; + }, + + // Deferred helper + when: function( singleValue ) { + var + + // count of uncompleted subordinates + remaining = arguments.length, + + // count of unprocessed arguments + i = remaining, + + // subordinate fulfillment data + resolveContexts = Array( i ), + resolveValues = slice.call( arguments ), + + // the master Deferred + master = jQuery.Deferred(), + + // subordinate callback factory + updateFunc = function( i ) { + return function( value ) { + resolveContexts[ i ] = this; + resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value; + if ( !( --remaining ) ) { + master.resolveWith( resolveContexts, resolveValues ); + } + }; + }; + + // Single- and empty arguments are adopted like Promise.resolve + if ( remaining <= 1 ) { + adoptValue( singleValue, master.done( updateFunc( i ) ).resolve, master.reject, + !remaining ); + + // Use .then() to unwrap secondary thenables (cf. gh-3000) + if ( master.state() === "pending" || + isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) { + + return master.then(); + } + } + + // Multiple arguments are aggregated like Promise.all array elements + while ( i-- ) { + adoptValue( resolveValues[ i ], updateFunc( i ), master.reject ); + } + + return master.promise(); + } +} ); + + +// These usually indicate a programmer mistake during development, +// warn about them ASAP rather than swallowing them by default. +var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/; + +jQuery.Deferred.exceptionHook = function( error, stack ) { + + // Support: IE 8 - 9 only + // Console exists when dev tools are open, which can happen at any time + if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) { + window.console.warn( "jQuery.Deferred exception: " + error.message, error.stack, stack ); + } +}; + + + + +jQuery.readyException = function( error ) { + window.setTimeout( function() { + throw error; + } ); +}; + + + + +// The deferred used on DOM ready +var readyList = jQuery.Deferred(); + +jQuery.fn.ready = function( fn ) { + + readyList + .then( fn ) + + // Wrap jQuery.readyException in a function so that the lookup + // happens at the time of error handling instead of callback + // registration. + .catch( function( error ) { + jQuery.readyException( error ); + } ); + + return this; +}; + +jQuery.extend( { + + // Is the DOM ready to be used? Set to true once it occurs. + isReady: false, + + // A counter to track how many items to wait for before + // the ready event fires. See #6781 + readyWait: 1, + + // Handle when the DOM is ready + ready: function( wait ) { + + // Abort if there are pending holds or we're already ready + if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) { + return; + } + + // Remember that the DOM is ready + jQuery.isReady = true; + + // If a normal DOM Ready event fired, decrement, and wait if need be + if ( wait !== true && --jQuery.readyWait > 0 ) { + return; + } + + // If there are functions bound, to execute + readyList.resolveWith( document, [ jQuery ] ); + } +} ); + +jQuery.ready.then = readyList.then; + +// The ready event handler and self cleanup method +function completed() { + document.removeEventListener( "DOMContentLoaded", completed ); + window.removeEventListener( "load", completed ); + jQuery.ready(); +} + +// Catch cases where $(document).ready() is called +// after the browser event has already occurred. +// Support: IE <=9 - 10 only +// Older IE sometimes signals "interactive" too soon +if ( document.readyState === "complete" || + ( document.readyState !== "loading" && !document.documentElement.doScroll ) ) { + + // Handle it asynchronously to allow scripts the opportunity to delay ready + window.setTimeout( jQuery.ready ); + +} else { + + // Use the handy event callback + document.addEventListener( "DOMContentLoaded", completed ); + + // A fallback to window.onload, that will always work + window.addEventListener( "load", completed ); +} + + + + +// Multifunctional method to get and set values of a collection +// The value/s can optionally be executed if it's a function +var access = function( elems, fn, key, value, chainable, emptyGet, raw ) { + var i = 0, + len = elems.length, + bulk = key == null; + + // Sets many values + if ( toType( key ) === "object" ) { + chainable = true; + for ( i in key ) { + access( elems, fn, i, key[ i ], true, emptyGet, raw ); + } + + // Sets one value + } else if ( value !== undefined ) { + chainable = true; + + if ( !isFunction( value ) ) { + raw = true; + } + + if ( bulk ) { + + // Bulk operations run against the entire set + if ( raw ) { + fn.call( elems, value ); + fn = null; + + // ...except when executing function values + } else { + bulk = fn; + fn = function( elem, _key, value ) { + return bulk.call( jQuery( elem ), value ); + }; + } + } + + if ( fn ) { + for ( ; i < len; i++ ) { + fn( + elems[ i ], key, raw ? + value : + value.call( elems[ i ], i, fn( elems[ i ], key ) ) + ); + } + } + } + + if ( chainable ) { + return elems; + } + + // Gets + if ( bulk ) { + return fn.call( elems ); + } + + return len ? fn( elems[ 0 ], key ) : emptyGet; +}; + + +// Matches dashed string for camelizing +var rmsPrefix = /^-ms-/, + rdashAlpha = /-([a-z])/g; + +// Used by camelCase as callback to replace() +function fcamelCase( _all, letter ) { + return letter.toUpperCase(); +} + +// Convert dashed to camelCase; used by the css and data modules +// Support: IE <=9 - 11, Edge 12 - 15 +// Microsoft forgot to hump their vendor prefix (#9572) +function camelCase( string ) { + return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase ); +} +var acceptData = function( owner ) { + + // Accepts only: + // - Node + // - Node.ELEMENT_NODE + // - Node.DOCUMENT_NODE + // - Object + // - Any + return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType ); +}; + + + + +function Data() { + this.expando = jQuery.expando + Data.uid++; +} + +Data.uid = 1; + +Data.prototype = { + + cache: function( owner ) { + + // Check if the owner object already has a cache + var value = owner[ this.expando ]; + + // If not, create one + if ( !value ) { + value = {}; + + // We can accept data for non-element nodes in modern browsers, + // but we should not, see #8335. + // Always return an empty object. + if ( acceptData( owner ) ) { + + // If it is a node unlikely to be stringify-ed or looped over + // use plain assignment + if ( owner.nodeType ) { + owner[ this.expando ] = value; + + // Otherwise secure it in a non-enumerable property + // configurable must be true to allow the property to be + // deleted when data is removed + } else { + Object.defineProperty( owner, this.expando, { + value: value, + configurable: true + } ); + } + } + } + + return value; + }, + set: function( owner, data, value ) { + var prop, + cache = this.cache( owner ); + + // Handle: [ owner, key, value ] args + // Always use camelCase key (gh-2257) + if ( typeof data === "string" ) { + cache[ camelCase( data ) ] = value; + + // Handle: [ owner, { properties } ] args + } else { + + // Copy the properties one-by-one to the cache object + for ( prop in data ) { + cache[ camelCase( prop ) ] = data[ prop ]; + } + } + return cache; + }, + get: function( owner, key ) { + return key === undefined ? + this.cache( owner ) : + + // Always use camelCase key (gh-2257) + owner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ]; + }, + access: function( owner, key, value ) { + + // In cases where either: + // + // 1. No key was specified + // 2. A string key was specified, but no value provided + // + // Take the "read" path and allow the get method to determine + // which value to return, respectively either: + // + // 1. The entire cache object + // 2. The data stored at the key + // + if ( key === undefined || + ( ( key && typeof key === "string" ) && value === undefined ) ) { + + return this.get( owner, key ); + } + + // When the key is not a string, or both a key and value + // are specified, set or extend (existing objects) with either: + // + // 1. An object of properties + // 2. A key and value + // + this.set( owner, key, value ); + + // Since the "set" path can have two possible entry points + // return the expected data based on which path was taken[*] + return value !== undefined ? value : key; + }, + remove: function( owner, key ) { + var i, + cache = owner[ this.expando ]; + + if ( cache === undefined ) { + return; + } + + if ( key !== undefined ) { + + // Support array or space separated string of keys + if ( Array.isArray( key ) ) { + + // If key is an array of keys... + // We always set camelCase keys, so remove that. + key = key.map( camelCase ); + } else { + key = camelCase( key ); + + // If a key with the spaces exists, use it. + // Otherwise, create an array by matching non-whitespace + key = key in cache ? + [ key ] : + ( key.match( rnothtmlwhite ) || [] ); + } + + i = key.length; + + while ( i-- ) { + delete cache[ key[ i ] ]; + } + } + + // Remove the expando if there's no more data + if ( key === undefined || jQuery.isEmptyObject( cache ) ) { + + // Support: Chrome <=35 - 45 + // Webkit & Blink performance suffers when deleting properties + // from DOM nodes, so set to undefined instead + // https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted) + if ( owner.nodeType ) { + owner[ this.expando ] = undefined; + } else { + delete owner[ this.expando ]; + } + } + }, + hasData: function( owner ) { + var cache = owner[ this.expando ]; + return cache !== undefined && !jQuery.isEmptyObject( cache ); + } +}; +var dataPriv = new Data(); + +var dataUser = new Data(); + + + +// Implementation Summary +// +// 1. Enforce API surface and semantic compatibility with 1.9.x branch +// 2. Improve the module's maintainability by reducing the storage +// paths to a single mechanism. +// 3. Use the same single mechanism to support "private" and "user" data. +// 4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData) +// 5. Avoid exposing implementation details on user objects (eg. expando properties) +// 6. Provide a clear path for implementation upgrade to WeakMap in 2014 + +var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/, + rmultiDash = /[A-Z]/g; + +function getData( data ) { + if ( data === "true" ) { + return true; + } + + if ( data === "false" ) { + return false; + } + + if ( data === "null" ) { + return null; + } + + // Only convert to a number if it doesn't change the string + if ( data === +data + "" ) { + return +data; + } + + if ( rbrace.test( data ) ) { + return JSON.parse( data ); + } + + return data; +} + +function dataAttr( elem, key, data ) { + var name; + + // If nothing was found internally, try to fetch any + // data from the HTML5 data-* attribute + if ( data === undefined && elem.nodeType === 1 ) { + name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase(); + data = elem.getAttribute( name ); + + if ( typeof data === "string" ) { + try { + data = getData( data ); + } catch ( e ) {} + + // Make sure we set the data so it isn't changed later + dataUser.set( elem, key, data ); + } else { + data = undefined; + } + } + return data; +} + +jQuery.extend( { + hasData: function( elem ) { + return dataUser.hasData( elem ) || dataPriv.hasData( elem ); + }, + + data: function( elem, name, data ) { + return dataUser.access( elem, name, data ); + }, + + removeData: function( elem, name ) { + dataUser.remove( elem, name ); + }, + + // TODO: Now that all calls to _data and _removeData have been replaced + // with direct calls to dataPriv methods, these can be deprecated. + _data: function( elem, name, data ) { + return dataPriv.access( elem, name, data ); + }, + + _removeData: function( elem, name ) { + dataPriv.remove( elem, name ); + } +} ); + +jQuery.fn.extend( { + data: function( key, value ) { + var i, name, data, + elem = this[ 0 ], + attrs = elem && elem.attributes; + + // Gets all values + if ( key === undefined ) { + if ( this.length ) { + data = dataUser.get( elem ); + + if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) { + i = attrs.length; + while ( i-- ) { + + // Support: IE 11 only + // The attrs elements can be null (#14894) + if ( attrs[ i ] ) { + name = attrs[ i ].name; + if ( name.indexOf( "data-" ) === 0 ) { + name = camelCase( name.slice( 5 ) ); + dataAttr( elem, name, data[ name ] ); + } + } + } + dataPriv.set( elem, "hasDataAttrs", true ); + } + } + + return data; + } + + // Sets multiple values + if ( typeof key === "object" ) { + return this.each( function() { + dataUser.set( this, key ); + } ); + } + + return access( this, function( value ) { + var data; + + // The calling jQuery object (element matches) is not empty + // (and therefore has an element appears at this[ 0 ]) and the + // `value` parameter was not undefined. An empty jQuery object + // will result in `undefined` for elem = this[ 0 ] which will + // throw an exception if an attempt to read a data cache is made. + if ( elem && value === undefined ) { + + // Attempt to get data from the cache + // The key will always be camelCased in Data + data = dataUser.get( elem, key ); + if ( data !== undefined ) { + return data; + } + + // Attempt to "discover" the data in + // HTML5 custom data-* attrs + data = dataAttr( elem, key ); + if ( data !== undefined ) { + return data; + } + + // We tried really hard, but the data doesn't exist. + return; + } + + // Set the data... + this.each( function() { + + // We always store the camelCased key + dataUser.set( this, key, value ); + } ); + }, null, value, arguments.length > 1, null, true ); + }, + + removeData: function( key ) { + return this.each( function() { + dataUser.remove( this, key ); + } ); + } +} ); + + +jQuery.extend( { + queue: function( elem, type, data ) { + var queue; + + if ( elem ) { + type = ( type || "fx" ) + "queue"; + queue = dataPriv.get( elem, type ); + + // Speed up dequeue by getting out quickly if this is just a lookup + if ( data ) { + if ( !queue || Array.isArray( data ) ) { + queue = dataPriv.access( elem, type, jQuery.makeArray( data ) ); + } else { + queue.push( data ); + } + } + return queue || []; + } + }, + + dequeue: function( elem, type ) { + type = type || "fx"; + + var queue = jQuery.queue( elem, type ), + startLength = queue.length, + fn = queue.shift(), + hooks = jQuery._queueHooks( elem, type ), + next = function() { + jQuery.dequeue( elem, type ); + }; + + // If the fx queue is dequeued, always remove the progress sentinel + if ( fn === "inprogress" ) { + fn = queue.shift(); + startLength--; + } + + if ( fn ) { + + // Add a progress sentinel to prevent the fx queue from being + // automatically dequeued + if ( type === "fx" ) { + queue.unshift( "inprogress" ); + } + + // Clear up the last queue stop function + delete hooks.stop; + fn.call( elem, next, hooks ); + } + + if ( !startLength && hooks ) { + hooks.empty.fire(); + } + }, + + // Not public - generate a queueHooks object, or return the current one + _queueHooks: function( elem, type ) { + var key = type + "queueHooks"; + return dataPriv.get( elem, key ) || dataPriv.access( elem, key, { + empty: jQuery.Callbacks( "once memory" ).add( function() { + dataPriv.remove( elem, [ type + "queue", key ] ); + } ) + } ); + } +} ); + +jQuery.fn.extend( { + queue: function( type, data ) { + var setter = 2; + + if ( typeof type !== "string" ) { + data = type; + type = "fx"; + setter--; + } + + if ( arguments.length < setter ) { + return jQuery.queue( this[ 0 ], type ); + } + + return data === undefined ? + this : + this.each( function() { + var queue = jQuery.queue( this, type, data ); + + // Ensure a hooks for this queue + jQuery._queueHooks( this, type ); + + if ( type === "fx" && queue[ 0 ] !== "inprogress" ) { + jQuery.dequeue( this, type ); + } + } ); + }, + dequeue: function( type ) { + return this.each( function() { + jQuery.dequeue( this, type ); + } ); + }, + clearQueue: function( type ) { + return this.queue( type || "fx", [] ); + }, + + // Get a promise resolved when queues of a certain type + // are emptied (fx is the type by default) + promise: function( type, obj ) { + var tmp, + count = 1, + defer = jQuery.Deferred(), + elements = this, + i = this.length, + resolve = function() { + if ( !( --count ) ) { + defer.resolveWith( elements, [ elements ] ); + } + }; + + if ( typeof type !== "string" ) { + obj = type; + type = undefined; + } + type = type || "fx"; + + while ( i-- ) { + tmp = dataPriv.get( elements[ i ], type + "queueHooks" ); + if ( tmp && tmp.empty ) { + count++; + tmp.empty.add( resolve ); + } + } + resolve(); + return defer.promise( obj ); + } +} ); +var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source; + +var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" ); + + +var cssExpand = [ "Top", "Right", "Bottom", "Left" ]; + +var documentElement = document.documentElement; + + + + var isAttached = function( elem ) { + return jQuery.contains( elem.ownerDocument, elem ); + }, + composed = { composed: true }; + + // Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only + // Check attachment across shadow DOM boundaries when possible (gh-3504) + // Support: iOS 10.0-10.2 only + // Early iOS 10 versions support `attachShadow` but not `getRootNode`, + // leading to errors. We need to check for `getRootNode`. + if ( documentElement.getRootNode ) { + isAttached = function( elem ) { + return jQuery.contains( elem.ownerDocument, elem ) || + elem.getRootNode( composed ) === elem.ownerDocument; + }; + } +var isHiddenWithinTree = function( elem, el ) { + + // isHiddenWithinTree might be called from jQuery#filter function; + // in that case, element will be second argument + elem = el || elem; + + // Inline style trumps all + return elem.style.display === "none" || + elem.style.display === "" && + + // Otherwise, check computed style + // Support: Firefox <=43 - 45 + // Disconnected elements can have computed display: none, so first confirm that elem is + // in the document. + isAttached( elem ) && + + jQuery.css( elem, "display" ) === "none"; + }; + + + +function adjustCSS( elem, prop, valueParts, tween ) { + var adjusted, scale, + maxIterations = 20, + currentValue = tween ? + function() { + return tween.cur(); + } : + function() { + return jQuery.css( elem, prop, "" ); + }, + initial = currentValue(), + unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ), + + // Starting value computation is required for potential unit mismatches + initialInUnit = elem.nodeType && + ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) && + rcssNum.exec( jQuery.css( elem, prop ) ); + + if ( initialInUnit && initialInUnit[ 3 ] !== unit ) { + + // Support: Firefox <=54 + // Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144) + initial = initial / 2; + + // Trust units reported by jQuery.css + unit = unit || initialInUnit[ 3 ]; + + // Iteratively approximate from a nonzero starting point + initialInUnit = +initial || 1; + + while ( maxIterations-- ) { + + // Evaluate and update our best guess (doubling guesses that zero out). + // Finish if the scale equals or crosses 1 (making the old*new product non-positive). + jQuery.style( elem, prop, initialInUnit + unit ); + if ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) { + maxIterations = 0; + } + initialInUnit = initialInUnit / scale; + + } + + initialInUnit = initialInUnit * 2; + jQuery.style( elem, prop, initialInUnit + unit ); + + // Make sure we update the tween properties later on + valueParts = valueParts || []; + } + + if ( valueParts ) { + initialInUnit = +initialInUnit || +initial || 0; + + // Apply relative offset (+=/-=) if specified + adjusted = valueParts[ 1 ] ? + initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] : + +valueParts[ 2 ]; + if ( tween ) { + tween.unit = unit; + tween.start = initialInUnit; + tween.end = adjusted; + } + } + return adjusted; +} + + +var defaultDisplayMap = {}; + +function getDefaultDisplay( elem ) { + var temp, + doc = elem.ownerDocument, + nodeName = elem.nodeName, + display = defaultDisplayMap[ nodeName ]; + + if ( display ) { + return display; + } + + temp = doc.body.appendChild( doc.createElement( nodeName ) ); + display = jQuery.css( temp, "display" ); + + temp.parentNode.removeChild( temp ); + + if ( display === "none" ) { + display = "block"; + } + defaultDisplayMap[ nodeName ] = display; + + return display; +} + +function showHide( elements, show ) { + var display, elem, + values = [], + index = 0, + length = elements.length; + + // Determine new display value for elements that need to change + for ( ; index < length; index++ ) { + elem = elements[ index ]; + if ( !elem.style ) { + continue; + } + + display = elem.style.display; + if ( show ) { + + // Since we force visibility upon cascade-hidden elements, an immediate (and slow) + // check is required in this first loop unless we have a nonempty display value (either + // inline or about-to-be-restored) + if ( display === "none" ) { + values[ index ] = dataPriv.get( elem, "display" ) || null; + if ( !values[ index ] ) { + elem.style.display = ""; + } + } + if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) { + values[ index ] = getDefaultDisplay( elem ); + } + } else { + if ( display !== "none" ) { + values[ index ] = "none"; + + // Remember what we're overwriting + dataPriv.set( elem, "display", display ); + } + } + } + + // Set the display of the elements in a second loop to avoid constant reflow + for ( index = 0; index < length; index++ ) { + if ( values[ index ] != null ) { + elements[ index ].style.display = values[ index ]; + } + } + + return elements; +} + +jQuery.fn.extend( { + show: function() { + return showHide( this, true ); + }, + hide: function() { + return showHide( this ); + }, + toggle: function( state ) { + if ( typeof state === "boolean" ) { + return state ? this.show() : this.hide(); + } + + return this.each( function() { + if ( isHiddenWithinTree( this ) ) { + jQuery( this ).show(); + } else { + jQuery( this ).hide(); + } + } ); + } +} ); +var rcheckableType = ( /^(?:checkbox|radio)$/i ); + +var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]*)/i ); + +var rscriptType = ( /^$|^module$|\/(?:java|ecma)script/i ); + + + +( function() { + var fragment = document.createDocumentFragment(), + div = fragment.appendChild( document.createElement( "div" ) ), + input = document.createElement( "input" ); + + // Support: Android 4.0 - 4.3 only + // Check state lost if the name is set (#11217) + // Support: Windows Web Apps (WWA) + // `name` and `type` must use .setAttribute for WWA (#14901) + input.setAttribute( "type", "radio" ); + input.setAttribute( "checked", "checked" ); + input.setAttribute( "name", "t" ); + + div.appendChild( input ); + + // Support: Android <=4.1 only + // Older WebKit doesn't clone checked state correctly in fragments + support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked; + + // Support: IE <=11 only + // Make sure textarea (and checkbox) defaultValue is properly cloned + div.innerHTML = ""; + support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue; + + // Support: IE <=9 only + // IE <=9 replaces "; + support.option = !!div.lastChild; +} )(); + + +// We have to close these tags to support XHTML (#13200) +var wrapMap = { + + // XHTML parsers do not magically insert elements in the + // same way that tag soup parsers do. So we cannot shorten + // this by omitting or other required elements. + thead: [ 1, "", "
" ], + col: [ 2, "", "
" ], + tr: [ 2, "", "
" ], + td: [ 3, "", "
" ], + + _default: [ 0, "", "" ] +}; + +wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; +wrapMap.th = wrapMap.td; + +// Support: IE <=9 only +if ( !support.option ) { + wrapMap.optgroup = wrapMap.option = [ 1, "" ]; +} + + +function getAll( context, tag ) { + + // Support: IE <=9 - 11 only + // Use typeof to avoid zero-argument method invocation on host objects (#15151) + var ret; + + if ( typeof context.getElementsByTagName !== "undefined" ) { + ret = context.getElementsByTagName( tag || "*" ); + + } else if ( typeof context.querySelectorAll !== "undefined" ) { + ret = context.querySelectorAll( tag || "*" ); + + } else { + ret = []; + } + + if ( tag === undefined || tag && nodeName( context, tag ) ) { + return jQuery.merge( [ context ], ret ); + } + + return ret; +} + + +// Mark scripts as having already been evaluated +function setGlobalEval( elems, refElements ) { + var i = 0, + l = elems.length; + + for ( ; i < l; i++ ) { + dataPriv.set( + elems[ i ], + "globalEval", + !refElements || dataPriv.get( refElements[ i ], "globalEval" ) + ); + } +} + + +var rhtml = /<|&#?\w+;/; + +function buildFragment( elems, context, scripts, selection, ignored ) { + var elem, tmp, tag, wrap, attached, j, + fragment = context.createDocumentFragment(), + nodes = [], + i = 0, + l = elems.length; + + for ( ; i < l; i++ ) { + elem = elems[ i ]; + + if ( elem || elem === 0 ) { + + // Add nodes directly + if ( toType( elem ) === "object" ) { + + // Support: Android <=4.0 only, PhantomJS 1 only + // push.apply(_, arraylike) throws on ancient WebKit + jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem ); + + // Convert non-html into a text node + } else if ( !rhtml.test( elem ) ) { + nodes.push( context.createTextNode( elem ) ); + + // Convert html into DOM nodes + } else { + tmp = tmp || fragment.appendChild( context.createElement( "div" ) ); + + // Deserialize a standard representation + tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase(); + wrap = wrapMap[ tag ] || wrapMap._default; + tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ]; + + // Descend through wrappers to the right content + j = wrap[ 0 ]; + while ( j-- ) { + tmp = tmp.lastChild; + } + + // Support: Android <=4.0 only, PhantomJS 1 only + // push.apply(_, arraylike) throws on ancient WebKit + jQuery.merge( nodes, tmp.childNodes ); + + // Remember the top-level container + tmp = fragment.firstChild; + + // Ensure the created nodes are orphaned (#12392) + tmp.textContent = ""; + } + } + } + + // Remove wrapper from fragment + fragment.textContent = ""; + + i = 0; + while ( ( elem = nodes[ i++ ] ) ) { + + // Skip elements already in the context collection (trac-4087) + if ( selection && jQuery.inArray( elem, selection ) > -1 ) { + if ( ignored ) { + ignored.push( elem ); + } + continue; + } + + attached = isAttached( elem ); + + // Append to fragment + tmp = getAll( fragment.appendChild( elem ), "script" ); + + // Preserve script evaluation history + if ( attached ) { + setGlobalEval( tmp ); + } + + // Capture executables + if ( scripts ) { + j = 0; + while ( ( elem = tmp[ j++ ] ) ) { + if ( rscriptType.test( elem.type || "" ) ) { + scripts.push( elem ); + } + } + } + } + + return fragment; +} + + +var + rkeyEvent = /^key/, + rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/, + rtypenamespace = /^([^.]*)(?:\.(.+)|)/; + +function returnTrue() { + return true; +} + +function returnFalse() { + return false; +} + +// Support: IE <=9 - 11+ +// focus() and blur() are asynchronous, except when they are no-op. +// So expect focus to be synchronous when the element is already active, +// and blur to be synchronous when the element is not already active. +// (focus and blur are always synchronous in other supported browsers, +// this just defines when we can count on it). +function expectSync( elem, type ) { + return ( elem === safeActiveElement() ) === ( type === "focus" ); +} + +// Support: IE <=9 only +// Accessing document.activeElement can throw unexpectedly +// https://bugs.jquery.com/ticket/13393 +function safeActiveElement() { + try { + return document.activeElement; + } catch ( err ) { } +} + +function on( elem, types, selector, data, fn, one ) { + var origFn, type; + + // Types can be a map of types/handlers + if ( typeof types === "object" ) { + + // ( types-Object, selector, data ) + if ( typeof selector !== "string" ) { + + // ( types-Object, data ) + data = data || selector; + selector = undefined; + } + for ( type in types ) { + on( elem, type, selector, data, types[ type ], one ); + } + return elem; + } + + if ( data == null && fn == null ) { + + // ( types, fn ) + fn = selector; + data = selector = undefined; + } else if ( fn == null ) { + if ( typeof selector === "string" ) { + + // ( types, selector, fn ) + fn = data; + data = undefined; + } else { + + // ( types, data, fn ) + fn = data; + data = selector; + selector = undefined; + } + } + if ( fn === false ) { + fn = returnFalse; + } else if ( !fn ) { + return elem; + } + + if ( one === 1 ) { + origFn = fn; + fn = function( event ) { + + // Can use an empty set, since event contains the info + jQuery().off( event ); + return origFn.apply( this, arguments ); + }; + + // Use same guid so caller can remove using origFn + fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ ); + } + return elem.each( function() { + jQuery.event.add( this, types, fn, data, selector ); + } ); +} + +/* + * Helper functions for managing events -- not part of the public interface. + * Props to Dean Edwards' addEvent library for many of the ideas. + */ +jQuery.event = { + + global: {}, + + add: function( elem, types, handler, data, selector ) { + + var handleObjIn, eventHandle, tmp, + events, t, handleObj, + special, handlers, type, namespaces, origType, + elemData = dataPriv.get( elem ); + + // Only attach events to objects that accept data + if ( !acceptData( elem ) ) { + return; + } + + // Caller can pass in an object of custom data in lieu of the handler + if ( handler.handler ) { + handleObjIn = handler; + handler = handleObjIn.handler; + selector = handleObjIn.selector; + } + + // Ensure that invalid selectors throw exceptions at attach time + // Evaluate against documentElement in case elem is a non-element node (e.g., document) + if ( selector ) { + jQuery.find.matchesSelector( documentElement, selector ); + } + + // Make sure that the handler has a unique ID, used to find/remove it later + if ( !handler.guid ) { + handler.guid = jQuery.guid++; + } + + // Init the element's event structure and main handler, if this is the first + if ( !( events = elemData.events ) ) { + events = elemData.events = Object.create( null ); + } + if ( !( eventHandle = elemData.handle ) ) { + eventHandle = elemData.handle = function( e ) { + + // Discard the second event of a jQuery.event.trigger() and + // when an event is called after a page has unloaded + return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ? + jQuery.event.dispatch.apply( elem, arguments ) : undefined; + }; + } + + // Handle multiple events separated by a space + types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; + t = types.length; + while ( t-- ) { + tmp = rtypenamespace.exec( types[ t ] ) || []; + type = origType = tmp[ 1 ]; + namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort(); + + // There *must* be a type, no attaching namespace-only handlers + if ( !type ) { + continue; + } + + // If event changes its type, use the special event handlers for the changed type + special = jQuery.event.special[ type ] || {}; + + // If selector defined, determine special event api type, otherwise given type + type = ( selector ? special.delegateType : special.bindType ) || type; + + // Update special based on newly reset type + special = jQuery.event.special[ type ] || {}; + + // handleObj is passed to all event handlers + handleObj = jQuery.extend( { + type: type, + origType: origType, + data: data, + handler: handler, + guid: handler.guid, + selector: selector, + needsContext: selector && jQuery.expr.match.needsContext.test( selector ), + namespace: namespaces.join( "." ) + }, handleObjIn ); + + // Init the event handler queue if we're the first + if ( !( handlers = events[ type ] ) ) { + handlers = events[ type ] = []; + handlers.delegateCount = 0; + + // Only use addEventListener if the special events handler returns false + if ( !special.setup || + special.setup.call( elem, data, namespaces, eventHandle ) === false ) { + + if ( elem.addEventListener ) { + elem.addEventListener( type, eventHandle ); + } + } + } + + if ( special.add ) { + special.add.call( elem, handleObj ); + + if ( !handleObj.handler.guid ) { + handleObj.handler.guid = handler.guid; + } + } + + // Add to the element's handler list, delegates in front + if ( selector ) { + handlers.splice( handlers.delegateCount++, 0, handleObj ); + } else { + handlers.push( handleObj ); + } + + // Keep track of which events have ever been used, for event optimization + jQuery.event.global[ type ] = true; + } + + }, + + // Detach an event or set of events from an element + remove: function( elem, types, handler, selector, mappedTypes ) { + + var j, origCount, tmp, + events, t, handleObj, + special, handlers, type, namespaces, origType, + elemData = dataPriv.hasData( elem ) && dataPriv.get( elem ); + + if ( !elemData || !( events = elemData.events ) ) { + return; + } + + // Once for each type.namespace in types; type may be omitted + types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; + t = types.length; + while ( t-- ) { + tmp = rtypenamespace.exec( types[ t ] ) || []; + type = origType = tmp[ 1 ]; + namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort(); + + // Unbind all events (on this namespace, if provided) for the element + if ( !type ) { + for ( type in events ) { + jQuery.event.remove( elem, type + types[ t ], handler, selector, true ); + } + continue; + } + + special = jQuery.event.special[ type ] || {}; + type = ( selector ? special.delegateType : special.bindType ) || type; + handlers = events[ type ] || []; + tmp = tmp[ 2 ] && + new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ); + + // Remove matching events + origCount = j = handlers.length; + while ( j-- ) { + handleObj = handlers[ j ]; + + if ( ( mappedTypes || origType === handleObj.origType ) && + ( !handler || handler.guid === handleObj.guid ) && + ( !tmp || tmp.test( handleObj.namespace ) ) && + ( !selector || selector === handleObj.selector || + selector === "**" && handleObj.selector ) ) { + handlers.splice( j, 1 ); + + if ( handleObj.selector ) { + handlers.delegateCount--; + } + if ( special.remove ) { + special.remove.call( elem, handleObj ); + } + } + } + + // Remove generic event handler if we removed something and no more handlers exist + // (avoids potential for endless recursion during removal of special event handlers) + if ( origCount && !handlers.length ) { + if ( !special.teardown || + special.teardown.call( elem, namespaces, elemData.handle ) === false ) { + + jQuery.removeEvent( elem, type, elemData.handle ); + } + + delete events[ type ]; + } + } + + // Remove data and the expando if it's no longer used + if ( jQuery.isEmptyObject( events ) ) { + dataPriv.remove( elem, "handle events" ); + } + }, + + dispatch: function( nativeEvent ) { + + var i, j, ret, matched, handleObj, handlerQueue, + args = new Array( arguments.length ), + + // Make a writable jQuery.Event from the native event object + event = jQuery.event.fix( nativeEvent ), + + handlers = ( + dataPriv.get( this, "events" ) || Object.create( null ) + )[ event.type ] || [], + special = jQuery.event.special[ event.type ] || {}; + + // Use the fix-ed jQuery.Event rather than the (read-only) native event + args[ 0 ] = event; + + for ( i = 1; i < arguments.length; i++ ) { + args[ i ] = arguments[ i ]; + } + + event.delegateTarget = this; + + // Call the preDispatch hook for the mapped type, and let it bail if desired + if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) { + return; + } + + // Determine handlers + handlerQueue = jQuery.event.handlers.call( this, event, handlers ); + + // Run delegates first; they may want to stop propagation beneath us + i = 0; + while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) { + event.currentTarget = matched.elem; + + j = 0; + while ( ( handleObj = matched.handlers[ j++ ] ) && + !event.isImmediatePropagationStopped() ) { + + // If the event is namespaced, then each handler is only invoked if it is + // specially universal or its namespaces are a superset of the event's. + if ( !event.rnamespace || handleObj.namespace === false || + event.rnamespace.test( handleObj.namespace ) ) { + + event.handleObj = handleObj; + event.data = handleObj.data; + + ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle || + handleObj.handler ).apply( matched.elem, args ); + + if ( ret !== undefined ) { + if ( ( event.result = ret ) === false ) { + event.preventDefault(); + event.stopPropagation(); + } + } + } + } + } + + // Call the postDispatch hook for the mapped type + if ( special.postDispatch ) { + special.postDispatch.call( this, event ); + } + + return event.result; + }, + + handlers: function( event, handlers ) { + var i, handleObj, sel, matchedHandlers, matchedSelectors, + handlerQueue = [], + delegateCount = handlers.delegateCount, + cur = event.target; + + // Find delegate handlers + if ( delegateCount && + + // Support: IE <=9 + // Black-hole SVG instance trees (trac-13180) + cur.nodeType && + + // Support: Firefox <=42 + // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861) + // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click + // Support: IE 11 only + // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343) + !( event.type === "click" && event.button >= 1 ) ) { + + for ( ; cur !== this; cur = cur.parentNode || this ) { + + // Don't check non-elements (#13208) + // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764) + if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) { + matchedHandlers = []; + matchedSelectors = {}; + for ( i = 0; i < delegateCount; i++ ) { + handleObj = handlers[ i ]; + + // Don't conflict with Object.prototype properties (#13203) + sel = handleObj.selector + " "; + + if ( matchedSelectors[ sel ] === undefined ) { + matchedSelectors[ sel ] = handleObj.needsContext ? + jQuery( sel, this ).index( cur ) > -1 : + jQuery.find( sel, this, null, [ cur ] ).length; + } + if ( matchedSelectors[ sel ] ) { + matchedHandlers.push( handleObj ); + } + } + if ( matchedHandlers.length ) { + handlerQueue.push( { elem: cur, handlers: matchedHandlers } ); + } + } + } + } + + // Add the remaining (directly-bound) handlers + cur = this; + if ( delegateCount < handlers.length ) { + handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } ); + } + + return handlerQueue; + }, + + addProp: function( name, hook ) { + Object.defineProperty( jQuery.Event.prototype, name, { + enumerable: true, + configurable: true, + + get: isFunction( hook ) ? + function() { + if ( this.originalEvent ) { + return hook( this.originalEvent ); + } + } : + function() { + if ( this.originalEvent ) { + return this.originalEvent[ name ]; + } + }, + + set: function( value ) { + Object.defineProperty( this, name, { + enumerable: true, + configurable: true, + writable: true, + value: value + } ); + } + } ); + }, + + fix: function( originalEvent ) { + return originalEvent[ jQuery.expando ] ? + originalEvent : + new jQuery.Event( originalEvent ); + }, + + special: { + load: { + + // Prevent triggered image.load events from bubbling to window.load + noBubble: true + }, + click: { + + // Utilize native event to ensure correct state for checkable inputs + setup: function( data ) { + + // For mutual compressibility with _default, replace `this` access with a local var. + // `|| data` is dead code meant only to preserve the variable through minification. + var el = this || data; + + // Claim the first handler + if ( rcheckableType.test( el.type ) && + el.click && nodeName( el, "input" ) ) { + + // dataPriv.set( el, "click", ... ) + leverageNative( el, "click", returnTrue ); + } + + // Return false to allow normal processing in the caller + return false; + }, + trigger: function( data ) { + + // For mutual compressibility with _default, replace `this` access with a local var. + // `|| data` is dead code meant only to preserve the variable through minification. + var el = this || data; + + // Force setup before triggering a click + if ( rcheckableType.test( el.type ) && + el.click && nodeName( el, "input" ) ) { + + leverageNative( el, "click" ); + } + + // Return non-false to allow normal event-path propagation + return true; + }, + + // For cross-browser consistency, suppress native .click() on links + // Also prevent it if we're currently inside a leveraged native-event stack + _default: function( event ) { + var target = event.target; + return rcheckableType.test( target.type ) && + target.click && nodeName( target, "input" ) && + dataPriv.get( target, "click" ) || + nodeName( target, "a" ); + } + }, + + beforeunload: { + postDispatch: function( event ) { + + // Support: Firefox 20+ + // Firefox doesn't alert if the returnValue field is not set. + if ( event.result !== undefined && event.originalEvent ) { + event.originalEvent.returnValue = event.result; + } + } + } + } +}; + +// Ensure the presence of an event listener that handles manually-triggered +// synthetic events by interrupting progress until reinvoked in response to +// *native* events that it fires directly, ensuring that state changes have +// already occurred before other listeners are invoked. +function leverageNative( el, type, expectSync ) { + + // Missing expectSync indicates a trigger call, which must force setup through jQuery.event.add + if ( !expectSync ) { + if ( dataPriv.get( el, type ) === undefined ) { + jQuery.event.add( el, type, returnTrue ); + } + return; + } + + // Register the controller as a special universal handler for all event namespaces + dataPriv.set( el, type, false ); + jQuery.event.add( el, type, { + namespace: false, + handler: function( event ) { + var notAsync, result, + saved = dataPriv.get( this, type ); + + if ( ( event.isTrigger & 1 ) && this[ type ] ) { + + // Interrupt processing of the outer synthetic .trigger()ed event + // Saved data should be false in such cases, but might be a leftover capture object + // from an async native handler (gh-4350) + if ( !saved.length ) { + + // Store arguments for use when handling the inner native event + // There will always be at least one argument (an event object), so this array + // will not be confused with a leftover capture object. + saved = slice.call( arguments ); + dataPriv.set( this, type, saved ); + + // Trigger the native event and capture its result + // Support: IE <=9 - 11+ + // focus() and blur() are asynchronous + notAsync = expectSync( this, type ); + this[ type ](); + result = dataPriv.get( this, type ); + if ( saved !== result || notAsync ) { + dataPriv.set( this, type, false ); + } else { + result = {}; + } + if ( saved !== result ) { + + // Cancel the outer synthetic event + event.stopImmediatePropagation(); + event.preventDefault(); + return result.value; + } + + // If this is an inner synthetic event for an event with a bubbling surrogate + // (focus or blur), assume that the surrogate already propagated from triggering the + // native event and prevent that from happening again here. + // This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the + // bubbling surrogate propagates *after* the non-bubbling base), but that seems + // less bad than duplication. + } else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) { + event.stopPropagation(); + } + + // If this is a native event triggered above, everything is now in order + // Fire an inner synthetic event with the original arguments + } else if ( saved.length ) { + + // ...and capture the result + dataPriv.set( this, type, { + value: jQuery.event.trigger( + + // Support: IE <=9 - 11+ + // Extend with the prototype to reset the above stopImmediatePropagation() + jQuery.extend( saved[ 0 ], jQuery.Event.prototype ), + saved.slice( 1 ), + this + ) + } ); + + // Abort handling of the native event + event.stopImmediatePropagation(); + } + } + } ); +} + +jQuery.removeEvent = function( elem, type, handle ) { + + // This "if" is needed for plain objects + if ( elem.removeEventListener ) { + elem.removeEventListener( type, handle ); + } +}; + +jQuery.Event = function( src, props ) { + + // Allow instantiation without the 'new' keyword + if ( !( this instanceof jQuery.Event ) ) { + return new jQuery.Event( src, props ); + } + + // Event object + if ( src && src.type ) { + this.originalEvent = src; + this.type = src.type; + + // Events bubbling up the document may have been marked as prevented + // by a handler lower down the tree; reflect the correct value. + this.isDefaultPrevented = src.defaultPrevented || + src.defaultPrevented === undefined && + + // Support: Android <=2.3 only + src.returnValue === false ? + returnTrue : + returnFalse; + + // Create target properties + // Support: Safari <=6 - 7 only + // Target should not be a text node (#504, #13143) + this.target = ( src.target && src.target.nodeType === 3 ) ? + src.target.parentNode : + src.target; + + this.currentTarget = src.currentTarget; + this.relatedTarget = src.relatedTarget; + + // Event type + } else { + this.type = src; + } + + // Put explicitly provided properties onto the event object + if ( props ) { + jQuery.extend( this, props ); + } + + // Create a timestamp if incoming event doesn't have one + this.timeStamp = src && src.timeStamp || Date.now(); + + // Mark it as fixed + this[ jQuery.expando ] = true; +}; + +// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding +// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html +jQuery.Event.prototype = { + constructor: jQuery.Event, + isDefaultPrevented: returnFalse, + isPropagationStopped: returnFalse, + isImmediatePropagationStopped: returnFalse, + isSimulated: false, + + preventDefault: function() { + var e = this.originalEvent; + + this.isDefaultPrevented = returnTrue; + + if ( e && !this.isSimulated ) { + e.preventDefault(); + } + }, + stopPropagation: function() { + var e = this.originalEvent; + + this.isPropagationStopped = returnTrue; + + if ( e && !this.isSimulated ) { + e.stopPropagation(); + } + }, + stopImmediatePropagation: function() { + var e = this.originalEvent; + + this.isImmediatePropagationStopped = returnTrue; + + if ( e && !this.isSimulated ) { + e.stopImmediatePropagation(); + } + + this.stopPropagation(); + } +}; + +// Includes all common event props including KeyEvent and MouseEvent specific props +jQuery.each( { + altKey: true, + bubbles: true, + cancelable: true, + changedTouches: true, + ctrlKey: true, + detail: true, + eventPhase: true, + metaKey: true, + pageX: true, + pageY: true, + shiftKey: true, + view: true, + "char": true, + code: true, + charCode: true, + key: true, + keyCode: true, + button: true, + buttons: true, + clientX: true, + clientY: true, + offsetX: true, + offsetY: true, + pointerId: true, + pointerType: true, + screenX: true, + screenY: true, + targetTouches: true, + toElement: true, + touches: true, + + which: function( event ) { + var button = event.button; + + // Add which for key events + if ( event.which == null && rkeyEvent.test( event.type ) ) { + return event.charCode != null ? event.charCode : event.keyCode; + } + + // Add which for click: 1 === left; 2 === middle; 3 === right + if ( !event.which && button !== undefined && rmouseEvent.test( event.type ) ) { + if ( button & 1 ) { + return 1; + } + + if ( button & 2 ) { + return 3; + } + + if ( button & 4 ) { + return 2; + } + + return 0; + } + + return event.which; + } +}, jQuery.event.addProp ); + +jQuery.each( { focus: "focusin", blur: "focusout" }, function( type, delegateType ) { + jQuery.event.special[ type ] = { + + // Utilize native event if possible so blur/focus sequence is correct + setup: function() { + + // Claim the first handler + // dataPriv.set( this, "focus", ... ) + // dataPriv.set( this, "blur", ... ) + leverageNative( this, type, expectSync ); + + // Return false to allow normal processing in the caller + return false; + }, + trigger: function() { + + // Force setup before trigger + leverageNative( this, type ); + + // Return non-false to allow normal event-path propagation + return true; + }, + + delegateType: delegateType + }; +} ); + +// Create mouseenter/leave events using mouseover/out and event-time checks +// so that event delegation works in jQuery. +// Do the same for pointerenter/pointerleave and pointerover/pointerout +// +// Support: Safari 7 only +// Safari sends mouseenter too often; see: +// https://bugs.chromium.org/p/chromium/issues/detail?id=470258 +// for the description of the bug (it existed in older Chrome versions as well). +jQuery.each( { + mouseenter: "mouseover", + mouseleave: "mouseout", + pointerenter: "pointerover", + pointerleave: "pointerout" +}, function( orig, fix ) { + jQuery.event.special[ orig ] = { + delegateType: fix, + bindType: fix, + + handle: function( event ) { + var ret, + target = this, + related = event.relatedTarget, + handleObj = event.handleObj; + + // For mouseenter/leave call the handler if related is outside the target. + // NB: No relatedTarget if the mouse left/entered the browser window + if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) { + event.type = handleObj.origType; + ret = handleObj.handler.apply( this, arguments ); + event.type = fix; + } + return ret; + } + }; +} ); + +jQuery.fn.extend( { + + on: function( types, selector, data, fn ) { + return on( this, types, selector, data, fn ); + }, + one: function( types, selector, data, fn ) { + return on( this, types, selector, data, fn, 1 ); + }, + off: function( types, selector, fn ) { + var handleObj, type; + if ( types && types.preventDefault && types.handleObj ) { + + // ( event ) dispatched jQuery.Event + handleObj = types.handleObj; + jQuery( types.delegateTarget ).off( + handleObj.namespace ? + handleObj.origType + "." + handleObj.namespace : + handleObj.origType, + handleObj.selector, + handleObj.handler + ); + return this; + } + if ( typeof types === "object" ) { + + // ( types-object [, selector] ) + for ( type in types ) { + this.off( type, selector, types[ type ] ); + } + return this; + } + if ( selector === false || typeof selector === "function" ) { + + // ( types [, fn] ) + fn = selector; + selector = undefined; + } + if ( fn === false ) { + fn = returnFalse; + } + return this.each( function() { + jQuery.event.remove( this, types, fn, selector ); + } ); + } +} ); + + +var + + // Support: IE <=10 - 11, Edge 12 - 13 only + // In IE/Edge using regex groups here causes severe slowdowns. + // See https://connect.microsoft.com/IE/feedback/details/1736512/ + rnoInnerhtml = /\s*$/g; + +// Prefer a tbody over its parent table for containing new rows +function manipulationTarget( elem, content ) { + if ( nodeName( elem, "table" ) && + nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) { + + return jQuery( elem ).children( "tbody" )[ 0 ] || elem; + } + + return elem; +} + +// Replace/restore the type attribute of script elements for safe DOM manipulation +function disableScript( elem ) { + elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type; + return elem; +} +function restoreScript( elem ) { + if ( ( elem.type || "" ).slice( 0, 5 ) === "true/" ) { + elem.type = elem.type.slice( 5 ); + } else { + elem.removeAttribute( "type" ); + } + + return elem; +} + +function cloneCopyEvent( src, dest ) { + var i, l, type, pdataOld, udataOld, udataCur, events; + + if ( dest.nodeType !== 1 ) { + return; + } + + // 1. Copy private data: events, handlers, etc. + if ( dataPriv.hasData( src ) ) { + pdataOld = dataPriv.get( src ); + events = pdataOld.events; + + if ( events ) { + dataPriv.remove( dest, "handle events" ); + + for ( type in events ) { + for ( i = 0, l = events[ type ].length; i < l; i++ ) { + jQuery.event.add( dest, type, events[ type ][ i ] ); + } + } + } + } + + // 2. Copy user data + if ( dataUser.hasData( src ) ) { + udataOld = dataUser.access( src ); + udataCur = jQuery.extend( {}, udataOld ); + + dataUser.set( dest, udataCur ); + } +} + +// Fix IE bugs, see support tests +function fixInput( src, dest ) { + var nodeName = dest.nodeName.toLowerCase(); + + // Fails to persist the checked state of a cloned checkbox or radio button. + if ( nodeName === "input" && rcheckableType.test( src.type ) ) { + dest.checked = src.checked; + + // Fails to return the selected option to the default selected state when cloning options + } else if ( nodeName === "input" || nodeName === "textarea" ) { + dest.defaultValue = src.defaultValue; + } +} + +function domManip( collection, args, callback, ignored ) { + + // Flatten any nested arrays + args = flat( args ); + + var fragment, first, scripts, hasScripts, node, doc, + i = 0, + l = collection.length, + iNoClone = l - 1, + value = args[ 0 ], + valueIsFunction = isFunction( value ); + + // We can't cloneNode fragments that contain checked, in WebKit + if ( valueIsFunction || + ( l > 1 && typeof value === "string" && + !support.checkClone && rchecked.test( value ) ) ) { + return collection.each( function( index ) { + var self = collection.eq( index ); + if ( valueIsFunction ) { + args[ 0 ] = value.call( this, index, self.html() ); + } + domManip( self, args, callback, ignored ); + } ); + } + + if ( l ) { + fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored ); + first = fragment.firstChild; + + if ( fragment.childNodes.length === 1 ) { + fragment = first; + } + + // Require either new content or an interest in ignored elements to invoke the callback + if ( first || ignored ) { + scripts = jQuery.map( getAll( fragment, "script" ), disableScript ); + hasScripts = scripts.length; + + // Use the original fragment for the last item + // instead of the first because it can end up + // being emptied incorrectly in certain situations (#8070). + for ( ; i < l; i++ ) { + node = fragment; + + if ( i !== iNoClone ) { + node = jQuery.clone( node, true, true ); + + // Keep references to cloned scripts for later restoration + if ( hasScripts ) { + + // Support: Android <=4.0 only, PhantomJS 1 only + // push.apply(_, arraylike) throws on ancient WebKit + jQuery.merge( scripts, getAll( node, "script" ) ); + } + } + + callback.call( collection[ i ], node, i ); + } + + if ( hasScripts ) { + doc = scripts[ scripts.length - 1 ].ownerDocument; + + // Reenable scripts + jQuery.map( scripts, restoreScript ); + + // Evaluate executable scripts on first document insertion + for ( i = 0; i < hasScripts; i++ ) { + node = scripts[ i ]; + if ( rscriptType.test( node.type || "" ) && + !dataPriv.access( node, "globalEval" ) && + jQuery.contains( doc, node ) ) { + + if ( node.src && ( node.type || "" ).toLowerCase() !== "module" ) { + + // Optional AJAX dependency, but won't run scripts if not present + if ( jQuery._evalUrl && !node.noModule ) { + jQuery._evalUrl( node.src, { + nonce: node.nonce || node.getAttribute( "nonce" ) + }, doc ); + } + } else { + DOMEval( node.textContent.replace( rcleanScript, "" ), node, doc ); + } + } + } + } + } + } + + return collection; +} + +function remove( elem, selector, keepData ) { + var node, + nodes = selector ? jQuery.filter( selector, elem ) : elem, + i = 0; + + for ( ; ( node = nodes[ i ] ) != null; i++ ) { + if ( !keepData && node.nodeType === 1 ) { + jQuery.cleanData( getAll( node ) ); + } + + if ( node.parentNode ) { + if ( keepData && isAttached( node ) ) { + setGlobalEval( getAll( node, "script" ) ); + } + node.parentNode.removeChild( node ); + } + } + + return elem; +} + +jQuery.extend( { + htmlPrefilter: function( html ) { + return html; + }, + + clone: function( elem, dataAndEvents, deepDataAndEvents ) { + var i, l, srcElements, destElements, + clone = elem.cloneNode( true ), + inPage = isAttached( elem ); + + // Fix IE cloning issues + if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) && + !jQuery.isXMLDoc( elem ) ) { + + // We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2 + destElements = getAll( clone ); + srcElements = getAll( elem ); + + for ( i = 0, l = srcElements.length; i < l; i++ ) { + fixInput( srcElements[ i ], destElements[ i ] ); + } + } + + // Copy the events from the original to the clone + if ( dataAndEvents ) { + if ( deepDataAndEvents ) { + srcElements = srcElements || getAll( elem ); + destElements = destElements || getAll( clone ); + + for ( i = 0, l = srcElements.length; i < l; i++ ) { + cloneCopyEvent( srcElements[ i ], destElements[ i ] ); + } + } else { + cloneCopyEvent( elem, clone ); + } + } + + // Preserve script evaluation history + destElements = getAll( clone, "script" ); + if ( destElements.length > 0 ) { + setGlobalEval( destElements, !inPage && getAll( elem, "script" ) ); + } + + // Return the cloned set + return clone; + }, + + cleanData: function( elems ) { + var data, elem, type, + special = jQuery.event.special, + i = 0; + + for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) { + if ( acceptData( elem ) ) { + if ( ( data = elem[ dataPriv.expando ] ) ) { + if ( data.events ) { + for ( type in data.events ) { + if ( special[ type ] ) { + jQuery.event.remove( elem, type ); + + // This is a shortcut to avoid jQuery.event.remove's overhead + } else { + jQuery.removeEvent( elem, type, data.handle ); + } + } + } + + // Support: Chrome <=35 - 45+ + // Assign undefined instead of using delete, see Data#remove + elem[ dataPriv.expando ] = undefined; + } + if ( elem[ dataUser.expando ] ) { + + // Support: Chrome <=35 - 45+ + // Assign undefined instead of using delete, see Data#remove + elem[ dataUser.expando ] = undefined; + } + } + } + } +} ); + +jQuery.fn.extend( { + detach: function( selector ) { + return remove( this, selector, true ); + }, + + remove: function( selector ) { + return remove( this, selector ); + }, + + text: function( value ) { + return access( this, function( value ) { + return value === undefined ? + jQuery.text( this ) : + this.empty().each( function() { + if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { + this.textContent = value; + } + } ); + }, null, value, arguments.length ); + }, + + append: function() { + return domManip( this, arguments, function( elem ) { + if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { + var target = manipulationTarget( this, elem ); + target.appendChild( elem ); + } + } ); + }, + + prepend: function() { + return domManip( this, arguments, function( elem ) { + if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { + var target = manipulationTarget( this, elem ); + target.insertBefore( elem, target.firstChild ); + } + } ); + }, + + before: function() { + return domManip( this, arguments, function( elem ) { + if ( this.parentNode ) { + this.parentNode.insertBefore( elem, this ); + } + } ); + }, + + after: function() { + return domManip( this, arguments, function( elem ) { + if ( this.parentNode ) { + this.parentNode.insertBefore( elem, this.nextSibling ); + } + } ); + }, + + empty: function() { + var elem, + i = 0; + + for ( ; ( elem = this[ i ] ) != null; i++ ) { + if ( elem.nodeType === 1 ) { + + // Prevent memory leaks + jQuery.cleanData( getAll( elem, false ) ); + + // Remove any remaining nodes + elem.textContent = ""; + } + } + + return this; + }, + + clone: function( dataAndEvents, deepDataAndEvents ) { + dataAndEvents = dataAndEvents == null ? false : dataAndEvents; + deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents; + + return this.map( function() { + return jQuery.clone( this, dataAndEvents, deepDataAndEvents ); + } ); + }, + + html: function( value ) { + return access( this, function( value ) { + var elem = this[ 0 ] || {}, + i = 0, + l = this.length; + + if ( value === undefined && elem.nodeType === 1 ) { + return elem.innerHTML; + } + + // See if we can take a shortcut and just use innerHTML + if ( typeof value === "string" && !rnoInnerhtml.test( value ) && + !wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) { + + value = jQuery.htmlPrefilter( value ); + + try { + for ( ; i < l; i++ ) { + elem = this[ i ] || {}; + + // Remove element nodes and prevent memory leaks + if ( elem.nodeType === 1 ) { + jQuery.cleanData( getAll( elem, false ) ); + elem.innerHTML = value; + } + } + + elem = 0; + + // If using innerHTML throws an exception, use the fallback method + } catch ( e ) {} + } + + if ( elem ) { + this.empty().append( value ); + } + }, null, value, arguments.length ); + }, + + replaceWith: function() { + var ignored = []; + + // Make the changes, replacing each non-ignored context element with the new content + return domManip( this, arguments, function( elem ) { + var parent = this.parentNode; + + if ( jQuery.inArray( this, ignored ) < 0 ) { + jQuery.cleanData( getAll( this ) ); + if ( parent ) { + parent.replaceChild( elem, this ); + } + } + + // Force callback invocation + }, ignored ); + } +} ); + +jQuery.each( { + appendTo: "append", + prependTo: "prepend", + insertBefore: "before", + insertAfter: "after", + replaceAll: "replaceWith" +}, function( name, original ) { + jQuery.fn[ name ] = function( selector ) { + var elems, + ret = [], + insert = jQuery( selector ), + last = insert.length - 1, + i = 0; + + for ( ; i <= last; i++ ) { + elems = i === last ? this : this.clone( true ); + jQuery( insert[ i ] )[ original ]( elems ); + + // Support: Android <=4.0 only, PhantomJS 1 only + // .get() because push.apply(_, arraylike) throws on ancient WebKit + push.apply( ret, elems.get() ); + } + + return this.pushStack( ret ); + }; +} ); +var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" ); + +var getStyles = function( elem ) { + + // Support: IE <=11 only, Firefox <=30 (#15098, #14150) + // IE throws on elements created in popups + // FF meanwhile throws on frame elements through "defaultView.getComputedStyle" + var view = elem.ownerDocument.defaultView; + + if ( !view || !view.opener ) { + view = window; + } + + return view.getComputedStyle( elem ); + }; + +var swap = function( elem, options, callback ) { + var ret, name, + old = {}; + + // Remember the old values, and insert the new ones + for ( name in options ) { + old[ name ] = elem.style[ name ]; + elem.style[ name ] = options[ name ]; + } + + ret = callback.call( elem ); + + // Revert the old values + for ( name in options ) { + elem.style[ name ] = old[ name ]; + } + + return ret; +}; + + +var rboxStyle = new RegExp( cssExpand.join( "|" ), "i" ); + + + +( function() { + + // Executing both pixelPosition & boxSizingReliable tests require only one layout + // so they're executed at the same time to save the second computation. + function computeStyleTests() { + + // This is a singleton, we need to execute it only once + if ( !div ) { + return; + } + + container.style.cssText = "position:absolute;left:-11111px;width:60px;" + + "margin-top:1px;padding:0;border:0"; + div.style.cssText = + "position:relative;display:block;box-sizing:border-box;overflow:scroll;" + + "margin:auto;border:1px;padding:1px;" + + "width:60%;top:1%"; + documentElement.appendChild( container ).appendChild( div ); + + var divStyle = window.getComputedStyle( div ); + pixelPositionVal = divStyle.top !== "1%"; + + // Support: Android 4.0 - 4.3 only, Firefox <=3 - 44 + reliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12; + + // Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3 + // Some styles come back with percentage values, even though they shouldn't + div.style.right = "60%"; + pixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36; + + // Support: IE 9 - 11 only + // Detect misreporting of content dimensions for box-sizing:border-box elements + boxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36; + + // Support: IE 9 only + // Detect overflow:scroll screwiness (gh-3699) + // Support: Chrome <=64 + // Don't get tricked when zoom affects offsetWidth (gh-4029) + div.style.position = "absolute"; + scrollboxSizeVal = roundPixelMeasures( div.offsetWidth / 3 ) === 12; + + documentElement.removeChild( container ); + + // Nullify the div so it wouldn't be stored in the memory and + // it will also be a sign that checks already performed + div = null; + } + + function roundPixelMeasures( measure ) { + return Math.round( parseFloat( measure ) ); + } + + var pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal, + reliableTrDimensionsVal, reliableMarginLeftVal, + container = document.createElement( "div" ), + div = document.createElement( "div" ); + + // Finish early in limited (non-browser) environments + if ( !div.style ) { + return; + } + + // Support: IE <=9 - 11 only + // Style of cloned element affects source element cloned (#8908) + div.style.backgroundClip = "content-box"; + div.cloneNode( true ).style.backgroundClip = ""; + support.clearCloneStyle = div.style.backgroundClip === "content-box"; + + jQuery.extend( support, { + boxSizingReliable: function() { + computeStyleTests(); + return boxSizingReliableVal; + }, + pixelBoxStyles: function() { + computeStyleTests(); + return pixelBoxStylesVal; + }, + pixelPosition: function() { + computeStyleTests(); + return pixelPositionVal; + }, + reliableMarginLeft: function() { + computeStyleTests(); + return reliableMarginLeftVal; + }, + scrollboxSize: function() { + computeStyleTests(); + return scrollboxSizeVal; + }, + + // Support: IE 9 - 11+, Edge 15 - 18+ + // IE/Edge misreport `getComputedStyle` of table rows with width/height + // set in CSS while `offset*` properties report correct values. + // Behavior in IE 9 is more subtle than in newer versions & it passes + // some versions of this test; make sure not to make it pass there! + reliableTrDimensions: function() { + var table, tr, trChild, trStyle; + if ( reliableTrDimensionsVal == null ) { + table = document.createElement( "table" ); + tr = document.createElement( "tr" ); + trChild = document.createElement( "div" ); + + table.style.cssText = "position:absolute;left:-11111px"; + tr.style.height = "1px"; + trChild.style.height = "9px"; + + documentElement + .appendChild( table ) + .appendChild( tr ) + .appendChild( trChild ); + + trStyle = window.getComputedStyle( tr ); + reliableTrDimensionsVal = parseInt( trStyle.height ) > 3; + + documentElement.removeChild( table ); + } + return reliableTrDimensionsVal; + } + } ); +} )(); + + +function curCSS( elem, name, computed ) { + var width, minWidth, maxWidth, ret, + + // Support: Firefox 51+ + // Retrieving style before computed somehow + // fixes an issue with getting wrong values + // on detached elements + style = elem.style; + + computed = computed || getStyles( elem ); + + // getPropertyValue is needed for: + // .css('filter') (IE 9 only, #12537) + // .css('--customProperty) (#3144) + if ( computed ) { + ret = computed.getPropertyValue( name ) || computed[ name ]; + + if ( ret === "" && !isAttached( elem ) ) { + ret = jQuery.style( elem, name ); + } + + // A tribute to the "awesome hack by Dean Edwards" + // Android Browser returns percentage for some values, + // but width seems to be reliably pixels. + // This is against the CSSOM draft spec: + // https://drafts.csswg.org/cssom/#resolved-values + if ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) { + + // Remember the original values + width = style.width; + minWidth = style.minWidth; + maxWidth = style.maxWidth; + + // Put in the new values to get a computed value out + style.minWidth = style.maxWidth = style.width = ret; + ret = computed.width; + + // Revert the changed values + style.width = width; + style.minWidth = minWidth; + style.maxWidth = maxWidth; + } + } + + return ret !== undefined ? + + // Support: IE <=9 - 11 only + // IE returns zIndex value as an integer. + ret + "" : + ret; +} + + +function addGetHookIf( conditionFn, hookFn ) { + + // Define the hook, we'll check on the first run if it's really needed. + return { + get: function() { + if ( conditionFn() ) { + + // Hook not needed (or it's not possible to use it due + // to missing dependency), remove it. + delete this.get; + return; + } + + // Hook needed; redefine it so that the support test is not executed again. + return ( this.get = hookFn ).apply( this, arguments ); + } + }; +} + + +var cssPrefixes = [ "Webkit", "Moz", "ms" ], + emptyStyle = document.createElement( "div" ).style, + vendorProps = {}; + +// Return a vendor-prefixed property or undefined +function vendorPropName( name ) { + + // Check for vendor prefixed names + var capName = name[ 0 ].toUpperCase() + name.slice( 1 ), + i = cssPrefixes.length; + + while ( i-- ) { + name = cssPrefixes[ i ] + capName; + if ( name in emptyStyle ) { + return name; + } + } +} + +// Return a potentially-mapped jQuery.cssProps or vendor prefixed property +function finalPropName( name ) { + var final = jQuery.cssProps[ name ] || vendorProps[ name ]; + + if ( final ) { + return final; + } + if ( name in emptyStyle ) { + return name; + } + return vendorProps[ name ] = vendorPropName( name ) || name; +} + + +var + + // Swappable if display is none or starts with table + // except "table", "table-cell", or "table-caption" + // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display + rdisplayswap = /^(none|table(?!-c[ea]).+)/, + rcustomProp = /^--/, + cssShow = { position: "absolute", visibility: "hidden", display: "block" }, + cssNormalTransform = { + letterSpacing: "0", + fontWeight: "400" + }; + +function setPositiveNumber( _elem, value, subtract ) { + + // Any relative (+/-) values have already been + // normalized at this point + var matches = rcssNum.exec( value ); + return matches ? + + // Guard against undefined "subtract", e.g., when used as in cssHooks + Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) : + value; +} + +function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) { + var i = dimension === "width" ? 1 : 0, + extra = 0, + delta = 0; + + // Adjustment may not be necessary + if ( box === ( isBorderBox ? "border" : "content" ) ) { + return 0; + } + + for ( ; i < 4; i += 2 ) { + + // Both box models exclude margin + if ( box === "margin" ) { + delta += jQuery.css( elem, box + cssExpand[ i ], true, styles ); + } + + // If we get here with a content-box, we're seeking "padding" or "border" or "margin" + if ( !isBorderBox ) { + + // Add padding + delta += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); + + // For "border" or "margin", add border + if ( box !== "padding" ) { + delta += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); + + // But still keep track of it otherwise + } else { + extra += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); + } + + // If we get here with a border-box (content + padding + border), we're seeking "content" or + // "padding" or "margin" + } else { + + // For "content", subtract padding + if ( box === "content" ) { + delta -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); + } + + // For "content" or "padding", subtract border + if ( box !== "margin" ) { + delta -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); + } + } + } + + // Account for positive content-box scroll gutter when requested by providing computedVal + if ( !isBorderBox && computedVal >= 0 ) { + + // offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border + // Assuming integer scroll gutter, subtract the rest and round down + delta += Math.max( 0, Math.ceil( + elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] - + computedVal - + delta - + extra - + 0.5 + + // If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter + // Use an explicit zero to avoid NaN (gh-3964) + ) ) || 0; + } + + return delta; +} + +function getWidthOrHeight( elem, dimension, extra ) { + + // Start with computed style + var styles = getStyles( elem ), + + // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322). + // Fake content-box until we know it's needed to know the true value. + boxSizingNeeded = !support.boxSizingReliable() || extra, + isBorderBox = boxSizingNeeded && + jQuery.css( elem, "boxSizing", false, styles ) === "border-box", + valueIsBorderBox = isBorderBox, + + val = curCSS( elem, dimension, styles ), + offsetProp = "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ); + + // Support: Firefox <=54 + // Return a confounding non-pixel value or feign ignorance, as appropriate. + if ( rnumnonpx.test( val ) ) { + if ( !extra ) { + return val; + } + val = "auto"; + } + + + // Support: IE 9 - 11 only + // Use offsetWidth/offsetHeight for when box sizing is unreliable. + // In those cases, the computed value can be trusted to be border-box. + if ( ( !support.boxSizingReliable() && isBorderBox || + + // Support: IE 10 - 11+, Edge 15 - 18+ + // IE/Edge misreport `getComputedStyle` of table rows with width/height + // set in CSS while `offset*` properties report correct values. + // Interestingly, in some cases IE 9 doesn't suffer from this issue. + !support.reliableTrDimensions() && nodeName( elem, "tr" ) || + + // Fall back to offsetWidth/offsetHeight when value is "auto" + // This happens for inline elements with no explicit setting (gh-3571) + val === "auto" || + + // Support: Android <=4.1 - 4.3 only + // Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602) + !parseFloat( val ) && jQuery.css( elem, "display", false, styles ) === "inline" ) && + + // Make sure the element is visible & connected + elem.getClientRects().length ) { + + isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box"; + + // Where available, offsetWidth/offsetHeight approximate border box dimensions. + // Where not available (e.g., SVG), assume unreliable box-sizing and interpret the + // retrieved value as a content box dimension. + valueIsBorderBox = offsetProp in elem; + if ( valueIsBorderBox ) { + val = elem[ offsetProp ]; + } + } + + // Normalize "" and auto + val = parseFloat( val ) || 0; + + // Adjust for the element's box model + return ( val + + boxModelAdjustment( + elem, + dimension, + extra || ( isBorderBox ? "border" : "content" ), + valueIsBorderBox, + styles, + + // Provide the current computed size to request scroll gutter calculation (gh-3589) + val + ) + ) + "px"; +} + +jQuery.extend( { + + // Add in style property hooks for overriding the default + // behavior of getting and setting a style property + cssHooks: { + opacity: { + get: function( elem, computed ) { + if ( computed ) { + + // We should always get a number back from opacity + var ret = curCSS( elem, "opacity" ); + return ret === "" ? "1" : ret; + } + } + } + }, + + // Don't automatically add "px" to these possibly-unitless properties + cssNumber: { + "animationIterationCount": true, + "columnCount": true, + "fillOpacity": true, + "flexGrow": true, + "flexShrink": true, + "fontWeight": true, + "gridArea": true, + "gridColumn": true, + "gridColumnEnd": true, + "gridColumnStart": true, + "gridRow": true, + "gridRowEnd": true, + "gridRowStart": true, + "lineHeight": true, + "opacity": true, + "order": true, + "orphans": true, + "widows": true, + "zIndex": true, + "zoom": true + }, + + // Add in properties whose names you wish to fix before + // setting or getting the value + cssProps: {}, + + // Get and set the style property on a DOM Node + style: function( elem, name, value, extra ) { + + // Don't set styles on text and comment nodes + if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) { + return; + } + + // Make sure that we're working with the right name + var ret, type, hooks, + origName = camelCase( name ), + isCustomProp = rcustomProp.test( name ), + style = elem.style; + + // Make sure that we're working with the right name. We don't + // want to query the value if it is a CSS custom property + // since they are user-defined. + if ( !isCustomProp ) { + name = finalPropName( origName ); + } + + // Gets hook for the prefixed version, then unprefixed version + hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; + + // Check if we're setting a value + if ( value !== undefined ) { + type = typeof value; + + // Convert "+=" or "-=" to relative numbers (#7345) + if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) { + value = adjustCSS( elem, name, ret ); + + // Fixes bug #9237 + type = "number"; + } + + // Make sure that null and NaN values aren't set (#7116) + if ( value == null || value !== value ) { + return; + } + + // If a number was passed in, add the unit (except for certain CSS properties) + // The isCustomProp check can be removed in jQuery 4.0 when we only auto-append + // "px" to a few hardcoded values. + if ( type === "number" && !isCustomProp ) { + value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" ); + } + + // background-* props affect original clone's values + if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) { + style[ name ] = "inherit"; + } + + // If a hook was provided, use that value, otherwise just set the specified value + if ( !hooks || !( "set" in hooks ) || + ( value = hooks.set( elem, value, extra ) ) !== undefined ) { + + if ( isCustomProp ) { + style.setProperty( name, value ); + } else { + style[ name ] = value; + } + } + + } else { + + // If a hook was provided get the non-computed value from there + if ( hooks && "get" in hooks && + ( ret = hooks.get( elem, false, extra ) ) !== undefined ) { + + return ret; + } + + // Otherwise just get the value from the style object + return style[ name ]; + } + }, + + css: function( elem, name, extra, styles ) { + var val, num, hooks, + origName = camelCase( name ), + isCustomProp = rcustomProp.test( name ); + + // Make sure that we're working with the right name. We don't + // want to modify the value if it is a CSS custom property + // since they are user-defined. + if ( !isCustomProp ) { + name = finalPropName( origName ); + } + + // Try prefixed name followed by the unprefixed name + hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; + + // If a hook was provided get the computed value from there + if ( hooks && "get" in hooks ) { + val = hooks.get( elem, true, extra ); + } + + // Otherwise, if a way to get the computed value exists, use that + if ( val === undefined ) { + val = curCSS( elem, name, styles ); + } + + // Convert "normal" to computed value + if ( val === "normal" && name in cssNormalTransform ) { + val = cssNormalTransform[ name ]; + } + + // Make numeric if forced or a qualifier was provided and val looks numeric + if ( extra === "" || extra ) { + num = parseFloat( val ); + return extra === true || isFinite( num ) ? num || 0 : val; + } + + return val; + } +} ); + +jQuery.each( [ "height", "width" ], function( _i, dimension ) { + jQuery.cssHooks[ dimension ] = { + get: function( elem, computed, extra ) { + if ( computed ) { + + // Certain elements can have dimension info if we invisibly show them + // but it must have a current display style that would benefit + return rdisplayswap.test( jQuery.css( elem, "display" ) ) && + + // Support: Safari 8+ + // Table columns in Safari have non-zero offsetWidth & zero + // getBoundingClientRect().width unless display is changed. + // Support: IE <=11 only + // Running getBoundingClientRect on a disconnected node + // in IE throws an error. + ( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ? + swap( elem, cssShow, function() { + return getWidthOrHeight( elem, dimension, extra ); + } ) : + getWidthOrHeight( elem, dimension, extra ); + } + }, + + set: function( elem, value, extra ) { + var matches, + styles = getStyles( elem ), + + // Only read styles.position if the test has a chance to fail + // to avoid forcing a reflow. + scrollboxSizeBuggy = !support.scrollboxSize() && + styles.position === "absolute", + + // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991) + boxSizingNeeded = scrollboxSizeBuggy || extra, + isBorderBox = boxSizingNeeded && + jQuery.css( elem, "boxSizing", false, styles ) === "border-box", + subtract = extra ? + boxModelAdjustment( + elem, + dimension, + extra, + isBorderBox, + styles + ) : + 0; + + // Account for unreliable border-box dimensions by comparing offset* to computed and + // faking a content-box to get border and padding (gh-3699) + if ( isBorderBox && scrollboxSizeBuggy ) { + subtract -= Math.ceil( + elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] - + parseFloat( styles[ dimension ] ) - + boxModelAdjustment( elem, dimension, "border", false, styles ) - + 0.5 + ); + } + + // Convert to pixels if value adjustment is needed + if ( subtract && ( matches = rcssNum.exec( value ) ) && + ( matches[ 3 ] || "px" ) !== "px" ) { + + elem.style[ dimension ] = value; + value = jQuery.css( elem, dimension ); + } + + return setPositiveNumber( elem, value, subtract ); + } + }; +} ); + +jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft, + function( elem, computed ) { + if ( computed ) { + return ( parseFloat( curCSS( elem, "marginLeft" ) ) || + elem.getBoundingClientRect().left - + swap( elem, { marginLeft: 0 }, function() { + return elem.getBoundingClientRect().left; + } ) + ) + "px"; + } + } +); + +// These hooks are used by animate to expand properties +jQuery.each( { + margin: "", + padding: "", + border: "Width" +}, function( prefix, suffix ) { + jQuery.cssHooks[ prefix + suffix ] = { + expand: function( value ) { + var i = 0, + expanded = {}, + + // Assumes a single number if not a string + parts = typeof value === "string" ? value.split( " " ) : [ value ]; + + for ( ; i < 4; i++ ) { + expanded[ prefix + cssExpand[ i ] + suffix ] = + parts[ i ] || parts[ i - 2 ] || parts[ 0 ]; + } + + return expanded; + } + }; + + if ( prefix !== "margin" ) { + jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber; + } +} ); + +jQuery.fn.extend( { + css: function( name, value ) { + return access( this, function( elem, name, value ) { + var styles, len, + map = {}, + i = 0; + + if ( Array.isArray( name ) ) { + styles = getStyles( elem ); + len = name.length; + + for ( ; i < len; i++ ) { + map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles ); + } + + return map; + } + + return value !== undefined ? + jQuery.style( elem, name, value ) : + jQuery.css( elem, name ); + }, name, value, arguments.length > 1 ); + } +} ); + + +function Tween( elem, options, prop, end, easing ) { + return new Tween.prototype.init( elem, options, prop, end, easing ); +} +jQuery.Tween = Tween; + +Tween.prototype = { + constructor: Tween, + init: function( elem, options, prop, end, easing, unit ) { + this.elem = elem; + this.prop = prop; + this.easing = easing || jQuery.easing._default; + this.options = options; + this.start = this.now = this.cur(); + this.end = end; + this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" ); + }, + cur: function() { + var hooks = Tween.propHooks[ this.prop ]; + + return hooks && hooks.get ? + hooks.get( this ) : + Tween.propHooks._default.get( this ); + }, + run: function( percent ) { + var eased, + hooks = Tween.propHooks[ this.prop ]; + + if ( this.options.duration ) { + this.pos = eased = jQuery.easing[ this.easing ]( + percent, this.options.duration * percent, 0, 1, this.options.duration + ); + } else { + this.pos = eased = percent; + } + this.now = ( this.end - this.start ) * eased + this.start; + + if ( this.options.step ) { + this.options.step.call( this.elem, this.now, this ); + } + + if ( hooks && hooks.set ) { + hooks.set( this ); + } else { + Tween.propHooks._default.set( this ); + } + return this; + } +}; + +Tween.prototype.init.prototype = Tween.prototype; + +Tween.propHooks = { + _default: { + get: function( tween ) { + var result; + + // Use a property on the element directly when it is not a DOM element, + // or when there is no matching style property that exists. + if ( tween.elem.nodeType !== 1 || + tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) { + return tween.elem[ tween.prop ]; + } + + // Passing an empty string as a 3rd parameter to .css will automatically + // attempt a parseFloat and fallback to a string if the parse fails. + // Simple values such as "10px" are parsed to Float; + // complex values such as "rotate(1rad)" are returned as-is. + result = jQuery.css( tween.elem, tween.prop, "" ); + + // Empty strings, null, undefined and "auto" are converted to 0. + return !result || result === "auto" ? 0 : result; + }, + set: function( tween ) { + + // Use step hook for back compat. + // Use cssHook if its there. + // Use .style if available and use plain properties where available. + if ( jQuery.fx.step[ tween.prop ] ) { + jQuery.fx.step[ tween.prop ]( tween ); + } else if ( tween.elem.nodeType === 1 && ( + jQuery.cssHooks[ tween.prop ] || + tween.elem.style[ finalPropName( tween.prop ) ] != null ) ) { + jQuery.style( tween.elem, tween.prop, tween.now + tween.unit ); + } else { + tween.elem[ tween.prop ] = tween.now; + } + } + } +}; + +// Support: IE <=9 only +// Panic based approach to setting things on disconnected nodes +Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = { + set: function( tween ) { + if ( tween.elem.nodeType && tween.elem.parentNode ) { + tween.elem[ tween.prop ] = tween.now; + } + } +}; + +jQuery.easing = { + linear: function( p ) { + return p; + }, + swing: function( p ) { + return 0.5 - Math.cos( p * Math.PI ) / 2; + }, + _default: "swing" +}; + +jQuery.fx = Tween.prototype.init; + +// Back compat <1.8 extension point +jQuery.fx.step = {}; + + + + +var + fxNow, inProgress, + rfxtypes = /^(?:toggle|show|hide)$/, + rrun = /queueHooks$/; + +function schedule() { + if ( inProgress ) { + if ( document.hidden === false && window.requestAnimationFrame ) { + window.requestAnimationFrame( schedule ); + } else { + window.setTimeout( schedule, jQuery.fx.interval ); + } + + jQuery.fx.tick(); + } +} + +// Animations created synchronously will run synchronously +function createFxNow() { + window.setTimeout( function() { + fxNow = undefined; + } ); + return ( fxNow = Date.now() ); +} + +// Generate parameters to create a standard animation +function genFx( type, includeWidth ) { + var which, + i = 0, + attrs = { height: type }; + + // If we include width, step value is 1 to do all cssExpand values, + // otherwise step value is 2 to skip over Left and Right + includeWidth = includeWidth ? 1 : 0; + for ( ; i < 4; i += 2 - includeWidth ) { + which = cssExpand[ i ]; + attrs[ "margin" + which ] = attrs[ "padding" + which ] = type; + } + + if ( includeWidth ) { + attrs.opacity = attrs.width = type; + } + + return attrs; +} + +function createTween( value, prop, animation ) { + var tween, + collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ), + index = 0, + length = collection.length; + for ( ; index < length; index++ ) { + if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) { + + // We're done with this property + return tween; + } + } +} + +function defaultPrefilter( elem, props, opts ) { + var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display, + isBox = "width" in props || "height" in props, + anim = this, + orig = {}, + style = elem.style, + hidden = elem.nodeType && isHiddenWithinTree( elem ), + dataShow = dataPriv.get( elem, "fxshow" ); + + // Queue-skipping animations hijack the fx hooks + if ( !opts.queue ) { + hooks = jQuery._queueHooks( elem, "fx" ); + if ( hooks.unqueued == null ) { + hooks.unqueued = 0; + oldfire = hooks.empty.fire; + hooks.empty.fire = function() { + if ( !hooks.unqueued ) { + oldfire(); + } + }; + } + hooks.unqueued++; + + anim.always( function() { + + // Ensure the complete handler is called before this completes + anim.always( function() { + hooks.unqueued--; + if ( !jQuery.queue( elem, "fx" ).length ) { + hooks.empty.fire(); + } + } ); + } ); + } + + // Detect show/hide animations + for ( prop in props ) { + value = props[ prop ]; + if ( rfxtypes.test( value ) ) { + delete props[ prop ]; + toggle = toggle || value === "toggle"; + if ( value === ( hidden ? "hide" : "show" ) ) { + + // Pretend to be hidden if this is a "show" and + // there is still data from a stopped show/hide + if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) { + hidden = true; + + // Ignore all other no-op show/hide data + } else { + continue; + } + } + orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop ); + } + } + + // Bail out if this is a no-op like .hide().hide() + propTween = !jQuery.isEmptyObject( props ); + if ( !propTween && jQuery.isEmptyObject( orig ) ) { + return; + } + + // Restrict "overflow" and "display" styles during box animations + if ( isBox && elem.nodeType === 1 ) { + + // Support: IE <=9 - 11, Edge 12 - 15 + // Record all 3 overflow attributes because IE does not infer the shorthand + // from identically-valued overflowX and overflowY and Edge just mirrors + // the overflowX value there. + opts.overflow = [ style.overflow, style.overflowX, style.overflowY ]; + + // Identify a display type, preferring old show/hide data over the CSS cascade + restoreDisplay = dataShow && dataShow.display; + if ( restoreDisplay == null ) { + restoreDisplay = dataPriv.get( elem, "display" ); + } + display = jQuery.css( elem, "display" ); + if ( display === "none" ) { + if ( restoreDisplay ) { + display = restoreDisplay; + } else { + + // Get nonempty value(s) by temporarily forcing visibility + showHide( [ elem ], true ); + restoreDisplay = elem.style.display || restoreDisplay; + display = jQuery.css( elem, "display" ); + showHide( [ elem ] ); + } + } + + // Animate inline elements as inline-block + if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) { + if ( jQuery.css( elem, "float" ) === "none" ) { + + // Restore the original display value at the end of pure show/hide animations + if ( !propTween ) { + anim.done( function() { + style.display = restoreDisplay; + } ); + if ( restoreDisplay == null ) { + display = style.display; + restoreDisplay = display === "none" ? "" : display; + } + } + style.display = "inline-block"; + } + } + } + + if ( opts.overflow ) { + style.overflow = "hidden"; + anim.always( function() { + style.overflow = opts.overflow[ 0 ]; + style.overflowX = opts.overflow[ 1 ]; + style.overflowY = opts.overflow[ 2 ]; + } ); + } + + // Implement show/hide animations + propTween = false; + for ( prop in orig ) { + + // General show/hide setup for this element animation + if ( !propTween ) { + if ( dataShow ) { + if ( "hidden" in dataShow ) { + hidden = dataShow.hidden; + } + } else { + dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } ); + } + + // Store hidden/visible for toggle so `.stop().toggle()` "reverses" + if ( toggle ) { + dataShow.hidden = !hidden; + } + + // Show elements before animating them + if ( hidden ) { + showHide( [ elem ], true ); + } + + /* eslint-disable no-loop-func */ + + anim.done( function() { + + /* eslint-enable no-loop-func */ + + // The final step of a "hide" animation is actually hiding the element + if ( !hidden ) { + showHide( [ elem ] ); + } + dataPriv.remove( elem, "fxshow" ); + for ( prop in orig ) { + jQuery.style( elem, prop, orig[ prop ] ); + } + } ); + } + + // Per-property setup + propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim ); + if ( !( prop in dataShow ) ) { + dataShow[ prop ] = propTween.start; + if ( hidden ) { + propTween.end = propTween.start; + propTween.start = 0; + } + } + } +} + +function propFilter( props, specialEasing ) { + var index, name, easing, value, hooks; + + // camelCase, specialEasing and expand cssHook pass + for ( index in props ) { + name = camelCase( index ); + easing = specialEasing[ name ]; + value = props[ index ]; + if ( Array.isArray( value ) ) { + easing = value[ 1 ]; + value = props[ index ] = value[ 0 ]; + } + + if ( index !== name ) { + props[ name ] = value; + delete props[ index ]; + } + + hooks = jQuery.cssHooks[ name ]; + if ( hooks && "expand" in hooks ) { + value = hooks.expand( value ); + delete props[ name ]; + + // Not quite $.extend, this won't overwrite existing keys. + // Reusing 'index' because we have the correct "name" + for ( index in value ) { + if ( !( index in props ) ) { + props[ index ] = value[ index ]; + specialEasing[ index ] = easing; + } + } + } else { + specialEasing[ name ] = easing; + } + } +} + +function Animation( elem, properties, options ) { + var result, + stopped, + index = 0, + length = Animation.prefilters.length, + deferred = jQuery.Deferred().always( function() { + + // Don't match elem in the :animated selector + delete tick.elem; + } ), + tick = function() { + if ( stopped ) { + return false; + } + var currentTime = fxNow || createFxNow(), + remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ), + + // Support: Android 2.3 only + // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497) + temp = remaining / animation.duration || 0, + percent = 1 - temp, + index = 0, + length = animation.tweens.length; + + for ( ; index < length; index++ ) { + animation.tweens[ index ].run( percent ); + } + + deferred.notifyWith( elem, [ animation, percent, remaining ] ); + + // If there's more to do, yield + if ( percent < 1 && length ) { + return remaining; + } + + // If this was an empty animation, synthesize a final progress notification + if ( !length ) { + deferred.notifyWith( elem, [ animation, 1, 0 ] ); + } + + // Resolve the animation and report its conclusion + deferred.resolveWith( elem, [ animation ] ); + return false; + }, + animation = deferred.promise( { + elem: elem, + props: jQuery.extend( {}, properties ), + opts: jQuery.extend( true, { + specialEasing: {}, + easing: jQuery.easing._default + }, options ), + originalProperties: properties, + originalOptions: options, + startTime: fxNow || createFxNow(), + duration: options.duration, + tweens: [], + createTween: function( prop, end ) { + var tween = jQuery.Tween( elem, animation.opts, prop, end, + animation.opts.specialEasing[ prop ] || animation.opts.easing ); + animation.tweens.push( tween ); + return tween; + }, + stop: function( gotoEnd ) { + var index = 0, + + // If we are going to the end, we want to run all the tweens + // otherwise we skip this part + length = gotoEnd ? animation.tweens.length : 0; + if ( stopped ) { + return this; + } + stopped = true; + for ( ; index < length; index++ ) { + animation.tweens[ index ].run( 1 ); + } + + // Resolve when we played the last frame; otherwise, reject + if ( gotoEnd ) { + deferred.notifyWith( elem, [ animation, 1, 0 ] ); + deferred.resolveWith( elem, [ animation, gotoEnd ] ); + } else { + deferred.rejectWith( elem, [ animation, gotoEnd ] ); + } + return this; + } + } ), + props = animation.props; + + propFilter( props, animation.opts.specialEasing ); + + for ( ; index < length; index++ ) { + result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts ); + if ( result ) { + if ( isFunction( result.stop ) ) { + jQuery._queueHooks( animation.elem, animation.opts.queue ).stop = + result.stop.bind( result ); + } + return result; + } + } + + jQuery.map( props, createTween, animation ); + + if ( isFunction( animation.opts.start ) ) { + animation.opts.start.call( elem, animation ); + } + + // Attach callbacks from options + animation + .progress( animation.opts.progress ) + .done( animation.opts.done, animation.opts.complete ) + .fail( animation.opts.fail ) + .always( animation.opts.always ); + + jQuery.fx.timer( + jQuery.extend( tick, { + elem: elem, + anim: animation, + queue: animation.opts.queue + } ) + ); + + return animation; +} + +jQuery.Animation = jQuery.extend( Animation, { + + tweeners: { + "*": [ function( prop, value ) { + var tween = this.createTween( prop, value ); + adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween ); + return tween; + } ] + }, + + tweener: function( props, callback ) { + if ( isFunction( props ) ) { + callback = props; + props = [ "*" ]; + } else { + props = props.match( rnothtmlwhite ); + } + + var prop, + index = 0, + length = props.length; + + for ( ; index < length; index++ ) { + prop = props[ index ]; + Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || []; + Animation.tweeners[ prop ].unshift( callback ); + } + }, + + prefilters: [ defaultPrefilter ], + + prefilter: function( callback, prepend ) { + if ( prepend ) { + Animation.prefilters.unshift( callback ); + } else { + Animation.prefilters.push( callback ); + } + } +} ); + +jQuery.speed = function( speed, easing, fn ) { + var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : { + complete: fn || !fn && easing || + isFunction( speed ) && speed, + duration: speed, + easing: fn && easing || easing && !isFunction( easing ) && easing + }; + + // Go to the end state if fx are off + if ( jQuery.fx.off ) { + opt.duration = 0; + + } else { + if ( typeof opt.duration !== "number" ) { + if ( opt.duration in jQuery.fx.speeds ) { + opt.duration = jQuery.fx.speeds[ opt.duration ]; + + } else { + opt.duration = jQuery.fx.speeds._default; + } + } + } + + // Normalize opt.queue - true/undefined/null -> "fx" + if ( opt.queue == null || opt.queue === true ) { + opt.queue = "fx"; + } + + // Queueing + opt.old = opt.complete; + + opt.complete = function() { + if ( isFunction( opt.old ) ) { + opt.old.call( this ); + } + + if ( opt.queue ) { + jQuery.dequeue( this, opt.queue ); + } + }; + + return opt; +}; + +jQuery.fn.extend( { + fadeTo: function( speed, to, easing, callback ) { + + // Show any hidden elements after setting opacity to 0 + return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show() + + // Animate to the value specified + .end().animate( { opacity: to }, speed, easing, callback ); + }, + animate: function( prop, speed, easing, callback ) { + var empty = jQuery.isEmptyObject( prop ), + optall = jQuery.speed( speed, easing, callback ), + doAnimation = function() { + + // Operate on a copy of prop so per-property easing won't be lost + var anim = Animation( this, jQuery.extend( {}, prop ), optall ); + + // Empty animations, or finishing resolves immediately + if ( empty || dataPriv.get( this, "finish" ) ) { + anim.stop( true ); + } + }; + doAnimation.finish = doAnimation; + + return empty || optall.queue === false ? + this.each( doAnimation ) : + this.queue( optall.queue, doAnimation ); + }, + stop: function( type, clearQueue, gotoEnd ) { + var stopQueue = function( hooks ) { + var stop = hooks.stop; + delete hooks.stop; + stop( gotoEnd ); + }; + + if ( typeof type !== "string" ) { + gotoEnd = clearQueue; + clearQueue = type; + type = undefined; + } + if ( clearQueue ) { + this.queue( type || "fx", [] ); + } + + return this.each( function() { + var dequeue = true, + index = type != null && type + "queueHooks", + timers = jQuery.timers, + data = dataPriv.get( this ); + + if ( index ) { + if ( data[ index ] && data[ index ].stop ) { + stopQueue( data[ index ] ); + } + } else { + for ( index in data ) { + if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) { + stopQueue( data[ index ] ); + } + } + } + + for ( index = timers.length; index--; ) { + if ( timers[ index ].elem === this && + ( type == null || timers[ index ].queue === type ) ) { + + timers[ index ].anim.stop( gotoEnd ); + dequeue = false; + timers.splice( index, 1 ); + } + } + + // Start the next in the queue if the last step wasn't forced. + // Timers currently will call their complete callbacks, which + // will dequeue but only if they were gotoEnd. + if ( dequeue || !gotoEnd ) { + jQuery.dequeue( this, type ); + } + } ); + }, + finish: function( type ) { + if ( type !== false ) { + type = type || "fx"; + } + return this.each( function() { + var index, + data = dataPriv.get( this ), + queue = data[ type + "queue" ], + hooks = data[ type + "queueHooks" ], + timers = jQuery.timers, + length = queue ? queue.length : 0; + + // Enable finishing flag on private data + data.finish = true; + + // Empty the queue first + jQuery.queue( this, type, [] ); + + if ( hooks && hooks.stop ) { + hooks.stop.call( this, true ); + } + + // Look for any active animations, and finish them + for ( index = timers.length; index--; ) { + if ( timers[ index ].elem === this && timers[ index ].queue === type ) { + timers[ index ].anim.stop( true ); + timers.splice( index, 1 ); + } + } + + // Look for any animations in the old queue and finish them + for ( index = 0; index < length; index++ ) { + if ( queue[ index ] && queue[ index ].finish ) { + queue[ index ].finish.call( this ); + } + } + + // Turn off finishing flag + delete data.finish; + } ); + } +} ); + +jQuery.each( [ "toggle", "show", "hide" ], function( _i, name ) { + var cssFn = jQuery.fn[ name ]; + jQuery.fn[ name ] = function( speed, easing, callback ) { + return speed == null || typeof speed === "boolean" ? + cssFn.apply( this, arguments ) : + this.animate( genFx( name, true ), speed, easing, callback ); + }; +} ); + +// Generate shortcuts for custom animations +jQuery.each( { + slideDown: genFx( "show" ), + slideUp: genFx( "hide" ), + slideToggle: genFx( "toggle" ), + fadeIn: { opacity: "show" }, + fadeOut: { opacity: "hide" }, + fadeToggle: { opacity: "toggle" } +}, function( name, props ) { + jQuery.fn[ name ] = function( speed, easing, callback ) { + return this.animate( props, speed, easing, callback ); + }; +} ); + +jQuery.timers = []; +jQuery.fx.tick = function() { + var timer, + i = 0, + timers = jQuery.timers; + + fxNow = Date.now(); + + for ( ; i < timers.length; i++ ) { + timer = timers[ i ]; + + // Run the timer and safely remove it when done (allowing for external removal) + if ( !timer() && timers[ i ] === timer ) { + timers.splice( i--, 1 ); + } + } + + if ( !timers.length ) { + jQuery.fx.stop(); + } + fxNow = undefined; +}; + +jQuery.fx.timer = function( timer ) { + jQuery.timers.push( timer ); + jQuery.fx.start(); +}; + +jQuery.fx.interval = 13; +jQuery.fx.start = function() { + if ( inProgress ) { + return; + } + + inProgress = true; + schedule(); +}; + +jQuery.fx.stop = function() { + inProgress = null; +}; + +jQuery.fx.speeds = { + slow: 600, + fast: 200, + + // Default speed + _default: 400 +}; + + +// Based off of the plugin by Clint Helfers, with permission. +// https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/ +jQuery.fn.delay = function( time, type ) { + time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time; + type = type || "fx"; + + return this.queue( type, function( next, hooks ) { + var timeout = window.setTimeout( next, time ); + hooks.stop = function() { + window.clearTimeout( timeout ); + }; + } ); +}; + + +( function() { + var input = document.createElement( "input" ), + select = document.createElement( "select" ), + opt = select.appendChild( document.createElement( "option" ) ); + + input.type = "checkbox"; + + // Support: Android <=4.3 only + // Default value for a checkbox should be "on" + support.checkOn = input.value !== ""; + + // Support: IE <=11 only + // Must access selectedIndex to make default options select + support.optSelected = opt.selected; + + // Support: IE <=11 only + // An input loses its value after becoming a radio + input = document.createElement( "input" ); + input.value = "t"; + input.type = "radio"; + support.radioValue = input.value === "t"; +} )(); + + +var boolHook, + attrHandle = jQuery.expr.attrHandle; + +jQuery.fn.extend( { + attr: function( name, value ) { + return access( this, jQuery.attr, name, value, arguments.length > 1 ); + }, + + removeAttr: function( name ) { + return this.each( function() { + jQuery.removeAttr( this, name ); + } ); + } +} ); + +jQuery.extend( { + attr: function( elem, name, value ) { + var ret, hooks, + nType = elem.nodeType; + + // Don't get/set attributes on text, comment and attribute nodes + if ( nType === 3 || nType === 8 || nType === 2 ) { + return; + } + + // Fallback to prop when attributes are not supported + if ( typeof elem.getAttribute === "undefined" ) { + return jQuery.prop( elem, name, value ); + } + + // Attribute hooks are determined by the lowercase version + // Grab necessary hook if one is defined + if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { + hooks = jQuery.attrHooks[ name.toLowerCase() ] || + ( jQuery.expr.match.bool.test( name ) ? boolHook : undefined ); + } + + if ( value !== undefined ) { + if ( value === null ) { + jQuery.removeAttr( elem, name ); + return; + } + + if ( hooks && "set" in hooks && + ( ret = hooks.set( elem, value, name ) ) !== undefined ) { + return ret; + } + + elem.setAttribute( name, value + "" ); + return value; + } + + if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { + return ret; + } + + ret = jQuery.find.attr( elem, name ); + + // Non-existent attributes return null, we normalize to undefined + return ret == null ? undefined : ret; + }, + + attrHooks: { + type: { + set: function( elem, value ) { + if ( !support.radioValue && value === "radio" && + nodeName( elem, "input" ) ) { + var val = elem.value; + elem.setAttribute( "type", value ); + if ( val ) { + elem.value = val; + } + return value; + } + } + } + }, + + removeAttr: function( elem, value ) { + var name, + i = 0, + + // Attribute names can contain non-HTML whitespace characters + // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2 + attrNames = value && value.match( rnothtmlwhite ); + + if ( attrNames && elem.nodeType === 1 ) { + while ( ( name = attrNames[ i++ ] ) ) { + elem.removeAttribute( name ); + } + } + } +} ); + +// Hooks for boolean attributes +boolHook = { + set: function( elem, value, name ) { + if ( value === false ) { + + // Remove boolean attributes when set to false + jQuery.removeAttr( elem, name ); + } else { + elem.setAttribute( name, name ); + } + return name; + } +}; + +jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( _i, name ) { + var getter = attrHandle[ name ] || jQuery.find.attr; + + attrHandle[ name ] = function( elem, name, isXML ) { + var ret, handle, + lowercaseName = name.toLowerCase(); + + if ( !isXML ) { + + // Avoid an infinite loop by temporarily removing this function from the getter + handle = attrHandle[ lowercaseName ]; + attrHandle[ lowercaseName ] = ret; + ret = getter( elem, name, isXML ) != null ? + lowercaseName : + null; + attrHandle[ lowercaseName ] = handle; + } + return ret; + }; +} ); + + + + +var rfocusable = /^(?:input|select|textarea|button)$/i, + rclickable = /^(?:a|area)$/i; + +jQuery.fn.extend( { + prop: function( name, value ) { + return access( this, jQuery.prop, name, value, arguments.length > 1 ); + }, + + removeProp: function( name ) { + return this.each( function() { + delete this[ jQuery.propFix[ name ] || name ]; + } ); + } +} ); + +jQuery.extend( { + prop: function( elem, name, value ) { + var ret, hooks, + nType = elem.nodeType; + + // Don't get/set properties on text, comment and attribute nodes + if ( nType === 3 || nType === 8 || nType === 2 ) { + return; + } + + if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { + + // Fix name and attach hooks + name = jQuery.propFix[ name ] || name; + hooks = jQuery.propHooks[ name ]; + } + + if ( value !== undefined ) { + if ( hooks && "set" in hooks && + ( ret = hooks.set( elem, value, name ) ) !== undefined ) { + return ret; + } + + return ( elem[ name ] = value ); + } + + if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { + return ret; + } + + return elem[ name ]; + }, + + propHooks: { + tabIndex: { + get: function( elem ) { + + // Support: IE <=9 - 11 only + // elem.tabIndex doesn't always return the + // correct value when it hasn't been explicitly set + // https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/ + // Use proper attribute retrieval(#12072) + var tabindex = jQuery.find.attr( elem, "tabindex" ); + + if ( tabindex ) { + return parseInt( tabindex, 10 ); + } + + if ( + rfocusable.test( elem.nodeName ) || + rclickable.test( elem.nodeName ) && + elem.href + ) { + return 0; + } + + return -1; + } + } + }, + + propFix: { + "for": "htmlFor", + "class": "className" + } +} ); + +// Support: IE <=11 only +// Accessing the selectedIndex property +// forces the browser to respect setting selected +// on the option +// The getter ensures a default option is selected +// when in an optgroup +// eslint rule "no-unused-expressions" is disabled for this code +// since it considers such accessions noop +if ( !support.optSelected ) { + jQuery.propHooks.selected = { + get: function( elem ) { + + /* eslint no-unused-expressions: "off" */ + + var parent = elem.parentNode; + if ( parent && parent.parentNode ) { + parent.parentNode.selectedIndex; + } + return null; + }, + set: function( elem ) { + + /* eslint no-unused-expressions: "off" */ + + var parent = elem.parentNode; + if ( parent ) { + parent.selectedIndex; + + if ( parent.parentNode ) { + parent.parentNode.selectedIndex; + } + } + } + }; +} + +jQuery.each( [ + "tabIndex", + "readOnly", + "maxLength", + "cellSpacing", + "cellPadding", + "rowSpan", + "colSpan", + "useMap", + "frameBorder", + "contentEditable" +], function() { + jQuery.propFix[ this.toLowerCase() ] = this; +} ); + + + + + // Strip and collapse whitespace according to HTML spec + // https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace + function stripAndCollapse( value ) { + var tokens = value.match( rnothtmlwhite ) || []; + return tokens.join( " " ); + } + + +function getClass( elem ) { + return elem.getAttribute && elem.getAttribute( "class" ) || ""; +} + +function classesToArray( value ) { + if ( Array.isArray( value ) ) { + return value; + } + if ( typeof value === "string" ) { + return value.match( rnothtmlwhite ) || []; + } + return []; +} + +jQuery.fn.extend( { + addClass: function( value ) { + var classes, elem, cur, curValue, clazz, j, finalValue, + i = 0; + + if ( isFunction( value ) ) { + return this.each( function( j ) { + jQuery( this ).addClass( value.call( this, j, getClass( this ) ) ); + } ); + } + + classes = classesToArray( value ); + + if ( classes.length ) { + while ( ( elem = this[ i++ ] ) ) { + curValue = getClass( elem ); + cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " ); + + if ( cur ) { + j = 0; + while ( ( clazz = classes[ j++ ] ) ) { + if ( cur.indexOf( " " + clazz + " " ) < 0 ) { + cur += clazz + " "; + } + } + + // Only assign if different to avoid unneeded rendering. + finalValue = stripAndCollapse( cur ); + if ( curValue !== finalValue ) { + elem.setAttribute( "class", finalValue ); + } + } + } + } + + return this; + }, + + removeClass: function( value ) { + var classes, elem, cur, curValue, clazz, j, finalValue, + i = 0; + + if ( isFunction( value ) ) { + return this.each( function( j ) { + jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) ); + } ); + } + + if ( !arguments.length ) { + return this.attr( "class", "" ); + } + + classes = classesToArray( value ); + + if ( classes.length ) { + while ( ( elem = this[ i++ ] ) ) { + curValue = getClass( elem ); + + // This expression is here for better compressibility (see addClass) + cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " ); + + if ( cur ) { + j = 0; + while ( ( clazz = classes[ j++ ] ) ) { + + // Remove *all* instances + while ( cur.indexOf( " " + clazz + " " ) > -1 ) { + cur = cur.replace( " " + clazz + " ", " " ); + } + } + + // Only assign if different to avoid unneeded rendering. + finalValue = stripAndCollapse( cur ); + if ( curValue !== finalValue ) { + elem.setAttribute( "class", finalValue ); + } + } + } + } + + return this; + }, + + toggleClass: function( value, stateVal ) { + var type = typeof value, + isValidValue = type === "string" || Array.isArray( value ); + + if ( typeof stateVal === "boolean" && isValidValue ) { + return stateVal ? this.addClass( value ) : this.removeClass( value ); + } + + if ( isFunction( value ) ) { + return this.each( function( i ) { + jQuery( this ).toggleClass( + value.call( this, i, getClass( this ), stateVal ), + stateVal + ); + } ); + } + + return this.each( function() { + var className, i, self, classNames; + + if ( isValidValue ) { + + // Toggle individual class names + i = 0; + self = jQuery( this ); + classNames = classesToArray( value ); + + while ( ( className = classNames[ i++ ] ) ) { + + // Check each className given, space separated list + if ( self.hasClass( className ) ) { + self.removeClass( className ); + } else { + self.addClass( className ); + } + } + + // Toggle whole class name + } else if ( value === undefined || type === "boolean" ) { + className = getClass( this ); + if ( className ) { + + // Store className if set + dataPriv.set( this, "__className__", className ); + } + + // If the element has a class name or if we're passed `false`, + // then remove the whole classname (if there was one, the above saved it). + // Otherwise bring back whatever was previously saved (if anything), + // falling back to the empty string if nothing was stored. + if ( this.setAttribute ) { + this.setAttribute( "class", + className || value === false ? + "" : + dataPriv.get( this, "__className__" ) || "" + ); + } + } + } ); + }, + + hasClass: function( selector ) { + var className, elem, + i = 0; + + className = " " + selector + " "; + while ( ( elem = this[ i++ ] ) ) { + if ( elem.nodeType === 1 && + ( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) { + return true; + } + } + + return false; + } +} ); + + + + +var rreturn = /\r/g; + +jQuery.fn.extend( { + val: function( value ) { + var hooks, ret, valueIsFunction, + elem = this[ 0 ]; + + if ( !arguments.length ) { + if ( elem ) { + hooks = jQuery.valHooks[ elem.type ] || + jQuery.valHooks[ elem.nodeName.toLowerCase() ]; + + if ( hooks && + "get" in hooks && + ( ret = hooks.get( elem, "value" ) ) !== undefined + ) { + return ret; + } + + ret = elem.value; + + // Handle most common string cases + if ( typeof ret === "string" ) { + return ret.replace( rreturn, "" ); + } + + // Handle cases where value is null/undef or number + return ret == null ? "" : ret; + } + + return; + } + + valueIsFunction = isFunction( value ); + + return this.each( function( i ) { + var val; + + if ( this.nodeType !== 1 ) { + return; + } + + if ( valueIsFunction ) { + val = value.call( this, i, jQuery( this ).val() ); + } else { + val = value; + } + + // Treat null/undefined as ""; convert numbers to string + if ( val == null ) { + val = ""; + + } else if ( typeof val === "number" ) { + val += ""; + + } else if ( Array.isArray( val ) ) { + val = jQuery.map( val, function( value ) { + return value == null ? "" : value + ""; + } ); + } + + hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ]; + + // If set returns undefined, fall back to normal setting + if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) { + this.value = val; + } + } ); + } +} ); + +jQuery.extend( { + valHooks: { + option: { + get: function( elem ) { + + var val = jQuery.find.attr( elem, "value" ); + return val != null ? + val : + + // Support: IE <=10 - 11 only + // option.text throws exceptions (#14686, #14858) + // Strip and collapse whitespace + // https://html.spec.whatwg.org/#strip-and-collapse-whitespace + stripAndCollapse( jQuery.text( elem ) ); + } + }, + select: { + get: function( elem ) { + var value, option, i, + options = elem.options, + index = elem.selectedIndex, + one = elem.type === "select-one", + values = one ? null : [], + max = one ? index + 1 : options.length; + + if ( index < 0 ) { + i = max; + + } else { + i = one ? index : 0; + } + + // Loop through all the selected options + for ( ; i < max; i++ ) { + option = options[ i ]; + + // Support: IE <=9 only + // IE8-9 doesn't update selected after form reset (#2551) + if ( ( option.selected || i === index ) && + + // Don't return options that are disabled or in a disabled optgroup + !option.disabled && + ( !option.parentNode.disabled || + !nodeName( option.parentNode, "optgroup" ) ) ) { + + // Get the specific value for the option + value = jQuery( option ).val(); + + // We don't need an array for one selects + if ( one ) { + return value; + } + + // Multi-Selects return an array + values.push( value ); + } + } + + return values; + }, + + set: function( elem, value ) { + var optionSet, option, + options = elem.options, + values = jQuery.makeArray( value ), + i = options.length; + + while ( i-- ) { + option = options[ i ]; + + /* eslint-disable no-cond-assign */ + + if ( option.selected = + jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1 + ) { + optionSet = true; + } + + /* eslint-enable no-cond-assign */ + } + + // Force browsers to behave consistently when non-matching value is set + if ( !optionSet ) { + elem.selectedIndex = -1; + } + return values; + } + } + } +} ); + +// Radios and checkboxes getter/setter +jQuery.each( [ "radio", "checkbox" ], function() { + jQuery.valHooks[ this ] = { + set: function( elem, value ) { + if ( Array.isArray( value ) ) { + return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 ); + } + } + }; + if ( !support.checkOn ) { + jQuery.valHooks[ this ].get = function( elem ) { + return elem.getAttribute( "value" ) === null ? "on" : elem.value; + }; + } +} ); + + + + +// Return jQuery for attributes-only inclusion + + +support.focusin = "onfocusin" in window; + + +var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, + stopPropagationCallback = function( e ) { + e.stopPropagation(); + }; + +jQuery.extend( jQuery.event, { + + trigger: function( event, data, elem, onlyHandlers ) { + + var i, cur, tmp, bubbleType, ontype, handle, special, lastElement, + eventPath = [ elem || document ], + type = hasOwn.call( event, "type" ) ? event.type : event, + namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : []; + + cur = lastElement = tmp = elem = elem || document; + + // Don't do events on text and comment nodes + if ( elem.nodeType === 3 || elem.nodeType === 8 ) { + return; + } + + // focus/blur morphs to focusin/out; ensure we're not firing them right now + if ( rfocusMorph.test( type + jQuery.event.triggered ) ) { + return; + } + + if ( type.indexOf( "." ) > -1 ) { + + // Namespaced trigger; create a regexp to match event type in handle() + namespaces = type.split( "." ); + type = namespaces.shift(); + namespaces.sort(); + } + ontype = type.indexOf( ":" ) < 0 && "on" + type; + + // Caller can pass in a jQuery.Event object, Object, or just an event type string + event = event[ jQuery.expando ] ? + event : + new jQuery.Event( type, typeof event === "object" && event ); + + // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true) + event.isTrigger = onlyHandlers ? 2 : 3; + event.namespace = namespaces.join( "." ); + event.rnamespace = event.namespace ? + new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) : + null; + + // Clean up the event in case it is being reused + event.result = undefined; + if ( !event.target ) { + event.target = elem; + } + + // Clone any incoming data and prepend the event, creating the handler arg list + data = data == null ? + [ event ] : + jQuery.makeArray( data, [ event ] ); + + // Allow special events to draw outside the lines + special = jQuery.event.special[ type ] || {}; + if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) { + return; + } + + // Determine event propagation path in advance, per W3C events spec (#9951) + // Bubble up to document, then to window; watch for a global ownerDocument var (#9724) + if ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) { + + bubbleType = special.delegateType || type; + if ( !rfocusMorph.test( bubbleType + type ) ) { + cur = cur.parentNode; + } + for ( ; cur; cur = cur.parentNode ) { + eventPath.push( cur ); + tmp = cur; + } + + // Only add window if we got to document (e.g., not plain obj or detached DOM) + if ( tmp === ( elem.ownerDocument || document ) ) { + eventPath.push( tmp.defaultView || tmp.parentWindow || window ); + } + } + + // Fire handlers on the event path + i = 0; + while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) { + lastElement = cur; + event.type = i > 1 ? + bubbleType : + special.bindType || type; + + // jQuery handler + handle = ( + dataPriv.get( cur, "events" ) || Object.create( null ) + )[ event.type ] && + dataPriv.get( cur, "handle" ); + if ( handle ) { + handle.apply( cur, data ); + } + + // Native handler + handle = ontype && cur[ ontype ]; + if ( handle && handle.apply && acceptData( cur ) ) { + event.result = handle.apply( cur, data ); + if ( event.result === false ) { + event.preventDefault(); + } + } + } + event.type = type; + + // If nobody prevented the default action, do it now + if ( !onlyHandlers && !event.isDefaultPrevented() ) { + + if ( ( !special._default || + special._default.apply( eventPath.pop(), data ) === false ) && + acceptData( elem ) ) { + + // Call a native DOM method on the target with the same name as the event. + // Don't do default actions on window, that's where global variables be (#6170) + if ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) { + + // Don't re-trigger an onFOO event when we call its FOO() method + tmp = elem[ ontype ]; + + if ( tmp ) { + elem[ ontype ] = null; + } + + // Prevent re-triggering of the same event, since we already bubbled it above + jQuery.event.triggered = type; + + if ( event.isPropagationStopped() ) { + lastElement.addEventListener( type, stopPropagationCallback ); + } + + elem[ type ](); + + if ( event.isPropagationStopped() ) { + lastElement.removeEventListener( type, stopPropagationCallback ); + } + + jQuery.event.triggered = undefined; + + if ( tmp ) { + elem[ ontype ] = tmp; + } + } + } + } + + return event.result; + }, + + // Piggyback on a donor event to simulate a different one + // Used only for `focus(in | out)` events + simulate: function( type, elem, event ) { + var e = jQuery.extend( + new jQuery.Event(), + event, + { + type: type, + isSimulated: true + } + ); + + jQuery.event.trigger( e, null, elem ); + } + +} ); + +jQuery.fn.extend( { + + trigger: function( type, data ) { + return this.each( function() { + jQuery.event.trigger( type, data, this ); + } ); + }, + triggerHandler: function( type, data ) { + var elem = this[ 0 ]; + if ( elem ) { + return jQuery.event.trigger( type, data, elem, true ); + } + } +} ); + + +// Support: Firefox <=44 +// Firefox doesn't have focus(in | out) events +// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787 +// +// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1 +// focus(in | out) events fire after focus & blur events, +// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order +// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857 +if ( !support.focusin ) { + jQuery.each( { focus: "focusin", blur: "focusout" }, function( orig, fix ) { + + // Attach a single capturing handler on the document while someone wants focusin/focusout + var handler = function( event ) { + jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) ); + }; + + jQuery.event.special[ fix ] = { + setup: function() { + + // Handle: regular nodes (via `this.ownerDocument`), window + // (via `this.document`) & document (via `this`). + var doc = this.ownerDocument || this.document || this, + attaches = dataPriv.access( doc, fix ); + + if ( !attaches ) { + doc.addEventListener( orig, handler, true ); + } + dataPriv.access( doc, fix, ( attaches || 0 ) + 1 ); + }, + teardown: function() { + var doc = this.ownerDocument || this.document || this, + attaches = dataPriv.access( doc, fix ) - 1; + + if ( !attaches ) { + doc.removeEventListener( orig, handler, true ); + dataPriv.remove( doc, fix ); + + } else { + dataPriv.access( doc, fix, attaches ); + } + } + }; + } ); +} +var location = window.location; + +var nonce = { guid: Date.now() }; + +var rquery = ( /\?/ ); + + + +// Cross-browser xml parsing +jQuery.parseXML = function( data ) { + var xml; + if ( !data || typeof data !== "string" ) { + return null; + } + + // Support: IE 9 - 11 only + // IE throws on parseFromString with invalid input. + try { + xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" ); + } catch ( e ) { + xml = undefined; + } + + if ( !xml || xml.getElementsByTagName( "parsererror" ).length ) { + jQuery.error( "Invalid XML: " + data ); + } + return xml; +}; + + +var + rbracket = /\[\]$/, + rCRLF = /\r?\n/g, + rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i, + rsubmittable = /^(?:input|select|textarea|keygen)/i; + +function buildParams( prefix, obj, traditional, add ) { + var name; + + if ( Array.isArray( obj ) ) { + + // Serialize array item. + jQuery.each( obj, function( i, v ) { + if ( traditional || rbracket.test( prefix ) ) { + + // Treat each array item as a scalar. + add( prefix, v ); + + } else { + + // Item is non-scalar (array or object), encode its numeric index. + buildParams( + prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]", + v, + traditional, + add + ); + } + } ); + + } else if ( !traditional && toType( obj ) === "object" ) { + + // Serialize object item. + for ( name in obj ) { + buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add ); + } + + } else { + + // Serialize scalar item. + add( prefix, obj ); + } +} + +// Serialize an array of form elements or a set of +// key/values into a query string +jQuery.param = function( a, traditional ) { + var prefix, + s = [], + add = function( key, valueOrFunction ) { + + // If value is a function, invoke it and use its return value + var value = isFunction( valueOrFunction ) ? + valueOrFunction() : + valueOrFunction; + + s[ s.length ] = encodeURIComponent( key ) + "=" + + encodeURIComponent( value == null ? "" : value ); + }; + + if ( a == null ) { + return ""; + } + + // If an array was passed in, assume that it is an array of form elements. + if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) { + + // Serialize the form elements + jQuery.each( a, function() { + add( this.name, this.value ); + } ); + + } else { + + // If traditional, encode the "old" way (the way 1.3.2 or older + // did it), otherwise encode params recursively. + for ( prefix in a ) { + buildParams( prefix, a[ prefix ], traditional, add ); + } + } + + // Return the resulting serialization + return s.join( "&" ); +}; + +jQuery.fn.extend( { + serialize: function() { + return jQuery.param( this.serializeArray() ); + }, + serializeArray: function() { + return this.map( function() { + + // Can add propHook for "elements" to filter or add form elements + var elements = jQuery.prop( this, "elements" ); + return elements ? jQuery.makeArray( elements ) : this; + } ) + .filter( function() { + var type = this.type; + + // Use .is( ":disabled" ) so that fieldset[disabled] works + return this.name && !jQuery( this ).is( ":disabled" ) && + rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) && + ( this.checked || !rcheckableType.test( type ) ); + } ) + .map( function( _i, elem ) { + var val = jQuery( this ).val(); + + if ( val == null ) { + return null; + } + + if ( Array.isArray( val ) ) { + return jQuery.map( val, function( val ) { + return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; + } ); + } + + return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; + } ).get(); + } +} ); + + +var + r20 = /%20/g, + rhash = /#.*$/, + rantiCache = /([?&])_=[^&]*/, + rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg, + + // #7653, #8125, #8152: local protocol detection + rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/, + rnoContent = /^(?:GET|HEAD)$/, + rprotocol = /^\/\//, + + /* Prefilters + * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example) + * 2) These are called: + * - BEFORE asking for a transport + * - AFTER param serialization (s.data is a string if s.processData is true) + * 3) key is the dataType + * 4) the catchall symbol "*" can be used + * 5) execution will start with transport dataType and THEN continue down to "*" if needed + */ + prefilters = {}, + + /* Transports bindings + * 1) key is the dataType + * 2) the catchall symbol "*" can be used + * 3) selection will start with transport dataType and THEN go to "*" if needed + */ + transports = {}, + + // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression + allTypes = "*/".concat( "*" ), + + // Anchor tag for parsing the document origin + originAnchor = document.createElement( "a" ); + originAnchor.href = location.href; + +// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport +function addToPrefiltersOrTransports( structure ) { + + // dataTypeExpression is optional and defaults to "*" + return function( dataTypeExpression, func ) { + + if ( typeof dataTypeExpression !== "string" ) { + func = dataTypeExpression; + dataTypeExpression = "*"; + } + + var dataType, + i = 0, + dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || []; + + if ( isFunction( func ) ) { + + // For each dataType in the dataTypeExpression + while ( ( dataType = dataTypes[ i++ ] ) ) { + + // Prepend if requested + if ( dataType[ 0 ] === "+" ) { + dataType = dataType.slice( 1 ) || "*"; + ( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func ); + + // Otherwise append + } else { + ( structure[ dataType ] = structure[ dataType ] || [] ).push( func ); + } + } + } + }; +} + +// Base inspection function for prefilters and transports +function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) { + + var inspected = {}, + seekingTransport = ( structure === transports ); + + function inspect( dataType ) { + var selected; + inspected[ dataType ] = true; + jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) { + var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR ); + if ( typeof dataTypeOrTransport === "string" && + !seekingTransport && !inspected[ dataTypeOrTransport ] ) { + + options.dataTypes.unshift( dataTypeOrTransport ); + inspect( dataTypeOrTransport ); + return false; + } else if ( seekingTransport ) { + return !( selected = dataTypeOrTransport ); + } + } ); + return selected; + } + + return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" ); +} + +// A special extend for ajax options +// that takes "flat" options (not to be deep extended) +// Fixes #9887 +function ajaxExtend( target, src ) { + var key, deep, + flatOptions = jQuery.ajaxSettings.flatOptions || {}; + + for ( key in src ) { + if ( src[ key ] !== undefined ) { + ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ]; + } + } + if ( deep ) { + jQuery.extend( true, target, deep ); + } + + return target; +} + +/* Handles responses to an ajax request: + * - finds the right dataType (mediates between content-type and expected dataType) + * - returns the corresponding response + */ +function ajaxHandleResponses( s, jqXHR, responses ) { + + var ct, type, finalDataType, firstDataType, + contents = s.contents, + dataTypes = s.dataTypes; + + // Remove auto dataType and get content-type in the process + while ( dataTypes[ 0 ] === "*" ) { + dataTypes.shift(); + if ( ct === undefined ) { + ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" ); + } + } + + // Check if we're dealing with a known content-type + if ( ct ) { + for ( type in contents ) { + if ( contents[ type ] && contents[ type ].test( ct ) ) { + dataTypes.unshift( type ); + break; + } + } + } + + // Check to see if we have a response for the expected dataType + if ( dataTypes[ 0 ] in responses ) { + finalDataType = dataTypes[ 0 ]; + } else { + + // Try convertible dataTypes + for ( type in responses ) { + if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) { + finalDataType = type; + break; + } + if ( !firstDataType ) { + firstDataType = type; + } + } + + // Or just use first one + finalDataType = finalDataType || firstDataType; + } + + // If we found a dataType + // We add the dataType to the list if needed + // and return the corresponding response + if ( finalDataType ) { + if ( finalDataType !== dataTypes[ 0 ] ) { + dataTypes.unshift( finalDataType ); + } + return responses[ finalDataType ]; + } +} + +/* Chain conversions given the request and the original response + * Also sets the responseXXX fields on the jqXHR instance + */ +function ajaxConvert( s, response, jqXHR, isSuccess ) { + var conv2, current, conv, tmp, prev, + converters = {}, + + // Work with a copy of dataTypes in case we need to modify it for conversion + dataTypes = s.dataTypes.slice(); + + // Create converters map with lowercased keys + if ( dataTypes[ 1 ] ) { + for ( conv in s.converters ) { + converters[ conv.toLowerCase() ] = s.converters[ conv ]; + } + } + + current = dataTypes.shift(); + + // Convert to each sequential dataType + while ( current ) { + + if ( s.responseFields[ current ] ) { + jqXHR[ s.responseFields[ current ] ] = response; + } + + // Apply the dataFilter if provided + if ( !prev && isSuccess && s.dataFilter ) { + response = s.dataFilter( response, s.dataType ); + } + + prev = current; + current = dataTypes.shift(); + + if ( current ) { + + // There's only work to do if current dataType is non-auto + if ( current === "*" ) { + + current = prev; + + // Convert response if prev dataType is non-auto and differs from current + } else if ( prev !== "*" && prev !== current ) { + + // Seek a direct converter + conv = converters[ prev + " " + current ] || converters[ "* " + current ]; + + // If none found, seek a pair + if ( !conv ) { + for ( conv2 in converters ) { + + // If conv2 outputs current + tmp = conv2.split( " " ); + if ( tmp[ 1 ] === current ) { + + // If prev can be converted to accepted input + conv = converters[ prev + " " + tmp[ 0 ] ] || + converters[ "* " + tmp[ 0 ] ]; + if ( conv ) { + + // Condense equivalence converters + if ( conv === true ) { + conv = converters[ conv2 ]; + + // Otherwise, insert the intermediate dataType + } else if ( converters[ conv2 ] !== true ) { + current = tmp[ 0 ]; + dataTypes.unshift( tmp[ 1 ] ); + } + break; + } + } + } + } + + // Apply converter (if not an equivalence) + if ( conv !== true ) { + + // Unless errors are allowed to bubble, catch and return them + if ( conv && s.throws ) { + response = conv( response ); + } else { + try { + response = conv( response ); + } catch ( e ) { + return { + state: "parsererror", + error: conv ? e : "No conversion from " + prev + " to " + current + }; + } + } + } + } + } + } + + return { state: "success", data: response }; +} + +jQuery.extend( { + + // Counter for holding the number of active queries + active: 0, + + // Last-Modified header cache for next request + lastModified: {}, + etag: {}, + + ajaxSettings: { + url: location.href, + type: "GET", + isLocal: rlocalProtocol.test( location.protocol ), + global: true, + processData: true, + async: true, + contentType: "application/x-www-form-urlencoded; charset=UTF-8", + + /* + timeout: 0, + data: null, + dataType: null, + username: null, + password: null, + cache: null, + throws: false, + traditional: false, + headers: {}, + */ + + accepts: { + "*": allTypes, + text: "text/plain", + html: "text/html", + xml: "application/xml, text/xml", + json: "application/json, text/javascript" + }, + + contents: { + xml: /\bxml\b/, + html: /\bhtml/, + json: /\bjson\b/ + }, + + responseFields: { + xml: "responseXML", + text: "responseText", + json: "responseJSON" + }, + + // Data converters + // Keys separate source (or catchall "*") and destination types with a single space + converters: { + + // Convert anything to text + "* text": String, + + // Text to html (true = no transformation) + "text html": true, + + // Evaluate text as a json expression + "text json": JSON.parse, + + // Parse text as xml + "text xml": jQuery.parseXML + }, + + // For options that shouldn't be deep extended: + // you can add your own custom options here if + // and when you create one that shouldn't be + // deep extended (see ajaxExtend) + flatOptions: { + url: true, + context: true + } + }, + + // Creates a full fledged settings object into target + // with both ajaxSettings and settings fields. + // If target is omitted, writes into ajaxSettings. + ajaxSetup: function( target, settings ) { + return settings ? + + // Building a settings object + ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) : + + // Extending ajaxSettings + ajaxExtend( jQuery.ajaxSettings, target ); + }, + + ajaxPrefilter: addToPrefiltersOrTransports( prefilters ), + ajaxTransport: addToPrefiltersOrTransports( transports ), + + // Main method + ajax: function( url, options ) { + + // If url is an object, simulate pre-1.5 signature + if ( typeof url === "object" ) { + options = url; + url = undefined; + } + + // Force options to be an object + options = options || {}; + + var transport, + + // URL without anti-cache param + cacheURL, + + // Response headers + responseHeadersString, + responseHeaders, + + // timeout handle + timeoutTimer, + + // Url cleanup var + urlAnchor, + + // Request state (becomes false upon send and true upon completion) + completed, + + // To know if global events are to be dispatched + fireGlobals, + + // Loop variable + i, + + // uncached part of the url + uncached, + + // Create the final options object + s = jQuery.ajaxSetup( {}, options ), + + // Callbacks context + callbackContext = s.context || s, + + // Context for global events is callbackContext if it is a DOM node or jQuery collection + globalEventContext = s.context && + ( callbackContext.nodeType || callbackContext.jquery ) ? + jQuery( callbackContext ) : + jQuery.event, + + // Deferreds + deferred = jQuery.Deferred(), + completeDeferred = jQuery.Callbacks( "once memory" ), + + // Status-dependent callbacks + statusCode = s.statusCode || {}, + + // Headers (they are sent all at once) + requestHeaders = {}, + requestHeadersNames = {}, + + // Default abort message + strAbort = "canceled", + + // Fake xhr + jqXHR = { + readyState: 0, + + // Builds headers hashtable if needed + getResponseHeader: function( key ) { + var match; + if ( completed ) { + if ( !responseHeaders ) { + responseHeaders = {}; + while ( ( match = rheaders.exec( responseHeadersString ) ) ) { + responseHeaders[ match[ 1 ].toLowerCase() + " " ] = + ( responseHeaders[ match[ 1 ].toLowerCase() + " " ] || [] ) + .concat( match[ 2 ] ); + } + } + match = responseHeaders[ key.toLowerCase() + " " ]; + } + return match == null ? null : match.join( ", " ); + }, + + // Raw string + getAllResponseHeaders: function() { + return completed ? responseHeadersString : null; + }, + + // Caches the header + setRequestHeader: function( name, value ) { + if ( completed == null ) { + name = requestHeadersNames[ name.toLowerCase() ] = + requestHeadersNames[ name.toLowerCase() ] || name; + requestHeaders[ name ] = value; + } + return this; + }, + + // Overrides response content-type header + overrideMimeType: function( type ) { + if ( completed == null ) { + s.mimeType = type; + } + return this; + }, + + // Status-dependent callbacks + statusCode: function( map ) { + var code; + if ( map ) { + if ( completed ) { + + // Execute the appropriate callbacks + jqXHR.always( map[ jqXHR.status ] ); + } else { + + // Lazy-add the new callbacks in a way that preserves old ones + for ( code in map ) { + statusCode[ code ] = [ statusCode[ code ], map[ code ] ]; + } + } + } + return this; + }, + + // Cancel the request + abort: function( statusText ) { + var finalText = statusText || strAbort; + if ( transport ) { + transport.abort( finalText ); + } + done( 0, finalText ); + return this; + } + }; + + // Attach deferreds + deferred.promise( jqXHR ); + + // Add protocol if not provided (prefilters might expect it) + // Handle falsy url in the settings object (#10093: consistency with old signature) + // We also use the url parameter if available + s.url = ( ( url || s.url || location.href ) + "" ) + .replace( rprotocol, location.protocol + "//" ); + + // Alias method option to type as per ticket #12004 + s.type = options.method || options.type || s.method || s.type; + + // Extract dataTypes list + s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ]; + + // A cross-domain request is in order when the origin doesn't match the current origin. + if ( s.crossDomain == null ) { + urlAnchor = document.createElement( "a" ); + + // Support: IE <=8 - 11, Edge 12 - 15 + // IE throws exception on accessing the href property if url is malformed, + // e.g. http://example.com:80x/ + try { + urlAnchor.href = s.url; + + // Support: IE <=8 - 11 only + // Anchor's host property isn't correctly set when s.url is relative + urlAnchor.href = urlAnchor.href; + s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !== + urlAnchor.protocol + "//" + urlAnchor.host; + } catch ( e ) { + + // If there is an error parsing the URL, assume it is crossDomain, + // it can be rejected by the transport if it is invalid + s.crossDomain = true; + } + } + + // Convert data if not already a string + if ( s.data && s.processData && typeof s.data !== "string" ) { + s.data = jQuery.param( s.data, s.traditional ); + } + + // Apply prefilters + inspectPrefiltersOrTransports( prefilters, s, options, jqXHR ); + + // If request was aborted inside a prefilter, stop there + if ( completed ) { + return jqXHR; + } + + // We can fire global events as of now if asked to + // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118) + fireGlobals = jQuery.event && s.global; + + // Watch for a new set of requests + if ( fireGlobals && jQuery.active++ === 0 ) { + jQuery.event.trigger( "ajaxStart" ); + } + + // Uppercase the type + s.type = s.type.toUpperCase(); + + // Determine if request has content + s.hasContent = !rnoContent.test( s.type ); + + // Save the URL in case we're toying with the If-Modified-Since + // and/or If-None-Match header later on + // Remove hash to simplify url manipulation + cacheURL = s.url.replace( rhash, "" ); + + // More options handling for requests with no content + if ( !s.hasContent ) { + + // Remember the hash so we can put it back + uncached = s.url.slice( cacheURL.length ); + + // If data is available and should be processed, append data to url + if ( s.data && ( s.processData || typeof s.data === "string" ) ) { + cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data; + + // #9682: remove data so that it's not used in an eventual retry + delete s.data; + } + + // Add or update anti-cache param if needed + if ( s.cache === false ) { + cacheURL = cacheURL.replace( rantiCache, "$1" ); + uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce.guid++ ) + + uncached; + } + + // Put hash and anti-cache on the URL that will be requested (gh-1732) + s.url = cacheURL + uncached; + + // Change '%20' to '+' if this is encoded form body content (gh-2658) + } else if ( s.data && s.processData && + ( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) { + s.data = s.data.replace( r20, "+" ); + } + + // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. + if ( s.ifModified ) { + if ( jQuery.lastModified[ cacheURL ] ) { + jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] ); + } + if ( jQuery.etag[ cacheURL ] ) { + jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] ); + } + } + + // Set the correct header, if data is being sent + if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) { + jqXHR.setRequestHeader( "Content-Type", s.contentType ); + } + + // Set the Accepts header for the server, depending on the dataType + jqXHR.setRequestHeader( + "Accept", + s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ? + s.accepts[ s.dataTypes[ 0 ] ] + + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) : + s.accepts[ "*" ] + ); + + // Check for headers option + for ( i in s.headers ) { + jqXHR.setRequestHeader( i, s.headers[ i ] ); + } + + // Allow custom headers/mimetypes and early abort + if ( s.beforeSend && + ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) { + + // Abort if not done already and return + return jqXHR.abort(); + } + + // Aborting is no longer a cancellation + strAbort = "abort"; + + // Install callbacks on deferreds + completeDeferred.add( s.complete ); + jqXHR.done( s.success ); + jqXHR.fail( s.error ); + + // Get transport + transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR ); + + // If no transport, we auto-abort + if ( !transport ) { + done( -1, "No Transport" ); + } else { + jqXHR.readyState = 1; + + // Send global event + if ( fireGlobals ) { + globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] ); + } + + // If request was aborted inside ajaxSend, stop there + if ( completed ) { + return jqXHR; + } + + // Timeout + if ( s.async && s.timeout > 0 ) { + timeoutTimer = window.setTimeout( function() { + jqXHR.abort( "timeout" ); + }, s.timeout ); + } + + try { + completed = false; + transport.send( requestHeaders, done ); + } catch ( e ) { + + // Rethrow post-completion exceptions + if ( completed ) { + throw e; + } + + // Propagate others as results + done( -1, e ); + } + } + + // Callback for when everything is done + function done( status, nativeStatusText, responses, headers ) { + var isSuccess, success, error, response, modified, + statusText = nativeStatusText; + + // Ignore repeat invocations + if ( completed ) { + return; + } + + completed = true; + + // Clear timeout if it exists + if ( timeoutTimer ) { + window.clearTimeout( timeoutTimer ); + } + + // Dereference transport for early garbage collection + // (no matter how long the jqXHR object will be used) + transport = undefined; + + // Cache response headers + responseHeadersString = headers || ""; + + // Set readyState + jqXHR.readyState = status > 0 ? 4 : 0; + + // Determine if successful + isSuccess = status >= 200 && status < 300 || status === 304; + + // Get response data + if ( responses ) { + response = ajaxHandleResponses( s, jqXHR, responses ); + } + + // Use a noop converter for missing script + if ( !isSuccess && jQuery.inArray( "script", s.dataTypes ) > -1 ) { + s.converters[ "text script" ] = function() {}; + } + + // Convert no matter what (that way responseXXX fields are always set) + response = ajaxConvert( s, response, jqXHR, isSuccess ); + + // If successful, handle type chaining + if ( isSuccess ) { + + // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. + if ( s.ifModified ) { + modified = jqXHR.getResponseHeader( "Last-Modified" ); + if ( modified ) { + jQuery.lastModified[ cacheURL ] = modified; + } + modified = jqXHR.getResponseHeader( "etag" ); + if ( modified ) { + jQuery.etag[ cacheURL ] = modified; + } + } + + // if no content + if ( status === 204 || s.type === "HEAD" ) { + statusText = "nocontent"; + + // if not modified + } else if ( status === 304 ) { + statusText = "notmodified"; + + // If we have data, let's convert it + } else { + statusText = response.state; + success = response.data; + error = response.error; + isSuccess = !error; + } + } else { + + // Extract error from statusText and normalize for non-aborts + error = statusText; + if ( status || !statusText ) { + statusText = "error"; + if ( status < 0 ) { + status = 0; + } + } + } + + // Set data for the fake xhr object + jqXHR.status = status; + jqXHR.statusText = ( nativeStatusText || statusText ) + ""; + + // Success/Error + if ( isSuccess ) { + deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] ); + } else { + deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] ); + } + + // Status-dependent callbacks + jqXHR.statusCode( statusCode ); + statusCode = undefined; + + if ( fireGlobals ) { + globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError", + [ jqXHR, s, isSuccess ? success : error ] ); + } + + // Complete + completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] ); + + if ( fireGlobals ) { + globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] ); + + // Handle the global AJAX counter + if ( !( --jQuery.active ) ) { + jQuery.event.trigger( "ajaxStop" ); + } + } + } + + return jqXHR; + }, + + getJSON: function( url, data, callback ) { + return jQuery.get( url, data, callback, "json" ); + }, + + getScript: function( url, callback ) { + return jQuery.get( url, undefined, callback, "script" ); + } +} ); + +jQuery.each( [ "get", "post" ], function( _i, method ) { + jQuery[ method ] = function( url, data, callback, type ) { + + // Shift arguments if data argument was omitted + if ( isFunction( data ) ) { + type = type || callback; + callback = data; + data = undefined; + } + + // The url can be an options object (which then must have .url) + return jQuery.ajax( jQuery.extend( { + url: url, + type: method, + dataType: type, + data: data, + success: callback + }, jQuery.isPlainObject( url ) && url ) ); + }; +} ); + +jQuery.ajaxPrefilter( function( s ) { + var i; + for ( i in s.headers ) { + if ( i.toLowerCase() === "content-type" ) { + s.contentType = s.headers[ i ] || ""; + } + } +} ); + + +jQuery._evalUrl = function( url, options, doc ) { + return jQuery.ajax( { + url: url, + + // Make this explicit, since user can override this through ajaxSetup (#11264) + type: "GET", + dataType: "script", + cache: true, + async: false, + global: false, + + // Only evaluate the response if it is successful (gh-4126) + // dataFilter is not invoked for failure responses, so using it instead + // of the default converter is kludgy but it works. + converters: { + "text script": function() {} + }, + dataFilter: function( response ) { + jQuery.globalEval( response, options, doc ); + } + } ); +}; + + +jQuery.fn.extend( { + wrapAll: function( html ) { + var wrap; + + if ( this[ 0 ] ) { + if ( isFunction( html ) ) { + html = html.call( this[ 0 ] ); + } + + // The elements to wrap the target around + wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true ); + + if ( this[ 0 ].parentNode ) { + wrap.insertBefore( this[ 0 ] ); + } + + wrap.map( function() { + var elem = this; + + while ( elem.firstElementChild ) { + elem = elem.firstElementChild; + } + + return elem; + } ).append( this ); + } + + return this; + }, + + wrapInner: function( html ) { + if ( isFunction( html ) ) { + return this.each( function( i ) { + jQuery( this ).wrapInner( html.call( this, i ) ); + } ); + } + + return this.each( function() { + var self = jQuery( this ), + contents = self.contents(); + + if ( contents.length ) { + contents.wrapAll( html ); + + } else { + self.append( html ); + } + } ); + }, + + wrap: function( html ) { + var htmlIsFunction = isFunction( html ); + + return this.each( function( i ) { + jQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html ); + } ); + }, + + unwrap: function( selector ) { + this.parent( selector ).not( "body" ).each( function() { + jQuery( this ).replaceWith( this.childNodes ); + } ); + return this; + } +} ); + + +jQuery.expr.pseudos.hidden = function( elem ) { + return !jQuery.expr.pseudos.visible( elem ); +}; +jQuery.expr.pseudos.visible = function( elem ) { + return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length ); +}; + + + + +jQuery.ajaxSettings.xhr = function() { + try { + return new window.XMLHttpRequest(); + } catch ( e ) {} +}; + +var xhrSuccessStatus = { + + // File protocol always yields status code 0, assume 200 + 0: 200, + + // Support: IE <=9 only + // #1450: sometimes IE returns 1223 when it should be 204 + 1223: 204 + }, + xhrSupported = jQuery.ajaxSettings.xhr(); + +support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported ); +support.ajax = xhrSupported = !!xhrSupported; + +jQuery.ajaxTransport( function( options ) { + var callback, errorCallback; + + // Cross domain only allowed if supported through XMLHttpRequest + if ( support.cors || xhrSupported && !options.crossDomain ) { + return { + send: function( headers, complete ) { + var i, + xhr = options.xhr(); + + xhr.open( + options.type, + options.url, + options.async, + options.username, + options.password + ); + + // Apply custom fields if provided + if ( options.xhrFields ) { + for ( i in options.xhrFields ) { + xhr[ i ] = options.xhrFields[ i ]; + } + } + + // Override mime type if needed + if ( options.mimeType && xhr.overrideMimeType ) { + xhr.overrideMimeType( options.mimeType ); + } + + // X-Requested-With header + // For cross-domain requests, seeing as conditions for a preflight are + // akin to a jigsaw puzzle, we simply never set it to be sure. + // (it can always be set on a per-request basis or even using ajaxSetup) + // For same-domain requests, won't change header if already provided. + if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) { + headers[ "X-Requested-With" ] = "XMLHttpRequest"; + } + + // Set headers + for ( i in headers ) { + xhr.setRequestHeader( i, headers[ i ] ); + } + + // Callback + callback = function( type ) { + return function() { + if ( callback ) { + callback = errorCallback = xhr.onload = + xhr.onerror = xhr.onabort = xhr.ontimeout = + xhr.onreadystatechange = null; + + if ( type === "abort" ) { + xhr.abort(); + } else if ( type === "error" ) { + + // Support: IE <=9 only + // On a manual native abort, IE9 throws + // errors on any property access that is not readyState + if ( typeof xhr.status !== "number" ) { + complete( 0, "error" ); + } else { + complete( + + // File: protocol always yields status 0; see #8605, #14207 + xhr.status, + xhr.statusText + ); + } + } else { + complete( + xhrSuccessStatus[ xhr.status ] || xhr.status, + xhr.statusText, + + // Support: IE <=9 only + // IE9 has no XHR2 but throws on binary (trac-11426) + // For XHR2 non-text, let the caller handle it (gh-2498) + ( xhr.responseType || "text" ) !== "text" || + typeof xhr.responseText !== "string" ? + { binary: xhr.response } : + { text: xhr.responseText }, + xhr.getAllResponseHeaders() + ); + } + } + }; + }; + + // Listen to events + xhr.onload = callback(); + errorCallback = xhr.onerror = xhr.ontimeout = callback( "error" ); + + // Support: IE 9 only + // Use onreadystatechange to replace onabort + // to handle uncaught aborts + if ( xhr.onabort !== undefined ) { + xhr.onabort = errorCallback; + } else { + xhr.onreadystatechange = function() { + + // Check readyState before timeout as it changes + if ( xhr.readyState === 4 ) { + + // Allow onerror to be called first, + // but that will not handle a native abort + // Also, save errorCallback to a variable + // as xhr.onerror cannot be accessed + window.setTimeout( function() { + if ( callback ) { + errorCallback(); + } + } ); + } + }; + } + + // Create the abort callback + callback = callback( "abort" ); + + try { + + // Do send the request (this may raise an exception) + xhr.send( options.hasContent && options.data || null ); + } catch ( e ) { + + // #14683: Only rethrow if this hasn't been notified as an error yet + if ( callback ) { + throw e; + } + } + }, + + abort: function() { + if ( callback ) { + callback(); + } + } + }; + } +} ); + + + + +// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432) +jQuery.ajaxPrefilter( function( s ) { + if ( s.crossDomain ) { + s.contents.script = false; + } +} ); + +// Install script dataType +jQuery.ajaxSetup( { + accepts: { + script: "text/javascript, application/javascript, " + + "application/ecmascript, application/x-ecmascript" + }, + contents: { + script: /\b(?:java|ecma)script\b/ + }, + converters: { + "text script": function( text ) { + jQuery.globalEval( text ); + return text; + } + } +} ); + +// Handle cache's special case and crossDomain +jQuery.ajaxPrefilter( "script", function( s ) { + if ( s.cache === undefined ) { + s.cache = false; + } + if ( s.crossDomain ) { + s.type = "GET"; + } +} ); + +// Bind script tag hack transport +jQuery.ajaxTransport( "script", function( s ) { + + // This transport only deals with cross domain or forced-by-attrs requests + if ( s.crossDomain || s.scriptAttrs ) { + var script, callback; + return { + send: function( _, complete ) { + script = jQuery( " + + + + + + + + + + + + + + + + +
+
+
+ + +
+ +
+

fit function

+
+
+l0learn.fit(X: Union[np.ndarray, csc_matrix], y: np.ndarray, unicode loss: str = u'SquaredError', unicode penalty: str = u'L0', unicode algorithm: str = u'CD', max_support_size: int = 100, num_lambda: Optional[int] = 100, num_gamma: Optional[int] = 1, double gamma_max: float = 10., double gamma_min: float = .0001, partial_sort: bool = True, max_iter: int = 200, double rtol: float = 1e-6, double atol: float = 1e-9, active_set: bool = True, active_set_num: int = 3, max_swaps: int = 100, double scale_down_factor: float = 0.8, screen_size: int = 1000, lambda_grid: Optional[List[Sequence[float]]] = None, exclude_first_k: int = 0, intercept: bool = True, lows: Union[np.ndarray, float] = -float(u'inf'), highs: Union[np.ndarray, float] = +float(u'inf')) → l0learn.models.FitModel
+

Computes the regularization path for the specified loss function and penalty function.

+
+
Parameters
+
    +

  • X (np.ndarray or csc_matrix of shape (N, P)) – Data Matrix where rows of X are observations and columns of X are features

    • +

  • y (np.ndarray of shape (P)) – The response vector where y[i] corresponds to X[i, :] +For classification, a binary vector (-1, 1) is requried .

    • +

  • loss (str) –

    +
    The loss function. Currently supports the choices:

    ”SquaredError” (for regression), +“Logistic” (for logistic regression), and +“SquaredHinge” (for smooth SVM).

    +
    +
    +

    • +

  • penalty (str) –

    The type of regularization. +This can take either one of the following choices:

    +
    +

    ”L0”, +“L0L2”, and +“L0L1”

    +
    +

    • +

  • algorithm (str) – The type of algorithm used to minimize the objective function. Currently “CD” and “CDPSI” are are supported. +“CD” is a variant of cyclic coordinate descent and runs very fast. “CDPSI” performs local combinatorial search +on top of CD and typically achieves higher quality solutions (at the expense of increased running time).

    • +

  • max_support_size (int) – Must be greater than 0. +The maximum support size at which to terminate the regularization path. We recommend setting this to a small +fraction of min(n,p) (e.g. 0.05 * min(n,p)) as L0 regularization typically selects a small portion of non-zeros.

    • +

  • num_lambda (int, optional) – The number of lambda values to select in the regularization path. +This value must be None if lambda_grid is supplied.When supplied, must be greater than 0. +Note: lambda is the regularization parameter corresponding to the L0 norm.

    • +

  • num_gamma (int, optional) – The number of gamma values to select in the regularization path. +This value must be None if lambda_grid is supplied. When supplied, must be greater than 0. +Note: gamma is the regularization parameter corresponding to L1 or L2, depending on the chosen penalty).

    • +

  • gamma_max (float) –

    The maximum value of gamma when using the L0L2 penalty. +This value must be greater than 0.

    +

    Note: For the L0L1 penalty this is automatically selected.

    +

    • +

  • gamma_min (float) – The minimum value of Gamma when using the L0L2 penalty. +This value must be greater than 0 but less than gamma_max. +Note: For the L0L1 penalty, the minimum value of gamma in the grid is set to gammaMin * gammaMax.

    • +

  • partial_sort (bool) – If TRUE partial sorting will be used for sorting the coordinates to do greedy cycling (see our paper for +for details). Otherwise, full sorting is used. #TODO: Add link for paper

    • +

  • max_iter (int) – The maximum number of iterations (full cycles) for CD per grid point. The algorithm may not use the full number +of iteration per grid point if convergence is found (defined by rtol and atol parameter) +Must be greater than 0

    • +

  • rtol (float) – The relative tolerance which decides when to terminate optimization as based on the relative change in the +objective between iterations. +Must be greater than 0 and less than 1.

    • +

  • atol (float) – The absolute tolerance which decides when to terminate optimization as based on the absolute L2 norm of the +residuals +Must be greater than 0

    • +

  • active_set (bool) – If TRUE, performs active set updates. (see our paper for for details). #TODO: Add link for paper

    • +

  • active_set_num (int) –

    The number of consecutive times a support should appear before declaring support stabilization. +(see our paper for for details). #TODO: Add link for paper

    +

    Must be greater than 0.

    +

    • +

  • max_swaps (int) – The maximum number of swaps used by CDPSI for each grid point. +Must be greater than 0. Ignored by CD algorithims.

    • +

  • scale_down_factor (float) –

    Roughly amount each lambda value is scaled by between grid points. Larger values lead to closer lambdas and +typically to smaller gaps between the support sizes.

    +

    For details, see our paper - Section 5 on Adaptive Selection of Tuning Parameters). #TODO: Add link for paper

    +

    Must be greater than 0 and less than 1 (strictly for both.)

    +

    • +

  • screen_size (int) –

    The number of coordinates to cycle over when performing initial correlation screening. #TODO: Add link for paper

    +

    Must be greater than 0 and less than number of columns of X.

    +

    • +

  • lambda_grid (list of list of floats) –

    A grid of lambda values to use in computing the regularization path. This is by default an empty list +and is ignored. When specified, lambda_grid should be a list of list of floats, where the ith element

    +
    +

    (corresponding to the ith gamma) should be a decreasing sequence of lambda values. The length of this sequence +is directly the number of lambdas to be tried for that gamma.

    +
    +

    In the the “L0” penalty case, lambda_grid should be a list of 1. +In the “L0LX” penalty cases, lambda_grid can be a list of any length. The length of lambda_grid will be the +number of gamma values tried.

    +

    See the example notebook for more details.

    +

    Note: When lambda_grid is supplied, num_gamma and num_lambda must be None.

    +

    • +

  • exclude_first_k (int) –

    The first exclude_first_k features in X will be excluded from variable selection. In other words, the first +exclude_first_k variables will not be included in the L0-norm penalty however they will be included in the +L1 or L2 norm penalties, if they are specified.

    +

    Must be a positive integer less than the columns of X.

    +

    • +

  • intercept (bool) – If False, no intercept term is included or fit in the regularization path +Intercept terms are not regularized by L0 or L1/L2.

    • +

  • lows (np array or float) –

    Lower bounds for coefficients. Either a scalar for all coefficients to have the same bound or a vector of +size p (number of columns of X) where lows[i] is the lower bound for coefficient i.

    +

    Lower bounds can not be above 0 (i.e. we can not specify that all coefficients must be larger than a > 0). +Lower bounds can be set to 0 iff the corresponding upper bound for that coefficient is also not 0.

    +

    • +

  • highs (np array or float) –

    Upper bounds for coefficients. Either a scalar for all coefficients to have the same bound or a vector of +size p (number of columns of X) where highs[i] is the upper bound for coefficient i.

    +

    Upper bounds can not be below 0 (i.e. we can not specify that all coefficients must be smaller than a < 0). +Upper bounds can be set to 0 iff the corresponding lower bound for that coefficient is also not 0.

    +

    • +
+
+
Returns
+

fit_model – FitModel instance containing all relevant information from the solution path.

+
+
Return type
+

l0learn.models.FitModel

+
+
+
+

See also

+

l0learn.cvfit, l0learn.models.FitModel

+
+

Examples

+

>>>fit_model = l0learn.fit(X, y, penalty=”L0”, max_support_size=20)

+
+ +
+
+

cvfit function

+
+
+l0learn.cvfit(X: Union[np.ndarray, csc_matrix], y: np.ndarray, unicode loss: str = u'SquaredError', unicode penalty: str = u'L0', unicode algorithm: str = u'CD', num_folds: int = 10, seed: int = 1, max_support_size: int = 100, num_lambda: Optional[int] = 100, num_gamma: Optional[int] = 1, double gamma_max: float = 10., double gamma_min: float = .0001, partial_sort: bool = True, max_iter: int = 200, double rtol: float = 1e-6, double atol: float = 1e-9, active_set: bool = True, active_set_num: int = 3, max_swaps: int = 100, double scale_down_factor: float = 0.8, screen_size: int = 1000, lambda_grid: Optional[List[Sequence[float]]] = None, exclude_first_k: int = 0, intercept: bool = True, lows: Union[np.ndarray, float] = -float(u'inf'), highs: Union[np.ndarray, float] = +float(u'inf')) → l0learn.models.CVFitModel
+

Computes the regularization path for the specified loss function and penalty function and performs K-fold +cross-validation.

+
+
Parameters
+
    +

  • X (np.ndarray or csc_matrix of shape (N, P)) – Data Matrix where rows of X are observations and columns of X are features

    • +

  • y (np.ndarray of shape (P)) – The response vector where y[i] corresponds to X[i, :] +For classification, a binary vector (-1, 1) is requried .

    • +

  • loss (str) –

    +
    The loss function. Currently supports the choices:

    ”SquaredError” (for regression), +“Logistic” (for logistic regression), and +“SquaredHinge” (for smooth SVM).

    +
    +
    +

    • +

  • penalty (str) –

    The type of regularization. +This can take either one of the following choices:

    +
    +

    ”L0”, +“L0L2”, and +“L0L1”

    +
    +

    • +

  • algorithm (str) – The type of algorithm used to minimize the objective function. Currently “CD” and “CDPSI” are are supported. +“CD” is a variant of cyclic coordinate descent and runs very fast. “CDPSI” performs local combinatorial search +on top of CD and typically achieves higher quality solutions (at the expense of increased running time).

    • +

  • num_folds (int) – Must be greater than 1 and less than N (number of . +The number of folds for cross-validation.

    • +

  • max_support_size (int) – Must be greater than 0. +The maximum support size at which to terminate the regularization path. We recommend setting this to a small +fraction of min(n,p) (e.g. 0.05 * min(n,p)) as L0 regularization typically selects a small portion of non-zeros.

    • +

  • num_lambda (int, optional) – The number of lambda values to select in the regularization path. +This value must be None if lambda_grid is supplied.When supplied, must be greater than 0. +Note: lambda is the regularization parameter corresponding to the L0 norm.

    • +

  • num_gamma (int, optional) – The number of gamma values to select in the regularization path. +This value must be None if lambda_grid is supplied. When supplied, must be greater than 0. +Note: gamma is the regularization parameter corresponding to L1 or L2, depending on the chosen penalty).

    • +

  • gamma_max (float) –

    The maximum value of gamma when using the L0L2 penalty. +This value must be greater than 0.

    +

    Note: For the L0L1 penalty this is automatically selected.

    +

    • +

  • gamma_min (float) – The minimum value of Gamma when using the L0L2 penalty. +This value must be greater than 0 but less than gamma_max. +Note: For the L0L1 penalty, the minimum value of gamma in the grid is set to gammaMin * gammaMax.

    • +

  • partial_sort (bool) – If TRUE partial sorting will be used for sorting the coordinates to do greedy cycling (see our paper for +for details). Otherwise, full sorting is used. #TODO: Add link for paper

    • +

  • max_iter (int) – The maximum number of iterations (full cycles) for CD per grid point. The algorithm may not use the full number +of iteration per grid point if convergence is found (defined by rtol and atol parameter) +Must be greater than 0

    • +

  • rtol (float) – The relative tolerance which decides when to terminate optimization as based on the relative change in the +objective between iterations. +Must be greater than 0 and less than 1.

    • +

  • atol (float) – The absolute tolerance which decides when to terminate optimization as based on the absolute L2 norm of the +residuals +Must be greater than 0

    • +

  • active_set (bool) – If TRUE, performs active set updates. (see our paper for for details). #TODO: Add link for paper

    • +

  • active_set_num (int) –

    The number of consecutive times a support should appear before declaring support stabilization. +(see our paper for for details). #TODO: Add link for paper

    +

    Must be greater than 0.

    +

    • +

  • max_swaps (int) – The maximum number of swaps used by CDPSI for each grid point. +Must be greater than 0. Ignored by CD algorithims.

    • +

  • scale_down_factor (float) –

    Roughly amount each lambda value is scaled by between grid points. Larger values lead to closer lambdas and +typically to smaller gaps between the support sizes.

    +

    For details, see our paper - Section 5 on Adaptive Selection of Tuning Parameters). #TODO: Add link for paper

    +

    Must be greater than 0 and less than 1 (strictly for both.)

    +

    • +

  • screen_size (int) –

    The number of coordinates to cycle over when performing initial correlation screening. #TODO: Add link for paper

    +

    Must be greater than 0 and less than number of columns of X.

    +

    • +

  • lambda_grid (list of list of floats) –

    A grid of lambda values to use in computing the regularization path. This is by default an empty list +and is ignored. When specified, lambda_grid should be a list of list of floats, where the ith element

    +
    +

    (corresponding to the ith gamma) should be a decreasing sequence of lambda values. The length of this sequence +is directly the number of lambdas to be tried for that gamma.

    +
    +

    In the the “L0” penalty case, lambda_grid should be a list of 1. +In the “L0LX” penalty cases, lambda_grid can be a list of any length. The length of lambda_grid will be the +number of gamma values tried.

    +

    See the example notebook for more details.

    +

    Note: When lambda_grid is supplied, num_gamma and num_lambda must be None.

    +

    • +

  • exclude_first_k (int) –

    The first exclude_first_k features in X will be excluded from variable selection. In other words, the first +exclude_first_k variables will not be included in the L0-norm penalty however they will be included in the +L1 or L2 norm penalties, if they are specified.

    +

    Must be a positive integer less than the columns of X.

    +

    • +

  • intercept (bool) – If False, no intercept term is included or fit in the regularization path +Intercept terms are not regularized by L0 or L1/L2.

    • +

  • lows (np array or float) –

    Lower bounds for coefficients. Either a scalar for all coefficients to have the same bound or a vector of +size p (number of columns of X) where lows[i] is the lower bound for coefficient i.

    +

    Lower bounds can not be above 0 (i.e. we can not specify that all coefficients must be larger than a > 0). +Lower bounds can be set to 0 iff the corresponding upper bound for that coefficient is also not 0.

    +

    • +

  • highs (np array or float) –

    Upper bounds for coefficients. Either a scalar for all coefficients to have the same bound or a vector of +size p (number of columns of X) where highs[i] is the upper bound for coefficient i.

    +

    Upper bounds can not be below 0 (i.e. we can not specify that all coefficients must be smaller than a < 0). +Upper bounds can be set to 0 iff the corresponding lower bound for that coefficient is also not 0.

    +

    • +
+
+
Returns
+

fit_model – FitModel instance containing all relevant information from the solution path.

+
+
Return type
+

l0learn.models.FitModel

+
+
+
+

See also

+

l0learn.cvfit, l0learn.models.FitModel

+
+

Examples

+

>>>fit_model = l0learn.fit(X, y, penalty=”L0”, max_support_size=20)

+
+ +
+
+

FitModels

+
+
+class l0learn.models.FitModel(settings: Dict[str, Any], lambda_0: List[List[float]], gamma: List[float], support_size: List[List[int]], coeffs: List[scipy.sparse.csc.csc_matrix], intercepts: List[List[float]], converged: List[List[bool]])
+

FitModel returned by calling l0learn.fit(…)

+
+ +
+
+

CVFitModels

+
+
+class l0learn.models.CVFitModel(settings: Dict[str, Any], lambda_0: List[List[float]], gamma: List[float], support_size: List[List[int]], coeffs: List[scipy.sparse.csc.csc_matrix], intercepts: List[List[float]], converged: List[List[bool]], cv_means: List[numpy.ndarray], cv_sds: List[numpy.ndarray])
+
+ +
+
+

Generating Functions

+
+
+l0learn.models.gen_synthetic(n: int, p: int, k: int, seed: Optional[int] = None, rho: float = 0, b0: float = 0, snr: float = 1) → Dict[str, Union[float, numpy.ndarray]]
+
+
Generates a synthetic dataset as follows:
    +

  1. Sample every element in data matrix X from N(0,1).

    2. +

  2. Generate a vector B with the first k entries set to 1 and the rest are zeros.

    3. +

  3. Sample every element in the noise vector e from N(0,A) where A is selected so y, X, B have snr as specified.

    4. +

  4. Set y = XB + b0 + e.

    5. +
+
+
+
+
Parameters
+
    +

  • n (int) – Number of samples

    • +

  • p (int) – Number of features

    • +

  • k (int) – Number of non-zeros in true vector of coefficients

    • +

  • seed (int, optional) – The seed used for randomly generating the data +If None, numbers will be random

    • +

  • rho (float, default 0.) – The threshold for setting X values to 0. if |X[i, j]| < rho => X[i, j] <- 0

    • +

  • b0 (float, default 0) – The intercept value to translate y by.

    • +

  • snr (float, default 1) –

    Desired Signal-to-Noise ratio. This sets the magnitude of the error term ‘e’.

    +

    Note: SNR is defined as SNR = Var(XB)/Var(e)

    +

    • +
+
+
Returns
+

Data –

+
+
A dict containing:

the data matrix X, +the response vector y, +the coefficients B, +the error vector e, +the intercept term b0.

+
+
+

+
+
Return type
+

Dict

+
+
+

Examples

+

>>>data = gen_synthetic(n=500,p=1000,k=10,seed=1)

+
+ +
+
+l0learn.models.gen_synthetic_high_corr(n: int, p: int, k: int, seed: Optional[int] = None, rho: float = 0, b0: float = 0, snr: float = 1, mu: float = 0, base_cor: float = 0.8) → Dict[str, Union[float, numpy.ndarray]]
+
+
Generates a synthetic dataset as follows:
    +

  1. Generate a correlation matrix, SIG, where item [i, j] = base_core^|i-j|.

    2. +

  2. Draw from a Multivariate Normal Distribution using (mu and SIG) to generate X.

    3. +

  3. Generate a vector B with every ~p/k entry set to 1 and the rest are zeros.

    4. +

  4. Sample every element in the noise vector e from N(0,A) where A is selected so y, X, B have snr as specified.

    5. +

  5. Set y = XB + b0 + e.

    6. +
+
+
+
+
Parameters
+
    +

  • n (int) – Number of samples

    • +

  • p (int) – Number of features

    • +

  • k (int) – Number of non-zeros in true vector of coefficients

    • +

  • seed (int) – The seed used for randomly generating the data

    • +

  • rho (float) – The threshold for setting values to 0. if |X[i, j]| < rho => X[i, j] <- 0

    • +

  • b0 (float) – intercept value to scale y by.

    • +

  • snr (float) – desired Signal-to-Noise ratio. This sets the magnitude of the error term ‘e’. +SNR is defined as SNR = Var(XB)/Var(e)

    • +

  • mu (float) – The mean for drawing from the Multivariate Normal Distribution. A scalar of vector of length p.

    • +

  • base_cor (float) – The base correlation, A in [i, j] = A^|i-j|.

    • +
+
+
Returns
+

data –

+
+
A dict containing:

the data matrix X, +the response vector y, +the coefficients B, +the error vector e, +the intercept term b0.

+
+
+

+
+
Return type
+

dict

+
+
+

Examples

+

>>>gen_synthetic_high_corr(n=500,p=1000,k=10,seed=1)

+
+ +
+
+l0learn.models.gen_synthetic_logistic(n: int, p: int, k: int, seed: Optional[int] = None, rho: float = 0, b0: float = 0, s: float = 1, mu: Optional[float] = None, base_cor: Optional[float] = None) → Dict[str, Union[float, numpy.ndarray]]
+
+
Generates a synthetic dataset as follows:
    +
  1. +
    Generate a data matrix, X, drawn from either N(0, 1) (see gen_synthetic) or a multivariate_normal(mu, sigma)

    (See gen_synthetic_high_corr) +gen_synthetic_logistic delegates these caluclations to the respective functions.

    +
    +
    +
    2. +

  2. Generate a vector B with k entries set to 1 and the rest are zeros.

    3. +
  3. +
    Every coordinate yi of the outcome vector y exists in {0, 1}^n is sampled independently from a Bernoulli
    +
    distribution with success probability:

    P(yi = 1|xi) = 1/(1 + exp(-s<xi, B>))

    +
    +
    +

    Source https://arxiv.org/pdf/2001.06471.pdf Section 5.1 Data Generation

    +
    +
    +
    4. +
+
+
+
+
Parameters
+
    +

  • n (int) – Number of samples

    • +

  • p (int) – Number of features

    • +

  • k (int) – Number of non-zeros in true vector of coefficients

    • +

  • seed (int) – The seed used for randomly generating the data

    • +

  • rho (float) – The threshold for setting values to 0. if |X[i, j]| > rho => X[i, j] <- 0

    • +

  • b0 (float) – The intercept value to scale the log odds of y by. +As b0 -> +inf, y will contain more 1s +As b0 -> -inf, y will contain more 0s

    • +

  • s (float) – Signal-to-noise parameter. As s -> +Inf, the data generated becomes linearly separable.

    • +

  • mu (float, optional) – The mean for drawing from the Multivariate Normal Distribution. A scalar of vector of length p. +If mu and base_cor are not specified, will be drawn from N(0, 1) using gen_synthetic. +If mu and base_cor are specified will be drawn from multivariate_normal(mu, sigma) see gen_synthetic_high_corr

    • +

  • base_cor (float) – The base correlation, A in [i, j] = A^|i-j|. +If mu and base_cor are not specified, will be drawn from N(0, 1) +If mu and base_cor are specified will be drawn from multivariate_normal(mu, sigma) see gen_synthetic_high_corr

    • +
+
+
Returns
+

data –

+
+
A dict containing:

the data matrix X +the response vector y, +the coefficients B, +the intercept term b0.

+
+
+

+
+
Return type
+

dict

+
+
+
+ +
+
+

Scoring Functions

+

These functions are called by l0learn.models.FitModel.score() and l0learn.models.CVFitModel.score().

+
+
+l0learn.models.regularization_loss(coeffs: scipy.sparse.csc.csc_matrix, l0: Union[float, Sequence[float]] = 0, l1: Union[float, Sequence[float]] = 0, l2: Union[float, Sequence[float]] = 0) → Union[float, numpy.ndarray]
+

Calculates the regularization loss for a path of (or individual) solution(s).

+
+
Parameters
+
    +

  • coeffs –

    • +

  • l0 –

    • +

  • l1 –

    • +

  • l2 –

    • +
+
+
Returns
+

loss –

+
+
Let the shape of coeffs be (P, K) and l0, l1, and l2 by either a float or a sequence of length K
+
Then loss will be of shape: (K, ) with the following layout:

loss[i] = l0[i]*||coeffs[:, i||_0 + l1[i]*||coeffs[:, i||_1 + l2[i]*||coeffs[:, i||_2

+
+
+
+
+

+
+
Return type
+

float or np.ndarray of shape (K,) where K is the number of solutions in coeffs

+
+
+

Notes

+
+ +
+
+l0learn.models.squared_error(y_true: numpy.ndarray, y_pred: numpy.ndarray, coeffs: Optional[scipy.sparse.csc.csc_matrix] = None, l0: Union[float, Sequence[float]] = 0, l1: Union[float, Sequence[float]] = 0, l2: Union[float, Sequence[float]] = 0) → numpy.ndarray
+

Calculates Squared Error loss of solution with optional regularization

+
+
Parameters
+
    +

  • y_true (np.ndarray of shape (m, )) –

    • +

  • y_pred (np.ndarray of shape (m, ) or (m, k)) –

    • +

  • coeffs (np.ndarray of shape (p, k), optional) –

    • +

  • l0 (float or sequence of floats of shape (l)) –

    • +

  • l1 (float or sequence of floats of shape (l)) –

    • +

  • l2 (float or sequence of floats of shape (l)) –

    • +
+
+
Returns
+

squared_error – Shape (,) if y_pred is 1D or = (k,) if y_pred is 2D

+
+
Return type
+

np.ndarray

+
+
+
+ +
+
+l0learn.models.logistic_loss(y_true: numpy.ndarray, y_pred: numpy.ndarray, coeffs: Optional[scipy.sparse.csc.csc_matrix] = None, l0: float = 0, l1: float = 0, l2: float = 0, eps: float = 1e-15) → numpy.ndarray
+

Calculates Logistic Loss of solution with optional regularization

+
+
Parameters
+
    +

  • y_true (np.ndarray of shape (m, )) –

    • +

  • y_pred (np.ndarray of shape (m, ) or (m, k)) –

    • +

  • coeffs (np.ndarray of shape (p, k), optional) –

    • +

  • l0 (float or sequence of floats of shape (l)) –

    • +

  • l1 (float or sequence of floats of shape (l)) –

    • +

  • l2 (float or sequence of floats of shape (l)) –

    • +

  • eps (float, default=1e-15) – Logistic loss is undefined for p=0 or p=1, so probabilities are clipped to max(eps, min(1 - eps, p)).

    • +
+
+
Returns
+

logistic_loss – Shape (,) if y_pred is 1D or = (k,) if y_pred is 2D

+
+
Return type
+

np.ndarray

+
+
+
+ +
+
+l0learn.models.squared_hinge_loss(y_true: numpy.ndarray, y_pred: numpy.ndarray, coeffs: Optional[scipy.sparse.csc.csc_matrix] = None, l0: float = 0, l1: float = 0, l2: float = 0) → numpy.ndarray
+

Calculates Logistic Loss of solution with optional regularization

+
+
Parameters
+
    +

  • y_true (np.ndarray of shape (m, )) –

    • +

  • y_pred (np.ndarray of shape (m, ) or (m, k)) –

    • +

  • coeffs (np.ndarray of shape (p, k), optional) –

    • +

  • l0 (float or sequence of floats of shape (l)) –

    • +

  • l1 (float or sequence of floats of shape (l)) –

    • +

  • l2 (float or sequence of floats of shape (l)) –

    • +
+
+
Returns
+

squared_hinge_loss – Shape (,) if y_pred is 1D or = (k,) if y_pred is 2D

+
+
Return type
+

np.ndarray

+
+
+
+ +
+ + +
+ +
+
+ +
+
+
+ ©2021, Hussein Hazimeh, Rahul Mazumder, and Tim Nonet. + + | + Powered by Sphinx 4.3.0 + & Alabaster 0.7.12 + + | + Page source +
+ + + + + + \ No newline at end of file diff --git a/python/_github_pages_docs/html/genindex.html b/python/_github_pages_docs/html/genindex.html new file mode 100644 index 0000000..c3dec59 --- /dev/null +++ b/python/_github_pages_docs/html/genindex.html @@ -0,0 +1,186 @@ + + + + + + + + Index — l0learn documentation + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + +

Index

+ +
+ C + | F + | G + | L + | R + | S + +
+

C

+ + + +
+ +

F

+ + + +
+ +

G

+ + + +
+ +

L

+ + +
+ +

R

+ + +
+ +

S

+ + + +
+ + + +
+ +
+
+ +
+
+
+ ©2021, Hussein Hazimeh, Rahul Mazumder, and Tim Nonet. + + | + Powered by Sphinx 4.3.0 + & Alabaster 0.7.12 + +
+ + + + + + \ No newline at end of file diff --git a/python/_github_pages_docs/html/index.html b/python/_github_pages_docs/html/index.html new file mode 100644 index 0000000..7b69890 --- /dev/null +++ b/python/_github_pages_docs/html/index.html @@ -0,0 +1,148 @@ + + + + + + + + + Welcome to l0learn’s documentation! — l0learn documentation + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ +
+

Welcome to l0learn’s documentation!

+
+ +
+
+
+

Indices and tables

+ +
+ + +
+ +
+
+ +
+
+
+ ©2021, Hussein Hazimeh, Rahul Mazumder, and Tim Nonet. + + | + Powered by Sphinx 4.3.0 + & Alabaster 0.7.12 + + | + Page source +
+ + + + + + \ No newline at end of file diff --git a/python/_github_pages_docs/html/objects.inv b/python/_github_pages_docs/html/objects.inv new file mode 100644 index 0000000000000000000000000000000000000000..2244ecb18287f99d2c6a0b5030ebd03b99306da6 GIT binary patch literal 1048 zcmV+z1n2uBAX9K?X>NERX>N99Zgg*Qc_4OWa&u{KZXhxWBOp+6Z)#;@bUGkxFl=RE za&8JEAXa5^b7^mGIv@%oAXI2&AaZ4GVQFq;WpW^IW*~HEX>%ZEX>4U6X>%ZBZ*6dL zWpi_7WFU2OX>MmAdTeQ8E(&S)r(G9orf zkO;Vdr<1Pw8~we0Nw2{Vh;3{~$^tIuoO^8Wy@W3~B}&YbmmM=GJKgSbkr*Zgx<-ji z>HJ`heD)UMD_$bU;*JpIdVcr)o|#oKE?5aCS`Ses6ZTYW^huZlH7uE8E+B3WY=77! zQmM-&xZE>6(L}`oGCb-8qN4kp6UBa$0zH|of96EdbVHSr>Js9Ci9H=o``%8KHb|TF zmXj^)EcQUCI8hb5LC@@w#IGPl{^azKbVAdfuLdcit7AenPvrj{k?Hbg((w}Z(vc6Qq ziNZ2AE?dZnEso6VRly4!ckZYW`@`;vGU5?A%j#ojQ&RaD((dQ9*IhKi&pP$qd;F7R{1JF~D{pk{H{0l%@I z2@I|;HM4XQFu0ETTHe^tufUD4ShP*5FjOqg%n57Bb9*RpuB~&K5RNr`P01l<^K&S( zK9gBmnYEJ%v8cu(i$xZT9JXbb32g}HgGct!$N7^E#pXMYD|)zSaX3mvaY_wg@vU7I zxKAann4ogfQdD$D6%`4M>OD88X4ulwlvC>)!%yd1O%0Yi_?Q9HF85)Ewa;DG-0wBF z1|ax30FpaY1KMsfqBO-vVibD?J6R@`iCS=kl_RW6f{P*-MP;;=teVF3zgC!P&{D}Y z9A2H#1PTyTbxw}kl;FK$@iP4_q%9ro!P3Gt + + + + + + Search — l0learn documentation + + + + + + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ +

Search

+ + + + +

+ Searching for multiple words only shows matches that contain + all words. +

+ + +
+ + + +
+ + + +
+ +
+ + +
+ +
+
+ +
+
+
+ ©2021, Hussein Hazimeh, Rahul Mazumder, and Tim Nonet. + + | + Powered by Sphinx 4.3.0 + & Alabaster 0.7.12 + +
+ + + + + + \ No newline at end of file diff --git a/python/_github_pages_docs/html/searchindex.js b/python/_github_pages_docs/html/searchindex.js new file mode 100644 index 0000000..1d1a55b --- /dev/null +++ b/python/_github_pages_docs/html/searchindex.js @@ -0,0 +1 @@ +Search.setIndex({docnames:["code","index","tutorial"],envversion:{"sphinx.domains.c":2,"sphinx.domains.changeset":1,"sphinx.domains.citation":1,"sphinx.domains.cpp":4,"sphinx.domains.index":1,"sphinx.domains.javascript":2,"sphinx.domains.math":2,"sphinx.domains.python":3,"sphinx.domains.rst":2,"sphinx.domains.std":2,nbsphinx:3,sphinx:56},filenames:["code.rst","index.rst","tutorial.ipynb"],objects:{"l0learn.models":[[0,1,1,"","CVFitModel"],[0,1,1,"","FitModel"],[0,0,1,"","gen_synthetic"],[0,0,1,"","gen_synthetic_high_corr"],[0,0,1,"","gen_synthetic_logistic"],[0,0,1,"","logistic_loss"],[0,0,1,"","regularization_loss"],[0,0,1,"","squared_error"],[0,0,1,"","squared_hinge_loss"]],l0learn:[[0,0,1,"","cvfit"],[0,0,1,"","fit"]]},objnames:{"0":["py","function","Python function"],"1":["py","class","Python class"]},objtypes:{"0":"py:function","1":"py:class"},terms:{"0":[0,2],"0000":2,"00000":2,"000000":2,"000000e":2,"00001":2,"000064":2,"0001":[0,2],"00010":2,"000100":2,"000130":2,"000132":2,"000133":2,"000134":2,"000141":2,"000159":2,"000167":2,"000173":2,"000178":2,"000187":2,"000212":2,"000216":2,"000533":2,"000797":2,"000857":2,"001":2,"0010":2,"00100":2,"001199":2,"001371":2,"001419":2,"001483":2,"001497":2,"001587":2,"0016":2,"0016080760437896327":2,"00190748":2,"002":2,"00200":2,"002048":2,"002130":2,"002157":2,"00215713":2,"002161":2,"002187":2,"002500":2,"002556":2,"002597":2,"002634":2,"002654":2,"002821":2,"002911":2,"002987":2,"003636":2,"003684":2,"003685":2,"003750":2,"003788":2,"003866":2,"004044":2,"004111":2,"004113":2,"004211":2,"004515":2,"004637":2,"004882":2,"005264":2,"005560":2,"005760":2,"0058037":2,"006364":2,"006480":2,"007959":2,"008151":2,"008771":2,"009191":2,"009286":2,"009325":2,"009603":2,"01":2,"0100":2,"01000":2,"010249":2,"010854":2,"01128182":2,"012180":2,"01272103":2,"012732":2,"012762":2,"013932":2,"014394":2,"014442":2,"014785":2,"015045":2,"015697":2,"015724":2,"016000":2,"016811":2,"016812":2,"017599":2,"018729":2,"01994648":2,"02014176":2,"020606":2,"021199":2,"021333":2,"021393":2,"021913":2,"024710":2,"0266543":2,"027624":2,"029115":2,"029367":2,"03":2,"031573":2,"031623":2,"031892":2,"032":2,"032715":2,"03271533058913737":2,"032770":2,"036989":2,"039705":2,"04":2,"041058":2,"041672":2,"043199":2,"043230":2,"043245":2,"044333":2,"044517":2,"047991":2,"048700":2,"05":0,"050464":2,"051675":2,"058013":2,"06":2,"061685":2,"06471":0,"065862":2,"06707991":2,"07":2,"078750":2,"079546":2,"0s":0,"1":[0,2],"10":[0,2],"100":0,"1000":[0,2],"10000":2,"1000x1":2,"1001x1":2,"107":2,"11":2,"110":2,"110626":2,"113":2,"114":2,"114306":2,"115":2,"116":2,"117":2,"118558":2,"12":2,"124533":2,"128":2,"129":2,"13":2,"130":2,"131":2,"132":2,"133":2,"134":2,"14":2,"142882":2,"147182":2,"147743":2,"148003":2,"148650":2,"15":[0,2],"15002055":2,"156250":2,"156704":2,"16":2,"161024":2,"17":2,"178144":2,"18":2,"184678":2,"18562493":2,"188422":2,"188875":2,"19":2,"192033":2,"196406":2,"1d":0,"1e":[0,2],"1s":0,"2":2,"20":[0,2],"200":0,"2001":0,"2020":2,"206093":2,"208883":2,"21":2,"211002":2,"219990":2,"22":2,"221470":2,"225336":2,"23":2,"230848":2,"234899":2,"237988":2,"23997924":2,"24":2,"242631":2,"243655":2,"243993":2,"244295":2,"244520":2,"244716":2,"244886":2,"245011":2,"245133":2,"246182":2,"25":2,"255":2,"25545111":2,"2555564968851251":2,"25555788170828786":2,"2558807301729078":2,"25608131":2,"26":2,"2669789604993652":2,"267":2,"28":2,"297484":2,"2d":0,"3":[0,2],"30":2,"311":2,"31499242":2,"34":2,"3474209":2,"355651":2,"371856":2,"383356":2,"39":2,"4":2,"40":2,"41":2,"411":2,"411211":2,"432053":2,"438":2,"44":2,"45":2,"479195":2,"5":[0,2],"50":2,"500":[0,2],"500x1":2,"500x1000":2,"507616":2,"52":2,"5313128699361661":2,"57":2,"58":2,"582":2,"598994":2,"5th":2,"6":[0,2],"600880":2,"617520":2,"62":2,"667317":2,"680704":2,"68272239":2,"69035746e":2,"69435":2,"69583037e":2,"7":2,"70":2,"72":2,"751100":2,"771900":2,"77309853":2,"77364234":2,"8":[0,2],"83":2,"84":2,"884520":2,"8th":2,"9":[0,2],"90":2,"92195535e":2,"92440655e":2,"928603":2,"93":2,"94":2,"944563":2,"964874":2,"97317979":2,"97338278":2,"99161941e":2,"99171256e":2,"99204841":2,"99607406":2,"99669481":2,"99813347":2,"case":[0,2],"class":[0,2],"default":[0,2],"do":[0,2],"final":2,"float":[0,2],"function":[1,2],"import":2,"int":0,"new":2,"return":[0,2],"true":[0,2],"var":0,A:[0,2],As:0,By:2,For:[0,2],If:[0,2],In:[0,2],The:[0,2],Then:0,These:[0,2],To:2,_0:[0,2],_1:[0,2],_2:[0,2],_subplot:2,abov:[0,2],absolut:0,accept:2,access:2,achiev:[0,2],activ:[0,2],active_set:0,active_set_num:0,ad:2,adapt:0,add:0,addit:2,advanc:1,against:2,algorithim:0,algorithm:[0,2],all:[0,2],allow:2,along:2,also:[0,2],alwai:2,ambigu:2,amount:0,an:[0,2],ani:[0,2],antoin:2,api:2,appear:[0,2],appli:2,applic:2,appropri:2,approxim:2,ar:[0,2],argmin:2,arrai:[0,2],arxiv:0,asid:2,assign:2,associ:2,assum:2,atol:0,attribut:2,automat:[0,2],avail:2,avoid:2,ax:2,axessubplot:2,b0:0,b:[0,2],bar:2,base:[0,2],base_cor:0,becom:0,befor:[0,2],begin:2,behavior:2,belong:2,below:[0,2],bernoulli:0,best:2,beta:2,beta_0:2,beta_i:2,beta_vector:2,better:2,between:[0,2],binari:0,bla:2,bool:0,both:[0,2],bound:0,built:2,c:2,calcul:0,call:[0,2],calucl:0,can:[0,2],cd:[0,2],cdpsi:[0,2],certain:2,chang:[0,2],characterist:2,choic:[0,2],chosen:[0,2],classif:[0,1],classifi:2,clip:0,close:2,closer:0,code:2,coeff:[0,2],coeffici:0,column:[0,2],combin:2,combinatori:[0,2],command:2,commonli:2,compar:2,complet:2,compon:2,compress:2,comput:[0,2],computation:2,connect:2,consecut:0,constraint:2,contain:0,continu:2,control:2,converg:[0,2],convert:2,convex:2,coordin:[0,2],correctli:2,correl:[0,2],correspond:[0,2],cross:[0,1],csc:[0,2],csc_matrix:[0,2],current:[0,2],custom:2,cv:2,cv_fit_result:2,cv_mean:[0,2],cv_plot:2,cv_sd:[0,2],cvfit:[1,2],cvfitmodel:[1,2],cycl:[0,2],cyclic:[0,2],data:[0,2],data_rv:2,dataset:[0,2],decid:0,declar:0,decreas:[0,2],dedieu:2,defin:0,deleg:0,demonstr:2,denot:2,dens:2,densiti:2,depend:[0,2],descent:[0,2],design:2,desir:[0,2],detail:[0,1],dict:0,differ:2,dimens:2,dimension:2,directli:[0,2],discuss:2,dispali:2,displai:2,distribut:0,doc:2,document:2,doe:2,done:2,doubl:0,draw:0,drawn:0,due:2,duplic:2,dure:2,dynam:2,e:[0,2],each:[0,2],easi:2,edgeitem:2,effect:2,effici:2,either:[0,2],elabor:2,element:[0,2],ell:2,emploi:2,empti:0,end:2,ensur:2,enter:2,entri:[0,2],enumer:2,environ:2,ep:0,equat:2,equi:2,error:[0,2],especi:2,estim:2,everi:[0,2],exampl:[0,2],exclud:[0,2],exclude_first_k:[0,2],excludefirstk:2,execut:2,exist:[0,2],exp:0,expens:0,exploit:2,express:2,extend:2,extract:2,f:2,face:2,fals:[0,2],fast:[0,2],featur:[0,2],fill:2,find:2,first:[0,2],fit:1,fit_grid:2,fit_grid_l2:2,fit_model:[0,2],fit_model_2:2,fit_model_3:2,fit_model_bound:2,fit_model_k:2,fit_model_spars:2,fitmodel:[1,2],fix:2,float64:2,fold:[0,2],follow:[0,2],format:2,found:[0,2],fraction:0,from:[0,2],full:0,further:2,futur:2,g:[0,2],gamma:[0,2],gamma_max:[0,2],gamma_min:[0,2],gammamax:0,gammamin:0,gap:0,gen_synthet:[0,2],gen_synthetic_high_corr:[0,2],gen_synthetic_logist:[0,2],gener:[1,2],get:2,github:2,give:2,greater:0,greedi:[0,2],grid:0,gt:2,ha:2,have:[0,2],hazimeh:2,help:2,here:2,heurist:2,high:[0,2],higher:[0,1],highli:2,highs_arrai:2,hing:2,how:2,howev:[0,2],hstack:2,http:0,hussein:2,i:[0,2],iff:0,ignor:[0,2],iid:2,implement:2,improv:2,includ:[0,2],include_intercept:2,include_legend:2,increas:0,independ:0,index:1,indic:2,individu:0,induc:2,inf:0,influenc:2,inform:0,infti:2,initi:0,inspect:2,instal:1,instanc:0,instead:2,instruct:2,integ:[0,2],intercept:[0,2],interfac:2,intern:2,introduct:1,ipython:2,issu:2,item:0,iter:0,ith:[0,2],j:0,jmlr:2,just:2,k:[0,2],keep:2,kei:2,kwarg:2,l0:[0,1],l0l1:[0,1],l0l2:[0,1],l0learn:[0,2],l0lx:0,l1:[0,2],l2:[0,2],l:0,lambda:0,lambda_0:[0,2],lambda_grid:[0,2],langl:2,larg:2,larger:[0,2],latter:2,layout:0,lead:[0,2],learn:2,legend:2,length:[0,2],less:[0,2],let:0,like:2,limit:2,line:2,linear:2,linearli:0,link:0,list:[0,2],load:2,local:[0,1],log:0,logarithm:2,logist:[0,2],logistic_loss:0,loss:[0,2],low:[0,2],lower:0,lowest:2,lt:2,m:0,magnitud:[0,2],mai:0,main:2,maintain:2,make:2,mani:2,manner:2,manual:2,match:2,math:2,matplotlib:2,matric:2,matrix:0,max:[0,2],max_it:0,max_support_s:[0,2],max_swap:0,max_valu:2,maximum:[0,2],mazumd:2,mcp:2,mean:0,method:2,might:2,min:[0,2],min_:2,min_error:2,minim:0,minimum:[0,2],mix:2,model:[0,1],modul:1,more:[0,1],moreov:2,most:2,mu:0,multivari:0,multivariate_norm:0,must:[0,2],n:[0,2],ndarrai:0,need:2,neg:2,newx:2,next:2,nois:0,non:[0,2],none:[0,2],norm:[0,2],normal:[0,2],note:[0,2],notebook:[0,2],notic:2,np:[0,2],num_fold:[0,2],num_gamma:[0,2],num_lambda:[0,2],number:[0,2],numer:2,numpi:[0,2],object:[0,2],observ:0,odd:0,onc:2,one:[0,2],ones:2,onli:2,oper:2,optim:[0,2],optimal_gamma_index:2,optimal_lambda_index:2,option:[0,1],order:2,org:0,other:[0,2],otherwis:0,our:[0,2],outcom:0,outperform:2,output:2,over:[0,2],overfit:2,own:2,p:[0,2],packag:2,page:1,pair:2,paper:[0,2],paramet:[0,2],partial:0,partial_sort:0,particular:2,particularli:2,path:[0,2],pdf:0,penal:2,penalti:[0,2],per:0,perform:[0,2],perspect:2,pip:2,plan:2,pleas:2,plot:2,plu:2,point:[0,2],portion:0,posit:[0,2],precis:2,predict:2,present:2,previou:2,previous:2,print:2,printopt:2,probabl:[0,2],problem:2,proce:2,produc:2,provid:2,py:2,python:2,quad:2,qualiti:[0,1],quit:2,rahul:2,random:[0,2],randomli:[0,2],rang:2,rangl:2,ratio:[0,2],real:2,recal:2,recommend:0,recov:2,refer:1,regim:2,regress:[0,1],regular:[0,2],regularization_loss:0,rel:0,relev:0,repo:2,reproduc:2,request:2,requir:2,requri:0,research:2,reshap:2,residu:[0,2],resolv:2,respect:0,respons:[0,2],rest:[0,2],result:2,rho:0,rich:2,ridg:2,roughli:[0,2],row:[0,2],rtol:0,run:[0,2],rv:2,s:[0,2],same:[0,2],sampl:[0,2],satisfi:2,scalar:[0,2],scale:[0,2],scale_down_factor:0,scipi:[0,2],score:1,screen:[0,2],screen_siz:0,search:[0,1],second:2,section:0,see:[0,2],seed:[0,2],seen:2,select:0,separ:0,sequenc:[0,2],set:[0,2],shape:0,should:[0,2],show:2,show_lin:2,shrinkag:2,shuffl:2,sig:0,sigma:0,sign:2,signal:0,signific:2,similar:2,similarli:2,simpl:2,sinc:2,singl:2,size:[0,2],slightli:2,slower:2,small:[0,2],smaller:0,smooth:[0,2],snr:0,so:[0,2],solut:[0,1],solv:2,some:2,sort:0,sourc:0,space:2,sparis:2,spars:0,sparsiti:2,speak:2,specif:2,specifi:0,specifici:2,speed:2,squar:[0,2],squared_error:0,squared_hinge_loss:0,squarederror:0,squaredhing:[0,2],stabil:0,stabl:2,standard:2,start:2,stat:2,still:2,storag:2,store:2,str:0,strength:2,strictli:[0,2],string:2,structur:2,sub:2,subclass:2,subject:2,submit:2,success:0,successfulli:2,suffici:2,sum_:2,summari:2,suppli:[0,2],support:0,support_s:[0,2],suppos:2,svm:[0,2],swap:0,synthet:[0,2],t:2,take:[0,2],term:[0,2],termin:[0,2],test:2,th:2,than:[0,2],thei:[0,2],thi:[0,2],those:2,three:2,threshold:[0,2],through:2,thu:2,time:0,tnonet:2,toarrai:2,todo:0,toler:0,toolkit:2,top:0,translat:0,tri:0,trick:2,troubleshoot:2,tune:[0,2],tutori:1,two:2,type:[0,2],typic:[0,2],u:0,undefin:0,under:2,underlini:2,unicod:0,union:0,uniqu:2,up:2,updat:[0,2],upper:0,us:[0,1],user_lambda_grid:2,user_lambda_grid_l2:2,userwarn:2,valid:[0,1],valu:[0,2],variabl:0,variant:0,vector:[0,2],veri:[0,2],verifi:2,version:2,versu:2,view:2,vignett:2,visual:2,want:2,warm:2,warn:2,wast:2,we:[0,2],when:[0,2],where:[0,2],which:[0,2],wiki:2,without:2,word:0,work:2,x:[0,2],x_i:2,x_spars:2,xb:[0,2],xi:0,xlabel:2,y:[0,2],y_i:2,y_pred:0,y_spars:2,y_true:0,yi:0,ylabel:2,you:2,your:2,zero:[0,2]},titles:["fit function","Welcome to l0learn\u2019s documentation!","Introduction"],titleterms:{"function":0,advanc:2,bound:2,classif:2,coeffici:2,cross:2,cvfit:0,cvfitmodel:0,detail:2,document:1,fit:[0,2],fitmodel:0,gener:0,grid:2,higher:2,indic:1,instal:2,introduct:2,l0:2,l0l1:2,l0l2:2,l0learn:1,lambda:2,local:2,matrix:2,model:2,more:2,option:2,qualiti:2,refer:2,regress:2,s:1,score:0,search:2,select:2,solut:2,spars:2,specifi:2,subset:2,support:2,tabl:1,tutori:2,us:2,user:2,valid:2,variabl:2,welcom:1}}) \ No newline at end of file diff --git a/python/_github_pages_docs/html/tutorial.html b/python/_github_pages_docs/html/tutorial.html new file mode 100644 index 0000000..6f62ccf --- /dev/null +++ b/python/_github_pages_docs/html/tutorial.html @@ -0,0 +1,2132 @@ + + + + + + + + + Introduction — l0learn documentation + + + + + + + + + + + + + + + + + + + + + + +
+
+
+ + +
+ + + +
+

Introduction

+

l0learn is a fast toolkit for L0-regularized learning. L0 regularization selects the best subset of features and can outperform commonly used feature selection methods (e.g., L1 and MCP) under many sparse learning regimes. The toolkit can (approximately) solve the following three problems

+

\begin{equation} +\min_{\beta_0, \beta} \sum_{i=1}^{n} \ell(y_i, \beta_0+ \langle x_i, \beta \rangle) + \lambda ||\beta||_0 \quad \quad (L0) +\end{equation}

+

\begin{equation} +\min_{\beta_0, \beta} \sum_{i=1}^{n} \ell(y_i, \beta_0+ \langle x_i, \beta \rangle) + \lambda ||\beta||_0 + \gamma||\beta||_1 \quad (L0L1) +\end{equation}

+

\begin{equation} +\min_{\beta_0, \beta} \sum_{i=1}^{n} \ell(y_i, \beta_0+ \langle x_i, \beta \rangle) + \lambda ||\beta||_0 + \gamma||\beta||_2^2 \quad (L0L2) +\end{equation}

+

where \(\ell\) is the loss function, \(\beta_0\) is the intercept, \(\beta\) is the vector of coefficients, and \(||\beta||_0\) denotes the L0 norm of \(\beta\), i.e., the number of non-zeros in \(\beta\). We support both regression and classification using either one of the following loss functions:

+
    +

  • Squared error loss

    • +

  • Logistic loss (logistic regression)

    • +

  • Squared hinge loss (smoothed version of SVM).

    • +
+

The parameter \(\lambda\) controls the strength of the L0 regularization (larger \(\lambda\) leads to less non-zeros). The parameter \(\gamma\) controls the strength of the shrinkage component (which is the L1 norm in case of L0L1 or squared L2 norm in case of L0L2); adding a shrinkage term to L0 can be very effective in avoiding overfitting and typically leads to better predictive models. The fitting is done over a grid of \(\lambda\) and \(\gamma\) values to generate a +regularization path.

+

The algorithms provided in l0learn` are based on cyclic coordinate descent and local combinatorial search. Many computational tricks and heuristics are used to speed up the algorithms and improve the solution quality. These heuristics include warm starts, active set convergence, correlation screening, greedy cycling order, and efficient methods for updating the residuals through exploiting sparsity and problem dimensions. Moreover, we employed a new computationally efficient method for +dynamically selecting the regularization parameter \(\lambda\) in the path. For more details on the algorithms used, please refer to our paper Fast Best Subset Selection: Coordinate Descent and Local Combinatorial Optimization Algorithms.

+

The toolkit is implemented in C++ along with an easy-to-use Python interface. In this vignette, we provide a tutorial on using the Python interface. Particularly, we will demonstrate how use L0Learn’s main functions for fitting models, cross-validation, and visualization.

+
+
+

Installation

+

L0Learn can be installed directly from pip by executing:

+
pip install l0learn
+
+
+

If you face installation issues, please refer to the Installation Troubleshooting Wiki. If the issue is not resolved, you can submit an issue on L0Learn’s Github Repo.

+
+
+

Tutorial

+

To demonstrate how l0learn works, we will first generate a synthetic dataset and then proceed to fitting L0-regularized models. The synthetic dataset (y,X) will be generated from a sparse linear model as follows:

+
    +

  • X is a 500x1000 design matrix with iid standard normal entries

    • +

  • B is a 1000x1 vector with the first 10 entries set to 1 and the rest are zeros.

    • +

  • e is a 500x1 vector with iid standard normal entries

    • +

  • y is a 500x1 response vector such that y = XB + e

    • +
+

This dataset can be generated in python as follows:

+
+
[1]:
+
+
+
+import numpy as np
+np.random.seed(4) # fix the seed to get a reproducible result
+n, p, k = 500, 1000, 10
+X = np.random.normal(size=(n, p))
+B = np.zeros(p)
+B[:k] = 1
+e = np.random.normal(size=(n,))/2
+y = X@B + e
+
+
+
+

More expressive and complete functions for generating datasets can be found are available in l0learn.models. The available functions are:

+ +

We will use l0learn to estimate B from the data (y,X). First we load L0Learn:

+
+
[2]:
+
+
+
+import l0learn
+
+
+
+

We will start by fitting a simple L0 model and then proceed to the case of L0L2 and L0L1.

+
+

Fitting L0 Regression Models

+

To fit a path of solutions for the L0-regularized model with at most 20 non-zeros using coordinate descent (CD), we use the l0learn.fit function as follows:

+
+
[3]:
+
+
+
+fit_model = l0learn.fit(X, y, penalty="L0", max_support_size=20)
+
+
+
+

This will generate solutions for a sequence of \(\lambda\) values (chosen automatically by the algorithm). To view the sequence of \(\lambda\) along with the associated support sizes (i.e., the number of non-zeros), we use the built-in rich display from ipython Rich Display for iPython Notebooks. When running this tutorial in a more standard python environment, use the function +l0learn.models.FitModel.characteristics to display the sequence of solutions.

+
+
[4]:
+
+
+
+fit_model
+# fit_model.characteristics()
+
+
+
+
+
[4]:
+
+
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
l0support_sizeinterceptconverged
00.0795460-0.156704True
10.0787501-0.147182True
20.0658622-0.161024True
30.0504643-0.002500True
40.0445175-0.041058True
50.0416727-0.058013True
60.0397058-0.061685True
70.032715100.002157True
80.00021211-0.000857True
90.00018712-0.002161True
100.00017813-0.001199True
110.00015915-0.007959True
120.00014116-0.009603True
130.00013318-0.015697True
140.00013221-0.012732True
+
+
+

To extract the estimated B for particular values of \(\lambda\) and \(\gamma\), we use the function l0learn.models.FitModel.coeff. For example, the solution at \(\lambda = 0.032715\) (which corresponds to a support size of 10 + plus an intercept term) can be extracted using:

+
+
[6]:
+
+
+
+fit_model.coeff(lambda_0=0.032715, gamma=0)
+
+
+
+
+
[6]:
+
+
+
+
+<1001x1 sparse matrix of type '<class 'numpy.float64'>'
+        with 11 stored elements in Compressed Sparse Column format>
+
+
+

The output is a sparse matrix of type scipy.sparse.csc_matrix. Depending on the include_intercept parameter of l0learn.models.FitModel.coeff, The first element in the vector is the intercept and the rest are the B coefficients. Aside from the intercept, the only non-zeros in the above solution are coordinates 0, 1, 2, 3, …, 9, which are the non-zero coordinates +in the true support (used to generated the data). Thus, this solution successfully recovers the true support. Note that on some BLAS implementations, the lambda value we used above (i.e., 0.032715) might be slightly different due to the limitations of numerical precision. Moreover, all the solutions in the regularization path can be extracted at once by calling l0learn.models.FitModel.coeff without specifying a lambda_0 or gamma value.

+

The sequence of \(\lambda\) generated by L0Learn is stored in the object fit_model. Specifically, fit_model.lambda_0 is a list, where each element of the list is a sequence of \(\lambda\) values corresponding to a single value of \(\gamma\). When using an L0 penalty , which has only one value of \(\gamma\) (i.e., 0), we can access the sequence of \(\lambda\) values using fit.lambda_0[0]. Thus, \(\lambda=0.032715\) we used previously can be accessed using +fit_model.lambda_0[0][7] (since it is the 8th value in the output of :code:fit.characteristics()). The previous solution can also be extracted using fit_model.coeff(lambda_0=0.032, gamma=0).

+
+
[8]:
+
+
+
+print(f"fit_model.lambda_0[0][7] = {fit_model.lambda_0[0][7]}")
+fit_model.coeff(lambda_0=0.032715, gamma=0).toarray()
+
+
+
+
+
+
+
+
+fit_model.lambda_0[0][7] = 0.03271533058913737
+
+
+
+
[8]:
+
+
+
+
+array([[0.00215713],
+       [1.02014176],
+       [0.97338278],
+       ...,
+       [0.        ],
+       [0.        ],
+       [0.        ]])
+
+
+

We can make predictions using a specific solution in the grid using the function fit_model.predict(newx, lambda, gamma) where newx is a testing sample (vector or matrix). For example, to predict the response for the samples in the data matrix X using the solution with \(\lambda=0.0058037\), we call the prediction function as follows:

+
+
[10]:
+
+
+
+with np.printoptions(threshold=10):
+    print(fit_model.predict(x=X, lambda_0=0.032715, gamma=0))
+
+
+
+
+
+
+
+
+[[-2.68272239]
+ [-3.667317  ]
+ [-1.77309853]
+ ...
+ [ 2.25545111]
+ [-0.77364234]
+ [-2.15002055]]
+
+
+

We can also visualize the regularization path by plotting the coefficients of the estimated B versus the support size (i.e., the number of non-zeros) using the l0learn.models.FitModel.plot() method as follows:

+
+
[9]:
+
+
+
+ax = fit_model.plot(include_legend=True)
+
+
+
+
+
+
+
+_images/tutorial_18_0.png +
+
+

The legend of the plot presents the variables in the order they entered the regularization path. For example, variable 7 is the first variable to enter the path, and variable 6 is the second to enter. Thus, roughly speaking, we can view the first \(k\) variables in the legend as the best subset of size \(k\). To show the lines connecting the points in the plot, we can set the parameter :code:show_lines=True in the plot function, i.e., call +:code:fit.plot(fit, gamma=0, show_lines=True). Moreover, we note that the plot function returns a matplotlib.axes._subplots.AxesSubplot object, which can be further customized using the matplotlib package. In addition, both the l0learn.models.FitModel.plot() and l0learn.models.CVFitModel.cv_plot() accept +:code:**kwargs parameter to allow for customization of the plotting behavior.

+
+
[11]:
+
+
+
+fit_model.plot(show_lines=True)
+
+
+
+
+
[11]:
+
+
+
+
+<AxesSubplot:xlabel='Support Size', ylabel='Coefficient Value'>
+
+
+
+
+
+
+_images/tutorial_20_1.png +
+
+
+
+

Fitting L0L2 and L0L1 Regression Models

+

We have demonstrated the simple case of using an L0 penalty. We can also fit more elaborate models that combine L0 regularization with shrinkage-inducing penalties like the L1 norm or squared L2 norm. Adding shrinkage helps in avoiding overfitting and typically improves the predictive performance of the models. Next, we will discuss how to fit a model using the L0L2 penalty for a two-dimensional grid of :math:\lambda and :math:\gamma values. Recall that by default, l0learn +automatically selects the :math:\lambda sequence, so we only need to specify the :math:\gamma sequence. Suppose we want to fit an L0L2 model with a maximum of 20 non-zeros and a sequence of 5 :math:\gamma values ranging between 0.0001 and 10. We can do so by calling l0learn.fit with :code:penalty="L0L2", :code:num_gamma=5, :code:gamma_min=0.0001, and :code:gamma_max=10 as follows:

+
+
[12]:
+
+
+
+fit_model_2 = l0learn.fit(X, y, penalty="L0L2", num_gamma = 5, gamma_min = 0.0001, gamma_max = 10, max_support_size=20)
+
+
+
+

l0learn will generate a grid of 5 :math:\gamma values equi-spaced on the logarithmic scale between 0.0001 and 10. Similar to the case for L0, we can display a summary of the regularization path using the l0learn.models.FitModel.characteristics function as follows:

+
+
[14]:
+
+
+
+fit_model_2 # Using ipython Rich Display
+# fit_model_2.characteristics()  # For non Rich Display
+
+
+
+
+
[14]:
+
+
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
l0support_sizeinterceptconvergedl2
00.0037880-0.156704True10.0000
10.0037501-0.156250True10.0000
20.0029112-0.148003True10.0000
30.0026543-0.148650True10.0000
40.0025973-0.148650True10.0000
..................
1280.000216100.002130True0.0001
1290.00017313-0.003684True0.0001
1300.00016713-0.003685True0.0001
1310.00013418-0.015724True0.0001
1320.00013021-0.012762True0.0001
+

133 rows × 5 columns

+
+
+

The sequence of \(\gamma\) values can be accessed using fit_model_2.gamma. To extract a solution we use the l0learn.models.FitModel.coeff method. For example, extracting the solution at \(\lambda=0.0016\) and \(\gamma=10\) can be done using:

+
+
[40]:
+
+
+
+fit_model_2.coeff(lambda_0=0.0016, gamma=10)
+
+
+
+
+
[40]:
+
+
+
+
+<1001x1 sparse matrix of type '<class 'numpy.float64'>'
+        with 11 stored elements in Compressed Sparse Column format>
+
+
+

Similarly, we can predict the response at this pair of \(\lambda\) and \(\gamma\) for the matrix X using

+
+
[41]:
+
+
+
+with np.printoptions(threshold=10):
+    print(fit_model_2.predict(x=X, lambda_0=0.0016, gamma=10))
+
+
+
+
+
+
+
+
+[[-0.31499242]
+ [-0.3474209 ]
+ [-0.23997924]
+ ...
+ [-0.06707991]
+ [-0.18562493]
+ [-0.25608131]]
+
+
+

The regularization path can also be plotted at a specific \(\gamma\) using fit_model_2.plot(gamma=10). Here we can see the influence of ratio of \(\gamma\) and \(\lambda\). Since \(\gamma\) is so large (\(10\)) maintaining sparisity, then \(\lambda\) can be quite small \(0.0016\) which this results in a very stable estimate of the magnitude of the coeffs.

+
+
[44]:
+
+
+
+fit_model_2.plot(gamma=10, show_lines=True)
+
+
+
+
+
+
+
+
+
+/Users/tnonet/Documents/GitHub/L0Learn/python/l0learn/models.py:438: UserWarning: Duplicate solution seen at support size 3. Plotting only first solution
+  warnings.warn(f"Duplicate solution seen at support size {support_size}. Plotting only first solution")
+/Users/tnonet/Documents/GitHub/L0Learn/python/l0learn/models.py:438: UserWarning: Duplicate solution seen at support size 10. Plotting only first solution
+  warnings.warn(f"Duplicate solution seen at support size {support_size}. Plotting only first solution")
+/Users/tnonet/Documents/GitHub/L0Learn/python/l0learn/models.py:438: UserWarning: Duplicate solution seen at support size 11. Plotting only first solution
+  warnings.warn(f"Duplicate solution seen at support size {support_size}. Plotting only first solution")
+/Users/tnonet/Documents/GitHub/L0Learn/python/l0learn/models.py:438: UserWarning: Duplicate solution seen at support size 12. Plotting only first solution
+  warnings.warn(f"Duplicate solution seen at support size {support_size}. Plotting only first solution")
+
+
+
+
[44]:
+
+
+
+
+<AxesSubplot:xlabel='Support Size', ylabel='Coefficient Value'>
+
+
+
+
+
+
+_images/tutorial_30_2.png +
+
+

Finally, we note that fitting an L0L1 model can be done by just changing the penalty to “L0L1” in the above (in this case gamma_max will be ignored since it is automatically selected by the toolkit; see the reference manual for more details.)

+
+ +
+

Cross-validation

+

We will demonstrate how to use K-fold cross-validation (CV) to select the optimal values of the tuning parameters \(\lambda\) and \(\gamma\). To perform CV, we use the l0learn.cvfit function, which takes the same parameters as l0learn.fit, in addition to the number of folds using the num_folds parameter and a seed value using the seed parameter (this is used when randomly shuffling the data before performing CV).

+

For example, to perform 5-fold CV using the L0L2 penalty (over a range of 5 gamma values between 0.0001 and 0.1) with a maximum of 50 non-zeros, we run:

+
+
[45]:
+
+
+
+cv_fit_result = l0learn.cvfit(X, y, num_folds=5, seed=1, penalty="L0L2", num_gamma=5, gamma_min=0.0001, gamma_max=0.1, max_support_size=50)
+
+
+
+

Note that the object returned during cross validation is l0learn.models.CVFitModel which subclasses l0learn.models.FitModel and thus has the same methods and underlinying structure. The cross-validation errors can be accessed using the cv_means attribute of a CVFitModel: cv_fit_result.cv_means is a list where the ith element, cv_fit_result.cv_means[i], stores the cross-validation errors for the ith +value of gamma cv_fit_result.gamma[i]). To find the minimum cross-validation error for every gamma, we apply the :code:np.argmin function for every element in the list :cv_fit_result.cv_means, as follows:

+
+
[52]:
+
+
+
+gamma_mins = [(i, np.argmin(cv_mean), np.min(cv_mean)) for i, cv_mean in enumerate(cv_fit_result.cv_means)]
+gamma_mins
+
+
+
+
+
[52]:
+
+
+
+
+[(0, 8, 0.5313128699361661),
+ (1, 8, 0.2669789604993652),
+ (2, 8, 0.2558807301729078),
+ (3, 20, 0.25555788170828786),
+ (4, 19, 0.2555564968851251)]
+
+
+

The above output indicates that the 5th value of gamma achieves the lowest CV error (=0.255). We can plot the CV errors against the support size for the 5th value of gamma, i.e., gamma = cv_fit_result.gamma[4], using:

+
+
[50]:
+
+
+
+cv_fit_result.cv_plot(gamma = cv_fit_result.gamma[4])
+cv_fit_result.cv_sds
+
+
+
+
+
[50]:
+
+
+
+
+<AxesSubplot:xlabel='Support Size', ylabel='Cross-Validation Error'>
+
+
+
+
+
+
+_images/tutorial_36_1.png +
+
+

The above plot is produced using the matplotlib package and returns a matplotlib.axes._subplots.AxesSubplot which can be further customized by the user. We can also note that we have error bars in the cross validation error which is stored in cv_sds attribute and can be accessed with cv_fit_result.cv_sds. To extract the optimal +\(\lambda\) (i.e., the one with minimum CV error) in this plot, we execute the following:

+
+
[57]:
+
+
+
+optimal_gamma_index, optimal_lambda_index, min_error = min(gamma_mins, key = lambda t: t[2])
+print(optimal_gamma_index, optimal_lambda_index, min_error)
+print("Optimal lambda = ", fit_model_2.lambda_0[optimal_gamma_index][optimal_lambda_index])
+
+
+
+
+
+
+
+
+4 19 0.2555564968851251
+Optimal lambda =  0.0016080760437896327
+
+
+

To print the solution corresponding to the optimal gamma/lambda pair:

+
+
[58]:
+
+
+
+cv_fit_result.coeff(lambda_0=fit_model_2.lambda_0[optimal_gamma_index][optimal_lambda_index],
+                    gamma=fit_model_2.gamma[optimal_gamma_index])
+
+
+
+
+
[58]:
+
+
+
+
+<1001x1 sparse matrix of type '<class 'numpy.float64'>'
+        with 11 stored elements in Compressed Sparse Column format>
+
+
+

The optimal solution (above) selected by cross-validation correctly recovers the support of the true vector of coefficients used to generate the model.

+
+
[70]:
+
+
+
+beta_vector = cv_fit_result.coeff(lambda_0=fit_model_2.lambda_0[optimal_gamma_index][optimal_lambda_index],
+                    gamma=fit_model_2.gamma[optimal_gamma_index],
+                    include_intercept=False).toarray()
+
+with np.printoptions(threshold=30, edgeitems=15):
+    print(np.hstack([beta_vector, B.reshape(-1, 1)]))
+
+
+
+
+
+
+
+
+[[1.01994648 1.        ]
+ [0.97317979 1.        ]
+ [0.99813347 1.        ]
+ [0.99669481 1.        ]
+ [1.01128182 1.        ]
+ [1.00190748 1.        ]
+ [1.01272103 1.        ]
+ [0.99204841 1.        ]
+ [0.99607406 1.        ]
+ [1.0266543  1.        ]
+ [0.         0.        ]
+ [0.         0.        ]
+ [0.         0.        ]
+ [0.         0.        ]
+ [0.         0.        ]
+ ...
+ [0.         0.        ]
+ [0.         0.        ]
+ [0.         0.        ]
+ [0.         0.        ]
+ [0.         0.        ]
+ [0.         0.        ]
+ [0.         0.        ]
+ [0.         0.        ]
+ [0.         0.        ]
+ [0.         0.        ]
+ [0.         0.        ]
+ [0.         0.        ]
+ [0.         0.        ]
+ [0.         0.        ]
+ [0.         0.        ]]
+
+
+
+
+

Fitting Classification Models

+

All the commands and plots we have seen in the case of regression extend to classification. We currently support logistic regression (using the parameter loss="Logistic") and a smoothed version of SVM (using the parameter loss="SquaredHinge"). To give some examples, we first generate a synthetic classification dataset (similar to the one we generated in the case of regression):

+
+
[72]:
+
+
+
+import numpy as np
+np.random.seed(4) # fix the seed to get a reproducible result
+n, p, k = 500, 1000, 10
+X = np.random.normal(size=(n, p))
+B = np.zeros(p)
+B[:k] = 1
+e = np.random.normal(size=(n,))/2
+y = np.sign(X@B + e)
+
+
+
+

More expressive and complete functions for generating datasets can be found are available in l0learn.models. The available functions are:

+ +

An L0-regularized logistic regression model can be fit by specificying loss = "Logistic" as follows:

+
+
[117]:
+
+
+
+fit_model_3 = l0learn.fit(X,y,loss="Logistic", max_support_size=20)
+fit_model_3
+
+
+
+
+
[117]:
+
+
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
l0support_sizeinterceptconvergedl2
025.2253361-0.036989True1.000000e-07
119.4320532-0.043199True1.000000e-07
218.9286032-0.043230True1.000000e-07
315.1428822-0.043245True1.000000e-07
412.11430690.004044True1.000000e-07
57.411211100.188422False1.000000e-07
67.188875100.219990False1.000000e-07
75.751100100.234899False1.000000e-07
84.600880100.242631False1.000000e-07
93.680704100.243655True1.000000e-07
102.944563100.243993True1.000000e-07
112.355651100.244295True1.000000e-07
121.884520100.244520True1.000000e-07
131.507616100.244716True1.000000e-07
141.206093100.244886True1.000000e-07
150.964874100.245011True1.000000e-07
160.771900100.245133True1.000000e-07
170.617520120.178144False1.000000e-07
180.598994120.196406False1.000000e-07
190.479195120.208883False1.000000e-07
200.383356150.192033False1.000000e-07
210.371856150.221470False1.000000e-07
220.297484150.246182False1.000000e-07
230.23798816-0.110626False1.000000e-07
240.23084816-0.118558False1.000000e-07
250.18467816-0.124533False1.000000e-07
260.14774321-0.211002False1.000000e-07
+
+
+

The output above indicates that \(\gamma=10^{-7}\) by default we use a small ridge regularization (with \(\gamma=10^{-7}\)) to ensure the existence of a unique solution. To extract the coefficients of the solution with \(\lambda = 8.69435\) we use the following code. Notice that we can ignore the specification of gamma as there is only one gamma used in L0 Logistic regression:

+
+
[83]:
+
+
+
+np.where(fit_model_3.coeff(lambda_0=7.411211).toarray() > 0)[0]
+
+
+
+

The above indicates that the 10 non-zeros in the estimated model match those we used in generating the data (i.e, L0 regularization correctly recovered the true support). We can also make predictions at the latter \(\lambda\) using:

+
+
[84]:
+
+
+
+with np.printoptions(threshold=10):
+   print(fit_model_3.predict(X, lambda_0=7.411211))
+
+
+
+
+
+
+
+
+[[1.69583037e-04]
+ [4.92440655e-06]
+ [3.92195535e-03]
+ ...
+ [9.99161941e-01]
+ [1.69035746e-01]
+ [9.99171256e-04]]
+
+
+

Each row in the above is the probability that the corresponding sample belongs to class \(1\). Other models (i.e., L0L2 and L0L1) can be similarly fit by specifying loss = "Logistic".

+

Finally, we note that L0Learn also supports a smoothed version of SVM by using squared hinge loss loss = "SquaredHinge". The only difference from logistic regression is that the predict function returns \(\beta_0 + \langle x, \beta \rangle\) (where \(x\) is the testing sample), instead of returning probabilities. The latter predictions can be assigned to the appropriate classes by using a thresholding function (e.g., the sign function).

+
+
+

Advanced Options

+
+

Sparse Matrix Support

+

Starting in version 2.0.0, L0Learn supports sparse matrices of type scipy.sparse.csc_matrix. If your sparse matrix uses a different storage format, please convert it to csc_matrix before using it in l0learn. l0learn keeps the matrix sparse internally and thus is highly efficient if the matrix is sufficiently sparse. The API for sparse matrices is the same as that of dense matrices, so all the +demonstrations in this vignette also apply for sparse matrices. For example, we can fit an L0-regularized model on a sparse matrix as follows:

+
+
[90]:
+
+
+
+from scipy.sparse import random
+from scipy.stats import norm
+
+
+X_sparse = random(n, p, density=0.01, format='csc', data_rvs=norm().rvs)
+y_sparse = (X_sparse@B + e)
+
+fit_model_sparse = l0learn.fit(X_sparse, y_sparse, penalty="L0", max_support_size=20)
+
+fit_model_sparse.characteristics()
+
+
+
+
+
[90]:
+
+
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
l0support_sizeinterceptconverged
00.03189200.009325True
10.03157310.004882True
20.0206062-0.002187True
30.0144423-0.004111True
40.0139324-0.002556True
50.01085450.002987True
60.00928660.002048True
70.0091917-0.001371True
80.0087718-0.000533True
90.00815190.000064True
100.006480110.001587True
110.00636412-0.003636True
120.00576013-0.003866True
130.00556015-0.004211True
140.005264170.001497True
150.00463718-0.000797True
160.00451519-0.002634True
170.004113220.001419True
+
+
+
+
+

Selection on Subset of Variables

+

In certain applications, it is desirable to always include some of the variables in the model and perform variable selection on others. l0learn supports this option through the exclude_first_k parameter. Specifically, setting exclude_first_k = K (where K is a non-negative integer) instructs l0learn to exclude the first K variables in the data matrix X from the L0-norm penalty (those K variables will still be penalized using the L2 or L1 norm penalties.). For example, below we +fit an L0 model and exclude the first 3 variables from selection by setting excludeFirstK = 3:

+
+
[94]:
+
+
+
+fit_model_k = l0learn.fit(X, y, penalty="L0", max_support_size=10, exclude_first_k=3)
+fit_model_k.characteristics()
+
+
+
+
+
[94]:
+
+
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
l0support_sizeinterceptconverged
00.0504643-0.017599True
10.0443334-0.021333True
20.0327705-0.027624True
30.0293677-0.029115True
40.0247108-0.021199True
50.02139390.010249True
60.014785100.016812True
+
+
+

Plotting the regularization path:

+
+
[93]:
+
+
+
+fit_model_k.plot(show_lines=True)
+
+
+
+
+
[93]:
+
+
+
+
+<AxesSubplot:xlabel='Support Size', ylabel='Coefficient Value'>
+
+
+
+
+
+
+_images/tutorial_57_1.png +
+
+

We can see in the plot above that first 3 variables, (0, 1, 2) are included in all the solutions of the path

+
+
+

Coefficient Bounds

+

Starting in version 2.0.0, l0learn supports bounds for CD algorithms for all losses and penalties. (We plan to support bound constraints for the CDPSI algorithm in the future). By default, l0learn does not apply bounds, i.e., it assumes \(-\infty <= \beta_i <= \infty\) for all i. Users can supply the same bounds for all coefficients by setting the parameters lows and highs to scalar values (these should satisfy: lows <= 0, lows != highs, and highs >= 0). To use +different bounds for the coefficients, lows and highs can be both set to vectors of length p (where the i-th entry corresponds to the bound on coefficient i).

+

All of the following examples are valid.

+
+
[107]:
+
+
+
+l0learn.fit(X, y, penalty="L0", lows=-0.5)
+l0learn.fit(X, y, penalty="L0", highs=0.5)
+l0learn.fit(X, y, penalty="L0", lows=-0.5, highs=0.5)
+
+max_value = 0.25
+highs_array = max_value*np.ones(p)
+highs_array[0] = 0.1
+fit_model_bounds = l0learn.fit(X, y, penalty="L0", lows=-0.1, highs=highs_array, max_support_size=20)
+
+
+
+

We can see the coefficients are subject to the bounds.

+
+
[110]:
+
+
+
+fit_model_bounds.plot(show_lines=True)
+
+print(f"maximum value of coefficients = {np.max(fit_model_bounds.coeffs[0])} <= {max_value}")
+print(f"maximum value of first coefficient = {np.max(fit_model_bounds.coeffs[0][0, :])} <= 0.1")
+print(f"minimum value of coefficient = {np.min(fit_model_bounds.coeffs[0])} >= -0.1")
+
+
+
+
+
+
+
+
+
+/Users/tnonet/Documents/GitHub/L0Learn/python/l0learn/models.py:438: UserWarning: Duplicate solution seen at support size 0. Plotting only first solution
+  warnings.warn(f"Duplicate solution seen at support size {support_size}. Plotting only first solution")
+/Users/tnonet/Documents/GitHub/L0Learn/python/l0learn/models.py:438: UserWarning: Duplicate solution seen at support size 6. Plotting only first solution
+  warnings.warn(f"Duplicate solution seen at support size {support_size}. Plotting only first solution")
+/Users/tnonet/Documents/GitHub/L0Learn/python/l0learn/models.py:438: UserWarning: Duplicate solution seen at support size 8. Plotting only first solution
+  warnings.warn(f"Duplicate solution seen at support size {support_size}. Plotting only first solution")
+
+
+
+
+
+
+
+maximum value of coefficients = 0.25 <= 0.25
+maximum value of first coefficient = 0.1 <= 0.1
+minimum value of coefficient = -0.1 >= -0.1
+
+
+
+
+
+
+_images/tutorial_61_2.png +
+
+
+
+

User-specified Lambda Grids

+

By default, l0learn selects the sequence of lambda values in an efficient manner to avoid wasted computation (since close \(\lambda\) values can typically lead to the same solution). Advanced users of the toolkit can change this default behavior and supply their own sequence of \(\lambda\) values. This can be done supplying the \(\lambda\) values through the parameter lambda_grid. When lambda_grid is supplied, we require num_gamma and num_lambda to be None to +ensure the is no ambiguity in the solution path requested.

+

Specifically, the value assigned to lambda_grid should be a list of lists/arrays of decreasing positive values (floats). The length of lambda_grid (the number of lists stored) specifies the number of gamma parameters that will fill between gamma_min, and gamma_max. In the case of L0 penalty, lambda_grid must be a list of length 1. In case of L0L2/L0L1 lambda_grid can have any number of sub-lists stored. The ith element in lambda_grid should be a strictly +decreasing sequence of positive lambda values which are used by the algorithm for the ith value of gamma. For example, to fit an L0 model with the sequence of user-specified lambda values: 1, 1e-1, 1e-2, 1e-3, 1e-4, we run the following:

+
+
[113]:
+
+
+
+user_lambda_grid = [[1, 1e-1, 1e-2, 1e-3, 1e-4]]
+fit_grid = l0learn.fit(X, y, penalty="L0", lambda_grid=user_lambda_grid, max_support_size=1000, num_lambda=None, num_gamma=None)
+
+
+
+

To verify the results we print the fit object:

+
+
[114]:
+
+
+
+fit_grid
+# Use fit_grid.characteristics() for those without rich dispalys
+
+
+
+
+
[114]:
+
+
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
l0support_sizeinterceptconverged
01.00000-0.016000True
10.10000-0.016000True
20.0100100.016811True
30.0010620.018729True
40.00012670.051675True
+
+
+

Note that the \(\lambda\) values above are the desired values. For L0L2 and L0L1 penalties, the same can be done where the lambda_grid parameter.

+
+
[115]:
+
+
+
+user_lambda_grid_L2 = [[1, 1e-1, 1e-2, 1e-3, 1e-4],
+                       [10, 2, 1, 0.01, 0.002, 0.001, 1e-5],
+                       [1e-4, 1e-5]]
+
+# user_lambda_grid_L2[[i]] must be a sequence of positive decreasing reals.
+fit_grid_L2 = l0learn.fit(X, y, penalty="L0L2", lambda_grid=user_lambda_grid_L2, max_support_size=1000, num_lambda=None, num_gamma=None)
+
+
+
+
+
[116]:
+
+
+
+fit_grid_L2
+# Use fit_grid_L2.characteristics() for those without rich dispalys
+
+
+
+
+
[116]:
+
+
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
l0support_sizeinterceptconvergedl2
01.000000-0.016000True10.000000
10.100000-0.016000True10.000000
20.010000-0.016000True10.000000
30.001009-0.014394True10.000000
40.00010134-0.012180True10.000000
510.000000-0.016000True0.031623
62.000000-0.016000True0.031623
71.000000-0.016000True0.031623
80.01000100.015045True0.031623
90.00200280.001483True0.031623
100.00100580.002821True0.031623
110.000015820.021913True0.031623
120.000103110.048700True0.000100
130.000014110.047991False0.000100
+
+
+
+
+
+
+

More Details

+

For more details please inspect the doc strings of:

+ +
+
+

References

+

Hussein Hazimeh and Rahul Mazumder. Fast Best Subset Selection: Coordinate Descent and Local Combinatorial Optimization Algorithms. Operations Research (2020).

+

Antoine Dedieu, Hussein Hazimeh, and Rahul Mazumder. Learning Sparse Classifiers: Continuous and Mixed Integer Optimization Perspectives. JMLR (to appear).

+
+ + +
+ +
+
+ +
+
+
+ ©2021, Hussein Hazimeh, Rahul Mazumder, and Tim Nonet. + + | + Powered by Sphinx 4.3.0 + & Alabaster 0.7.12 + + | + Page source +
+ + + + + + \ No newline at end of file diff --git a/python/_github_pages_docs/html/tutorial.ipynb b/python/_github_pages_docs/html/tutorial.ipynb new file mode 100644 index 0000000..78fd59c --- /dev/null +++ b/python/_github_pages_docs/html/tutorial.ipynb @@ -0,0 +1,2358 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "# Introduction\n", + "`l0learn` is a fast toolkit for L0-regularized learning. L0 regularization selects the best subset of features and can outperform commonly used feature selection methods (e.g., L1 and MCP) under many sparse learning regimes. The toolkit can (approximately) solve the following three problems\n", + "\n", + "\\begin{equation}\n", + "\\min_{\\beta_0, \\beta} \\sum_{i=1}^{n} \\ell(y_i, \\beta_0+ \\langle x_i, \\beta \\rangle) + \\lambda ||\\beta||_0 \\quad \\quad (L0) \n", + "\\end{equation}\n", + "\n", + "\n", + "\\begin{equation}\n", + "\\min_{\\beta_0, \\beta} \\sum_{i=1}^{n} \\ell(y_i, \\beta_0+ \\langle x_i, \\beta \\rangle) + \\lambda ||\\beta||_0 + \\gamma||\\beta||_1 \\quad (L0L1) \n", + "\\end{equation}\n", + "\n", + "\n", + "\\begin{equation}\n", + "\\min_{\\beta_0, \\beta} \\sum_{i=1}^{n} \\ell(y_i, \\beta_0+ \\langle x_i, \\beta \\rangle) + \\lambda ||\\beta||_0 + \\gamma||\\beta||_2^2 \\quad (L0L2)\n", + "\\end{equation}\n", + "\n", + "where $\\ell$ is the loss function, $\\beta_0$ is the intercept, $\\beta$ is the vector of coefficients, and $||\\beta||_0$ denotes the L0 norm of $\\beta$, i.e., the number of non-zeros in $\\beta$. We support both regression and classification using either one of the following loss functions:\n", + "\n", + "* Squared error loss\n", + "* Logistic loss (logistic regression)\n", + "* Squared hinge loss (smoothed version of SVM).\n", + "\n", + "The parameter $\\lambda$ controls the strength of the L0 regularization (larger $\\lambda$ leads to less non-zeros). The parameter $\\gamma$ controls the strength of the shrinkage component (which is the L1 norm in case of L0L1 or squared L2 norm in case of L0L2); adding a shrinkage term to L0 can be very effective in avoiding overfitting and typically leads to better predictive models. The fitting is done over a grid of $\\lambda$ and $\\gamma$ values to generate a regularization path. \n", + "\n", + "The algorithms provided in l0learn` are based on cyclic coordinate descent and local combinatorial search. Many computational tricks and heuristics are used to speed up the algorithms and improve the solution quality. These heuristics include warm starts, active set convergence, correlation screening, greedy cycling order, and efficient methods for updating the residuals through exploiting sparsity and problem dimensions. Moreover, we employed a new computationally efficient method for dynamically selecting the regularization parameter $\\lambda$ in the path. For more details on the algorithms used, please refer to our paper [Fast Best Subset Selection: Coordinate Descent and Local Combinatorial Optimization Algorithms](https://pubsonline.informs.org/doi/10.1287/opre.2019.1919).\n", + "\n", + "The toolkit is implemented in C++ along with an easy-to-use Python interface. In this vignette, we provide a tutorial on using the Python interface. Particularly, we will demonstrate how use L0Learn's main functions for fitting models, cross-validation, and visualization.\n", + "\n", + "# Installation\n", + "L0Learn can be installed directly from pip by executing:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "```console\n", + "pip install l0learn\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "If you face installation issues, please refer to the [Installation Troubleshooting Wiki](https://github.com/hazimehh/L0Learn/wiki/Installation-Troubleshooting). If the issue is not resolved, you can submit an issue on [L0Learn's Github Repo](https://github.com/hazimehh/L0Learn).\n", + "\n", + "# Tutorial\n", + "To demonstrate how `l0learn` works, we will first generate a synthetic dataset and then proceed to fitting L0-regularized models. The synthetic dataset (y,X) will be generated from a sparse linear model as follows:\n", + "\n", + "* X is a 500x1000 design matrix with iid standard normal entries\n", + "* B is a 1000x1 vector with the first 10 entries set to 1 and the rest are zeros.\n", + "* e is a 500x1 vector with iid standard normal entries\n", + "* y is a 500x1 response vector such that y = XB + e\n", + "\n", + "This dataset can be generated in python as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "np.random.seed(4) # fix the seed to get a reproducible result\n", + "n, p, k = 500, 1000, 10\n", + "X = np.random.normal(size=(n, p))\n", + "B = np.zeros(p)\n", + "B[:k] = 1\n", + "e = np.random.normal(size=(n,))/2\n", + "y = X@B + e" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "More expressive and complete functions for generating datasets can be found are available in [l0learn.models](code.rst#l0learn.models). The available functions are:\n", + "\n", + "* [l0learn.models.gen_synthetic()](code.rst#l0learn.models.gen_synthetic)\n", + "* [l0learn.models.gen_synthetic_high_corr()](code.rst#l0learn.models.gen_synthetic_high_corr)\n", + "* [l0learn.models.gen_synthetic_logistic()](code.rst#l0learn.models.gen_synthetic_logistic)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "We will use `l0learn` to estimate B from the data (y,X). First we load L0Learn:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "import l0learn" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "We will start by fitting a simple L0 model and then proceed to the case of L0L2 and L0L1.\n", + "\n", + "## Fitting L0 Regression Models\n", + "To fit a path of solutions for the L0-regularized model with at most 20 non-zeros using coordinate descent (CD), we use the [l0learn.fit](code.rst#l0learn.models.gen_synthetic) function as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "fit_model = l0learn.fit(X, y, penalty=\"L0\", max_support_size=20)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "This will generate solutions for a sequence of $\\lambda$ values (chosen automatically by the algorithm). To view the sequence of $\\lambda$ along with the associated support sizes (i.e., the number of non-zeros), we use the built-in rich display from [ipython Rich Display](https://ipython.readthedocs.io/en/stable/config/integrating.html+) for iPython Notebooks. When running this tutorial in a more standard python environment, use the function [l0learn.models.FitModel.characteristics](code.rst#l0learn.models.FitModel.characteristics) to display the sequence of solutions." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
l0support_sizeinterceptconverged
00.0795460-0.156704True
10.0787501-0.147182True
20.0658622-0.161024True
30.0504643-0.002500True
40.0445175-0.041058True
50.0416727-0.058013True
60.0397058-0.061685True
70.032715100.002157True
80.00021211-0.000857True
90.00018712-0.002161True
100.00017813-0.001199True
110.00015915-0.007959True
120.00014116-0.009603True
130.00013318-0.015697True
140.00013221-0.012732True
\n", + "
" + ], + "text/plain": [ + "FitModel({'loss': 'SquaredError', 'intercept': True, 'penalty': 'L0'})" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fit_model\n", + "# fit_model.characteristics()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "To extract the estimated B for particular values of $\\lambda$ and $\\gamma$, we use the function [l0learn.models.FitModel.coeff](code.rst#l0learn.models.FitModel.coeff). For example, the solution at $\\lambda = 0.032715$ (which corresponds to a support size of 10 + plus an intercept term) can be extracted using:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "<1001x1 sparse matrix of type ''\n", + "\twith 11 stored elements in Compressed Sparse Column format>" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fit_model.coeff(lambda_0=0.032715, gamma=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "The output is a sparse matrix of type [scipy.sparse.csc_matrix](https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.csc_matrix.html). Depending on the `include_intercept` parameter of [l0learn.models.FitModel.coeff](code.rst#l0learn.models.FitModel.coeff), The first element in the vector is the intercept and the rest are the B coefficients. Aside from the intercept, the only non-zeros in the above solution are coordinates 0, 1, 2, 3, ..., 9, which are the non-zero coordinates in the true support (used to generated the data). Thus, this solution successfully recovers the true support. Note that on some BLAS implementations, the `lambda` value we used above (i.e., `0.032715`) might be slightly different due to the limitations of numerical precision. Moreover, all the solutions in the regularization path can be extracted at once by calling [l0learn.models.FitModel.coeff](code.rst#l0learn.models.FitModel.coeff) without specifying a `lambda_0` or `gamma` value.\n", + "\n", + "The sequence of $\\lambda$ generated by `L0Learn` is stored in the object `fit_model`. Specifically, `fit_model.lambda_0` is a list, where each element of the list is a sequence of $\\lambda$ values corresponding to a single value of $\\gamma$. When using an L0 penalty , which has only one value of $\\gamma$ (i.e., 0), we can access the sequence of $\\lambda$ values using `fit.lambda_0[0]`. Thus, $\\lambda=0.032715$ we used previously can be accessed using `fit_model.lambda_0[0][7]` (since it is the 8th value in the output of :code:`fit.characteristics()`). The previous solution can also be extracted using `fit_model.coeff(lambda_0=0.032, gamma=0)`." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fit_model.lambda_0[0][7] = 0.03271533058913737\n" + ] + }, + { + "data": { + "text/plain": [ + "array([[0.00215713],\n", + " [1.02014176],\n", + " [0.97338278],\n", + " ...,\n", + " [0. ],\n", + " [0. ],\n", + " [0. ]])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(f\"fit_model.lambda_0[0][7] = {fit_model.lambda_0[0][7]}\")\n", + "fit_model.coeff(lambda_0=0.032715, gamma=0).toarray()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "We can make predictions using a specific solution in the grid using the function `fit_model.predict(newx, lambda, gamma)` where `newx` is a testing sample (vector or matrix). For example, to predict the response for the samples in the data matrix X using the solution with $\\lambda=0.0058037$, we call the prediction function as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[-2.68272239]\n", + " [-3.667317 ]\n", + " [-1.77309853]\n", + " ...\n", + " [ 2.25545111]\n", + " [-0.77364234]\n", + " [-2.15002055]]\n" + ] + } + ], + "source": [ + "with np.printoptions(threshold=10):\n", + " print(fit_model.predict(x=X, lambda_0=0.032715, gamma=0))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "We can also visualize the regularization path by plotting the coefficients of the estimated B versus the support size (i.e., the number of non-zeros) using the [l0learn.models.FitModel.plot()](code.rst#l0learn.models.FitModel.plot) method as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ax = fit_model.plot(include_legend=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "The legend of the plot presents the variables in the order they entered the regularization path. For example, variable 7 is the first variable to enter the path, and variable 6 is the second to enter. Thus, roughly speaking, we can view the first $k$ variables in the legend as the best subset of size $k$. To show the lines connecting the points in the plot, we can set the parameter :code:`show_lines=True` in the `plot` function, i.e., call :code:`fit.plot(fit, gamma=0, show_lines=True)`. Moreover, we note that the plot function returns a [matplotlib.axes._subplots.AxesSubplot](https://pandas.pydata.org/pandas-docs/version/0.21/visualization.html) object, which can be further customized using the `matplotlib` package. In addition, both the [l0learn.models.FitModel.plot()](code.rst#l0learn.models.FitModel.plot) and [l0learn.models.CVFitModel.cv_plot()](code.rst#l0learn.models.CVFitModel.cv_plot) accept :code:`**kwargs` parameter to allow for customization of the plotting behavior.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fit_model.plot(show_lines=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Fitting L0L2 and L0L1 Regression Models\n", + "We have demonstrated the simple case of using an L0 penalty. We can also fit more elaborate models that combine L0 regularization with shrinkage-inducing penalties like the L1 norm or squared L2 norm. Adding shrinkage helps in avoiding overfitting and typically improves the predictive performance of the models. Next, we will discuss how to fit a model using the L0L2 penalty for a two-dimensional grid of :math:`\\lambda` and :math:`\\gamma` values. Recall that by default, `l0learn` automatically selects the :math:`\\lambda` sequence, so we only need to specify the :math:`\\gamma` sequence. Suppose we want to fit an L0L2 model with a maximum of 20 non-zeros and a sequence of 5 :math:`\\gamma` values ranging between 0.0001 and 10. We can do so by calling [l0learn.fit](code.rst#l0learn.fit) with :code:`penalty=\"L0L2\"`, :code:`num_gamma=5`, :code:`gamma_min=0.0001`, and :code:`gamma_max=10` as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "fit_model_2 = l0learn.fit(X, y, penalty=\"L0L2\", num_gamma = 5, gamma_min = 0.0001, gamma_max = 10, max_support_size=20)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "`l0learn` will generate a grid of 5 :math:`\\gamma` values equi-spaced on the logarithmic scale between 0.0001 and 10. Similar to the case for L0, we can display a summary of the regularization path using the [l0learn.models.FitModel.characteristics](code.rst#l0learn.models.FitModel.characteristics) function as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
l0support_sizeinterceptconvergedl2
00.0037880-0.156704True10.0000
10.0037501-0.156250True10.0000
20.0029112-0.148003True10.0000
30.0026543-0.148650True10.0000
40.0025973-0.148650True10.0000
..................
1280.000216100.002130True0.0001
1290.00017313-0.003684True0.0001
1300.00016713-0.003685True0.0001
1310.00013418-0.015724True0.0001
1320.00013021-0.012762True0.0001
\n", + "

133 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + "FitModel({'loss': 'SquaredError', 'intercept': True, 'penalty': 'L0L2'})" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fit_model_2 # Using ipython Rich Display\n", + "# fit_model_2.characteristics() # For non Rich Display" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "The sequence of $\\gamma$ values can be accessed using `fit_model_2.gamma`. To extract a solution we use the [l0learn.models.FitModel.coeff](code.rst#l0learn.models.FitModel.coeff) method. For example, extracting the solution at $\\lambda=0.0016$ and $\\gamma=10$ can be done using:" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "<1001x1 sparse matrix of type ''\n", + "\twith 11 stored elements in Compressed Sparse Column format>" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fit_model_2.coeff(lambda_0=0.0016, gamma=10)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "Similarly, we can predict the response at this pair of $\\lambda$ and $\\gamma$ for the matrix X using" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[-0.31499242]\n", + " [-0.3474209 ]\n", + " [-0.23997924]\n", + " ...\n", + " [-0.06707991]\n", + " [-0.18562493]\n", + " [-0.25608131]]\n" + ] + } + ], + "source": [ + "with np.printoptions(threshold=10):\n", + " print(fit_model_2.predict(x=X, lambda_0=0.0016, gamma=10))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "The regularization path can also be plotted at a specific $\\gamma$ using `fit_model_2.plot(gamma=10)`. Here we can see the influence of ratio of $\\gamma$ and $\\lambda$. Since $\\gamma$ is so large ($10$) maintaining sparisity, then $\\lambda$ can be quite small $0.0016$ which this results in a very stable estimate of the magnitude of the coeffs." + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/tnonet/Documents/GitHub/L0Learn/python/l0learn/models.py:438: UserWarning: Duplicate solution seen at support size 3. Plotting only first solution\n", + " warnings.warn(f\"Duplicate solution seen at support size {support_size}. Plotting only first solution\")\n", + "/Users/tnonet/Documents/GitHub/L0Learn/python/l0learn/models.py:438: UserWarning: Duplicate solution seen at support size 10. Plotting only first solution\n", + " warnings.warn(f\"Duplicate solution seen at support size {support_size}. Plotting only first solution\")\n", + "/Users/tnonet/Documents/GitHub/L0Learn/python/l0learn/models.py:438: UserWarning: Duplicate solution seen at support size 11. Plotting only first solution\n", + " warnings.warn(f\"Duplicate solution seen at support size {support_size}. Plotting only first solution\")\n", + "/Users/tnonet/Documents/GitHub/L0Learn/python/l0learn/models.py:438: UserWarning: Duplicate solution seen at support size 12. Plotting only first solution\n", + " warnings.warn(f\"Duplicate solution seen at support size {support_size}. Plotting only first solution\")\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fit_model_2.plot(gamma=10, show_lines=True)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Finally, we note that fitting an L0L1 model can be done by just changing the `penalty` to \"L0L1\" in the above (in this case `gamma_max` will be ignored since it is automatically selected by the toolkit; see the reference manual for more details.)\n", + "\n", + "## Higher-quality Solutions using Local Search\n", + "By default, `l0learn` uses coordinate descent (CD) to fit models. Since the objective function is non-convex, the choice of the optimization algorithm can have a significant effect on the solution quality (different algorithms can lead to solutions with very different objective values). A more elaborate algorithm based on combinatorial search can be used by setting the parameter `algorithm=\"CDPSI\"` in the call to `l0learn.fit`. `CDPSI` typically leads to higher-quality solutions compared to CD, especially when the features are highly correlated. CDPSI is slower than CD, however, for typical applications it terminates in the order of seconds.\n", + "\n", + "## Cross-validation\n", + "We will demonstrate how to use K-fold cross-validation (CV) to select the optimal values of the tuning parameters $\\lambda$ and $\\gamma$. To perform CV, we use the [l0learn.cvfit](code.rst#l0learn.cvfit) function, which takes the same parameters as [l0learn.fit](code.rst#l0learn.fit), in addition to the number of folds using the `num_folds` parameter and a seed value using the `seed` parameter (this is used when randomly shuffling the data before performing CV).\n", + "\n", + "For example, to perform 5-fold CV using the `L0L2` penalty (over a range of 5 `gamma` values between 0.0001 and 0.1) with a maximum of 50 non-zeros, we run:" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "cv_fit_result = l0learn.cvfit(X, y, num_folds=5, seed=1, penalty=\"L0L2\", num_gamma=5, gamma_min=0.0001, gamma_max=0.1, max_support_size=50)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "Note that the object returned during cross validation is [l0learn.models.CVFitModel](code.rst#l0learn.models.CVFitModel) which subclasses [l0learn.models.FitModel](code.rst#l0learn.models.FitModel) and thus has the same methods and underlinying structure. The cross-validation errors can be accessed using the `cv_means` attribute of a `CVFitModel`: `cv_fit_result.cv_means` is a list where the ith element, `cv_fit_result.cv_means[i]`, stores the cross-validation errors for the ith value of gamma `cv_fit_result.gamma[i]`). To find the minimum cross-validation error for every `gamma`, we apply the :code:`np.argmin` function for every element in the list :`cv_fit_result.cv_means`, as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[(0, 8, 0.5313128699361661),\n", + " (1, 8, 0.2669789604993652),\n", + " (2, 8, 0.2558807301729078),\n", + " (3, 20, 0.25555788170828786),\n", + " (4, 19, 0.2555564968851251)]" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gamma_mins = [(i, np.argmin(cv_mean), np.min(cv_mean)) for i, cv_mean in enumerate(cv_fit_result.cv_means)]\n", + "gamma_mins" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "The above output indicates that the 5th value of gamma achieves the lowest CV error (`=0.255`). We can plot the CV errors against the support size for the 5th value of gamma, i.e., `gamma = cv_fit_result.gamma[4]`, using:" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEKCAYAAAAVaT4rAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAAAge0lEQVR4nO3df5wddX3v8df7nN3N798JkN9ZkIpIA0IICYmIaBWVohdFQFCEVGgfbUVvLRdv6/XHffSHbdXaai2pIFQoBQQqKg+FIuAFksDyIwSCgpiEhIRkIZJfkE1293P/OLNhs9ndHHb3nDln5v18PM7jzHxnduYzycl7J98z8x1FBGZmlh+FtAswM7PqcvCbmeWMg9/MLGcc/GZmOePgNzPLGQe/mVnOVCz4JV0taYukJ7u1/b2kX0p6QtJtksZXav9mZta7Sp7xXwOc3qPtLuCYiJgLPAN8voL7NzOzXlQs+CPiF8DWHm13RkR7MrscmFGp/ZuZWe8aUtz3xcCN5aw4efLkmDNnTmWrMTPLmEceeeSliJjSsz2V4Jf0F0A7cH0/61wCXAIwa9YsWlpaqlSdmVk2SFrXW3vVr+qR9EngDOD86GegoIhYGhHzImLelCkH/MIyM7MBquoZv6TTgcuBd0TEq9Xct5mZlVTycs4bgGXAmyVtkLQE+BYwBrhL0uOS/rVS+zczs95V7Iw/Is7rpfmqSu3PzMzK4zt3zcxyxsFvZpYzDn4zs5xx8JuZ5Uymg/+cK5dxzpXLym43M8uDTAe/mZkdyMFvZpYzDn4zs5xx8JuZ5YyD38wsZxz8ZmY54+A3M8sZB7+ZWc44+M3McsbBb2aWMw5+M7OccfCbmeWMg9/MLGcc/GZmOePgNzPLGQe/mVnOOPjNzHLGwW9mljMOfjOznHHwm5nljIPfzCxnKhb8kq6WtEXSk93aJkq6S9KzyfuESu3fzMx6V8kz/muA03u0XQHcHRFHAncn82ZmVkUVC/6I+AWwtUfzB4Frk+lrgQ9Vav9mZta7avfxHxoRm5LpF4FDq7x/M7PcS+3L3YgIIPpaLukSSS2SWlpbW6tYmZlZtlU7+DdLmgqQvG/pa8WIWBoR8yJi3pQpU6pWoJlZ1lU7+G8HLkymLwR+WOX99+ucK5dxzpXL0i7DzKyiGiq1YUk3AKcCkyVtAL4I/C1wk6QlwDrgo5XaP8CO3Xt5bW8H//nQ8/u1b9mxm7HDGyu5azOzmlWx4I+I8/pY9K5K7bOnl3buYcuONq64ddUBy8aPcPCbWT5VLPhrwcwJI5g2fgTfueD4/drP+Kf72fbaXiICSSlVZ2aWjkwHf0OxQAMwddyI/drHDG/g5V172LhtN9PHj+j9h83MMiqXY/WMGlb6fffE+lfSLcTMLAW5DP6RTUUErNywLe1SzMyqLpfBX5AY2VTkiQ2vpF2KmVnV5TL4odTds2rDNjo7+7x52Mwsk3Ib/KOHNbCjrZ01L+9KuxQzs6rKbfCPGlYEcHePmeVOboN/RGOREY1FVq73F7xmli+5DX5JHDN9rM/4zSx3chv8AHNnjOepjdvZ29EJwOpN21m9aXvKVZmZVVbOg38cbe2dPLN5R9qlmJlVTa6D/9gZ4wF4wjdymVmO5Dr4Z08aybgRje7nN7NcyXXwS2LujHG+ssfMcqXf4JdUkHRytYpJw9wZ4/jV5h3s3tuRdilmZlXRb/BHRCfw7SrVkoq5M8bT0Rk8tdFX85hZPpTT1XO3pA8ro08sef0L3ldSrcPMrFrKCf5LgZuBPZK2S9ohKTOnx4eNG84hY4b5yh4zy42DPoErIsZUo5A0zZ0xnpU+4zeznCjr0YuSzgROSWbvjYgfV66k6jt2xjj+++nNjB5W9DN4zSzzDtrVI+lvgcuA1cnrMkl/U+nCqmnuzPEAdHhsfjPLgXLO+N8PHJdc4YOka4HHgM9XsrBqmjt9HAAdceAfyDlXLgPgxksXVrkqM7PKKPcGrvHdpsdVoI5UTRjVxKyJI/00LjPLhXLO+P8aeEzSPYAo9fVfUdGqUjB3xjjWb3017TLMzCruoHfuAp3AAuBW4BZgYUTcWIXaqurYGeMJoDN81m9m2dbvGX9EdEq6PCJuAm6vUk2pmDuj1IPl7h4zy7py+vj/W9LnJM2UNLHrNZidSvqspKckPSnpBknDB7O9oTBn8igAeua+H85iZllTTh//Ocn7H3drC+DwgexQ0nTg08DREfGapJuAc4FrBrK9oeKr980sL/oN/qSP/4oK9Ok3ACMk7QVGAhuHePtA35dg+tJMM8uzckbn/POh3GFEvAD8A/A8sAnYFhF39lxP0iWSWiS1tLa2DmUJZma5VvU+fkkTgA8CzcA0YJSkC3quFxFLI2JeRMybMmXKQHdnZmY9VL2PH3g3sCYiWgEk3QqcDFw3wO2ZmdkbUM7onM1DvM/ngQWSRgKvAe8CWoZ4H2Zm1oc+u3okXd5t+uwey/56oDuMiBXAD4BHgVVJDUsHur2h0lDM9eOHzSxH+ku7c7tN9xyQ7fTB7DQivhgRR0XEMRHx8YhoG8z2hsLEUU0Ij9BpZtnXX/Crj+ne5jOhWBTtneG7d80s0/oL/uhjurf5TGgolH6fPf2i79Q1s+zq78vdY5Nn64rSzVZdaSgg9SEWKqGYBP+y517mrdMyN/q0mRnQzxl/RBQjYmxEjImIhmS6a76xmkVWS0FCguW/eTntUszMKsaXsvTQUBAr1mz1l7xmllkO/h6KBbFjdztPbdyWdilmZhXh4O+hez+/mVkWOfh7KEgcPmUUy9zPb2YZddDgl3SWpGclbZO0XdKOblf4ZNLCwyfx8Jqt7O3oTLsUM7MhV84Z/98BZ0bEuG5X9YytdGFpWnjEJHbt6WDVC+7nN7PsKSf4N0fE0xWvpIYsOHwS4H5+M8umcoZlbpF0I/BfwL4xdSLi1koVlbbJo4fxO4eO9vX8ZpZJ5QT/WOBV4D3d2gLIbPBDqZ//ppYNFAsgZXJoIjPLqXLG47+oGoXUmoVHTOLaZesY0VSkwblvZhlSzlU9MyTdJmlL8rpF0oxqFJemk5onIXmYZjPLnnK+3P0ecDul5+NOA36UtGXahFFNHHXYWAe/mWVOOcE/JSK+FxHtyesaIBdPP194+CQ6OoMIh7+ZZUc5wf+ypAskFZPXBUAuLndZeETpsk6f9ZtZlpQT/BcDHwVeBDYBHwFy8YXv/OaJgIPfzLKlnKt61gFnVqGWmjNuRCMFf8FrZhnTZ/BLujwi/k7SP9PLoxYj4tMVraxGFAtib0fw2p4ORjQV0y7HzGzQ+jvj7xqmoaUahdSCo6ceOARRV/C/uH03zZNHpVCVmdnQ6jP4I+JHyeSrEXFz92WSzq5oVWZmVjHlDNnweeDmMtrq3o2XLky7BDOziuuvj/99wPuB6ZL+qduisUB7pQszM7PK6O+MfyOl/v0zgUe6te8APlvJoszMrHL66+NfCayU9B8RsXcodyppPPBd4BhKVwxdHBHLhnIfZmbWu3L6+OdI+hvgaGB4V2NEHD6I/X4T+GlEfERSEzByENsyM7M3oNxB2r5DqV//ncC/A9cNdIeSxgGnAFcBRMSeiHhloNurltYdbQdfycysDpQT/CMi4m5AEbEuIr4EfGAQ+2wGWoHvSXpM0nclHXCBvKRLJLVIamltbR3E7ganoVAajP+65etSq8HMbCiVE/xtkgrAs5L+RNL/AEYPYp8NwPHAdyLibcAu4IqeK0XE0oiYFxHzpkxJbzBQSTQWxR2rNrFp22up1WFmNlTKCf7LKPXBfxo4Afg4cOEg9rkB2BARK5L5H1D6RVCzmhoKdEZw7YM+6zez+nfQ4I+IhyNiZ0RsiIiLIuKsiFg+0B1GxIvAeklvTpreBawe6PaqoSDxvmOmcsNDz/PqHt/CYGb1rb8buH5EL4OzdYmIwYzY+afA9ckVPb+hDoZ5vnjxHH6yahO3PLKBjy+ck3Y5ZmYD1t/lnP+QvJ8FHMbrV/KcB2wezE4j4nFg3mC2UW3Hz5rAsTPHc/UDazn/pNkUCn4Cu5nVpz67eiLivoi4D1gUEedExI+S18eAt1evxNogiSWLm1nz0i7ufWZL2uWYmQ1YOV/ujpK072YtSc1ALscnft8xhzF13HCuun9N2qWYmQ1YOcH/WeBeSfdKug+4B/hMRauqUY3FAheePIcHfv0yT2/annY5ZmYDUs5VPT8FjqR0WeengTdHxM8qXVitOu/EWYxoLHK1z/rNrE71GfySTkvez6J0p+4RyesDSVsujRvZyEdOmMEPH9/oYRzMrC71d8b/juT993t5nVHhumraRYvmsKej08M4mFld6m9Y5i8m7zV/jX21HT5lNO866hCuX7GOPzr1CIY3+iHsZlY/+ruB63/294MR8fWhL6d+LFnczMe+u4LbV27ko/Nmpl2OmVnZ+uvqGXOQV64tPGISRx02hqvvX0NEnzc4m5nVnP66er5czULqjSQuXtzM5T94ggefe5lFb5qcdklmZmU56OWckoZL+mNJ/yLp6q5XNYqrdWceO43Jo5t8Q5eZ1ZVybuD6PqWxet4L3AfMoPTA9dwb3ljkggWz+fkvt/Bc6860yzEzK0s5wf+miPgCsCsirqV0Tf9JlS2rflywYDZNxQLXPLA27VLMzMpSTvDvTd5fkXQMMA44pHIl1ZfJo4fxweOm8YNHNvDKq3vSLsfM7KDKCf6lkiYAXwBup/TQlK9WtKo6s+Ttzby2t4MbHlqfdilmZgfV35ANqyX9JXBPRPw2Gab58Ig4JCKurGKNNe+ow8ay6E2TuPbBtezt6Ey7HDOzfvV3xn8epeGX75T0kKTPSppapbrqzpLFzby4fTd3rNqUdilmZv3q70EsKyPi8xFxBKVROWcBKyTdI+lTVauwTpz6O4dw+ORRvqHLzGpeOX38RMTyiPgs8AlgPPCtShZVjwoFcdGiOazcsI1Hn/9t2uWYmfWpnBu4TpT0dUnrgC8BVwLTKl1YPfrwCTMYN6LRN3SZWU3rb5C2vwbOAbYC/0np2bsbqlVYPRrZ1MB582ex9BfPsX7rq8ycODLtkszMDtDfGf9u4PSIODEivhYRGyTlbhz+o6eO5eipY8te/8KTZ1OQuPbBtZUrysxsEPr7cvcrEfFsj+avVLieujd13Aje/7tTufHh9exsa0+7HDOzA5T15W43qkgVGXPx4mZ2tLVzc4tv6DKz2vNGg//SilSRMcfNHM8JsyfwvQfW0tHpSzvNrLaUc1XP2ZK6HrzyXkm3Sjq+wnXVvSWLm3l+66v899Ob0y7FzGw/5ZzxfyEidkhaDJwGXAV8Z7A7llSU9JikHw92W7XoPUcfyvTxI3xpp5nVnHKCvyN5/wDwbxHxE6BpCPZ9GfD0EGynJjUUC1y0aA4PrdnKky9sS7scM7N9ygn+FyRdSema/jskDSvz5/okaQalXyTfHcx2at1HT5zJqKaiz/rNrKaUE+AfBX4GvDciXgEmAn8+yP3+I3A50OdQlpIukdQiqaW1tXWQu0vH2OGNnD1vJj9+YiObt+9OuxwzM6C84J8K/CQinpV0KnA28NBAd5jcBLYlIh7pb72IWBoR8yJi3pQpUwa6u9RdtGgO7Z3B95etS7sUMzOgvOC/BeiQ9CZgKTAT+I9B7HMRcKaktZSGgjhN0nWD2F5F3XjpQm68dOGAf372pFH83lsO5foV69i9t+PgP2BmVmHlBH9nRLQDZwH/HBF/Tul/AQOSDPU8IyLmAOcCP4+ICwa6vXqwZHEzv311L7c++kLapZiZlffMXUnnURqSuevSy8bKlZQ985sn8tZpY7n6AY/Vb2bpKyf4LwIWAn8VEWskNQPfH4qdR8S9EZH5gd8ksWRxM7/espP7nqnPL6rNLDsOGvwRsRr4HLBK0jHAhojww9bfoDPmTuOQMcO4+oG1B133nCuXcc6VyypflJnlUjlDNpwKPAt8G/gX4BlJp1S2rOxpaijwiYWz+cUzrTy7eUfa5ZhZjpXT1fM14D0R8Y6IOAV4L/CNypaVTR87aTbDGgpc/YBv6DKz9JQT/I0R8auumYh4Bn+5OyATRzVx1vHTufXRF9i6a0/a5ZhZTpUT/I9I+q6kU5PXvwEtlS4sqy5e1ExbeyfXL/cNXWaWjnKC/w+B1cCnk9dq4I8qWVSWHXnoGE75nSn8+/J17Gnvc8QKM7OK6Tf4JRWBlRHx9Yg4K3l9IyLaqlRfJi1Z3EzrjjZ+/MTGtEsxsxzqN/gjogP4laRZVaonF045cjJvOmQ0V93vG7rMrPrK6eqZADwl6W5Jt3e9Kl1Ylkni4kXNPLVxOyvWbE27HDPLmYYy1vlCxavIobOOn87f/+yXXHX/GhYcPintcswsR/oM/mQ0zkMj4r4e7YuBTZUuLOuGNxY5/6TZfPveX7P2pV3MmTwq7ZLMLCf66+r5R2B7L+3bkmU2SJ9YOJuGgrjmwbVpl2JmOdJf8B8aEat6NiZtcypWUY4cMnY4vz93Gje3rGf77r1pl2NmOdFf8I/vZ9mIIa4jty5e3MyuPR3c+ND6tEsxs5zoL/hbJH2qZ6OkPwD6fWyile+Y6eOY3zyRax5cS3uHb+gys8rrL/g/A1wk6V5JX0te9wFLgMuqUl1OLFnczAuvvMbPntqcdilmlgN9XtUTEZuBkyW9Ezgmaf5JRPy8KpXlyLvfciizJo7kqvt/wwfmDviplmZmZTnodfwRcQ9wTxVqya1iQVy0aA5f/tFqHnv+t2mXY2YZV86du1YFZ8+byZhhDWU9ocvMbDAc/DVi9LAGzjlxJnes2kRbe0fa5ZhZhjn4a8iFJ88hIti83YOfmlnlOPhryMyJIzn9mMPYsqONjk6P2mlmleHgrzFLFjfT0Rm07vRZv5lVhoO/xhw/awKjmoq07nDwm1llOPhrjCSGNxbd1WNmFePgNzPLmaoHv6SZku6RtFrSU5I8/IOZWRWV8wSuodYO/FlEPCppDPCIpLsiYnUKtdSkba/tpcPP4jWzCqn6GX9EbIqIR5PpHcDTwPRq12Fmllep9vFLmgO8DViRZh1mZnmSWvBLGg3cAnwmIg54xKOkSyS1SGppbW2tfoFmZhmVSvBLaqQU+tdHxK29rRMRSyNiXkTMmzJlSnULNDPLsDSu6hFwFfB0RHy92vuvBxJEwK629rRLMbMMSuOMfxHwceA0SY8nr/enUEfNaiyW/lp++PjGlCsxsyyq+uWcEXE/oGrvt54UVHpdt3wd582fSek/SWZmQ8N37tYgSTQWC6zetJ3H1r+SdjlmljEO/hrVWBSjmopcv/z5tEsxs4xx8Nego6eO5a3TxvGht03nx09s5JVX96RdkplliIO/hl2wYDZt7Z384JENaZdiZhni4K9hb5k6lhNmT+D6Fc8THrvHzIaIg7/GXbBgFmte2sWDz72cdilmlhEO/hr3vmOmMmFkI9ctX5d2KWaWEQ7+Gje8scjZ82Zy5+rNbN6+O+1yzCwDHPx14GPzZ9HRGdz48Pq0SzGzDHDw14E5k0fx9iMnc8NDz9Pe0Zl2OWZW5xz8deL8k2azadtufv7LLWmXYmZ1zsFfJ979lkM4bOxwrl/hO3nNbHDSeOauHcSNly48oK2hWODc+TP55t3P8vzLrzJr0sgUKjOzLPAZfx0598RZFCSuf8iXdprZwDn468hh44bz7rccws0tG2hr70i7HDOrUw7+OnPBgtls3bWHnz75YtqlmFmdcvDXmUVHTGbOpJG+k9fMBszBX2cKBfGxk2bx8Nrf8ssXt6ddjpnVIQd/HTr7hJk0NRT8kBYzGxBfzlmHJoxq4ozfncptj73AFe87ilHD/NdoVgsiggjojKAjme7oDDoj6AzoTKZ7Ltt/vWTdCDo6g1kTRzJmeOOQ1unEqFPnL5jFrY+9wA8f38jHTpqVdjlWBX2FRm+B0hUa/QXKAduIoLPzjYVSX8tK9fTYRtc63ZZF8jM9l+23XiTrdfayjR7LIqlr3zb6WBbJn1VnJ/vX3u3Psc9lnfuHe/dlnRV4bMabDx3Nzz77jiHdpoO/Th0/awJHHTaG65av47z5M5GUdkk1JSLY09FJW3sne5JX9+k9HR207e2krePAZW3tHfv/TLd1DliWLO+1vb2TnW3tABQLpb+f7n9NYr+Z3iaRYPfebI/PVCyIgqAgUZAoFoSS+Z7LCip9z9V9vWKyTOralpJ1km0kyxqKBYY17L+sa5tdP7ffNrotU4/1etZywHr7auh9G0rq2ldHofdlkjhh9oQh/zN38NcpSVywYDZ/+V9P8vj6V3jbrKH/cPTU0Rn7gm5Peyd7u7237Tcf7OnoYE979Lvu3o5OIqD7SVLXg8aie2vs95asV5q7qWUD40c2vh7o3cJ6KEgwrKFAU7HAsMZi6b2hQFPD6+/DGwuMG9FIU3H/9q5XQxL6ceAh9dLe+0qtO9qYNWnkoAOlK5TUPVS7b6/Hsv3W6xbMvS4rHHz7vW3Dqs/BX8c+9Lbp/M0dT3Pd8uf3BX9E8OqeDnbsbmdn21527G5PptvZubud7bv37pvuat/R1s5zW3YydkTjvkDuLdCH+r+xXf/4u+w7A97/rTStHuvQdTbcwYjGIm8/cvK+oB3WUNwXwPtCuFhgWGOBpmLxwHAulsK7t2UNSWCaZYmDv46NHtbAe996GLc8uoHbHtvAqGEN7GprLyugRzYVGTO8gdHDGhgzvJHZk0ayY3c7zZNH01Qs0JicvTYmZ7jd50thqf3mX2/vNl8s0NQgmopFGhtU2m7XOsUChYID1SwNDv46d+780pe8nQEfPn7GvjAfPbwU6GP2Tb8e8qOHNezrczaz/HHw17n5zRNp+ct3M3n0sLRLMbM6kcoNXJJOl/QrSb+WdEUaNWSJQ9/M3oiqB7+kIvBt4H3A0cB5ko6udh1mZnmVxhn/fODXEfGbiNgD/CfwwRTqMDPLpTSCfzqwvtv8hqRtP5IukdQiqaW1tbVqxZmZZV3NDtIWEUsjYl5EzJsyZUra5ZiZZUYawf8CMLPb/IykzczMqiCN4H8YOFJSs6Qm4Fzg9hTqMDPLpapfxx8R7ZL+BPgZUASujoinql2HmVlepXIDV0TcAdyRxr7NzPJOERUYQHqISWoFBvqQ2cnAS0NYTq3Kw3H6GLMjD8dZC8c4OyIOuDqmLoJ/MCS1RMS8tOuotDwcp48xO/JwnLV8jDV7OaeZmVWGg9/MLGfyEPxL0y6gSvJwnD7G7MjDcdbsMWa+j9/MzPaXhzN+MzPrJtPBn8Vx/yVdLWmLpCe7tU2UdJekZ5P3yj95vYIkzZR0j6TVkp6SdFnSnrXjHC7pIUkrk+P8ctLeLGlF8rm9MbnDva5JKkp6TNKPk/ksHuNaSaskPS6pJWmryc9sZoM/w+P+XwOc3qPtCuDuiDgSuDuZr2ftwJ9FxNHAAuCPk7+7rB1nG3BaRBwLHAecLmkB8FXgGxHxJuC3wJL0ShwylwFPd5vP4jECvDMijut2GWdNfmYzG/xkdNz/iPgFsLVH8weBa5Ppa4EPVbOmoRYRmyLi0WR6B6XAmE72jjMiYmcy25i8AjgN+EHSXvfHKWkG8AHgu8m8yNgx9qMmP7NZDv6yxv3PiEMjYlMy/SJwaJrFDCVJc4C3ASvI4HEmXSCPA1uAu4DngFcioj1ZJQuf238ELgc6k/lJZO8YofRL+05Jj0i6JGmryc+sH7aeMRERkjJxqZak0cAtwGciYnvpRLEkK8cZER3AcZLGA7cBR6Vb0dCSdAawJSIekXRqyuVU2uKIeEHSIcBdkn7ZfWEtfWazfMafp3H/N0uaCpC8b0m5nkGT1Egp9K+PiFuT5swdZ5eIeAW4B1gIjJfUdVJW75/bRcCZktZS6m49Dfgm2TpGACLiheR9C6Vf4vOp0c9sloM/T+P+3w5cmExfCPwwxVoGLekDvgp4OiK+3m1R1o5zSnKmj6QRwO9R+j7jHuAjyWp1fZwR8fmImBERcyj9G/x5RJxPho4RQNIoSWO6poH3AE9So5/ZTN/AJen9lPoXu8b9/6t0Kxo8STcAp1Ia+W8z8EXgv4CbgFmURjH9aET0/AK4bkhaDPw/YBWv9wv/b0r9/Fk6zrmUvvArUjoJuykiviLpcEpnxxOBx4ALIqItvUqHRtLV87mIOCNrx5gcz23JbAPwHxHxV5ImUYOf2UwHv5mZHSjLXT1mZtYLB7+ZWc44+M3McsbBb2aWMw5+M7OccfBbJkj6i2SEyyeS0RFPSrGWz0ga2ceyM5JRKlcmo49emrT/oaRPVLdSyytfzml1T9JC4OvAqRHRJmky0BQRG1OopUhpvJ15EfFSj2WNlK7lnh8RGyQNA+ZExK+qXaflm8/4LQumAi913QAUES91hX4yRvrkZHqepHuT6S9J+r6kZclY6Z9K2k+V9AtJP1HpWQ7/KqmQLDsvGW/9SUlf7dq5pJ2SviZpJfAXwDTgHkn39KhzDKWbe15O6mzrCv2kns9Jmpb8j6Xr1SFpdnKX7y2SHk5eiyr1h2nZ5+C3LLgTmCnpGUn/IukdZf7cXEpjxywE/o+kaUn7fOBPKT3H4QjgrGTZV5P1jwNOlPShZP1RwIqIODYivgJspDQu+zu77yy5Y/N2YJ2kGySd3/VLpds6G5Px3I8D/g24JSLWURrf5hsRcSLwYZIhjs0GwsFvdS8Z0/4E4BKgFbhR0ifL+NEfRsRrSZfMPZQCH+Ch5DkOHcANwGLgRODeiGhNhhO+HjglWb+D0oBy5dT6B8C7gIeAzwFX97Zeckb/KeDipOndwLeSIZxvB8Ymo5eavWEeltkyIQnpe4F7Ja2iNCDWNZSe5tV1gjO854/1Md9Xe192J/svt9ZVwCpJ3wfWAJ/svjwZxfEq4MxuD2opAAsiYne5+zHri8/4re5JerOkI7s1HUfpS1SAtZT+NwClLpLuPqjSc28nURr47uGkfX4yqmsBOAe4n9IZ+jskTU6+wD0PuK+PknZQ6s/vWefoHmPSd6+za51G4Gbgf0XEM90W3Ump+6lrveP62LfZQTn4LQtGA9cml0c+Qalv/kvJsi8D31Tp4dc9z8qfoNTFsxz4v92uAnoY+BalIZLXALclT1G6Ill/JfBIRPQ1xO5S4Ke9fLkr4PLkS+PHk9o+2WOdk4F5wJe7fcE7Dfg0MC+5XHU18IcH+0Mx64sv57RckvQlYGdE/EOP9lNJhg5OoSyzqvAZv5lZzviM38wsZ3zGb2aWMw5+M7OccfCbmeWMg9/MLGcc/GZmOePgNzPLmf8P7+DH5YWlQRQAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "cv_fit_result.cv_plot(gamma = cv_fit_result.gamma[4])\n", + "cv_fit_result.cv_sds" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "The above plot is produced using the [matplotlib](https://pandas.pydata.org/pandas-docs/version/0.21/visualization.html) package and returns a [matplotlib.axes._subplots.AxesSubplot](https://pandas.pydata.org/pandas-docs/version/0.21/visualization.html) which can be further customized by the user. We can also note that we have error bars in the cross validation error which is stored in `cv_sds` attribute and can be accessed with `cv_fit_result.cv_sds`. To extract the optimal $\\lambda$ (i.e., the one with minimum CV error) in this plot, we execute the following:" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4 19 0.2555564968851251\n", + "Optimal lambda = 0.0016080760437896327\n" + ] + } + ], + "source": [ + "optimal_gamma_index, optimal_lambda_index, min_error = min(gamma_mins, key = lambda t: t[2])\n", + "print(optimal_gamma_index, optimal_lambda_index, min_error)\n", + "print(\"Optimal lambda = \", fit_model_2.lambda_0[optimal_gamma_index][optimal_lambda_index])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "To print the solution corresponding to the optimal gamma/lambda pair:" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "<1001x1 sparse matrix of type ''\n", + "\twith 11 stored elements in Compressed Sparse Column format>" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cv_fit_result.coeff(lambda_0=fit_model_2.lambda_0[optimal_gamma_index][optimal_lambda_index],\n", + " gamma=fit_model_2.gamma[optimal_gamma_index])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "The optimal solution (above) selected by cross-validation correctly recovers the support of the true vector of coefficients used to generate the model." + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1.01994648 1. ]\n", + " [0.97317979 1. ]\n", + " [0.99813347 1. ]\n", + " [0.99669481 1. ]\n", + " [1.01128182 1. ]\n", + " [1.00190748 1. ]\n", + " [1.01272103 1. ]\n", + " [0.99204841 1. ]\n", + " [0.99607406 1. ]\n", + " [1.0266543 1. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " ...\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]\n", + " [0. 0. ]]\n" + ] + } + ], + "source": [ + "beta_vector = cv_fit_result.coeff(lambda_0=fit_model_2.lambda_0[optimal_gamma_index][optimal_lambda_index],\n", + " gamma=fit_model_2.gamma[optimal_gamma_index],\n", + " include_intercept=False).toarray()\n", + "\n", + "with np.printoptions(threshold=30, edgeitems=15):\n", + " print(np.hstack([beta_vector, B.reshape(-1, 1)]))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Fitting Classification Models\n", + "All the commands and plots we have seen in the case of regression extend to classification. We currently support logistic regression (using the parameter `loss=\"Logistic\"`) and a smoothed version of SVM (using the parameter `loss=\"SquaredHinge\"`). To give some examples, we first generate a synthetic classification dataset (similar to the one we generated in the case of regression):" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "np.random.seed(4) # fix the seed to get a reproducible result\n", + "n, p, k = 500, 1000, 10\n", + "X = np.random.normal(size=(n, p))\n", + "B = np.zeros(p)\n", + "B[:k] = 1\n", + "e = np.random.normal(size=(n,))/2\n", + "y = np.sign(X@B + e)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "More expressive and complete functions for generating datasets can be found are available in [l0learn.models](code.rst#l0learn.models). The available functions are:\n", + "\n", + "* [l0learn.models.gen_synthetic()](code.rst#l0learn.models.gen_synthetic)\n", + "* [l0learn.models.gen_synthetic_high_corr()](code.rst#l0learn.models.gen_synthetic_high_corr)\n", + "* [l0learn.models.gen_synthetic_logistic()](code.rst#l0learn.models.gen_synthetic_logistic)\n", + "\n", + "An L0-regularized logistic regression model can be fit by specificying `loss = \"Logistic\"` as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
l0support_sizeinterceptconvergedl2
025.2253361-0.036989True1.000000e-07
119.4320532-0.043199True1.000000e-07
218.9286032-0.043230True1.000000e-07
315.1428822-0.043245True1.000000e-07
412.11430690.004044True1.000000e-07
57.411211100.188422False1.000000e-07
67.188875100.219990False1.000000e-07
75.751100100.234899False1.000000e-07
84.600880100.242631False1.000000e-07
93.680704100.243655True1.000000e-07
102.944563100.243993True1.000000e-07
112.355651100.244295True1.000000e-07
121.884520100.244520True1.000000e-07
131.507616100.244716True1.000000e-07
141.206093100.244886True1.000000e-07
150.964874100.245011True1.000000e-07
160.771900100.245133True1.000000e-07
170.617520120.178144False1.000000e-07
180.598994120.196406False1.000000e-07
190.479195120.208883False1.000000e-07
200.383356150.192033False1.000000e-07
210.371856150.221470False1.000000e-07
220.297484150.246182False1.000000e-07
230.23798816-0.110626False1.000000e-07
240.23084816-0.118558False1.000000e-07
250.18467816-0.124533False1.000000e-07
260.14774321-0.211002False1.000000e-07
\n", + "
" + ], + "text/plain": [ + "FitModel({'loss': 'Logistic', 'intercept': True, 'penalty': 'L0L2'})" + ] + }, + "execution_count": 117, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fit_model_3 = l0learn.fit(X,y,loss=\"Logistic\", max_support_size=20)\n", + "fit_model_3" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "The output above indicates that $\\gamma=10^{-7}$ by default we use a small ridge regularization (with $\\gamma=10^{-7}$) to ensure the existence of a unique solution. To extract the coefficients of the solution with $\\lambda = 8.69435$ we use the following code. Notice that we can ignore the specification of gamma as there is only one gamma used in L0 Logistic regression:" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "np.where(fit_model_3.coeff(lambda_0=7.411211).toarray() > 0)[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "The above indicates that the 10 non-zeros in the estimated model match those we used in generating the data (i.e, L0 regularization correctly recovered the true support). We can also make predictions at the latter $\\lambda$ using:" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1.69583037e-04]\n", + " [4.92440655e-06]\n", + " [3.92195535e-03]\n", + " ...\n", + " [9.99161941e-01]\n", + " [1.69035746e-01]\n", + " [9.99171256e-04]]\n" + ] + } + ], + "source": [ + "with np.printoptions(threshold=10):\n", + " print(fit_model_3.predict(X, lambda_0=7.411211))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "Each row in the above is the probability that the corresponding sample belongs to class $1$. Other models (i.e., L0L2 and L0L1) can be similarly fit by specifying `loss = \"Logistic\"`.\n", + "\n", + "Finally, we note that L0Learn also supports a smoothed version of SVM by using squared hinge loss `loss = \"SquaredHinge\"`. The only difference from logistic regression is that the `predict` function returns $\\beta_0 + \\langle x, \\beta \\rangle$ (where $x$ is the testing sample), instead of returning probabilities. The latter predictions can be assigned to the appropriate classes by using a thresholding function (e.g., the sign function)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "## Advanced Options\n", + "\n", + "### Sparse Matrix Support\n", + "Starting in version 2.0.0, L0Learn supports sparse matrices of type [scipy.sparse.csc_matrix](https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.csc_matrix.html). If your sparse matrix uses a different storage format, please convert it to `csc_matrix` before using it in `l0learn`. `l0learn` keeps the matrix sparse internally and thus is highly efficient if the matrix is sufficiently sparse. The API for sparse matrices is the same as that of dense matrices, so all the demonstrations in this vignette also apply for sparse matrices. For example, we can fit an L0-regularized model on a sparse matrix as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
l0support_sizeinterceptconverged
00.03189200.009325True
10.03157310.004882True
20.0206062-0.002187True
30.0144423-0.004111True
40.0139324-0.002556True
50.01085450.002987True
60.00928660.002048True
70.0091917-0.001371True
80.0087718-0.000533True
90.00815190.000064True
100.006480110.001587True
110.00636412-0.003636True
120.00576013-0.003866True
130.00556015-0.004211True
140.005264170.001497True
150.00463718-0.000797True
160.00451519-0.002634True
170.004113220.001419True
\n", + "
" + ], + "text/plain": [ + " l0 support_size intercept converged\n", + "0 0.031892 0 0.009325 True\n", + "1 0.031573 1 0.004882 True\n", + "2 0.020606 2 -0.002187 True\n", + "3 0.014442 3 -0.004111 True\n", + "4 0.013932 4 -0.002556 True\n", + "5 0.010854 5 0.002987 True\n", + "6 0.009286 6 0.002048 True\n", + "7 0.009191 7 -0.001371 True\n", + "8 0.008771 8 -0.000533 True\n", + "9 0.008151 9 0.000064 True\n", + "10 0.006480 11 0.001587 True\n", + "11 0.006364 12 -0.003636 True\n", + "12 0.005760 13 -0.003866 True\n", + "13 0.005560 15 -0.004211 True\n", + "14 0.005264 17 0.001497 True\n", + "15 0.004637 18 -0.000797 True\n", + "16 0.004515 19 -0.002634 True\n", + "17 0.004113 22 0.001419 True" + ] + }, + "execution_count": 90, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from scipy.sparse import random\n", + "from scipy.stats import norm\n", + "\n", + "\n", + "X_sparse = random(n, p, density=0.01, format='csc', data_rvs=norm().rvs)\n", + "y_sparse = (X_sparse@B + e)\n", + "\n", + "fit_model_sparse = l0learn.fit(X_sparse, y_sparse, penalty=\"L0\", max_support_size=20)\n", + "\n", + "fit_model_sparse.characteristics()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "### Selection on Subset of Variables\n", + "In certain applications, it is desirable to always include some of the variables in the model and perform variable selection on others. `l0learn` supports this option through the `exclude_first_k` parameter. Specifically, setting `exclude_first_k = K` (where K is a non-negative integer) instructs `l0learn` to exclude the first K variables in the data matrix `X` from the L0-norm penalty (those K variables will still be penalized using the L2 or L1 norm penalties.). For example, below we fit an `L0` model and exclude the first 3 variables from selection by setting `excludeFirstK = 3`:" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
l0support_sizeinterceptconverged
00.0504643-0.017599True
10.0443334-0.021333True
20.0327705-0.027624True
30.0293677-0.029115True
40.0247108-0.021199True
50.02139390.010249True
60.014785100.016812True
\n", + "
" + ], + "text/plain": [ + " l0 support_size intercept converged\n", + "0 0.050464 3 -0.017599 True\n", + "1 0.044333 4 -0.021333 True\n", + "2 0.032770 5 -0.027624 True\n", + "3 0.029367 7 -0.029115 True\n", + "4 0.024710 8 -0.021199 True\n", + "5 0.021393 9 0.010249 True\n", + "6 0.014785 10 0.016812 True" + ] + }, + "execution_count": 94, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fit_model_k = l0learn.fit(X, y, penalty=\"L0\", max_support_size=10, exclude_first_k=3)\n", + "fit_model_k.characteristics()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "Plotting the regularization path:" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 93, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fit_model_k.plot(show_lines=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "We can see in the plot above that first 3 variables, (0, 1, 2) are included in all the solutions of the path\n", + "\n", + "### Coefficient Bounds\n", + "Starting in version 2.0.0, `l0learn` supports bounds for CD algorithms for all losses and penalties. (We plan to support bound constraints for the CDPSI algorithm in the future). By default, `l0learn` does not apply bounds, i.e., it assumes $-\\infty <= \\beta_i <= \\infty$ for all i. Users can supply the same bounds for all coefficients by setting the parameters `lows` and `highs` to scalar values (these should satisfy: `lows <= 0`, `lows != highs`, and `highs >= 0`). To use different bounds for the coefficients, `lows` and `highs` can be both set to vectors of length `p` (where the i-th entry corresponds to the bound on coefficient i).\n", + "\n", + "All of the following examples are valid." + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "l0learn.fit(X, y, penalty=\"L0\", lows=-0.5)\n", + "l0learn.fit(X, y, penalty=\"L0\", highs=0.5)\n", + "l0learn.fit(X, y, penalty=\"L0\", lows=-0.5, highs=0.5)\n", + "\n", + "max_value = 0.25\n", + "highs_array = max_value*np.ones(p)\n", + "highs_array[0] = 0.1\n", + "fit_model_bounds = l0learn.fit(X, y, penalty=\"L0\", lows=-0.1, highs=highs_array, max_support_size=20)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "We can see the coefficients are subject to the bounds." + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/tnonet/Documents/GitHub/L0Learn/python/l0learn/models.py:438: UserWarning: Duplicate solution seen at support size 0. Plotting only first solution\n", + " warnings.warn(f\"Duplicate solution seen at support size {support_size}. Plotting only first solution\")\n", + "/Users/tnonet/Documents/GitHub/L0Learn/python/l0learn/models.py:438: UserWarning: Duplicate solution seen at support size 6. Plotting only first solution\n", + " warnings.warn(f\"Duplicate solution seen at support size {support_size}. Plotting only first solution\")\n", + "/Users/tnonet/Documents/GitHub/L0Learn/python/l0learn/models.py:438: UserWarning: Duplicate solution seen at support size 8. Plotting only first solution\n", + " warnings.warn(f\"Duplicate solution seen at support size {support_size}. Plotting only first solution\")\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "maximum value of coefficients = 0.25 <= 0.25\n", + "maximum value of first coefficient = 0.1 <= 0.1\n", + "minimum value of coefficient = -0.1 >= -0.1\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fit_model_bounds.plot(show_lines=True)\n", + "\n", + "print(f\"maximum value of coefficients = {np.max(fit_model_bounds.coeffs[0])} <= {max_value}\")\n", + "print(f\"maximum value of first coefficient = {np.max(fit_model_bounds.coeffs[0][0, :])} <= 0.1\")\n", + "print(f\"minimum value of coefficient = {np.min(fit_model_bounds.coeffs[0])} >= -0.1\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "### User-specified Lambda Grids\n", + "By default, `l0learn` selects the sequence of lambda values in an efficient manner to avoid wasted computation (since close $\\lambda$ values can typically lead to the same solution). Advanced users of the toolkit can change this default behavior and supply their own sequence of $\\lambda$ values. This can be done supplying the $\\lambda$ values through the parameter `lambda_grid`. When `lambda_grid` is supplied, we require `num_gamma` and `num_lambda` to be `None` to ensure the is no ambiguity in the solution path requested.\n", + "\n", + "Specifically, the value assigned to `lambda_grid` should be a list of lists/arrays of decreasing positive values (floats). The length of `lambda_grid` (the number of lists stored) specifies the number of gamma parameters that will fill between `gamma_min`, and `gamma_max`. In the case of L0 penalty, `lambda_grid` must be a list of length 1. In case of L0L2/L0L1 `lambda_grid` can have any number of sub-lists stored. The ith element in `lambda_grid` should be a **strictly decreasing** sequence of positive lambda values which are used by the algorithm for the ith value of gamma. For example, to fit an L0 model with the sequence of user-specified lambda values: 1, 1e-1, 1e-2, 1e-3, 1e-4, we run the following:" + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "user_lambda_grid = [[1, 1e-1, 1e-2, 1e-3, 1e-4]]\n", + "fit_grid = l0learn.fit(X, y, penalty=\"L0\", lambda_grid=user_lambda_grid, max_support_size=1000, num_lambda=None, num_gamma=None)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "To verify the results we print the fit object:" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
l0support_sizeinterceptconverged
01.00000-0.016000True
10.10000-0.016000True
20.0100100.016811True
30.0010620.018729True
40.00012670.051675True
\n", + "
" + ], + "text/plain": [ + "FitModel({'loss': 'SquaredError', 'intercept': True, 'penalty': 'L0'})" + ] + }, + "execution_count": 114, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fit_grid\n", + "# Use fit_grid.characteristics() for those without rich dispalys" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "Note that the $\\lambda$ values above are the desired values. For L0L2 and L0L1 penalties, the same can be done where the `lambda_grid` parameter." + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "user_lambda_grid_L2 = [[1, 1e-1, 1e-2, 1e-3, 1e-4],\n", + " [10, 2, 1, 0.01, 0.002, 0.001, 1e-5],\n", + " [1e-4, 1e-5]]\n", + "\n", + "# user_lambda_grid_L2[[i]] must be a sequence of positive decreasing reals.\n", + "fit_grid_L2 = l0learn.fit(X, y, penalty=\"L0L2\", lambda_grid=user_lambda_grid_L2, max_support_size=1000, num_lambda=None, num_gamma=None)" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
l0support_sizeinterceptconvergedl2
01.000000-0.016000True10.000000
10.100000-0.016000True10.000000
20.010000-0.016000True10.000000
30.001009-0.014394True10.000000
40.00010134-0.012180True10.000000
510.000000-0.016000True0.031623
62.000000-0.016000True0.031623
71.000000-0.016000True0.031623
80.01000100.015045True0.031623
90.00200280.001483True0.031623
100.00100580.002821True0.031623
110.000015820.021913True0.031623
120.000103110.048700True0.000100
130.000014110.047991False0.000100
\n", + "
" + ], + "text/plain": [ + "FitModel({'loss': 'SquaredError', 'intercept': True, 'penalty': 'L0L2'})" + ] + }, + "execution_count": 116, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fit_grid_L2\n", + "# Use fit_grid_L2.characteristics() for those without rich dispalys" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "# More Details\n", + "For more details please inspect the doc strings of:\n", + "\n", + "* [l0learn.models.CVFitModel](code.rst#l0learn.models.CVFitModel)\n", + "* [l0learn.models.FitModel](code.rst#l0learn.models.FitModel)\n", + "* [l0learn.fit](code.rst#l0learn.fit)\n", + "* [l0learn.cvfit](code.rst#l0learn.cvfit)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "# References\n", + "Hussein Hazimeh and Rahul Mazumder. [Fast Best Subset Selection: Coordinate Descent and Local Combinatorial Optimization Algorithms](https://pubsonline.informs.org/doi/10.1287/opre.2019.1919). Operations Research (2020).\n", + "\n", + "Antoine Dedieu, Hussein Hazimeh, and Rahul Mazumder. [Learning Sparse Classifiers: Continuous and Mixed Integer Optimization Perspectives](https://arxiv.org/abs/2001.06471). JMLR (to appear)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/python/doc/.nojekyll b/python/doc/.nojekyll new file mode 100644 index 0000000..e69de29 From 76d010c1e9f8158bc2dc70bddefb8f01f39ba078 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 3 Dec 2021 16:51:10 -0600 Subject: [PATCH 078/125] testing github-pages --- {python/_github_pages_docs => docs}/html/.buildinfo | 0 .../html/_images/tutorial_18_0.png | Bin .../html/_images/tutorial_20_1.png | Bin .../html/_images/tutorial_30_2.png | Bin .../html/_images/tutorial_36_1.png | Bin .../html/_images/tutorial_57_1.png | Bin .../html/_images/tutorial_61_2.png | Bin .../html/_sources/code.rst.txt | 0 .../html/_sources/index.rst.txt | 0 .../html/_sources/tutorial.ipynb.txt | 0 .../html/_static/alabaster.css | 0 .../html/_static/basic.css | 0 .../html/_static/custom.css | 0 .../html/_static/doctools.js | 0 .../html/_static/documentation_options.js | 0 .../html/_static/file.png | Bin .../html/_static/jquery-3.5.1.js | 0 .../html/_static/jquery.js | 0 .../html/_static/language_data.js | 0 .../html/_static/minus.png | Bin .../html/_static/plus.png | Bin .../html/_static/pygments.css | 0 .../html/_static/searchtools.js | 0 .../html/_static/underscore-1.13.1.js | 0 .../html/_static/underscore.js | 0 {python/_github_pages_docs => docs}/html/code.html | 0 .../_github_pages_docs => docs}/html/genindex.html | 0 {python/_github_pages_docs => docs}/html/index.html | 0 .../_github_pages_docs => docs}/html/objects.inv | Bin .../_github_pages_docs => docs}/html/search.html | 0 .../_github_pages_docs => docs}/html/searchindex.js | 0 .../_github_pages_docs => docs}/html/tutorial.html | 0 .../_github_pages_docs => docs}/html/tutorial.ipynb | 0 33 files changed, 0 insertions(+), 0 deletions(-) rename {python/_github_pages_docs => docs}/html/.buildinfo (100%) rename {python/_github_pages_docs => docs}/html/_images/tutorial_18_0.png (100%) rename {python/_github_pages_docs => docs}/html/_images/tutorial_20_1.png (100%) rename {python/_github_pages_docs => docs}/html/_images/tutorial_30_2.png (100%) rename {python/_github_pages_docs => docs}/html/_images/tutorial_36_1.png (100%) rename {python/_github_pages_docs => docs}/html/_images/tutorial_57_1.png (100%) rename {python/_github_pages_docs => docs}/html/_images/tutorial_61_2.png (100%) rename {python/_github_pages_docs => docs}/html/_sources/code.rst.txt (100%) rename {python/_github_pages_docs => docs}/html/_sources/index.rst.txt (100%) rename {python/_github_pages_docs => docs}/html/_sources/tutorial.ipynb.txt (100%) rename {python/_github_pages_docs => docs}/html/_static/alabaster.css (100%) rename {python/_github_pages_docs => docs}/html/_static/basic.css (100%) rename {python/_github_pages_docs => docs}/html/_static/custom.css (100%) rename {python/_github_pages_docs => docs}/html/_static/doctools.js (100%) rename {python/_github_pages_docs => docs}/html/_static/documentation_options.js (100%) rename {python/_github_pages_docs => docs}/html/_static/file.png (100%) rename {python/_github_pages_docs => docs}/html/_static/jquery-3.5.1.js (100%) rename {python/_github_pages_docs => docs}/html/_static/jquery.js (100%) rename {python/_github_pages_docs => docs}/html/_static/language_data.js (100%) rename {python/_github_pages_docs => docs}/html/_static/minus.png (100%) rename {python/_github_pages_docs => docs}/html/_static/plus.png (100%) rename {python/_github_pages_docs => docs}/html/_static/pygments.css (100%) rename {python/_github_pages_docs => docs}/html/_static/searchtools.js (100%) rename {python/_github_pages_docs => docs}/html/_static/underscore-1.13.1.js (100%) rename {python/_github_pages_docs => docs}/html/_static/underscore.js (100%) rename {python/_github_pages_docs => docs}/html/code.html (100%) rename {python/_github_pages_docs => docs}/html/genindex.html (100%) rename {python/_github_pages_docs => docs}/html/index.html (100%) rename {python/_github_pages_docs => docs}/html/objects.inv (100%) rename {python/_github_pages_docs => docs}/html/search.html (100%) rename {python/_github_pages_docs => docs}/html/searchindex.js (100%) rename {python/_github_pages_docs => docs}/html/tutorial.html (100%) rename {python/_github_pages_docs => docs}/html/tutorial.ipynb (100%) diff --git a/python/_github_pages_docs/html/.buildinfo b/docs/html/.buildinfo similarity index 100% rename from python/_github_pages_docs/html/.buildinfo rename to docs/html/.buildinfo diff --git a/python/_github_pages_docs/html/_images/tutorial_18_0.png b/docs/html/_images/tutorial_18_0.png similarity index 100% rename from python/_github_pages_docs/html/_images/tutorial_18_0.png rename to docs/html/_images/tutorial_18_0.png diff --git a/python/_github_pages_docs/html/_images/tutorial_20_1.png b/docs/html/_images/tutorial_20_1.png similarity index 100% rename from python/_github_pages_docs/html/_images/tutorial_20_1.png rename to docs/html/_images/tutorial_20_1.png diff --git a/python/_github_pages_docs/html/_images/tutorial_30_2.png b/docs/html/_images/tutorial_30_2.png similarity index 100% rename from python/_github_pages_docs/html/_images/tutorial_30_2.png rename to docs/html/_images/tutorial_30_2.png diff --git a/python/_github_pages_docs/html/_images/tutorial_36_1.png b/docs/html/_images/tutorial_36_1.png similarity index 100% rename from python/_github_pages_docs/html/_images/tutorial_36_1.png rename to docs/html/_images/tutorial_36_1.png diff --git a/python/_github_pages_docs/html/_images/tutorial_57_1.png b/docs/html/_images/tutorial_57_1.png similarity index 100% rename from python/_github_pages_docs/html/_images/tutorial_57_1.png rename to docs/html/_images/tutorial_57_1.png diff --git a/python/_github_pages_docs/html/_images/tutorial_61_2.png b/docs/html/_images/tutorial_61_2.png similarity index 100% rename from python/_github_pages_docs/html/_images/tutorial_61_2.png rename to docs/html/_images/tutorial_61_2.png diff --git a/python/_github_pages_docs/html/_sources/code.rst.txt b/docs/html/_sources/code.rst.txt similarity index 100% rename from python/_github_pages_docs/html/_sources/code.rst.txt rename to docs/html/_sources/code.rst.txt diff --git a/python/_github_pages_docs/html/_sources/index.rst.txt b/docs/html/_sources/index.rst.txt similarity index 100% rename from python/_github_pages_docs/html/_sources/index.rst.txt rename to docs/html/_sources/index.rst.txt diff --git a/python/_github_pages_docs/html/_sources/tutorial.ipynb.txt b/docs/html/_sources/tutorial.ipynb.txt similarity index 100% rename from python/_github_pages_docs/html/_sources/tutorial.ipynb.txt rename to docs/html/_sources/tutorial.ipynb.txt diff --git a/python/_github_pages_docs/html/_static/alabaster.css b/docs/html/_static/alabaster.css similarity index 100% rename from python/_github_pages_docs/html/_static/alabaster.css rename to docs/html/_static/alabaster.css diff --git a/python/_github_pages_docs/html/_static/basic.css b/docs/html/_static/basic.css similarity index 100% rename from python/_github_pages_docs/html/_static/basic.css rename to docs/html/_static/basic.css diff --git a/python/_github_pages_docs/html/_static/custom.css b/docs/html/_static/custom.css similarity index 100% rename from python/_github_pages_docs/html/_static/custom.css rename to docs/html/_static/custom.css diff --git a/python/_github_pages_docs/html/_static/doctools.js b/docs/html/_static/doctools.js similarity index 100% rename from python/_github_pages_docs/html/_static/doctools.js rename to docs/html/_static/doctools.js diff --git a/python/_github_pages_docs/html/_static/documentation_options.js b/docs/html/_static/documentation_options.js similarity index 100% rename from python/_github_pages_docs/html/_static/documentation_options.js rename to docs/html/_static/documentation_options.js diff --git a/python/_github_pages_docs/html/_static/file.png b/docs/html/_static/file.png similarity index 100% rename from python/_github_pages_docs/html/_static/file.png rename to docs/html/_static/file.png diff --git a/python/_github_pages_docs/html/_static/jquery-3.5.1.js b/docs/html/_static/jquery-3.5.1.js similarity index 100% rename from python/_github_pages_docs/html/_static/jquery-3.5.1.js rename to docs/html/_static/jquery-3.5.1.js diff --git a/python/_github_pages_docs/html/_static/jquery.js b/docs/html/_static/jquery.js similarity index 100% rename from python/_github_pages_docs/html/_static/jquery.js rename to docs/html/_static/jquery.js diff --git a/python/_github_pages_docs/html/_static/language_data.js b/docs/html/_static/language_data.js similarity index 100% rename from python/_github_pages_docs/html/_static/language_data.js rename to docs/html/_static/language_data.js diff --git a/python/_github_pages_docs/html/_static/minus.png b/docs/html/_static/minus.png similarity index 100% rename from python/_github_pages_docs/html/_static/minus.png rename to docs/html/_static/minus.png diff --git a/python/_github_pages_docs/html/_static/plus.png b/docs/html/_static/plus.png similarity index 100% rename from python/_github_pages_docs/html/_static/plus.png rename to docs/html/_static/plus.png diff --git a/python/_github_pages_docs/html/_static/pygments.css b/docs/html/_static/pygments.css similarity index 100% rename from python/_github_pages_docs/html/_static/pygments.css rename to docs/html/_static/pygments.css diff --git a/python/_github_pages_docs/html/_static/searchtools.js b/docs/html/_static/searchtools.js similarity index 100% rename from python/_github_pages_docs/html/_static/searchtools.js rename to docs/html/_static/searchtools.js diff --git a/python/_github_pages_docs/html/_static/underscore-1.13.1.js b/docs/html/_static/underscore-1.13.1.js similarity index 100% rename from python/_github_pages_docs/html/_static/underscore-1.13.1.js rename to docs/html/_static/underscore-1.13.1.js diff --git a/python/_github_pages_docs/html/_static/underscore.js b/docs/html/_static/underscore.js similarity index 100% rename from python/_github_pages_docs/html/_static/underscore.js rename to docs/html/_static/underscore.js diff --git a/python/_github_pages_docs/html/code.html b/docs/html/code.html similarity index 100% rename from python/_github_pages_docs/html/code.html rename to docs/html/code.html diff --git a/python/_github_pages_docs/html/genindex.html b/docs/html/genindex.html similarity index 100% rename from python/_github_pages_docs/html/genindex.html rename to docs/html/genindex.html diff --git a/python/_github_pages_docs/html/index.html b/docs/html/index.html similarity index 100% rename from python/_github_pages_docs/html/index.html rename to docs/html/index.html diff --git a/python/_github_pages_docs/html/objects.inv b/docs/html/objects.inv similarity index 100% rename from python/_github_pages_docs/html/objects.inv rename to docs/html/objects.inv diff --git a/python/_github_pages_docs/html/search.html b/docs/html/search.html similarity index 100% rename from python/_github_pages_docs/html/search.html rename to docs/html/search.html diff --git a/python/_github_pages_docs/html/searchindex.js b/docs/html/searchindex.js similarity index 100% rename from python/_github_pages_docs/html/searchindex.js rename to docs/html/searchindex.js diff --git a/python/_github_pages_docs/html/tutorial.html b/docs/html/tutorial.html similarity index 100% rename from python/_github_pages_docs/html/tutorial.html rename to docs/html/tutorial.html diff --git a/python/_github_pages_docs/html/tutorial.ipynb b/docs/html/tutorial.ipynb similarity index 100% rename from python/_github_pages_docs/html/tutorial.ipynb rename to docs/html/tutorial.ipynb From 36ae565c2bc90a5e975b6724d16e7c2d1ba506f5 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 3 Dec 2021 16:52:48 -0600 Subject: [PATCH 079/125] testing github-pages prt2 --- docs/{html => }/_images/tutorial_18_0.png | Bin docs/{html => }/_images/tutorial_20_1.png | Bin docs/{html => }/_images/tutorial_30_2.png | Bin docs/{html => }/_images/tutorial_36_1.png | Bin docs/{html => }/_images/tutorial_57_1.png | Bin docs/{html => }/_images/tutorial_61_2.png | Bin docs/{html => }/_sources/code.rst.txt | 0 docs/{html => }/_sources/index.rst.txt | 0 docs/{html => }/_sources/tutorial.ipynb.txt | 0 docs/{html => }/_static/alabaster.css | 0 docs/{html => }/_static/basic.css | 0 docs/{html => }/_static/custom.css | 0 docs/{html => }/_static/doctools.js | 0 docs/{html => }/_static/documentation_options.js | 0 docs/{html => }/_static/file.png | Bin docs/{html => }/_static/jquery-3.5.1.js | 0 docs/{html => }/_static/jquery.js | 0 docs/{html => }/_static/language_data.js | 0 docs/{html => }/_static/minus.png | Bin docs/{html => }/_static/plus.png | Bin docs/{html => }/_static/pygments.css | 0 docs/{html => }/_static/searchtools.js | 0 docs/{html => }/_static/underscore-1.13.1.js | 0 docs/{html => }/_static/underscore.js | 0 docs/{html => }/code.html | 0 docs/{html => }/genindex.html | 0 docs/html/.buildinfo | 4 ---- docs/{html => }/index.html | 0 docs/{html => }/objects.inv | Bin docs/{html => }/search.html | 0 docs/{html => }/searchindex.js | 0 docs/{html => }/tutorial.html | 0 docs/{html => }/tutorial.ipynb | 0 33 files changed, 4 deletions(-) rename docs/{html => }/_images/tutorial_18_0.png (100%) rename docs/{html => }/_images/tutorial_20_1.png (100%) rename docs/{html => }/_images/tutorial_30_2.png (100%) rename docs/{html => }/_images/tutorial_36_1.png (100%) rename docs/{html => }/_images/tutorial_57_1.png (100%) rename docs/{html => }/_images/tutorial_61_2.png (100%) rename docs/{html => }/_sources/code.rst.txt (100%) rename docs/{html => }/_sources/index.rst.txt (100%) rename docs/{html => }/_sources/tutorial.ipynb.txt (100%) rename docs/{html => }/_static/alabaster.css (100%) rename docs/{html => }/_static/basic.css (100%) rename docs/{html => }/_static/custom.css (100%) rename docs/{html => }/_static/doctools.js (100%) rename docs/{html => }/_static/documentation_options.js (100%) rename docs/{html => }/_static/file.png (100%) rename docs/{html => }/_static/jquery-3.5.1.js (100%) rename docs/{html => }/_static/jquery.js (100%) rename docs/{html => }/_static/language_data.js (100%) rename docs/{html => }/_static/minus.png (100%) rename docs/{html => }/_static/plus.png (100%) rename docs/{html => }/_static/pygments.css (100%) rename docs/{html => }/_static/searchtools.js (100%) rename docs/{html => }/_static/underscore-1.13.1.js (100%) rename docs/{html => }/_static/underscore.js (100%) rename docs/{html => }/code.html (100%) rename docs/{html => }/genindex.html (100%) delete mode 100644 docs/html/.buildinfo rename docs/{html => }/index.html (100%) rename docs/{html => }/objects.inv (100%) rename docs/{html => }/search.html (100%) rename docs/{html => }/searchindex.js (100%) rename docs/{html => }/tutorial.html (100%) rename docs/{html => }/tutorial.ipynb (100%) diff --git a/docs/html/_images/tutorial_18_0.png b/docs/_images/tutorial_18_0.png similarity index 100% rename from docs/html/_images/tutorial_18_0.png rename to docs/_images/tutorial_18_0.png diff --git a/docs/html/_images/tutorial_20_1.png b/docs/_images/tutorial_20_1.png similarity index 100% rename from docs/html/_images/tutorial_20_1.png rename to docs/_images/tutorial_20_1.png diff --git a/docs/html/_images/tutorial_30_2.png b/docs/_images/tutorial_30_2.png similarity index 100% rename from docs/html/_images/tutorial_30_2.png rename to docs/_images/tutorial_30_2.png diff --git a/docs/html/_images/tutorial_36_1.png b/docs/_images/tutorial_36_1.png similarity index 100% rename from docs/html/_images/tutorial_36_1.png rename to docs/_images/tutorial_36_1.png diff --git a/docs/html/_images/tutorial_57_1.png b/docs/_images/tutorial_57_1.png similarity index 100% rename from docs/html/_images/tutorial_57_1.png rename to docs/_images/tutorial_57_1.png diff --git a/docs/html/_images/tutorial_61_2.png b/docs/_images/tutorial_61_2.png similarity index 100% rename from docs/html/_images/tutorial_61_2.png rename to docs/_images/tutorial_61_2.png diff --git a/docs/html/_sources/code.rst.txt b/docs/_sources/code.rst.txt similarity index 100% rename from docs/html/_sources/code.rst.txt rename to docs/_sources/code.rst.txt diff --git a/docs/html/_sources/index.rst.txt b/docs/_sources/index.rst.txt similarity index 100% rename from docs/html/_sources/index.rst.txt rename to docs/_sources/index.rst.txt diff --git a/docs/html/_sources/tutorial.ipynb.txt b/docs/_sources/tutorial.ipynb.txt similarity index 100% rename from docs/html/_sources/tutorial.ipynb.txt rename to docs/_sources/tutorial.ipynb.txt diff --git a/docs/html/_static/alabaster.css b/docs/_static/alabaster.css similarity index 100% rename from docs/html/_static/alabaster.css rename to docs/_static/alabaster.css diff --git a/docs/html/_static/basic.css b/docs/_static/basic.css similarity index 100% rename from docs/html/_static/basic.css rename to docs/_static/basic.css diff --git a/docs/html/_static/custom.css b/docs/_static/custom.css similarity index 100% rename from docs/html/_static/custom.css rename to docs/_static/custom.css diff --git a/docs/html/_static/doctools.js b/docs/_static/doctools.js similarity index 100% rename from docs/html/_static/doctools.js rename to docs/_static/doctools.js diff --git a/docs/html/_static/documentation_options.js b/docs/_static/documentation_options.js similarity index 100% rename from docs/html/_static/documentation_options.js rename to docs/_static/documentation_options.js diff --git a/docs/html/_static/file.png b/docs/_static/file.png similarity index 100% rename from docs/html/_static/file.png rename to docs/_static/file.png diff --git a/docs/html/_static/jquery-3.5.1.js b/docs/_static/jquery-3.5.1.js similarity index 100% rename from docs/html/_static/jquery-3.5.1.js rename to docs/_static/jquery-3.5.1.js diff --git a/docs/html/_static/jquery.js b/docs/_static/jquery.js similarity index 100% rename from docs/html/_static/jquery.js rename to docs/_static/jquery.js diff --git a/docs/html/_static/language_data.js b/docs/_static/language_data.js similarity index 100% rename from docs/html/_static/language_data.js rename to docs/_static/language_data.js diff --git a/docs/html/_static/minus.png b/docs/_static/minus.png similarity index 100% rename from docs/html/_static/minus.png rename to docs/_static/minus.png diff --git a/docs/html/_static/plus.png b/docs/_static/plus.png similarity index 100% rename from docs/html/_static/plus.png rename to docs/_static/plus.png diff --git a/docs/html/_static/pygments.css b/docs/_static/pygments.css similarity index 100% rename from docs/html/_static/pygments.css rename to docs/_static/pygments.css diff --git a/docs/html/_static/searchtools.js b/docs/_static/searchtools.js similarity index 100% rename from docs/html/_static/searchtools.js rename to docs/_static/searchtools.js diff --git a/docs/html/_static/underscore-1.13.1.js b/docs/_static/underscore-1.13.1.js similarity index 100% rename from docs/html/_static/underscore-1.13.1.js rename to docs/_static/underscore-1.13.1.js diff --git a/docs/html/_static/underscore.js b/docs/_static/underscore.js similarity index 100% rename from docs/html/_static/underscore.js rename to docs/_static/underscore.js diff --git a/docs/html/code.html b/docs/code.html similarity index 100% rename from docs/html/code.html rename to docs/code.html diff --git a/docs/html/genindex.html b/docs/genindex.html similarity index 100% rename from docs/html/genindex.html rename to docs/genindex.html diff --git a/docs/html/.buildinfo b/docs/html/.buildinfo deleted file mode 100644 index f22a669..0000000 --- a/docs/html/.buildinfo +++ /dev/null @@ -1,4 +0,0 @@ -# Sphinx build info version 1 -# This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done. -config: 821a7001e95886892bae70fb345cf85d -tags: 645f666f9bcd5a90fca523b33c5a78b7 diff --git a/docs/html/index.html b/docs/index.html similarity index 100% rename from docs/html/index.html rename to docs/index.html diff --git a/docs/html/objects.inv b/docs/objects.inv similarity index 100% rename from docs/html/objects.inv rename to docs/objects.inv diff --git a/docs/html/search.html b/docs/search.html similarity index 100% rename from docs/html/search.html rename to docs/search.html diff --git a/docs/html/searchindex.js b/docs/searchindex.js similarity index 100% rename from docs/html/searchindex.js rename to docs/searchindex.js diff --git a/docs/html/tutorial.html b/docs/tutorial.html similarity index 100% rename from docs/html/tutorial.html rename to docs/tutorial.html diff --git a/docs/html/tutorial.ipynb b/docs/tutorial.ipynb similarity index 100% rename from docs/html/tutorial.ipynb rename to docs/tutorial.ipynb From db79bd273de54c8f88621713ea20e3d1581a270e Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 3 Dec 2021 16:53:35 -0600 Subject: [PATCH 080/125] Set theme jekyll-theme-cayman --- docs/_config.yml | 1 + 1 file changed, 1 insertion(+) create mode 100644 docs/_config.yml diff --git a/docs/_config.yml b/docs/_config.yml new file mode 100644 index 0000000..c419263 --- /dev/null +++ b/docs/_config.yml @@ -0,0 +1 @@ +theme: jekyll-theme-cayman \ No newline at end of file From decc77d7557eab8d3def772c013c8eb6a76e83e6 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 3 Dec 2021 16:56:07 -0600 Subject: [PATCH 081/125] Create .nojekyll --- docs/.nojekyll | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 docs/.nojekyll diff --git a/docs/.nojekyll b/docs/.nojekyll new file mode 100644 index 0000000..e69de29 From 0c0d3d2194bf0ea37cd51bd14914447fe16e0b53 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 3 Dec 2021 17:14:52 -0600 Subject: [PATCH 082/125] Create python_docs.yml --- .github/workflows/python_docs.yml | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 .github/workflows/python_docs.yml diff --git a/.github/workflows/python_docs.yml b/.github/workflows/python_docs.yml new file mode 100644 index 0000000..7537031 --- /dev/null +++ b/.github/workflows/python_docs.yml @@ -0,0 +1,31 @@ +# This is a basic workflow to help you get started with Actions + +name: Python Docs + +# Controls when the workflow will run +on: + # Triggers the workflow on push or pull request events but only for the master branch + push: + branches: [ master ] + pull_request: + branches: [ master ] + + # Allows you to run this workflow manually from the Actions tab + workflow_dispatch: + +# A workflow run is made up of one or more jobs that can run sequentially or in parallel +jobs: + # This workflow contains a single job called "build" + build: + # The type of runner that the job will run on + runs-on: ubuntu-latest + + # Steps represent a sequence of tasks that will be executed as part of the job + steps: + # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it + - uses: actions/checkout@v2 + + - uses: ammaraskar/sphinx-action@master + with: + pre-build-command: "pip install nbsphinx sphinx-rtd-theme" + docs-folder: "python/docs/" From ec03a2adadbd01a58e33c51a3aea928e20723582 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 3 Dec 2021 17:15:58 -0600 Subject: [PATCH 083/125] Update python_docs.yml --- .github/workflows/python_docs.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/python_docs.yml b/.github/workflows/python_docs.yml index 7537031..a029a8f 100644 --- a/.github/workflows/python_docs.yml +++ b/.github/workflows/python_docs.yml @@ -28,4 +28,4 @@ jobs: - uses: ammaraskar/sphinx-action@master with: pre-build-command: "pip install nbsphinx sphinx-rtd-theme" - docs-folder: "python/docs/" + docs-folder: "python/doc/" From 5c541cde0864130644dda50f26f8cd720138a2f2 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 3 Dec 2021 17:27:27 -0600 Subject: [PATCH 084/125] Update python_docs.yml --- .github/workflows/python_docs.yml | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/.github/workflows/python_docs.yml b/.github/workflows/python_docs.yml index a029a8f..e691554 100644 --- a/.github/workflows/python_docs.yml +++ b/.github/workflows/python_docs.yml @@ -24,6 +24,16 @@ jobs: steps: # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it - uses: actions/checkout@v2 + + - name: Install Python + uses: actions/setup-python@v2 + with: + python-version: 3.8 + + - name: Install Dependencies + run: | + pip install nbsphinx sphinx-rtd-theme + sudo apt-get install pandoc - uses: ammaraskar/sphinx-action@master with: From af09de6225ccfbe456f9387408b04f5ec5a97749 Mon Sep 17 00:00:00 2001 From: Tim Nonet Date: Fri, 3 Dec 2021 17:28:46 -0600 Subject: [PATCH 085/125] Update docs format --- docs/_config.yml | 1 - docs/_static/alabaster.css | 701 ----- docs/_static/css/badge_only.css | 1 + docs/_static/css/fonts/Roboto-Slab-Bold.woff | Bin 0 -> 87624 bytes docs/_static/css/fonts/Roboto-Slab-Bold.woff2 | Bin 0 -> 67312 bytes .../css/fonts/Roboto-Slab-Regular.woff | Bin 0 -> 86288 bytes .../css/fonts/Roboto-Slab-Regular.woff2 | Bin 0 -> 66444 bytes .../_static/css/fonts/fontawesome-webfont.eot | Bin 0 -> 165742 bytes .../_static/css/fonts/fontawesome-webfont.svg | 2671 +++++++++++++++++ .../_static/css/fonts/fontawesome-webfont.ttf | Bin 0 -> 165548 bytes .../css/fonts/fontawesome-webfont.woff | Bin 0 -> 98024 bytes .../css/fonts/fontawesome-webfont.woff2 | Bin 0 -> 77160 bytes docs/_static/css/fonts/lato-bold-italic.woff | Bin 0 -> 323344 bytes docs/_static/css/fonts/lato-bold-italic.woff2 | Bin 0 -> 193308 bytes docs/_static/css/fonts/lato-bold.woff | Bin 0 -> 309728 bytes docs/_static/css/fonts/lato-bold.woff2 | Bin 0 -> 184912 bytes .../_static/css/fonts/lato-normal-italic.woff | Bin 0 -> 328412 bytes .../css/fonts/lato-normal-italic.woff2 | Bin 0 -> 195704 bytes docs/_static/css/fonts/lato-normal.woff | Bin 0 -> 309192 bytes docs/_static/css/fonts/lato-normal.woff2 | Bin 0 -> 182708 bytes docs/_static/css/theme.css | 4 + docs/_static/custom.css | 1 - docs/_static/js/badge_only.js | 1 + docs/_static/js/html5shiv-printshiv.min.js | 4 + docs/_static/js/html5shiv.min.js | 4 + docs/_static/js/theme.js | 1 + docs/_static/pygments.css | 134 +- docs/code.html | 251 +- docs/genindex.html | 186 +- docs/index.html | 221 +- docs/search.html | 196 +- docs/tutorial.html | 273 +- python/doc/conf.py | 6 +- 33 files changed, 3338 insertions(+), 1318 deletions(-) delete mode 100644 docs/_config.yml delete mode 100644 docs/_static/alabaster.css create mode 100644 docs/_static/css/badge_only.css create mode 100644 docs/_static/css/fonts/Roboto-Slab-Bold.woff create mode 100644 docs/_static/css/fonts/Roboto-Slab-Bold.woff2 create mode 100644 docs/_static/css/fonts/Roboto-Slab-Regular.woff create mode 100644 docs/_static/css/fonts/Roboto-Slab-Regular.woff2 create mode 100644 docs/_static/css/fonts/fontawesome-webfont.eot create mode 100644 docs/_static/css/fonts/fontawesome-webfont.svg create mode 100644 docs/_static/css/fonts/fontawesome-webfont.ttf create mode 100644 docs/_static/css/fonts/fontawesome-webfont.woff create mode 100644 docs/_static/css/fonts/fontawesome-webfont.woff2 create mode 100644 docs/_static/css/fonts/lato-bold-italic.woff create mode 100644 docs/_static/css/fonts/lato-bold-italic.woff2 create mode 100644 docs/_static/css/fonts/lato-bold.woff create mode 100644 docs/_static/css/fonts/lato-bold.woff2 create mode 100644 docs/_static/css/fonts/lato-normal-italic.woff create mode 100644 docs/_static/css/fonts/lato-normal-italic.woff2 create mode 100644 docs/_static/css/fonts/lato-normal.woff create mode 100644 docs/_static/css/fonts/lato-normal.woff2 create mode 100644 docs/_static/css/theme.css delete mode 100644 docs/_static/custom.css create mode 100644 docs/_static/js/badge_only.js create mode 100644 docs/_static/js/html5shiv-printshiv.min.js create mode 100644 docs/_static/js/html5shiv.min.js create mode 100644 docs/_static/js/theme.js diff --git a/docs/_config.yml b/docs/_config.yml deleted file mode 100644 index c419263..0000000 --- a/docs/_config.yml +++ /dev/null @@ -1 +0,0 @@ -theme: jekyll-theme-cayman \ No newline at end of file diff --git a/docs/_static/alabaster.css b/docs/_static/alabaster.css deleted file mode 100644 index 0eddaeb..0000000 --- a/docs/_static/alabaster.css +++ /dev/null @@ -1,701 +0,0 @@ -@import url("basic.css"); - -/* -- page layout ----------------------------------------------------------- */ - -body { - font-family: Georgia, serif; - font-size: 17px; - background-color: #fff; - color: #000; - margin: 0; - padding: 0; -} - - -div.document { - width: 940px; - margin: 30px auto 0 auto; -} - -div.documentwrapper { - float: left; - width: 100%; -} - -div.bodywrapper { - margin: 0 0 0 220px; -} - -div.sphinxsidebar { - width: 220px; - font-size: 14px; - line-height: 1.5; -} - -hr { - border: 1px solid #B1B4B6; -} - -div.body { - background-color: #fff; - color: #3E4349; - padding: 0 30px 0 30px; -} - -div.body > .section { - text-align: left; -} - -div.footer { - width: 940px; - margin: 20px auto 30px auto; - font-size: 14px; - color: #888; - text-align: right; -} - -div.footer a { - color: #888; -} - -p.caption { - font-family: inherit; - font-size: inherit; -} - - -div.relations { - display: none; -} - - -div.sphinxsidebar a { - color: #444; - text-decoration: none; - border-bottom: 1px dotted #999; -} - -div.sphinxsidebar a:hover { - border-bottom: 1px solid #999; -} - -div.sphinxsidebarwrapper { - padding: 18px 10px; -} - -div.sphinxsidebarwrapper p.logo { - padding: 0; - margin: -10px 0 0 0px; - text-align: center; -} - -div.sphinxsidebarwrapper h1.logo { - margin-top: -10px; - text-align: center; - margin-bottom: 5px; - text-align: left; -} - -div.sphinxsidebarwrapper h1.logo-name { - margin-top: 0px; -} - -div.sphinxsidebarwrapper p.blurb { - margin-top: 0; - font-style: normal; -} - -div.sphinxsidebar h3, -div.sphinxsidebar h4 { - font-family: Georgia, serif; - color: #444; - font-size: 24px; - font-weight: normal; - margin: 0 0 5px 0; - padding: 0; -} - -div.sphinxsidebar h4 { - font-size: 20px; -} - -div.sphinxsidebar h3 a { - color: #444; -} - -div.sphinxsidebar p.logo a, -div.sphinxsidebar h3 a, -div.sphinxsidebar p.logo a:hover, -div.sphinxsidebar h3 a:hover { - border: none; -} - -div.sphinxsidebar p { - color: #555; - margin: 10px 0; -} - -div.sphinxsidebar ul { - margin: 10px 0; - padding: 0; - color: #000; -} - -div.sphinxsidebar ul li.toctree-l1 > a { - font-size: 120%; -} - -div.sphinxsidebar ul li.toctree-l2 > a { - font-size: 110%; -} - -div.sphinxsidebar input { - border: 1px solid #CCC; - font-family: Georgia, serif; - font-size: 1em; -} - -div.sphinxsidebar hr { - border: none; - height: 1px; - color: #AAA; - background: #AAA; - - text-align: left; - margin-left: 0; - width: 50%; -} - -div.sphinxsidebar .badge { - border-bottom: none; -} - -div.sphinxsidebar .badge:hover { - border-bottom: none; -} - -/* To address an issue with donation coming after search */ -div.sphinxsidebar h3.donation { - margin-top: 10px; -} - -/* -- body styles ----------------------------------------------------------- */ - -a { - color: #004B6B; - text-decoration: underline; -} - -a:hover { - color: #6D4100; - text-decoration: underline; -} - -div.body h1, -div.body h2, -div.body h3, -div.body h4, -div.body h5, -div.body h6 { - font-family: Georgia, serif; - font-weight: normal; - margin: 30px 0px 10px 0px; - padding: 0; -} - -div.body h1 { margin-top: 0; padding-top: 0; font-size: 240%; } -div.body h2 { font-size: 180%; } -div.body h3 { font-size: 150%; } -div.body h4 { font-size: 130%; } -div.body h5 { font-size: 100%; } -div.body h6 { font-size: 100%; } - -a.headerlink { - color: #DDD; - padding: 0 4px; - text-decoration: none; -} - -a.headerlink:hover { - color: #444; - background: #EAEAEA; -} - -div.body p, div.body dd, div.body li { - line-height: 1.4em; -} - -div.admonition { - margin: 20px 0px; - padding: 10px 30px; - background-color: #EEE; - border: 1px solid #CCC; -} - -div.admonition tt.xref, div.admonition code.xref, div.admonition a tt { - background-color: #FBFBFB; - border-bottom: 1px solid #fafafa; -} - -div.admonition p.admonition-title { - font-family: Georgia, serif; - font-weight: normal; - font-size: 24px; - margin: 0 0 10px 0; - padding: 0; - line-height: 1; -} - -div.admonition p.last { - margin-bottom: 0; -} - -div.highlight { - background-color: #fff; -} - -dt:target, .highlight { - background: #FAF3E8; -} - -div.warning { - background-color: #FCC; - border: 1px solid #FAA; -} - -div.danger { - background-color: #FCC; - border: 1px solid #FAA; - -moz-box-shadow: 2px 2px 4px #D52C2C; - -webkit-box-shadow: 2px 2px 4px #D52C2C; - box-shadow: 2px 2px 4px #D52C2C; -} - -div.error { - background-color: #FCC; - border: 1px solid #FAA; - -moz-box-shadow: 2px 2px 4px #D52C2C; - -webkit-box-shadow: 2px 2px 4px #D52C2C; - box-shadow: 2px 2px 4px #D52C2C; -} - -div.caution { - background-color: #FCC; - border: 1px solid #FAA; -} - -div.attention { - background-color: #FCC; - border: 1px solid #FAA; -} - -div.important { - background-color: #EEE; - border: 1px solid #CCC; -} - -div.note { - background-color: #EEE; - border: 1px solid #CCC; -} - -div.tip { - background-color: #EEE; - border: 1px solid #CCC; -} - -div.hint { - background-color: #EEE; - border: 1px solid #CCC; -} - -div.seealso { - background-color: #EEE; - border: 1px solid #CCC; -} - -div.topic { - background-color: #EEE; -} - -p.admonition-title { - display: inline; -} - -p.admonition-title:after { - content: ":"; -} - -pre, tt, code { - font-family: 'Consolas', 'Menlo', 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', monospace; - font-size: 0.9em; -} - -.hll { - background-color: #FFC; - margin: 0 -12px; - padding: 0 12px; - display: block; -} - -img.screenshot { -} - -tt.descname, tt.descclassname, code.descname, code.descclassname { - font-size: 0.95em; -} - -tt.descname, code.descname { - padding-right: 0.08em; -} - -img.screenshot { - -moz-box-shadow: 2px 2px 4px #EEE; - -webkit-box-shadow: 2px 2px 4px #EEE; - box-shadow: 2px 2px 4px #EEE; -} - -table.docutils { - border: 1px solid #888; - -moz-box-shadow: 2px 2px 4px #EEE; - -webkit-box-shadow: 2px 2px 4px #EEE; - box-shadow: 2px 2px 4px #EEE; -} - -table.docutils td, table.docutils th { - border: 1px solid #888; - padding: 0.25em 0.7em; -} - -table.field-list, table.footnote { - border: none; - -moz-box-shadow: none; - -webkit-box-shadow: none; - box-shadow: none; -} - -table.footnote { - margin: 15px 0; - width: 100%; - border: 1px solid #EEE; - background: #FDFDFD; - font-size: 0.9em; -} - -table.footnote + table.footnote { - margin-top: -15px; - border-top: none; -} - -table.field-list th { - padding: 0 0.8em 0 0; -} - -table.field-list td { - padding: 0; -} - -table.field-list p { - margin-bottom: 0.8em; -} - -/* Cloned from - * https://github.com/sphinx-doc/sphinx/commit/ef60dbfce09286b20b7385333d63a60321784e68 - */ -.field-name { - -moz-hyphens: manual; - -ms-hyphens: manual; - -webkit-hyphens: manual; - hyphens: manual; -} - -table.footnote td.label { - width: .1px; - padding: 0.3em 0 0.3em 0.5em; -} - -table.footnote td { - padding: 0.3em 0.5em; -} - -dl { - margin: 0; - padding: 0; -} - -dl dd { - margin-left: 30px; -} - -blockquote { - margin: 0 0 0 30px; - padding: 0; -} - -ul, ol { - /* Matches the 30px from the narrow-screen "li > ul" selector below */ - margin: 10px 0 10px 30px; - padding: 0; -} - -pre { - background: #EEE; - padding: 7px 30px; - margin: 15px 0px; - line-height: 1.3em; -} - -div.viewcode-block:target { - background: #ffd; -} - -dl pre, blockquote pre, li pre { - margin-left: 0; - padding-left: 30px; -} - -tt, code { - background-color: #ecf0f3; - color: #222; - /* padding: 1px 2px; */ -} - -tt.xref, code.xref, a tt { - background-color: #FBFBFB; - border-bottom: 1px solid #fff; -} - -a.reference { - text-decoration: none; - border-bottom: 1px dotted #004B6B; -} - -/* Don't put an underline on images */ -a.image-reference, a.image-reference:hover { - border-bottom: none; -} - -a.reference:hover { - border-bottom: 1px solid #6D4100; -} - -a.footnote-reference { - text-decoration: none; - font-size: 0.7em; - vertical-align: top; - border-bottom: 1px dotted #004B6B; -} - -a.footnote-reference:hover { - border-bottom: 1px solid #6D4100; -} - -a:hover tt, a:hover code { - background: #EEE; -} - - -@media screen and (max-width: 870px) { - - div.sphinxsidebar { - display: none; - } - - div.document { - width: 100%; - - } - - div.documentwrapper { - margin-left: 0; - margin-top: 0; - margin-right: 0; - margin-bottom: 0; - } - - div.bodywrapper { - margin-top: 0; - margin-right: 0; - margin-bottom: 0; - margin-left: 0; - } - - ul { - margin-left: 0; - } - - li > ul { - /* Matches the 30px from the "ul, ol" selector above */ - margin-left: 30px; - } - - .document { - width: auto; - } - - .footer { - width: auto; - } - - .bodywrapper { - margin: 0; - } - - .footer { - width: auto; - } - - .github { - display: none; - } - - - -} - - - -@media screen and (max-width: 875px) { - - body { - margin: 0; - padding: 20px 30px; - } - - div.documentwrapper { - float: none; - background: #fff; - } - - div.sphinxsidebar { - display: block; - float: none; - width: 102.5%; - margin: 50px -30px -20px -30px; - padding: 10px 20px; - background: #333; - color: #FFF; - } - - div.sphinxsidebar h3, div.sphinxsidebar h4, div.sphinxsidebar p, - div.sphinxsidebar h3 a { - color: #fff; - } - - div.sphinxsidebar a { - color: #AAA; - } - - div.sphinxsidebar p.logo { - display: none; - } - - div.document { - width: 100%; - margin: 0; - } - - div.footer { - display: none; - } - - div.bodywrapper { - margin: 0; - } - - div.body { - min-height: 0; - padding: 0; - } - - .rtd_doc_footer { - display: none; - } - - .document { - width: auto; - } - - .footer { - width: auto; - } - - .footer { - width: auto; - } - - .github { - display: none; - } -} - - -/* misc. */ - -.revsys-inline { - display: none!important; -} - -/* Make nested-list/multi-paragraph items look better in Releases changelog - * pages. Without this, docutils' magical list fuckery causes inconsistent - * formatting between different release sub-lists. - */ -div#changelog > div.section > ul > li > p:only-child { - margin-bottom: 0; -} - -/* Hide fugly table cell borders in ..bibliography:: directive output */ -table.docutils.citation, table.docutils.citation td, table.docutils.citation th { - border: none; - /* Below needed in some edge cases; if not applied, bottom shadows appear */ - -moz-box-shadow: none; - -webkit-box-shadow: none; - box-shadow: none; -} - - -/* relbar */ - -.related { - line-height: 30px; - width: 100%; - font-size: 0.9rem; -} - -.related.top { - border-bottom: 1px solid #EEE; - margin-bottom: 20px; -} - -.related.bottom { - border-top: 1px solid #EEE; -} - -.related ul { - padding: 0; - margin: 0; - list-style: none; -} - -.related li { - display: inline; -} - -nav#rellinks { - float: right; -} - -nav#rellinks li+li:before { - content: "|"; -} - -nav#breadcrumbs li+li:before { - content: "\00BB"; -} - -/* Hide certain items when printing */ -@media print { - div.related { - display: none; - } -} \ No newline at end of file diff --git a/docs/_static/css/badge_only.css b/docs/_static/css/badge_only.css new file mode 100644 index 0000000..e380325 --- /dev/null +++ b/docs/_static/css/badge_only.css @@ -0,0 +1 @@ +.fa:before{-webkit-font-smoothing:antialiased}.clearfix{*zoom:1}.clearfix:after,.clearfix:before{display:table;content:""}.clearfix:after{clear:both}@font-face{font-family:FontAwesome;font-style:normal;font-weight:400;src:url(fonts/fontawesome-webfont.eot?674f50d287a8c48dc19ba404d20fe713?#iefix) format("embedded-opentype"),url(fonts/fontawesome-webfont.woff2?af7ae505a9eed503f8b8e6982036873e) format("woff2"),url(fonts/fontawesome-webfont.woff?fee66e712a8a08eef5805a46892932ad) format("woff"),url(fonts/fontawesome-webfont.ttf?b06871f281fee6b241d60582ae9369b9) format("truetype"),url(fonts/fontawesome-webfont.svg?912ec66d7572ff821749319396470bde#FontAwesome) format("svg")}.fa:before{font-family:FontAwesome;font-style:normal;font-weight:400;line-height:1}.fa:before,a .fa{text-decoration:inherit}.fa:before,a .fa,li .fa{display:inline-block}li .fa-large:before{width:1.875em}ul.fas{list-style-type:none;margin-left:2em;text-indent:-.8em}ul.fas li .fa{width:.8em}ul.fas li .fa-large:before{vertical-align:baseline}.fa-book:before,.icon-book:before{content:"\f02d"}.fa-caret-down:before,.icon-caret-down:before{content:"\f0d7"}.fa-caret-up:before,.icon-caret-up:before{content:"\f0d8"}.fa-caret-left:before,.icon-caret-left:before{content:"\f0d9"}.fa-caret-right:before,.icon-caret-right:before{content:"\f0da"}.rst-versions{position:fixed;bottom:0;left:0;width:300px;color:#fcfcfc;background:#1f1d1d;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;z-index:400}.rst-versions a{color:#2980b9;text-decoration:none}.rst-versions .rst-badge-small{display:none}.rst-versions .rst-current-version{padding:12px;background-color:#272525;display:block;text-align:right;font-size:90%;cursor:pointer;color:#27ae60}.rst-versions .rst-current-version:after{clear:both;content:"";display:block}.rst-versions .rst-current-version .fa{color:#fcfcfc}.rst-versions .rst-current-version .fa-book,.rst-versions .rst-current-version .icon-book{float:left}.rst-versions .rst-current-version.rst-out-of-date{background-color:#e74c3c;color:#fff}.rst-versions .rst-current-version.rst-active-old-version{background-color:#f1c40f;color:#000}.rst-versions.shift-up{height:auto;max-height:100%;overflow-y:scroll}.rst-versions.shift-up .rst-other-versions{display:block}.rst-versions .rst-other-versions{font-size:90%;padding:12px;color:grey;display:none}.rst-versions .rst-other-versions hr{display:block;height:1px;border:0;margin:20px 0;padding:0;border-top:1px solid #413d3d}.rst-versions .rst-other-versions dd{display:inline-block;margin:0}.rst-versions .rst-other-versions dd a{display:inline-block;padding:6px;color:#fcfcfc}.rst-versions.rst-badge{width:auto;bottom:20px;right:20px;left:auto;border:none;max-width:300px;max-height:90%}.rst-versions.rst-badge .fa-book,.rst-versions.rst-badge .icon-book{float:none;line-height:30px}.rst-versions.rst-badge.shift-up .rst-current-version{text-align:right}.rst-versions.rst-badge.shift-up .rst-current-version .fa-book,.rst-versions.rst-badge.shift-up .rst-current-version .icon-book{float:left}.rst-versions.rst-badge>.rst-current-version{width:auto;height:30px;line-height:30px;padding:0 6px;display:block;text-align:center}@media screen and (max-width:768px){.rst-versions{width:85%;display:none}.rst-versions.shift{display:block}} \ No newline at end of file diff --git a/docs/_static/css/fonts/Roboto-Slab-Bold.woff b/docs/_static/css/fonts/Roboto-Slab-Bold.woff new file mode 100644 index 0000000000000000000000000000000000000000..6cb60000181dbd348963953ac8ac54afb46c63d5 GIT binary patch literal 87624 zcmaI71zemx*C#x!Tp zndIaoGr4k-bN9U&_Lhd8SbF`U&{aS5&tGC24eIF6>x)sAOb&v zfVhIZGKkgz05Gxu09p-Ln#TZfWmRDSfawxMKLh|EoVkQZ`Q(-Vma{B@>M4POeg`;B zkdcjnJpjN;2LM2A0syd<0h`_}My}4p000*vh=&mrIB6Qd!%gkYY(O+#0043i0Dy~+ zMDP?cGjIac*g%2((WW-Z z97F_wef;$GNYK zfxA5bOcYe@pSr|Q_wavg4Qxz6G!PGXCa5nlCp;7+_I6Ir05EaTdqH{!{e&2vHVd-7 zqY0?4Du@P%1cew_u&6xu6(fCPef=#1e*gtEa_Fq!$Vh2VDfAaI9A$rFawGD%3Zn{` zgy^VfK}VWhXJU_#D|iSpz)(AE6ae79l9T`z{7Dgec+=K{^=9K?!wUkQ%eaTrpjIC> zLC8Nb@pFsd7ck_Sk!=816dlWeVYWSNRMZzZ%}6%bZDUA)+~NZV;g9^cr|GFKyZe`} zidYTZm7dU!k6>K<5q`*>Dao$Y2>XfSh@4lX_chMROUufP07Bu;w~|>J@*~h z8aP=_3{}bwwX%57OdFGJj?3eh?_+r|_=znRWSa|kViSC$RK)Ok@HyQrquqh1QhUm2 zD#axlDzU|}+qJuj4PN`wdW1Q8w#UyVncX4X1;k;KqNy&nG-avs3m&sQqsS_7#K?e| z)9F;OQ!VEQ%1Qf(Y|eN+2lxU}?rMDt1nhIO>18ni9TBcQ4`8!U*6eXw%5OuafEU=M zwS%l$`22YQyA8YF*h3ZaT_6lZIAm*v7dFfhg1$5=H^f)z%E@iat(7w-QOoT{3(4)~ z>cHV9nMzvk=|x;0r~8FU5u%2{?xjU`UU^#WHgM&BANT1*`K1sX!83!8KiG*V82yx5 zBx8pm+K>F!(2D-b6Co81jUK2|S8E@zTp#2Ufm(hT5V@_Z#HZsaf1oaKyOv{%w0H5_ zF}kq>VThTK0kHmIOHDSb|MS6asI}pF(lz)h3>i=(L~5xZ5%ZO4hJ>e&6bqi1`$qxf zPTr?6Vz4nNi~<%Q37jRQ@=rM?^5Z;yB?B2Iqyy+#Lx?6~f+hnP79({gynD#{T|p)o zE{8-e&8OK-0s?8KfNj9tEK4B8RC$x-Zs2hl zAp%2Vnc`G2)ij&Z?P;4h& z%<3zlRmIRw#E=zlj%7Z@PCA7ZOO6$=cqgRTid)aJ*mNh^)QV8gDgbk<6Vn2X|4&Ik zY*WE@yAd}X`%_M8*u61)~Lr`Cu}mS*kN&o^z+?JT)oEtJwN%`de{ zVV>CI9!cW0fy3_Tw4QBdHKB)(uvSlLu?{uzk2GPAejn44UHjTur#xN#)V|xzS;r{v zJ#o#?|rTB2Nzj~0wg0)B;Y#eq$=S|I=H05;jlVrq)OouufyhCVv;G4ikyye zt9q-1t4$@If8|ZvNPa&3zQx9AskF&!-ihX(=c0qn&$u%+orBbFAUaBYypyzpbOL_c z*PY#7AjL9BvkGHSftjR&+ZpD8JnlJ%7|jvtVNhYUmpHpEvYE-CD(rE+XuXd|Z6hJS zvLj?n&L%}=GSS(ko?AI{$pWil$->0!=c5EonyH#sgUWN`B;tY^#&}h{imd_c1B(QD zL$vZnQa1XCB`RWbX7Y;dLZFM`?oO-fi%eE<8YCS1DAQN>V61MQONDas4iiV=ysO`y zPFV|%GlZ;SC>gCNUrg>lX8F zy_yfLhE{;u%TviO#PqKJrbQVu4`B*EUA6-0De%WuSFgR)+}qiuLfrYt)hnrA~eu9CPLJY7CI>6paS zWnopw;$U)dp^e}K+3}Y&a@*xhfM}R|{p`3LBacr-0@@jdb$DYK?&I$w^NSzRrP_ObwH`u$VHUzG=(mgYH-8BkFliqhRIf0BGd z#SQg;0fKNb#@807bm?Drgy!lpM{LR48+WFs5(5dCRWWRk+F6%u!UC!_e|G-NAr_e& zkhjKs_ucr>s~%Vl?bq@7jQ0$36KTUBuL?@_DYrCJsOXJ$Y<%D<#UD9hAiKhziB?l{ z+@3`ziu0ITPg|%c2ncA@g=VtiSPCbJ6n%WEhX-?xw^!rQv@vT8nwRq?U+&teVHix6 z?zsBZFV{XuCaJAy)0DX&{jBMtI-uo7(#+pMpP{GQ%-HqM&}N zunOPt%jUEFRew`XR|b8$R#@!TW*RD)Lmyx8k9~^#iXhmW%OvI9{o5gwvKwbxO-Pr9 zrHL8uC0;lh1-W>*+wP)oZXv-n8PSUr9c@>~L*?3tB`{h`R5jcBC;`!sC*ay}P3YF- zOHx+}f^xY%^qt^rl;*2M-0sVu0O`#xK|d|V2Qchx2z-oqKg=uf{9PTB-=1CMHOX}w z5ik+PI%J9ATOLj_NS9a6sqdVXRmc$`@|{FPde3Ld@i=>DCcZ9vU4_8Pt@60L=3{Ddonu+Kt8=A&#Vn{1Ypkd|)aXDP#76Yobb7n%}Flnxrd9qH4- zWI~QjPwDfrhjA9no=4E%bL6QaE@56ZdTHg}5v+wEZ3?%SxQv=RuOi0^w~E>&huyhO z<&aJvb9)GNqf>5R2$CP~*2xmZXFtOc67KBLCroJ-^HXR(Q@yh1Ym~M$BF}dXymZb; zk>B~hz{vA7M=mt7RyFZ=*!h6O412ly#z@538Xo1Q%QXY_ zis@n>*p35+Jl|D=G8Wpv4CII7V^V(+HiL=1WJu)d#D2=;A^ULM(34*W-VzRN^APY1 zkhD6f&96yS+dXkE;QJKLjtK>wH@ItlmA*cE0+Tn$X1zfoxOK#8Y4e!KSQ016l1FTS_y;IU~ zH0H@KQe66>d{J0yJF!U30V2p|jjwpP~RQcZ^;^$KDSF(j~Z6 zm9$oU#i>!atd#+3?Gb6T65}nLkV@-?ZE6^KF87fk5twD`FPTW)uDAlX;VGsO6izN0 z^Zi9Jr}G(4_W~ix1M(=E*;L`Y@`9b|Z2{J5;X$4yw4?MBL<>5=7ipHZ#He$Bqkw_h z>4)%&V#x$ZWi(mi=BQKlg!ONdCONiu3p90^w&(fiDJNQ-2N{i*E`OJRb7xXANuFPP zVjbTG#N|@OJ2&oQu6BsxlSt>6I9Z#v zu$#o3+v4i?$vn9P%7?nx1O>)%-!huKh1e5ei4WyQ{69$o*73?hEi4^L|PM6o3OZtv{obc z&^9FkXsSNueb?fEWGBaqZYg-?9Qn2HM|E(mEA%4SDm-WRD+CQ*>BTHu_sCe zEtvvN11~9xQ;IPTSwyAbnKP=K5s6$OK;z-+S*|Q88@U2xmolu#**gnC5nKlfGY9rV zdxpco&ZC=Fe*_EMZh4N~d?JoQ#(VzBeWE?`x)AH5mQ+t&+GVY#cpDR*Wj)tIR^67U z@gpgY)%J11x{_0J&>yI)?jUKBh@B%W@(Jru-XOn7F{-F=h%yW0k~4%?PM?xFNV_3@ zQBO0A%1qcBMv_GG(4vz&9`2MBS?2W3&B|N<#-pA?r2R$qY_ZR`(%eS0Df&C*ne~Mr zCAXI>*0SuqQO#R*?R4Wkk>x9HdeV}K4-Zj$_{=(WXD)GN$W#jAL$20vwPD&q*& zK6rc#Y2OZv}J>(0U_y@);yb6iiTJo;V=z!?!ju|Jm2_o zeZI|odXun6**3LT8a}ZYBi?#LNzbO*)~oWrGO0CemvCPDZ z1(^{WXJFJ+&azKH<)Mk2kSY^ zs_$-lh>7D>*`2%tSFhX~ToY9-EVe&G0ec~2T10UPwF?%n|KQT*k>M1Ur@yL($D8Or z)F&&Q#7w$_DuBlT{iTg?5>b6 zYI7KuM$~c#OI*9xvk7l^EQ^^VO}s~>Vp=v4zEY&#-xi|;?RGi;Uw&cd&HLDA)S{sP zLl=9j5^2bH^Z0$FOIYKAE;p%JVi&ebtG%nIoo|6Y?R;51!W5 z4I~R;7{UWIc#X+n?>@7NeJA#h*Ynkmm!{kFtik21{?@1+x$~ISgwU^f5GXgWP!$J8 z{M)Px*Ib#q><@;GJ4AEY*9kVy>MKsQ*YWO{TclTJc(4wN8)>!f7IE>_Yv%VIyuKyAL;H1Rq5w!h1 zZ3dp0Cd~Z8wS`U4=kabMC9TDrQ8r;rZ8iB5-o;#yOs)j(4EtM1y2|z!xr0x@nFO_l zJc9Kv{y7B*P}H^thk@Ac1kxpe%J z?z4G+@&$3N#InXh@s5(_Y-?iP@G{mVb#9muk>f`e)PcufO+CCAn~ZE{Ev->nohPzA zlx4J+d{4(6Tz^d`8ycfJq#EX&LaFt5Ce3hy`&{dh@GGeoG^PiaoHrUhiF7+SIVQ~0 zH>A>&yH#=faF(iV9xT895kg+G`^8ri?7pvWniK3zG7KE|c{-ysM&i7YaB~j>HMJ8( ze4R)A`qw+1W!|Bzf$>**n{P1x(GhyQas0UmEpf$HIL07TCx{)F&2+-ZVT_ zbJ&9`s^g||GWesGPnS(}}GYKk(r;UoZ) z6}B*CNMKeQ!>V>1^_kNMYD%T7US;bviJKM*_+9+&q|}#SzPjMqMWs!pNLuyZNU#V& zr9x#;O7*`*f{jwD<^Mz~$?z(rf+3(N27X>Kj~l4`lLiW?@Dm;sZDAxoe=FiwER$C` z{$I&0jL(nXpnBU7bLy{~-PF{dihLS7rkY4z?-{IG-#0fb=IXmH;zbHxkdNjUUgMpWGnm6Db@C4DYp!#4C1!9gGMp3NT0*>ixyB&R zBxMYWeQVdI!F;)%Ro|}{f`JXuqP|wL4sR=XI^7eNshR|^B72VTHjJc3FKW5BCy&{h zgqL2{Khn>yGb^a(19;`vZg8ex#fI3D7dg~FoLPqk@^3kZSXUqMjjCKEi8JvJ^O~$r zfu4C|O);X9ct+WGAAh_GGEc3%1dfh;S^NXm@JqflV~^LOT`i-$38<-)I@c6fQ!|L7jN(7}5EZUu~;6m0s| zrqi%14?Y3i18989elP}u(YTUBcw`E%E)Lcyd||y`&hJze?Y>9!iamRw-X<=>&yOm= z-wlQ@DZ^q^xOysESRvT^Tt}%s#A5bSlO}gNO5fP}0I?%(O7+U%pOrD%9{)45wtwNHWt9ByY zo#Zu}_4iV``Kb(@Jw=s0MVBiDCJ)AHe=_0#2>gu;zkG_XjolPWw(^XnH_Ur31cU_kp_LQ2fz5B%l*`Fo_a{Vnln~e>#6}#BP93D9^)@Yw zs_(KRF#8{kXQ0k?VWdZOhZ(ok;@p?LW?r`WB-t;yUPuy?5@^R9xW+zwEeoz3d z7Qf&*q3C8uyY&O+I}-wQO8P`JrdFRrny_lcy#&bd3zI~W9FmN(!Z(X%T22(7+>|RD zc}8fBryq5>Q;W}IGMHs}{tl0fHwRzL)dcfPo9Tu|Q_Ka$StHMk=7)S8?Rvutv&4&- z?eD3>4@-f8e?-0QA5lj>0lnd<=^LeaPK`exYra?Nywd@yzl|yr5%c|Cz4gGl&=Hg!_dL#Oj(iKoa^q7eX z11JO35!+{3*s)a|FVz})_8NO$wRx+oeV3~2W?T4PMq{eNZ1k3_;YYskJ>u@6Q_8gB zANpPM>R-k)wck-cOjVpy@0y36X&c|Wn%}$Bx1;{asUAg1nW=Cay`3Q&^>gK*W|er# zT1e8qqBO8xRv!Cdh@HrT6z*v|$aqGu`Ci^B*Dm1|c}tImJmUCKoe9rXMswZ=9ObUd zsfDgXE13;W8Cn@dzLt7Hn&BrM|BpUXX{iVHNoGw@s}!Y}m1BiuIXf}r71jRl769|r z>OZpfGGP*b1%H8|%IMCX8JtxZ>e}RLlX2Yq%TDy<(Pn0GN#AJkc(cMUvm={#w;*bB z)clP(s-HuWW!~41nLm?@cZwJD@=K(9sF~)(O~;6mnrE!4_W&+`QJl-C+5p7Nr9Qoz zC2_bZ*?kV>kk@ivwC>3DO^!f#`=^%K}HM`PYgIBz{T zbh0iz^YfaVr5Qy>AmG#VuG8%TzP!h2XycLB-mtJ>hWFO>%rT6T0I~%>zz7?CNE6fZ zzI)u&`w)>Qd7UxWBdh4GPh7pl5wvRzZ-x{%6n;Jr7k2af6cF%IQfB&RVWt@D~I23E1I$WZhcfCB}R>nOS&Es=nE5-K9_M6eF zT&nEIye;MG_{Ob4+`ImhTdnl5t5oSFpH4_3XS#B!6yGN2zj)AeEuBBIo-53Wi}74C zcN$7ZVzz~PJt}2mSE<^9Tzj0ouF@LRPKN7M_`wT*M&lsm1pq8WMDeJAh z(*GM=yIldV)+JXTkKG$~jDG#*OCyjN;#jFeDUd4a*tuvI_kAR4jf!J*vdJ!9`>y-? zse7BJsXlT2G;fLb!O0)~h7T=w%2NOA`$Z=2ONkXFfk@>qNe1S7^pKU4C{;byeaxoN z<7Br*7;DCd$xQg=GD{7cvJ~g7F$G$e0S%me{C(`mmEB2r_@ z-V!O}rU|&lgq3UIZt_gr@(wlJ6Iz&)O}ZOwTkE8EkX86r`bNo;KCCjXN}X=-$~e(9 zjZbJsh~S+cA6lB~Odi$ymkLx%lYM*3ktvqLU%bYH zYYNFt4tY|C!0QBsQr!W05G+<%Gsju%-bEglutKx9`4ter*<0VTb3(|c=6Ruu=u-!7wkn7h8 z7c8(wqt^NsS}5_uy_Bi7#2!v`aNIJEkXhGr{x&{LVA@6oXPk)fFTYXKY9jly&)p4n z)f*sog*|?B;@1a4{jMJCM*L|(uwykJrkg30BPZKA+YP}s9qXp)LHUGdrsf6HiH&LJ zScTgw?}=eO1N-0HWW^+>E$gn0X~!g@`WtV%jcGFt&J@I}uUh$pWtisY%u#k$O%sap z3FENzPhrodiWRP5lle=C_|eF<8a~J+!z2Gp&NX*VIAi6^g^kAQ38R1EuGumn102N8 zf;~AzD+wW@-8kPTtBchCrctz&Ewr4V_;weZ8Tv=eILUSv3K`ChMu>KM_dseRs3jh4 zh;Z+(%5XM4CQ32EUyO0EQllZ905Vu5oISp~Q86H>wlbuIkkG}Nls)ean*3{OJAe*L zHQR8UbY}5p(`|1H{B%-4BhmclkTpP3CNJ#`-#)5B;hcIU$R zMVs)BsQ=Rk`mLODM}2U~##|63KF`iGZ%_s1mVy4leD(Z2@h$C2{6 zqMjF}+wgp{d?Vf%MZ@elG0!LiV$pROTepwlTaC}qnE0OGzJ*J`o7xR??j?@ZQ`RQ` z=tjkbg{%9-Qz;J6F+{KV(f5xWis$wRU;q5|;$hng2t_--C0`4!mCjt0fS0u>Ha5TA zTB{5E3wTEn*p&Yo3}hmc&P`JL_B4%L(cE)Idfo!MxzJw=(LRPg`rn_|9t^9WAn04> zx+*QCy|`!68FYsBor`$*j%2_4-uSf%2tfFDUw^pL=7LF=_uzPg(jGjcV~0K0-*X@q zWk7b5Rersd_I|zoUx2|AwK>T53|c%;yt-?z(Vkw+`Yv8VSJNgMKQJcDNaU}+e)I@j z<1^L-r@Akn{4W51MfA3L>$%#kPnLPtJhsUzet*`+oOOL;HxyKsw8^ea;LubNN9nzo zWvR_!1^nV%0@K-&VKHHdLsXXlk*CHJ3;2=DCCC_x z{txVgC!H{BE>79Tl%$O_#J4v57G(mo%Jz6kYD`Go|Nnp@sgOm_u40--o#d*>i!c(p zlC_e$zFAp|A^c=p8MC(EvDzblVRoO&g%;i473~e9c5kud0){rXi?Kvw^<$z$>2(t0 zag*0Y;L(oP#m!{fO@94Om)7rNZ+%(L!ID?!$tDL*l`npj?5~MbSc3nC<4-A^{84>r zLsiV{yY;w9LFOJ;_RPBPK+_;UfYR~NoV*y5Z%p&q-B!n=Av&gsIa&NK?2+(ee8cJK z@jIBn)!%{-{4>{N6V@1*p=guoa9sMsDpTm6Q|zV1)P7^X4?;?h4^!6`r$`7JrDAz` zzfn#`GZ$)VQPD3j=er2UyReq%hI;y_#TggaeKCWw?m}5#a*jt1u^G6`Psn)DEDcS) zO4n$2Xbc8-==65bD28-jj3oVg{7~qaIW}JCvwTaKq47Y#aYBw6aC*p!H>9|#Br&AV zR=zoLhRD~QuE$aRZ(rhSc@D7YNfc{V#z`ENUP^-jPEX#fN4jPFjQMZ2YrUGR z1MPj6pJjK$JBW)1$;F_6PpkYENRf)e^y03{l0kRagIX zeubVE=Zo`?#?$$`xI|*`jCGx8HwY_7DqJYBgYAT;@x{9wSfb=r8Q!=;SRRb~N8p;} zKEDSogq717k++(ycA#drrgsT8rc{ictlGKAmMD3L>-=fDB<{SPdKDReJ1dmoo(f52 z0dT?nWKuFq`6&2{WDDACpGUq&dqPXd;e<{_#k>nXlIidd^O9nZthovvG%H2?iKxT( z?6AbD_Q)mR%!ps`8pMbm7$9WZ>EdF$`L7rpn%Y@3oiPn8H^nn&8jRGtaXV>Ugq5#F zG#@@hf7mPyg!}10d71XbYZ61E)qMM!K%xsaMJ0sOq0n1M+auo=D4?au#QiG*)wux6 zAg;=vU@4jk-@t*hcgG=y{14K>HyxAFmR==$1h@DfFLW3vnwW(3*1RTM?o*Ce3H#e@ zAe!V&O;=%1y?X_6#Ws8UN6$QAR{@`ba%g?RpeC;P1*#Ws|uD=b_R9Bc~@ zxABJ=VuEfW&bLPIx!3dvX0?#WI@PyEcnVxmgXXOao*wTFYopu*<;N-@TeM$@j}bQ;K2hj0MOP`2v_ zoCcEDA*75kXppq)7o7&GGDRzCu=p)8`z_T2IO_nxED#10=-U(EXcO?i!vi8T7El}} zkgqCG(Boh+BqzW}D;Q_e*;q6LjO*S<3}Z%2??()fM@;0X3>c_PY^jW@O7+i6O$k9e zeSVo~lo{!n>|4>u2SIWNA+`sRga;vd2PLX41~B!#45oQD?iP52E1{W9Xr(r3E1`V0 z%oxq-1m{c`Zt3+4hL-fj3+Sbdke2jKT9MTYJH?HV+ZYIaW(UQSkQS^$I+1w1NN)WE zZ%8N%!;#|=JFLIOzFJ3NSBINza8wt{TpesBImFe( z#+!xT=Wq)@&I+!dc%}JeYGBI6dexOgOZ4<~XITsr*Yz!=dTPmRO@e|DeL5VLLP(4* zKw}I(Y1V+L)bO)%sZoZ-Tv$}X*UaT8MD3*jI-cbqaIfVsd>GCx{xHrx?mo0d#Te32 z=9s)3IaX$Q`@T~djGIp-6LRd#)AmEB-WVg|kG!M|_Fxtaj=wtw$ZuFuCuwzuDrI79zZY#UZ>| z^6ta9p_ZRC9_uTT3!qb}F<{}lTQzFf~9F|^Moi;*E%F?zXS zCZ$|D+fW?8P+`hf$u&t*{7(eqh7(+Q5bTscY zHQ%wPv|(RxK;LY+aYIbxar;J@& zJ2dFap_C|1{8AEtwjXVte6PSfx1Ya@-~)!eMc&>$;xnb8n;F0N!BHevC}8UR3UN>zvy~$n;Aj)N?>07Uu*G zgUg632*7FbA>GKRLw~J6bpYh7BUAaxC>Rk70YNFIQLh64CnO^6( zIpsL3`|AmpPg7y^iP>tv)J9v;X1MWegM0IQBAV+-J`Q6K^gy@ny>(0u_->dA_+(O( z6q`Y&h)XcUg~iLGDOi6_(nwG${~47bNKaeTBt(EvChhYx;H_)z*AmOuJg#4T!dkcu zb#V*OHguxe<0aYqzc%WQ^hKQ;9Jw{mb6?g&as(NrXIFosyoLXjB4O4pfhaf#g=AT(9inJv;j_mEz>Y2Q|CXb7C}u1j;TF@o&r8jXWS}Up-)~j zCak7CfE(1P*2B#Xz^hD>#jIPFTJDq6PZd37UoryoT1N4c+94kH-_0W4DeR@D-TG?g zU!O9~g}`OE6WA*{eu%E_U#>RAW((kuU8_U4b%JTJ3R&9)yZp7o%i?aG>|uDBWH#Vo zJJ_+6{9qNtfqAvC(@~Fo@wD|8FW+Mpc{8|GKKL}`7KbK@KKO%LOh*%5Fi%+6gcfD* zzC;BI2oU`NyI)5l&45?;Sv^Y-jvO{w1wBb=jHmKzJjzCpu`zAGrA+t5Z+PCHn;Q8cQD z9kJUfpV%`;=~+S%W-x#}juf^Z+V9wJ(7MeuaOA-KgALlMLc^$L=zmWPcsLL`W)U5h zGlnC~VGV^GNA8f`4La05C$xO?vCsi_(b?*4nCU5P4OY>da;K(gM}JaTx1qJ5ZPM9T(LCm9rD>OZw@|l1b5hAc7&{DxS7p;r zj#stLw00Z1UHoCkc^7$wj>Ll^w5ksSi`yWiFx?VZRrTjf zU8WuFO|a5-B#=f<(a99S7tXWwS0iXY1zIhXa!wfZOp%${L+hWB$2h9+4Kb^v5OMXw z-4#y2WZKOg1WhhZ7j%a5icJM&r+U<7!SFDydMKZD#AI_A9)8XlQ&!aWYPdfRy-#Rd zY`p)`sD2}p6Jd}u=mf|acT!yS8+||7hw1>-fO~nMF)ED*9!tB!>7zB#_Zg$fZ6|lY z*C3QEh5XbVIVt^I;=*Z2V7f7)4LGT}WZwwQXud)2QR3}WlIh5FE4U=w2%7NnAkybK z2qjo;GO8mm;BmDct~!IA%2&(B+=D%Ir>7AI9*)M>kRf0>py|tETGbiJy0&J~f>rI% z%;`+dAG7HMt&B~mQMBfq%!3>^L-1PBmd`TQeBON}nes~GYCJB%@?P6CmB8G)8C6qNfs4WN zJ)rOJarGzFw>qpErHW@&MgtSgyA!+I8UOos!y+YPUSSDg8Q{ zG**gjt+T-q=Kmuh`2f)~G|A3jvu3?J^Z%b{P1c@YZ9xiIZPo1z;+f-VRql*zpCh^! zF}6y3O(QB7*rudPaTsT*qT5X|(Q)8#gIMe5JMLU7-x&5eep{>N?}0cD;w|ML5IOGW ztyq9ZOIBTP0w(^?2%|dz*lYJhZ@G&5nllp_!j~*?E#5PAzO=0S-uIm;y8Buk(r?%9 zc=L&;?>+QQcXgBCr9G2W7D_3ZW{#ah$?jNHdgJ(gu9{E+;*VsI+Ohi-LYYAa>BgVr_ezF+Ga?CQ9Y1q8aiH9MWxQc0 zx?vNzX$BxP5F<40VjAXQnr>qn#ABLJo)%`;&AL+L>V7|~$V$9%6k-@NX(d(P&(KN5 zb5yn+wP~e&*z4kr3%iyeT*Uyn-|w|{#HFIsGo#ZwpfkcHP)R1xQ76z?TubSV<9X0t z>~(s_#a>JDk7GSqZtk_e#u+gs341gEei4#wMa|CutcplBulR7U3fKfOtgLlwmfBYJ zE1C`13B0U}>4Tap8&o+htj>t#u-w0I@#UDjXXI;59hKxUNja8Jov#&lVo~WjzQ-Q_ z0HN<|G@={o+$%2Sw6U+)u#`zqbyg95YmiclytQLLgZDCy3e7=YDm~akEVw{nQ58{< z261u33DqNiVHrafj5306dADtCDi40jXcrftaW>L7Z5?a~3rG$KaKS8RhJYyG4L0o> zi5nX5MUuv;Amn=>J;;WIY&;R`DZQ;kNgEuh>8 z9B>kis{2=VqGBOFtxJ6poz6~IUzMSJ>i#be{C3?^o7FLCoAya*JDbx+SI!l{9;H!0 z4`dk_-1B8s;2xMg4j(FHBLFryG{QD5fL!CpxR`WR5=m}O35d^fv>fA|*KxcQ@?|YF ztz+ds%C&&4$ED9@BF7DmbF4&9eNUvg#>O1axUo@`L*<;JE)oQqcq=nk&hXhaMCPS==>GO03P_=zpXcgEg2INif8f+D94i9{r?_yBA(|5dE z$_1f=(X6cwI8FK-F6nmQPk_R7IGVL{bQw$8pi*dw~1y4k5-~5XRi^Zq2(d z_9vVhxWLW8Q9Ogw{dMYKXmFEF?R^gWJ#&bg2sZ+6(~+#Kbc400T}HH%K52FpQ302o zD>F@YWXNo{rWosYLCIL#R_WZu68fk z^X2&rVe8D&m5V1Vd+279Cp{MdusEg{>Fu&OpQ=u)>*LE7tc+$a#W|RrFPB4Gn?} z)aqZIrOycVDXOun7P%|nSP|hB8hCH+dV&Narxx-@C$Ih0age8qhA-9b)lxXvBHMnWX$3- zMY>@Ij%j+LwC#bWemr@~etha@HBF;zB=-HpTpQOVlUN_*PYQ7&F`Ng%${`iJii%6X zANE6BSUQe_jrnW#;{*@9mm?U{Kd7e=synWxU~;{w^S*4pUXBxea3(3?auB{k!lKt@ z%vTO$;?(Vp><)xr<-*g$B z-Ekj^?*YGodmEGgkmP+CUnj3ps&tdijr867ZqiNQ^)`}%zWXgtHjIJK?}%0Z4-wgr zOxp8wl)R@@DU^R7Q`^VQS^xMNWSxx{c(W2$*l#c2mw2&QRw?($m+w5nwpR<tdPs!! zX+}9vY{1bEudIyuo$fc3=C!BqA0=ujnuZ~&3mRr3HkOAuFilHpVcg3Gix_;8x~Cp2 zFZkw4$~ni>TDuZ>E58}|ZndaTSwR!^luvVutLaT<`ec&coCHC8ARp7~3oIcrKImeZ z|Gu9XNU24?4O{F?wxi^BdB0qpOn3YLjH?MRO=}4*OlpX#$m$5pPpJC=%xDWOPHBp% z%IONoi?59+OK%M+N^Xp<%-NUV=6&ukAnED!P&9AiT4r}93h zAegU#Ybm>4JXCK_xKQP%p-WL0WWm#vhU zifUI3YG;vaPlmZcx!#JW}j;caDK1!iq_xMJvXwtj1XlmoM)!A<_;qfT?jSUB^}a=+wslVgq~^QWGqGEs-rg z(zDN;t(;@_1*6^J2kg;CuqWf3SA3gA!j~#+0ZEMsTkn)F0ZDXuaz!a%!fY$iMPqqU z_J2I}Nab)PmRT-;St#-$OS&;oWGnRt;VH^-jeU*;W>Lh2RvJtYp0z3ykukSszQ2`3j-vCIvh<(JduLoImwdDV(tKBr`P znDzU}zraBih6HOp^sG>4w_?8AeFAgdQah{S^GJ(mxWrIF>{m48un3tymPF-n72xSL zx7vgFC)04aqsB=}Il^9BNX9e1-q=_LaAt&`#!ro*xoVoWK>9F6fzwedXFu83+!mHCWg?pj`G;M{x| zU9|u4fmv+%Q+aQ5tM-EIS?+_?Io}nwVF}kc?+Kz3dX}5qs#iz_9TVeXLJX_jaJN~vm2p9{5aH$69``7IYg0Jf6pcFn~weNhR9C3%e znh=i8n44#Xo*_E$NNvwj^hQM9*`nhhF!M#$CDgnfI^CX?j*oBhOW{a2=M%3SR$rYv zU5tYd%MeXC=33c^^rKTuUn7#fyI%h?m&k{yIMr!=u3tkYV*w0n`ADM?J))N88k2J~ zqGQ4G1;Sui;9%g+wL&!FxNr-i%$6t5{QP7^KSUamY)Rjb<)BmY$FlSIaXp$ZwQ~<> zh(3a`FA}bD0>R&boFUJKxQ1_7-LG3&Z749?LQ0D?#~kL6xUlSmh6Am5n&Hh>!GDUP z^%DH@1BJr;C(Q{qACYrZXkGDhE&x+x|GP$U@yx~6Q$xc}d;3DIF6AgEm!Bz0UOqxa zg^o3K&9Ww~IHshbCD@a$}USiQ)4(>4Fj6C?{ z!amQ;OQ_jR$#zL;L?nEe%qP|b=cq72MbLzn8iaF)n(MQm%Od{nL$yKt-Mjat4Ld)K zq=2=?5lh%ViBd(QM!`nRpvmh9*&e<(hN`0?e+uCbnjB<8Rf^H9=vmdN^{Un zaIlXL01C+V)q>GcQNQOuOyM9laaYDZ{=m4_G1rhEt3PK!DAF;jf`L(CgtupTwkzk>M=Mod$@BAVV`Hp+vTODvy zDWX@gjJ6c;5DDGkhj3s$81^mud6h=a4h^Xg(Fp(`Sz3uWTIu`+1syVmz6%FNOFAkt z)j1To zT?$Nfpac9x3{DQc;WrT^*>j7mPS&5 zR|RZQLCEf^_OvFZzD(q1ajFM&wtP`YI!=1*eKz0T!m#Kdo-t-);n(wEFjP3`{GgR|X%6QJ;C<{3vm>Euq(><=7- z2t-?n!jHAoV&zax32XvD*6>281ds|nL8X|)=(m;9`Q(ve!tCP|mUs95Zm{A8a_IqOa#J(tbk@@erDy7!iqH7PMPTiDsEj`!QC)t;i;e~uMjt}Ff zp9SAKxE)WO)N?<93n0kRe!5tK=(0+LhabATL^)gcL)~EavN|jD66bR{A zK34!Wu8sySJX|b}#CcgUD9K%_kFC81gsgVW$FAdgBE@4f3Yzr*4f$qw!;fl@@_82ED|oCyilg-*VCoMT1# z=hv;7@N=2kR=N$|U*)wg$n-6*>1HV~jRZSXIMK~$cKgqs%)+m1BD~~ca=O}*j+d?& z+TSgV~rEHzD}$&)>AC^Ctt3o6ATWOCn7;7TELAO zmvxaKAgKdx(JWkR1ON*M*$NP8m4s@v0#*f#Iazsbj=huDmfJzL0t^(j!I>Mysd^ie zl`+=X)GNHW@Uh0LuDW8(^|JJ6XnXxUCe6L(=EdUFh1bO?PB3%sq^YxRy8bbG`HU+k zOslKVww^wI;EJu?3!a&M;G<)Ew998)Uw6}V*KKyYnUaz$IOUE9OM@OideEc$E%eF9AKwspVq@g5$)pzZB5QDzmPXvW z*1DUT+-uj;y)DBhg2f{7FlI!6lavF12Ryn>`ZL$7x0BxVduT~XX^GA0Acp&V(tR-pTYPqpP6uR& zxg9&+IPk5HBVQg6=Q+W&YpWaT8?UaawhM7N9mKAx7h$&_sc8B1EphSv9X$EU8S7^* zy7#i6P7B0y%6~O-4HYsDGQbbRLqjMcFeI2D*%)ynXNnS7P;nd;08pi&(J(nTV!=tv zvoaC9o=kt1-)Xld#c7a%8FAJEEJ}4*@(i%964@~2I$~LFmybDPt09k$Sve@sZ`#0R z4N2nrBOX*;M#TQHa7I*=j7qng1x|N3RPiB%T0EsTTd7CVR}U+> zxYd^|K1j|vyF1dFaF%g)M0_do#M5`)iTz3XxpjDh!7s|B-@MXqF7QG(=oad1rG#)C zpjrXtqy`xK*MgTTe>&x>&})+!!QWT~Lt}eQ=g>CSjLe)m^N-@oQ>Vojx6W+1Q5-#r zAjC~IHP>HXTXREB?Wob!6Dvp6u&y&UcPo5h)@vtDyf*v!!fu;q?0WazmS^f`&#u4f zrkUjYgz48zteHL?WLuH=v!nYyEHv1Sa;1nY4FO$9feo-A0~HH3zrus|FV7sVd&k=WPX{dT$w-zx38@u4T4ns>`a0BCK6 z8US3xdO{A%l$UvsauU!2DXk}I&uH&4cHUanw!g_A<}NVapCxD4XwkxcC{CW-YI#2uJy+HVg)-!%5$ z4ShmAlhGi12o$hRL&|~jhBh6Fb5;qAC9!eiSSdn16 zM2v&5^5(%~ubepSYLrciB0YMx^{(st<`Hoc^YFn{%W8Z5v1(G|gt6L=H!kd6e0*rP zE2>2OuL@(4=&ilYS3m&D;PO!AWqo^TjJ5Nl2Ki{wWTT>_9iiq?rxw$zBa){K33QiTTd9u_7RLu%dO=VoE z4Lluy67a}tmwZJBup1Ad`E+qf&~B7BZFl^aUsT+f)_M7a)%V!bzuYo&)mX{{mQJ}h zt&B?%N5oEXRNP~=;b1Hp`+WbrvLjQ(Oi`uV@Fd=f%W-3~XxB5;qb3(SySk-aHz_SiufOp>9cuvLS+o#HdaTxMCnckdcXs43|-J*4A~q-EPyIk_({+ zjlSsjSmZ5wsJCMy{tXN8rACo5H6-#wQ$-3%!HUPUCM)~4IoaCOWIJ%c)9rP z0C1K2BGmoC0O}sIG5TWsf^0{`4$~W!FBhLjBE=gvY`|PhnmMoWdU5KlS&J4g zI>5sR_D|iEpY_tsZysxMGp9S;@{X7^b;|S`UaOllwGJ+Eq;oPy+C$G!Nqa=i zi70~V>jWuj07PRjb}0BUUgY!IeO`lPc>O9&h#Z4$DsCic)0hkgu7sQ z^|nKAyfSXB-+f|&_-c!IU#!5H=-+}V)pYN!f+F$x>A-1mv8Z5|INNYD-i? z{!}xUm9IM+JueM2&iFiHTk~nVLo1SD?wt5^>Z#j{=F(Uo^7QCdzi0^>{~ zLP81F0R_d;s(}!w1jAVd8@H=A;ZQlDY)4HyJ!($qv0(%IKWWy7LXeG-$A2?=-8pf+ zoEi|i$@uxo&>;GS`XnJmDQ8i}0f8x&O*tjJ5jdlqH2|eCzQ7nO7=<{5tjsi*!=7S|qsn6nJ+g_! zh$)W7ZrSb5fL)hB?Lm*zqI-;u3dk#?jL7@uZ4Xkjk&M~65xpBXN|#BNE&p%e5DvS= zBz(**Z<{|;OdHoJ7b=%3T%`bHy~LFO?L%2|nAf<83kR56WsY$=(GBx4qot(AFv21B zvBt*%f?Mv(Y90nB$Z5-NBgl}(BSAIJCCYIw4UiHU6$~jg(k8YanW1#`6h+ebFV9tn z5{wH+j@`#)Ta-9{KlrEsVyicbFW!>#EGL+CZEfWZ8*w|A@LJw}`=`^#wVSS4ID>X^ zht0j<_eqRd&?{7$oX}3`7Z!vRWSEhj>a-zPD5L*rH&X5PSkxLG37~O{W?4sXG=NFf zor^JT9O?g{xF6TAk8GbPK7I7gh?&u9Q|9A6iQ#aj$cgMsZ)!@!$Hfd8*|D5jZ1kAo zP+_}xMi~KuMwZ9Y8z7p|%!CC1R

!pma|lSQ?8FBe{DRl|@FzhU7Cb>&@ataZS{g zrCQo@Lushkm71KyL3$%QD?KeSADp!x{f z=8g-xggQyFIyp&U(+DO4!2ygCg$vPu1pqEc^*Qa)IPstXB!i@fDLx<-```)5UsmT$Yl%a2onC zAFmUqUVZ7M=U;sB~=#ZhJ zS2lbGii8+5IZ#kxQUi*iaRi9X

#R4x5a04mzf2YJ>#U<-Nc81}`=EFMdUjIP>d| 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

b(7>T&1{%W+D%3_gwxcBR7_myM-&X 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 DnuPx& literal 0 HcmV?d00001 diff --git a/docs/_static/css/fonts/Roboto-Slab-Regular.woff b/docs/_static/css/fonts/Roboto-Slab-Regular.woff new file mode 100644 index 0000000000000000000000000000000000000000..f815f63f99da80ad2be69e4021023ec2981eaea0 GIT binary patch literal 86288 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 z zZ2-<1Ybj>ry=wB%#OeUdiE+9`#Py2p!LG*2hZxR@)SJLuvvvK@WnguRj>04QT;@=p ziSLxKh|ITPEFvHIo%1R_G|1-+uM^@{W&cq*)=vd13iD;jjTtAjBg;Dw-Q>TUYZlJSeBkv-?$@oFicPM?|XbM6TTo&Tmo@-5-m{6m`dN8NXC65~W^&+l3KA3kf_>ISBJ zQ^O?*tey6*`J7W3*1Ff$&oqluCJKN*Zq=?)o^xw_e3GeQ_sz^poas!cN^tj2v09=| zXZ7t~m#x5S39{8kdi%0VmHM#I3}{J^PxM{6{cW>KpdA&@VCfI-R#7Bbv@oPItMxlq z{@joy!^e?qhm-@UG$7+BbisOnoYKtt(Cj`z5oEx?SFA#)60E#JJt0S3Aw92)xm9Ip z6`bXI**Ls?hi40rqmIR9d1AryjSsI|9l+M+N@!W9xQk5ayCAD-epT)fh1@C=q}Nk@ zc2eTC;1O?7;aB%ViU2Jua1(PBAgMw>(p&LPXWcH#VtM z#S?fSO?t1?*Me2W7{IDje0uE3dw<`^y-{bG zEtqgz1*$_Hw@XR-U9Uo`!xBr;;uS?_A|@3^Cn3%iL`VGY@Cp)lp@%O%o8AesdS@i@ z|BxXz&qHIIfKUDxI6dH$36iqoZ6fl8?bfdgz(3yvK|@V=8XWCRVXX5v(u`ui#5fgP zQXT88S~VgytH2OJc=S(SnmKc8p|1%h2RUKo^Q8g_7ZLW_4f6kQrrYUkuUpo7)fN^G@s6%AkFF3~ z);1%NPQYGAcQ7qg(0cDyN9r86U5=X3_1?9qA)bIoPXPEWN^Mdb0p1hq}PvRVJ`WrNT9LnNgLo1L^^gPc z&tz9r`pqe(fX`a5{KHKsvB2p%mCwTqtUtwk@3Yn;zi<!uynUmOh%uzZuzs*IIoAd!~*@j|E-idiF^H!10(RRUH*^BuAubU6HI&` z!%lgtn@|*i%2g_khkp-y6D5?sGRV*}~WHgQov^tBEmGgQlN;wu57s#L?1E)iRS)+URCh26* z7KB=yL{vyitM$QmGO=aH^e$`qLe#qN_^n5l>V>fE@V@BV?+QkbW@omhl%%FgT{2}% zn6#{wtZ~AohP_iILwNyn^_L6ZnEh!lFvK>TDxFy3$V}IaC|$}H0*a?rEu8D;C$xvD zBUh0e$8ocM~0yC^rqLyv7$);#CN6=EPQ>tE3Gn9ESALKH4qaY@J*2!C^ z+Z|eYJ7UTCR`Tn$a*a$?yK5jhp?d3ugPj@876+M3E2*?P7C3{K7?f*`u9*k1lJN7?mR|zEiucQzB+%d^Lp>eDKfot?5YSpsP6;IzU z`1U^4xHay;HTF@iYWc$zPrnbCrj}OcKENCJ)1 z*9OaC_ZeCHzm#ntq>Ye-9cqR^9*`F|NZL41in4%Ok7D^-=92}MUeH>xV#C$B)$T$4 z#GHNp{xWoi_hW0ZjLCMYltc`%53$02Yk9UE<6fEg;*=BirV}YPyVb4F+V zQ$FhYUF(>E_Oo)ZJ>P->K}IL1IEqfWD_*+&gJXVWU=&3s8cRA|p*WbPNJTLhL<3YQ z%#s2Ciwcy)UXWrT-iuR=kQ!D{i~w1vSOop1emPk>b`df5-@CAjDt>L#3D%n~85}CZu16hkYkz>gAtSg1)!AH?{FIR;Y5&E95SR;HtX%j&i5CJ`as2`3wBYxJ`D|8a^P7~{Zt27vCO^E zq*N>?*^>ypQ{<(`lppMxU^%T};Vli{Nmw&U5*0|=p~8GL&PtcLfc{H`nB=biFO`>; zxKJOKF?q^6$Y0%ltDvDj8hbIug#wj_ieo2>n#1RdwDc^2O2(zGP}_cDu# z2eCT)A02IXf=716_?y7p78Ov3RAEyo1cSLZ5-@w5XP`hpW zkN~N@eWb7O8t$mV?~!^kN|=vYCG*UJ<}zDJfaWqo3GKy=pzmF*5MwtR@hmBRcD3r| zp*e{}Y|e%{E@*`@=>rl16*OPv2A))*>tYN4jy2a!NWc84 zlJKiV>O7lGKnf|N2I4<(FC%^%_FuR#bFA#Di9tkPocyP!miibQCZvelA8MrY4gow% zP>qc;dyCF5_W1p@{chuKrf)vlm2Dcfdt8MsPS-CW?67E=U zNCNJu*G-d}qtD}$vN!@0sDs+(E*#w9QQ483OFpYPPS-dE8Hnb7A)PzSG z`nYhow#k;YH)5u98~aFcxHiawwKt-}2pnQW7##Yi0VnyT}`aYm? z^^;O@ZTyEYir_3pgx{f00`<0!l$dLSJlJa^8tpJ4HW z@@Pi(;2pNLY*tma#&cB~N&OORbWAZVwh+qqFjdLATJC1K>}lPpH<;+2bOU$khQ}O% zfyQb`N>gNPUDR=3q{Hb3Zpj}PfAA)D#+qS3JkFL|oBvqX9-c>eVdcj0FCk7U}duVxrKF2n5pQ5H?< zVXfYY)%#$S=>_cL{E{uOGj%I>*xJi}`&xG1NM*L|m-K%eUf>)fVHP=M@#BEbKOP%q zY$NT=Wj*t@zj9Zd6ua!bDG*U}S39f0zsMUcwf8wJM&3<6xBSjvIU$8Cc8dBXEo|KX zu8E54Oxl4mq{I8hgqgWvxmlScS>D)nOMcxu7IOGeATai0eW3l{ztjyGh$zu+I7FZOzRw`iU^ z8)|EUHBxJWH{Zf3Y=|mpu{(IGS$whvkxYF3KA6z;>l$RgY7y*x97n+qN!QZhaE`^sHS2rRxwoX8$x~ED!is9`G6RzM|w*8 z)+ey5Jo*OkkMQKVBKTo+{Tk}~Je@vOkTk4aAp`@UEf=a@1tI})MF~=y=F|Tdt~{R~ zbw@PS+vB`HTIwqLvG1}}T)$_B|-x-sf<&WEzjsgl4{VW77^s4==IMpn#w_@U5T zl08+Bolu6|Tj_1p8zBPPK9D&e7lsgAO(QjnRO=m3bS!hmWpUj9)4ovHTRyV^EI)xI z2aHsPwNFPc!!)j~NmDZD_9{t?0-RSG@~aN@f^OBBiD|ct{t3i3?)EEDj|L!B849V= z^?_hDDoJSnGiaVqaQG!V)uBc?(q&*wj%)s%1ka{?b}SF) zn0PS9yrZP))?Ahm#j+5isLhJywg+?DU(Os~kO^zbGE#DPi{>ZpU||v-5|$WdDa$y4 zLgkpp-u;EAzQ70H>4u|d#Nxt=X8LdM%ms9O zeXC4cwcjj#etz<9eO_q_-R*wx*mlv@#z3)~BG6`sR~v2zPS{U5X# zQ>RgQaETuCy60UI%!Nn4dD4vfHbGAYau;QeqTa&j<~>Y(E8g0%gDO6ACjy_%6LMfe z=BaUvd5}$7hs7NL#p@c8){~P(x^y+0pY1tx@w4nR*JjII6E#k!z+(!L4`ZHR+Qap=ZcVwdwz%}1c_9q_$7P^Xkm42V0Dois z@$OoSSq<6uD1sqf?*iT-b1K|Jp2j+BC)=ML_YUmMjL&-Bw&Kfi@*+tZDt`L~=g50> zqN&@?-rEimx75{J_jwjemF4br{Ls!8$K6=ZSM140Rmi~jU4iV|;_Yzs%L2ri&f{sd z8J`4QPc#09qlP;@w`*P`plRj+ok~(5O|^mvcF~Y9SfhaDKZL?68X+`DiYBB*bfVzE zf+}<%cGiIKt+^hP5#< zdwJ^BHkik4F_qxhkJGE}-8J6m`b#qZ!?A9pZ{U4jj48o!FuZYDCf7D!-#WJOmdKga z21XGcJ8Nt*o`&Glk77~mEY2gEaZ*N!@p4h@&q$!nQ_1%dXkR`h%zzy(`okp!U~<@5 z`YeSn+7N%VipFQJAr@?$0{ML-)}0I1&Zou+3&#nil5i-Doxebmt+Nvo;&Y7nr0>W%8}DELf3oFJy?&$(8sDB^bbYu;tzTqB{GEp6;Pgsy?x8A)$S zL>G+{F;+D$33z{$jW7H1^c2Ev)x0_k5uu6{!ox(!zdwJ3Rj1>7o(6&Do5WX5>Bxg6qP1D=O? z5Q`wOr@v~=dG=90Y^v}a+zwe`B4hi~cVRSjUsdFvO{6SfN&#O15~%PPHcTG8Rxb=z zFJ$h?uK_AmM{G|as^-EMpOF+R8tzeQRzp2DoJ$@#V7Sf(^USv$B(R)gnI0KzrL&$V zB)R*ZDVkgp2FmR#+U{51+Xx1+fp3Q{v`lXaH5|Adf{~dzj}uqxl3lVI!?=fb*2-Ju zzZ3(LezM-VxPKXo3c<&9rpmT9sd;(O12o2OP;(i6hLBxijD>dH@Nzw~92XDWi;FAb zt{x9nNGfv(mB@uY$zMI*x;9*k}|Dle;U17F05JQ>yHprz+y$g`4 zJ=P6a4A<@0p$I23bYdjOW?pj^r!(jxlN}DhjBgQa;-?@kz7Gt+C(KA8!k$sx`nsbw;0r@5GAEb?ERqIEv1o8zDl!|3j!#2 z7Zn?}}V2arw_fV8U^8Qiq0dqd0Sf4>Szqba+I$ov!PF?HGH>@DBq zJC6e8)n!+E`iFaln(L2I3X4(b!30>2yLGM~XFrM`#W#`p#x#+?WS^&O6+AGX;YN*C zhi9X+=O@mDIo>hKx+<0&Yy8nG$SREe$SV?5;}3#P7DV&vS9feus#g9@i8> zJV0CsN>>6vt8_yEnFWE!4`D^P9elzn-RMAOQ6TbE5s0+NQ1V=($dDa4=Eq+=yuHbA z4l5bAYZ~^@?}b-I3V&wu25^Q9sQQAqn=9-w=Ew}FN=DR>4J^qMR#heyQR%f{JCgW0 zwOUm0RJSkP)mp-6Dn2ZDteNkUgz>WWXxyc29$hBLMne1(l%^Ski)<|RMO)aEj*Jz1 z_h?QXI~LOCi!aKiUN++d!R2v5gCsub!~Je)fh*UZH~b}o#P{Qs3W*DDR=-}OP0x$W zD`TG^P^$AJMcjfR4~H$@fpQMC2F0P2pY z*ALX~FRmct4J;j*RKo>>ryZEDet<~Z1nv7^+B15g_Eo)0rlHNQqM<3ysv@Jg&D)H< znz%i#etqmX6E>EACx3K@>*^ie#NVSsyk3S>ZwYQv9m@ex0@(_)K7auVV>zn5EwAbA z1>U>vzda&aOZ%|EYTu0L;UvrDV|Yw@#m~08YBSiNby()L0OWE7j+CUDPs++$XXk&z z_=$X>DWlD5AB{*O$yGT_@-4TE1JkTx715p3&wth<9B!A5zs!U(6?Jd(sAM4(+*Ix0 zs(LgskjmMBNp*UT&V!a3t^5#?#FOOyDan#2GHmF9jFr)>XLG22@`tz+dkugPg-{G$ zglcTzN0Jdvq)w>D`yJXlT)42b$>yh^RRW0+$e_xsK!X(Xb{*LIY^9?Dm1PR;ZnNS` zo-uB3T32CgkVLi?bZSLmt+|-b@HPWS;$2we>d1U=>PRY-k6fY=n!F_Kv!O>HG{qXSY_0jWH?)Z%gS*~#5zaP1^SG{%Q<7eBm>gIS)PH?_)YY2`Qy=%*aE*!*ky+8_vDCDyTS!}b zAvB7o(viyLs7p@fU?DV>r*K1#=2D$azejU4cTdycyYa^mIfROtKAu&d{bKU=HkE0?SmbfGrgUH8}+ zo4j}2xEa`LJ6m+fJEpit(vJNI=j0~`&gHE?O@`08_o_k-}O<1YZJK0^|pE?G$bOUydF(nRDVbQ z6K`&yPtE6X_;t8;K|_vtUxAP~@3`9mln;*O<4^&$hXkRWy|4lHzBgM4Zd`C6{t@d#0G!0yg0<~2)fPk}KYC{;EHnz*=#bPgL~G&nl_J$T zNbmCs2N4*2fe%2~gPx!-!J_k$ z%N0!Y1Jgsu)(z`UP;UqR(Ex%M4tn)puZjH1NlFNO`7xVMfhTZue(zW5)sdz3lO9y* zwuzQZ>RdpcJQC%}G`%3Fj{v+gk(gXx#sq2g95L7jQ7q&MkJ>77M-SCAGUp-6{>4pJA9UP1`HcLF5jAJjeT zmUGT`_B-G2e_hXY=brn0=6#=;OlIb-*)x44GxTGQ%phKyinOqX~&+F6df%OR0Qe}2^-ZvjBp1n+J zSmALWx`KL4y2Hw}#CLa){IF2+`Uu`>3%w_mY}dOL_MtPUzAKK8mgKYH9@GQ(xiUf- zD*&$v+%UtBDpOW-0DZPGE~0#Jvu~5p474w;n|t<=#1&&)*Nre0hnJ-NuGd0SzAek} zaeXk78;Y)4hhaXs4yM>jpRXI$oum2nkE5Jil=_Wo2SA53AcoOX!m)>@8be(k%=W`X zTcLPw#U$~0-(D=~G3W3~f=MvX8v){8E@W=irsbE1Y5}rI9*pv-jBwv#&a=F?{XtPc4}SYkIJ;zm4u8* z`hvAgZv4}Q6VUu_gLfc=+zVWY-xlssru%i_o}t0tE!^XUUgdXl7xH7prMpfV> z^Iow)g%a-vOMbVA55*GxNv0Ti&P{sLW_7DmsXw#T zcj+#4jQ4(yNG^JBQ}n)}@GVE-TQ{y13$DlXiDp*-X1o{Hst~-Rb}K^zp92J;6M;oh zKx6ko9j;^Z_32JCRiX=GjC+irv8!VZ6k|34>oeiSd2`k}wYmhLq+pvoxb8{q=)+n~ z0#IVCja1NY0{vG(FSE6jZ(g&>38*d#xS=#cRbU;h*BGdm(Z;C>r_>Q`)6Fp99Vnx= z)Q%J^>7W~(C$e!0slv*4kyq(_0*I>PTiouBE8$LkG?t*V

msZ%O|+*Z+LS;;x4v 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%0AU9xwl*jMUcB+ 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 NDMp1hFB${m{{V&DCTjoy literal 0 HcmV?d00001 diff --git a/docs/_static/css/fonts/lato-bold-italic.woff2 b/docs/_static/css/fonts/lato-bold-italic.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..c4e3d804b57b625b16a36d767bfca6bbf63d414e GIT binary patch literal 193308 zcmbrmV~{1$wl!L|ZQHKuvh6P0?6Pg!wr$(C-DTT;)#rTo#uxG4zn76abMMH^Scx&m zm~*U^+eJ>42>=iP008J72LSPB4e4_M0Cd*~00g}9^XvaLVMm?7;LMtU=>b%bK=_$J zrl2E2K*jX%M;-_PvH_6*Z*wCD`T{|3^8ef76A-T=D!!K0uMUtyCfbipnb@-6~>&vo<=5v&El{-By6>L{OV6 zw||(fG9&(2G32VVLaL}&V;soRBk|UGrXV;Q@4hqz++ES86zcsi!$pOBmaPXk>}RS> z$(yRVKUiZ@Ywu+rI2x8d%2-|=3USQcE(0I-vC}|TFL1SG zh8RjT1O)~p%^H&4y;e*I%RH_~fq7)k{-oMK>?y}Rm=5s!QOvPUm?bA5TLMuGSw19L z0tF}LLlNg;9wnO0(2yrq!)YYERts0XN!@9!vuKYy)C|mA<=Wu^_MigiFKG3d{KCh$ zd7O0Y0yjNxpo17;Xc+rhK?{LuWUB}!yT;a)1JbTC+td2P@$?L-)R_Pn%|6fZ%1Pn( z_#Mhg6$K(uy7Ms_-7GnU&fwQZ6@k$*B*j9qC^{Rh7H@_r>IM{vXXidJ^ym$8dZW1XKQ(OAR|H(~DV#0HtO@y|>qAhz zZ$+LQmpWJF_8a)hYbf;x`QFZqcV$qNL83-at%*!$Q5v`uqLLl4dmt6;Qp`P3BV#W5 z096uniju@dI1C%5hTbrjBDj?3)Qa`uQEwczH3bFLzoDK2-Um7rQzvs_+)e=g$QX#A zt^tSamwn_0=${}smMRN;_EKQgboTl=7gDm)7SmK&sSAbFC4KVqhlii<_Oepct%_XI zIoh#P(aSyUg*5n`gu2E%-)SWZg##grz>21|6SHGhBXy4F`lSrmN9C*hnc}Jq10_Q& zv$7pgpmGZ7o7-D)A4!FcJ6gcd%5CIG6dU4Io~wHo86y_yW*r5vyj8H|V!bI}e&Iwo zKR}~)(awps%)6*HqQ+&k-@aA2GmVnWVxUKrbk*57s?I}@iII=H?l6(+3nRbHuEc%J z`znQ|taoIRmq*i1+A*peKsy(@*y$fq1A}=)C^f{ zA6*wLgh~pJ07pNFgfzpbQnGco4Q4GL^edQC1Dg>x=lq?;5is0O7fk}hIdSplweyTY zg@ANudQIdQ4uw~hH!2NM%567J3Az%PRUCIbHQS{-{I@IMRKglt%e!rH^=S~&5tcT~ zfZCx{=c*n{XCNBpA(kVfa)VS%tgiG_KRsKwQg?3v-4tV+^j{Y5HezTHT=5hR$NI{r z)G@%;U>D~zs36rnYW0#&>FV}$(9UO2BV1i;CKvy4K8X*21WPlXCYIU&TnphSSAQEc z`@ieJATZ8)+v`{sO_TGYxhvWhs=7U^J7s-MbFUR=z)<#k?g1m6S&Q961zLP5G!99e zIC)R=7;=gNq)Q8%*ae;;ej!J(`9$Rcl4vdd3)VpUp0?|xSijMntCw=wrE7F>>8$uy zD)$t0_Cu|Q!rjyVbgm78(k-ns(ml!4QsLDJ9<5^fpVayw4UD8GA37)C4;~6`r%n`lhr}*l!ZQPk( z@?v-pv1w%6vdEknx?`Srtz=ptlDGRzQbZ1OokXwTCD+{rJj0+ybSi(BHm*aIbLCJd zqxEKSdO3W4cu%Dt^xObd0OW0v=Nom9f2h=subU9}XQ*aP(!#Ojg|4N~pdfX>tMp9T zz1MHtP>rC7nwqFaG_8XZK6BZl+EmJ%+$tV<82-uUgh)ej34TVrvMftM5>P1!d9f2v z6CA40!Wo7#NGQ95Wu@L<%+q}_W3-btjirP1>Ydl;PuDT+-ac|?5RdgS+Tl{=xC(Yn zg7XqiDnIVDfB2C+T3JHdHf(NVHQpe4mhOO4;<;i~yy|(-=<{evX#9EnBhPs}744n2 zszj6bkYY~10tVZvoS^D>fSlHWoz&}j?M#EyBe`AcLU1^K!` zaX8nF>0IV%3B|TUFpDL(B7tzDs12@W_h(n#l*=nDw~`a4<7U7XT{>L8AdN`TV`Wkbe61G?Y! zB8}K|Zp${C=P{eznK*&PJYZ9Ax8|@aRaLsW>xz*#8J#Oe`OukK3`8dX#3|>O2ElYi z(OLWi*c!|01Cc|CbD+X8Y7aV&==s?EyK0+I;_+3CPOjzbRH0fQ+dQqywmS{|CTA7L zYaiKobqHs{b#;0}*~cB3t9+Il@Y5|@s+CnJ`*ri8ny%|#!mkj>c0>z^^8UpB4DNj` z&kwPVZCk#tz}N2Uciwxi(jSDE-`)btdtXcZcHfx~p@a7)fB-@Z<5&LKBqKKv;(hn^ zCdc=l`JV&c4WN~R%H@|HCQej4!{?>y*)p=kKm`y$1bT@Oe-6;6IM@_S9W!D|gMl9m zv>iDbHgr>8)*{^uI^(74d1a&`RL$i3wapn;#M!cdx1OVpCRDP`$1`OrncmW96ILJj z+NO5v7VU&H1_v|_)pwGAyCLwcqsw(+N-iHNmx)1sh^Jcp_m7HzsgdXA*`nkVruZWI zInfhjB;}$_?a-NCZ2C5PKb@mByUKl#?fATr^Z2M!7DZ$V*2v-}r!A)DD}zH;hTl>r zzBJk0^b84gyJGaKXXO#2EBAF6bLp}XHs|yy#Vd`-Q{NfG;hiHb?xi2A4$jbXp}d|> za3eDhT#vD;trNbO`2_8IIC&f1WVgerC3RW|e3%1Yo*9G4`~KXtCs$>kb6bAnU#ggP z=AwR`ZmK0!w`{TU>qo~^h^MCO`WtUL=r$eMKUz##LJds2v$OiVT6XToTA0aI+5O!*cH!%5EYKY7%^WKUNN1 zUY61<6mX+VAumY2mB%O(3(-z>N55siZ0>wgzC%9b4!t3RUm*vEWS zx~abrUVk5IzP3#8DSj2)kxzVg1ib8v7wr&!^SvUz@{N59d{N##r^w|ha=K*jKO37trUp@^jhRp@GRRZ$1t zVf1RwhwPd30n!#8uO`!|qHku&Xz#q+&5llPm1am&P8lWNq_*AgWkUbvXB{`s=`uZ) z4z(KBs`=WNGy7Puw%}NddQT+eo5aQERV`xmUsQRAEKf-)Li;MBqLAf+V9h$E>3N_l zgz3jm#Xjm-cMUnLG-+Y-TdZd7Wsq@yKD!`fg~P$G5%#5v7OI`rh`UeuwWXOnGd(0E z#(V%cfU9gAfDgWJ@Xx2qsgGCs2LvQYlDT9b>N+BrLRpYp7>o@{;E3;>6?3wRu5Il& z3V95!JuTT~qb5T^Kx~p`k_ie;rtfcE{j*Elm*Vqp)hn;-`|#Cj2NfJ$g-Li&`fjPU zA;+RrR5NJJbs$>QBEROc5``?1f-w@q!>tn-RyKj zgLptg|9k|TX|VP<>-7CU-q|}xIUYNff+QLO3gdLb9vp`4NW>+rO$rgw_?O;F)%D#3 z$O0-ezOFCF@1IaUF4LW-Znyxoy&8oE(vhJcRPd2hG(8MGXLPAT!oN;g3-ZwxEuOBN zJ#-Nu!UUy21UV7~a^)#dpqwy4AjEE>*XVhEh-Tl?BGrNs~@_|DUQb%G5Ap9jbEuwLj z{;9mu&xl56Px|aA9*ZEHEFMFx=&s`?2qAaknoX4FI*%MpEmysN3PBi%AZSaY#gYAB zx4#auRU&0PM9Zp6GO z3+u;cDlK0CY)qdsZvWxX!!JR%P;53FfG`H1Rh@1(^u3b*ze4*s!sr~H!8k20T?`&(=b zE8S?B%bb^nnMSFf?-(0a4|F*Q>3H8v=y(s;KPhNoQz?-O85p+ocPP&Kt5Kq(1K+>R z>0p>`xL$AYL`Rrmb#*l~xjq(&p|78Yzf#bP_`GVxd#H5fTQ&50L<6!hw}|=kFhQ7X zume~Uq3-iEH6--Paq#8X^6}fsSUJ1$ePdN6KP^xoAEh4&kGOWAkO6ByRl8?>iJJ#t z0}LYEfg>tIBYES*l+JrPW&I_~%`G7$#DPOK+`-i~Bqhe7^%uL;I}fJ;HCYJ_o^3p_ zdr$QiNiKtZC}bTiK*#if@-U#KfH-{LCMO9PHVu(JHfDdQKulyGMr1gGKrMqAC@L^Y z0fVk|<*++2@Zt(R)VZ`XFKWL33vKlwq>brNB1|#?>1Qd2o-QbHJ`}mL0-ikFe5+%C zLqtABdcJvjG5ImT#*4&8P?=2Y++Ms)z!L$lULraQQ!T zRP>LQn6Y3*i7F)eZ_J;#NK4D9#P^%Dr0JnZ#M4A8Kz+MAE6QQ;=)?0-g06$D15(Aq zCw3Bzn@VZ;CvdzqrClix*`mtl9XL1@CEhS7JrItX z03SQ)uF>}Ua_eFi2{uIETh@c%?VLf|a)RSK|7ghBuNtxl7v{$DK1V_rSBo888OLP= zaRk>(IB`}H2*^NB?=Z80%}`-_swv`QL#uW4nlDT8hQXJR#?{ZVs6*LlmCnx9w>>QKwu>ifCs-$fweOIE-3zNn zLUX;~3#fGc*fremBScv6a=@9F4mMiiL34swXr2qYBAIEgg)7UZC0Mx40<-jdv+#WS z=l8(;OHV?}H7o)`iKG!#pku4%DH_u2g)40;m{|G5j5~N|WC)s2AV?b9&(#KJXidu% zJ$(bqf)35WCQ~FiAJ}AXtxzdxlu^K*+~6>#^N3!9Y@&?GS15@jK@5cec^L>0A%9%` z?*j_}&Ej9vX^QKH+%LJnPIG^Ts&4p{3gcR$e z&Gx-PLsDy%T0c=h-u-=WxX;l^d&lm`VKhj>&r=J!eHSVvN9kW&cDQqo2g(NtN-G>% z2E#TqZ34=p1_7PysL>bH2;`qjH|q?I?Q6NBRCN~QaP|KrBNe!#QYkkh6&8OQPeG7y zpJdhD-rFmGS(;k7zI?m=g1yTA@;K!8uUxx=8`xuaN zc@)3$M9jhr5r%+t9g8NiQF2^t-PMZ#zsXfK6Dx{mXB1?q&0{GYYb%pgt_zxqYRYSx zcLB~ropw65Q3Q3$096!=MA%123gP6mN6vktb#-LYy$li+{sql_Hbl7f-6iYc@vIzm zVYNL3$=m1Q+V%NlZ+aC9IH86CD0!Or9^kXD8%Bnd3FMVh*wI*(#Wd6P4GeDu42I$A zdaP#C65PwD6!vb)h&fy)aEkGSxO z%Uev`y?7k)$%~fzyay&e5Hh2KfvU}k0H@;?jf)oaXF+vgK4fi1$p@EC8#Gs8QQ);2)Ht;2 zBBh1P(x`p_{_zUiiB2v-3kf`9B%c zk1m-11ibQ3z$Xr)|9#elfuEa2!6K&o_?{^?R-L*2qE`>I#Cg`vkg0M1nnw?Xv$GXM zTEE=4SA_Tiv#DC(;s+WFb_D{*v9R^0CL0K4UZjzSc#&%|9yJ4I#$%3NfxjN8kx#q) zFst_FKvrf%$rUpN}m##es7w;TzAfs8{FenoG zC3n$m5z*}tH^e35OAx`uTn~_0^h)!Yx%Zg`4OzqsSmZ0_>yxueu9uWop1)FVQ~b=w zg8PDD*%AgP9nqybfu)a(<5<6#?t`{KouAw`po_JwOltrq}K z@`z_C6OAx6>ND`X()8AFNd&-mA)7JVZ$z=MIc3AuYt02atwKk(7N)JD4aq__+Fa;I zcpi6KL+-C=m%ZE&RxIb#Vw}YJY!&PP20?;0_l|757 zyDqAvt=5?kgAV*iE(#!8@3#}2NLM-xio~U@G@Fe&^*OnU8fh0&^(PCbwTkM0Z+~cR zQtq7UXSV-I&Z+FxPR!5p&k{>QO-a0nKt-=KB?Wz#vhyR$zig?SSghlo`QCmrxyIXL zu8yI34aBC_U5YVfEjtK2XgwfXIjH64c*dD34W`jF;JNwuuD?!NR=F@qC*?n);v+=O z1(J?bUOI<-U!k9Ay#MUV7UW%!EGltCB_@DFRF^kldw)Jwq~j@Z_MQgrf)Nj$U4_9~ z_a#yV^1Zp~dek^QA|w*&E&QcZ3C>7JbToar4gYP-RQKr)jDJHOZg zBl2`7^AH$B0Kq6OnXH^+qB%WjYaq2x9@~VzD#Oq!f^-3-q^Y)?)-9e|su*Tq84vOX z-ZAWyHx;EX){65ir*WLoQk8QwYz~+8<$6PP%K0EmU;TU{8Df90YbHLfPvvo~Tq@PP znYd&< zrDU^&WHaU34}Imr_$Nl>8@2dXXe6J1G=C;cJpRtlq;jn18h*@Fm#ePM##m`spTv=? zUX!^dvsy6VQIYY;@rd+Htjr>Oa^{-KBM;WrEzp+G{(X)BIS?--c=EoalXOJ6!rK9wB|I*ON(EGq^a>_X1 z#w@BGDBVLSK&^$GkCTO_6GjUG1;7WY4GL^Avxc`dcAlkh>N96^+B;ha_4Gzn?m7UaMpfR|2g1vsN!!9d?zl?u=COcGdGj%s zop1nY1c`sYcd&2pgH%}nGOiS`VS%f(bU4q1Q9-@F@0rU~(bdVyJ*~_z09HHgyw41_ z%my0&M90~=x~Bj3crM2xRK6cc*~JHF6}AAZxaq+EuNMrf%C!*L<5|H{cjUORS%;XxxOfK3`d#j*7j? zjW>fu|0z#nmpkZ70>R;k$)407gapj>;~0+z?+mzbb5Y~HVHeG>*QZ(OkBJ2UFhqk& zfrQ(e#;sl7aJ=K+X{rCv9H=gUk!}~=p;kgi^PL>!rh%^`Y!|_5Mn3+M0}xmc?+lK zn=MvP*=kB$#1TG~R;pekBN>SPPuUwf!oYoGe{}MFbtS8^V}n!sjU+ngQXLu!QxvEu zNm0ZXctI*M$n#0}(YLARnbFGX(; z5;t>)nLNTl6E8@j(;aN6gD~;KSYP4v&8)H<+|x5(U1I)|Ht7ow`jHF)jMEGlyDL|g z6G-dD55`q#%1Pz;*J(U4`4o{1!x%s3CmKou8Bf6Q!PP(|i5u;7@q4Bn966G)AA>m3 z)pMAw;yT62Djh*s7>ZI@&^2XXQulNE;GQhxKGVIl^tvJ(<2KTCQNu%nac1vZ&Yt5q zQAoL}+_XxgDW52x_oL+7vMt~RU9*x<`#jv>i;2>k!7ni{DMah_S`aP}_7DDK(KKLp z5#WWNKxng(!|v^xjl2e}a)ZFLMP(>!Xb1{DAoExwuMUyoG5)E}fi)d-_FVNw}vP#bq6-FYKoO74!o%m{S9)W6PE zfxW&P-q*mNS7NTNjodds|F*rKqHkV%XMOIW9b?Ad%~9;`e8%y~7RJQfw0=Woxb^#- zH0C3=uobc>xHW*xeE}KVMRN>?yI5f%5CoK44VduB3&bz`Gsm;M#c9 zpSbz%r-*U0bn}!v@s@ge7C(OrKMQ+tUCHU*YycP7*3k{jcArmQ_w4|e9K@u+`#u99 zkKwj0JTsWSweu?F5NZdY=Bikk zBn_le$<%Nk$z7=iRESnqX>AlfE^B6NO0=}^F26+Bfe%be`nLV_|3&#n(TQ1nANGn@ zZ5utUJA1Cbx~`0YKcBAxaHKheY^o2{= zWUG_uOYNwZ@@PJ-vf_0fewH6lmtv|C*PQyH@oUr@&XkcqVws2jm&wQ3A}ai7r(>TeMVkah2rqNV!6AoTeg z33-GQ0&+rvq%Z>dK~YRnklQh%C@(}!$T-QvTZ^6Mw`sHWSjvi1$Ae!&6N9Rltlpx7 zoIofc?nicds(#@DyfheCQvKR;>3SJR_k}dp67L0sAf^aLCJ|w#8G+6xp}v}+f)0)$ z;-@+2YlTqdPa|nr)O<|0PDSeu4ht5#+xaA`Gt~B|i;Wo9T_*FyqMERwPa?aT;XQfr zHo3s}3}hlIvz~%XmR@Sea35QKrI=dV`3&mXp@7)CqQ6@?;Z2ct%YKiH6LqfKj0yMJ zcYh;3C5M+=f6;jzeVI&N}FLvn5DN9D4B{u8aI9ru7FpnxO4&o5U2;T)l)aqS=QCnHvCro zx$$Pza=gv6b>3C<=vDX3KjJkj^n9PVI9gWRQGz*Sl7nr1<@RvoQ4loUGn8#c`M|Js z2;reAP#deVFG~W+wEHC@@1&O}Dskj;cinW8>%Av`U2a?M!Mb8nn&o=CpFOdh;^*u)L5=sl7JiNztc z!|pph$aS&qgS@MYvrmaj@80p=A)7~qo9?=$J7+G5Z*_B$56LT^JW zQ{wR;X@V;?YNNN0Vo&UI45J7fe{_Hz z2}5#Bx7iz?iy<2;MEh4Vk5LT(d~XbeDr(v{m4+>3VjsG((aEvxAOqqKPeOrZz#fpB zh=#hn_?RcgpUv>VXZjyi01G4rIkaH>>R;0EF*? zNUWI!AG-eRXuL=YAc$qvZN~ti07EVwZlXruZxEI^aZ@QhO`TZ2_t;~eh$+Z-lz%)p`5e+{Wf>C)Jg(NushB94s-7r%Eo3o6{eUY0T6Pqu?Hg;zPvAa(Ye0J*j|>5 zVH@BlfYukGz~C`EbIi9+Cd`&i(LExe8;u4-3=UzKhU( z>$XNHk4tQXjFcd#8dGFi?sVTKvNjIviUW|bce85Y>%vTq_iUo(J1F6tWB+of&t_!U zWDfpE&FKAuI^qdG50Xv~52F9)o~!4W7|Jc00&O3lfVm|+ax?j1wt?$X9r11D+*Iv& z<4<63f4q$~*u*G4Q~UXu_t6$wr>Zp9kcB-?{ehr1l8;FmSjMvY4H?T26|HD zYW24^ec(BXU4a7ntEbiuv4wGF5fdxy2Bj_AWT?094Y0+QhyZwpmtUZ>bsdqT=KYos z2q_|Yo%4*doGw?`JZk<;2dk|S=@bR2lr$})KWn=#b#Bb% zE&Y?#gHLGX?_>}cKExbSp6I+iPPQm#cV!s;LR0PYn^?`-F|p z=RMyBygwq!0A#$0S~R#n#aMW`#4rFVs=lC12COcMAE+%sHb2S#;2($M(*I6cZ8qi*uop&qyG3Vu$}i_>F3Fvf?%1*z@F5HG zpgkLpgNhy_4EZ8F!HNsp_@GIctR$Bc&3{$skzvS%t{wvuZ_1J;OTeWc524&XCQ6Cr zQYXTQ9C#zifijU5tg2uZ6`{jeMI_ak$6-|!?>WMDv$ky8vYYd#D&g4}aa*b4Ied^g z-!c)aEg-Z&ZcogrVFh!Lms*Igi*qP>@4A-7-|S3W@*K>(-Ll*Grm5iWuI5AU_=-4q zgX^e!ez*OkT|4*cV$W!6(P(Yatc~%ile2wa{P0pSo<)Do59H33m)OSQgSdV^OHJpE5#GVtFuH1<;4Xgx@fME2>cUEeMg+s6+Ll z5SHds_tyhiihd0Jo7|s_l?CXFP+3_vk0h5zXuf+;kh0~EEfRg&YKXV}ur^tRp*0s$ zA0N%&trs-#tQ!qA3$rDJAYlZRBx+iCn)%qVCd*araCyhEZ!DIybm3WrXSJOjX^)rS zd%CCG{PwbZ`mxY*H+ttIPAckScL^Gbk}m#tSqXm33aN!VuQbKJAQk^ViL)b2GGB{6fBlFT2hTSP z9-;c-O%?Vxk+`B+3>shH+y7h;zcgCLz~L>Z#yV#^8nAH(5rzO`CV_b{k5isIpunI1 zvS;$vu49|-tG|(h*ttAz(im975L8aP_UQ)?ZcTkneU!;6{8^x>+j71_3IK$8qt9Da zo96UR7XqYscywC?C=o@nxUTIx*TrP;;Z2G429qY`qX9WqRax2}04e^bb!#lB`k`HA0zB-7wx(WxGrAZf-L&;THQ z370dB96)I}$M&~38Gkji$=(Sq16r|oNURhWO6WnLhx>=2o1Wx?;1oENjt+)WDCB4g zgANOuBuhFSh^Pby)qbZHuFfTMw-3uwxmY$=u`YAF*gLU%2zerd<2U>T-Tb?0IMQv3 zxfK7!xXCD* zE*2Ii4@35#S#K_gD?7AAPPbY9mqa~(>QTPem&#b`MIUUKxQRLG!sKeewFK)bSM$9T z*+BK+zUvo&QAJxeX`7bjU&+tE#P=D1e4M=8zJ1TLR86bG*pk{J&)C>6^8BqTZLVZb zM*10LbF5kj*0$mq-!@N0uRGSkn_9416_sYtq-+Msy`RBu560+sD%$MoINL1;H0Q)L z*G4pr%U52w8fv&YTR6L}HQHP>KVz@8*GQbi>TZiGeujEPd~VkbNFCi)UgGLd^g8-9zgIWE!zRtr4-KUf8oD9rzcPqstpUp%=62$hv0guLG(V*@6`j;7 z&>na)*eqGLw%V&t!N<^?!P`>naJw>6S`pa+`w z3m%pXv&K3WtnAXw{PPJ8EC-|ls)=zMVb)j;Sa}cm1oo}s8eh@+G0{OTYSFE%0roal zzexM@Y4dV}dkEU5t%HTTX~`P(-bUpBcmjm1LB?1ev?2Ykh7K)a^HeTvCdf930iini zZ}*c*wQ1!rA0o)hM_>|tZ&OUBtv~tV{7fhAt-sBug9WzL2evq_=Ur2m6CAHdXAPeA zzS5BROqfz1^qj@DRP9_OQz|@*5?nj#oMcN8HhCGB_C=??54Mw9J&Zn^iVBU54i73! z;mFkR0V*4iB$v}5h0THy57nCmYd8(_ra3LWGz}JE$Rd7{-9RE3bX9tfS|NL}O&7s? z8}ELs@afnA^?ubS-t^nh_L4hzb`XqMctoGFs+hJ=ktt#+{&V11wMFjwqi;TAU8WDj z{1JYlo$ZWzj$xn-S}tvE0mTN#f@G=LC45*rm}*feg85ClhuIYI*p-n zF$7Y#M3MC}Kmrir(srS_6%GME6STqaZcqnBd&e!k zM}EJQytyQk6aRtRz*2~x998+OH<~QPkVZ=xL5C2*p!42tzW$XhiWn8}OSk%~S==@DCCxRe4om0K!PrAj%oslI>j>c^zdw!CnLox%V`Kv`aGFzuk zUSl}Qn6j6>B9!Rk3%7gcWJ+|;MGT(j*F$gcqR}n-GJNN8@k@vliAuc(C{VObm;fD< z>$n;@1V9ey1Wb@LX!vO`^FRZ2L$zR*-ibOn=0s#wxps>ISFlt_CtfDNF;Jk$oD5R* z1(_f7--=RBznqV^%IDkLTY(42ZML`YAHx>WPP|^O7q->CLzh+kKoO4n*^e%0qAha( zmY!Z+Pw9WbHM3`4vGmxz9SAoY&8$LhTA6LhkGJGQl||gbC=lMVdSG#_yW)Ol$_^B9 zEAh4~_iIE6ke*=U#!FZ z1|&<)>zhA1t0Pb{#s&AeM8!*$wctB-To4l`!3HYFux;=d`R z=*%x^QbHohVb?{EvaIMoA$AN$HVX!Dei0ZCdxIt>2pum*YuUEMl%h%NVJ8dr^TO0T z8s+VN!}Q1Kd(o|Q{r0Q~ju)TT>(f5_S3W%WGRuD@(~FIn%Re9o##9@GHcbt;jDfP< z0&;PInE};xbHA7~gIve`*KktOu_N8KdqqNMiQ;TxhFStWYfhE-dDgJ=-qTpAb7#B1 zT>V$|BTcE(s!DFtTVZp#H;y;nrj|?9FO6g6f2AU{z91&LBBWV6AVGg16I~%w4f?hv zax?)@*ne`BO{T{ zy8iicj{p9Ipp}2Un?T}$LNc2of$)E~_(6n|D$)(yGySTOFOMJod_aQ`F@XHvnsdND z9)bU-bO!!O_$N%X#K~vLECR!ZNEFkw@}!fqQyOF3Hv~m&Xo^j-5vYm9UJ2FqV8I`3Ru1 z%ax&9v{lY071tk^y0bhYY%E$Qci(4Vf}f3vFjy;(Mv;P@<67!roi%!r6W{S+NXPTm zLLLqNniE*UN76*JB}<_tQ|t*r={Kl$bj=2~sF^Nx6t`qm9UkeZtLeP`5+kQ?)?)I{ zU%&rqFTe#IRnOZ>5r@Uw(5RCOheOt;d9G`$#o3@J9d04rRD_js8TJO{&%IB_v4cPer!U#Q1`qkvXKLPg73IfEy( zo$Ejk8Hz)7-As?RjBf-~Vh(2F7RXopf6SHlU)mn)f(-K7g}X4c8>H19+*t&q%bz$# zy?`WwRfDgxN@X9BVP>^xs~22H_G~xKkSu%20K)d+8bdU+OYd;f6VoHm|7y*Db)p}^ zf8CLJ{N0Wk>nm)fZup8Xtv#CxsZ}Ggs!tOkQ6q(`m^ObQ2o^{c-$YSm&LxU0IG#~k zn7vFo#BnPu*b;RG*~nv*-U!qzX@fv7@L42cW|0gB{m#|JnX05rIF7#UfbHynJk*2{ z=R28fpxL@pZtI8H#0UIevY9c`FY0eG9eF0X$A-=DG3q}<4p&i7{>{xBJH>l1NmC;= z#yUHNAM1L@r4E%5ApC#95dPKN1#r@h!2CZ+etM#D#6Oqz|Ej=;4po{Q8~+(Tw{QJ! zVD0}xvu)pD1|A?(SmM71(RAID)JqPx$L-lv2Yin66I?e=*2j$$&a4)mE&)my>A%2J zDr42q25?3AZ(*K~88BzmtY$@5ZSB|rKRs^UjE&MUFx??RLj}sAWiF*C%WsYWT#}&n zbdD9{h{7|*&$74HX8i%S&E@lb@a|NCup5`tMGA~FZGxxenodAO@PrUqY8E?+a?Thv zZ988X#GGaDku>o1mVPtN&UV3(+!f$2?7M+uj-wMUMx_4 zs{g*?S^>3N4&(Tr@4kicO7SETNGDB7%F4?BS^TV(SDdu}GfTu5#*?(qkU~E1YB@Bc zYJ(*eC^%12&`=L=Zur1NXv+Y(Fd4Kin>uBX8Md=`IBlCOv_*ha?pHb;!-|Eg5-Wb3 z56zXQ2@G)&0Fzx@GR))%4REzKj~Pdbh4B?{mHtDfpNe5V|M$fVN}T$f1N8nR^|2>2 z*2FtPuCItmB7#X-!x?Vs+EWT)RX6YX_n?f9r;5NkoP&k7kgZhnv0NLW<8Qi1EOWG( zKS-O4Q&OXJd}44-d;Ahj)Rv3Qz{De-@g7^aq@BfNT^|J(ed!kj!ih0IT`8jq;CM)X z5dXK5ti_@Ku@GA~%aiG>Qj;%TJG*U@`{@6=#>6RNRTVN2iiz!I zz(!If^M;T(M0g6|?{T1@b;)vykZ1k!L_vMlV~AN&ng22Q0I648tPk#8% zXPt}eGh@=MWJ6bFcV9QHHgyTGmfw^zKuiS)cLeimw{bK(6$_`-{G`-8#>c8n|6aN1 zDQOk6)C6t>@Uv0n3`*TE#80UjDbd|)nL+c)O!j`moDsVMLqAWVYiZP>q-VU2?CG|L zXV}ZwL}n6S`L%rLMSr86yAu@&^=WyZ(RXq*Wb{Npk*@zs2LX3P*CQvWwn3sA#T|~N z$<`A%UlR!7$K*N5eEHf+yif>tkV zhJzgN#_7sUV7z+NBAaGxli{@0MOR_UZG={%t*^7gI;&cWjlrG)-6fhn^z|NDC~bd& z4!+X~I}Z+q!2sY37(=;#xr=2G>*x3HsZ>ti|26slqK$kZ*oAuBn3a}QR@Xr&hM~sx zVjc5PUQDZH-e-Yr?<_8(w)J_O-s}Dj=Uf`;gT&lf9cS}{CUf5@D>in5E zqGT)W>d^jD3JHTIZS-jJb#RUhEngDr3G?Y5)IT8P#A#V}Owh$)@h#!_U1<6(z12f< zuY>+Q_3di-Kz2A&icOw!?*)U1`=7J@!H`-r#82my{C|z|X!IW%`_T$1@*k{l;nmQi zUI`%m_}@R+iiRXj?3Eo$@<#{bg43sqp+^WGL@JZ6mM>q#s-gqn`+tLD!q|QG8Ky(a zAQIWxR<`PMC%Aw?A5|83L1N$vqaQL#9xHSm&4#sIUjE=(^bI9G8ur;UuqzpllTf^j$pe84EwEFqvF}ZvHPMPRzewxT2=*r(FPKBG6u=>nkH`U9+ZV=1 ze`=s8Q2#E&<;<2G+Ly!<`JCaCM-Cn zWHGvk=>v95+->=+4tEA9x7 zbU>tec0)(*VhYn!`)FR)vifjZLhtio?rvW011J7|GV{~0Z*Dmi$G^W5V8~K0kcTUe zD%g1j6QEqFZREQ5KlzdAJ0uMNu1Li(2AKa|;eVH%K8Y32>lL`w2}QOz26deYVcwDm zKqUd+Be!Fz)i=2)qVN7ej$Q^c_wcD6L6)cX@Wk`2AObA1`L`Y25~ zxKOLw{oX%4ecgo%Y4A~E(o@q4Ozt~MXuUDWc3Sni<&h?z=vov%t%4PV=R^H#-ItX> zQ6lDmsJaRAE3v@p0=@q?2FY%bOIgj40&BOI=q;F4{?Az#qL*Hi8E zz9Q_Pca&c1q>yN?$5zVIovfx6o&!CGXzCv|qVCef;oUBH$TSFy_$TTAH@3XO6C<)o z{&TN#LDS)C#(~P{Vyk6gjDawqp%)eJ+3|lbKH`k%7vKioC_(W_mLAnyii>#{H%QXY_GW_+Ihzy@{lzuL6==_H zQG0RC$I(+PaIrfpt|X^TZoi_-L8zPko=OKcYXY@H)&bXW8!B_DtThOTT?pp>cX`eY zlWP064dWwy!P5dyi{)o)%k4bIp7QSB;a%gJzFU)Sl2?c057fJ7{c7+1$p!*s2;~&u zBzwWf;w-f5lI2^i`}~E9hL{KIl6-a8t$kJ8XYXMa|F5D%Wu8^5-_ue_q^JHyH#J^Eq2|fp*UR^58NJGbPxf{LOtJ)8 z{EH1CyNTZ|yz||!-~*bxi_J14xRD8yBsHLpqT`d!59&F6P2(dF2A2$?Rs(( zMu_AGS!6Xa`$RkRE<7cqV7=1e&d6|X(`z3>oq?%&#Hu4<|+yx zLSdewGM>FfFpt?`_T1cLbQ>Gj1iM2%4(f~eh5zG47FUw({Xzo?0%3-TcN2yFCo2D) z+W@w-C8^ZMS==u)Go7xe8%5Ax1QOh%#F7>0^u;#zcCz_!DLvMBk@s$d+_8os!s=eH zX;#zLH^u$*%T)TaO3oGtc4|NUY`Bu3wK6{Tw=5XVsBpxLC1SBX=BaHtuOW% zbj&**zCcLSWiUWpCN#_}441=9kpMya(Nl;FECmV9?3UZAhb0ajmNGSqZb8aozGljr zCo#=fD@!&)0{KU`U2{;8lS)OVA~XuY~oBD$5VJ@D3Qop zal>19gz@jsKSY0Z2Wg?3P9wrE@0Tz^Eq&VnPtKIGT8ZvvB>3uDYJAv|*RMSg#m__u zPN!MKAA}nGfyuZ#vLe=?T}wdzO~`=4w1v{7>z-6g%s>nDSz z4T_OsV$z_JWMpJeondcars@HF2>;l8u(VvUe2SDf({VwVl&yiU85FNn<+ znMJVRLRy{&K1RLBLHddEllM?bO5tf?p<*;DQl*N3N-@Ym&y%cMo$XP;>voA`+shu0 zkuYsouzr%NE@;l+o#ukx8jGN#ia?;{z0D=Wv*z|t+5Nyw7(QBoJN(;~5c3d6=(Xz` zs6(Q^L8omUzM8#S{Iw(z_#kO%ZeIU+Q zG*;$XCM**yGeu4C*Q70m`C-#7!DJVBi-!DI^rSBu?3P9+sN+Q$2%d71%DCO-9w!Am z@wr^p8w6Y}D3iFb`k$whHS7pSqan&ty~PXNt&d|tiV&^$!x>Tc z-z8RRosl(|WQZjLp(27%2<8w5SY%`ux#!gGtRJSu&7xoIaz7#Se9&hv->la?^iIe_ zl}#K+VE%kTcJqYLstj#LvCSWY>tPv(zR$Mf*PmNWcGd8WZ#Qu-3Y7bo)gPgWKVLuw z$C-S3lAxdQ2MR3Lt9d>9FF5XuBf{Ma!IRbI&5PJ+lcmj`v|8kDb#C25;R}DRlvVS2 ztR;H>a!)K~wA;$^Sw|H5yyCzSgwjJTO?iU}_qN6bwVTQ!Ia%85d;=mXjsE-*g_Rpl zV^O$4XLoX;C3g=Vgd$Q%b)RC`Vdpdw(Yp$xvdqW2FhZ11HhTfzb0JiXx7y|C!>gp! z$GDY8ZR{+kesgO5*6v{enJc!$XCoD~c{fvg>RPM1Dhk;>zhOVnfXMtnDV@l@FA!cY zGLPZMzTd}9DJJe(_`ixL3BC)MCq0@QAUL>Y7jB zsC}gk?KfgZV9vpx8cpoy`4p3S=|q?B@Lc=Ei|* zXxB5y_=Q|m;8AgZ${Tk?&SOmuMG}^Z1Oi)|GM~LXz#s}o1~<vz{Z#kTZx3g?okvM!cvR1cph1b z0c3lpi~tc|vPe(KJ1CkY9N$23M=IUN07Fn2b&!@^sg4r@vYS9wp=_keX0gXgyHT_e z+&N{#SLGVFkOMv5qvf!8PZbh=E>xRSRH%%LxF1HNX-g*fBYe&mhzhs(?V##Ax(M#e z1d0Hi%bwr!h;Cq2&K+^O@NkiOTVXznPsW|o`avvHs^Mii@-w=fOCx;J1P8k~T+~h6 zv;(x|?az037&V*uvCXg7=pj%0h$(Txlv}FY#ka6AG9wGeK^;yoJ1hC2j|i!3K63N7 zlFjHJNO}jGMt@9%XJ8wVN$+ITmopA-j!JHtz`$;?v%wub_UuF|uQc@sIDxKRj5ed= zqC!B#Wx>katIw!j_>u7)gy3 z>Nzo%Mh?z&l@AyHiw1X^O$e?rvrX~qXh6ahSwF4bw>1WjWT^OnFEvYff!;i{S=I(O zX+aH66+1T;N?OKk#hxvSS24bCgZW0F*@R_;;Pjex{Gou4ELU&#>boM{u$5Xs%v7pK z#3y2kSn$V)Jz3mA+)&RSkV>d_m=q3}HJ)_~$}}BEf=>@0%9GlZ7J@RDZFf+fhm((= zRE3tyod>V7|A2p5BRZ+q3Tm;IvSKU{ZzZsP{*oYji$}pjM+p|(E3ia4p;mM!u3T;m zUMZ_vxe!BtpH$`OvoxSaN5C`m*!596bNQe#qcKK7eA(}|WndHXQyMcV)`y~^v&t$o zOrtk`xlnPDl2E1EpP^8yuktmK}YAzE)9qzi)b*)of;da=5mU`;rXG$cJX<0 z`%X?tB}{h*u^JhXKQ)xR3hGgc#ZrpF2*AJ1+S%9!xpWPvy#z>4O{qwZM4@KONrbUk zW2#&ff8WD>t7+Sd98HOE`>lIJBTVD%B_qR!8p)?Fs!9 zA%U~mYtR(7d8(pyNg3r3Z*7lE&h2u+dMS}m$fRI?T-LRTe`DQS76)bp2Z| z7K)k;9HaML)lt3N&GdrQv|7Xpc@I{0&^KSEP@)-!&U-5df>!dhDLwP2Uh7}xv~IFB zli9un=2nrC{rq4P-2FRphS$A#mH6btWipr!a+C3Auk^+<=%39KMpI>B!8i~Sgg<}7 zsbRbX+wNb#nzfi(x1Razt;fH@z-LzK$+3|0)`9=vhlm~R8Sg%=vz*1r0QdAIsywNs zm`EZQT@Dsf#x*T`)1ZF%F4)3ba@qLmwE6pdh(Wt@sht7-N9o%Mv)hh(rFPXg(M=uD1BbK=f#I{14Va7jZ1Ys;OBLh3H^1J( z@`vXbe|Cg4jP-{ooqZ8dq9UOrfB-^@BSNh@R15~_a{q1If`F<420kcMi!F8|;cj5& zy8x{QH?TK?a}Znw6l!o#0p~GQwhe+2k6gKV2m6KssREJzr_v-{)4>9uXT{ZA-yd4{ z`Z_Lwy!?V7t^;SvUbwlAK0Q+S!%DktyM*5lQ zJUznf11`3vC33q7xGBK|OHg*IYfwjL;t^3#L9cJjMgCjC8(;Nm?NGVZoNCi^rPiGq zp|^u`hi^+RcIvQ=D-*<|fpi6+<4-S4PIi8-`U1}bS5@Yzs4?~86;08Vi)6jXz5Hl# zKbE`nV8}b#`MR49{k@~$m+VM^<1ckh8Vj`N0zb$4_`t%gDT7{ZL^*lZ(N|EugDxV!l$iqe>!hZt^PQHQ=RS#*43$Nc8GM-ne?JS0U2-VS#rUn9nN*>jFVSQR!bQnN>|(aFg1z&yml& zv~;6j?xGw=GBXo}QR>FR1Hw?NmP(j8&lnrDrU(vzsvqJhOesN}7PqCY5dk$Cu#Evc z?nAZ^AJr1T0K}%s#A9#l_vkbgAihaQ7lDYMFzb&>DxPHt@TkBsHesqo36$ke26UL> zFsn&rQm&Z+PXP}#nwn&QvNLu`+DW*>>k%R>27?|HT_iy4tHpT}b@@q6Em5=AUgI^X zu(UGWOf3Ws>RA1Lz3TMUxo~+~2j^Q@(d24?tJTlfi z%=`Snh=O(4=VLKjp2@4HxuI?sk5KhM{fK!xjjy5PCYRoyFxl_;xCrD`$$G|LE(;Ya z9|gztDq5W7Y}eUtZnJ}%it%%M203DWU!Gi-YGy+QB+SeVK7C%hlHyR6rJESL8Zl|b zo70KDCv+hpritmW-hA1)F@R5wcjxIAwyhGSqaiTNB8=A;a`Gdh3z(fyye#u&iU@2A z*tC>GycEL3ri*vW8v>tb=v<IOqwQ`+#&Q+_L-%atX#M+uZgjH zouH?TZ5`1ZbFa6z@7l&Ab$sEr=bO-6nE(qb6S8vgXQ;LK8&0IwJg?In!o~3R*-S0` zM#}^pk&5Q0K>RlKB+1aur9HoFL+vXT zJx+W*?UA-4k)fcLd3--*X5N&^YURM((I98>x}gVW6iM=nrnsdjE6sgN{RBB+r#rIB z%fs@`);vz`w;rgbi+Yz1br3=wNtz_@AdXr1U^%SLi4FF*Tt)0|O7&Q)8zuQHfdeaz zAj500I zVwhXv^|3(c!0Er7>vmK`j*2`qIW?!!!Z1Nx-A%^c(@It4Ka_DgyH(?-_YU&H++8?% zDNxwqyB{K`;GsJbKgn$7(Vcjm(iQ#S`B2uHq|6Lma%csKRB-U|=yG04JxDG@5_L&Z z2jzlACK4_$^z4^mxFY8bns@=W(C;>*78vHcwnZmcL$CEViMF!d0Z12BpPxN$ea%m* zA0c3Z#l*Gx1>I%U^GJ=!qAOYE@5jb!>N2<@`{PTQL4-KD8-!L#*)#lnsfrZ&Txkel zl`Fwte}!45>edX)!j&SmG{qO7WmaWu2rSw-9vHQiCpo$!+-{KUlS9}jfQ^T#Z6|n7I8o2O+Y5`8vA_>^xuKP z*h0HcD-K|bydGEoEP={m*J+oak!0P%)P&p)GV)=B6309K7s9ko?J zcQo%!u))FRisW+Brsv+>$ou$oQqpv(z12pjAXLbZp46ON%1a=A9AAH`<)Kjm1t7fo zPx6Vey{eSW@t;Xua`5cmp*bW-^53k{dMz{Z_eT3wuAdbn7b#c}3;2E~28chjc8aN? zmTq0;N3f)Jup*i8t$++ zCSbKo!jNn@IKcILf4L~}cw{|+3i?!;0S>ygcw_0bnwXMu)hD;LmDx6d@wyi=717gN z{dVH={IG^T{R}`T<8IX%J-6%6BUR&1aoste!&$L83sxNu6LN(fj<;kPpZqP zdAxK+9ws%60{;1ghey8UNW-8Y+yqFGgAdnV#?5jh(e$Xbhf5@zSSBJ{q)jD+ZjOC z%zxbH@3haGGdaD-dQ6F`nPej+5J?qV8WvN+lOE2m&D0`@H~l*&Pz_e)Vc4VgUMtnC z5Z^U*lS(Cq(mG;PN~2Q6wxw&1iH;5c+kg^8QD>o{Qeog=tB`I2FctnjVL4qX%`5%7 zYs<)RE`r9a$tt%_dc706JWFm7$>1uWO#gqbB!xP$I-^9jdH^8+<{=uE&j#7qge$Rh z%fF)}n%pt2WwIYCKn7I*@oL{Y!=zM2u;9pB#4bVow{S>_iV>A+BvsnnWtaw8jiGW5 z*XAQo9-+Qs6z+=P@$bdSl-?xQE-_{WFnUVIC|b9!x)}4Ir1z=zMc2BT(%2 z4eve8!y6K&9fC8W=S)c{h}vJ%M_d`>dQeKgZxrdiqi z8C|2xO864xqm@M$7W(#+(8EgWF;SS{dxYiO&f}`61Vs@OGwJ}T64khJLUElf0M2o+ zpOIYfR{xn&^*w^a(Y^wsdDj3(-7&nP2X%MT{dnuJJ<$Zj4m<4GN4fX22VRVxUqGnT zy&-}|dc8bm&xC%6Xgntd7axS#gE+o_RpFi1mt)V~u6j3(Q+euxqWZe8iB+$IgngkA ze;(Q9Nrm~vh~@cqk8GEZ)Ho{N$Dx1?5-DedqwZF6SRDV>A(Wl8wSe+Pi za#(V7_Z2k;iE}2VDQ#jVRmgPOHzfa-H=!3}SmsN9z z(8QnazZLG>W{uBAQsmItv^vfWWpewcRd5tO8HE%d^(k(k6^Q=C3T`>NF+FjZ)74o|p_GPj1O}nMH zO8tvx;veYZw~ra}Pe^6QaSiI^wFnH_JCK*uZ|zdEnluR{r=*WZN;Sk0@#)4r2|vZJ%V;e? z!q^z|t^y%z3xBblf#I)o@N~IL*ipB8BHs&0Blr3Zxz?PDZ<$-v<+PtodUnPl_Ydr` z!KPt|G*Z5@BA_*rLX@hR+n!AJbKn}hAY3o8Rp;`tfO^13B9~r2&QD+$`?zG}!K%sHd@wM%NQM+N zdWb;g(|HEZZX>1SUi9TVtP4j|Ne!Mf2cXTYW8c$CchkY+b%AWjiaB6v~norU{lYxmTgL71*p31JTw8iGcNBt8_eL`!u?^atw++SLtTS`>AW?}8<))-4xhU%dIRtX7%(gBo5z|4Yj4CoUHc}B~TjMga5b3(O z@%1IOf2Q*|(j zV>A_3$K%XM#u3BglF*tony&MUDQvV!!ZecK%=FkJ`Z2>;MJ#a~G`Rgl1H>tkY1Q!Z zlc}bkhH9xhdq$4#jF(6AxIn`nTg0Vh(_uGgNIq1cjD#na8j;h+1dMt#tM(3h1k7Fk z+|t>kvEsCFrg6~8>1vQ9>)9SZbR>QA$a~8+j3-)*4DD2lgFj%&H3 zy+rplB8H>NPBw?sSc{U1ah^I5uVdrChwYa?wthnJ+SiX%{Nuyx>w=`=nx;0Q!(wUe z;B@H^;Q}vsifV*I_jwVL(ZlZLQdIEGc0=3t^CNX=AN3v?Qq&D&q7pB154mIuv{RwYiS)X2!%4NxNE_qUy3? z{WODg)YUL_lXPGo)bH#%q10oQsnur}zkOCNqn)r2#+QGlapI1PUUkF-DyRXp z#D)=zk7H36MPdeVDQ4h3s`2NITrP6WCE~HJ{ zj-k_P(+7rW3_5@r49YU>D=EUHKN%PaIgQ$FS5c)&2{(mE)5qX>@oaXvHywQZY1=V4 zCf5zX4G=c0@GBcjibvuU^FZ_*zeP%3G>V->iI*bX-oc(*e6uN8YHI`JC?Dg`%)&JI zHguZ!nW1}o*P4)Zg&R>A^6*#^Sm^C7WDmPUXNapkf_^nJ5RGvsY{>rfnH$Wx1@8xl z+9|9+@}e+4!v1GrC=BniR zHs9(dAD`li1v3pY*G}OiwwN3LjDB%oTLxeD8LL-2+wPVu4Rov08q}8KLcsbO>@|P^ zo?d|vE?dk-LiHE6X0RvJ@AWj7FC;`;cN#L$nDm_PLdqtsW3j zxw-XE&1!~tQ$p};R;`F}$RRf1FHix5~MU{mD!~Dn{4SipRRL%SriCk7say*mJnW7*8#b%RJG%o&s zMB*(#ByRfzl;Z&+ahBJAMB=sJ-<11N3oocwJhuJ7>a`!Cl8kY0Gf6k*U$Q&_Awc7q zl@{EW__Ycy`QNx9#(&|4a@r_>9pD|E2kug4%W2<9!%;I$iO|hO@#5LaQb_>y@IiRDjjHgmdvl2LN|apb~K2B3-U5-uX-LB6L*5?nuze^R|OkeZB>JGGj-{IH$NY234MaR z;rRW*Mf&6V%&%#sP8i~Mq$t5t@DL*Uc`gIZ^lj>^qj^ftY6o_aP%o4b7YZ&80DM=2Yw&9jvY zbiyBmXavp#VhVYT&&Q{O^(PKLl+>+FrXWF(@xSsyLwxE$F-Y^{1uby0P+pFOl?7o= zrI8IQNfYfUqo9d((HgeVhOPWu)j6=#A``l3RGl=jCr+j}IyyviPAu=>A(QOFF9=4Pc)KWzn`n0`O{9)@R43 z43)>@CxK9D7{mKC-1-j4qwr)jBkM#M^&#}|&@y-BH>yLB06ng_OJgqPzcQK)zEUAD zl=r$j1*+oqZbi}!0T{x3mA<2hW({Iv8H}@_3}Bvr39J{E52-5Zf7u(r&V|bixpfQ2CDVuSLg`l0jOmb1`Wl#$S429iA_s zmj)19n&fk-=Jx=XIS*4<+yllDKZsnsB?gsxhQ8id-->fdm{j+kv&#U{ajmG5EJh| z@;yA4N5d!RRJ!~YKJJ9QA^u~cIFDhO2;1akQmzsC2pF&}r!99T)54Q}E#gyrNTz;R z2o#7vWbDt_Mlpm@2&T)ME?*9pc%FCki-^QpJ?rGzOi#p(MaV8tO4S>XvwA7{iWqxP zQq1z=LSiBc5MEI%HdqHZXQDwf)17g02{P$AMfIY+c{Xm@Jb3nV%AHPk3nrbAYPHgo zo}#h+tup<6TwTGx7OQ$NDXwjaIYQj|<$2HPeYNm#q}lcf$TiqLeEM;~^Sm%enZU>( z5gLz$c-VPtlWl+nJ}-d3<*AQMfUM1O$BO=8RSUfBS8}>n$#ud{%$FG0{f#p^jN0aS zt4LYsn>>3bPY4?L(-m^kImRlb;p{qN{iCj6S9I)eFtL+mvN8$l4GtUncJh4g$P>1q ziX(+4WWq26WCL2yIMkE~6!PjN`qbpjx7!i%lS_>a;4xqyRu1A3vr*@i36Iav4_#NS zkaO$N62uqxR#n$K49e?~YpV-KKx#$ABI0rKD@-lnaY``$Lr%VVYBzs^lkaxdws#VX zEQO<>Mx@HFN)OBml#M<^k`8sV%&#Bo?`1qkY!tAh3`WQn@Nqtn^S$`_GbfJPaY6ip z%KuA>nko)LSLHzRvBH|NFo9l`h#)^M`!<(h*_#t7G%W<0Sg2`&zAKRV3GnI z&&kC|N%IvmJxyK3ysE5@1=bT#A(^VsV@j7SU^MrcxZxxR7&Y|Z5!EarsdDEr z0xA@MHNl5G%aPIl)0s^;yC$nrEa>&RJKTy?Z*Byla!0~{;*RD&oPFL1njEIr`5uiYPh6|2h&xp48fQ=TntU4slLAa`1AAZ-#HWk50MkIrr>= z>%8-A72K`sOJ8X`LDae(bF+X-OkqkCQ&bnVs>OX1L22(oqEHrFIf`cgw`UUKl1xIqEys7Dz0_qcd;N#YX!TH^i)II4yL4d zLPCDey~Iz%x?czF^0-=EuS9>M^po5tQnz%t>!S)8a|oBs!k}4Xt*q@fx~7+wb`a?v zV3tg^1r*|$QGZlej{jgtE>#X`%ilfK8f4l-i61}|NRNyID~c@l-lO)@h+v-t6Jpgh z1p=0!pi#_#flDR8nn!Q89IIWwHL)Zi)DfCgY_#^}&!bh7mi;BF&b>4zz(*)E>k+0S z24)f<%kVb8{5e{@%0s!=9V%bfLtB<((S>VK_a?mxeku?L(c$&!!M;oIV{_{>S7$v= zf6OAjHOUW|Y{7UoA=-kTbU|-;7cSQ!#1|Z@*rh`v&`t0H5}+|nalO?5G@KmPT4GZ~ zC5ZQRJiuC_Ov(BdCj=!G6MrllJS_eDQr$_b-sabh^sklqYvkOxQR7po;Crf}eEjB7 z^>V?pM*Ut*mr1}WQe_a(2Vx{#4Ve8MEflosw+8kgAqhH92<(LZ1=IcmwA1m3TsWA) zt`dItMY00=B9Z(*e32Yr{1LTyuPDK2Tr0xQNZT`nJL{r)0jEi;O~g zb&@$Ml6*L_VMqcKQ}<|i>x1Wq=m3W z#v*AW>T-2;tQyG=kBm;Wp&1n;o6cvsPun=ci+A%c;NQB);Kk*%PdHdY#-4WtNptGo|ny51#!6vmd|~AxopQBu}H;s75lx#ZWAA0v9u3 zDMt5&gx12m-W)oZ)X?xn_xr9`7&{iu7Fxg6zNPngaw~>pV0Ri-%z71eaI)&_SMj_58hUB$6OCb1h0KjXc(NcEbRC?} z6jI4L?Bcz|9aI@ta^0V%Vymh$;36{FH4E+pjRlLQBN6n((C8UMh6Y5-$&=i83FE0g zCy5h;NS6ySI%A{rS|z!@Mtd&MIbeB`4WD{x#tI}nkQzqaYR>DslN8HiRZsV#sQBKU zGXT;$JL+wBz^?2yagA%-mgWy(T2jYY4A0`Z@#oU+;$6lLB@ zarjTsp9mEW$R9DX6Lb>l(!ixYf>FZ{@Y8`H%a%2L_tU|&I?3X&6e*Mk1#C9&pgE7o zU)lqJs@4A>5Q}@S(Ed#b1Kn-P@_WUcOZXaB34jn-bSwmQ`gl5BtEBF&)xT-ke>@O_ z{>uY#*Wwx;I8A*wp*o2e|1io>aEptI)hPeYkzuL#)w&4(KsE&&d-LJRwRXLLA#1p4 z%H*D<$X(=xiPxYoTh>gt-jGrlSkp;lWlbBOls+~Ia)`5N!cidn^!p_O8E{8c z>)x<01f$M92DY_#{IfSyhW;rpQuE&TdZ*!$53Mfs4^gdl$oa!W40pq#oZB)fZbBKk zX;f&@;$+Fv6lmj}FR%^|a6DR2z8V#urA!1rlZr~FQPBI|juJj!8_`O?2j!rD#D2h` z@{ReIo0pgVx6H(t9F8F7Pjdd9kY^hg9^G3C)HR@`qBK0e;YxLi8F+8=@7`OH!1ooZ zc-*dWodmL?0?;1CdJf$CqIi22u@A_NAwU``PTY9&6^;(_GR(FA{lI!(1VGi$t-~4M zd66K(AT!{>eUx{zkKs7O16UIS~Ykl-;&`rA%+jQzS(;+L)Li?jvV${r5uC)$NyACb@jCnT9&T%^3(&av$jws6>V z0STf@Ki_%w5Fm;V`fneyf1*XVnW1wd!%o^WBnrDsR9F+Fa0V}E5G5=n@RtJ+zoTe9 zfSUzmfPm}*{v9L=QlzE+4)c8D1|3pBL!F8Qr2s)OOQC>8Doiqg0`X4KO1J%0q7wEu z99Th7ODnWgCR6UTA%3MquZB+c3Tu@nBYmISfJ3sFlJhtZw;Wagz4x%*eHv8O-N1nz zaXo2sL5en0dq{rZ`%N+4^kKY7w?pgWmbc!_>F*lN1T=oJ;auA@jK=d-zG;fIHk9Er ziq_&VMMu^!cEQ17i1p zG!irn2)+C)|5RI&@jGn(zxQ;;?>|V_Ea*Lw0r6DpBTaK@*A>=BktAT#&Ab>m>Qzoj zuc?C+mM&)K8~!i7;#TOh-2qyVF$lFrBIH)qcRB;GDGQRTuC=WJX_xe~TW5i@a?X|nr{=_o_@-IeiTSq^iBDYv+dIKn!CgDLa6X&YMW^PgER;+@}j z?BPIy2G4bBK7X|Q0RI9q7&R9PJf)$F&Nllb*5d-QEei1TIL#0rbVIIK{C!j3^>U+t z5C7}-2;hHA0VQSDTPx2@#tk^|JDnUgPZe`mLL6eTvF3y(H5)R2#wPz95_3CEf_>>! z>-}xj^vc zgu^k8+=o0rGyJCLV$Wg5T1;v2#G*E zz%v34V~YzAM!+UGHTC|AQz$^Zm^=tN0O3u#6NIQd8yzHz8xZ6GhwML#1_Mp|HV2v#o7SDe*j`uHTpPtiq?;M+v6vEosPzIqGMylZULe*E!1}Z8dX9 zle3f2IxujN!-`UqYN`Api^Jw)?pBEM3k{J{CdUnzwYjDeBlV~MsghmeBbH{lj63b% zY<=5ec&~dCU7wTxrTo~qwF)?@!Q_q?mF5v$;f$F4N{(RPpDbGV7g-@W=??>gN&bSh z0s-^MKTfukdYXcKPz^rXd(P@*8KO{!n&m+mBZBgGoRU%#4TO_LQ2gDPQG&C=8TwD4 zLFoM*3rLs@_|a%6RAkFi=A~6p>#+x&5{5gcj&8X8sm~udx7=|kcil{8DC>6PO=TSE zy{u8&g1=2^8fTs@#8rH+w7ws#^1HAf4(RIQO#Q$@M}Pe}F&U(;NSnllU>sXMgC^ov zITbD;`m%FFe==C)YBBEWue`aCe6`pVh-wm(Z| z$gXjK6z!k&e7~;V692E_6;QhdRnh*fU0Z9*>Vid02jIZDQ4~p1D%qii%m6iKa7Kc* zE7om#6F_~A2Jo+#Xb}RPqnUa(#fdQf-w(zoWfQ@|*~AnGs=%@WzL3+-9R-0cUpHqvUcg zlW;B^930akZ((mdVhRe0e9G@CLJfuLl_|70($o4nId!wJHC)IyqhcbGO8#o%ho$)+ zDBj6XUfQVk!}d1k3}PoM<=uFdc^ws__PCZ2@<^C@-0hRPPLZtN>1Oml+44H|T(BFE zf(cN>DGWF%W+c2n=D3IYA3iVMG$PGAnXxV#R@O@lYG{0n=vmRozaJ{`Kh9>q{LK z$XlN@Q3`LvV({KwVA`C51va*bD!otJxI`UV`g9Lsb`5(1Lk)9vb_)KiM8E?*909;} zFu=rUzAL`~`KWy{+48YM_lyQJ{jziTGS-@v$JyC^l2CvgPFT%fV%21`mGVkLoAm;s z+F^EZ+zA#rV5=^c%p-YKuxjIBj6A0$A7J%bfb!RIchH6Zy)XLTp1U)ZSIo`FLJ-EH zJR){F$v_KV)@tYneSYs6-C)E!IGM@l2?rBcL(armc&pyzAGl=FGb@RDZ6vpHP&`;J zJJ-!W0#HYO2-xiNe$>2#$L1OSNWOmX^F_eR{2DhTI-EkG>^6x?vO=E%iwyVE>nz{o zYLOgu3>3fOp?k+9YMnThQ}@IMH?he?_r)p)@758tnFbmrhHSYWezH51BiGNPF!=s* z^qXteYlJG4QYBt>gc1 zilRnXUZ?#Y0!>N9Ii%{XNXo)T?=~dmTBy>hpZDW(B!kK(cug51F184t92uy;HuK?C%BixsPw9Rl};)wn+{qjOCE_&1FH zvq;p=X&pT+vK1Mw3U3Kv+a~HPRnirwzn@OoM^fO;ACFzx<9~?({ciqq@Gkma^?-0T z46N!wh^(4E$KM>)6dqtH%Sz{Z3B42-c7Z_LKESp29lThP$-1t&?RHoqJkLj0Ft1rj zfyp+FSa`7a4BLjUYP9MnN5=t$@SUj08}{f6uk=W6gCaZ>tG7zPr>ZB-YDaxiU78lI zp+DuzkOvxTducy^i0ZSj1`|s14*M8-hVyO7W?kV(bj^E?y8SZK@yH##-~C>Fj2wXY z36p{=HQiN}W5cLx_Io^oh(IPX2q4o2G`oR+{4Rd{Ab6Db<@`^_Rs7eVnQxR0N))N| z1{Jt>_36x?Zqz7k+@OGszph^MIu<^CZuy0Ima+9yM32XXx|MHp6U{tP&XJPTWuhMz z2jdB=;3MyajtK&Do}@N9i_h2*gWz=udJT~Qu5#`ZZ@MRKc`x8K7hq6_qz{!UPxQk$bkpJRH>~A;ORQ5){4mydg`+bo{*RJ&1 zUZby{2x_1~f{cV4jQT?$;b%h6P?hSE*w)_dHL~{g#PqL1Nbh0>z1NJVc!xsK8GN@L z6m-9|59vFgm)|9?ji9Rcw%u`64%KUY06k|)3Vyd&`fI92YyWRkwcJBd(GEE@xNy-= zN`aSN3ms)rr_sxkmh97fZG(ah?qY)WaB*f6mEyo-bI><5dyODZZ!_D{o?xFm4HR3& z8eAUGIlLmu0i}0;&#AP3%1YP?lL2R*pC=g7Ma`?{-mMXJRwG#RNZ6=l{I;u}c+mQ{ zlj7Ql=EXa?U>-NAb2UA@da-q$K~d4MW~8=Hv)s!l{TE|%tYT5=6<&xUC@WNS?L*^5 z)7S5{_qqh-f32|~?;I6{*?14ejnEXgeR+a-yH`5IWU8~4_!6trEf+NCTIb1JC2Wqt zk3olO2Ds5G@D)~M3?L|d>dS|7u98kVe#0E@bS48@{QQsB6VRKUVY;YSE4b#*B?}@| z*s@|;gd%r4W`lw@_7p19C988CS{qgRJSD98863y#mV|?|I3xa)!~G@*&`cH@sf)XJ zv|-s#De=PpZXSd$Ku*Zj#@|a4L`A1@rv={h4BcjJl^YDXVD2GG8@b2vlSb5Z5hGdj zK5=*#tlK6U>M$abO=Xs*kan))Til_YUs^yg5jhU?L3p)vn}-7Owz6>G?S}tw;jP{U{Ib(J3hS!*7qW(0T}&}B zI~>6_tlKp^Xy#l=YTBKHGfa#K*6}_x<>^V>Q6pZ$>PS zMv8fU;PHVLU`47&^lG8GPSlyybK1jX+4FtH7LqxS9zTP#jBs_MOi>x#v zOhFi(xmK5c;OaDdH2N;jKEDSJPeu_%`I1=iHb9EUN$Ih1pJ(EvV2lJFUX|vIeq705=j zySdjXgEpU8jzxddTH{DwZg%HTf{?U!Mw2!7i9z!d81Ix(uA0~PH1<53G}ywXS18LJR&Al?0aQCKE&@{Sl8 z(+za+i$~i74q7#Hu09*4g+RswhZ$i^!*%U&0OHTdaK@~E8wgLf78<7EQXY5yiBO|Yo0ZWj-sTROA zi&ERUQ=MTe^{*in_6+NH_`lBX{}V=du;?m^-fidqis?#WVyyWRIRCfplQ81HWOe`J z3Ff&Xq#1Z~^)?Qvd{1mmX3sK{G^M2PCW#8#AA)Y@9umodj^UaO=+^(<4u&~|x1_jUa)RK}o`l#-Lv(_t6$ zqVYq>gG1dq@1pH($>ZM~hUf<(Zzk6_J1nk)pHWSNsWl zPtefqXpm)k;1pN24q`z{g7g&1q>&@N&*jlaxvTkeGeH{Q_DtjwEfn z^%Op&cBs?*cQjOgs62RL1kpg?bH|)ZtGS%q0k(lG|r6OXBD4NBM>?$Y16~)RqTBCU1c4>IIC!MqiV3^>g7#)-FYy?YBDEI$? z4@Gj5BEs=cuJ~Y7Qrbi~as&dZ82i{6r6gqu;Jp-cYkYm)5b%41-9B4sO>|FiU{utH zPTE(jrzmlmd(^e?JW*(|@LtJL+P5{kh98G%R;?Ra;740<09vhZ5GY%-*)Z&U{(aa~ zZ_#3XfG)w6(AKhMh>2r5#l06EnjyE^VEL8dtJ5MM#tFN8Hpd+)gg?}Z1(ZDz$tmL+ zC5el)L(UlGF@$vz^Rc~d2Fv7aIuoi1Gly38Lnlj-X6iEuoiB0&Iq*0lWbQj4cRe3! zjPzXmx8!r6_}PfyhO-$#Z^wk>KuJT+$uXXxPPh*9QKO8aj?&KurvsMpq$I?L8PeDO zh_F{xi}#YG4_Lh+%=RaC${re$pE2+7hO#Hw)8+L&M~oP#bN()=^Pa>Hm_)11EC*ve zB80PY>oQ!U=HiU!a|?!JjEm9NYYe9c;i(aI4#Nk|p0xzJ^S>)o-{3VCV{5jP6PaQT zXt5i^IzlRxWi~m^LKVChy%d7Exze!vKy&^mT$iE&Q@P*{5E=LpQI8&~OqGnO^yVyZ zCt}>Oow|*fnN69Q)#c>o8sa(0NfvN{aTOZqV`YD&nj%zgvvi@Cm8UJhd2*cRwq4u` zE;x_x?b|n*wIsDUc|UeTA%TR1GWB|st zT;&2X2e2~>&kB>ufAQ*x5)D(#;=5Eg;+M1>-G%psS4wgm(~XrXr25S& zZY&_Elee)6x=&j6wo2&z2f8OG&gk`qoI+#Z?xL)7eb~n{aoC&byxn&Bc*LGH2`HM-Q(`$oae06kh{D;k#g*YE&F7v zF(*?n$0J@_GyIS6^OmO+n)+pKb&olZdLhd+`*gS&-n}xj++Qk+2xb}5 zY-P@8wHZ;YEi+XH)-&fC#LGy_W6i&M#kDb-9{AGRy!aEd4WOX9ky))4_*u7Y$a2?- z7ao_;SZc1=iiB^Fc0>PBx>lTxQkdQnnuwlu%ogtw>!RMu=J}279>!O@wooR@XcVmxVJLZgeB>h-Vj9O& zQB!$JehEU!p(GL%S}E+|`GJ`H^tr7H;_=jPhK76!=B!amUSdeiF7@^LiKD{aJ zYOMNLqmBA>51CdqD1z_uuvzQJ_}lBSNBza>HKGc%%Ov&dr^=i9a&A+a6Xxe-+Hjfo zX`BwhDWg|krA+T<4ANRFM)lvXEB*FprA^P6>??Hl*lU0vS2~f0CGJ=E_IiWN?%qNm z%gQM*dRY$|E7?&q?z4g})3uD^_Qa;yr#5<>e;aAKZc(cVS~Z1h@wOimZr@qun0 zUo2L8)*4$({&soZ6ItlbdApyp%GGeg_B|#-z?f>*t2wuQ7h58HqH+@Pnl?K6v8;zq z<;!Wqa=H`p#0aeW1!>xpdDPBd@scQ+Wu$^(;16%LQ6*PBgU3Kc)RK?fv?&#<;TZJT zuyGA55Ed|pAh044c!58h9pn)3q<^DeZswPkx2&=jnSO;W>+$`pzi1ls9fnQan6bMPeUR0>^s@6)xswq3l_S_wqozb1$0=?yb=$T;EdQ|A$ zPnB+Z9GRV`7oFS~@h94u+t#j25sN|y8F2W}mW8WNAZ!rhugF-JC6n%xR6EK{>E&mJ zn(i`H2Lf4AtnJy?=+BuwJKY5B_{P``v9lvuBC%O0%qY;g>VwGgmGiFX(?m^RdMp;k zV;naY@X;Vkc&Zb(gaqzIV~jIy|XYnUqF_ywGV)Crt1TBv+;3n8tBnc*0%ih3ZFxauXP>fL%28qp18BTDGmQ1US8vmFB4t1s_Kq_2P+ zcPB2!Oyf^iX4OG!$<-ye(uR8qAwX%?%x?6RePpk#8i3Y?V?W#zbby%c^;D?Lx&|BO-ZXh6N0@`3rMd zTrjT_bEjrDR2M1YMrs-ATR6AikL4_~R?y`Kv+U!7q&`9>dRA$;Bu@rtAUjAP^W#`8 zup}@o%nZwd>>lnIdH>Q{eTeXFKHuy(_CMECl9hzk^fOw|81eY(j>D4M$ltw1@mwwS zo%am>Bul8`x{G2Y9nonzSmr`cf^aTTL z8GaT*`^!OoRL4>4arI}09THGh|3c^sgpCNZc&MNYK_MoZz}`1} z91&T8E**qo*WgGHrLHQswe2E}plFp<%E?WW=E$K4(dwR~5o zU|kr#D*)r;*S&Eu?#_vH@B85CmZK(`^7au!6_6$blw=DK?zq8hdfk-nZTc`=(#&}_*YWT zL7AK85goEa={jyNF7IC*CG<1-$GWQg0B^6Ew39^oWdz07rO_ z#k(8c-75=Ez;|>|0C{628f>6Hf{Xz^5W`{?+cS$iJ#p+W!e<4glIvKsIh4bz@=kT= z>pynseWn_|4K59>nwL0~0s)s;I}(lQEK~ejKAYdW6tT>f2!5AI3>=(BaU+gSPeG{2 z#y0w(R+%5t_+4f0U8*cIvAzWQcF`W$SE%%;?1u%s@kY+thmt;Z5{6Jw^(xj;w(siGfiyvi;pmbo5nY7pf)jrJbFso;=yW7s^owMn3p&GB z=NM0!MawvT+e39dC@7e2~<1zA&D7Fr1|F zaz!j|9{9I}9%Y27`_%9c5Y`s`OhsAJAdG#OU1n@&uIj-!K&u$j!#q{MOk@Cy!Gs}X zG>PuLsvi`&J@ytmY6V#Z|E>37x;TNgc-u{iCZ(CuCpPkw7)y>~i`}q0J@Yj}i2e3n zaJP}QI5$&ml~#wr(Y=djgEhUD<_iZ>U>B)Di4lTk#|mNv*Oo2hHP>SZ$8qWtu7p2c z1mgJv7`|k`Zx@f%9#5XGNl%I~w6V0DKq1}Z%g}BoI}sDG`*)csoMWsZXd$_9djROH z2A;Z52`ylk$y`)r22;FyhRRS(xXWm_j6N`4=IJ!Rp??IH3ArE&?RbYS_c8(9SRhc) zPx41yQhf}fpX3X2uOR9+g)^}T0xTAk^dj8h?||5s-#%bSjshB}M&sQ*I1}!AIV>J$ zf`HP_vvrH;)9LQy7Osq$UZ$U4YzZ<#)sM+Okhx7`=+v$YHIi;q$MblYs#|=7Eq0+r zD~tv2VenKwk4i6h5LBUt+OCUx``)Ry>gZ5EqIgLa6)st4ts6&aVI`%?t{FC~Ve*u~ zAjC!5U8yauqv{-esad%U^~rd+-K-0zDLDKzpF8APw4K`9t%@x?P*@f5-}sUfv7Z#M zt2xJEX5I`zhHzna3C+v zYUvD{FtoyP#W=JG8WIUE&i(U1lcNQ%CM~th@~K79VgZGNhkwPX*im`Sk_d8mArN*0l9LjupFp|96BfM z3`IPDcP67aP5NPb{M)spJg;oWZE`YNiVHrYxV{T={sC)DMq+iHWC41zc)K4huemfy zb|fg)gSKg`D~Jos&`D@y?X@{EQT+%nr&Sl1vi`vJ2w%_*(IM(_n5mBV)&fc?Zd+;n zmcp2d^7!e(C5K9=%Hr%}-JB6it1L66^YEgNNTBv}b9HiVCg+>|UJ+=W!Z@u-Ah?11 z$jX)4BY#Mrg{8*mmP!f`;<(r4?t=CPR)K&Oj^56@NFE9QsG=B2*VO3cf`FjOUqm1? z9V(inP0=Pug}N44sCYdf3gwWLuw5gD{UJm$L)MBZtO|+jdc6*Bc#b%PZG?nD5u5Au zi=QDkjLjT6)4(5z0E?7Zx$-PEolmHLzYJ;F^9vimk(&SoO`5iZjAyNz%|Bcr zb|>I#i{j?Ah%^jl*W@@cG(ENLZ9=`MQob1CGi~A(+44i$_D&oSaL0?~j5qdQ*J* z0PpFVa4&49=`o%}Ap!`jlq97yUomDh%?Bd{Oe96~r_DruVHj|<9n2{qX+fIn*MDbWk3-Qzjhab^AS)1!0p5xB@_x$*sH zQZTUtqs>OI{3IMDa^b1%Ns?> zC?Z!3?;q+n$$WxFTlL^os>1CqH8&mWvpYm*am=0TO)e>h9)`*16HXD?WZ$2qg| zyzwe)Sb$sxjpN4_sL2WLaOygOX&-?XBc@Lg48|IW`qMZWJ$Ls$5yXk4zZ?AFfB{Q> zM(pyWQVT(+a9tSd`Nla<7yOrL7$H~5gBcudZV;ThXQXp(i1r+)gQ>fo z>4z<@RA6FzptY3 zL>MqN3H0*d(!P{KDpWZmTcb^+F#2`g4n}hubB=_m2$j0zn+Gy69^urt_&Q%KQwF&h~i3v%6)v4&|4J%g&{ReQT~;K zrTH5L1P94$_$`z*RzlsJg^rtR0k*nBW$H`F1EQ&T2Ax`lCo$XwajtMLKpcAhS9q)W z;jrAV3-W^(^IQOFU>2JLPEEv=1!9F$G$cpgsUUZ75!*7S_ON!k+JzWXHYZ_gtf}o1 z8BKcV;Wk`aQ5@a5)I4wg(X3PKJa2zYqMql-o7rT*8dg>@#R9w1Pr{ppRMg0UEmEX$ z)H!f=?_T>*^hOazEb&vic`g)p=wPolL#xK^NjlPV1wKOh*SHszYFS;iGi4@Z&75Hl z(&3#p4HL9}xqR9%)xdSuM=m{GoyeAj7vSX*zRReDDOz|jH_fPWAXF>t${lh7&t$yfXQO&P=C9wM) zUuvwrg^YbrZPj8Mi;XA$;Fq&_ii^Ppomat+-+@buUmT=&J)#gTVb)PTV_jgN{uT9o zruFh?1`sjSF(}Za7nw4#(67?kPK7>y+UMIIZnRyUVnjOaoUVHrJDxxQs*KOjMSym5 zo(nY&MD;VomwRXXc>i2|S;Y+h)6FqVw`xDA)!@qOn<-)$tpEd%<<&1xNzo$-O(;+t zpi9@IMlB3+DhK=na#1c};|4XT`Kz9t;`Wg<%pb)NVyZWi4Wcbo{nxj$tpor<)mok3 zZ_@$N*uq=?Cz1YawaPJ(lh#^Ns?h!K?4QN0dGqfm+vqe9VCRhT%*AM=U z+hqJZL+VUOt)@bd;NKir`Pog`9(JOCay6Et2SW-BNc3=e98D|KVx+V{?aM*a!?v*ba)ktg`zV3Hx=~>dUHI zA#Cy3t+U!D8vU(CR*0`9VZsKZ&gh5Xg~YKIiku16{S zdnbv^gG>I)RbK6j09A3YTPz4<8PJb|gM-OebaJNmFbjB5zZSw zp46U)etV}a?VN^+3YcVnh|zK_*XrWls^|M`PPqveCa)LWsV&di#4eiLk11MTfL-p6 z`(!8Ufhr$QCUU!VRkv8Dd}uv1f7_o`Rl^)5x#M8+RY&#(y}+#7T!dVdkY2Mm@bN7z zJrL6BXwd1-XgEHt37@Csx41^9NHfgL}G~=r!i> zxugIk_*AX)37a9>5q~-XP;8&QHAm_Y0imM@$`$Qw`y9Y?0ueAlK|%9d*%3!6sA*ST zq}fL8e~i{2&>4Qc_$y>@X)}7%4N3B+VI~*Hs+%`VhDi1K^M0rP&h-@>72Qp3QRX(- zv1$9(&(s^!RjA%k=8}9d@j_H)EWW0;xY{hf*3b}zCJ2X=iI=|yo?POyw+|R`X3Q6X zG7ichV2K*EwDh#bt!)3mIGQyml7HaA{KsqAsIvVxbo?%v$St8puR7<9go(RYbhjR_B(_&e6lS1K%=ZmrjSUS4Bl>=r1xocvDpI6c+A-R~!*=UI@QPD)l+aovo;M zVUp2-aB;ihMf#Kes18#iX;9!XiuS=SDDpCn9??izcvw0@ejf=QfWnqfu+o9&I*iIs z1+93LwXA_X9B9eNUmaX|)l7*6G$W}%ftWHob(ZgP|I34SrZ`JWg!HL{ixH&xD^9nc z3i%iF@lQ;y+SSj5-9R9Zf?%WwV54vMFLI9?YC3hDTv$LrrBi|0ZK)a2&+$1+eF6g2 z=MldkUr&hj`QoLRPn&fq!x^kU^>d3)Q=N=dy43%-gB9(n8kfXP(d`7!)#M5wK|D@h zn+?P#W1sXeW&G?XHi8kw|28t0d>Y&oBR#x3=hEPGQEkI`ys@P-jX*Ye<_YmMfrRONCe{ zDHZxmsm^Sy`9ZhOE_;$mxkNCvP*y-~wSWzmaesDoMF;~ub)Qjp|I!9qSYtn)T zoZJEFch!q(YW#t8qA#(9qQoIXyQ+?SI|zC{{B|t}Sts(BHTP+P4^jba&;Baz01h=? z#2i8Hf2bvH3*h<92*V^+Zbb2#HujD!*yXe#!1lEn`lL2eovPJg%kd^0WeW$YT`md2mXs*KoY7J9YH6E?))L4DC9G?1W1smf%PrE`k&wz7ON) zh3g$J^u&m$4N<^rZ&~tKkw^#yXrMiuzk=AOf>muhQrL5jUfV#>?jRYA_`#Oe`G1<# z8g0$LWV41=b1^wZ@<+W$ff4`zO2KBSb4}30)cR2@a@4~9S@1#8L`IRDJMDzo2py}&?Cq?2R>XI@bt?DcF>zE@owf2mruUkA!b5A9OHk6v5 zA&A4&E5MubyHZy0F)}NIz3tWLYo)CJvX>e9nhO!dKWA?a=G1P}!C$H?5C!}#AQ(=5 z?oQp0D1zuOVEXTEeb>piCz;bFYAGDqG#m5Y`1bfQBk$lbb}za_^N;5W@ILX608$nO zxTNH7!nEoxe`TCI3e@sViz`oW5+e}M;Uh|)o*A<}v=p^DwkDU1ng$OB5N;@F3uILn zUuEzn4Q2Nhd>*rOnb|2X-{+T#3Q?qaO?q zrUjUWe%LbyJA7nPEo&tssn@N|ua7+?Ixe@(Xu#Lr&!RE<(;(HP+t2p|w6!bmp&lZP zUsLHE`&#ycj!J0PY;_xCBq4ZX;d-;P~9beW5J03p1?g> zj(@$C`yN~@P57%@V`7K*mp#UP5UEUG1DT;!P5Kv}{HRbHfJH=rfcW7#)fa`;zxs{h zCVVfpiqqeBdCjwBm1&!*jb2L5sHm`hO0dIl6nZ%QJ;3EPPb`SvWf4lJIM76+C~fM! zG|3#wj5cD(`Dv=u;Zn1!B5ydR<~~S^QWz2^({vBrD$)f4s!|mE?~WpCn-(`BBA&2a zQXsKFV*svi=rr_w6Xy)n0t*OAu^u|XU>haANT#>oGk%!gX}55A1roqV0bynd|DWzI zfd-(e0Hnx2faEr~QD~`Dz_9=ru5y@MH#yws-dXgiyvf%3anP{hsO~epUZ)Y~JmkL9z-0RX-Ff+T z&S4mx9H_g?(R|dj_>0Y^m89YKX+=z=^PubVbSs#rh!{8T`D9lsZ^NzcMl4?*9C!D! zs;)}yj@l^%;)a{j?s`C6Ab)jgRlxRCrpn=Zu!aOOuYNkY_$WJ+;ayi5}Evb3sq z;-7}7(Pg;G87u##N?Qy8UWY|GyiOW2+X{_HGxn*R0r{N*x}QG@d#08T_I_M^f! zk%B)F+21_N+*#9awLXr9UGwdE+Li#jN*k z6i-w~j^i}@bIG>4$aORp<2YQ<=w@=HzWUN*;1w1>2aDlNk2Pa*h7{3~XaJUOICsLg zDwjeVVZVP?_0uF!e+i)7P6gL4QTBJ}(zlb5$kD5_A6>7`vp}H!f`9g1SEapiBJrGY z%2}X+SKSN@M}xc}7rlv)s+f)GKY5YRvAstipKshu>$_328_#|TaFjz-ZtMVqyj@vw z1kr!ME5GIO&(|mzh@Amy>}EfDBz;XqcD@T}L!p1Dr2yo_KS59lqQEpXJ-cxWeYh__ zyAwX}7Ug|t!(4&n8sD+fiZ08Dikg7TN?EJQ^1|zZ1mnq$$^*$&xIZVfI2{_*PhI zkJ6M29K5A@xYC=dSSv3rNs(c;7saex+ZOgXyX(wT=vP)+!q7e;4a{EZVsy*O#=DB?bKqNc%emJBC-41p5$jiED%4*!exbw;q=>rC`R_S(jUO^NOHP4DDl ztC`zAmtgADi=fU8$_2dF-LivUa%)7BiNNxdE6nV&%-!L`wg6PiDGxMc{S}#*$t(~=L23&e6A&WFD0EKXxMeR2y@d~KQlvhPc)W=x!UmQbZgKsh&hDM(5~!3z0gJXV@r zrn|Up%A2W6QKTl#AwLY58aR->oXyRZ)>9VZe0rfHERzfTN8a|C$(3C&-!6vDsY@a$ zcRB-vN@od)-zw4w$=ZiM{8IRmyy|X2{m4TmoE>e)MV3irg9ve+24VbN!(a0=W|0V+ zF8G!?zPrzcmly@ zAX3Wx=lguUaE+++<=2%aJDq_7Fg!#DAT zISQ9(?!n3f*T$iX$^xioz(cFZuU6IJj}zc!2jJ%%}b$ z0{Ct}A9-Z7006T$T#vv&LAV%HS5=OFcfNTpcC_i2Kc9;}(9&OL9T3oovPaft2Wurp zA^h3K<+9R^02l&FmdLR}5tLlDWoJxt=pm45>-9wcww!`@8rh!C^;>FlA;G|`X0`Qg z=JMVfGqp^SfAeGUjuX+vKcyP$)Y(#W1VG*fp;3|Dd#vnS2_!vY;lPvjmIm zH>mDrF|z1(?G2JG14J;{x{f#_ZWGaIZf}NMNHUCdi?0V9{d@!`!SbwF`%ZXR{Gzbw ziHI+IbrnhkAxN=dDf#?F28Mj_!u7S;C8u+8&>Xy4h=044u(TyXHPXDes2Kg1i<7p| zCFVza-$yC-M?74X_B}OA@1rEJQ(-V8``HXJGeZ%PI~}SiCBoN-yFQMLrcS@kDRJY9 zJ3m~JdCcz9UYl@zbRVTH$NLU!G*Af=S)QdW6F*p^69^MG*$OWH)U?(SM~$fQ(Xb<;Q;KJ} zk;cU*O7Xd;f59#so}oAh6Id)_D(of!f;dGZ<8&h01z~)YhJqqa&ui{qDOLTmrxj>qhaAmO6DLr1D!is`}NKzY@gn1XZ4*&?4M3U z+WBVK>Z3&KHr?V;<@9E*2gkD~+=cS1AkKY@rT?qJ8$b(qS}`G+4tdWV~ZZvt35zp-y> zPJu~af7AP|izsPH`AV9HK-X=v5BTOc9UOTkwZPgF$$gFZxr7_r>S)!(V7)HWUm-A0 z<)|~pTsbqmEJj?+-nvVjj44m^rzf5{ zJMG=7&Q{{67WHQ?h8xf24}{Y1`7QD(Z8`SqX7T&Y*ZrPFbL87W1odYpqui3NZXU&n zlTc_t(a@^5g;$!?vVblT8%~sXKJZtb=|OnRH3P%nXQ7I7GfkE|-ZL~El=Yoboe--I z&Hz=jyP#o39b`R7J6o9ty_U`cM9&oLP!UDpQas$kFpg-X})L z>zmX_70PNzmhcXYy;`qn$4ACE*%c78A8KHT8=Xe?f{Juzzp-*;yT;L9X;rrRQ(oyM zWUVD)FuL1ZV4pdds29Nz4er2@k8kjNIVWWUtkf@`G!2C@5cB^Ew$Tng<0|G8fbHog zCoBBibnG(cSJA=h1_e7EZUlIUef6GM-Rw+$Ly-K1M;9WQFU|8lEpXCi&xO#g3nQ?h z86vxY;h*CVSpENv7X7clYO8;VfZ<^}pIggMWdDCC;&L8c_pz*eWO1?Xl91;12hdE0 z_|C&hbmSKdoTfRnv^8j-t2G=kd&$4@b^@q>v#!M!Tfj4}p;Iu@WX~(w0L;x_3yiC4w#r#2>Se$l(sor<%)6iI3POy!5 zcFw?Yg31RoVp0$g&p;_EnfRoV!E~EG6^edL4i|sfj4#$J6~BQ$uJ1e}94_K6Kxe#5 zMq^6usg-p|J)@M7NOq<|kozi0XSL=BYElIha{|5#T%5Ylnl{aX7MZ_CCo>b zT?f(ekmh~8)eG!ogprXuV-lB2O-U_TNmvz;*p1cT^Mms*6%CjmBD}z=%POE!7zx^t__n2~8 za~saXVVn@n`gh|3xlu6dl2DG3yBrIq?0!Cyw$-=~ogmPpbkzkl+I-h~7w4b!@ZwPm zZ0@DYwDfA@!nC7_YFk#5*`CU=l;rB%4R7C}XA3LJ7N!!It@=W~*0R^i8xK2p_vLq7 zv}`s3)G;vG1m4N}{j5Cuw?!jgZ8khBPaVFfU%s|*jbS{*h1w?V+Dxr;()?QNSiAQ) zOS->Xr@aY2S`#9ND>Hz=t{I`RM*`wggkZAQ-t7yKq||ArnLhN&fO7jtF>c(tIyWO zFO~=xM!ygPfJs?tLE3Y@O`Y#!!mV-f=3Us4?(BR zdQ^-g#PW9_V?)}=93TBeM)2rUfhH((wUNbks)qWxbC$O+KOJMV?O&gh1uH&Mq@8JS zEs3~Y;aZ};6lNN}5f}S6nt*>C54-N6(GX@tWo%Aatl4Q0o;ED^%EqA8AS;|AQ>dnr z(f$J5k4_d9lnk0Ncr`X)iNA&kCp4#3p-M`u>t_AUlLlA{r0GvWUrszCfjYx*N^JJq zB;B0irbOqzDzhqCowbg&mE@>f@tMGR@Y%tWD-_##=dxBg?GH>eJA9S20;>>MSKLfRvz9D9Z`LlYyg}iLweQdneYFSFcvGJ7>gMMEd zn_k-74zq)Ki)({l)vU?4(;+(eXcjw|Cmh1YZ(~konw5%k3#FgVL0gZmpd$4>kQdCQ zk9%t1$9Qma06y)-w!#t!sNtwq8PMd*X+qeXjzeix2{tOkGN)z;!F*B_imQq|i8 zi|oC_ugw6N$i)C2gq~xb?!j`GFZLlAkYHlAzsBXRres2lY3otC@2*yKg8>%f z6zhwVKKh*?TumwI9C=W}M$?J8PuxFX71WZ3(8?(kNmpvCmu=!@2q=l6=gL_Ee-Gp8 zKIF`58k8}pU({bnJH|*=RQ6{l(DNp)61ZFpyud~4esCy%yn8)ZnhH4Ri&tVA;wP!j zE*$Q5?@7S&ake4=pQ$B;$VN&=Pi8bv#xV{J4GiUeYRscLg%;IKJdly!K#K~+C_iTW zjk=DhTrnJtYQa-4FFR}Tf*L4+Iv>0>3`0rBZ`Io`d9ii!UNhxQLOR@FO6Ed#MN9h9 zLh2#RJ=`a^92=b;d^P_w>uT(qDf=5#GK{mP!@-7?(HClW`yg6cPi+KO_p9ZD!P?)H zmnBuN$_ zQeY6_;rDGlmy-6%mG8KkrgvupD_n|DbEG;=w#}~d8|@XH4T*J;6`5^6zKrPAe8!4U z^<2_rRZdr-4@QOvo)Sl<#|g5`eyJf)E7m7jTV{%{r04FdLu z2^kp~2(LZn-28!A&k6i3x#0U1_St40*H7W^yTxc47if@QWcBKDST|ZNsV9k5qIKbH zMDfRGsFAgO78`fBXfgS~_iY~ZB3%}P_OTc!8I#k~SHH_bnt{A(kc43N;JxdOnP&b@ zf7mub35LiD(j!q7j&E=Zt=Xk=JS-Hi3PD{m=M04fE?Qi6dCiH3dEg zt%F_q94dF#B-+LA)@~zV+?{~pH9{OkrKn5-sK{2#!!jr=+~9RN=o{$oRW1G(3q}%_ z9@jI-X&sI9GhgfF!L3yDqG0xzKw7n}nG1NZUta9fuv=*Qa3UN7nr#HQLVfOZikK^* zSoa{|!eIYQio83{v6@9^pi||qX#SvWz&e$O4E<6BUvR14)8Fj%g3>z|?JSxRq3UlE zk1{(?RGa#c(S~B*;HzOK-%}STt*4d(Ib+x#hoeqarl( zl|^saxrHdx6Q`MP@`e5izdMw~7j6&sW+u1iqo4L6+Oh+r?=ZHLm~n5rKQO$W8^6{6 z^S+0koFbrs%MTMUynX!$k_*+_?^~lKJz2d&j8uveU$^6I7&b&iS0F&IZ`4Md8W3q7 zeUnc~_bY`MQ|gb$00#lQ9v@JZq`HEv0TJZhPZ11e2y8NZ37A_VBJP9Wm0Z4W1l#w)| zYN*(667tvr_FEw33=Ee3@0J>q7Jp{Y#lZ7GQ#>SmtuQii!?y0v>jAfNR}n^y4LX}F zsEEfS^dWG75lnrvo&22h7o4Am=)>l>u{yY1IB*mZqdTyHByf}4^lEO*lF>?GT#6h7 zfjo}tv=U?lJdJ$QholU4YU2C}xT3>dhe5612tr1LOV}ptNbc;H7v?RO7M2`rb)_Zh zeMB$kyPJPy<~ic2V?wpgkK%8JA1ULDF{^0T3(cFTvVY*ljr}q+C5Ma%;S*TWdS|B> z@s(8O6yBUu-WY?^iioaEEoG@KYRdOB0YDlj{unNOSKX1Nn-61Wp8r#$sy7sRptb?0m6&v zL6>yu7l=EHbOMNO2!mxFMs2yk%*|9h_L>Xv#~WA83+=ef-}-J@n@~3FOByfl(u`EMy@Z(TDP1 z47%XG&(6rfK!44T=>$T?O{`P0(~BTX;S^^nt}4tB<)eyBhDAn>t&WrJm&cKf*zIha zvP96Y&K>G5c{aDpO9^~3C6}XFNZ6eRTEBN6E8aAvABKPbN&LY{sG4$=ItGm_XTX&t zH|hCe-50yxS7a%{`mv-LIkGvS+pp({27t>kkOR$+d`j%b&J zku=~t%ri7C+gTj;lkS^IoZ=W&bDT^nzwMWRb9 zr%L?tSQFRU9li8?(Y7?Bbd$#2ZAC}=c|hh15N0b9BbTSUE1DfP9kJ=cXqQ^m3)z#; z;#V$)8>+*DqFM7?erQe{mV+ypk=6adCD`;%eJ z^Wa1TyeuvF_X6gCYo3m*-d+bkRmH}}?sxJKL%t%o@*S2b_n{6dy>pdD*+;$MJeNSb7UU=_} z5G-*0HOf%s!jP#7nsJc*&|iB$VRPeBF$pcP;JUdYEB)t2{@ty8obu`BjGGGH(~jnf zqD|AOm`d<=Q?vxZz-0K2OzJv4q}_uG&`gS{AtFkFay!nyAdt%%&2TVxa~-CU82_(F z?w5{4bNRakpE__Pd#;-c7rU}3V$7mtLI?>w94(!XCQ1$-8|okX?Mt6*#L>Gp%J-<63piIyzC7L9_-@6nQHc)L{THMkbIr=S* zXtO66w{`w<2|usbRNfhHSuJZt!A>iM-X{M+bFWPJeCYyemoML<(n%&n;qdl!1Z(eZ zz+SlwC(!QakyBHF)K&jxx@{f7gGKy|@Ebn)Z1w`ip}yAp(CNtj-Ue^*Dzc^i65&xC zVQ_En9lRUMTg5l^lj&#zY_bB+dihn17n_djQoITYVgR`i@H>p0sIW@D{eHUK=}+@# zW`clo6GaCc(eL+Q+0Cw_1QFAGNinHE(=d6arNIc(4=_!!@pQg1XB4Id4Z|A>+OWfJ zi#V>d1j%lX(z9#G-?zdW@e3Q7q1?qBAbj>qU%s84;V7B~U|JS?$q>7L1BbNFVw2q@ z%Xdv~|9Ma40ySjxo$Pw(z_B?Cz+WpM0$k`Iqy~w@m%B6VNG#&E&!|^2?CF;B;{y+^ znxkq8z{8;5h>^kUt6a=o3kJNo%s!zuR`=~AnT-vE@OrCW+MxM4bdLz^4}(*f5c_9a zlpgQEeP5=l<}P?eFQRO3fGSo^mQ`3UO*>?&NqveU#(5|_G5eHnj zqNhy?JB33C+!3rR7K~Z-K-@o!cO?>&u?$qKnT-@XmL~c?d4j5=zr;p0AfUNVhqXBl z`>~?2-gRi6H4#>PO+N1B{MjVr5Y>zF{Gc?lKM&~s zfksj>n>%|ncD}XXQ$rLdxs%v7k=%x*I0AW1+Cz`N>c^7M@fBgNjPeIm?s=-T8xqBd zzYk2R?`?Q$#|ost!I}HgV$DnE7K_uLgi=FMT&w;9ii*rZs$c20@I5WV17>f+MN`S- zvW1Are5PIiE&UG#dBq*9D{T8kC$0Zo)aG=>sqNHJm@c}zA zdD+%AanW^kzxj?J&?685dV1sBh2s-ez08i(um+NJcdhs+em8A~#-~sW=65s96sQB+ zw{qFp{Jo`Qeh&nMZlL-c=`B2Nwj#0$!RZ!8vJZc$Z5&;OS}PdwfMCc)8qGf6^2+wW zCU8(Pz|6ctN00|$f0p5?f+joR0o+FS$F$6#vpg*Kp2`-TXiKa|{6{+pdT=ZZrTmMA zzG38&g63YZw0R8QLS^GzcEx3BbVsgo_Sd>!)kC)ksM+TP-sffqKE+v+Mr-vc`IcS5 zzksVkx9O1oO^^CpG1B@Ol`02mqHfER)$w?lx+S{DEXG>DeSEQi1itZW&2F&%8Rpbd zdUF>q3%hqb;x8Uh^5V)P;1J480uaEs#h9+BBKrX}gnYKb;U3i9OV{5vL9IW3+G?yi z`y-Rw``PsseIr7|mGAw5%A0GGM;dH4#5ADcPk@3X%@81RP6um2Xsk!A+r2x@ots;G zkXZSyAL(0axWg{P{!#g|lKy>f+9$9W(3%icN3nG-V#Pwz!E>FQb#JbfqSUff&P!d^ z!mxB#zGGX#Mpkm?`kkSp41%}NQ-=Rb(`9q)(lvA3elgx7pP00ZSm;J@j&nw8`kf@0 zGz`>W0~)Az6JMZ{?_CG(@)g?XXHKNv_>${+fM+p&bZK*A3jkdS7^1tcBLsF1_;4eX+`ZjPy z5bzPfnmhnT7X1%C`#GI;f-WyHupe2CInn{8{46~n;u4T%lf1(K9G; zeaRR%q20WSj~YvR@eiU}jn?ReuCb##xPH`}%BC>XT8#OLn=B^SNVos2_&BbE!$Jn5 z2{_>seyLV+TR79{`TuS4(gZAC9PQzsGCztzTg;+0MZR7v)D85gTDb%uDK1^z$z?sT zrvHzzcZ{*L>%wl!wr$&8w$-IBTV1wo+qP}nwr$(4uljkvlaurB{MlLA$xc?XbKjY3 zu4|6LkNm&4ngOK7)JMyi`c2Bcc7 zy|}e0f&L4-|1!tVV7;fjL8#{-}hydzuqX(ZdDfmHzvu05I%4 zEDPlRKS{#=>yd*F!BVQTEaM;DPCWIMuj#I*7<4E7zmofZ`Ivv7Kmb1D%g`Oa073qr zp6dSv!RY=-8vbAHTQSPDj4~DCPd2C!NIj9h1f`7Q|1#g8(;=Emakr;ghWvFXWs!6)=F<8i7DOjnhso{WEdH58^4hHL1Zc2s zxQ&#WaPG1Jkt96O>ns)XPZb1H{gq}i8tDbdKTIK9wxH~=+;4-6w4)-6F;J|yP7$#6 z>&VI)$`N^XLc~%kwNBvEcz+C>-S1|{x{PQzDL5?9A)bvR^nskS|Jk zK%B#^h!?vy%+LC7)Ys-~wxRie|5k_G->%ZXd3YHQW^D!&>}v9y-(`Jg-+eHn_GCtb zT+mOMN;-Y0+DG9Vlf)AnR5_6G((dt3r730WQjv3a6@HdTtE+z?lkj+@g!}~kfAgQ~c|D?@C!GE?;PjV3RN4oZ9B9NH5 z8a_I0dwGy`4>T;(IsAu~%pXod8v%9%jx{X>q^~hW;m#)HbXe{h9_`8{#zO#>H*?ka zhyq`Zi0~=zwbR_DV0rGin6c2WtbqmsHHRaoa8ocdxH{070!_Nith+i@bFiF5^)T~A%iZw#cnuAYa3!n$Q6N`EPkjWmbDDC+haCkc`aNzHVJ zbZ>39G<)q_{};4V*93Q~0`kGJxvA|D@-tzX!iee9;q`3`ztG&eQLUH1*LY38(BI1x zuVvPlOD@$t2J}EUl}(!`BU_OZ+1-=_;V2ck(%5fLOA z2SA*gF$jb|lPn4^R}6{#)iFO)*ufy8F?wOa2j>;M;56ylrxqC$3T-BuVz1}iciF?9 z)1oDm7hoc-H?4@fj%B!|He?Ik7`oT;X_1CS`61!6<3O!$vVYdvI9Z-Vdcvp-T}-yS zglVr2EyXuWyA=8)8XArYl{I0+Vdh0({Iye*Sr0pdfN3^G!#6}f=sND$u5S80?t|DT zt3Q`#(JMO(OUAp|SfQZl6M*z=mJj=l&?_a(_jCFUlUC~|sZAmH=hp9z*P6OQ^FO|+ zT-1}uC5@bEbWQ$%y06s-lVF`Q?lLtwnEu5o%-Z$)qThwi+V?g%o;+|~dHeGfHEWG& zTTq9)d!|nA+tMmzVoPf~{2=)O_4lPj7()c!lh<;{fh`pAC z#Cn`S@bZY^{I}q`D3b4D+Q8vz(PXH0hdNNX-Z!j&hdue6`KH2Ce8n>1%cE(tw|&e834X%lAL*DBE#wk}dNBs{_OWyO`5;I<2#2v3 zyvFE{jKpUVKmC%_GM&@*f=50& z!P0=g^Pt~NB=`YlHy=r4I{|#EYpgbz1435Hd9e6l>$`-({~Yr|UEFlc^4(i$`LnEr zsr5qVsJw?i72j9n6|=c4qo$MXle(N^c>}nGk!(d7Q#txIb5*@XJ?0|cL`uO*S(p-o z4ppRvqgmh*!2qQ|2w&vlA==hyq(Kx8{BLo|lq$`&*p}sJKmO@5TbM0b ze%a47G*DO~S}?(7y#2s{Lyu<78U=|jkq#nLESZ&67!FQxINPmO!I$lBrMRCM*0>Q4 z3{+AV&L1qG<-mv;Ac2&-MJ3_E^xIRdBZ;rD9m^15*FpT&`8JCAlTkwCU_xcq$z+*eiRiln5_>guId}t5u|v*;RgY2i-V*EIRc}r_(C1 ztoe%BJPxI#U=_w-L$s+i@YtN|+iJ;c>$zNR9k$N{vyVU%{JO5F@yTv}nSK+1m*2@z2M zf_H(0WFk7{75B>&U*zez)5b<8nn}zpu841-DSS+m?orx^P(dmX<)G|B>5=qW?9q~bgi{7);h+3Leo;uo>AZ*eY+6KIK zG97-l!95izcT)xx(KIP_nQq~n=3rWYSn7sHK0n_xd2s9T zd*dcbk?~}^+0I=1FkIV$FL3n{US=f=L!Qb0F-Z9of+9F@nL`|kURDKt7I@1OZIHqm zd0Mjei@QfVFpYLpRnE6ZVG#%TeCL*C|KVB=!lBGi=Z){seJH?~u30t`7Cvcxj}zF(8;X*CY)iN>jVzP1XK9+$h{VZL zA7={B!i9XW7<(3tf*8!qUE`7$P4Pi1%HrK%5)k^?805XvGe_F1EHRN~qzslSgI+92 zZxCyhf~#W~?4?Fy2foqED1zR-llk5ILe!IW{>76ja!sTu-5iz09w0`#X)wPgIGcKL zw<_fjHPDi8eGs*CklhyMmF0pS5x{W7nG2FNwa9r$aED^jMG{x-sw;puLUrrO&(UJf z@@m&BR&_J_M8Z3WmuFZKtfo(e$n)>s3?kx&`WaR^=3+8&&kmh3MzjQBaUkw3ai9p+ zI@2YpAypov2Mr+Y8_O4QTHh1iaW39;HCvb?S`x@{<@jis;|TUdhii&i z8@A=6&K6JYO@gbN0Q8RehZ=2WQf8}+iH_Izi8gfig^Re5)+XKWFw*Dtt>!uy{rFBs ziT?KUU?pA*Q|YdBT_Rr;)XrQYJL$?r%m|soC_Pa7T<#V6K)QDo7Cau%Q-3-#Au3zm z2z^S;!AY@d_R-?HB2|b_Ws{5u40g33g9rws^0@R6%>4sP93}uZJlCt$8og7an=re5R{jyP-Qbh` z;snp=Rd}e%?Cuq7GVdh~?{7vGJm}FdGp1%adi@NgG#~D`A-ipI{-~fNqUD6)4@4c7B$Cbjsm_-~&|qs^lD*Ut*=(~^-zo2)WfnH`(R3Gj&G%kP||5buq%%2GPFN@=|3)m!Pw<43p%ca>7P%J3~YuUfWTR6iLgHWgfy3FENB4yIatRox&hn2MNLDoE2{XR z&aepr{HlO9w%KjPg_DX+1!f-If@WFzXINy+69bh8O$-5K$_v}iHT$mC-PJWLD8~Ot z9QldMp!*R_Y(*6}seE?l{NS_raL+-OTfhV4c04zG({>s@Tz#ghJs*-p01WBZJqkmC z&9w5_!Yhvq^o+UGt39whjCh@e$=6#vtj@A4SjO${xw_trtINNqKkDg6D(i;5xn$I& z99O#EHlU!FoFWF{GekuzN~B0NPnIvC_J*0qs}SIT

l?s7}*4vp!2W|88=L^r| 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

nR1?qM=|aYy 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

F}woT zIx({Ow~?=c{IbPJ5zvC(7;};$g#;0Fa{7*mQAQ%X=w$qiu85S|NqUrZb+@qZm2{8e z#ITitbb#a$T)aZfiM@b%fD8{t?{GbO>iI|*iyAQ|sIOyfMW(gup3swA7&#MlG;pgE zbH!*y@(ACPtOdyswIXo3lVU}I6S)P|GN`^&$e393;?cR4%3w*+&(Y$ajJ!7jyp;JN zxsy)u+p13y5 zRv%)$M#nwp$-1;D2}vU!Lq9{keeKVQfQ1s=Va$nwg~||QV*H8}Q7TB~DQ-H7R4~_y zxzpoUMCoX~K|ealj459cq@!A+Lg@qC7)!-XsGxjKLJi0Z7zF{%9gD`~bd6ev8t`50 z+FnHtF2xnuB?_bYUqd*>9l+vzyz?acghy=Ku5)WAEN2Po^+&#mq}#IVc7*0hFofU; zzL(eaf+g?1ueo^o>(fWm5o4UPME*nb@FmNcrVGmqT3s-eF~bb1dobe+asx2gyHm81 zh7tk2^O>^DuD|MGO(v33uvJI(iolVuC*loe%OgW1j$o~hl9h+40X>mhFf0)Uj8)M7 z8(D2@|3g;mRiS~P8O)pgq!e|x1Ff}l?$PsXLOZmLY$Q8Gy-q&pc-?;|m+HeBKuqN- z`z5LxzR~X>)c#8v2Ij76!BI=h^V=-&i9P2-2B8--A*5yy9mpDT$*5%vT@pv1oalNc zu=}#<<~ihuV`CjYpv4avsa4(I&YOcP6_U$^C+OSkd2r267gzdh0YB-Rv=yk!2>=kK zeL1v}r)Q_za@&%O+BTDBZ%z^bk<7Y*%yW^=e~v*r5v{$dV*flKloI?~{a*U1DHk5b%JuP-UQD)Q<;Mzz`aL zD1LG#^8PAZn2olcZrwep#baMJA4XEt7?Tb!S9mMgX8N)y9bmqlDHS>p6GaJ`+Ad;H ztrE@+ZG&tV9|iXwSgxtR@zV_nqzXS#s|SF15aENy{M_ZR0U!pn)<^+i0$-p7HcA zPBVIYr;qrqLyZoUROpSMM&E};(tX*BDMp0+H-!#wbi@JAAYZDeIa{u>PZLsss&j11 zxI?eY+yjcEy)d!%1HZQBHHE6f8?>PNc`X@UvywUd*L}>7~emq^G_pOdj7G3vGG=Zu$A)mZP}OQ!B`{h;sNQMR>ht6 z=O5vWzOgMz^ZC#;rBuv#?sndGEvg|pOKmqUtrR*?MPujVA`?wYu6>9mn#$^}W@17< zb>$o$M6q5Fk3-aS)&oRc>!m9`88^jgi*>xsG_?jugym`E)ag-_w)SG&(ckGsaox?| zR!1t`9$t#^JRh(Y8T70EASl^tbyE!hMp-tEW^5nq9c;BF?g+s34n~Fj3f#F5Hv~p? zn#ZeW2u@0mEqhpB!nG7M%}QK`UA>3TyoS%rOn-D2^b_?bM0vlYp19cSP2%;t_+H#U zSbnV!uk}jfS(pL1mk^ar)lpAgtj7|slbdS zP3bOA`6Y3_KqzsRQpA0Ts=;dHmSb=2{j2iZ;mQ_VYoa(CBJ{?`ti91jozY3AQC%W2 zjP1A7#-juSIU14K8u}wd&xVM8`jtPbcb0sW!t%|t^jxB}PD~5sI!*rtcwwt@L8#$5 z>k8oYwZ?EGzWk=F(`x(pm%C-p=>{40@{gAl-+P3C$0(&0`IPXuh&E1cDW478^=H;b zg^dGrK#0R@@55~Ib)aCQPk70t!#T*f!u~vNczu<4#PE$odssD9&Jz9wok}lanN#L# zcH#@YD-C%eYpNf64_6~z@vyA;A{wAe4 z5rlLr1}MyD8`qJC`p_(AMd!=+!1Ic-CmqhU7U(&j~31xb*-<< z4b%-b;1D^#aN{%Zmm9bSLr5rNYO_vemR}{0rfkkTBEX`QXWL>yg@?3>xe$b9GS

8ef8K{ReTQT1j*|N=yGY3`pO&^8cVFIF5q8r(x&+80p#lAF=a`?4g(d=C!;H#LV#ibs2NtX>?Se4o7ML%Dy?bzq#UFV^!Gucrb zr~|TD5iwI;@m(9~K!*-@go4agUO+gGiple-l^sOH-v?+dS3q}VK-gU7h$KQ?**&(SaZng5~u!~WUzH}3OLsy*#M znHrsjUq95wV90I5UigVz{aRlcQgUHZE?BR~(vcKV%{q5husCt_EBv_}5%`1BI)=T# z?=c&Q7Je1aw(U1FSPOrr1I!KR@@w_K6Q+AH6zVCt+r!<@_sEl};JZr0G zYO4qHXqGcMYq3iEn98q^yCWtSH3=+ll{)&r!H2-#oh!))#0Pc9aLety%^Avr-eofWm zG+3{Fu_w34gSBxi1tga3u%?ltVpsHU7EpZdQBOoV`+MnIzw^o{xyKq!!@M$gEnm0k zuMfJRPbU<6fo#d!7yGWdu0*HJO2wjay%O(@CQJTJxiXJ8ZU${hSnW)HbkP`;d6*KS zl~SnX9c+xD{n!sdEXX2TTj@LzTHQkAr6Lc?B>ACP5jI=MkfyYwH~i0cBL0$=1=M#u z3;;aQhma0~;2qa1$VV6#gg$7Z=+$pNpZcS=p`E@F)qdx5MWv0>hA!8MYj=;wiagk< zWQ=-2_Te?6HuhA&+e+e6WXS+v8l5rn%&$aE*=W;J8Hf1{@Xv{(AL5_#MvR(F0FyBS zi4!vJQ4pzb^9C|~63d)?Ee;FP;q{A9Yb&AM;I}6e=Mv%6G9?lvk z(FO#06q2Bbj-C~KC#D80eVlRxe`J63U+-%af>50U;(t|^QQ-mJoxUr6zF9DYWE^Ug znMT+nPeNfdYIG$i@08k#%@LL-u`qfjI!AziAW5g(ip9}mPofqyLv+Ug{!Xmd-j&w4 zQ}ZiSoR}?`OUQ@8xE-M@FOIk_P<$SXB4-898sl6b`Cx29C8va+pcn;Kbox{x_#mHj zzCHSV03$l_D+zB9{7?ovfR#u$SZ}@3h|t<^4O$X3F=jgaDBhsN2MuRast2$cKjhr* zJ3UhlPf)!(IE*U{_l%0SE-_)R?;S*DX?|-QGle9V@L=SXr?2uzP_3!atg4L=8sOi>(hZg?gGh2A6QC37?yq-DYoH!E*E5fix>#Oe z72aQZ9}Kf~L#ZI_WRX0Q#k(Gccosa(WTF|3kFgr)&~ zSV`GjOZnzm06&&@Ig*b!VpeI9MFqJcgIt4mnWrky;#_|pf%ry;mHRXuAhoc9Xr?7z zW&w&4LC+7?Z$BiCUY;ibwi+@mmmfwncK#~p$FJT9D?W)K=w3tlXDUj~Kodg%lb<45 zLNm_9S+xmTy7WR{qW@Hnv1%XWnfCM-4O_L(@l1Q%qM##Bk!bJs&?lUm{Vf^E*T@Lv zUP;Ea=kd;X0}YQX^glev*d$*=B9yx%i+(q(Dmr52*A~Q}RZ)!9R zwUF!Q!jt1V%#U!L*cxyaida_5YE7}#PdU|3CAp%XpL+Gm@%#yfbN zy77N64|BMFyrfIU3=#}Sk6L|`>p8|q{qldG278V@rGEJd9eef7e~;Fn;OYjUvvme1 zuDp>u%BJ%i!xy$D#3k`8zF>Fff52%VdjoNR@>=)j6#E{q>j6aEl;9CrWEn z-QbsF#O49+*&^Q&GhVarxFQ<7;UA+qL+T4Aci~2jT~Ji zNe{Ch96|po$E-qfJz#9m-IjG=3(#BM^L;LFO&-E&VQnpo-m&lFHu7gnu^RA zt?4CHP7SIx-K(wn3FG#Z>!4P*MUU51w08VKNQ=vt(H%OV zcmA&ryuV!k1eF4j=}7bW2(sL!web69$1lZv49=E)3_6`S-#VT}q2y|hA~S$R$s0Z&Tc)JE>nStN;BY{_waI3ChaT$h%%XiA zp~p^wcPlhd=)p|T9c=mQTVBz~DPEXfrB6gOKT)$t#7K^rJv-BWBtrZ)=HuUJ9lppf zsKO>}$IYL;)On;pEEV^0+}z})4(b1xYMy_O`bWKM1Z~SWbWJByZfO*mpyRTM@L{>W z7WDTNO{Ihen&Ipb*@Mrws~$D62K^T`_y0j=K>RjIa?AqHbyn6@2gN}16FZAU5>d|J zfWx<1q`=?J6W!9mJ+mgulrN*@LoU7CqZl+^)0kt~y*zrQM&l zGpwth%$0WYzB_b{LNM!STwy+&f*60n`8uwdGydGV<`FqtkQB@7T%zo8*)eMtefakN zc1^-|4Zf@HGeLVg!7|be;x~noV>Wc#HJpNMk&2kPKfe7dWqDml)UfnJ&mapLwOz~U z#TH~3kv;wG7cHA?e(fk-{c+sRLE6< ztvBl*o*5wCq21w>|M{l!(uC0PtAN{7jHh^$zb56e*N3)|E~ya|6}?; zJvje$;D1FpuiqR8;MM4&lo7`|rYRtL1U7f7Ury;fwBM9Sj{S#E0aA@FqHY;NnPz|{ z%j*)NY{=s=0IGHE|1+7+x)#4i7eluUrA#wOljTiGLN-Kp4DjETiE<&~;{XfmTJ9QM zGTkz)GR+W87V(mVuaLUjUwCl#Sl61?=yK_nk(OyjYO+X`{L$w@{+As;zZ>={Z2wy( zUnag?|Ky78gCFMC<+t1Q_-A?;S7j)-nn8XnZ`#WUMJ(C}b0bXJ*|?Jdn2{qv+sXcp6e1ag8fWC|50$R_hGl6VtB4(tMpnu zm2w}LX`!8~KX7=za9^!@mvEN=`q)0!u33BLcuu3*hl+-ZR?Hr_6Bw#K-SHw&S|g@| zAdo?$qNB7U3FKjHVjM=Euir+pKhD0n5Kv5B><(=|FRX_ecrguTG)Xv4ZdBQe=+##) zpt*0ec~Q)j0S`Fu`ZbHaxEYrW^v&FQTyo$R-@hVMrFb69DPZJBmU+z`*T zgcfC6RT51qC;AToz_yf)H&$7}UQuz&Z|(gX`wi!fT^MZ90TXlH+D)T_C)kxp&2`iM z6VY*x4OQ-))3sMcA^m6dPsoqP zirH0rA(}|m5B5x3;2mpzx>4Q4z+UZR(gp0g>b~gQqvjv|W?=?=g^J-|L?Ht!e^33x zQs)FGQXQ);!xN%nW{nKjdZ8WSdAB`I;-6UOTzVP4b(+&*_6$yrF4sJX;BXt3g^C~7 zwl2GS*TF+#$kk_YLt(-&{H^-K^o{x}g3YY$!r863)EBt7f)#Uen~*-@9YpPKs=gpU z@tDa)m;^LXaC)&b-z)y%C@}ApHMbeYOx=$~*iICKQMT@J_fMc{u+VQ^Z*J=*=c{zj zo8{(G?c2pDP1>7bJ__nFu)S;)x+ZzuTkYGRwvm5UPM4u54;3XfI%+O1GWu z$Ce6#Ev$NI6bP^^qBh@>_FLYY>;~S_y}uwYF|gN5uh~jaeGZfnVy1^jP{|o8MENn< zdV>bkM3QQcOaz2z`CK0D8mROL2!NUn)OGqe+6~z*@{>haI?>KKg7awvY-0siV{#|V zQ&1en3kR=qy*?e#pSxAuv};UHi&dqUE9JTqob8|Ad3{lYyqNhiuv9O%pIOMU6{!ZZ z6R-@XY}PDoYpP9rM^-1WwWJBb*+_NyWZTW%e@Sk4VO!k(R#wGRBHHoGC7p4mA^R?7 z<&V%0X`j^`lVo)LWuGaW%Aqn!I5UQ_P*yReVt<3=)RbGccc&1euV zJ!!pfy&vYWwQ1L=treeNCIHXF0nuro!YaQCKbhrZ$AH)8V*QiG$^Jv(<_+fr?=at`1pDTay$w!p?WdNgY+GX+IpCbJDk$j&%-9i>b92ww71VNbR&X^aYHDJ4H~8A*t>>i& zT3UMR_!YWlu*Ih8+luEX0gJJr`k{+`lyTVn8vD#(@4A_MuesNwm3*UloL@2n+B^+U zCO`E42Cr$Fgois8Ts0pWEQdk`joKWGn`Z03X=NXr*q_*I!mpWq^d?=G`Ih})pDQNL zimZl7d9n@p)`rla3f170{3V{|WP?ec>gHKBHcs!fF7-BnZ1)P3t3$MRg(<+SHTqvjwq`9wg`m)UwSVBp*mB+yr5eA3||7cCmil&#CvQ#{3- z@N%x`rK(NIghtMQF{qF`<%>G8ns37JWPmQ9kX%-TZ1TrzA}4GhwkrFyF?5K{jrifI z5S9vC6kd`SyjHU>A`?b=L#{C2-S(*ZTY=EZtBZOg9_G;}RL{x)t@vp;=#Y(QEiH`qqMO{u6k8OGmZcpW#;eY` z9HgK<)2+DK>~kHzTu*b&*(2&R6PooNfrYC_7Ri(j5&R`UTZUDWTe~MkyfVSlZi99+ z7o3dp09H%NQ=VZKjhy!h?`uI;hQZi$CgS|XSDVAys>t(SlFej5U+sVY3|Q&myRWD& z8}qmi&!4-dYpaTb(?U$ShLd$G9p)v(!6EYC5HC|~YH&!h?$nrmX(!v%m}YGuQ9b?J zop-Vs>iiE^HfUHGWrd<~YrPDA!ypRsh;G%lA=tbci^0B1W`NQI z3qa0+86f|_iW`C~Uo6G3=6S7$+KT~-9iQK}Z_k+7?(#Cq<=DNAyaPpXb&zIHL?NKkwZ?NFI9X(Y9W;Z0N8Q!nQXWV9m`?b zFtT-Xl;wP_`4BRJe=~u$al3VNTo!2zBUHhyX&u)E_LvHKh&nEHwrUUmyh3j-^DoD4Xps@ga?^}L7b62@* zlCbJE1S8d>_7EwTpZ-y9_3o$6boI?ujxCx!jE!XK@M;DI2EOn0E)p6wzm7o8WXfb> z9(SqVa@bT8QPZf}q8=4tp640niGq2Hz~_u=V-N9%PSN)3C7+yFcYHFrxrmCSYpO(xA@{^xWt{Wh!=CI5HKnKq^K#6S!Z3HPwM+(Lc z_4{ji8vOB^i^_8V@ny?7a~_+x;k8>yEKCk^8!`9k6q}yd)PZj>MJt&|AGIzuVW@V44jK(+-KbqHMcF*3NQLV4YgTcW(rc=1 z4u>UU58jzZK2r)I)f6(d>KXt8lRdt0^vx)ROxAnNF6&gH>4>YR3)A3RWte7syHVd| zg-i-gUkRP=mQkcE+bw=O7b^8mUX~-Iwpw%)DN-#BE$d4Wv+*tVnbO~-AhO-i8%(LF z^s}U{`UV2m4(Jx9YWHY{0W9n*WfN@d>*~0cE%r5v@oW3=YDqw>Ip<}dul{NNNhcQ` z*Kkn5op1LsIPeg;GEaX=YyaIM|B{$y`Rn^wu~jy`Hz8vSRCH}=(Ni~gM5NDx3Q z0{E8RoV6CoE>iMjl)1C!NY8SGWj=HMc{{?y*p4S`gz1tvtKl4+ko9fHb2P%z$Hiv#n zjbw)RehL?!?@WX2B_bCA=YsS!?FA|cFM!v!qn!?;d!7SwfU3wv3^FY8J&LpXORte2&-)Jot00S^n0OuDozoGp)tQnLV1zPm0y_lW>~$fa(7!px83 ze#8+U8#-=E{*7s!#tgi8qyi4TG+mpxem&=2bI+4lKYwZ9b$*sRLH~Aw zBKGh`)j2tejiF9gX1J_qR`o~lR{VyIjf^DTY5{pYIEKBU2h z5ntKpfsEyn@;B21@3&+{mz@2Wrn+o5%u0NT#;>7gc8!yq@rFuM(OOp7bt7*(Epk@a zH5#{TDU^NrbIZ^o-jYSUO(`9Dq5&)@`cf^Ckj@4&7Y3Pw1hwM7qo_RJ%9WtjBFTP} zsX>w>Y6+5)@Q^27JjNZzn+}g|pr!&#EUw(*@jB;je@c^-UU)9JIz@WjDq9~G)F4jS zozX_&!(YVIhTMh>W#^fS)bL2lS_2n`_hr&kU;7E4!=cZ7+}??>8(zIXo~T&MXPK10 zIeo^9d2d(Tn0T9zb=b|oL6UV7cd?$;!%%^j)uQQhB6!^2vl=JY%}`N~wh}kk&ESZi zr5~syDks@Pp*6QO^QpcStTKAuE9KjA94w_ak4w?_Gqjy+!VcFiJscf}Vr#Z-I@$W# za1A&QC-<-Rt#Gd0_m0}NTee*Y@-VPlkR4u>9o|?mu}^St>Ny;$)2DBTelssF-#+&o z-**__r*`#rtns3OB;8(fz1Q&P4Y)-Ifs3|(fDte;U!~>R+0(q3TVj}7;+R_^w0F$e zJ%eq%WV8~`YW`e@5?GUPcLP;cU_~tMCjd?Vu2^` z$NrLow_9mBrvwsP4B;ac41!`Zu71Abm)PCJ*eZkUDuWK-cXF%~Pa+~oBJ7?D3Oqn+ zuPSiHBAsy^MddpTJW{B#H#*}OPmrO;2b_P zN&DWgxyY`EW!{dbFs&8UURniNkD!dFW8?@BNV-fB45!ehR<~J?T;&K*eA+ylcXuq2 zg++I_M&+UR#5YVw@%Dmia*gWGQj_tK`OWG-U)nk6QXvPqX}bD0k>qDgR zSyaGuD$XquJzV%i4DZwz^jCkH+h{4|8PLfI+f9atrpd&ov9f&)>#ixIP35IcRlvWF zCb)JF^W}eXeIDjJo%D)Na&;!48%!N$hK%3mMH_9;YkoU4Y;0Md$7& zx0lKYwyo+eaoFkMqBC@pghN)wRsmJ9} zQ8VmUrkvrXOps$A@-I2&@v@sOMvE;@n3>C_$tU`~P}8*}aBQsCPnih)rF`K_VO6ny z5%!ishH&oPRib>@+eQ43O}=qH)73o(DlhZJ`s43t)vn^?!&DY0vdm@uzcAg(6r3@n zv?;VH4DCOv`zle1ov+m&pVfIr(rSLG&0^M%RxU4cZSUl{PV?-TIB zV@fwrOFIyi#K<}DA71fH(<}Mm1W*|MLP&74Ab{b{SIN!DHrVr z!ekOll&bW7vBDgqbdT+M8dqP&m55jAQ+?TherBBx(gd8g#24A9Ibih1^Fey6kJrZQ>}vY-@=|B%a##LLPnEsctG zLpIrViGxGdXF>WAn|CB)7b?5J3jLh=m@`bpy`#KLc0HOY4txUkXW`niEu@pDxI&}# z8Xj$cyXEKe-+)@vZMIib7Vlf=(Gl&F?A!e^J~=T_D+|DP-J!dCo`uXkVjae1Dri8l zQ)S4zQ0Bqxb)kKs$QfVQBJ}Zqwp6;R<+82Y`P}nJI}!K!BC3dYK4x%*_-Q*PhDGi$ zFHjCpn-)i~yJg)PK5iR*U2xv2Uuf9&)zYqa$%C|HGY3E!Dk8h;cKg9F2&s~+S>=kN zybSuLGDdVj=b-ZN6msQXC91V$Mnpp}dk(SPXmeIJdUQSP>b&8#x5I6>i&*Dd<~TmO z!vXs-^KBVM=iWy9F=sAaYtc+}we(!1MRKI+2g{4&HMVoz4c*11gK=Qpa@pY|E;J2X z%_Utx>%AA}7l_{Jcdh6+d_Dk5^qNT=wXXwR8+`Z??3GDX=CbcO*VZoMOA`tkgcP^xS5qwr#3YbL8aIWJ}nt2Ek@jO*-;vQCz{9=*<%3#JYXngExN)4uTp! z-C=t*m*Hx$+{|89z40}*){WN|{%X*BV`O`L;xcNY!xpd3$SKmOhJ;Mm`}hd0KlMql{HI%_`VNRv3y@5@}+C`#e+c0%sYKd*V{ZmRa$P>LpN>>HQJEh|6)`!k5IL4zs#I_5tJ3a|6=gF>a3JdaPsiBwX6F6VpfBg8r4GeqKi5MJn0~Nz|DWxu&Ajy zsUfM@@E~jP8DzS3pj8&;;ppV3j=Ye6z|H%;b+%O!+u6~>QLAgQc~OP;n{S8j>nI=% zkVf^r!~PVMHfDZJC0FED*{u5$yB6jT%xz?Sm{j9a{@LtMy(`ehMX!9cJDhb4K!*atinN;Z+$Z7kin%!i|Aapi^vpIrEYTxptxTtD* zq%pK#wVm@4Vn{EypNq3v6dYViWBOQ`B7r&aN}0Kr6U)@D%gj?7PHsqK)lJG}cdVl4 ztg3gcs+TyaNm;8A(Bro!k63=}GoBO0I|5>+`qju&U0E|~_?cdc%IP}zLkc@lyY>Dn|718m|_!8RleZ`I(F0JgTqu4 z*4ewbp=M+oLo5qKpiFN}&575gd4bw8BH%AxrgX4wS!h@SZFoX=L;`I@LPL)%ez&YV z7+;q_>3s{s$me&{{ ze4)8PBnM?ooFto{EsRz}Pd4pwmwC?&T?-}BC7u`Y7Tlx#=JHkWr^EsD=hiD#k#zotj_2F*V6 zeO>G@tfTIWL~iSNCYyj14zU@$5G7BHPVPz#Ye%X7%N?Qkl^VIMf4E#PD($<9KYlHT z>s@IsOw_MBw{QAkv%H_b0eQ^6yxvYmYu?)HW=*wuMhKPl+sxWWi7mP?@`K zqpm3uf{FYF6Maf6gS}&~y%X5#Jkw{4(BVKh5Hi#Htu@H3>mXsTeZU|)wHb5q<6iX= zRcC=ci`_>e2g_DU7P}}S2MgacZwfwuo{23S2d)U2XdP^otL=R5QB4P3%2i!#Z?M@v zXg%-+m3g;&i|y9s^EuOWtKJ^SdeB|ZoI~L=KOdIZ+i*6it=qp6F;t2KtR27iu{-v@ z0fjNFU{tnd6=sE>V!_gjOhvkcyR>Nz$VRRnjXr|BwOc&wKV9dd*(V#mF&|~hb4uNM zxq1F6n2^l*^Ya%ts}|jFM97?3Rz{Dr-tD&jxPMhP?Eul(Z_KUP8kq>09}n3A;oN156$#47IdHJeaVmn?8Jocf!(C5V&!Wq&82XY`8 z73Fm#1#)PZKHOgU8jk5ha-mqO%)V-Dvvb)|T;59ErkBl~Aw55j87uNLDCN1Y*q9%;z8cn@k5<3nz|U<9D!*3t z2chpqBq!Pkoe!FOgZ)Bb^T|u&JTPp3CX&8}P(6{iIh*&4v1eP-d$n(k40qdYymW_~ zs#`5g@UxN2YbC2zky@*mx*e5ktxb~tg&mAB z+-;V#k0Vz^vgJ$@qt3;4P{-x!q;{#=5!1uvip^!$I{C5bK@O5_Y3oz?M1j&>ZN<;g z8;uxMu>p=+FD?xat67!JDHEY{!GTVy42x6UQuM2F&B%_|L+>STle3KLTH+@DE$kP$q-5NcZO8CaAE8Z``#QNqxmlXg&jT8(I`Cl<;pD-ac*A5>uAS z!}=_Az60zN)jODhCkUMzY()Fgz^K%O!ctl%Xb4{1a^>cUS>~PfMJm(Dhe%9D(dJOI z_N(K9dBLI`%$)tmxJL3q@{U^Cb z0mm^uxscIn&q+|hzL*)1_BZKAIy7Rh*s?ag+?~r?7qz)+E3M274hNd1`q}-Y^H0X)y@BM6JFkOC^gy<3`P0Gs9q;fJ+YRk~PWCwlk_fiD~ zVG?_dty^3})YFm9YITXnG~48_$7G)(&H~RL&=(^N{Q^T$V zj6z7iE%CrfR#3)AsV)<$J6#+{Z!X0QlB6^q3@ealld|5J>nhh0BBYC_rIwhssF1A# zU&?HbNgeKb=2iFzB60VJ=cPx-zz+RRk&q(YgAp$|m3bxWzv3sFn=^zY;JW z{Qhzdi0{jbMX1UI%_gj4=YUa4>HMff3Gud4vZ0^ggf^e3fe)OLpR~Q@<1I4fD!{m> zim~$X7pb3qrvkdcgr|zf^6_Aj(~)0L2~HP_I53Ix?_Yq}i^@;GZ(cSv1#%k-*>f}d zr808W3fW*OV#e*suwnj&T+Zo&vgShQMboF>CAi%et=#dVDW3=fUk;lhOjyXPd1rEF zQL(H>Sk9|CSe(i!I*@qE@WwK6`JWe~xJ)TV9DoVVX+~pk_s#oPOHvo-x5Dy^ZMXO- zCZj^W;so#)IJKXkF}ybhO17##9W12a?If#!btLzE_#~7_`6&9caHBZ);{M_+;ON<~ zF~L8FcKSGh(oY05y)g6n&Rbu>L^b>3a!1}ol@EUKJE1Fk+hTTA?R0FcpRYL5@rb@_ ziLDFt{o>UnS_iS0&Lx&F$xTS>8t$x~cTl>5s#-j_F0!y{*dlSPPyDT)*iLsz%u`>^ zdDv@Mb}P8Uq?~ET<|I}RZADe}z@@YF3U~84*if0ytbCT(_D-%WJMee>Mpa$D-eW@7 zc|c-{!NuW8UB~!d|Nf1*nC_a?naPO6ODba#PBFx7jEQW)uXkwy$KSSd#^!=K{qy#+ zJ4LMaYBqB2O!j2PTdo592D_i=wu3O?q<7yR-7rTKZXFi_;P%tF6ce_Ze+%z$3DMlE z&kZ!Qvu=8iL}spsS6F$4CI-VV6TGAR@2<_4#gbBf9-RxRijGy?cGGIi)tBpcpC5&r zfzF=FpDk1n*B(J{Y;Q5V5`Ez*9JMq zU94XtZc?$mdDALM(g^WCxNUge%UP#Be#HPSzCh63D(s372Y@oCI3~`o$d?t@)v1pK zmvcQoW1$R0Y3IE{zx3o$$zqs51Qd7aM2kEMzY%^T5-c42@*qtuoFB2HLIufC8uj3- zT^8y8dhHGKPVo+)m|upislJt7-N}$kbZb0j-B{}??Xu~zep2<>cuhW_)g+eEIkA3x zoz-bozhuvwL8CmwU64qnQSgDGFp-Liiu_DHN)Adzr9s3X4Sf0S#72AsFla={F-X6Z zYk*&T1`?^10X9(|6P}k~6&vVAlDU;B$JbL2>)|t=*iQeURHkZ7Y6SFIGVmilaV)^T({@R_2kD1=hcLe() z`zGaBWhR>4d7?#6S$8dW*Za8pVkN3&CR#Zf&+2PMN3-;3>iCi6)9DI0I$Ab$p)CqC zg_R5Ic@C57We&4f^Sm~WGa@VqJpah!gbzomF+!Tb?X_|D4|wJlR|#TV**5i|K2|M# zMqI+#_Vr#xmGrA(`OLHbWzg(I_3NBQW1-IS2ZO0BJN=!*i z`G{tw@@lF`eBXiDJa3{F@P!D~U5;u3v=0JqRD7dtF?=-2)2lRAo-QDh2e;{UhHqBS zvEleiugTPWUi+OYzefKaKTi#C>~xauXgPD#R${mJY93@Ew+D4<`>`gz>s=jpcnMOZhK+3JuvAW z*uW&&<>vIaS1BG$Ee(QBHZhyiL_LK(frnebrs@9&WrQRx=o~l~Y1rpN*Zqo(uf86jNYkCRo(mL7eJJ}OC*{l4= zF9PrXmhfyY-UXR|4l>{Ft!3z~J>6V9`e$e!1))#wWJA)@K;OcB7nU`q}lF+fM? z5H41G*O+wn`tt-n?qgh)^DS1dn|6YMKReyO4mHC6xl#Ye|5NgT zpPl7D^~LQ)_}7Gx!%Jl+V3xzXVJASy5mlrj|1a<>Qt^2UasCAjnqB+=Dm}n12k2y~ z?qqt=E=Q#;5~+LqDd>&s_ct?JV}!#Ytvw-^$haOt_G%*9GLfd;eKkPZ8j~-J)VPb) z?2Fa>^RiRbZon_OhBa!Jn>~5DOf+Vdi4lz&RPzdvFG>()^#4bHQQkc989z%K&j4R1H^hLZHy-#dePhQ%*7^gN{q2IggpZU*7JzmUJn-l+Gw83%IBNiIG~fZrazd+2bAjW+v!y`up|t_jZl%)f&O28o~K( zNF;NWnT`klwr^$U-a*RVlgy26mVA37YdP31uRTh2XP?{^ zj_%!Fm(}Tp+T%#RMg=EHKPme+5G$SWK$HvOydn90Y2ioVm-xDmsMZfT*NW@$NlryK zoj>isu=euyZ7;U1qi@!p6+Twi+)K8J&F#vebPYF{5hxpYhAQ1Ar?KzI;GltPXPE?7 zF^RnIKJ6oIVrwFC{nefTVXsgh->#1f2T>e1SQfHqChU4N(V@)JkFWHyg9onr*D2gP zD(}^R2N`>SsX$w@Q-(la;7fnOP{n$R0q=AuJ)Tc5W$PE($<*~5CCtc|hG~7N&lxv!AX-BIwneo5!toYCt#>8~{Xdpt?TA^M2hZH^1@~+%h1Shi1B$*>!hv|>V z`N!j%xZH1#Mo=E!4Ypac+`*h2MwVv%4!`K)uF$07Y}nVyH@I=9-*iGtn~7|V+yV}eylZl z_m@Y->&_P;%xl{QoX44^Rf5qqqiQ%aoib+S?;;Z!ZyQ5(gMc{1as@RRz<2#HI%A>J ziOAM@fbT+#^JF*4lNn!Pq;Rw~M zwV-F|j_S4kgFBYfdSklmxkIF!NG~NUTRJ=PX_YB|86mBEy+iITJ`u@>LR=)VNH6(- z`D`{X@wSu*x;i8Jindazw`H=krLw|b#V@SI6RpL4ttqZ+lBW{xzf$T(g#C^BhfF;d zRXz4~E%^0m#QP}}zw7nyH+|oK^#PAAq`+ybhuA^nG#o*%j60FDJMgnRvS-EF!e|=R zMw|+0_vP>K$5=iYo!EnJs!%n!TtCv3rd4Az-;|VX;l3nNXx>bjhIJC%6wXr5^->qA zI=i1pBY9=K?obx#P=52jOx>aU0^AN|t``W)iwKLnc@Pw_ofY4|5CA@bfKL*@CuiVO zC-yB0_HDS@u_*9~1NdazAb}1I_z3Mrf_9TayNRIzJX8U1r~;78{0YpSZ2KR)`yY7w z9~Al@n9cl&&HVAq{4?yOqcAuE@XVen{zszu&qD0|hRpzKCN+92K3Xj?Y7(8=jmZ(f zV)i81|De+Upx&XAAhSb0;KO6np@ZA&!vk=7#Yg#ig8FqV*ntMv zfd_ya({Jqp zP0D?h+!P;d_ZPhiIO`zQT`m5?vz3znvQcEoN|<`@i{BzUuW%h610!&a7r15_(N+#{ zPx-gz*-EK@9sdQB9&}4~_E2^<>uo}c1mZvLAQg8Tdl?&A1Q_XT-t7)y*;2+UbsMiQC&q z+S^F|$CCDheP5fuGz?kT>6_K@u<(LCh-KPQ^4FrKzDe5?0__Q9?U&GME!p~$U%f#0 zExDN@o7o7vnIf8*qLA5$u$khUJOzS01*AL$;yeYKJOzC9LX3Z5`63hBW5kwlMtf3H z)d=xKkhw;Xl>fG5ZBgov*GgdW3lSY-jJw(n+``WR9atQHZGdJ1DIFOp`-nTV9 zDp(|TtlGi=`)hbb5F{ckA|WD2E<`R~E=(?4P6SFz^%#Nvi8JJv6IH(~!5~hWc!<~C z>qwcmI5F>BBjV^Kbmc<4Zu(rP$|EXhrX?+Kp_M=nY)Sw|qz_?WzoH})VC&WUemX#e zBPI5+bc^^7jub6B6(iNB+-4kS-1j(<0C~V~9Lm%5?0&{OQQ*tF572@h3INLB63SXo zK^cHWxM|WBtk7E^K7g_|%pVCl2b>2iiHF>v-#Gw1aF(Pj!~k0Ze`B!)R6@Kky>V#% zMy3=VQ%uVj0U;4#5zvUNh?EGqPZFOhb*Y#E$!O&vjgrwd@{5cJY>$M+=O2@dB)BT5 z#i1U5f}G@4kF={73@*R=30KXth7vcO)lCBTM63;JJ|CXvm0}A&?d<{ z)}^l&{a~}^H)@E;%sD8?x&u1)8;EPIz>z<%%erq-8JE#Vf z3Mv4BK^>rYP#Gu;)C9@~1%hfpX`n(-45$;74~ho0gHk}%x8HATZcA=MTE~3neb;@b zRxQNwb=$_aN(sBs^g64`#(88r za=U;7iUYNScL!e&_z!>w9}e6Om=6pOd=ID&G!9S?Y!3tvkPoa5cn?$#$PWAuC=UP! z&Ib$!ga-n4;f*tcOWeHqW8cn~fd+laO}qB)O)>^1EB~yRuCTAjt$bYZTKTl1xq`l8 zzaqTydc|yob46i=XvKR)W(9x6V}*6ac;(f~mlgGu_XZh<6^9*%d6gqoH3tZ*_L-w* zS%kdLV0QDuN(SN)@#atp@$)brVSb2iL#;!uIXs&jzw5}Sj@b78wweKx^I7HDhgMRcOs;^?ogURd#h~t$5XX6}C!xq=E&T@&c2!4;=tR-m5MroX>)Y zMEpeF{LdE#5p&^fkp$t-B3#1tBIm+r!qFll!b~D|!UrP6A_l@MBJILHA}GS)BC;ZM z!VcN>+2`5O*{s!l<>%?0D%Bgrr?j1fj_U@;4rf>Am=~C*nAeaq$fe4O%9YCb_{I1s zuMdHDidTw{4rsyKpd+Khpi`)$z4N{UrL%I~d_7@(X5Hf$>6nIm`}6IEX!*n;+MQWf zBHKavCC|;>&D}lnZP=a6jm-VvE$v;=P0_v8?cUwqJ^pR-o%W6P{roNO4ex!^t;gNf z&DA~TE#wAruW~znGkz=Ro8>=VeMzBP7x*58s zyDh%6zOlZC-4fgo+^5{?+%4QJ-1FTv-!$KQ-d^8f-C*6v-l^WKJXk-%9tj?eUP+4+ zu%l$Y3ZTG|L*@+h{UJK};V;3*j~{V9l6}PcNc@uJha?q0l`s|eD<(5K^Lu8j3e*aW zhPS*(O~@W^Jy5QYFp>4&485j%Q~c&I5G_zqg0=+pWf8m|LLbowgGx<#b&2iYUA@1; z!bHWyfV_iXLeNyuRo<&$jiZiZjAOB)vSL)dtHP{8`}Xb|<~Ot>^rQDjSY)VV@5!*T zQM2D?qj|g)k}{OT5H-7r-))3!)z^$h7*0V&bt{f%bPE%K|3N7$ax_x-_U z=4~5c&6^9gu zTZh8JVBrLzDPcMxI^heUd?9?{&7q!Q*CE&8SfQ~YvEizr6Co3!LVZ~P*1X7%)K?LF zR5CbFw@(D6(cCh3GRQz=*)VAtnL*&7EUk2rj1|yIc261~h%cKgtt~SToR{U5X#zIM zdPrZ%U;;5^Au=k!Wh!fG7&QU4k-D@d0gr5!dH^?$vJBUhZ-eOaheHC=kEA%HWTbec z#97!`Bw6@bgju)_5LPg2Bx`I{R8>q9kWac<#uMl%do7J6V~{_TN0(ome>jCUrN}{B z6a_b*PZh!k515te@@f;?MO;Q+#$rTa#Kc6zKw_em!OD@!v13tVF=MeTQ7kc)5tWe2 zXom;~h(q)t_%QM?mNbeqk~B6eDl0N8+Pz=@}7dmMEfLmoj6A&<$4Xdajt zoETyoY{!WTVf~`QkNX7t1XZ%Yxdr;=F-);>uycIk5awXy;N_s?5a3|p;Nqa0%G6EO zjn~cAP14QyDsQh~uZ)mGs2~(clp1IuG%B6GLX)gH3ri{PPeS^Ay>`6+WUHX`%^Dkq-9vpkv7D{s~xRWz$C zbv?fP>5w*b(=v3@8taR1AW;lJ+iChIKwo?SP;ksbVe-mNydJX!kDs*rP|}<6Y!zMe zH3ok=GA$IwyXpURKhPvdCgvgI`|C+$rC0SWWIHg?FcX&GE|T=qp7va^unW0Oy1?q+ zCpL-O(%v*qqE4v((RSND60W$@u@oX0vH`DR0O_;^Q(U(x-@~CO-mE6#MQ;`_RV;>H zIggD>!#h^r7Noopd-K45QeH>24soR^F(ldTh`4y{k#n0XjN4E4Blh0W++;RHCc>SrrVv4mnEwM>a?gI{uU8fz$~yBINUpZZNZC#( z&`o(D&}sQtgOR@RW`?st&Sn|ntI{U9Oy&E!Bwj^Ij$nKR@V9ZlL;JHR(8L+ z`E+uiQN8zd#qX`n1=G<&5APCBMe?rL_Xkfoni=nHCjx}pUpmQi8w#1X(a;f5w0>Q4 z4wogPo(%<-zFRfg&ax$qTQ|hyRBtE4W78s}#K6CBHfX?AeU+67MLWU=&4wb}S(9Yo zs|hk_v0J=b*W<#cr;%Tgbh-qWtO*jJAEp^B5LBL0mFb601SZ{6e&2eWcgeS@!}@jb zpWsP;s3@cX58nM+jPY`iD(~4fyg+-~#^lbibUn%(yRm;tTYSS@R>~Dq?r;ZtGd@0> zM2g5^_zONgca^N-4=8#z5QM#U7$`Gd~oY8w0t~a`0BJ?WfO1wM;7ZjWA@x;rMAY0 zc|S(l;e!L)B`f>=iJNBLQ#98$SKU=Qbr#h9&HXT-; zT`WlcQprQqm%8aWp<~SYScU;p1m0pdJ1CmtJk(j&Vl|vOzA&ScjRdt*;=jj9l)_PY z(n;G3)!+f>I;&!U!hDy=k9co31IxvGLFcv#F{J=inv3t!Vu#TSaWMU1#OJ)gOL}kW zh3~=@fvY(9(0g%pZ7b)hRu3hU;60N_oA;%${nNKwyn4}UWBz(=ALelC__{w+%aVyI zaa`rzB;X)Q_d-1#Ne5&K5*8x4&lnR5tD8dt2&P*v%{d<$(2r9Jzc_qlmbYFx7}Uk` zx_$|mAYuIpt;VGKx;?JTfXE+ZPR(qcSt$en30|dxEtHk zbr2IUu3 zcgfn1l)O&~weXj)1A!}lYe#D_AB>w>9_kowvGXGyU&47q>n9DM7>xQDlBp6_goU$Y zVni5CLc6;}Z!Qm#9=6l!^kg2~e*W_7>8#UqD&+>N$L!M+o5Yb7q4r}r)Mc{+CWaL4 zN@ev{T3-^fd`Ko7KtxIax@i^JB-+WXJwc^7^wBh7q1-i(_H}0n`|dXT47i1J5$wkV z^K8jpeLtzbQ8mVB4fpPm){zk$a!yn(L^mMUOJ4_Al92)LP$oB!3MMFe7zuLTeWx*J zSdk}0A0G49>Z5XXSJH;Lc?>>i>};9FFa%48&`SrRY^TPRDb4k;m#vqrd@SBqnR6P< z7tHq#X84??(>bPDA~=Uyq+h9lrqsFogO^L$Hf4G2LMwchp(v*ZO_&R)_MUMsKS+C$ zQwr&f+%?wp19+6Zmv%AL2PtLKEDVj1^5-g@CfeNSJ4&{lwENJE(2O*wWbkBU$S3v+V7^?YK|P(w{0@3 zt{y)~Mz4J@0ZOxr$!1rN@EDJ)iB*$xtZOXSN^9t<HqB_2_DFtD;2ZHZ*B-$t*Q)F2`6^qh3Fm$5o7Go)NJs3~#C!j|ECgz~M{$jE z^ywVOGuYfP58Tj_DB7NhRqXo}H!b3tu@^;Qw;`cO5fOe*$IQMy`!`o;7i7bxu}fAt|$Y%7(`YS?Z7`*)KP&^y$GiP zwE?xOz&=m>MRkSt>2ZH0xVrb^)bMxCQGY{1ox#W)@0>HytIwfq%r)Cd6Aafi&xH?J zXK(K}hIx1G5K_YnN!F1$7s++Oek~{Ns8_C`szf!hC16Hsq57Juw8sv{B88fIRFhX0 z-6d6O8$ZX@1C&Iv9--c0cQC~HK5Q<9Ut+Bk(6UYxY=!5UviEG`-}ll7R)C^}OcsZd z4kqmvgolh~g{y6L3C93qBOQ9@QF~Y&TCNJ`vg`Q*m7w5jye_Yy@J1_#5LH|A<+lNf zU!JwP)HCL_&pR7=mIa?M9Xgw^0*afeuQ2^fu6`~H-F{h){fcsWjd%57?|4D#Zr?Ix(6@EcE#YP22{bE%{6-Iq*ldN;B zyWM$@MOPUQd3`B|H`TV+wkDh1rGDx@5zmmTnx>@Zsw>OG;~Spk4ZDDe=N~7QLjHb# zMm&6@uiOt09%K%48b}{h-B^t>pIfUG7J7~sc=p3iWZk9Q^Kbav^WAZ86+@d_@od-Z zUnYVmHfuKPL+2}}M9N!QYdmANjMt3ULj~iV6>Xc{BJh6AJB<8-Rsy^nDya|C7*1hZp;9JM=Uvt**u! zDvc6e5n~sHFeS6*C_X;ghT15A_nnybOFocLhp5|7cbX`=kj}p94<-O(Y-2Uwm@htK z`;Ap6ynMBUykQ)ppE$$ixS*lHWNbYZ3p{8eP(Q++sxIjlCRKYRg4!icjtOcGRKXFb z)VI~O)V2G{Vb5vLgJ4JSBDhGn8;Br;Dnu&8%NPXcDPVN?H}Cwpzr4sX9OlERJo7}v zU_bCE0ADXzUt3q(U|x?`m)D?4&qM!8_sRfM526b(P|+LL9oG|N&e9$) zt0k)RC|_XI$DMEBv97G=)xXzA(M2%`*OS#B(j79O(<|1u*0nZ(=@IA>7^LXEMCs}- z81U&g>oyyB>Rsz&>0%kg>Z|ImR9IKSDhVo$cte$~xmGfHyIIT>mpPj{D%a;N4y=j4 z5}Of!Beo>A%P`Hb&#=m{$uPHTVrgKhWofRgt88psdpCP$dryQ5!kxs4 z#Dl~=)2TsVTyR{7Rj@4+wRqgdLomzVxWSYTeDS71qC zOkhS}XbEBX*Ko`5$Z*&2z~1?r%QyEUrz4LeS2DLI!B_!RK~09YX>AUF%>Bssz`uqBS^bhr6%bUxH z<-KM2^7itv;Ev#y;E~|2;I<%a-^smApn1^2ZDq~4`L9aL%u#0h_}bs21F}sr1lb-L zoNSxyID031Kl@MiVK&To(->jAXAC#qHa=eeyS}x4w7$E3Ai61v5ZxF3^UXEKJ;&3; z%@g#2ENcki?ER1(K?ncsb(Za|noyi${lhxKy2U!ty23ihy3RV?y2u(*yi`9~-(SC4 zKU_aQv$eFdw7>Lc>2L`q@Ym*&5|0agzAFs6)@OvblF< zXk|m_m(Z+GpU|?})4bR`+C1Gn*u366)jZI=);!X@;MwE3=sD}zx3DL4AavaR_u!1_L9l!2_~QN% z5HOu{3VXbKq74vx7JtTmc6z3N)_s2aZ1K$ftn^G0P#=&R5E;-KkQ7kaJ<$ETd#?Lu z_sUC8J-M+jwkHM`J9NA@IWa+Hf2Ac(UW2?EXi9-Ehg281EH3p!^+$lIn(0?lpsAaw zp{bdvf~mKuw&^!he^Yf+8&m0*5PBn1DN|Qd15;~LRnve?wN1HAuT9NOrA@;h)c-Dr zoc@F3E0%Y#89P7;#kIH1)V#*gN!-cFN!Q83Ny*9ANyEw3Nyf>;$=FH4$=ONI$F5lGO7 z{dh!7hD}C7hEGOFhD%1C{UMtu8<0(!P4Lo1kr?9}6B^?hldpeV$5|&^$6F^B#TF$I zB@zXEL(9R)!7@Sjl>PuP>L+oQd4S4&BK!?JgWkz~E-?FvP!3wFqXyY=O2A# zCyFl0Tl(tIK)Fn}EG9@V$Sp`EC@9D($RS80C?d!t$R{Y)M&HKWM%5H;d#NC|Sl-w-dgxu`hG~A5dWO}*!e({y}1^H_E zI&{!#p3aCmI(-X!E z#0ceS6Vfb1^>XYLt`sqqFy%2-Aqo&>6*(0Z6~%F-ad}=k0@{>MDReqC3$zCD8Sw@Q zLhd5U-1wEfh>`INu zCdRUo>xkC+D%@V2>Fv6Xz*5*4P4v6+eBE!`&M|Mw`v-dam?}YQ1I~cF!ONo(DI1#F!1p3Q1b}!ur*RN z@;5R!ayHU7iZ*gI(lm-RGBxtKQ@HcHbGuW`B@1Q<=Cq~mm#Jy~WgNvDM-7lJpwfeu z{?eJ%;nun+|ESARVCFSY5><&}-*UP~aWGt0FloHVZUzG`3V(u2z;odM_!Qh3 z9tmfF!{K`HR`@Mk8eRy;gU`X;;TZ5SxC1;3E&_jqOTnq(+wjkDF1RZk;$}^wQ(DTc zz0A~^WM-MiX_Qu8QEp#>FcA3R;>7&)XsRVO;#do2x>S3S{m#w4WB0wFtu|=fmzMR`MI8yJ|&D=aNa8U6*0`P zaj|oK;u7X!81K`d3Q zRIHb|2sl&9QW>?9x`y?4t5CHE$~3f=%9hK*%0#su%aOG(Dv8v2+H4Ky`pX!!X3DL! z#wycI8cS?#=Az2xv<}L6H65y!wHxbgRp*|{q_kwqAUauPf}h>1%JR#&Ml5;s%;&Q& ztp@C=GRF7n+?NLJHxSe#bFJFj^fGS$&s=`l zkhW?`wxLL+x7B6l{@#A*oMKsuPIZ~F!J0;AskhxFWPfe$z6?vdS)06ERL`%it@BRu zvXCU<^X`R!-FOz-o>{9VYexAP&(7V>9SnIlY)@uK1~#}$yH~VR1hd-R+uMWT?FkneL`sRa8|} zTjV(QJ-wIbr>)F9xRlU@tJKPN44l5ib8d@2%Uq?WU0-LVJa(5J!((9Ew16mEGI0H| z=QK8zj?3e~V{JFSU|0bkW;$!@5I7#aKZp8q=KO}8U)~n^c0cqy#66rmlsqgxggop# zG(3zxWcs@LfAN?12l;FHJ9N=>GrVLWq3#yyW(#27NEb^MOB2g-oG|%ivOjR~vgYb_ z-IdEVDn9Rr!*y*hsmD&!=KEorD%Dp@NNcJl?_24huwtWYF6IF8X%hyD>H^(KSF!yk z%w9|WJAQV($$I%6IF{xc41S$>sx#lWw+pZ8dl)Iko^dHu0Sju7d>Cp;DhnG1=2NoOQJ8=G>BqaiC~~ly~rS2<_UG@ZJp=VU+F|pisoxi zE*D-((!r@}N)~Zd=a0i3Auf}wh~^(dYqgz$Eh<-BJ=SXBR;wdAmX}Ug{zxL^xz^CT zH}{I0!9CJFf_mQ2*`n2%8$5^WoY!=Uok8c+kLnavF~vMrB0oqM)X;$4W~#5*@{G!$ zF#oSIzw|2!WuGzqi2d&=4in^Nu23mSrItg_U2f*crwp8o$-MWlez}^+o49{Cqo3yA zhptVL7XW(6CD!&Vd7O}GI-)LQ{%-dm8%_`=GHmJmHHwmMiGP;Kc9heRyw`I6Fk{Sz z0q5w^a^sc|!?*4SrD48r{Y@_ro-g)&PfGl23%Y_h`L=PKH-+kPb904iow&#e-s(Vp z!?WUcmTc@UdAPrjOOyO%&l8ZB5uWNt3jc5xKnNFHT6$(~M`poxmzL#=&F-0;55P|! zOqU9CV zMC77@cI!;RjNIswi6Q4ujoaNuDrdJ%K!2#(bIXl2?Ko2#e4+gpYqG6S`-Al?wetDQ zsY|%M{dB##p=+a?;XkEXzzK^P`fy0sGhMx=N2Xtg1!!^YS3Md$XPcgxtDS_U4&!d) zjZHMucXFBc?KCUW4zJtsJrEA1Y_*-vG`MPK#kql&=1kw+FeTp$TfMqM`ddoVAF0;>RmTQ zWxh3ZjOfDOBtJh1@_KclvxPUxQ(hoiuF@odTf+-&+$EMoy_^)Mj^QugKOEa19PaDl zGqGNE$L5DSRkezP`L7)1W^Soa3$lM_^c3E(G-@_fQqvQ{wpKNWIUKiC;9w=YJ#+r3 z`WeE&Lf${dI}eoOmpZ!Ry_4Il{9v?f{anz?PH#3|YXq3mUq}^-_K1W`dsB9z=!Vrd zznMyDnV?#uYQ)TPX#MBnM82fE_esqb$+j6J*hb!?zW;mDu8X+vQE#7%8^^|R zr<8zOpV$A(K?{Qhxs|6xLeiZp2i+m%cER*lW&GoBRB`L1_M`@EKiSmLzH@$YNJX3M zfz-}o)@x+vVf_;jNs3wEM}{9?sQvZ*;ZM1rPxX8w{z*N0lj*bBTqmbd*~p|BfcHyX zCFHkCF|A#TKkdGsgzGV3uhZUt@_uKf3Kbb+#|{8O~C>puBzK> z%%HH`aubQ;Zy>riMR04_ZK#r}-6hTHfJ2>6t6tcwPph;Co2op|&q+PJb!wr1-r4nN zzwZ1cbvRuOeJW?B(+>e5-N=?=mOlSPB*nSQ>tVx7rsTbkU66bfda4QLoxq$QKeW+w`aU1u>C_1pcX4zOL9#8ocHY;! zk>&EROQaJr?Y0cUu%$uoZNE) zCw%PePma*>U(oXT?EG!)gxyu{h`K#nPfKecmGT%7PUQPu9&?O&XUEHat+rEdhIaQrB5%LHt?vS z8b2;tIhk6h{!{&4rV{}6B=bkQ#KQBGzx?@m<;h@FIW;9(JAIy*)UJlz9$aLZjZWJA z(GFdqi@7Mj<)4M`Ppam+SA-AAchcM%MGya2c|Zn5YkJ&9>!Q~q(PJ(EOU``1AE@+m zxCO=i>co1~iMnTgDKglh3Hq=mRmDAGLa4@OS~XBGvSKIcqPvb9on@JvL`njhFyD1U zrK^jc*zFR=S*r<&05v%S>R|7y1AalR;h*ZFUq*cT=qzoP51KX&kIz=hVXetH-&H$f znT}6879v%L4_=wSHIx9@INnB~f1!gb^|KV!<6s|ZL~$3f4jyxNX-{Uq_XAk^;g!5a z%k8l@wwR{B>QeDF+;1MZumlyfo~_k$jjdMYg#=n+z3CX6?FaDJq zS?BitEYY2VTA6T@$yBxSy~xIA)i^bYB`&98;Y;@FmpLhFw2E{unXEwB*KX_Av61n- zj}0N*GW12epsr7{4YMiU(<54wGZc+`YZ}UX!YICP`w-WC{KW)u) zBKRS(*4dbDK4o9sO7)hMMxgXMo8b{}?$=pj;$RS(8EmuUHr<)Tc15bwFi{(rR-|$k z7+pbY6+V(3G`0ALw)M%+RJN3C7e&oK+-;C)u0~1K++f&IjW%4=u}&VYVZqQGD;MHY z|3K;z@?=-YqpjhXVq&NhpW0X=IhD0#G#9rw%KjchB zI%H5kFW1XX{;60&Jw2CoCUFmhCfCZt{teH@(bH976g#Xar<6u))md|$0e%Tk(7VJo@&~l#}?RDn1Ox zgNjOI(9Ar{#H|3WEeNM!q|cJfgU%N$Xv3R+|Hvu&bnE(dzvd0;T2uEO3Lf7UIYCc6 zWb4}IXhty%7EWBzdsWbx*o7+@tF0)P!&$!pbj($~5Ovckm^iX@wEK`_GhHljVMFa# z6n3o<<=CW@Fr7$a1<51REWrgj=!gR`F7$SiuxU0+`;)L`83??QLM#VA*OYfJsQX$6 zcL@b9RqC2w+)`)L)@-us3OnZ~=X}m3A!^<1%-_04KDlnGR*=hiavF*&a_084i|_{5 zz@)>-xon_sfFH!u#Ir?vo1L4>zG?B4ebc$ry8P@XH)nGBW$vFjzcR7%BwL9Ry!4Qj z5YfKZVdh6xUbI8(qspU|O8DiXj(uelf_o}f6s}xci4SW*jX4;jZ+5Dow;#EZ;bUNP zGOHs~EB5+SpES1kZs=(KsHDro%FglUQRFke>?OIUr)W^NK);eH=F6DgOsY=m1{YVF z7<)C;q+|Rc(#C4}_r|vFW$X9G8oeSUJK^hk2gJcBnjxOfK*ujF*SS&3s^oHWbniK zF>HT|3LO!~2f3TteU2~XC$4k8U#d@nYyof)pB6=3sApm+<>A^u9IF&iwqL1VzF+l| zm!`qKnL=omSa-4OK*k7XUSZ7r+YODliCW2GjsYlm3KQ)75@n zB1G7GkhOm|8f7)tsk2+WM96rcwP&pj99d%3gfHbI-Z#a3X-_}(gSFBuY6TT~e{IW2 z{_+{CJKp@%+9K*hxeID9ZjabMCae?!BWpU69?H25R88@l&;PL2)sIKL$|9EP=i@W2w zw26`0o*tcNp1zeEsy-a}Fo+88%rX7=)0XNW!k(fo?H4bVP$Yt~F6S2|m23nFolDd& zLMm8<8#dhHBQ?B71_MA15CX6PpmITS>F;X02L-8OfOj~A;uh@CFF+X_LMaPjs64O; zCr!eF7YYL6W9und5JHoH^VoW-7SvD{U=!|=v<2JCMU06nps@26%1dP(nMvmYeOLRQ z)(lsvpEfl@nH`W}O2yj?v=540e2e@4Z)k}8zit2LPXCvo)Tpqt*5i6`d5zf4)3IXh z|4^RUs@MFm?q!wliVp)W9S6uf`}YCQAfGRRLUG%9b~5P!f#`~{tjq#!HQ~Z8B4=Da zGzd7+lj?ENCB7|%rno4C`-Z4WL9&Sy9^cu-&(34`xTXDx?)Suj(tvnU~d-8E1(hP4BK8zkL-b+a-*7 zh4wv+o%ge2n2}xs{T3$Dboa0~QT~gvJou6&^JnPk_c-gNYcB38_IatUxK`-T01rch z`{MP`{0?dQ?Nv99{x9E!jJq56wFUSCY7=me)zG{K%{{;h-~k!FfIKQ$?KR0XtgJsc zC4CY9jq^+`X(MOi9mc}^$ zpi~3byVDx`I)3{v-)W6KiSzzjcUt2jsL397TH`8dFM=i|wN7!@wH?%s0kH!cSBCT- zQ6{x`VA$Dj%WO^x8ay+Q@7PAI4c)hm>yJDSN_Lok44R!XyL23-!4h)+CG{)z$IxKs zDEXdm^jGwbxI2*lywvA;^i^W*zkfL@Xy2o@Xq3$I&>Fz(%!Q?UDegd(m)&m``8NYG zvvZ%4^-r0KOXJP4$7 z(?02{SlEiveeGyH(>CJhHQWyjNwrj*Q=-WErmXE=mHGg?3@F$hdKf#+E4a^N$x z*CG7`@+**rZ_xbmx}ERNm>`~u1cvTe`|mf6ggkfyD08u)!^sE0EKzeRg-(|`sb ztTB5QNJr(*WqohCEN8u}2crI|FI0S%wpJRUMeisgL)tEgN_fl*EG-RInx`|!MPMxu zGc2`o+=H_7rX=gf`K3O_50lF0ZjoIr(rl}&htv8wEUTrjLVvwG4F;rEEAH0v5nRI@ zXk>F@(K3HX(idl2T4QMO;*3eXP+HFa`5g=C+$!I(kfkkXlIoE9DzqmQy_7FOPe&8= zM$XF88Ch*p%S^4b8hL&Xq$A>Q(#Yj&C6xO@mw7eFPyHflz1iJTAE3{eIZiqk^^@to zi^ZAlC+{q|c!juH_LtJpYu|B^+WBJ7r&a>Cx;TS;p!+fMuz1`zfPI0m4BQIbDJ&#= z1lNC;R5Ns+MmlrR-5Tk27VGUXIu|1?-?>rd4HoB3YKyi5X_Nsh#u2Dn8j;C&bnK?R zrKi0dX;gI$J36v2;=FIrJ_h}G$x;>Vm29U+YHy1>tiFtNKv?0H2_el1$v^OGsV-Lw2dr02cL-NKRk~j8{ys?MmjXfl9>>>FU&d0M$lXt%il#Jzo6gL&4r_1)hgl4T=FH3*9B>xrm#zY?a zj7+X6&50*y|JX$nY07NVCumcVmgDNHjhCKx+PwB(mGl|;(W(+naa>Dw@7?y~l=2jx z^2qn+r2IxtyKa`tk6tzBb?(^7{t9(V@f=G2U$%!QuKC})lP6`}KY%?sKbUglyKWYr z;ods({kC!SNY^zDMuT|nvc>(aeI<aR1H*pL^Vitmuj%;Zq*RgM^!^r_o#-c?o|y} zol%`tomc%ubwTx(szdd*s#EoMRhOz;&8S&5r{>iPwMwm4Yt&k`PA#YnYLnVr*hN$w zQj6-aI--uMW9qm%p)OM=)#d7xzzIr0EocOtU=U1#Rj>Qb*%~=%QRv=Xg{n69gg*&4=|51UtvZu zKP7+fwg$AY`txzD{`?_UfBuSXW6v=AxlD2OXP$Y9tL1KDe#_m)eVuuk`v$j)&2Zo2 zzR%Wi>$&ypEnExN#x`)L`2_nge;a>0yM@1lAHY7%-^Jg>KEvP54`X-o!}*cy9)1)* ziv1Nonjg*X=ReI)Vqf4V^OM;Z`6>Jq_7MMB{{pbL!A03YMqmvZvigxZnMVF$Bn~b%j4`D6o6y@#8zT6Du4&_d6rt&%EFSsu# zf2aHdH>a>qCW$-?Ye~P1wWMFcTGFp$73ue|esq0dS4{4Qg)d_LKId-6Bm@Xa2*^yB2a!ocKx8HiA_6jm5HJKx z00EI1#4w5&WS(aT^E}#G?0b(^q_!U&r0>0tXIpA51w=%Yx6ZmZ6fk^5p{4daUw;34 z&pl`Fwbxo_@3rp@2tbfVxuc<4v})HCF$2bAq@mrQjDas6LJOH%U$)Ry~-!bSnUI~J9ZhQ`cikC4K6T;Uyd}lP`PzlvhA5WnrI-(1Dp)ZCa6C?53EnAAhf`<|)g>tBg255p7 zXpioA9s`hu;TVO9C;}^~WBUX&?V8j!fzO7<5P;@SA`pWzD34mGgT{CgtI;VT3S- zS;r|WtRk!}Y$$9lY$Hr!)^&Oc`wCNpX~GQQXyN$Gk^M8BslqJbJYlwQsc^M$W9G== znNE&ykMNN2gz%*Bl<>?5_NsGMcusg;ctLnkcvX0VA8U)B$=L6q#IN$pgnKY5pDf7F zxXtsF<|p0b*~;+DR*;|hB0MAgFh8|;ZY!OKQkc>CW@NruEZ>Z~2aD&MWn@gb3Q@Wz zBl69%`J}~bLAmdx<#~<$?n=B)<(K&%ZOMGIM7~&=*Uw(O+NSaPITf?8086nJTd@a6 z@E%U#Bm55M@hPt01}Q2)Q4~w%D3R(@Q))+DsTU!Uu6 zZWuaSe5}+)RQ!BczX@rnt)b6LT@7h$uds&gi4EHwJ0q;~!V(?t>6YjS@W@9sFO%8ToH}+yb4&pG5<6UY_Pg4tONo}Yt=Sv6bNS&xNB~cg7 zoo<{xeJPW(XC#fHS7}$HD*O5w<{S z^^LlrzNQ^^gdJ&nc2PTM8@qsAP+e0uZP;X6cEDD)W4p9NeW|Xiuk1p0VY`TJ+nRRB ztU8n)r-sx@EE+_qG=yH_Tu!Hq+s8|9Q#S3O-L!}Ht4I~4qSZ(>N@a8X8hR=N{1kP? zJb6ddiWwVj`Tp(R)#?M@>-QeuBZ6z_EPn6Xghy;ou2sGrybs_ND(NA4D%7sUt+wNL zNe^MHx7$my=jgrBc+?IG{JO7Ohs?+H_R9{k7jmUq7~T-$Z$9r6%fNyq=gd(PVie{Jl+ zyZJQPcW3<*t;pM+c&>H*y}bWz#AL26vLA^>dE1u2Rk)v#!!edCpE-C3s~@p-dD~f* z_X?qG9*5~Xr!VIEEazXw(!6ah$Ge-{Ct(KWb4|IPD}zJ-f>z&czlCOqvx}+s)lbw( z^`SbWeyUEZ|4{#_{!5)w@6vkOKpSZjZKf@>jkc>FsUNHN)X&t<)d#ed{J6w%8{dD1 z56$nPT?^n>a~AixgUif!)fwI~KG^#4_f@TXxcvuQL45me^JP=Ss?XG?>MyjG)~Ua$ zFVsc#H+4x}R)402^bRee#k7R?2+L_Dt)kVmMqN>#tE;q(Ry<%<_&rNSc>j9v?rQKM z^!)v^aaSZ4yr@y znA)f|sm)wzPvZ*wRkcNJRohgK+RnZ0RJ+t}?kmW)rE*dZp)`Ll$GbVjHfFG6U#Dz1 zY~680`_|zxwl5mx#l{M1ky?XFe18(ZUPGyBsamF%s}+>4mgIY zqQe%Yu|?@LjIGF^>Cn=Dtn?qR)~d~1#U z19XrM(P275N9hi73O_i-NYKT^L`zrqr}{+$2E&r?61<@|5hJf184@74;-?<7$u#&uyy zl;Vmc0cCi8Er$x6mz7ZkRoU~^P!qNAI2xe|dgDc|pi+3nO~X(O<8^lgMshvnuf8+z z23J)xF-xA;eC}Mom05W|*&}3M$ys%473dUR1uFTgims>I>UO%l?x;KI&N@kV(bM!2 zy;LvPEA&de%8hmt-D++Px29Xmt?f>7-*B_sneHriwm(nn4{o)ZdRwcN@7Jo{ruXW7 zdcQuX59!1Dh(3B}Kf#z_TrfUZI#?!HHuzYuT(G>~n>&#+>NE!Gy7xS~-*rs=*0D9u zSo!pxfwf?9b=^`>1=b*FAG434sQsmV9T6PM zdWd3c`f%R^^*~hBFYA|)$Pt`|YGP9jj@vdo&NiLI6C9fl(N3)Cs6W%6;RSs|-#{*w>fiRS&6RQJXK!WY zzr(m5)%?_uefgbh5iF7KZNBsBuSQ7aPH_DSi>r)w9M2|v-_!iQzr?W#D3IeN8K$WN_HK1nHnk$SR)R$7YzRTeH zVm#LpSzI?{^X_Ri?z@Gjx{D(RsQ+7wIb9uq?~93RzKBjFn(juoAg{ z-@2M;F8U(6hz>wk(PZ8W`kG>&5FLabqN(U5I?h_>D_urUU)2crny+@8d(~I3r2BG@ea)5(KTZ>!Bfl^(S|tyZJEjF#!Rt~GY8>0W~%*j=1X{iInMr&`I@zo zciETmJS-mFMOZwx&tUP${>qF&3udhQH)b4KGUL&TSsKqU6VRGj2G26fx|f*ctyRnl z?iFT5Yb~>q`#H0+dzo3)TEk4VRx_*FKV#N%zhO4CKVUYpPcs+Z@vGdp`}{6JhdNMK>KV!+Okr=0V}Ip{_UBf89e`<~$<`KM>9TjoS3Azz z@2eN%Z5NI8c8JD#J4NHYJ))((U7`uzZqYK{UeU7NKG6!^0nv)yLD5RyVbRLo5z$2N zsAx4z@Z;w#mnUeV#BY+sZ?YdJYqK9AZ?hj8Z-XBdZ-pNfZ>1j<&-Zw|=li;}=X*B6 z^SxZgTjxi`Tkpri+vvx`+vLZ?+v3N=+v-Qc+vZ0?W?s&9)>csbL{~y>G-k{E|09Y* z9m%S?e)gcAZ;$-?R{z$kfqst3tI@a4)#4WV!{4Vj;GIVw`~tu6pLf+Ku*{z;&3?1P z>@>T~ZnMYiHTyj6d7kSzUO}&rSD0J$f5+{OGx#-rk3U$`c@CcBPUd;=R$cGTap$@> zJ$U33pX$HL^@o4?M;tPYu319IO-;rnubO;owP%csA*)oKa< z8%fpYE{loJ_GUZpuqd>%L^3~JgX~gXWhWx|KTaj5ij(M6cWOGdow`nar-9SZY3w}Z zeB%7k`NFyCeC}LvE<2Z;8_w6xH_lDXn`mw6fVQ1KIe&KkqN8SAtI9F1ZFtzmF`hA|kcrgF6gRQXSEjnDW$KzIOk?w;X=U1)jwZ=;H!qkz zrk_bRgUk>!)C@P7W|SFgUNaNT6f@n-H1C@C%=@yl?9VxwV#nBVPEn_nQ_-pHRCTI3 zHJn;b9jBi2xbuY5$Z6&@cUn4aopw%pr-Rec>Ev{FlAJD1SErlP-FeRG;XLpB!MWgk z>Ri*FE~pFZ;<|(`sbh309joJXJnvj4dL=o(YXol^%h<*>K~vB~m?#r%N|}nLnyG2( zm000040tKc3001BW3wWH>m}hiV zx3b42jkISp0^4*0w$HJ#P4B(;-g^sRO6Z~YP6C7wdJQ2Yq>>N@m@6-GC_Fh|iM$%bJ|E;5+Mk9m(k^HD^LW-m-!uMpd?fC%TLGL{HI2^b`HX05MFA6XV54VuJWsOq7je zRoPg+BLwEf0)lWj0i~kWG?zZ1Pw6w7M_-5nbeIm&5jtigZG?@oL0i){wvB8P+srn# zo9!n1tKA}-%8s&|>@J(jI`%(hzPk=Zj`^sO|l1%l-uMkxl>%0 z+r=a?nKO&LqL&`22g%KHhZ-Q)`IAveR+c4&!kn0g!bGI#Eo;hJvWzS%OUcr5wcKrQ z(nz^Xc9s=nMNv^Sm(65dSx%PMqcAs)z+5;Ahv9DAgZpq7g;1zTPbsM-y+bWT2eCw~ z5NpIbu|;eU+r(zET`cowP^THSZ8ZATm%nP&?2x&^*vG&?+!Iurjbca4c{x@G$Ts@Fo}*j0wgE^92h9O9aaV zD+SvGdk1F*R|VGxFGQQ@G|?HNgV8b3@zHsr3q;q6ZWBEwdT#XhF)AiBCUs1@m`pK& znCvk*W2(ipjd?eV$`Y0(I<{}@lQngCQ`+*D@KthQoTiuSGZ%11AF)0*?dFf+CpO*OE6_AXq$D%Gc65*elpCxFERpZ!PKn zp`~_o!{`s9r~a)am9HgZOw`|65@I?eYYE0C#NLU0`(IiX#qIrvmI1jEa`p4IWLOyV zwTL&tWG(+#rFz2uSkD93-z2?nX8q@ayq(v-bNz2i^>Vs@TiyRtd$rxAZkLt_ajEj9 z3b&qKntr*|zgt!&Zb@7t#Ff#>zj>WFH?eoJ6?Zw@@1NW!F-Kx_VpL-0#PGzk$^KHm zSNO$q7sD?+O7c$ylFAerl1guEvX0$y48~wA`eVc*_zo_&QAw?w&n@zMUP(DK<))Oo zLsExC{56V@*pP&f-67XP-h@(UuF!m;E`WfAtT2 z@*i!X_d*|pd13UI7nU~Z2}}RCmpaK$dMDfQ|NK&65n)mP<);tJ@tI6g*uiA=9K7Tg*qi-+P_*C1d2kRkXvCpj*vaZ;shl~ z>k)dSPpDizaq=Yd)A$4(hQodSjKW=i(MPaP)RajCqA*G&SBVH}k<6jiG+YG45TCPi zebUbJS^I_0!2&*M4=1xW!l$jzT2aEMZ6lwzO?=iildDB9pSPQnh-`cBd`agSO#&v=#e`VmL$;$I)~g-=`D!0i6^nL@69eNAVkai{Dy--&u(Z zt->Egf(R3Bajy;FejAMkY>Y@P+T%gd0dLz3c*o|)`?jFyg1_4m_{5eJ8ALa8*Q6Ec zMOTuxI%!*rl&!(1MJCaMQrqT~#qt13e zb+HH3Sgb@#u`(^g_OxELQRDD?3;56$G8fEc3ffL?lG$#y;UFAL2k{51Rf1|uo~?}q zX#uvQbyUa>!78){tI}$mMt5;K-N92fH=ee+DB2FD7(0l{*$GtMenegE3F>B#Q*}F; z>f1SPvicC0+A!5ljaTi}N2-IGfYs<{oIzJ8i|tIY-b;$JT`1mmrE&JY`dCd=lSC&q zSxv#}*o$`HQ);ZHs%dVfnvR{+yPN@M(p9`?^Qw+&hU#R;sLpDpTC9FjOVm=eO#Q5u zs}*XcTBTO2HM~=;RqITIT5p}&pf;*s)F!oA{c0llJ)6UeQ(M$lwM}hTJJe3KOYK&B z)Lyku?dMtQfI6rSsl)1sI;xJTa;qe&Z=|jyt<$+szh~3T~=4rRdr2W zS2xs6bxYk=chp_ps_v=#d{{kD57lq#k(=datHVQdaeFs z4I|j&lrR!T!Dvp+>D&))5uf5S{$4r`#=?g%o^SDO_y{KWam6zDSgi3LcxlXabH!XW z*ZloBSHyfTZ-k7lv?$t*ET%`z{mm)*Z zay#XWBgZZ!hPu=)y;$y5^eVYj^xsl?5cxbA-Y38|k!6(H%aUTowbsUR7;b9uhnYcR^!gs|ku^Y$G zOk6DX;30e<_TpC)vKn-Y=I7oxUA#oUw(EFU1t8)YH#$&`0aa0@^C&Wo{ zN}LvF#5r4BoEI0wMUiOV5tqdkaZOwm*ToHSQ`{DJ#9ecdKd`O%eVzl~z(Sbsmbj&` z7=D12@C7XKW2@!xIs60*U@3eBKkNLum@c4;>w>z3E~HE9!n%|$qD$+dx(s{|i)g3K z$Lru*_>M}!3heDin#(ozjPipTJ-cq#snDS0ig;`LHu5%C*# z6pzI3I8HnfPsKA{DV~cL_$Mx*4B|Bv!JgDm{3+hjU@4@MAhk5olPF2Dbo8YRm8oQE znU+q;bTYlnz`>Y+gZ7q;v6o~P87JdqR+&v^mpNoknOo+e({x7W z&S`@4+QJ3Ra8Wx*)G6SSP6?NF z2wc&je2DjfgA|YwLLd~vAQhyBG>{h3L3+pl;gAtBL1u`6NQi;}1R)w?APdC0IS>c& zkQK5)cE|xaAs6I^JdhXiL4GIz1)&fWh9XcDia~KG0VSanl(v6B87K?o>}&hRzJ>Bo z0V=YBN{nowGBZ?xs!)wna43gCb*RCqpeEFU+E54TLOl;XfBW*-b6yIl4-LGO(9qmA zcRb-qXyhpmJPnOK<9W~onnE*ozy!F59Rbau1#PDNbl;}1#Z1svwGHe@JKoN6Gwf-5 z)xM+^Zip)CWngZ9t?-i40P2|7a;=nCDS zJG=)y{Igy!=nZ|KuYXSJ4+CHz41&R&-aj)9g<&w_Wd_SK5SqXczXQ-PoV@-~ifdZkU@mkoMs$x`wmqI?kaR_zB&_xpWJ^ zrhB-^8eC>m;mk!$xWNkfSTc5JpZj{Y-r|kAU%3*s@Q9F!^+2K^dj-`rr996O( zQe`g-)wENomYqhm?R2VRXHZ=`lbYDM)YN`T&FnmCZa-69>_O^o57B$}F!iuUsHZ(j zz3fTqZBJ1jdxrYjv((?7rvdf?4YU_&h`mfh?G^gaKA>6l8O^rOX^wqi(|PeW(LQvQ z>})JbUtux&8jI66Sc1OAlJp&xqJ>zRzQ;231D2&lSdMvIjR&9%5L*W^0*DbB~w@C%%WpK~K_#!a{dH|FNt zlw0CTT#Ku5J+8uaxCS?HPwvaTxj*;fe%yx#;5kgh3wRmN<0ZU^S8Pw)$M&}UY%klF za#9}3P5CGn<>j&b5r4=Z^EjTs<9Q-|%%AXQ{3(CVb9p|`<1aXZgB-;%9Ldof;4EC6 zi*bFf$F2As9?C=P0NbCZ@l^hj7jPM_z~#6Sm*t9Fo-1QhY>CaW6*luvr!BBGCvXRD z#~ryXzsv2p6K=+BxCM9Muecqz;!ggCzvu6G5r4}+@IwBPvvN+(&bc`o=i(fkhf8ru zuF9pk3YXw&*ccmOLu`OeOchhz6f>nvW$walxHGrruJ|P`z+Z49ZZc&|X;YR*@Ngc) z19=z^#v6DYui;fw!IU%Qc_z=`$vlZi@o1jTQ)miJrb#rBN|;KfqAAHg@z=bVzv3lS zfbw%3$8x+WVTzlYrk1H~YM45vuBm70n+B$#X=DnRd?vqXV-jQyQ!pv(#23s%^C&s* zRL&Gi&Owzog=JIOOx7`N^{AwH&^%7cLzySCi22>LGwt;mHu|hSr_bvP`l3$M$Mp$) zQs35h#C$nNej?|}Pvt!MnVc^_mtV*Q@=N)Z{91k^zts=yD;DfHEzHwlI+aeX)9AFe znog(F>kK+vXOwqjXPrrB))6{VN9lkL>S!HfcA8ygx9lz3=`3o#IVOKL$K`T!%A7GL z%vp2NoHpmod2>{~=cdX%a-ZBQ_sb*ls5~eS$V2k5+$C4ax^joys$=C^9iNn|)7fc~{;uiMG7CM8#ECT5jjNwQ8>Frao2O z)jai?>Zv|gUznfGaWz1>}R=H3P&40J_UiPl7$v^dE&)sYCoBjLNH)LkSx34F3#3UP+BQ=(tUxJ8GeI*&6R0q z=r?{^&wa8@AW1vJlwo|&yE=MzzX};jkg*r|p%ATS#>`fW#&+%nblIZSFgg^yy?`>s z`0s*IFghK%Z`n2(AsL>m_YKqVBG(~Pk%$f*$|%tl^t?^Em3#eFbJFuW{`URAmbTRk z1hw0NO`D-5sLH4sh9XHxahF!18k_{J@$)riK5qvCPV{0ylkFgaM)0#qM(d2$BP$BS z&?2)OhLVhSa1e$LWtG4^xnc~5@?JZjymVWQHB){(pev%sJU&=>* zhq5IbdQbF34|gYP`69yF3Zk|ZZ-;>l@pN-1z$1%;8d!EHuV~yW_l-=NnlT)uE0JR9 z#+2DVB(nqilrK3nt^_+d<#nFrjD5j3&}I}eC8}#D3#vapWq7_@vPa3DP%kHcGQGtt z!vzl!N5b#PmQ7B({lK=Q z9hPi|rd5*3_|%Q-4$UYKg`hLuU49)vx*<*TX&a|$oE)0PHFG*80vYJQF3ot6=tY8N zkTi$pRBJa#a@~5kOw$MQi9>Iw)>hEkNtKoj{k+znRf#d{?FGr~tVd?-(rlTV6s_wf zXZU9tKV&YU64_!qNH}?j*6pFZY_?=eyf(yE`kY@u@3SUEBu)6=g!bi9ol?NWFyEg*-dywptRW8Y!=srw{`is-SG2z$foJ;1jbOq~G|qZs=}&|I)i-1{xnwRPqRWUM z4xj8V8au8!bVXIp)f`&?FDja_1Nv2z#8@hdifHoiB9(V~y{2qp+5@b0tVK-px@j&h zzPpIbaTkv>UTgtJyn|kSCx%N{%(8(RN?2$hE(mP} z_nlxwrrR!u0Y~ohXsGtRMbx3x1Dae7q(FH>zo4tO@3vN16f0AZfG?XFg!vu zWRs0?wQ4$L9Kax>#%@p%HGCV{++A^y`}z>ZA@HR7P?e-yC@04NDX8 z=lRtTho#(5QdBr=4J_tbSV=180tWEbNZmfF-h7#TBImZEYWc)VT}9W*Js9R@fw#vw zC`*MZpn9VY8)lcAOQO{)7?Sk5I+g}@_-nLc^Z)8TcAxi4O=5){ska>teDpaP!}uE< zzbyv|7{oCOxrvY$)8WL|9dkHeq05-Xk5AFx!Ok@o=IILXT}4+RTAVc>c@+(O%7%IR zL~%P(3-D9b$DRTB48UaYx$2u*(+1F*E#~+D+st9G!yE>?%we#{oZA3jFo(gH%wZ5P zhe60358xhi7~E$LgRhvw-~n?Q0ADkQ!8god5HW{A%p4bBpE(RV%wf=F4ub~j0b@SEcN1CxbKZvX)R0ssF14|trc zy$4`aRk}Dn=a!iylj$u}GreXqlbOs+dhb0XgcL{uApt@sp-XQ9Dp(Lu>;g7WRInGU zYk9WSRd?UI``mrIuDcdQjY{U`f6l!#$)th){!ccWDY@tC<$UKm=dcKtlf@!5wiN9`O5gm`uti1i)mo<`IE(tI5d6Oh%g|Jr9d~3E!q-z#uY&;LkUi*Y}jI zsB>tXzEl$_zhA^wIQ;HpZ>l-XtQHuB4KlM&t4XuSWR^6I)@PPc_v7CU^9%7s!-t8D zsrlB@x!IxmY^TL6?_OmIxGWC8$&|tu^0i@`#)lsBX|!o(narFa5agSrkSuB930vjK2a9}c8ZMXsF0~Y`W{I*AU8a_|Mdl*0Yo+*X9Bz*spxK!f@ zSSAo-M({uSR=>Z^KpDcHnN+|=eX6j+0pZvesgvYMdTej(*nBj4AUzlw2Lzb-xJ)Yd z`w)8+_^qQLKQZ)#=Ji*Wa3(^|NS9i5VyjV-B;b-_G8U8JC*|51g`r;O7(&0ab2TQr zTxTNKgpftk{vQ^LJq+<9SxE>#8aatUWCH(UN zUb^{h>@P$bX2hQLw_C$Q*lB9{yVQb@!F=iywSheG2M7aa-34{yeF!6wC1W{QEDIzr zke-T}3`$655UE8Vq6{2@RtbX$d%n6aSFJ1PEvGL0Vc)e|ufFchZ8^I9xy8U)w)>UM z;me<^|w+ZkKaX&oSVDwIl#W-_8(f> z!Q_7E<217-4%E5o$-Ew8L6Xl}!dscEi^6GSB&?@C}YZU^eSgYi2<*j`Q zU`H-Xi-^`ABwO-0En6kzuoQy~hKB4T2c`L=T_8aC&gQ)#h}!cR0-NAzF#$`ValnRA1dCzDt;;)>nR4qo;0o^qoWu(h%y z5!}i7qdXq{N6x3d3%60<0X}vT`6_H(_-gV*_y%kl)H5mcQzU!_XDQ%QkYI}`@)#6+ z0KSJmexf_vhMfe*4>JQDK8%I}{KG`zhaX=09*svN-WG=cjq(sYOpnQOKt#a92sU!t z@Vh?hB=`!x*2c;dfgC4G@Kr>XGXUQuSkUSj81J!+ zFlL|_@+j~{VYAOiY)xbmrH2691&lW2N8wvqq2X%<~xm?6paQEbqMBy$q?+b_RkB>lbB9WQ(4;~YB*u)~_N$;h;JKx`b9`Ns7_R`(k+C9`) z$m2p!UQnu7@~$ z!AgJ}&4O4k7LacBKvEglas`NbdB_(I%19(J5j>QKX9KLEYdr$&aj)}lEJvthW#F?H ztfcYneYCDd+hFT|d0;b*_44yGvU&2PWcgk|q@swh;QoRYIz7T{;9L>DZ$9Lx?ibdsePK^U z#UAu~cSYRCPj~e%e>KY2{_dxl01=JF#Qk(ER-1!&=pm>s1gzvKJ(VLsPv?<3l`HlmG}ZdIASfAH8Y)gyeHwlpL1eQ5Uw-wR~Q5kco(c~5S z9jv8hWu^K0Ll5DzFP0`#?};4t0Z9H+H~xN4fva(CjVeWq{b((o9a^@A(uWg*;9ZqG z{1$m4ciGX|mD~Fp6at5a_6eyY-x4gykK9Q78C5QJbkfAQ2py9`r?La|oJy|1?@3fk zWoacHc^S=_n#|61o7Z(_7H@lcUFq(POPuuyda*LAVR7}qX86@r@T>fFkF47INeyv_ zOp{t~a%l{ss3`@9FYRH}Vtu5EmY!{=Dqmsyc!v}d&M>8ZbYu&kki!IL^h zI_-{c!(08a?Fh!p0%HOzRp6xf$H0#z4GX#N28SiF7msVt-mQcXbLH)lG z>H!C3A4uo{192l&LtUh5h}Fa!mqNrFe@1_Y=D~NszZ1mdWdZs}hW#64Qm?}&UWdQw zr>JX=hD)$#kAlHJ{~11e0Oo0V@L6TVqrhh)vZi0^Fzlao8=KvL*L3S=`>*-z)+WGn z&)oQFdgtyYeBSWw+x~P%TiYFf+6G_W(X_iOotDo5>Nq{7FA`fgG3iV4SZ0%oM?f$M z2$@&3>G4$(qgptc&{*kACqHZ3I|plMxOE5@^2G4%gRkGxE9R;VRvDAxbfC<~-(}-; z-TwQlqR22v((!I|zAa|4;(>|wj-xRf_{nwQCohJd`~*&Q;k+uDpQsUmrZ|rg1yS;Z zQ9XQ}Ye7cF0vEnYVP)bc%roLFa6B6`o)t~8BjZX&$IS)^j9d{6p~^&@h04E3y~5+N z6FJoR@2P_SF?r&Cj1$DgNw`1*q17YsYMF>9{E?kT!^Z#HoUTlf44cUl2F>st`f7)> zN{`P~SRqPxt9DD!)q=R$<>c-(VW(8mxYy=O z=pf2Qu6We!am4UxC}q->(dr#$!fsi7J*2ZVZDyVsJC@|D_AeaZ1OEP{B`p~inVDbg z=;>dUzVx|VU0eUU+^TiW?n#8VonJF}lQr{!fmt^%%O?|MBJd8GoSI`OEzsr9FMT;} zcDZxc`a?JFSLs!XW^bWQIB#LF#;34WE-km!RTcPjxM@LuvN;(tps}&Fwt80a=EqlP zEV6hyci1p;fpC)VKz)Up8zGaXh|LMa(1Btmoj!{EV5PGsl-W^WT(PLU-I&akdn*RD(@Kr34W(z)}GG$4;N;iF03uv@$}%Px36!I7}Ip6Dmes4+e-1s z1^iw@%u1OU|FBqQ(`;tqTN_sGcDrN^u8YsL(1rt()p+Y@OxSnzV{`#G3M}U){X&{Iv~Lr8Io%7!AMp3iTvBiU4OS zEEV{@B@cG+I;%~EZ9zwcQ4T|_ktroLAMDSKU{p8_>PH)@<9(At>W;+5T~7`$n6^(M zCBi$-n`|Ac3%-fS2~Fu}!NC{NqJ&%l{n?agPh>8f9Yre3ehyijb8v3+_F3+smezt5 zz9F{39nu7w;EzWaP)XU{_Fli4yEm@F^$RD%QmEG|H!M*|$JGEvEGx`D><11*d;w zGcUPf8vUN0i&_-kL{XnESFmphUQ@mMz#^&U(FBPgLF#SDDO+4=NlD4_{yLqJ*(4&N zulI1@`~w|MAf~?dIOKYTIG)Rot9GXz-i76=RP%J2g2Dogy*!wlQrVrJvC?lyyMpTA zm~Domd}m)?R_BKN4<8AC=nZlcxm<3<2hhCP!Bob^sEH!XDY$wCXElz| z%-pvW`uHE9!xy3qbF?nO)Ji3gx1NaQMp+}mC}&S*Mtgx#8?5uzF7XZ>PUFe)?poY@ zO>Zb~@b2E04PI>6?{v=G(bm4H-c*oH-2RKt-BaFLw(FJ6t6n+S7)-^`($vTZf=$-b zb+8aq2gAKIPUSG>?WS?^Ou`A6ra&ry>ZE>|9~+@@%ZIqtdTW<@z@7s~(s@R-1rD1bh`?`wc{A@hu(jkOl;nwFj54^CiHkkU!(Kp{@_)`FJ zv6DyO+`X8YxrD~*$v}rkgD-;#R2&<}W)0@UJUtc9N4aW9A!lEtmCI{vgxI&~@S_WE{O4WG#hcF#%s#QHYIpyU%&m2b6n;vQjF4z; zNi#)x-jxk<2cM>+2+H{@7)#?=ZphQov8UO6p`$dik_UDS%qne zWatq3mJb9MKY4Xs$(APu=H9!eILU~u_0BA?Y*=xq07yW$zkZx(U{m?!a4oCib2Sqtc%3$O z?f%!d#-a~>kpmL(D)|B{nZ@#pY^fj@_#<-X@M)!B9PUePTGP=$&vk9(xg_8#bfT0} zuM%*nFkZoDYt_9qt=G&;mt4gc#p4oBZDz?M!%r}}=78~%P5y(GiB{0Sl-V6)3=AC8 zI2>Tm^oz#jheYj^$)9zmyz`DilZAerGOF3*+9;U{8KYer|tTIkC{SL8w@yvLF| z4T0zrQ=y)Xr5WfC7)qwWy#u|EkH1PQKyRBOSVr}k{UMZ5`b6BIKtxj|tzd$Z)0}SY z=qnhXj>c$Mte!vyhF_bMWyY{Cf>V44#HsE#Y0Y$4UWSQdS~3Coaq4kJg?RmP1ks#k z>Sn3r2Q2+WnqoyxG5e#khS9j@&mW|qCmP7 zGZ*(1M8=PWP1`nvMM}umSvnM-CsKqww2>W!%iv+PK|fC~Zun^mo%Ms&>J*tlk?mus zYdg-@^5=0AxC!$Ub%F=~_lpS3)ibuXdPvS539qJY4TBAFkjr0~z~?6{QX7z{8C(!5rhM!AdZc`Rrj~okf4hD$yZEKx(Cq8Q#hL7X1_ zd`ZmbPod8l8|7e7M;m{mj!tj1zg~5fQyOyRZ&2uIEPE{8LHm2175EjjO_uePG)y7J z-zX!R=SS!m>AkF9jBQe27OJLpho;(1?WUaMcuZxr_>y_kxxq_+FJ9B;k5AYo{uNQj+;W%7nvG@_fzf#;&P%y?*=+8LuFkj1^oI}F-$Yo1- zQ)QFPMC7uCxoNUXGz%F%HC^3pT$UM$5%JeUyqmAc|KCK&w9?4j`0_qa)0K%E%RZ-* z&TpeOCMFWqvYCgg@A)y%Yg)19;=d!9xMtiuP|5|r zRFH`nd((jHkp4TGNRFIS0qQPfBUO@6x?&3|b$Z8_IuBCa(l)DV<-a`!O(Emb>J}nYs+MH`+I{ z<*7A;53S0WRpaoA3_fFBTkg_Btwn=gOr=c8v(&V;)tK|#%J7pqt1N*e*or)d+GCW+ zEPlc@J0(FB$gkPh;$f3obFwxOPf!NuRF-U=pX;uk7pR!4m6c^G(!4H_^P0|@jk8kK zDpYHwZpD8fWUNG1UZk$cjx5tkM3Wj{^03?qML9(%=%=f%D|QYntXSY3LY+Rvt2%3S znOvPh;Rw}cL3eG`=a$xcyAChPMAcYteQ~CW$4kS)e#gBhP9Dk6!JZhd>bzs1P-^z5 zJ4IrZPGu`<^VJ#B^n&u8FRWYo+%*j%eTpX2&FJI?D7c?szABq~9m@|^j-NgcO|g*l z&dA8fjc6Q>9_B$^v@Se6(oOeEd{KHwjnsP5S)Vthk%m$C%!rY z?FMWa4K0&cb@b(zkJ7Ut2mu@;--`6r!qFyXreMQQK&5hJ8T6S>rP7(HH)Od~1a^rc zFyPW>pwBYkXXtkpQ@;dn!0{xkG!{!Tu3XB;Br(aDe|#tHaP069+(VI!tM(`PxJ-<= zAqJiS!T+Tq(rJs3n$#za)lKsop~(_vvL1aro%QH=NZ#3Fz_V$2|7l!;Ls%vYpVrm05H{ksWJ<^zq6s0cq!Yp^ z#%1h@a7Xn0vRMUKdD%pPd}sRb|4tMR#P$C#90H@(PXh;z4v-YEbr2%z2}3R$j>z;x z`$gC~4qMIi z9iYrB8Ff3OwhcViJ@8{4#fHOPfl!@YT$?&~Q*u&8%iOe?JKH@&Elt+KG|f*<4Z%5f z0&~~sd}i6AS^mmYdHVc=bC8Fc*P}|S@}gG@Is>U;(U{MJ@X@Z1@jw}$=Tm^W$)&Ze z=`nr}B7pBq4p?O4eIJAx@uM*Ip)s8?V@_;`4onBb)p1>8q=!0(p4W4U4j+ z(j{7PVtW_1dkj2=*5QdP2wQ@(KM+%8M^++Xb}7-J2rF3i%&v-xUC*o4%RWKNX4XBaac?L@z6jB}DT+ zOJr5m1DK%|F^jG+#d3ks(9JYCgLB#STlWbCb2Db_*l)mk@=FmG6g5|=*FSzDyW6_Xc=p8FI;^ndg|!Gdt;QqOh&b<;o?nk}%&Hcv1RMrG z$OHDxkOy3rlvRpW^2VqJ(>4)}TV#yw8cJESYSo%`t5y=6q_k+u(6Uftu2-SuSJEv* zOPpIB`X6P@Y_ieKio&JWV=a^51}4Lu2sQWCz9`Vv^`4=j z@gPqZ)Rpdhi3XV;q^ddE$htIjhR&6yS(g@#mkpg6Ip&XBmmbQ!r7yZD-M!t9lAv+x z(%1*TJPh71Y>2K)7iDCP4c( zbiGwa;tjJGB|jw=BqX^D9O0`8Ol@MuM7@I^sDH6N&+MsNo@wTeHVtF{Nsx=gj$o;$ zvdLB6J_kY#EIc|t&^xC-lJ^BGGg9&$5?6UgS4X+aH~0Fk{?l1_mXIe^O7naMw^6Nk z{YY{dGKzO(vU!|{p3pqJ@&8Cq{tsC@oqoAmr`NClBW_Qlk=x>@)yV%h0YD!$ z@-4BAe1Trqifl!P+$W~qKtZ5J*oeobQ<*#r+r9e4La!~mB-`ezYOV6+FFDYV+TK*9 z%SwP8a{3C~`L)4@u7;p9zcSyc@YRKO>=~-K`X%y(lD;+mtQmQ!PPf+JO---vubsKA z)jg(T)j6KLG*5neY37Uqe=yI9a_qZq9rog%^gp`2GE$4eUW2&9{7N#eoFN;n#=OiF zSK=_QKBdU5pzAF}DP3^bs)(1T)n{IMIZ~8h{Ht-~TkOwd4qE>t$JAw-;s|(;Zs9tf z&eUrrh+7!pyc#4;DrwMps{#7*`E=jXRU^#)y;2$nGsNL95C=$~#2=V|fovMJ&fY!_ z6EvxvsC?V8b2rA|bK?Wa?aKU&eIy6G3OHwiSFORX7py7-}y}+0Zhn z&^3nUlwB?u%S4?dKBVVwGbYbUCF2$}u0X^1IX1zGozuZN-b4DxB%3l%ENLy2YVHk? zYQ+}p_p)C*0iTjo4NxFb$E}AjvLJRrJupLA{0c&dT|<<4TFzs?zZ~eO?nBw@bqjdL6q>g&u%{D>`}UlGyCJRGmraieujx@uf- z1p=z4Ap1q6@1^;qH&WiDOUjp{X}nw*CNMU@is(J3o!0xMzgF*mGxg&wg1v7-dFJ6r z*{Pn&@Y)r6g(zOitB%xor!^7q5Tk`JNPe@W$bTi5#+whL8ypVQ=YnbN=ht$C!x@6a z{$}Z8FZ^~{L%dhOxbQWBMXHTsU8<29S}-KSzdoGC6XhRS&u#O5mb z53o(jr78>iI8VXlB^{1nkb*VpvUR##UHD82gN?hzEuH?)kycy`85bJW`i4z8blY`Yqpj;ow2(vvpwI?l%(V)CZ(hX49=1?wXylSB_6ji#i)}>lyO8c#*=A; zdZk(m`urYqVQV_Il`pqQlcfoASH8ngnqkG1K{sE_mn9$!HD89!f#VtRYr!w%8OYDH%kYyi>PenlVKCHGXtL9cn9yN_j!Vp= zX{^An#VXhbSVFX)Omf*;PGmpX_ad`YtWV-|B^t5HD$`c@?4^FKA*U(Lla+)MQsKZu zgiDafH)c3({$!q1zFMs}m(I`6>8o^_HAxa4_6u5vg}expr|Dg6G4n-vY{hM?o&(;F zG6|&6r^?LCRD0Ws?Z)Eyg$3O;x!LNBc~ve;$=uvvYk^6SMEr%XOAZTO*)+k{@j@C&(|wBGOI2t^?rfWKp3+c+zJWLTiIOcHI?)fNDv_J|6Wp$RKf-#zq#P-~UR%xa-fZI;QbS|PcI z;)Cz*mzgy}p$2|rL0?&DT^jiU`y3E(JbK+rGHLZ`;^-G8?&^@#C}9JxL@ZAvpBHLk zVQCO7m8~?OBgjrJkK`+*;2%=}X817|@=$ZwT;hHK?`*P!Z)C=1eGkXR84i8_ z5c@!wjo8P0hu1^fF-7FS)ZgjTV$!2kjF`oe&ol)-Pp(KkCv8smLwQ>BDXmdr5S&_~ ziz63nY+jqkzGyBIQHfcPei=*x9<>(}CDZfyN+fd#3nyM5`4Zw3wcQ%{*_Go>c1~}F z-Cog~lha#iw^#P&q@|{&`BGEK)0Xo2`31e@R%>~0LH_)53)NFnSy^0MSy{sPhYIWh zRte+7RK9pZJzvI@oqve>CW%_0w~K|z^_dZ8jQrB6B|x*U5`NkAWSugF2<)W9d zvwQ)B>w<7y5H6pt=STVwMqOfHQfVD*7Fi??Zz2rX8Y|R!Z8;MHpf~j9C`qo4l<*Ua z8mu%#upnIhsm2iXhI*w)8<8it6T*~_%9F#UYwGN1N&O$ne7i)$O(f*;dTz3XcWQx3 zLXyocUqakYIiXimuVW&yg7ItDf>)tz0*qfn47+^oi}7>E5~YdISS0~dAU9yrX3h+$ zLw>iw&XI})@+5tdA;}cX4VqMehG15Ymb6Ra6XNwEsYq%Jy6nYi>IAWZU(DrkVPr@Y zON3HOZkj32qjBgEPRS6bJK0&Zw!}_I@&Qa2Wzg?3!JkItPJNxTuF1|9HyhZ=?OV18 z1cC%^Ts(#-+}iq54&#~RVSD`r!H_rK#ynzJUITBk@4v{5Hc+6%OQzLbJKMKyPZ5oU6Kkes?-n{I6hv&j31fP z{vm79J`wC+6Sss+-1q@l zen`^~9R1YK|L~Z=rI-PkpD;t=5piwlnloT4_8gX0{sRpb(I z^wd{C5+`3xCPM8X2NiLM-(q47mQ22f&X|Mpq>o)R3;~UVTLal-s0FV(D@`s`t-&Ih52)IRE#G#$Px~#1GPSXb)H|X&`T4J zYS6oyoOJd*Vzoi&>nL~XEqbxWC`_AE?t(9w*q1}>#{N$4tF`@#9Rm%M+W&8oTl`uL zv-d`$^;_gu?CNLWrm|VscbtS@2{#LkuJV}WaTA$74({fMg$_I(P?z)9pI!BD)QOqZ$`73RPM#sc|vhM147ATKfb z(8M#2L(<3!A5^(B=G=x9_l!J?C2xj1r6Je6+mmAVdhID5(w$lp)aimXsqU(PRvV~t zTm62kGc66tz_zwV6g^X06jvm1$g?%8Z}Ne!x}k(`bCbzfJxDpAlD2!*^W)KFPqx{cr07WmbE6P_GY`+pT2*{W6!+>hV~eE-Z<9 zTWZog_9E?B*}LsUUX{vQWVaQjs#K|kHjBq&v8SejyFL)dz05dVjCC_{9lnzG=dxIj zZos4PFzM?;tEP7|-(d&Tu-K#>JQFXHX{4i$p8my?@R@T0cR`xns3D7&yuu^eqJO{4*o7Z(gZ8SJQG{? z$h6T`#7tD;&Sb{;nVpE)IH4)Wu)$}OwLwQxk|U^1hGVhs)CJJHfG#sXEU z8D@7)_EKl!SUHv+6DX*wu=tS^C{~c;V#QxIa5|@v^X>XszIGTY^!_TpMhKkn88dMJ zOCcYi`$bI>Klu5hrMD6X016wUXYP{l4Sld1krv)epSJt)B?o;_B3=6>yXo`3;VX-Q zN#-~}PPe6pfC1QWF7-4&nGgSmy{Z4@Q9TBO+DCY*XcopaUihm{>txOvTf>~|YKXK)+9F4r0YACs z3sVZ0dPt<_D~!~sIFIoStm2|cg%7wEWDc|rU(1|`j_kY!^6?OT?kR(a}J{yhv$qO9Xj3VY*>BM zV|^pH44t0Sd3xyR2uQ}t*4)wFe%snI3@clETYLK*YsxSp2kU#}UprgxJ+Nk`2fX+q zSn%+dyLSHTkv{BM#FG{li|vXzW0nKChYtOt>jelS_#WaYN)P(kuDVlLrnE{(0-WH@9-AXe)$?rhoKlGKdKP>NCMO6eJ~fg4Y@Ts&suvdinah z+S~71SDxOnzBK%m)B6w4Ja5}g{n<-j1o+K21N?<$+5I=QdFOimyw~CZ-o%;P@9SEA zd`U34CLYP^b};PM9smmZt%>FX(7T4gI(d!p}-?jayb z_oP(!Wma_tr01pX%0PdQeb)Z@aaX;5O;vv1_Tv6Ktdg>>wZ*M>uCM5(nvwo@LZ0T4 zPp|}04Dl$292?RCrc=-odpe9bTFzmEdcsoBnvp%X)atBRR?IDE%TVT*XZAJ(6Tqj1 zePx!0ea|eu>g<}#nMZ!VdG4-8(>$zi?a756Z}VVDX>SIpd0d%OTy4uOPha`imWueo z-d#0=&+IJke&nYkuK@Ski!xi6q_53k01jLFw90h5j zQ8{b*_L3o?-IrZ9!(&ZQdo4YOmsQAYMFBfM&aNb|mEV5zzkO5{c)acGeb+C^YnK?5 z{Jy8DpYJTc{qDP}QuI(}`6Cwz9r*~1y(MF32HO~qFm;pN_=8;(m^ai>WOkIar+He7 z?b@6UaFW#OL}jx&?M0zr>xwliT7$(~o*Z2L+rWdUwbEE^GJv9>*zLRey2C z^43zFB)esxCU5BsFHx+Q3Z+7uR+k>kt(vp$NY}!Lx0Y9Id1T>T|0q%h3+sKEU8OcQ zR}hbKV4TjHd-&EOV{{v$K1X?ck_|erCqg-EVC%E=+*^m z9>~t%Cy9jSKvkfvW8vK6$CvjgJ*6o*wIL@uRnA*r6{1b;&1;O3^z8iP%muZnWtm-a zo?Iy}N)MIXRhFj@*yYS=a!8hi)H8S$^l=&RjT{AglJ+u4$JmV4L3T&nEjl$k6@%U% z&&4^)G`qEr1@)(mQFNnGqvvVf`s%{GTvY&4rC>WX>WT9*CS>#z2S1quy+Exo1- zb~hr9 zK5WMSn`vanJ}fR^MQv{uw7rDL$=;0Zg(9c?a{y9onG}mXp&DA8y`(!gr>odb0Jfue zPF8kjiGvLi2bgB}fq`dtS61$R7Q1fq*?~}K;Oyr6);_o_J$>1OYq4#ePgDOndye|| zGhJQJ0NJ^-K>Bni%7swRO+5J+#G@Exo5;&U8lg}i^O2ipFn~fpBtvy#S{ozBR;Js= zlnWEx^90Y9QJ#{MkNsqI)?--V_SbhUylqjs!B;V(+TUJe?VgKD%=mSm9cgg4Y^;6a zf|t0dvV_R$EH-DqIyc#?&eT0fefesC-oU-R4+jGC^nPvevc`v3@66uy(JfgSm}|y{ z#+<%t=f{6!bZKDZ2P}ucP_83E<-_dJI1m^Z3g*u-1WQdtJ;g=>3#S&9RI6-izPoW* zA^mL9$oE7oq&t<4dy(i7UBIWaB}kiV>>xknzKL3))~QNqsVkK4O5oybe*EikM%{;C z|155j(POCP8G;Tc{8k2*iL$dEn5Qy`Ibu&^0q9YsNM$Ysg^4xzt>I*wBECanNa71! zRawJHeh;&+;tcULq{SYK51nDd+(^q5Vq@AQ;0xkunIqHetSj{Kg8N!?I?V~3jp>;~ ztt|~JjY9<)55f?o;3uWk_?tWQ$*vCDw*epVW%%wnD_R?{9btD#0nLXvn1`_=y&miY zz~;pCL@;iZt(~*(y1Jv0t_Z#&KBY8Z7m^O>Pq$NFQ$PH&i0MX1ndz)Lb?#iV4V7A0 z#n8@u(9R?0l|W0TTU}|d6Ui*5wE4(}NV?{1z)d2xNjxX3tHiQ>{rsc(9oZTfe(Q4@ z{qj`z3-MxM0$1a;)E!(_B=a`rRMu+JimaP5+}QhMf!vtHGv?0p&un}V&D2v%GJINj zdTzO+W_b_U!F)cC|NX&4Z08wS@th-_?%rFM#-`Li`I+etKnu8P$uS z60_uYWNGxJ5p1EaVz4zMY~|^#g^ex68&5BOTckFMdkZ@Al6S1@#csYLswwm4%urkQ z_IKVe&)^0`0z)pHjD$?IejA7< zY}PFtzFcdTyOW%umOa!b7of^+Ilf#e{cw>v;EPX7p9Wl!bK0RD=Ob} zek0m^5%N-P%sFwy$8e6xV`dm^nUGmV!E6>rQaTX366VMDpFS4ewvnIgHDGG4R4e`@ zzoLBSGXtxh*rc@FP^wBu&}L2_{?gqQpOA2Kd|E2y*1^#URbyBV9&nh!gwrRlu*~6+PbCTB!2$U zsx?h106D#UAxBD_8H0*P`4r+ML3g36Q#Vk_FLXxGjzj;dy5_vXk>}U z4-HkXYj*R+BAhE#Mm6iEx3(81P|tv3Zo`hpmSF<1MlYc1_TM5SzPcoebI;t~RkxzG zE+wjGfK>tWqJKl(E=PH)c+&h*96~5@7^yOw-2F2DM71aTGb^$dAMMQQs?C-wvTNsL zb{<)rRi1T*r<0S3@iv>zoLOpcW?4mW`ew~?8cH+GI-4~ z-m~aFh9dj`*b4E%S>M3yWCOEqJR$>I!D@PqOb+L#sUVbxS#8L5fp%-_=2`{8)wm@* ztE+w_w#uq{_galPayQC@(YsMBqZ9GbyHO(7m0?G#d-GJPy!qAt`Omd) zY{@}K`%-cEN8yYQ3|V#Vw1$w5YQ{F_Exx{~@5I^y^2B@8hG^Z3(2lD+YQr~B-{Duq z)V%1wVgGaNehQJF`77+9_n1Eeg~-S8sr%SQx`qZ*DT@dNZNPzEn@wM3LjUsT;VKX^ zhzLKmI?)j)n_B2>EZ!Q{kjf}(X# zf_O0hUzgCd143iP&4jQr$LfXjc4{=yVXB6CXpgHcdTBv6U|MD(msdf=V5S&1^RetE zCH0BA$bU3^)K{#cK2bJjJq|XQngS{LT5A7Cj#3%0s|y@k!do5r8eo%^IzOcLYxCT} zCX?R@-c2!wcVbtWQ>ZkjAM4Gn5Q}nCu~fU63Z`hV&hXuu6!50m9{wOTS0t{;g?KAQ zz9TZpbEu9udW+>)`D9}A1eCNbx-P+_8FkJ7yms|-JIm*E`kJy0mHXe^UUU7(c6i+E02qn|kyXy;M4`9*UA;C_FeHN2O-8bC?z-CvpiEs*#fMQja|RalBGzmb?l0 z=&b^?!?z|WeYeFv|BC#KF7xo+0-ZuYo)})^UzwlLZN@v%`zS1QznFehmJArfB!Q7j zzPI}2)Z2;bWSjCXbobBIjvN)pl?JW^V(VyAAw9rWUc$m10l;R`8+T9)8y9 zHfbJ4b%Hm$8r0w!Xss(W+Qs=VInfB*a1 zH@0S%?}4Vvo(BGu);t|j;Rl%91M)X+E{&IITD(U8vFmA1lG_{WNjTBF^8kNJ492e0 zV_=T0FQ9zFHD#TEkd0q&06pBw!P~mKj}2CGaemdn(K&OD4p#BOOU&xR_$3EyL(j1# znVCzD_57~$rUk*^f}1+AL1t}X!h%CYzkCyF`#$PI_!{av;`%W^H}W0S3k{=(@yr%< zX1b9NMz20$`rt`T_{rq5#yNqCqB@xHI>njcXNOHrK2Rzwe3jz|ZVGgRmrRAtUI`RP zTvCd85dYDr3V)r_;%=XbiRsHwz{mxN*LLy|7FzIUtR796IpeRb!T(~ualOf{ObE4G zsksv_uOWWFVksNu5+@g4x*>XhO=ji-7bAmQ7K@!o{wLU-g!m}mJQdK(c4 zhD5|k>cZ-epSfje4iIGR`qN$X&5*@fO+ujmo&oS@%GA6(J;8?E!{`v_)5-Traz6d( zcMvuk{=_kt2r-C5=rrDO_c8q~6KF>N;_icV|MYG2X~3UAdz60q3=#5$E93wHg9tx0 zRSrNc#EwtxHQxIJGFIk3MD{gsd?Vn{dLttK9Q7NK+(SLR-&rx8DIc&n=vHmZI)_j0(3d7Ru!cLveLm zsOiRm+QjfY>{fo&itA^#tf=BB`1dAW}>fmkR zN4vWp4c~U)tB02es9%sYgbVEj#w9p}vh(XL0ZM1@K!0)^m4RIKYx_DEP+hLcCz)b5cP?IyKVQrli#XO9K z+rcSARxQ+;jO5`@u$Fj*Ety*C^n>AUhpb}m+LAfPR^&rjL2V>ogYXTk(azw}rK!|N zG^4LX#Lq@GvZW;&)nI79NNp$FR43jLRm)Lb4R0sj|L7xX3!|gzkrDDlq~|ja&FoMj zlnU6KC;;rlz?%>5>GDzE*_Xb2%jme38VwhD5GoJ6+_XGB-V$DehNWfchPdB!g;*S* z2Z#Ug?NeIxJzx&tf%~ahQ`>dYt8cvV>hB;dRI6_#AA>&2GycRC2_NS~RtK20Gg7G! zS?JpmW^diRar5S#n|{~1YnGc(R(34T?Ynm%w{q9BtCl}=bxqdJKimeE@(8`-_`SE^ zcJHmX-18uzVCOD4Fw0ixQB~}GYQ^BwJIX5V2KY0#0sdQ8C2F=hGBJox;mAcoPy6DW zNo!R2w2M;)w7iRDq_-AY+|~1guDTqPCZ|)Lla}4Raofi3?227auUd0%WB#%0QtGk{ z-Z^__fp;9HQ`YL0HD&z`IVx#(Wx*yJ=6QJZ%Bb-A*QjX4&O`*|y8S&_?;@Y|nfwj>0)ZONs zlq8`w-@}=E?d%kht18pqoMR|ldZ3P)eSb}nCe19RzQUfQF3M~Hy~1sh-DNH62pGzX zfByFRUMRh1c?A;z48lm=fib2F33fTvLfL)a5|_3&9Da%U{_H$T&JGv>U(0R30s zW8!CO2Ku`prgwz8kN5yS6q%dB9DrjPKQr^?;bNGM;@05=o!z6xi)_iagkeH{OlvC2 z4W+=$^@&HYL)+fHd!36zWgG2qV)nHv1&fp9tb7hg&kvua@qzPPHrg{8otNP;^D><2 zOQq*!c%)iCIxmwjH_FjzKD+6`q7vy5Nxrl3n;DJ*$q{Ku(F5Nq3w)OJq;Fp~W(rSB z{LYeZ@|_{cXGrGgStjHe0B_yY1klJ6p(0vx7}09rdX`8Jwir zlJ&r*Gf_M2X*^+eq&LqzaskgJ#0Y1}Sld5mtkOzHq{y7iO1qlaDOq0DL+iS3>J5l& z1)k;wrK@hNOX=;KXD^4-8)v8{b53{9^1;Em3p?5ZRROb5l*Gqx%qVx)_5`*0IexMJ zs*dWxMyJqL=xtYMP1@%Cyt2DWGWYL{W3S<(|Ez-P!=YaSHsONAj_7d85-7%IM>s}{~FCxBd zo*{M=xX+zka?@-_de4E`RO3_-&omcl((MZBPvE2U)`9$r^|QQFAVKYn@QzF-2>Lz% zMrIQ(lODIvVSAk z#pD<0yf+`sGs84Iiw@%#5sx%CN$dsgC(bQ~yz(PnH83L&O~IZqNQf(ubHM1c(AX>< z9lv$-jp8O zQ_G+|w)O~3;dc^$UbV~MOp4bzv-s3s|4J?VFSUj9nkXqA&bUhR>)gUPZX&tIWE=hm zvjXYs^3ItLc~b!AIj9GY%@UzGGrdY+y?hD2{Lnr39Qvecpwa1U9H{#1#<#9-Xt@5Z zjbDtuxS#vzt+zhLW&2w<*4A#EW9x*BaSU@N!hn zY%;3%QIz52lKf@$5NLw`V>ZJx2;4G?Gcd1g=j1X|G#`#i+@m!r(n6G>*shPI=G zI8XMB zPj4x#+RP-zV*S@s3{gj6j!BiXUsU*@++q%tnPqqM5w+Vd+nzj}2! z3Y$%Go>(E~?cILg;C7i(CgjuW_>sFa-7)K#Y4s=DFMO*`q@l{2R2&!lsQvN8J1&oM3H;S}W?b6RQfN@!LM z53gD^JVYH6RIj4dT*T3uCW`o`Es1%t~${7d6L1IAd5RKNU-|McLQ9J z<|vz+qw{tjS%3wBHz6skEv*Bu!XbDIU#63cC`<}I7;q#D<0IuW-RTQv23TP19qLg+ zK)y=rDvZY{l3C7}apqNm3O{zgIlC$Hd~%6jjm}q5l#J7-zX#dWGk98h$ya}w|HiAo zZLe%TcmI>~EBXrz>8Yd3iL^)m=YJlh`4^5lqLz&Rg}DpXhDJ234|@gialZGZmj+|= zeEH?ebmr`<4aAbifPnhvV~mYL1+f`>C+gQmyMLrAC#_X7QC4}d&z@=!+^E$g&stSc zv1(SbMth^ckV3M>_8f1LHZUXIXiT3G&?b3v?6mLRO~fK>7g_#`F!!pBQuZdL!d}=B ziL@8mmCB85se$-}r*at`N_(bTsdQ)Bl@6mz#iQ{gN3eG|(*FZI*(-(CtYnWiP!mi@ z2-XC&p5!d65Vi68v2Ve7NIQ>-W((C#E0WOoG#?7EM=HEiD0QmbX(nSDvguDVn$p}V z@{ZAG+s=1)pKrsme)`0i=2EL&@J+;}Qn?~bzQJ$t3i2Y$i7WtR<70ym0jtvy3!Fw< zmri%vD7DmgF3M}#+n44ks4WSQsL)LmA_?OP1WLttWdyo<88ju%t(HHnl0U})EG5}%P(JnCBm~B;`uA`X}EsPVO`;q zjE_q?gg08@L>ObFDC5%y8;?%L1L6fNT`4tNW{1)mds_>*@rU&p>c{@PiIi}yEj1yz zBWzJ8@e;HIFiyh7gm5E<1wv=dvg#R&Ya*d+@6pl|HQ1bVDo$RMn3S2G@7JX`lw5_J znO|p7e+KJ-5$W+N+VKId6{bZ%;;fMJxqOo;fny5V6$(e#STuZ$Su0iHr@%tCnzpS= zMsg1AXb3SSx*YdgbS;(Da)PgLh@>{DSc9LcJ$J|9Y+t;CuW9I8mZ4AL!8&H*`@k|b z2SUwb$%yyqJyHl4dj!I@fGoPcEKo(4!*8*t;J4Q3x9~Th3;l++sd)&@0m<~>^cALO%hcIOL zTq_ncu_~58IA28JC{XN`T&R2@m(Fl50AGwj2z<#d1YwtiZ>q-Or*Pl?IMlz=r1{)Mf=o{9Mc4rA=m zpRi|MrQw{1%gpz&^Raj5@x+mLu=D5XcPlX#`Rv5Im1Ol#_s8CqQ6J##V{6bmQeh6^ z?IT}oJ9(19Z6E6t)Sn5&E7OJCzTy?fTU$@AC@x-cvbFX2iejw3_4vx7qLs&6TaK+L zDq3+2jVo{%yoQUe_WN1-K#|i`955IH#V%)2K#$FE76Sge1^fzXDc4T4(n8B-5pH06D{tz6Y zUWQ+jWAJx$Kc&NZlHhNO80$Rwlx;xTgfhA;WaKMS`9h3VGGT6M1z(m_2;v0_SGvuX z?oz=ijN`l0itN7j zuDOw_W_0?uFr{T}RZ3T9r!TvDZ*{h>qq8feYHe%EqIj8r{j)eHMGZhFu#4)1^d48# z){^-YX^>dbRFrrnGDrb1p$D=;eQFh&FHJJ@<{<^vI=hpdW zG$v=HbnojLIG>KaotT~C)ylJNp6pbQR+RxhF~~J?nc1T;`IB7Ua7lYs{brYaPVv;} z&P7?S46i*gP%^uq?pnKZuqtwE&;a!5qs+gz}EZg0;nD)r9#chwYqjtW(h{7E~mV zz0${Z<&ONOl;#^Vv9fO+K5cK;7dvO1T379{k)py^aY1!7p?A}VW`|&TDiS9Gu*l? z$ISC-eO84&CEsR9OUtxSL%F-lRJtu+&xJI#jfvRhWFO@B*^nkjY)wvEmar#GFQ>Q$ zhLw{Jq0xQ?G2sn8-U@Esu^Xh%l(CjTWo1WWR*mLf)?Wcb{GgG3sD?|cyOVO<1w?XQY zgD>58(?Dj|ePbsFAG@wLue2=3Q$0T?efh$!Qny;k>}f&$ovnrao5(7mTO;a^J+TkN znQDEG8pBRgN(UGs&?$U`DMt%KbRtg>TDhnp?e3+$w+`o&TzjT_@yT#LTOpPhlJWvs z9r+e(c4HtVH_1BE5SqRHwqN)4J$`!o>=3*^{diyBuWy6*+dFRkpY@HmY+qcHlvJ~L z`z?))N471jNyJ!^rqasNwP$RF zDRjgOELr}+!LI9Cl9F0?&F+5}xUQrE(RL-tG@jU-O1P#o!X+Q|d+?0EVNq`8!WpU5 zhxo?JZ(Me%tPFH4erpu5%Bc#hp56Il4j31w1PSo2?^b38Y zKA7HT#)}UKj?k1Gj5~OvN+#SS=941sR-r;pI+aj6)T(6)smfgt@>Hgq1WJRniYE}s zL}razEmgRS(`|)8qg|hh$nBxtfaJP6qvV?HQfri4l$Qh-VL#DvNS#-U;xSd47Kb|4 zmzS^a2#1+#=$zJ<>#*ngwD4+oz$?*Hy0$$OYF}Ggd@cIy+CqDtFCoE~XLscLbvi$7 z*Sv`JGNC0_z&az0zB0KE5cPKBIHNHYoe?Hfo+_fEl@~Tg1$Lq(n3Gw8Iq4;s{N}{& zaIh=!@HIDU^$D88YY!%MheKV7hoaBeDF^epBf4^3Z~P5O{M|GD@S+As}q1iH48Q>+IHT*aP56Xxk9H>?hY3FmfmOpPr3}$ zaty3<8mPB}A7;%- zx|7wePxThPTvk4-EqmzroJDbRJ}i%(ZJLR6_F@(na!U2MmyZ)?4)Bc8r> zm5f<;MWZ=F@ffAniLD%1n2=K7>`tpmRY9h7+*Gz_s3d3Ay-NhZu4|Jnf3>VC&MZ@= z<~5|*OLr|U%36NcB0gr*w}}Uiq-DkH8hceN{IMSCH$}j%OuJ;WoKkmZ0OIv9Myy zLTHH3S?s8%7)k>|qSY8f)Xxw?FFI7%oOP>v+Q2uZkN3r6Hi&=A;U&3+8y{a2k6ZO^ z^4bmI+&G0yXmF;OGD4*Rr(7?_8zmR^Z@XP@sjK4bS3BR1Z`k_a(89-e&m@njoPQA( zrZx$M@p3tLw2Ram)X_6=D20h`C=-!A2U^unQWPDurpS)*4zpwoFbgPi2nDII+TDqR z>BHxi)voU;Pw27cYGqKRH_z(>haubClagpFb6^!Bol8AZV9xRBp1{snQoiUsyS~C* z(iO>-5(cF`LAZU@m)&aD(*^T9TwcG_VU!)^>b==+fJ}KDrND%;rk;#T(WlYUN<}0FpV_yIn z^&5~&{pJVe0w0H8wR-s{TxMmg#UMSoARx2SOFG6zEWr4AVUNEOcm@1X%JqkO1J^su-1zsa zh9w3$kIZ;Elbh#URJGJ$;>JG_ct-|5S(44oa1K?!QoYEL%+AI;sV~5D^Bi{S3vZ-` z>KE(m3Xn=Y?N0=Uyy03Php#|^%R>!-gDH0EDMt6`9Q%$qPF#ES*may~D>&l#tOL(4 zS@PWe#>V~6Em`vXfm#0!HZF)n24)6>GY2A(1&u*0vi;qIb#({d-M-_!gSE8>-`g?& z#t>(d8SlKPRN? zx2Z|}0^mmL>jpR>{T|Mt7+6ozzG-7-{7w3K!x(x_81oZ82p0nzwdmP3X2eg!v5J9B zAED=ZI0wg*GvV{*IOe?{e}R6#oY!~%w(9C__xH_va9hnk?FAiaC>)|Kzb!4Tqri?uZv0?hS=qi1ZruOD z4W*?we6at@wi<#ozXNF!p;!dS>>?O#tbhc6XXMYo$$rd`FRcJapSl13`!P#y(H13J zI{+Lb#mu|`=WP4~*hYSIl1xX{0uw=nVtX1BNB0~ON@{$w%QvzVoJ*|<>(t&nm%rF= z;>W3VY$@mZ_|oBH-OX_L+Y8$x)Q{l-=LZ4H)*YbPT~S`?wq$uU3BD||T8&}qhU@z? zL!Fyyat3BMC%qCcWHB}jX8bLPPvN9f(Wx6^VWny!_>DC*9b0E#e96!)-5od0Pa7Ou zvm$5NnfbH#FR9ZFCuaynN$F*YfteX5Q`xe{%>HUmLTZuQUz{4l9{T~|6z*78K6t?8 zxNURQ-bDq8jq7Ko$`yKhj#q0)tM)}2LJ4PqCQuV`7kJeP$=Nh9^jHCqzZ9@92qt1K z3QtDI=0KAUM4j#wY>$wdgR9NjYcGwyE>J5(m>gUC2apPmDPtyiu%@YY-toam#g>Z;a))~xEhW-y zePBsZPFKEp^Qz=-|BZ{VTYV|iTx_j0d%^yu!Sm~iwVrg-9F16RO?8*e&04ThCQ8Ki zu5pD}(er8ohhsxF+0QG+&oU+q*p$=Zs1qAz&FsjtSo2#WnH~97b8b5(Q1TtEf$AHE zib~f1YQduO*W}mKgNU{``K^21r5&M+_B^w@u-TtByTpk-1l3HLJTUKYU*{cb%Zk@s z7@YIcLU79JV$OKs`206)7dbk=L&+y%b{=#XEd1Yb{Lz21)kcftA|{ZzRHHZOlZe6P z8o%oDCqk`UfPZ1l)LN}K(0Xhw9NVA5v5oSC7se=z@maF|`53E{JxcaVneRr)cT(Y{eGkejY_O>I7aysue zXVm%@4h=2z)n=G+$`~lNyDBrS*33$my*OZ`bnY`N+V;;&OPja9ZN(XP;-SInt#i`S z=4`DVILyfDGAN5agtA9MM@Ngre2FgCV3SPVaEcCPMnMQIT@Y!^Fj}%^rUqwZ7=aHG zo4mZFc>DbPqBVEV>p!zRSLMlfQ=iIn65qn!TfEeoJ;NWKnQpLT&!Cc2UZu^IGUvuQ zttVC$=PkRnJ9ovWCx8;&QJ+0=?A0|XDQjLm z7QHg#1}?3zwd9?QeI7H9AUiuWldSz7!|oJ192P-2IEA*I2_hk)-z$g*B4IO_$D+@0 zOW>UCfcRtJhM(y3Xh@Hne!h{JPvHB0@(g_5FGJ61V_)Mx!8slSH~kSkr^5Fd`uV`y z=o!xZ1c(0p!M~zDONH=e{Zji}F=x!G-}}ta&~NtC)$RGs(9kn`>&KF-d&8lgDzCSy zClv0jPX6zjhtA_o@L}6XCe0hs#tBFW{>UGI9ls>C8rAF?@W}5TdE^niGBtFski!=7 z2Eoe9bPQ<}chCdzpO`!7Q9oHAPnkQ=CJX*HoI6Yk6?iDplwmYPs{NkI3|E{a9M~k9 zweigC-aA$l_-Y3-s7HMriGTIlZ)(s)l;GjCzTSE1!P;S6|FkevGj@U z6*^zGWxmDaFnMYh=B?Q3@L*5O4;9ekt^?9k6peAs$Yn4|E)zxaxY7TSd@{Rg zv`S?m?-=xF$}b2ZEGKZAN2yOorHPheS$-<&# zY4EoVblKVQG6no@0sY&%#(!G?zbmK9?j9S9mgT{+F1qX-)H9f}8u;5by6m3u-xk8} zTIf3N9mlU2epgGEogbs3WesC%u?n!6g%eMYe>azvk40Ed!?I^4%EtbPMSu~OJv(0J zqYeT)wg{HJK3=aImKo`?H^xR$87<#_fNk~Vf2R*)1K#TXtgLxeNl8`nvaAIRnrWE{Kl>Cx*MTL<|2SrBK>B$<{AqH=;g zO`?hDSnCNonmvu zq_A3GvuN9OtRJ>DiFQ5cePEms zUTDW7D!jl-oOlU5AQffZM18DEAcUayZlJwWoo1juYmS$nI;9X-fj6lTqx=7WRX})2 z(`1)py6B4Oxp1gUWj0wxOO`RQY9OzCxjQJ+h!c!%qs*q01bymM)j&Sjm>jtc{0~l; zGwS_WJ!P&;cRAE@#R82>my#;r>cO@OtDi;3ll%eeg!S{0mBUou!K>)E%#I(J;mHc5 zq@;yw6=97w&u*>AaymFF~$S2WDi1I!hB> zW!;&Xiz4qyRLF)EBG3fuj_I=a6kQf;;*k`=mnJB70+v7{qFxqiu)lOkbb`?@;^dMz z@Gq59q86=*`J4OzWx$tozNCz4l*GS<@=NE`7OavOTI06UDz4$cmmEa_)4hM34Pvn6b$+^O-p*}47k?Hn30;^ zqEXdHk}4xcW27=EQqSnDrSQLch-Vy~y;eRRj9hkA+0JaYe%<8_hTZ;@LWxzZ@M-Lo z*$#X0oUH8Gg;t@)q24O+>rY_Z?o_`w5TG8D+vGg1E>s)v%qmQ@{f z8p(1TS!L38k?@=D=r=o~-z3oA+>N6enYr;!!b2ROeKw-Ik;qb;@KD#jNUZ~#UIbgP zBB~eM@(?&e^)bKMi51~v*yWgg-A;VP$aUCd#y@8v>jgqb^doq79&qwNga=e`cpj$i zq3+rYW>JrB0wthm3-uV7`4X5x-MtYsfs#$sqo8OL^%!*y@k=}Fb|Q&5Lg$T2V(I|X zPMIXrp4;))Mp8iSbhGE_&k#%S;#m9)9O!Rm73C9|N!UlO(L;{?E0()yFSWnqkTv+irD4j{o1>Y~au;?}HUuPfw z{PTy;KJ?K?55c-_0dw%b<9}iq>G;HG7h1&_57C;SlM%VHpDD+c#w@>;tCs~b^G%`o zeY2BHS*cczO%}{4vW5ocb|w9X_xJ{(Ld83#v8(w;hf$=^@DA!+T7l7Sq;C1SHw+)# z%z6XAKn&6Ls>s%rMA0Teh?WbINlFt0h5bz?6v|J<+vInGbv@vkJLR@`MwUDc zVSYFT=5*?wMljJol?lv7kf{?UC4%{V548yaIwcnhWycY0*iKu38@~+497)?QA@8`$ zZ;ZC#D}fs%ARg)%`<$&N?`H{UZ=0wt1Jwl(-BqVKXTp$0DOH(?S3*5|TATLuXW+b% z?{k))8QAs5SzCQ;Zh3m;z0}`-JCNGG<@D1F?+5V@bdZ=sYWYC9@lnG&*3s$v;LanO`B5hT<2?@DXZIOai zZJ|)xq!Msm>da0`%yvpONttF#CQ9&-X)(hqEKf{=7XOy{~L~jXL-3maN6cyO+Os)6C+0xl`J@z11sM%f)IW4_MS)_~-0yT0@T= zJLA!a7C4jckBR#Mo{BG?x1-KB!y1oqr3Ot#ZBWPF7+=)Cy*^rIWXg!Q=G{EUCzAHZ z%LJqw*)6T-S zW97}-km^mnSH|Uk6vvY#>)uj@wM~pJkxH;>NgPhxR3Z;N8~M4NZZWdf7_UWOkkz>ftO|d(QOj4osSBv`_my27$vn-Q!tM+s8UglYln)hl@nk+n zwJ-yK7bmtU5pOnAr=z^7aLVu-r!fBL#n`YY*jqNTK;}{+hHZp+JxI*PW{@8u-+g)? zK}n~_wT5UP``CQ*pg1{_W9siI2`X0vZ8|d)?Q$Mp$RSS)6hdxIR;X4r>mbLbQ0TaE zTmdq5X8nr%C)UmhF>qu4u2%s5m1%kYyoD%bnPf%K<21>P8U>FZ&tX$)V^vl{qFKca zF6JaiWNI#-E8s)<86ox&Y3v**KbcI5Q4D<)M!gc{cZ2fn3Oe@B{34B8_tv>b~QdWv^br6?y!o)G#%v z-%h3qCP5WOeTwq?K^pjo1{vynH0K*pO7AJP4eKisfBagmQ%HCnSmQK;$Q~On@neoq zE?7GgOp;{s33F0|Z`sk#_Aai6mg0=F* zNxX@h0r_1&CClfuTJR?7oZP0{{V1KA?tz|d^_Ju9-QDfSt@T^E8Pq2d9uNz~Tx|4r zi4}7*vT|~=GUiq!GPq;ku^+fP?)XH8)2X~e|r?ABRj-%mq5DVF^d#f*EKO=4ff zaG%J4%9~!zdvr$Br?=>B66!AS*fiuZo;aTRnlA*#X~?r!G5k3Mlm^N4uIa=m@PWw# zWIRH2v|i9KF6`kj@S2A5gVm{;l8|BrI0Xsp87G%*;MkOMJuRd2)kcLq)ex#v&7#vh z#z<%S3DR2lvv|bjh%4}@ojf-rPnt8pF-U&Tcw=ye+4Nk2Mr6LmP??pGWKwfNO4Jmw zW{I{38mG*e(X@t^{cKjzY5l84!}H+PhwjuK2S1@PapkyWeJOkhpuzy81;w^K z!cLnS$8LO`9!)YvC!v`dMv{p7xgmQ`+=UY4O-h)Dzslj5^1BPd>C=+y-3j97gd_3d z_=4hhN;adMc@w$w$ZlnpDQjVKp|tt671ILW4$T#$*7{eq47~eQEY~-V37r#-f*@}qB@%5(=1|*)~xm-rerM{`2PQQTnZxEJ&f461b4t7<_t3nV z8=Jk~H#MOsCWS>b9>fV)eZlhP2sx_qHssZ&_wSvB5=C^*OHalAdXAgx8b^VSn~V_~ z$XDT=7|pIKw0jrL5Kq?)kavm2H_d4(#Dr97Cb*Y>z|JLhM~1g9?Jw*1for$k>=()N zj?8V@*O!*N?DX7OEB#-7`Tg9(_?Fs;GEXYcSZls<>!XOAy;R`8B#0 zuSRcI7Zyn$La)Hc~Ue>v?@~(3mH%Ae9Mg&! zuTaL@h<(*2qT@i(Ewsr~Ra)vSThpBSoBPx*n?+{eszvcey*bq)DQ~D)5cujIxfR2A zB?Wcd^x5l6s9Vq7M{ot)1zHhXXiZN73#w<9eWy{||MKw+epwm#W6b z5$rj49}a6?h-$W^Ct>XqHD`LF=%IFK82dN=3B)D8DkT&*d7-+OpoC?Pq|zCa%D^1J%mfghnnJ%sJHYNIyI)EV#=LB|lE zNPJ8ONEuIl97t7xx9H@@5AGpNZ~Ya)@APYQqm;S?p`jSv61uXm?Aq0;s?F=5g>x@-Md?r2dZm^&qlA z$3=J##E(z=WlqlUO{?PUsi*2}&R57Y19@m*%a58vs)nSbnC}Lsz{X z^psTH&YkR+(Q!1$;AVqu5`=YzCcH8K3ujC)D%Qm7%!%4r{<4{6ep_*Go~67vTbagI z#*0l(zuE2em(3{iTMFjnl&o=)?DSf^$&Dke_lhk{6QSTj6o7fxpia4$;Zav$iVqY_=#r~?2 zQ6~%)PG^My%n{RP3ToK)Uqe{qyGAkJFB#4ZDHJ#;6X4j_zm_REJ1`Pk$5u)%eD=p* zOC{{<2rfCq*FN|c{D4gGFE*e2y+8)mgLyo`S8=kqXVugx)P`eU!#bXYb;uc8RX_u# z5suoKJp60wpLb~V+}V5?mn-GZ<``9X5_eOd0VTMkl0B*QDOJhZCq)SmUl)Y66v9G@ zMv(bk^h^VoLuPC#k4rrQsz!gqk#uAo65aH>?!fZh;vsirLx&+3CtrP3MH!z=tI$QoZW z2O!q=EA8W^?{Hww={4LuWtqsi4Zedlpm%f)RMFJk0>J8q{qqF*Ak*pwwBVey@&x-D zmz5gs;pZ>LTht}#1gU^Qmu0GVMD52k(hd(eQrNb!*AZuu62>79+jfC^92EK}@6lsNSyR6O$fG@=Fk{=OU!Ok@im1a!!J9|X zH^fS88@pn{E`WjZ9kCLGQB0~`5XPP;4BGw>xqOU{p1nXFJ$4L)sh6hVVr9-Jv2C|r zI0e3YnR*F8%ARit)2FR@2L2fjxq0g zsC8K9*cT|?FB!O+Lii*S2P<0z*3J@rIiW=gha4H7RV`e6!jLE9$w>5ktn1X>GkKkq~7wb zKp*7)3zP<1GKTUu8?Uz3nwYyT*s|+A-i92zJ*UCzsn51;PxiR{ewQbi`Xsq3Y(S|v zy%iz7K2+g#rlvX*Q&MPIMft#|5LXm?EGnzyw5Wn~xT%xaKgJ%X`w6x`>}@mlk2BQH zJF(}ell%4oJ^jr~^f#vQe0;GuBy{AZK$yO$QnLZ}4@0=ZqBX)l+Q^J_r7|DORVwp9zLJK0L#%!hDXfrJuz!qZ+zD0|Qf~pzi4(AWV!VVi zoT3P*%n~#B>X~Owj*epZvu6*0H)&eDP>z2-_82-#Cy^TB;8;+C8;8|_>^*1`1I%7M zAUcO9C1DqEw+BBb8mxlYrWMyVdc#*c=a!vSE4${O-ZOu|k5dAO`Evx8G z#EQP{z3HZ2a_+aNN8y%yt2MtRZ1wxC#Er&`hCrY` z-MH45l9G((FFR3+{lxbD%>2d7FpgM+B`iVd218DOx018u@SC@7yS<+Fux|!aqdTaF0SmN08G(C_nAx9p(srTD&d#QK!_I&#d zL(d5OreW;4Ni;Wn+k43OH$at#tcf!+Z8ZxYS$U z^gvFh=Ir0!^UXJ~4+@C`SeRW$w-qCrLNS2_3Q-%y+KZI={3*V5#*F$vpdo`^yDp%H z!5_x{flh45Ux@8STdGeE?iS7kDsWP$6(%I)d2)p+UR)DF@|427#9W>fWrbKDuMj!Pp=3Em zZNimfAJBVGk#V|c2Cz=Lw@)(0p1KW}1F#mYPNz-K>HZwO0w;2fRC^2DDJ2R;af-Vj zS))mYPsIvF3H5_srP1j$Dt+wwNrErOX3Oy<*o{W}I)A|J!cLY#Jtw#sOq zY3$&JwOSE3cVs=fZV+Y~U^;KVjh*T=7Af zi0pj(h*!CdY7Wz!>YZkC*0M!q^}KWMbs&`NO~ej2a`0R7rX6TM>P?y7Q7$G~V&tOemlD zljIZp%T+RR>BkN14KaCiaR`o`Mxq&Gu}k6iXh=ra)8R-g60l@EWEqphdeWgRm=E>J zIHg+ckW=0T*`Csrgi@uF%d_Psm(^%;1{;iewNb5>idAeg1k(Pc}{DoR=Ei!$bKpZ(M(pY6uvsxrlo24?VM#MH!`QXW0q-Kp! zsDVYyb)1%5NDHkKO^>%Mn|y9i9%)6c;;oTL8wym|7V#z~dXtlq*d>;{w)FJ&Jc}i- zJw3fG&qD3YDJaN6{}|qx1N%_R&OtgHnCP%6yZxAUj!?|uCgdhNvl5j@^*Xs-!p@;A z!gz(os7ony0w49d-Ygb^S_US>8~gzAcCjYKo*& z(+OlUOf_03j5p|P=G?aQaC?D6CjJ7^JV?yOtgvncYusN2*|LrAZ~?YD!{y9&E05|> z`yD;X*2p!e@u=5c}w}(8a753aER)$3g+qSACFYZ-HZ25v@FcXFL0Dr*!j|GJv*U(=~9CzKAs~Yh%E|LUBRbfQLbb_vvuM7 zCIOGf;Ftm1HUxQ8Ld$(TwjDy-dj+u2L)SmFQKG^lJRvENWngL{Vova}NbrcO(q2~g z2wx0gVh z$JT;<*KSurX&gfXuKAUtl+uwpp`WEXl!WqHu;*Ip?PztnC_bQfqJYMS-oNUn2-Z2M zM-;JGoS2C=bDkJg)d{pxLc*6>$H#U8LqRlRoyqtiV^Xp>UIk@=)t4MewkBHXuk!=y0UjEbZ{l3F0(#|tD$&V(kmM8xL`L>z$&Dhmoeo6Qj$4RWoNAIIm(cx;@* zvFg=YA&11-9KK8^H`tW%90AED01zuQ44-uqtFR}?-_m0^cDffkl@9@tB*84PWO=mr zq_l6FnFeJkxyj^Ga+FEAuA)`#AzjYgXwIFtpst-5)wL(k81c>YzS>a#f4zU80H16i(z5IFYpwPu~67&cc%I&utui^9PXoTcE3%pQF|1&#R>V zil49Ccvt7#d)JraLubGqiZ^Nv)OC4%ZKa;kf1)-wjD1b~nY>8nTuGhc*ge_uWNMbp zd*hXHbneWyQ!9$|mYtdt&6>$=ZT$D~6M+4A|D1~yb@Bmfta(5J8u>hwI^|C)y(|RVcBhKq($1s5mC&bGc-zRlvzkFQ?y#HL~<-R9J+oNA=gAb$It=C{eY zH_fo$#@q7h93~n#yCOGt#n}PsZ$NVz2%j1lc#8V=^yqt6uvXNnV{^#}o47RiB=zqT zC#ZivHSja+1aZn^v51QCe6W-9Z_=Svn5f<;4`BA^O!~;VmEZ@8i_+y}ZFuqe&qveV z0Ot&mx)g6shM9Qlr`Eiccl6D;VK4`5yF~XN>^J;f#&5t4LQDoD|0_h`4Ea*VV}^qVp(q(j+_)|RtYC* z^K^bx5nCf0u0LGc`N;k@dtq04Zc|uYzWc?EwcD4?ac4;t4vAossX2Z&fI9p@&D40XVH%rN>%V#|(B zXLiW1vA{v1VFn4lkGMq5e0TJNrW*${Nxq18olMTdNusljT>nlimd@AgZP9Uxf<8<* z8_{|%o0Xz_<+gbOIhYHcx|{`G z7=09wI;{}g0S@vLWB_|fsQ5M``9@(pI5B!NwgUG{azKv}s&(OI=V23C( zC(M+N08v_Dk0rg_Rl1aJJ7yT`JTGJhsvH1T7{{P>*gQ&oF!CV_$PVg>9C~ ztbKeS<{O7!X%Z%haRuko-NjXNM)V9cy;EQU#&<7B1h5e^z6B1P9RE1 zZ_Dqz*+<^-Q)lkp(98^@CATFlzb!MNeAn+b;Ri+rXRdEdN@`p`6W!OWYxZru9)E|$ z@cnYK7vhu@U5`0|QgKz@ACGP)A$zYgCCNwQ+4lO4?bfuwlwokaL?c7->>#5=1J)I! zjqGZ=aUgRF3z4_c0qoMOMS6Vk|6BR%F;+EoCuf+Bjgxs5d&6j6E!y62YSbKN?Sxih zX6&b~Lj!4P1BbezSNsL3HEc_6bY$gr-Zy&kBz0eB=Y7=49UnKAoLSJcwKbXg=8Ck? zc(*MlS!*}7|9LZ=7JBh-V@TGOmo$Xu?rZsJC5xFe$$!xE6PgdM8sGY=b0+>o#iBBs zt!z=nOE2B<)^!CXyWhC}CF;8?CQR%#dvQ;8MrVO_^hfO7qBVEToqv8^2>?$(u)l?0 zea1xjvs1`8x-T6ud>jx5*j5umO))7%jtZMqHB@f9;lMe({kswabxGoOEk(oY-2OMW z=Oxy!tkQU-nA1_%9$B=4GL6QC!E0J2b%eb5`|L%B+sii%)TxDT9X-afpk5|~b!Sh` zg*UMopq#WDz@F^-*kASDhT#jVa??9kty|TZzGhzKU|qUaW{j&%TyV{{;#H4sEX<%^ zWoSb+!JM|DRJmLyAPr@8MMF2$&e_(Hne2|#WOjAH2~j58m{gLQkhkIbBn9bIHTB)GoCd#~N8o^`kli9vWGp#7 zfOiltUXBniN^B8_+RGQH6%uli!UAFFpL&{C(fu*9-AH0QI6pPzOn7jpxF{rps0$mKTq0K{>;0sT~>5Jdv~L@Woda zv>#oP1LAe5rAe8qhkGlMc=}+H*dY>VVEdALWs0vp-bqoP{Caz3=ITe*<1dYbOXlVq zLv!~&@Ybs2nYj*v#CdWwZ;gEe+vzdLgN|`~Bs6zBVo6saF0`;WKt~;=z8n4KOKYMKaFteJyiG;CoY#`3LAu3ese%V^JkIAIy?yjmEEQj7 z(Ng-PO1q;nkDb(WIxJ3(g*R6SC zbMev@%f&>TTHkS5h}=h4`DJr$Dtr@=VjJO0xsvmC;({7ppZwt~&n16-$dZ zKe49n`oSVDXxFAFd)}cQhlngSXEvlndaJx@t4l18qs_D+PM)!EhysXHHnZn$#$$mK ziHQU7DJw=4Q-*DcCIK=N+JahYZ(D9;+jE=qlB)VvZp>@izjn~q5wD0-s?_OaZJG5$ zW#*)s1^L-)!-r1^^`car??11e>pC%BT6BM{hhB81i!>YkL+o}#8Aw>s6!*%MV)-Sl5x6Vo}rzk2$0q;uZ9 zf3-cPpjNMZbQ`IlI$CQ(s^?{@f4~p$`)fe+tErl%qOjJQu9RkT#heDY_|SktbeQ-{ z29>9p#fN)qPxw7!HSJ{k9qJDr1MD)Aod8X6bBEmnTf>Thldnwl+_JG|u8;T}Y6bU0 zso2>P7;m%|hq=;ROD6smJEv^&VC|#CrANA*D<9tZ#vHswbJt;OF6Hjq?%(vx&h7z* z1HEy?#IN=aDGOOM(hc9vb7aq))`Z?;qQrZ=Q~*y73Xt}l*N5&|e=^$b$|2ftuk`1?~6FRfYBI`|4EM zw&^1SV|Q){g*Mzd)_ZVSlSbVzw58cIriF@aFR_9b_}HKOy-jo0GkFq3y_I zfG=FB_(7#6SluBR^m}!9xMDPe-j&=y9a$xzKS;D6yqMq z9|96zChh8i*hNW0d&I;f+%qqxEQo2Ny4se$;*q;IRRyN5?krwD+H1tBT$H9T@bQ5? z@7>1TlA^(n3~(G;wZhG#E3VNzSd{J(y!^HY`LADL+*uV@x53?sk@9e z9orY`c%ZfyJ;U$VqxY61se$xeDVv34&>8x@(5BVL`*^2V(LAzlhD;o#Y;5|yPUBrp zWH?Xpi=16Zvkw`I^1wAxpY>0K)aKB7#bEF!gd^VyTA|G>l8cbdJa?B+48GDx=kE83 zb8R}pO5Ncz3vpZ`Pu?Nhnp%lU6Fe(w&D zd2adGGX!zxQ^Z{FO74H)zlC}N{$mOY48)v&Jp9L()?@qTevc`UA^jeB_&uzd@@vq# z$=){^vFDD~9ed5Nt>kNUR|Yo!7pQ|+=x=9mNpC|8r8u0%`I+d+@IV^JugxL?O*a)V>Q%}XBVFT48KV3n`L2~dtq@LnVCu?^Ux~S?5RSQu>7u- zOOC;<+j#e~?(MF*yYVjU65O*cv}diliXib*`*>Y%?V;CqZ-Cq8b$~Tg{{qeY7x+9K z?!(r(k5ktC{S0-y_`@# zydDJVg4Am2$gxMULTy3VB?UPIVH>!5%+m$WP|4%yw2?@kQg^dw{OZ2CGP+C2<~y7H zHBVf6zUSH%L3C_+xdX%aIGdrAFKg;OHdf3hd2Tzj;Y;8dqS}!}5o#i|&x^UPsMJ>; zqr|oB)|IPnUFPcUMa7k~r6)$0?C-HJX>aeOVRIY1uUYO#m6bp|G!-bClhNOvd!wY* zKXpwv@#pFB@o5sM5Z!wyudOs;29xX;AICB^CAxQ0fqyYrKXUixs#OD#O>S1j{cBsV z94jeZe&m*Wn`ckCI48^#+fQ_@Sy5SfS6y%6@Uem6)7NYpZ&47R(A(|Q`k-92LwW9q z`+F1bPvUjb@fKVqu-+k6a^|@v_3wyR^UXpn2Xy~NX=M{%vsJ2+S#s~YUGcrgcCZ8> zC=?L~>=KSyOtAS{DeI1~9kX-clzp)$8Ml#32#=hB({XS4E^zW|3NFS=jkG9~#=Z8J;jvs#u! z%7x;Wi_QW?wn$@BJ~SrN=4IwN+bh5(nM3Sw%>5%zfuF3cytdMTI@b52bRV9rF;H23 zZPlfZr3OhZst<2(#Eymd#MWIn&slvXrc~OC|DOjxpHAmKjV}-%NP%wntnU{37}d?XTNG1*y- z-ecTThbThc+p>n6HwGteYS|ehhsoS(C;N@lAa6Yd&rg?;z@CdvP62uI<8@nJANCt| zVf|RBxW&px@2FOzu=5BzQ>T0W6=LLK@iA9(*9bq0cHckLynnnR7c>hzTFSP@%ODM2R88SCP>w$i=^{kX(845>1&@LLl1Lpk@R0^& z5c$|ex%mCI4fXjye8XL7U{?gqW@NCaC3bs}vUx|h^ZxJ6O!p3)!89h>AI?o`OL*VU zaYe>TZ+cS9$P-Cf8Y8q=*5+_>=$g=QXzK}HZd*+#Ozw|s{-1aaq|KkP0NXj$Z)r?- z#ZfrVn}s&f@bMu>c*FHAlNZ|Sa)sGUVHVdB2pgR>cHznaW4Gp-&6%uBiOe9*!TzVb z@h{kZ47azhtLi({Yil2A=49t&vDGpj@)JZ_Sh*%J0oWoLYfWci8TC$vppNwy$d6g1 zXDil(Hv#v(FraS&O1ZbAWO_&5+<;}-+8OW47p`il+56ng=sjDi=qwQr+sQn+t+cnY zNTlL`W3H|W!}fLH*QBm@^sOsayl|wge9NP26$WAU_ij++D;{G04Quvq zV`B8C4Tr0Z0p{-q2E_KT-BDu~4`A3nN!R8Z`er->nYF#UgM2hV5HMDl^A78$6DJeJVMNk;Su0@uhuD`f|HeT2O9i>bt~u zc9!e(<(-bZs&#^DpS@ROJvP*|qsJkaEfve?JWr?zauR9a+r`!oaWkMWlnaMsNfN~zrVa{s7 zp`kWTKCKS)CSZrpO~N-~ZZ{=UmJlbgzma@Xkjgc9Dx0KmiHGL~bBHaJUK!svMY4fU zL9xMs!OUDno>?0aIixbhzkW)dy1-=ycD6iv(CrnLR;G|CXNuj%dTsF9K6)^!%bldJ zhw_byIvl0b5_Li@Mod!jaU4H@b|B8S%Yi;(g#JfD);5XlQkk5xT%h^D zQ-_;-i;?;AP728afuS@;vxq6r5fww41K0I}Zz!XNhS}TI9)l2>HE<19;w0{d`V|*5 zyB77PNYkKAX@-1y$Ck`REPFS8(K;4L787Yw1Nn+bxp2=!ac9^s$09Cgy5T>I+(rpa z+n6jduq6q-TV(O;n5R-*0#HyOd3c8L7>)OTSQlw1q^^l{=|aW)+ZXni_!91!Kud_P z^X_FsyNhxdN=dDQ4d|C&S1nq_Yvj5-PGSVSRoNUq_!_yY`qHpMfa-(`i8J^vct^V8 zbqpp4J?*(+EDHF*AZ25;F$elrd{<#-QK-A7%&035c)ebwpQ#dyE#8Kbf{=x8s~Z>| zsIwJ~UOPPfSfC_F#LKgI!_J0ITV4NPf1S8f+0Sf!5{7LZUW@?8v?5$dM|CXx4 zzMYM;ExUSMs?xq-Sznb~q~_qujO7Iq-?FQFnhve*l>QD3G99%e<*pW=no^)J$eVZ2 zzN85uZAEPa1k~kBNzsl> zH~2@JfR)8(M!@555nGx0`sZK!#|I~u{{q@Qt)Qnd%OHMZ@+$1WYd){SC;vY8(loSt z?!%0CeX7WNNq@Q7Og2BZJjLe3I*Q%!a>d^I#TtsW94dP`1N9XD1P{Y^hU$Kv zgk|DQ76j3Pm&C&YE*3TRHWmd}o*eLPTs5ezXRAd;<*gn^*dbQB$|}lS$|->|@u=V` zN2$|UGtu0Bc-$wllp6a*3avs?5Y$@&1$tvad1s(7^Ip){C*ar!h=rHt2;{rdqg6WILigVr=y0lsX4Tox3MhgCjmii|32m_4sKpw; zD`Es!&nByPQ7;AHGbQ)Uf!r!4-4*D`18t5X6t!YyV;>XCKYU;5SE}h)mQawz$>MRj z+UjN1RU;vlqPU?T#8? zN+WaVVzvOjar989!BW*>_Er6k9eC2b~``$j$+;r@D1rUvA5Sr&%Bb)YUh@I&(ANAN$pxe*@ps$`p_1R*?j5x#g<2VNov#b z`C6M)>c|%e@*UE&@4@PKdHnCo{e^$Tt+wU!dNmS9FW{eCQ1!=jfN z-J94Yer+-O9sP%TVs|@VFz9Wx^GQa7>!sZphvK?C`Q&xy^2Y$rn7HofYCW5F&of8K zGl_iXI?}Jrw_N^jJ&fogwk69065Q(FIg9u*7D|W=N=9Vf2W5mOBb3pZG4+4qvxL}4 z2N+8iF#k6H{T)e!$qmlMrRCKfwdY46{i3gY>SDaWbP~7XG z%f)-JclnFsH{uP+5vOQKDymASJlYh!nFEmCKIBzWFHUlt;_qC=!o_5&5^}JOC~=v^ z8Zj?hz>1J-Ax18{I`FUu84K9?yu>13N|KAwC5oaeTx7-3XdsZLuN&RTwb0IagY*d& zNAo%;BOqyk(XeGQdMMdycX-vcy~d_c(^^k&XK7ooP$knd3!eD8|M-}DtY|rZL~E=j&>hhXd=E25Heg zS~z9H+ZM%jNOg;$>`AX1n@jQ^wXAYd2`_i9T5@cn1exrv)@r{D8tvGe+mhrK`tNUu zWCs^dQ=stM>09UX=*Sf2}??9K;>b_G^py9Qjczwg}*ALb9)Q#C`m_44ag<|i) ze=}F=KZ(C5GN=CSD10=FYC)O>ygx>GUROarD#*x4i_K789VbZLu=UBgQ~Ii*K(L`m zFIJPeQ){T)sXZ@ln|U<+el%5TcWcL<hH+c@H8p~8z`7UKHpFnb|2VpH%o){OA0H8%ajE@2YNJ$ z++4cFG{WXqt!}cS6t9`b!uJL3YBSGV?Zyt01i$d$)FETX$_kmGvbQKW*<`~jTUC5I zXWNisV8_k-AVG`LSNcKc3T9dJ)OctB2^w+uZct!CZ(m)h<%mJY~Q??>WfZ` z+d308W~Q}|P4nLPu)p(mtSss9%J1WeSoEqb_l(Xwx3{L{suxyzXVxyW)NxdzqRQUV z(((EN2DWA0c0)y%>twdjpji9pmh!g4FRZxot)q2ZQ>Ck44278?GSmA1qZl%l5rpUV z0C^vfcb*=NuG3>2m6_W5*AOEnc1^`Tu}B#upFG9Si2@+^w0bLsLmKQ^WtYFY*DVav za7gHe4fn70O0?Lx=D=WSPgS7^-Qr2Okmh5Xm#TgzVr2{SWl9ATu^;`O{2HIm-o3rW z$&nRQG^%ic%%ebSXxe&Rtyac-r@srWfxP2}hE;XV4yDR3v1syGd;}zsQ9J(yz80=4 zn30Mz6a+$DK4Y=;&EyM?E7=krSMO=`^bIT@otarXE_H_Offk>YOxqltoU(V`yfHk~ zZ1L-Po)x!FZGI?-7mHXTsi>;hS94cwxyEA_Q9`J~$VGP9lFeGaCm2%urI$V3Yc_5io$BxNHWnMWJPEr*Ro}CseEigM&n-Atp)QeF)qJ?8 z_0eOf=Qu+xj>e5`7Ot@Z@-$qd$n4RS*WOv*{mI+Pp}ou9&}wzfWT!DFxNs^VXj-HC@S{rt5-%W_SV%;a@i*({40p&KymBw^XoUf zdbCAoa4T0!bNP7^4#T-*OMTm}?t%<#{zQi>Xy1)E8R;z6KjPzRIaGTrM^XLwW2^##ya8*{wdsh zA&C_bJNpE18~!QjrjK`IprTinjIx;d-|kNlH&JK%O>w5Nnz^rPx&e8 zdQm!LEN26IiJ}zo3TkFH2X(PrG9xkO<%Szep){weU~aH7lcyA!j9w?WaO-TKVme~c z23j2E3hC^vc&3*n73AuqYVBil_hWsU(%uqxyH6$JgI~`1qx*n84CfNW-!V^$UiWY` z&^Fsh#@19>#QA6?(8FK*sUTW3)^dt=D;&rDo%vBH5<)roQ8Wbi4P4P{tBNH_1#*;P zF_|PaUPC5HT_a)woN&#~l6g|UV~0j|MTQ>Q*PO_cGS)3C_jH$On*}Bwn7s57{cWO{ z%9hHY`U)|4G}7mjz}Ya8FdN3$O3RZOm%+QKkj0e;t6S`2yHt|;o{_?bpPTLOG*lHT zW|y>imzq)R!rr7R(hH}0-Stl4k6uCyJvJ^aYILEmmJb%&v46n1*AowrbDN@fByHve z6VJ+gp?WJd>uBM_&(1zbPTJW{PWts}@FRswCrF<3!h$*BIWXk#Ei8-YvZi#wSis8c zG^{{qI*z0)zUyGWGwG3GTa`tQ?oMN6q2gbiZQemM%BjH*Cw8NF;>2J&Ymbe~3L9PM zI!+CF>~maXR%U?to#+liTCGX-t8rQul8a~?jc4yrcVFMM2~y_bQzb1$c0|mR5N#O-nb(Nuy(AQ*~z-J;iW_MNsYX~4~|@O z&5`{FuDa>~_(9`UuWw6k+y&)R<@`nZTk!qola==Am?$U`jQ)7i@GiANtfXwDN~fzD zDJvgEpGPq#s3Kkl_s(5adfVWtGrPj!U1wGe-d2ijecsW%Jrdd0<#cv!i$u0}JFw#) zJ@?mhQ{K|H z?#}-KuLdXTEyl?DNY9l6F4w>n-I4XpMoaxf@Xa@|4%d=(dyiHRKX#~9W=C-Gc3In@ z$A+tq>|59ABIQ!%{3qBt$OEa^r%5HqJ|4F2TBC~2aUJZhv+-zrE+?q4RJct%#0PTS zrlr&B7x?TPiM_&tZB2{`W$^!DO#0hj7p0C#tD(k(cXSP;(-^-eWeZ15dNA-cE_h2e zHRFsh|{Cy(Fw4jb4RI`+{ffp3gZbt*M3)AOuM3=!Y?DoTj z8fchYw=rqfxqfmXgQc{5OzC;gh6YOr5!JHod9~yE0zE#U%BW`G3JNEYuhv zie!+eE8*!tQ6!?#aq^T|^4Noo-80}kwXk$fl zKn#B13fly|OGmKYpO?xWW~vmWpMsXPw~afd$HitYrj^+I+Nwt4y}94mfl7ZXPJ&=yluR4U5Ar~5r=tvV5Dlle2`x~P!6`F+T~PM99*O@ z{g}(ZWs>T!FLFdYzQt4PXpH5;d6wTi(O7NqQNo^I*j~`S9twz@)O5O`fjV2^*oook z$NhL9JqfOH*MK|ERnw5*ki(bFphM?gLEH@Wv!_T*-ZaixV~njs~GFWRmE4M*g@Li{#-uAiP!af z^C8KX(0t0;2aZa!}}=h##`)Jsq^urUX@jE zK9jy)xvbC@(VBS-7Gv;WcqAYLK;i2wu}1XZ9kWXyG0T(&+Skd-`K6}b>jKqH#iATJ zQ^agFSGJkV&1D85pCxA_{>qyF9D9vkPUaL*m3w4`_QF~(B&LMeYgCFA@hQl2nUe~W zB2~+44a)^e(5fK*ED(X}C$IuCV3L!&)$TAguBe)OO@?}^*`VC|F};+^6JJp3pPu#g zV!Cib;TuSScn?bQawH2Td?Kkpi;@jR^Z%gT2JdPXX?JL&J_MSb;t$nOrx2k%rzDNTsm57Y&rbWnl&$7)ncq2D>b*9b{FWtPD?|H))raj_b+R-X-gW-V3*E@ zS7gz}EtA`;M;_eW(6IZ#k?QS}En<4sHjRb2$Z)q$2W!SFHJZxtn&5Q1n*o>>&9*2u z@BHWZB^r;+!AlKyK>83vl66DKxg<h7cCUM|3Lm@nxx zv`hw9<}BBv=D2wpyIiSf@-%e(OD-$C{@TdRpFhxFvhMyhk!Pm7n=8yR_qb#9bf|W$ zT11n?dJfzr;45L$lkvt=4Y)-1`ElRDc=nJ+`iX zij;!6CzL^@GN{5@qjeGhu1`wuK-g6a*GD37(4?`dyDUEQtt_MH4a~{Z>7Rc^k%tN8 zUb(_2pZi20qbp@{g6hpdhi}p^qxpH!9%m_@A#B+v#PN63`rK>tR7|FVcOu)UdKVld zc7lW0Zk3q$l`f=Khjc*4&yUq|&}yk#j`%f6OZgKf%!u0PvoZI2QW~=qd|~w}t?VQl zLY|Tf_&4&&pzdk$d=+gQoG+z^FH~W43HQDYBi1L*m#I)V zDNN60pl}lWMC2ut_Oi>aF>{R}*XZ7e%23f=Sh~E~rU{!=0y@XJ#FSoaf@-DiBx|K? zX}$n&qB{TEE2V@MvQTR0@x{xePVcDaYoYnCgVz6{UFkJaScU?=D@)+~ZZhgml^w$4 zg|A0UjKv<0g_IPms|4qa;vq;l1 z`soKpo|rv#<3FDm9ev`TH=de(Vq`YB`u4H0+tvhwYi=7GyM1+#_(EzeQ7gR`iNxYn zs!Oa=?A;W+(hKX>y+M3_$F>VcBax#Qwr#&~BoaAtVY|wMe#4_u`_N|}ydU-RpV3O< z@shMaNdl7@PlU-6(JSzwv&zC3yE_7%8|$^&hArJC%}!xg$L%{0zk4DQx&HmD-~M2@ z$rjXeos)NgH$|pmmBwolIs5i?cI@dX;A;z{-txP!NX)Hp%Z*F-<#P-D7j+nqDcOvNJ_>a)}N+-){@TV*sG7|HpQ?ip}L7bIUCEC|1BujScO^+@z8Ie_6g`HRUY~KvG>>l;ti1q z?6%4{CJFeQFC}(}+2H4t4-DGl7Fcl4uuI>kVrFOPt~lPqcgOqF z*a4eQMe0e4_H%TaNMtsifO7Z5z%J{zh5El<3Eqk2C0yNJ=B9cfgy%oYWYXV;^oyu$ zbO7Iw%(T3TXw%b0YUg-b{34!32Y)5#Y1L&k7O4(=b!l`#Lc%OAx+gQ2fgNs0p>`Gd z^1hs297hyWHAts2E6BW#B@6b^u$ZGh`Au9TjUwi^Pfw@7UV|2|W1$~^*Rl8;&Rdvb z0av6Dq;CE*DW%YZJU)Enk0&1aOD`>4C-v^r;F(lqnaLVgR1Mgdq8rh@3(tps8GY%p ziw2C>T&Xgfky15xe39h~Qxq&&Zf@G)ZdhFBT4WEB zYJF8Crf_M7IHNi4pJl)U)seWj3)~_!65$}tn54iE@Rdyig`8-Kpy*Xqu-lJ~#7hL1 z*y{R+`s-{gL&el}<3GRYrRBOrrRq^#yL0-nz_Wa{k*~3;WZHt7k#L!tVCw<}66`?S zFQS!etfAg=b8CIMUFKf8yAgbz$c|*P!hUK^`B2CHivAR|cM$GVG-RSRe5XsKY;ju| zJQ=V%2X&}zajIyzG2IpC-Vv#qsx>4QCIap}E-6T`ZSue~(&~n+y4LIFpm5uT)mt+e8F9zygV_$YnKBSR5AO6r+)TKBGP( ztylYE0oO(Inek{obCDQ7qY1b479;;d`U#RQido{5*(9tiz!s}`WX|%Fg)IDlCKjW) zF&Q}vyMl`1B;_SjC|Wz&ylkAr+9L5|HbCKna_6ehn+dO25PVmCE_vl>9v)bs3ikMa z7NIU#lH<^~!1u_~S5Cr9w(Q20HAW8ot#6K?dz5myLhHNSVSoSPH%nYl*3?%-+k)tw zf%KyIGKD)sJyEf^ZxE1p&~vCL4L(92bsy|=%$E8k@TCH{jD($mZ;diM(?z@Yn<2jk zyYd`)KSv>h|A53IOsfQQ{7)99XH(Q0G{WatWgG|D;@k z%eWqsa|`Tl1?lb*6jDKlM5@6{R0;r|N&37ds502OTy&t=pU62+(LSN#|LN(Cm!CK( z&O!Sm8V&q5N~m;4wl;3lU-@lR#UmhSKeOQ(2}xfZLhX)uJ*bijZ6@W1!EPC3N|^A! zrPzt*)yAA4u{D@wR=og@eE|*wwxY4X9#Ifq5?fT_M;{ev;b_?Wmk8JeenlfsABWl< zKz$;`@Q*1vu2zU$gJ6%82t~;^xU{6M9&rSupai&)iqruMqxg;+A==9rg-(s zWvbrkE#-|{m)KDvIJmoLpw4<|+ewqN)~jWCZSC#7&5@q!-A}Jm z7(`h&9FeJIq9w@k8(Z#eDiRwTR@VkLkA!HHE(nDHegW<&H$#rb;e&()?VGuGD_|o_ltfD+-|lxr9n* zKEH8ID|Q$04NF~Yst!J3svYq+Z_`QF^j5Cxbb*XD*bOoJ34esfBK`pP%onEeVd*nyiiEC6&DvK43AjCfhra4K(x0 z(U#`2wM@21F1B@SZEo4xVUroSRLqAahx?HW-#MyYO-lxqGO5@P+76n$>FDcQi4EZD zt*;+#`rOpGs^*S6YF0IxFtGOQ;bt1va`^0;2t2B}t@b5bDNJ6PiQHpt@(%Oh4##_2 z#CB9rvoc~bMON0_@%iU>pz*1>Hf=fw$BLj)=Q9owb9fj{f~Etn90KPOxkzl%x0Vr) zWTRd`E67OoeRHd@8}J&$_K4+?FJ=AriNC#OKR?{D-U%l z^OYjFXT3xxxB;$(>8 ziqpuUkv-aCzFjf^iQ<9Dwc0e!&&)>lpL0!`z^9)YJ)(~VF5TP2Pc;U)jV~5~5dn{A zp<%>$K4_GSi17k`j-HGo2jN+w{2Lx+V`h4aLy%#3KB0gEgg9^R)N1LHPiN&Hy#6{E z@SavM3&0{)*F9GTTbRVm=@Murh9Z~%bSk9wsq@;qs`4nFKpfV+OeiD zOpPmR!jPvScZX|MlDz%O@%Hv;0t5WKCbFf|ZtvUzd9tIRpkphf*#z(Ib#P8ALPiiL z*IJ}Q31U%tr7+hO@#&xu5 zI6gw$E%qgV6{vnEBtlqn4Lb?nf-mJ7)utu;2L|>pF>4H2*^KNB;rhlSuWjE3=dTaX zWHEqDkY`@%2~9Pa%?(o_&r)-iASaubIaT-U#?5CBgu@5UZr=E8-BczI-h{gOS=v`L z9jT`v%m->kAwb>AOb~yNQ1T337Q-V#)QI7&2Fs04-?z7Ywfw2mtDA7~FTxjgq4jIj z6?`ct^Vi{*Hlb~i%K`!gFB3Zz=sR%CIOU7%JEoY!?x<-*`_Xi;#F;CUszuxGEvrNu zRlD75W9dv5K6*>4=09VcB=hA3sLIligpOfI&f<^5Z!T6ii!GBSY;OL6R!_>)7jts1<-u={il=gr9(P-K~|2Ozu;A2DB zqtTQ!S`8I0x!O|$t`u=p?y$+$9L)Dk-#R{i>k6N)w9Rg*^Qw8WM`c1LJzL?bFsMC7 zQ5Kykv^>tymlhcOE)ze`>&k~4d}5KO zs>7`-vznxAgIH5!(Ls4^E7s)c*)lUF3p+7DYlP>-i{)b^PzdnIj=lSL&LiB@nU@aM zW8m~-kKebAx-Hu>$o_br(IOZie>b)PZYm#`7O6k@61qAK^E>zN-GKqL$LO}*_vj<1 zWBC+&Nxe`U&2=}Xc6ZY8z#j%Xy83tSTy@)ot8ntx>7AcqtnQYYF5)$Cv3OudUCZ93 zZsHL#?uVhCwD@Q|AA}dHU5NYs7&gGCu&dDWu$ke(UV$y_0xh4GDpbseWu-rVpKB3M ztgw&Yz82F03zeY(e)|mpwr~Z+`*tuY)90FQnLw!;>GQ?Q|d0?RuQ1HfYh-ltPu3iR4?Zo?h9@ql+nv3EnN!Sty zQ?s1-@KfSL+<}KKy^4okBhPa+3=KZi6Qz7{<+Q6`7;l80r|4$yFW2WfCF zr&1ILk&!9KpF3H|;%RE4M(o9&-ii%Hlzv&A5v2c>9MhgrNk!%t8P~9&Nq1V(-!Exc zeBv%N@lrIgg7{~w!LO3)r>ji+eo@MpkunYZ-i)<)N-IMtMZ5izs zWNaoHi9`R7(d|fH0SViWe}HmHSM<0W9HJk+h{zlrlNQxe*`rH~9dmhb8Tdtcu%_8Q zwo6SV=stU~dx@c{NO5sVyLZU^C8U?sSD=0&pkm|MK$jNgb<+gI#Cyc#d6g;W4Yq=r zBV}L6GAWVzL&H?!xj*ZBT&^BHCKizS?oc?>KZawO$+4p0@aUMLc;q;B2KvXu>%Vw~ z4rLMZ_4kO^-&9*NkFj$Z-0af~tEyIIWZs+2$zcU$C$;7;qRipO>tz_ML|%b8QUQ^E-qw>f8DgIR@<=URP)%2%}aBI znYkh%Q)Tw)oi#S0z*gtJoy|W_TuH$SHjlUp`)e!|jB>G6B2+R-8~{;3uD@kl^Qy|4UcZ*ToWYiu)UIF* zN!i-8JXG1~QRgntsdNf$)Kc{(U+>FAc-Z3#B0+|q*2&zWkIXBIN z37q!PpNvoZWCRs!7}Rx5t;XV>a-DDbds9=lPy2M`J;lb>raJWl1E|=d-0v?(MHvHh zjzZ#Ey=6~T{kGnsqTX%wReQFqc1aW*dWyY5kI6TjO$_`U8YxYeo+d>+{22zk2mH(D zi16Q1o3h_z%b7V6_8VDd8l7-j#Pwf4bt1mEODbR<5sE#`KmR(Zi7ajC%Ru<50A>`A=oEb;f3H&u#6!W)_H6=#9s zE%-LE@RK-$u_NkpF_F8(0jWM0@W+xYes&f=s|5VwI*BUFKzwGPYs5DI#jCWZ9~1`i z^Mk?%h~G-`)~(~p$O0E^{t_JbUN|nDw488qP%$)Ik>kari#c7uuMA8PvlA5M{pRgF zKqCh7K5=I2WmkhqtcvzD2;>K(7eL_+CvLp)mUVnF_R)>x+c1Ei#L(Eea0jdzNgW@B zJmF>i4&X|SNyx|&n^bFBrB)Tso`|EcUBYiJM%mAUD0?8W2V9`GFC_zw@XADs;NrmpKB zI%fB=EMk#CZxGq*+;Ww-u|VY#R`B?AHF3_S4@@3u?>M^5Uux|Z2Pfgb#dbeG$u)q~DR5F98m$VH;S3Dp!?%Frw49@zE??egVJSO zpJx#fH=E61QfT23yRnb5M8rKJhty*Q1EQ>?a}X}51rbrDAlTo=MM^gD3><%4BIbY= z3`Zk#c;I@GHIKLh`-sUWmP?!hFo4!q56AmOd^|)y3FU~CSO$r1i2VZ6Ogzh0iN;Rj z7-->$DN0B4tYTsnj{^_fP1 zbjMzu92%OM8XB5}x9rGNFgSIjwe{#E`FV0?W^!s~299rnci}LkmycqV;QweRf|#Ay zE3xGZ1bUZTVpj14`8J?tGf_3G%3~3mTQ)Q_Y-lk{tUfi;aC7pG2)S7}El*>UTA(_V z#naHV*%Gr_V$#T2xeBdOqBcviv3^OhFyC9C=j0Xm8yxPg^8EbrF1NkLYvyr{u7E*Y zpi&F6MI514Az_MqHl`?Bs3vVIbhbBy!c$>KO~?S`FvQB=0%= z17+FjAD;Um)=K|y?inm{E5d$+=k{Kd&la(lzzr33XYHM&x3%DGEv>Mn9z0Dng=dhF zJrjmsH#eXZ{R}C7lGY2yLEVIKT}(3}L9bGBGL!XeH?8;gkL;mk(cpjkANu1R5-q)- zo=vCcX0D`bB|fP#YnsKRXVLp<`C^i{AIMekc#2%27yC%eCms|yWiohQdbl!49`T^Q zSX#gbJv=E@OO7AKWc0_NTy&Ej-6#%?FfDMA0z^Z?+Gqa7=2bJLGMPn~ua;}&asf}8 zr7qlBQ`q8Dwo0T~IRd@OCXaN>!<+kQ?_o?XpDE(gTchL;y_+MosIgq0kXi7*7E>;V z#n1IyEk=z-Z>S#fn`MPoCX2}_RT%`CR;R<-QL89*>*D*Xhi9IJA}0J;a!fi_M$%$T zZ=ecsb3qpIyewE6l$VS*+6*;gWuCqY9aju=SpkR4pptQfOxjYmO2V~TFRBduOnu#S zt!KF2stpYU%rdW&#mVJH^#Sl6oZp*Tvl4@n5G{fv5pS#j?#kgZnRybmSef4x3>IjW z8mU$);)t?~WPZO}U}`QiI&@Zzs-)dr(XXK!x!Kvd**t-Dtw<~_4h>Qv@R8x6#f4^Bs{gqH?P;j{l1Ets0 zV}HP$aGj<^pYX-<5E3P_AFFEIwraaXQrr>HI2C+4KQ||rrBRlNP5eh!shRW{dA{1) zXd`|F`4?XACP6MuZvrLNJPvU+##53q_Bi+gp1C9Pj% zla8W72knm7?=@6cBd~*vQv3m|i+(lv3dRk96sHd+iEh{#(5lJL;}9p{F3~4F#S^n(s0>&C|o6jd-FeUxPjw6$-GKnoEvfgL&YdSrRd?gsGpnh_R~? z1egb~)GGIw-9F}4saZfMuhf|AYG1S6-t1G`O`1x%5dR5FoR_1J$rL$xVpb@Z=UCyh zRJ-JISGC2r!oka>eCYMqmsmSve})`ID)@<5P|8&knoROV$qsw^L_EbsP8tj@}s{IVWTxZqKmi_hX~Z4#Y3%XC@UZl^+s)@+7+7GmtpV3C;_ z(HwCSE`uKvjlv`x?3gg5rU%8gVy;{-%r7qZCoT}=nw^CLjU(J1cAzU#K3;2Rh!_f| zmx+A-5)qACUZQduR4iUysJI?{BILk#n8%juUE!e$&(dm>zH*=>vQ8&1E2`{cC+OWi_ z@RY6$<4)$4xzbrxTI!9y%F4cD=^kA3pqM#JiMA5k${8q zL$3M;j69b=!Z+-35_t--VHD{G-3<-}=59h-qNkKmZ8<*4(Mi3$et! z99P9&o;vq9n@1c+u~TU5L_jIjS)h+|(j=uEW}P);>i1$p0}pU*H8yYX@m$iVT|`T1{- zk>`YPA9j-XSIA>dO^h6!$!}>~QHg^vAn_qg3art;C--*vR_^4{83py@rKP=WwUs1R))opM>tyRp#1IFPn(SLTkpMtx zt(@2d{+ios?fx}g?Ie+JT>OGYPExHzhS(goz>twxK2jW~03numuzc^b z(b1yrp2~HF`1OYm&XV8$%WHc2_`#c8>;zmvu>m{9u@u-iH=xX;-kY8k5kCh3HvAhd zVFrI=chukfoB;GEunSJJ+v_QLD4hQX?GU7|FI87j(Zm#wIg6J{;AT$$YFhY~M z9EZCdgTvaJNO#kCYg^k5T4k|4PjLj}7DP&M@A8``Jj(`KRnbb@#*%`NnXmQLw{;qf zYWRclqae@TUV*1q-73v$sZ_zwwrV&E*I-*IM<77;w^8hnXwj|Os*y^RLZ(H-RTPf2 zm$D@CSotl~Fa*RY{6m@`gOi~nJ76WFONnr_?nE3Lk1uFp1JbA^8`qu4qAX0C)b8r6 zzPxjA%xQJYgF`jpiAvQnvb&YaFL(Nfw(j0K^@|H#Hm>d1Q1kX4heEbgBx6MNBWMra2H#uCSLD$_yVWgpd$8Ni zy?^f9`{)(@@sBayGtZE@$8f*SkU1A*Zy(Z5jhXXk2gomJi`es2pMOXKby_Vs$Cs11^brw1%q3j-LdBGl^*|!Q$remf%Nv{u3_^>C3f8Rg1RJP zZ(C)|b62(%>dKsQS{GlM$D|oMA|bxm;cu9@qPOja4K?0@O`(bnBTW)szR|9TJUz}} zxNZHUuVelq?F<=P)lyM5lBLr-w8x5H1H{S|qodPc%aK@I@W_!*!O2gKfVZsETehsU zSYqKp%j4h*Vmtbv-gOteLvNEgMvjdCkF)mxY~slN$343%$?CoLZp)S|TbAVBd#||R z0tVB2@4YwELP-M>2nhs23Z#U8lC0f% zGdr)&d!ILiSrLqnbWj@_20FtI)Q}NM0Ux+u=POIFSLS+R$u``+lh?N4cuU`1)6>?j zy$bG&)p0SNOv8I1R>bGx+rh%5@)WJMU`E4=N9U&nC-%3uP$bkGtWy}Jv8m&FdXnLD z<&g96PR1jYCZp8WjkWPev4+jxQJL1zhO1iEPSwH-%tN*CHi^(Q9nq9NN6QM8E5njoRO8Un z9S4zp2K~meh+i%pq2r>O+K#|w{ih_(B+^JZ0+mT3vx&v(OmA{ymRavBjtf*7`CQ|) zX+|!QE0gn$K8GvaEZ_+zLkU&Umz6uA#O^d%^vHccb_njlFv@2Q#tip`2u6uyL3>qc|fPf!SIi}QMkYR#khcDItMrvmNhP0j%rzN+=pHQUZ##?8YxTqJM zQpuMECnR=SIcxzT;#+c3be7Dx>}>Eie}DJw_geG2v)qlj4wcdpRA#4%^lY5TjI(62 z&Fa)Np+1)Ob$5anp`9NX_5q{p>5)~7w68mSKIx1zwHKt+r5VgFYmy_o#wqiqWoUeC z=!L6HDy!a=$t z@{UXvu@KCqVz&oC74twiUu;yRn-r=Ef0(|O>N* zK!oiay>Qgrs5N6&{MR*OR)nsNUb9l{ZP3i@r%otuXaJmzj(fzQSsI_8q;~803^`;w zu2it-G@;mOE=)CZc_mN;s5Lt5_t3_O%>eepXE1cm0``-S948E0FfqB9j=A8qkl%b^ zev3o~ZxMKj0E0yWFq&*nQkGZ;-T59>YGZ~mNiSo_cx;})sLu&|_f#Ne0rKv>&Z#}* z=iY`a3zt_VBy~=NTvAVS1PVx8s>{Xh$@^`raNyIQmA}SX}ncL z0SrEjeT8{P#hR?)*wRfQ&%Q&kCd7&;xTNxGtdWpbB!Kg} z(}wfH*n5x@+MX@4bskriq#KQUW z+onzXo4s^GZr;RF2Xv$JawnA9sr$!aSMVI>a;nd5d_4os-P!^H2N{VjHlEXrK!-rPPOXOn}d3tNXFN2 zd1@9Z?xF^Wj(=F;^&IaG55bLl!5HG?^Ku_EoEdLIIacm<}O<#-jw9 z)TjVTSEdaBvA9IKK)ZYCKcUd3Y#RsMlXKwSrm=FuqvRr$G7>8XDHlq??AU42LvH#i z2zi!`0-KPh-R{#n9}E&RRYt2=nDH^qMCA#p`7gm=^xjCscVm;GzCv-GaJ(xFj02|^ z1taT(775ks+u@{*7HAVpD2>bVD_l~KLH&x>lbMv1>CwKbGPq?fg+Dv4v=`rP&1&#w zb!%{U&iXQml}lbfrcs9FDi-6y1K47!*3LU@`?LN4{AGv+@S?%a;j4EE zEb(5g-ES2kTVIAVFkGuE#27e9aw7B)YD^}L<>z>_Z34N?t23u3s0Btb};;B!e^`I-`iPGLl}R#LQe|L4O0i2?Hvy!1yLWbW z?dtJ*dvGo(1mLW=8@w5^mIi^w4`oDG}MPjnEFTQ?k+&l?M?Vf&iq-xG3?7 zAOOWyliI2Kgsm656P1CM+>6I~d;ue!9e03G800GZ?0?C0vC3MnCEKIL#P`Q?7b6_3 z$MI*dBxw60yB=kxP|1x_@K=>hj4#@6aJTmG|lx#xTQIA6FV<*BK=e z-J)2N`YdQzgPT@cQN8L%JVvF_YR*>(O zVH=bZ@;~NGeOf+<6|3NVjuQvL7-lo&llsKg45_<>oCIEA%_ocSrbV`>}I)4vKF`?aEtpsn`Nk z3O-wA(dhNjO(zaxA54jA%MorNfn}gIO~k&&#zHyA4`)?G;qBkh8emA{51okxK{kgi z;=(_%%$WiSmmzUxxm;OJXf#R%>KAv4b<7F|n;qQKIL1yJil<>DnD#+72 z3|f&nBT<8jD@7WkQz+^YzC4ToRJyxHvAt@XJs75IT{-^d;pDy&0qlz z6|-5KilOca>VmSGeQT#!%v09xt0^m}_D$@9ZU%V;y0Be+Db2pm z^+|Khs*8g$C&`sy?MV=GaaE0(UJC-*zY1zCh72taKzYU}IruE_R`+GAah^(1jpdY+ zpOC-d{lq(DlQw-!24ANX1{|SB7$-hNJ)$7pC6I1ubjEfhsf#tLcmS@~%gvj+Q&PG& zH;>tb{@;``|Ecw*ohN_l@BiuK*s}Fc&nK^7d~e6vhK98WiJJcZ6ItJF7pEE_}KkASg8>xyFK$PWzC^)|Y7p*8;&D9N9K3h7&*vfe!2mjQ6C>FI@P^#Q0Q2OXdDMPj;OJ zyz^c9yuR}L)Mh?MY^p0svef&@<#VtVa$9H(-ua`+C01)v12SM(>nTlAjem;#_4JrW zo_M-PX-kkfmfrdFWXzal`1(9pkmo12P&8JM_YlXJ97^(ppQ@6seR9%Gi=F5hO9D2^ zWQ{y&T-tMVeqQD32f8OL$(MQD&$1;VPOPOgcg^?brc8bYuyL1YIgS693$kZ zuEAf49L5E>3;#^Vyas>87ZDP45@nC>GD9P&g_SW2N^SahgF3BUWUZ+#)h&H#TV>(a z_xG67gXtzABhe@{IenI;TczL!QYzlF)SKnh3Y`w7Q6T0LrJGTkv>kN>Tfpv%QxQyJ z?fjE#w=h@?gOj!gARUuwI;0~r@1oMopf@v=gXeHon$ptJ&AUI?T8QB8bfwj`76H>9 zC)7H#l9ufekuvbTbjvbJiqj-AxEc7*aA=}#$MbVmzP!1V;EDz9P6Hf&%i5Fk*Ft(! zag@xl3|?li8IQpA`Gle?Yw%}c1|g$*-Gq-U;I2cR;+;8IxI79`2R}g&U`hc7DJ5nE zi?XLw#S>{+hD;U7y)(Pq$T0fNne@ku^ekhh3jF(yoHF=vzCt z)#@WZ9G{dSM;``z4*q42yGD)aRv(2QrpqaNK|Xky`8!TRxmX@E0`uN!9xjeTnD>A> zX^%R@7|tNHQjeL45j!$m=Hhf4SEA$&yv|ifxVH3Svn#_PzKUIQI`(QT8Pg7SWpr0( zDwJ7OU1{A1r)5~QpYT)`1$ZuVLRp-?X46zhLtTZ@SXtZPn7XM(A6GUZ^NlyKocX52 zs>78FU+J&cxN~i`T(_pa|CNQ6w^vRU7&YkpY&toM@DkD(35E1Gvex~EB$0?+5G8pn z^a&E^b^A)xSlsH!*E5*`s z-D3h%&nznfDVaWJ!-_F2OKYswqKWxaPAx7d-SF(rg$2L1e0tjAr`DHk$rCW# z22)RZO?RsJZ>8PoDx9m7m0+1gA6~_<^{=ci5KAGq3X)n@)w-1_RRNw>A@JEkx6^iO zAzX(Hs#e`HvQk|+T8CM&yw%H=tzNrg1*2_eZvd4>qn;Ci2|HV_o;`g66-Xa{@L@^o zhBH%8j|l`0Ipys7Rtfninp-S+mS98sm`~gB!}@M=G*9HEC z6J8fdWAiSBG`<(cqNRHY1;hR>I$jPZ%?}%YxQ}@6GaQNqa!~5FSQ2IAAQ8*NKmV6l zEfaIk@#GwiQt%K*B2!as7_eG(dRCT}yjN?2{`FXGR#v)tU_7H9XNv{ji46jQLH0Gm zilSqs1CW+Zf{%2U^hVtkUaM%;B?Oe}`Us@@Cb;9e0?ild<5LvnxvSQ1tM30~Z-qXi zExTW1;{3_Nwvq~=&EXVF ztwuFhnvhX5ZF@)W1ItQmDU`lyNKu$`$D(~^Cl3)W#s@KinA|9SbKI=`=y0k=4hYAe zQF0Wt|4|3hV0uTMW%iWPsotCeNYrVTE$9X1J+aS+QH}9kcc2O?sa+TDM43+xstVF$HBvw|sxRFN2PS?i;)YzQPvY z>j%%cpp zEJ+dih^;o*q?dpIy;Wjy@U2yLi6u$Y_-azM+SD4KCef2+6$q?Zp5LDdeGFRht-jg0 zY2CJgV?u*c$T%^u&^ISHt;dFUq4(G0Df*!w!O%dNO7-1}!WbHfFXX3Df$-SMi8&fg z&V76tJo%nEqsE3 z3`Zcg(Ka{*-7luGi_CJkTjBNOZ$JKsFDE`C=e`zNg{^rF>wG)x3z7$kSK)Q8(ed-B zhAfdB6v{C%gR_|{%cs7ux23lKwIzWm=|W7e69-*o3z|I1ZA;6`x}DHdSsvPhTXg!& zEuS6R|MT%yzTl`_EAaFlnm+GPhr_A}9bue!n~s%}Cu1Ll@Er;rN-5Nke^EDOJPMXt8~us7dUD$b z@x^iwr_GCB6AXvFm+un?A=KXtZ8?n{-%Rpw;IBZztM9>#^mwL^9ds!zN~z zNyOP6%oArL1Bp6>)u2lRmuzvN_dMBRNm({Im0HV_jPr0V&QWurH>LSTf*I$%_G6_E zpMv}oPiu6lkCImae{+1624u?uj&I0C>VmkeMn{CKI4Aflr5?0S@rKDK7N1 zBSj!C&m(6H`Sy&*APrW^7efo_MAia5KB|=lBS>I8_RmT?`7fEzad8G3e8xphycqgk z>5k9IgUW1sR+FU`d}BA@*9YiPfr0#nq0@(lP8NvD3#f6?UjG!18yBt#kIZ^_gO8p) zEBFWlH=&Np*He2Ai(Yeg78Dc7Kb*&h1`S9gi?ZfUaWV+ zd@DCcUCw$pw3qxXayev|>+!>v4)Ja*$}jNVz`G-0w8EAoD{^Z_O6H1T2A-Ubvj|)l z&BC^fgE5JL-BC2F zwOEt$#B6tGWzvd)s}hOPYO&6I35br~1B5TmU_cLVqRgQeLwBxt-7`y;UR+y@V|8B~ zoO*IzcIna+UAum0XW;w<^c)T3Nn$Tt1%#hL6~`uoLt%34Z*N1f^fg&UEFfMVVA8vQ zc>S}_X!!^ECJ|nzqcTLz^p5pMJkoCw4!tpc7!37CAB z<(JT}SoW*rRlMS z+>4H8FBJzZzQYoyoLYhIJZ&i#q>vvn#a!&3A(>3PMaTR>z($9*QaylHsNn1w zVEE*fSw4<4)X6wO`$rteU#l2T#c&WR1_-nDa1nxH zs4syt;*}2_eP>1&fH9UPcWr8E-QJhWW5yOQxM$LsRpZLdauc^cYuBN>s(1b8nFSmI zS$tCYE`ySn6ClJh9{PFr=C4n5vLr?&-rKNkVw%5q`iRo6a`^IXh0BZCe~f#wHXhQ3k1H>j_J#b$_lDAe!nj%-mGTg2i`{Z zEwmIblk>=boEc};s88~o6)Vm|Sylfrt+U93j0tcIbTBwN$t;KB8u~Y5Le`>l3+WkZ z#c8hemQ4MyLc8{tIghR^r01i_>Mh4&hP4~5TeIO9!l8K#E7ojex<3@9SrNsf^lAQr znVEQ+IZr##&NzX^N`wQSnTl-oViRr_N@6j}y@0$_I(V5ejp8NmaNI699Jt1q#El?+ zQ0P}CcWp+TlgAriW$!$6clB*>PtNFhWH9C^%^e06eo_4Mn=Pw)D2~F)8@ElMSOwcu z+#XQ$zDWN4nZ4w|^Rpp0+~M>Yc>nl@;vcv^=E2{HhA>Y=7{Yc77^tBxIoQ61_fPkY zJNnM-UF2Z*6oE2UpjL^zMI9McbE_Pd%Ec`&h!mhYbQJ%yK!b0LEtg+r;zd`_BnEAr7HSI}Lo+E!delPjk^HZlj54Yda z-aDqJr%%75_qDEllLCQB`?|3CzRnHzJ~wqlFO^qj(R+u`Q~uxx8$k}vzKu*p5qG8FxbAUQNyhe65B9${D;^;8s{6 zDU(1w`Fzyqt6s%=;P5~3)qL=&J#^$%>I@j_@f7O$X@{`}DR4t`n9Wch6Z>lwGs|qY zvY8d&12SRv`&$c2w!gRIwbwA2vur|kMo*E0`21RX(bD@TPC2u(n1a+o_a6Kw(@NzQ zWDcM5(BhOatXPI|88WFjNB9gHMSQSMG_0kdJ3GBK%ZPo!9X#9eSyyA%Fd!?5A;nrvjUQL z{n^gOzOlg$t%J%75J8!98S+z6Omq(>nx&o5CFfBnYjoWMl#6tn4N=Q@p8@IfLHgSF zO-VNvOf2~mcxuJ=4J*p0RQu&J9j~DAyB!Oj-cUNWbKx|BG0E&mH44O#>Uj||{V5X; zPORw5(f*~ktFhN)H_2qH%j(i5Zfl%)+?V{yZOKJ$HB*yP<_VJyX%|BNdmYm5jj|vA z8{yFICSHeL`nSfsiN$Z;oW`E+)aEQx*vbUUt0(8(NYteJe2V<$=>_j19Xc};`nW~O{!pwi8HA@}0qpf-C_`of+w?DHy6Rp#np>;~`+&BhbbqjU=aA$So;X?TY z=_(7K$Bv+D=yx-#M0-Rx_)p@6 zu)LLzm~iIEHSrU>$?EW2w??l7S;aW<*}!c>lN_-O_|(s6Io1UAxsP`_QLM;+?IfpBA+R6v0_1W@b%qFH_5NtC|z4cTUe&CS=*C z7=(JO-ry^=caDE9F1OCa(O@ceeE)v;u+}FjSU!ir{ zq73RhR?Js7F?HGP@;Cwu-48!WHeo4s6aC9>S2zbAqifut(efWc4eb?kbbsSfA!8qP z3WzOeYLv$1xi6fbzHe-NYVWSGWap_<-+%DIxuybLYMhe%6nv1{Ixn|uNsAZzCpzhy zN$ou}#@6up7rGIZl7;LCaOu*etEWz37x2m}XUP_D|5@YUDc>q5Tukp})F)G}I z-y~RU730Zdo_k7u`iX_Rxayon4Y87$jI#oG!p6`=og%UFGt3U@u+w)ooGqNizBd4 zL-As11pmzdjDUH@X*}#GD3TqN=DO;CX^7909+VXoJaAc^mts#*A96qD=Q?YAsI^Tf>-^(e(IkoDfYl_BTn6^@U&5Xl%{q7vqeF?fGTu z1F~FK=hdrqE}sN{UT;Gq2!wD1nzY1tnlu7KB!qLTVu*$GxI?&|RB)IY2W~2~K6r#4 zC9&{qBiuXhPLsj=b|JwJz!38=y?aFdGVcaJ6?U@fm)YOdPbUK zdGWH!kJf;zFv{ua!F}D`efAJqWO@nEB8PLiV&S-^QM~{n@!;qI8L_9r%Q^NxL23)gc zU<1YW^s`|+9_C4N)b(b@<7D1d`f9|N1CI?~8|F)9b{Kp2e_~1+X7xYrsd*8;bk!ta zI6?EJ1@dKzPUkD5_!16_uf!B)>mPF_qKd|b#Zdka@fvl8UmwXbrt$P{?9W1_6yVk< z{ILvhv*>RSMSlz3p5&y&L@#JHGikttE{Usk2ymWME#&G2`Q!6V zaaFTQ85~Adfv0I->5)HbZ^@PfiKeKkuP6OzX)D(*R3is4LPKzMd4@+AI!7%O>Htate{afaLfOzy?s z!z)A6>4%M1UbsN#$&u%%9y~J2d$>uT;4N3l`EP1%v9E|!v23;YjaaMt#WHdVID|j0 zm6B|Cb7Eq%8(fuX=sg1+8$wO@yRZ*sh4^o{Ex>lX{r1(j-@ftQV`6j=uds z33Y!0?(2HG4{@}tjX?df>5&3d+h!mo>f;QD8?|Qc#|(b#b6k_^Gtfhx`58J|A8}<5 zDy;uUp8YPo{dE#BQEcFoA3;w`41N`g$pkc+`=a8+__3?1B<1n?bzQ!z z{`BJt57hz%>}7C>mmdX|s--RH&ZTvHARvE3JsV#P^FRIx-CG3mF&#^yW5fuYbj}7u zqze&w6`N^BNq(X-=AE_?&2(3vW&{V9}4yga5x1o_o9nKH<8}eYwp4ney@qKKVP` z22G-xr6(r;7y2prOJTyNM9@h*Sd`+9(lVpPGB!3MY5$Mb;k3pP+Z2cH%$>P^q*Q*) zR=;X&!>j^bM4!_-NFOH7eSa}_UshWzE?yga#7d{~w zemmn#M5!W@N2pZDt58NC3-=ZpivRjYN&x)WpW*g+dPo3Jt%`oL#9_j}nqqTCNPq}E zjBf}6`N#H%H!&*sJ5utB8Q;KV-p`69-&1%sUIqCUi~YAhX?)_}L^>W%E4nO6(fo;` z9?P<}Izk^NBw%hwyDjt*K`6{*ouSZTDbj<7Eb;-AL7F@GE7UuPSKN_!Z@7EQ$m+Bx zU`e3Y1{%_)E|Y{h;wM5bp7zA%nxfSg=8d~&Q2~W3wVb4__ZdN)6 z3c1S{&R@m>{AIJ}E$0uQyuGpwPt8R=O3F7p4PM*2YuDDb>o#v*2VRRbbw+K0P#zzA z2205Ma4*#h4B1J;$`|*NdC$P7`93m|pythhEZi2xnU5n6QvQx5?C-$8H$x;C_JN*> zil7RhpX&N7;uQV%?g+m$;vs<;26>RErR}g=#ZGUjIBQ3_#jZA;nG@Ec>c4_+^6XDK zHPWJI6xJ`17JYYA&~#XviokCpwJD+vN-DwwX){M`;UTboltmg%3tSw+^V5jYB8`Hvf=lJ-}atO!KzFTYU=x z#m>B>rb!XYD9@N|k=#g8ZkA7CTHY}q>7Kz~nRd9>0;6JxH>#kK51Yx31cV#5PDs0% zVoEO>e!`1}9w`-D{PqTI6&gG0$x`xr@CxG}kT%x{+Oom0S{X?b<4wlUL+nipE1T$z zHj<3V5e0PP;2#BCVwjys%ca0%i z_#zks*U^$+iR81R9&Z0iTcR-0X22#&yai43#zi1OeUQ7LNsrAS7iBrzHot* zbXHFs8=3InU`)y26?_)lk66ry)ckQMAAcsOGnAXk$D7$GKbuNs*Sn+6l>T~CgJq;N zyp`#K>S&;iR?K(^^;rStp=ON#rJH3Cy5PlRN2Fb&Hp95!396^%oOust)}x-5X4KQN zx5SxH(VLbTkL|N^W$W zUt`*1)e51>ky6l-jxxfMTb7irb?BM=gy|*FHvN-C$WbQb#F6iClU$I*c{Aom62M-X zF}Vp&K&&>X#VGx&@8rrx3AS5jozd2Z;A#;PC{Y#8>k$w2_Kcjx#(9s!>@3~G$h_K{C-r9# zm_QHA_)2mzIOsHzXOa^t%CQQe&Z!#6H|KbD&ph*t)37*g?&r4RhNdA*Rl4NPa)izb!TVxO+%RIGV&S#4Pte2d}U?;CLJ;X}e;EyDJPu@e#wq zZ5<9un#CiLPj7{F8WB-gZPlC#+n)U!HthTJrrd=3MOB(a2}r$CZ2DasA6G?QVRo}+ zBC*w#YDw{@kC`|oJ+WnVldHM9P!-_l6mm;^z-36#@-kZbS~BA5m)5uKb7TK@6pjtf zTu7R*hq7lL8e6`0YMoLTuM2%20B>s)p*I*O2L4aT6N-g)lhLX-`I`!JCRMr+Tv&%l zEQPv8t`V5+I#b%%Dg;TNl@!B5`z6*u?H3-^&qoi}V+_4#SXL$NC&6ta1d%sRU(jl& zTQ)FQW@;1RX8O0^?4)-P9nv=sHF2O{;XXMt;~T?i?R-8*FNl?K$OrX@4WBOLapi2j zp0oa}{#(o(tK)KYvAEp~gigbcJIK$Mlb2VLpYI^w0wVJ-afZ#a-m|7KYJju3&B>Eo&H~KBh$A)ZTMtN3==1I!kwr^J#@_oqKtwfgS$X%4kLppd}i^J zSmz6m{JpH2Tt`d^-9xW5qd}%26 zJCa2o7D!@WBndiPeyL=<^t0C^Cf7+*lA6gYufGoX%|Sibr4G8jBMVI?&`<8tCo8lX zOr=$X)?zDP!+JtTm=18=qz?TpUhx{wWuo;e9G7?&j*En%+%9LxDGe_~Lo@t#KZEM{ zMp+p+4+Xt|fGw2qJ|wS@A(ZfKR$U^ii220pgPV_UTCr&=SEG_Lr-uf>_O-{?u3S4+ zk;>}>3#oirJSK}g$KFNds1(MuBHl6p35$smc+BV+Zz$kG9g+rUMNV6J;X)tCRJ2DT z413Nj8oC*`;)(tM)1D>& zefQnuzn`1B7)u(vts9U9xuG?a?()^{dUesFcW!Uj+w=(0aQF2Exxu9Fo!z~g8f^B8 z*;S(Gg1rAEpDyG zEMZFY4!O*(6ECd{cv_2H!Hxwv`E#3+m2p9%t2W2(s_4z=HUwRos&rRFk&kZNXZfN|jPQuyiw+^>t}T( zw3@3L+dYjZS}N8|u8@E>@=7xHU<^U^<6ci;x(H$vsQWc4xXJ=fvs^ktTq|TqLqb1w zSZ@1=WjC$>0FdjtX0Ftchrv`{VnJJa7xw)s`046>^2QbSPwgVN!CzqPoHHwGCA;wX z0=v{2Gz9_SENvAIFyl#{noi}a+<4VPAT^E%xgO&HVI{f zDc8KcyL$Y2fF0!lo4!M`{k@tRafU@3%q{m!;L5pmE3y`8^u(Lo`gP}~b{|>MrUsWo z7wRhk*sFAYXIT5h_nYnnvCq$AFIPD(3dWbAJO`0cD`Q;01}u8Oq_P~SK5tM~Y!Az3 z8eU_3V^@Ep*Y0w^m@5WW%ru!@h8A!3*k4ar#ZE8(w zPDfFS45jN-{blvshZg5LEqg8B=yOe=+DxiZL~_aG%4v1!8i|Qh>zcl7WAWlA*A$j# zp0WV5rN~6iB($4M4FPjTg4zfzCHbndy4)$-t19Ov+E=7Yjl#y2OQnf{B3ENYd`i4j zuqL4-MVm48wy|C7lM_~yi;coQv~OzRzEM#7CS!Qt4BPiN+cRN%9!H>8O6t5P1kn+mqrR$8oy}4SBo0rSJ>WK_78Dnxnj95Vi)%KzukX5L-$ceLq3YTyksQkv z@C714u12raCe`HlI|`iwjZHq5BakR1R*Om}6-o`>a(_ZYt~1dFif__wk$u|87v{`8zoz)8XUy{I z>SZmSBiOd?2Ub;9u6m$5v;f;yzPQ=rXZODLd+HjaC5`i|$mHto-56&-}JERUnxOIrd=qXVi5=eNCBykoO2a8)FaP z#O-wM{9EYy@OQ$UosWdP_-y!b=q_{*G&a2d5H<}{FwlPlyYDXI_5qxxjT(Ol-v-Ya z=*Qk+-g|xGU3iGLmG+TyS;&W~AIhB%S7${BglN2la7zh1l7u&u5E_07RSD}KS$ltf zCVq8)f3R|_PXbD0N-nNzJh05Ye%ngt%sYDBrpk^Pg_|GoSbJtI$y)Nrf^;Bo6nAH2 zPb_l+fi|Nfzw1B}yR28eX72po4FPu8NGqY3(`Yb+ht2GPUK~ z-dKz8ADGs(syQK{c~uj7U9++^X~Pcu!x*ZEFmZ_S5anZ0buN-5jK<~*uCNUx4BeZjc2H?hTd7|*dZ#WLoeFsf}8Y3PpreACE4?S=@cwq#(!X<3k#}br~j(B&j9~Y^k3e;KYTCb5LLE%Y>bdYe=JW7zE6l zDXAQ0q}z^+R%-9Ydy}W!GiU12>A^tjoP~2*14t>=W~ik`?yyn{w#{2KuPxZo8lRh> zWOLb4IX=ZZudHx&Z&qO3#@g=9y(MX>*>&mNox`dqZ{E@IO^e&|0;zdTS;h4Vd$Lxd zSIXEjEe~N&d<qmewDMjqEOHI09zAU^#LK5`ic`IC)FCcuPKku&uj9@HR_X+ zgkqnRvSV8Ye_`}7u0i{+e7HtBjMoODj*ciE8Bv^%$_SBA3MWKjUq?`l&OV#cy$S1+ zDY&@0XmOXdrL9iaxS~CcpML4C{_l^sk3IQQ{~cHEYZZGMH$1b()HJrkky;cd0`Dg@ zEUl|uF~)uSzUB>MlNkpM$udGlFjp-fTR*0D=SvF~zp=jw8fe5l6P`V_Yf1+E zSuErkY7apFhp1&7r)o~9Ku|PaX95&uC2GlOIV>+6QTJ7%1yGEX7ZH5voM;qwrZ{2oho^J} zg@yW(7Ow=9q6IQG^v}^`WoN3#F0V3aGYhKS8a6q~HO(O2P7yzvz3NAt2erNWC|Ozuo| zW0%qTl#wU#UkDN1%h@^UqR!;$ z=pxHXyMuJJWz^XeVgm4cZg-rux4@oi77ERNEKi(jOHA@j+&@0KJUzkTP)IBWIq@PV zsiH4Gy|%bCDIwb_73Li5Y+Tu#kl3=mt>b6`i^UP^wb*%=+vOH%3__t%Edo`+`RSz( zPUt4TT?8H5DI z4sRuIZV)%p3(vEwQ|F zTxWS=u|H72k&Cf4riz5Pwn}ee_2lfl&f;XJ#o@L1@-+sHbq4Bu?rvOIo;fDhEQR28!lAvhwPzFN~8-oBK5!PgWPo4>zDUot8X=;0kx5tq?q1?mvpIXsz zY-w5f#wX{jeP(G!!px_4yL$r`w}uDKCbujqE}m8EO01fgM&8SC@gxeir^KsfxhLPh zynbB8x<{u>eQJ9{`+Yy`c?cwZzLLe@$wlGXgmd^aL$bp*&{KUq|z79=seYWjsbzuu=~JphC6L z)!}rx*f3z2SSF!_f?14$I1;~Ts8t5>Xy!c&cD%YWqrCt9ZL8lM)BNu0Z6EZPXRLf} z$NYOU(*!E9$l}gP*mT>S_tmZo0AXNl?R|IMwka{&Z4rr80){WWeD2HS)!WXH|9D|? zYkhs|0xjbDR8J zY;I^5*WWz1lwL13kE$ih{$J@uB^2S+Ll-a{qsac);$d%&BHNx+9Eg`}rO1}n_(MNZ z6*`wm;r~i}K`KT3*U42Hs?c~JHZ3v%N@mHS{jG$1f9z0}2aUTPm2`aT`~zlG8}6{Z z7lp@W#gnnD5|tw%;Jp0hsoQhQ)o^%mIl&|>MyXE9 z;g~Y&ynMBsA4B2!Rgvd76XBdKFOD<9Q|^eracgB z)$I8Cp4PTwU+>Vg1_SMyZC@U3`J1S5^#hY9Kd`DnWOg{s!iLqSCr>%OszGRWI>7t= z*PmM{b)_V`BrBe~zGwHqb1NjS6rW4B{JCq8{xMJ<%UH`}q%jFGb7QEU0CY=5^e6}) zNJWJ)LAq%P^<>f0aVq~%WmE|n-YJua{DnM%W>Y|mv zjENIxL@NLgQ%#;^0J?sSfu{TiXV-`)peCnIwZ^Mc#79W-vGEiTCpx8Os}(|{Bc-4< z9l>@ME;!nqUYKA~R5^`@nHZS<0^r~5Od3IwaQK{1$U@iu$4rEDyaN3N8rdw20Otq? zc99%G1@LrZ9F#yi;&mkLGlzZ55WRL^XUd zrrMh8)$@gXjhevP?y8&j(y9GL0&&Le9qqSgiUk>44jgL)k0ffzv&&yBv$Rf_l>rXI zcaP6|tJc~vZ^xMI);zaFW~K9T{>7*v_*6Y4as?8#LVfMH9ms2JId}eIly#))7 zjU(#`jO^^WYff%;HkF^DTsZTg%(fgOQ=pbWYjyA%v|D#l{riyKjE-WC(3?K&ksO|e z&((0Vu_vB0IN9qf{$8>^HqP)I_{&!qXNRHDo7`yF9{RUI2|VPTpqG44W{%`+FNJz* z5;cb955|y&QfTI}`gUIA2@E7k#Wgd z4j}8mLx8JIc9M|DlGK(0HxHaAD|zmM7Jp=oSTc&%tUsXD8bvHpmDGaKG~>UIqWO7! zeC$}7W;Uc5Sp6=OpgT4W63tI@klTOx1rv}5A>lhx>+}DZaE>-Pjw0NeDkE#*0*?U? z3=t1vWaMN#iJ_omYxopyC>K1s8~cqgq*1}E8@i!WdNk-9*;xd#32N}p!s0SJvP~#) zud6e4LVt&=Qe}4Jq{-8=GS%fh2$K_GmS&cE$9YPZwx^o&$K@FcwFw1o<%F5@=Z~Az z-WI4xwIkt~ma?hi-5pw+pgL9%D-agSavhpDnM7me6EQ-6QLT&0{Ijm9ESlHsjnx<& z7N}!seJSIoI62nh2?f5ETpLU2NYNFSM@P* zJb&erOXfXToX?fZq_&h|AF2kk7IbA=JVptt3u;n67Af|sC~g;slzJsq>$SSY&EauK z8>K`+j2P_13|KaGjvzPtF+=DImVNdtoqs@V#J*x4qq@W(JdshUoQzTLQC=6QQ#gJ4 z|Btut0BoyB8rJT6Pm(QLvaD*^lGSC)-LfS2-n*UNoVdkFNbijhLV6$xp(G&$2!s^U z$N@uFJ3AAbVN>JH zSG~)j2DhtiE`3}khGfR+T{gAvMmW;<5EBuXVO6QD83<-qtL-RF|7WmdH=@CdX!uI_ z9iqX8Ps#^c*n7G71M0r;1DXLTp2b9j5HA)MymuayobhExIN|m9@E_e{JMLIT_50M zv2w}iX`7?#7Ve$C{E6C(Fq2M|T0E|NY`ca%3EJZeE1J?LZl9KoP4_dJ%W`y*$c*hv z*sacvoH?uYIW6w0p7h3|o|=RrPkVH%&Y<(A?cAxeX(V}b_fPM5Xhn6D-Wijg(pv*h zCt0>^sp%?=^|-L?C}L-bR|*dcEQ}ql5@HF_(A>oPe#E|e5_`;BIJM}1nqxymNA>TV_JOBQvq3chb zxMKcf>iH|aPo*Be;`=1($Q9owTqS=R_3{*1y51c21`4^ejf6qh!G){*5f1oRg&k1~OWYB(cz}9X+Fb)`=>1@w#-LycL7Ddxuh$;Y^!R+Hp*mC8<% ztLf_2)e|x^C#-HAzP`=nYFj@%w=rF%N^i`~u1i%aQ|rJi&IknzM+sf7p%T{Pg!QN| zEnts>y-4TbqLJcTg)V%U4f=WhPldapW&34v_JSrM+ZdmnsMRKB#~ZT~H0*Jx8h5Ot zy%gU_He4^goKZchx`onFVMDdW@lNty$ciceFI z(%i}%BWbQDX$}h1Jf1|}2Ub0MKh;Fz9*~E3Qvy(egV91qX>&zdY%cV)9|1>sYepytya4|wb&uI+a+?QWP&z4or#cWI=AL_ z;HZurxjF4s33$e>Suw%wp0J{Z|E6y-Ycz(LC!>u?G4_HeCQ5RXswa%u2ySN0&YI5b zoUWRrq?)dr?9Lh|>~K$5URk+(yvH*he@}38V`Bjv4wq480R*+wMD%d`G8Jv(fW-W+EELn^B9LM&pCQ zR&g%5!lf8AmmN3mH?hAA9FH&`OlNQRJ;xXZ4?ALe`vcWV#+_ThN3RWujNYe};`yR4 zaE%xIhH;0K1#$wjMNVwR!tthqu|>06(__=i94U2$SsHphoY|1s+L5^S#v9tKnSIdzj;g zEaOZEYbR{$%xXV&@y(E3rq$ zw%;bo#O+q&rK}8CNYi>10c&Kl9W}ASLN32?7XKy%iQqydvKL)I3_eqcGTfb6o9#w% z#NQg`$PKD6CXf9!FRa)xqkf*vYsl8s|FV86i|#%!cgjB%{iH8LrAWG47hVtNSh|;QX;}a6J)O!Yj{ge-|NeNdNY7{oBi3Z&HwiaMhu-!{Ak!INd!ebs6r*FXzve z8_0*r4CM09!f+~K;6`P|Iqx*PZV7Mzj7VKq> z-yYBeZ>PFKE!bhx=vtM{Wtiy9HcKnK>l0e)O44I>zULXd9f}?9s!Z-eeCe`0F)=@_>+YHB9?7hZ)JI3_G&*ah zWnw2-onT;}Nlb7KO9r3!4lAhI3}ek1ox^u6s=jeycDPItXNptIozp#Do6u4+)hUrY zduK#z{We5PHtMHh)K5d_3C^(;_Koo&*vF0qTK3C}M~+Yy>H+rGlMk#ueR?(JdNpznkbdw>{5%GYmzU6Zf%Lu~@$*DfA2n)U zNbip&XEoT~71a-dSt(@wh@Ru|GkriqAB;-|~Lqcl>5N_2O6Qk*4Ds?>yS_oVC1diJnPIS^{qbLaO<1Z~vQ zG>$?q0Qjg|WbsjLXPB)r^( z+G`!1k9a8+2)y{@LKw`v3x4ZUf|ZGBnRYPUr-a|0JPFUp!y}>|_yA1p1U-L4`5#94 zca!`wK0nHe1Jl_ZHuuBuJ6x_$0j4Wcv>6HP?Fhp=o$U4x9uP}~lBfs&M(TeS(S8Kc zj{W=axsimixv3*Krv@LwYS`Q1tS)xR2T!3Yh~$zdK15}sAxC{h*M*kd*M(ZB9lcYi z9f59i@+8HaVxI?jr$8n91kZQy3H3DG9*8MTdJx=xio9DSc$Yej-r+ky+`W*~Z~8V- zmG6SEQ~3RO!7}Ot>Kn{&TNrSJ0dE-4gaK+a`yBi1O`wo{>qd|Ul2@~Dfr9HnKKsln zPzX|2p~vKv>|5+}cz$X@tJ*JVJ^H1==SrA{fomrDfaex!d+$`>)i^xHcn@CKc;by7 zhi2e2ss%V~;9eMv9=sCr_*Ml0?gX_ufjeh+pg;5B7x;vUo3Cu4^OcB9QQUOp9Xwr$ zTwan6EUc5)f+#6twrS*PI+ZYNlBq=#FI3g4g-NjuCYw$z3>zh%L=tG2L|v1q&eRYa zPiw%w$)DH6>L#1)o@br<sG-;SPQ!c#R;!HdGlkB z-Fy;Qo_p@bbLV(l7+^uGzrBGr?FMhLsbKGoq^{k9XQ3B@{__Tx0)NU@g2I&;M~%M+ z(1OSC9Vm^RbI}|yTqaAWi4oDL7B**w6Nj#on=?%-!lYp;ol(iSY?gF6nsQ_F3v;!^ z{@wpO5FuQMb}xVQD@2T}_Ba!~-UO#-RHECRnBXRM18A;=6)*;utKc`6xqITA7f)BF z=6hppc2aqY_HevGlb|>>&KL>K8=di+=A~O3dSIwwW4wp0(&KV zTulcm-yw2%QO&##FFAzPcr_wKm`DTa^$7|3*o1^<>YW)W35_G_)r!VZ4QTMDCNz#} zR4bc6RH8o4>5S7SK8oJekL1(Ug-eu;qv{jWQ92@f-Tu2^8&!q$E*bH6&7Ix{RY{6d zCGklv(Iz>o@W2&jFIFCcTAAGeI-RMBMyuYU5IIeqmNK`=Qr=n2#3+j-o(@x%OcSm~ z%#XHIcudxcF78EURZLR2Oe(X+trjL)?8@>3Skk zV=Qs`JL1%Q}ih06j(6i{g?+QmIU@(ko(B$_PaS*cMh& zr#l$8T-OzrTs|(_JFz;MDwXNxg;{m^l5m-b{ho@943pt|0f@ls;CI*_P2n0M^s*lN z_(IK#sS7w6!FpOwrKx06QA$;|Q&uifgiF;iMr~r!Yp=z{dgHzdSH{ZOc$1+L+}@Ku zx->y)bH%3!#d3w*o!m34FegbQu8GvCBClg?WhN$inoIB+mvgxm7_I0-1q@dL zC)D7P>u18H=i_s=#yJfgJOqsz~~H7FL$mltso# zA)@JKR2K$~R6TcN#iDY%@S>U_DyoWin~cr}m&PD=xZc)VA>#h6U?$=h` z6jlf(CA!8RO1C~RWyZh2Q%&#B>p}H(`hSN@P<@L6>*x@J3K8e8MX1D;#=k-?tbxE1 znk=B5)e-Lcj=Y+=@r7ZLQZ)6MbY1!%V^pt#S9Ge|wVeiwHd-o{2?!2uMmexqoj-N(l~LXSZkBUu82}Z(W1({yoBoRf<`TZa&4OAUkprCGuD9= zXlSX0GC(F>?D`WCeJ;r^lSvzDOG|4Tq%xU333Ro;I4sT}PMiDl+BN@~lNufuH{yBh zUkBka^LWsNWA_vhlSrY+k&0#3Ey;FSl&qn;w6wYb{jev4u8!wN#KncD&iT)pwLi~I z6C2`&y@>Qw2elf`$LAt65-j|=NGtUZSj&8cV9x|$-SmFwWfBnV*$`M2f~`TY=Yp_W z_zhs_90WsD@~|pu1rQS03w}Qj%cPdWY2=J%Uofv4(K3Ua(L5wzcvvY)S3_Wjf_aM( zY$Aaj4wlh?@{T32Bf;~XGL()x8#)>+qXMOCBCunAmWQ=aAHjO&T}0nY!SkXl$^a(_ zUqP@x2g@Bz>0zCaL9myD1()OVXVWrn6Hk-~y8F4Sz2WONG6_DtsHk-VD~)iC{(odn;Hshu?to9*S#UzkzEb zb`4+g1sn+=3y=VMX(;s=6J=!ve;8_0@7OuuXxyK z_9UzW_j0`AVc7`ZG$`SC#ly4+wwloQYOvf21e-`;ulaxDVYvu4o#cHzm>1()OVS}; z@i4nz3m1@dh*vz!37>(BnEiwY6nuv7<0jO{9b6yhVcpah&`VF|`gjnw2Em@?`Zy1( zfr)^o77_jhU{&xbASAFC$oU|KO+w{X(jO510UnkKpMcYtV_d)IVRa~7KBkX9TO{ZA z2sVzSJ0M_qSQg6LNMHy3EDuBP;CPbvA^*=jtQ4iIA+SS1d_@S>Mqr17$(N8ApTZs!_UD0y`G0M>7=*>lh{J2LYHHj)!f+Fx(GLU7PFmS$>{{Ff;L(jJWpP3jmvUk$Ny)sLbMnKVzyEN= zh(%+|%@N-Dn-0&u3$0{hFO2kMu@9lyo_bfQP93{?BuGwuKjP=!OKrK2eem&@)+ ziXAQNJ15ASrCl58?2c8nHLE6NXHQyHQ@g4o8$OFrH8&&V6)R_tFSRzWKS_-`F|Xo* zrjEs3>)FpYh2P80Thy|Nomsh~nSGagv!ru9&~FUC2i%O_fZHn2o1)sAI_X z?3iS3jgUg!LV1NZAs)mJWf>5({q|7a?8#e3kJ>spJA3lhQKPp^&OSG}t*xi0t!*+R zZra$Bm)EngscF+>@;!OpyvaTD=K1}XexP^Ka^`n59+NLUz?}zP`hht^%SG`V43Kjl z|9{vWu$cE*Z|N604qpz(YBKr{7OyckUO(27A0I~PY_`n!$Xjo{xCU%yo5~iBafOAi zK}#Z&CjlHk2A*g0Nd3^t2Np4}@bw#T7OMz^ltKT2d}EF?CdQd#H037gbV<3Nt+|M? z)7xU4*$9T;<(iDy&Y0d_b}rZ)C<4bALS?LB_Hk?dK0jt~&1v?>)2D&#G~DW&4Y%G6 zm->i*(+reeLqk4&kOHV#_QNvtKX{rg0Z(rPkF)&!wNdN>n1bdo?d5!uy5um0Hvv@! zeUM%}`4eZo*{N4VR97@HumAoP*X9-MeM}m2LJ&o45<>kRd%W_{?Qhch^1&9G1MI#b z%R4~Udm7Ulrl%*3+uY$Ekr6A_M@y~7y1IepoQlFd*A2h9+spez4)udvoCkj!wQXvi zLUkRYdhEnYcZOPiR*kJ1-RBpXv$tpOqdy%GOF$GPG?Y%x1HY-yWq;80R71&lxBS#z zp2V!FuIo;%Z!Evzo#hT1vwW?Ru!~Y9YA-`>K5)y8J#d}=lqJchQu7J+&y(y&%%ee zOT|`qt$WP4Ded#-&FYLvt4PUh^g1<$z6u1|1g(;sP4nx9FElCKc}4L#Jq@XqITOj1 zveGPX`JT!`yaT7V=mRwg8ua3`&tFKq9&8O2uCp!(?h6?PQ z`Q(O1du4mRqs6fz$qJSy)?}NKYP)lCy6cim-r5AP%$l^q(UO2;05-0FN>a1p;H0vp z-HlqIXt61g{h7&XnVMJLRbn)jbd~2#ZOLLlM51Z2NT_Y>URpNk;EEdVZVq)8(HKrv z`aw^ZecmlCaYEw3xcF9V0eCFbh6O;tB^(G zfc!xaMW~~5)W__70~;JRIAbFVTv-L4y!5Qh%#4i8+Y-DcX~yW~^$pjL$&i{oiF4A1 z%`GjR-I{hnVNB9`^YgtK6>yn1HMyuTCDqHmBTvgMvsKJ)N=j;)U12NBO_LYio;SJH z>8zcccN_5ufclUe(TROS<4$bi7(sEwB3`G31UZo5t4{E=BgI#)i222sov6)7*Jp=I zveH*cO4}EgV0T)M{94Pl#3s|1sn$DNwH^(SS_|{?j7c7Aa(s-~*f6)wmfAeM&^>-w zgX4awjLaQ~S0AA^!oKkE7Kq3b+A{q-n<1h^4uuJxDrr2TvOB70)j6`-RyDfDG!)0y zN5;!FW^1Z7v(!`OP21iAzNQwtvu_q9H_j|=SUt(3c4X?O$z^Jtx+KqC9+M1JoGfZU z<$sHKkc;c*GZ-AX$X z19p84)<142v$5yaDdOIGORrf8$NTp2HZkyHgfANJ9V!EXWbx%e;-T?lML7GfsJzTa zfK_hSu)EYI>a*)Ia#X&trVMzqB`3zLdWh&LpRr2?24QW$R?(23FRcAFozr0o(YqH! zlkwc4K&t>WeIWfGsr_EfuzAg+^M|#}pWiZXezWlY`OTw#tq`3Y);xcH^SpV@n7&<5 zK<$Rd0_PXIDA>!wW1O$Va%v0c5(>#VA=wo}v#SB(oid0PS;;Xnxm6*vt5BuH;f-}; z;>_vHtKuYm?)=Haw8E%pxiGC@=l(-YWG#nq!G{qpGehay(ZisPIZtlRa(CW@!7Fe4 zxB|)QIJ=#aL|QWpktO+7k6jU8&{jmRmPHH2CJQBxvnyRCF-iH>wB{Tm!8roqd<$C@ z0%7R&Ig1lGaQ%S_N{iYG;_IsOOCk*!R$&Cg*sO7CdL*zF4Nt3XEOjaEadKcZi-plL zLT3p*0X8zv354i@vmpZ|IXf-dhdJugCQ*_nf0 zXspTXPA*+5y%)a8>>>I#8Xm3?4+oaO9j8kM^PTaYx)f`nCrzn0?TpW^OSTqyQkf=G zQueqK3wEmGL_e(P2X2Q=h?nOHFHOWkWN2<;+AWIvhvX@^fNC^%bIxUW3+AATeh=DF zS&L9vPh71mn}x7ovnJMIry?S(8S#;&s4SbpP}o)klef%4jM;ISvZ8?8%CC`Tqq4pi zev8WTT%nf?!9hInT&DMcXNTgf(qO&}IdB`{czhqnO-@YPdeqncO!}Jf^1Y4cIk*vb zy4vde(#Uw!=_Cwov&CvaB<@9s=RA~$=;8P!2y~2luYT21c$djJu#>QJuSWj= zi5w7g(`Vq5%=qBBKDjzO{vI;_cF+K7K$X86;2CBgwznj^60X1+33Ci=9XYSca73cd zbRacMa>P(IpWcwtI3?GRZikj(75RT8H~%l%)#(48*~y$FIt|5$Y?MP`^D^Y4 zLC@4u z*++lF*YX8oq~FJgw+TxHa)AZSvQ>gHg6jm=3%1}D2O`(PEsO9-QVe(o1D;L)%kSyw zW!+__BaZBB#}RW`S6RO&pA$jM!AIc&^wxYNAv@cC#8lSx`$IzqgmRUFogX zUe=bK<#J_Zx0Tt2PJ20eLjSVc%I&@1guV;?%@*M&S5}rQ@Fwt^T6MWRi1#jby0~4q zLtsFw&@qAqf^C9_1+NRfL#?dFTQX7#t#gQXnpErn1&4y6G{B=FjvF-nm&gu<9d|ZY zA>}1MNbkjYQD4CeB%nfB&=0keM@M-9c3gyG1N3u~2t^9+ESQwuZ}|&wbQNsJ;UGUq zXc}A&B?3YRaV_B(6u@a3C1aG~(xgncR;d7LRdh;vno6r+;?(h@rY>SdDw!E>t=mUO+v zWtPXf>e8VjLMCQ}0O3NScZxGQ8Yop-j4nRY7$E}HQe}Wdl{HfzpfRZ((MbQMj^wFO zre~(Ba9(AMJ3xx>RXGUf%EYv!p)yUFmUN#Nmq{{4CH6Q6WMf_dsOpMf)oopgJjIGS-Ff-k$TD z=pTr0dMR29$6y5Zi#^|xq>s<`jnZ=kI!)%iYAqT#IjYVmtqg~>~-J{{QVZN<~Jv&)@A7dI~p8dN7FRh2JUCu zC0!GHCW+q==60?h?wZh2swwl2yK8nS+@o=P!tC3mwFlPQ5Q^Fny#jz%)5Olx;f3&A z!)W%cd@yBXgYdp{b)zr-Dy|q=F91Fkug|&kIEW}(hI=(4lOdmdYjnf8a}6WG6n3dt zJi6}Ox%!d#e&G^!2RI-cDd29RqBXMSDwdd6dtNf|qT3&RelwoC%^T0Zgv|pk$PEUx z49J4|b^$v>yh3<5;14vq5L#WCv;h(~ZV(6FLVCqOzn}$m8_#|Nq}#Ru={M&#*41r1 z_YHet+cx&XH)l82%_?7Z_^k^!t-A2m;pJuJOOL#DVbx9O_p)+$GfMw8m;P&#{wJKC z;EKErr8%;!ynNXaJ}>@_@Q}MvK^l>sJCHUvp_!gABrP1B!ox$AxQ(ZV)29RX{&D*T zqYn4&8V{V^smsv8e0kN~<;_>16z&V`I0ts1`5otWeg~R*@QPJ|!FovXeq0#d|M3)I zb40mIemR=yeD-{CxY=%%Rzdjlfh&+l-^u>aER_LCM5*2z>wARy6soV0o@8?Vg;pls zzUzk~joQPVt&zEdk^-{NYqwmsmH%yOO5A3t&3EA72qlZ#OC_t)vn1i!`t%HKVz%*@ z7zKPP#lik`g*t%UGU@$}hGFB~h0~i;ZFO@SjN+L1WUD91n3q>*WiMzv+SWU*sf_F@ zou;pDxg>&>I^bFgX%G$-uS{e0BozdLSL6AzFNTTea@C|B(#A!Fi)8tR^t6@<-D9M> zgqRqIUL}$iB+XLiwp>@;vTS%#U1NE*t#)Qj$=tE|65zQ)m8r2bB~e5qS~HUJa=`J_ zB5h)Pv^>@*i;I${m35b!(}&L~8QHDV&1lbeGJ-ilMK zqi0>Yf%@9VNjwXikP;ZMuO^G+zE&Xyk6yBabh&YTBdc!Np5`s{lxA8}t!9lpKC(Wx zxM7T|aaCKEqi$BU!>&5gSi*jErQx&P_f2w4xjU~!ty9b7)6kMr?U}T?p>$?rvgqb) zH@xB6=P3z4PxZOr6jBP}E*sk(hnkGwaLbn&PQyLHqoAr?CLC>ui((C~(1Wr}YS68*%h?Yf$;^uaG2sgKt}F8XA(c5M$KsoxVS@Wq zIT_bM)s?BEgS2sHWuy9WTZ%*gZ>x_$3QymaYEAz`*vrnk9eJLDELTBftkaN=&(Jcn zewv-uI=i%V?y$5ui5{~wW6bpp^~*ZC3l|siVe>ch@c(lj&_+R#88r z(iAO{is%hj>1=dA8SfFaUR}!fm!Fp#MxxlO%KY9fp(6I5{}T-WZ25ySm2wRnIBq#-d97PHvJ)u;SW+T2%$eYFbc0ti@3JdWBzkZIz?~(wYK23Dj4v$ zKg@~{UgQdDuwUQ*LhHCTw$O+FunxkmxmFha7YYfm{84VvL0(}U#YSTD4XveIBS$_S zq_bRl;hKl_5DE+&^FJ61PBfB7T&q@NyQT^XCtsV6(_3?`wZ59dGxfi3Q%P_RzZMPX z8mEHESJ8)j&DT5$TwOZ?3;rkLKU!cSQ33{QOw6_Q=9oeHQ?Kya+jXEa1^#$lm|$Hv z{i;?l`M=Y!uCZ~){{elgcgi(4^nas$fp7mHyF&YYVB}wuMs|(7QC)+6=F7R}>HX^3 z8l3lsJ4_!Bu>Lk&F#GEI+qG&6m(}d%UtP2N@|x6#RsR!}kG=DMY0CoJN+L#%p@Vmv z7ee1$Z)T`)H&`cu0!- zurCmt>>i-y@JtpgqHF1~+?~7ryP%UB*FDzLb7FmCtZQss$33C9 zsH|C_3%*Ug$k}%e#NZupKVnw;uvx{$v$41P*~P`PhNbV)BzO$*+#UCL?6V8rQN+D2 zLa)=(hRrGoyyd?U&6mEXccLlkckB~iZl=*la(Jw!JN$yLKbc$dCKQ5Prd*R$oOu7J zDO?=|yzMBc4b^m_`2Q89e{;V0y=76o6<0_tbx19G>OllgcD9t(Nu zXOwHhjZ5>3u3xngAz?l^^0++KsyL@ih(|aOA6x0Ylu~$65KE%1UCt7T_|w9}#Y7Zo^u54!ITS}d$& zpHf=m9(gNVsnIJZsZFZz?Xm8LOjli@D^_DvhVP8SPxbj(;u-8`@-Pr3jS@rF6CG=c z${bhaG}?^OaptIu2~|nxCwH%(K7;E0CTg2Ve2N^bpGjq+l)StXn zyXhXXKY{HEf_a0UsEIEIdqRS2^UZoo^hF1kmG>r1vSOckLNm2OoGP#gjv#&gD})XE zj)49zgl6~@f=jR^fr5BRBDdHv(l3<;jY9JNBYKmPJ$C~hPhuqDqNMDPA~`U!t2Uz% zS4Z!KKMUWxjO|B|lLKeNLB=VUYv1()O;f-fYP%~gVEPf~va5$`cQ#<@5yx42#0_}n z?N-jf&k^naC%)2!4Obz7{plV=Ln`9`1<_B}N&|yw$i*e;(yVH=HBE<02B%brngD)8 zoys>CH$_d2y&C+{E8OK*i=3BN^kwGY0N!%&t1*X~_l zGro31uHoe2t2ucf_lqw%SMYd`hVuo_{E6J%$w`WdNy;(dyF3xtFI>22785BV&fg`t z>?C0%{6$s zZxx*bX=c1s8S%1ADwE!DL*L&&OVrrxUoZ#AU>m->id#?wKs2b|!#+wa^0AX4MDO2b z_rp$s5!1i~LtsOTHzcTo*8}8?M5a}wq=e~GZHl7Fm3FenXcIn33+Zf!(r$=0 z8nVjmi4~c8y?PwyTQXHh!QaKjXl^-yNbw+UbACEY>CIG+?|y ze~eBu5AVGrIxB8Cy*bYO``$PcO8X030>@F_U~GhOzPl*znKL|{0yNg%MRa1fICezm zi2$6MF20V;jR_&}e0nXV5dMnbhXskC6u}=O@Fau>_a%$qcqktK^B6zDbIAW{2%aus z1e#-MzTDvm&fiO>??ChUeF%OM!OIc+9GR1sp}x9XWJL8<^v(0AqXcGr8#tJd8MSdi zoLO=H?Sw4l$<=X*O4cVb#>ITBkbke&ejFYBJ!?mMFQc-|y%eFy!mrazTk|xWIO8+tzX60!j0>?{nz% zzev)M19))f?I=kX`|g&`3qN*}G`%QItN#U(hFHnN)(c&C+|k9p^JB-BEggjJ<7_yb z?cc-QI~=SZ_T5Q1ZY^j|PH8Q)*$P`zlA8;xYtxbw($f=?)7ZbH)_V*FPkm}ity`~m z*QPi!Gab$h>=aON8@&jw71s8}35RRhr;dT2m?P}V;4fT#Z=)9m(-419aP7nFY48)h z5O{av_lVH7C~+`mJi-xqZ1-;P7xrbGe=B;wo_o*535V-hF{nnbQ+A`_P0FZdSJHR+ zpTMod;7gBatkHK}I=YzZsAOLNxx06Vq`_^2%TbXO|JaRQ6CCfbkyJ6_74fI0vZZ2k z7DNzL%zn+Dk4FDM22it0XWSJY8>b7qa}MV3b#yblT{xB8-5n$?z1R!>0bO#gsqao_ zvhLe^n9;#!?)wMdzhDe$ulwmFDnhtnXnYKC0PwLcDHLCl4y3ZHXM^R;H+@Kn@abk( z&jQO4&YS4jaJTSI9_IjAqrpB@w-~uB7$5r1{m%DKsAI;*Bl} z_WX=F5o`}P{LD8B{KlMM&)&V4w08pixo{nsA8jg&8{gt!=+D{8^S_;^Tj*CNAO0|h z-3%xCaa#Wj`g6Dnr?shUsO>dwmz@6m(lM0QdD;)v?4q21vS0J_QxE*B@Q}d5Wc%j` zK1AQSf(-)f&FrM$ApibJ{{2|;K2PxSfcJkD9!2n+E9B?iw+@lNgU&?xKSlE6alt{3 z3J@)zFcuKazdzIO{b=$&PjEi?{#oJY!S^}-34Hzq z>7PsPNCgGJ6}Xy7_BOCb$U#?>P4Z{Q=q)?(CCb=jl}VGA371)9nR+YwQ)%*qc#_lKZr1@27S0X z9z1VX2;O?9|vjFvj=JS!v|{9R}GxQ%||~WS(?V2 zC$es!U3nT(9ZjLCB$F{<=#u;C{(bBYIGXr9?(t)NIuIP676+~FcAk)D&@P&xYour`@m~EKnbb|Iv>CC=P zby^&!TVunp{fHJ3o=rJ_adPZq&^?lFVcXcB*fzT5(lNU9quyOqH!S(+BeEAFpc7FZ zE1rLm>g!TjNZ4@=z8%Yjz~)2hkl!Xckv*K59r5uenvJvL-6}Bcr*b3vhCDIhsTbyM zh-1y*bM2;uFH_IZUm1sGoSCpSL7HmxeeD6~b?Or%E6>ynd{HeWlPoicY`!o9Q;G>2+(f=Tl`uEloiIF$W z-tt&tL_POdm4M zVM-d3renx7N2#!oG$V$L6>^A@gru1{WSXPFm?Om~&3eA9?Ig`Zf;2u&S_q!o`83y& zG=~IXJk6evG#iFYbCgQw(~LuD6g+=_A!&{X^7M)&QS-JZ3r7fDcmeS0&1kr-$ zfcUO^f$W7@t_f@Qo}G5+%l%h{npf&!fY8kKcp-fygJ(zmGo#C(evI1NFXtps)A1v4!KTDiMx24hOgP z!NK0iz~UA~4mqvtJs$nI!BdwEBGn38;$ybbah}+ik3WW|q7z*sOPnH@>f01%PR?m7 zvkKWs9M4PHeRK{Tjb?2e7d&Kr5W?^N!4QaB$^f@Zmakg5Y}v|H%fb7`&g_n9#d%X7 zT2fN8=Bat}o?Kn+oqX$9g*8rYHz~9-31%{Q@W|nP`;H##bz$bZ+7d<08=jiK^HKTpyIcRk?^7o#n4cWjX+B<2P8X@THDwhW9UttiL?a?69q zkF#aC5AX5)$~;KqGaiW)qy_K(whQ|j^ZiQwf_*(gW1kbZ_c=4^X#cr z)6xsKw~yJ3!Q}0un>?K?=vyDkpwm`qAm?U*{{t7Dc0< z+MBz%!JQK%E;>+0{S~8)=GA1{GzQtuidw0zB`rW&pkkK`K#EM+5%%s}~?wF63w&{;yjWoL*fup)GS*o+)SMy*)1PVBW^p-Fnm9lqN~MLRUC?$%u8gC)7?Y zeib}%{Vi)&)J$z~tCVpOjG?+YyL;2H$q%};B~9bAM(tcOOr~p2?Z<1qOB$D1>AX>@ zNX$%}zc{1OqkpfnZ5S%dsN`bJHn0yOnSBCVt6!m?^oipkBf67HYZyht`?sZJ46csh z&L0nqn{pZmNsxDOj9O;2XO@o2Y2P!yxMJabhlW66CpI}4p zE&>|^W`Z1wK|K)7KfZ7R8wF+nFGVBR8Uza?ZIH^Yr?w*cN<#deaE&lT1XI_5wIA2B z9I1(udS-gaki6lEC5|f7KqpL~-x#%)w&kKRYSqNcsA=gXj;N}2ct~z;4iguKx?p-} z3_n0uG_~Hq4Nz`=u^`4cknW9^wWfgla=8cW8c_VM0a9qN6b$Gwc846q8cdJdOUJnb z8wFJb42hmhwhAPyj}bGxI1@`n;5}$fK*GTGG}#`gC))$drSdQeZxEC}%>Ek$1Q}qL zkhVl?6w$kgrx5~;pq5Bs4L=N3w!m+ph*1(x;;Fz9{7Vj}y>jdfi*pgowTK>g-1L%R z4^0|5%wCca=X^Ri?>##$UF19|mZp-#`SyXIZSwm|3_3_&3 zk?k2HR*y}qfJr(V{a{C@E~7R*nKo;qd)nNoBUT@=vQL5(%A{d;fRnL_3@ZSCcTQP% z)C?x1)EhFbs;Q$~HL2>XuB{WUPnsy8{EOJ*w3AjL86873=zw++uzdGmU&#&?6(Xuo zGayw$WpVRz8b_){YTX=XXKwb`A|#_5GLVc$+Jjh^s){VSZ~E{}-QI%PdpeoKk`bAx zA&_JyLOL8(4Qm$8kyu1GT1)bJzc(jGnv`3q<5)yLyJGG$TZX~R)|`0IeToy))K@7) zzx@a`N*$s*lbo*v_LNA2h*Y5}5B6CXN~l@`UP)g)wkj!#QAEk|;u4Ep4tbz&&|>-` z;8lo-TkQshY92o|{_$v8xHhFY@lL)^u&;r&ywdP$tcBCJA3|c~6BgTb)#GRI{faX20c$oSN>DL`b-JF#w;nQ!mgE&!#pUZU=j$ zvWFNis5N-shU_@0U3~@)b_ci({MP$rRMZzLS%h9IKWi0yImsQ)$7o1qQK+pthe6yWWPcYY#P_md1S{s4FGkMua~$7=9NJN#;hL;Zb&&+ri* zb{G80e;m!P0`5fA?htZbyc7t_gHpY;LlQ0t?}{+U4t?<@yDMBeC0r^EpAr!PutP3E z2fGuV@t?S6-y7`Cp?z<(vPa>Y{zLcPkT|f^`wtUB17=75--t3^o66GYM?6-vI7L zy^?}nf#CNuq&*j~cQak6f7;0T8a`qfplkEHG7hhWyk@%C3%)V+^0s`e zNKHnQsk$!R1Eg?2v+wt@aItTFfx0fs?6E5)k_L?|CR!gOxrN#1+XiQH>zk?UKjA-+ z+%*dp;QBM4(Hwj!yOa8r>}O2GJQJz~`v{#8=ph!t`Pd6Ce%UV%I@v*se0-W4ZAk#9 z?d9XW(u=g&4$eBt$9rfb1gUXmB3^tWq2HREJF(0LV7%`ZQl`rP1N=xh7L~c2-#`1C z;2G3@>GWnlgT^@}c&PX9+45WaUrMg%)HM7oEAFi9}o@gOXd-s?Zk?7=$-A^0f&`yw%dJsO0?(QEzq zTng1J2$Kp0{@V~k zei?HfuY5xI9N`yKl~ z!kqL?{u3mYYepZ8>GhuwMI)Fi0AuH~2mD!RYNkMy?>wLGFuU7-qyGi8*7`>f6q0SDe@c$W)ZDCAb z|6q3^*l`3?^|cAR(|-?|-_eNa>mTe<|8X=|Q$kH&8?*oP@4|bU%x6K^FZ3|f&k=4)p1bYj?a)Na>(G&cs%yak@IhgJsJ%K$zV0nZ4C6gb7U5CmzM#?A%!bTz3T?AGb zgf%1BdEvJRRuqIyL9`qsv=oP=8{xl`z)JhUxV$C7@%lX7DNqpl%7%cI_a7r9Z$+@a zXV|&^5B+%UT*FS`+K%k$y^Z<@j)8_PE|8*$MT?ty`$hII>^U$+n<#w@&wfUFskWZtK<9tuE?|>-1!uAozN-SH^9WJ<$IL&)b@x2Du5<1(^WIUamrE=wYHEuZlMfUO4&+?Uu zUw`OXE*-%y95PscpcCvPQ?V zt=vHt!0Y_}JXOdsPaixQXz=#2Tyt}2L-|St_!>sK*pbN8IMh+t9Y=wj<16(J`-W1d zQ^Lh#Srd4vatIuKZR5rCJ|VTMc^t`K5fs@ENTUb_-;b|>If8z44B0k(_Qn?p{foG~ zC*YF7`LItOlutwQJuVDmaK5hNgv+ymfr${}tXp?cxgmLnt*HwSlJD z_o#O{ddr9A@x4#%=Lg3FC2S2I8hlJwTuxL!9$NxTen9N87&9e+-T4HN@LWz|hv^+g z9rZ|wuM8fk7hD++AVeRG$S?%(=r0gf?PTB67&tW1-~d?FA5WmYgaI_9y-pg^0$4nM zBbD*(F%lfTZ=QiiLh?uUwUwo>u>zS}Pm|2~T-No}qy5Sb%oAKzzP+NwBxn0koHGl= z%ak~4+YWjm$y?Ho=k5T{?>@Vin^->0^gRt%3j%4c(68@fvK=LRJ?1-4c1;80}3jbPo?ao{H7aX7vpI40m0BRDSo z1h&C5gK@YAj4wR*@i+?3V;twu%*SDP@C5Z`Nd9o5bN7ub*3IV|ehTN~@(iPY5b!Yv zL;APK0r0&1%xX}{&8`ov2k~w$UFi6;py7vu5@RNR$o^?H=#iR~{EYlP`@wpUFNpwx zkbFE}Y+SyeXzOL)=koT6w=Y!XygtWo3J~(EWpiJV0bp(j-lSxEke+_=E912H>z7UW}{q+SRlmhw!5lVkV zUx15veSyfN0r|p06bANjoGGX>V3~yTVWnX=kx5sO`~7r=iV&3{Ad{{v_fbPm8q2=P z>lc@k`--4QLLGp;`zQ-EeFDj#fwRZ5rSPNrtLP4axsAgS&>c8"bt0}@AlIHaMn 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 literal 0 HcmV?d00001 diff --git a/docs/_static/css/fonts/lato-bold.woff2 b/docs/_static/css/fonts/lato-bold.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..bb195043cfc07fa52741c6144d7378b5ba8be4c5 GIT binary patch literal 184912 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

x{o9f|7gEmo2*wv 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 z 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≶M9Zv|5`G?V+t`dH%WEMXqpk;_3Hk#c)5bow}^>GHdOg=@5pYx=49b13Ly zrJynzDRebu8rnRSaDCBo@|9g53n?-Toj%;)7@=UY|Noy}Ma{<^CTZW`I9PGat{6t2 zaDw4J3oUfqrNwG{*q4kXjQO#)d%E?I`6unq0@g?R`EPa45Y|xpiRX?D^@^QqfPjrp z`1!tA9;wNGs_VH%HtUBo8*1_;v~g)avtfdTTKYQ+w|_T@R1|@!z4MWbhw@XQ#{r8n zFBZwGL~*S&Epds65DN=S9LDmC%OD``N?Ja3mq@-KYHmwkg<5GJXlu`C1U~hF;}GUt zEV_svDDRB0pxY;h0iVB6!+t9MoPjoUN2{tnNvmp71!_;3|F6OefCDX3EgVYSHa&Y~ zU}M_~aPglu-?Am;VW9ar%IVbGkq@`{Tq5wAt!;iU^4x0?c1udN{X&%ux4V&|KJ4W8 z^-G%6%-Mk6r|NGgPt?6Gz6|&!zRxhaV4(F`GZ8rK4j__!PX?Q7^;*CQ1mh5%DvR6C z?e!IxGMT8~xw^^9NiPO6=pQ@SRODn~Fsq8jD|VmScW#=CFmzog>dWa9ISWyD>bX6* zxnZ#2TwN0;af`pj^X|5h-UR+^#wtJ!B@tKiK!pf5VjK5!fZLt zzX!?qwZ#;g@k9fI%Zc#zkaZg@VAO57d!5O3Ue&0UhOx8iALeb!OI zRvYFgz{G^aMMxIXA9Q8%Ks(ns{Ng8LwsDMRXV9_!HbeTZg#-D*^A&&kWc>8s7s|rI z=ynSoO>Z_is~m>%blt}gX#It_>e2=$ntV|mjceXzzfgYM^uWLH4|qn@T1Vx$y+(mB zr_oTl_0pJ8ZR}4L)pN;gX0*r7gHMr7oprWF%6?*dA?da-61JtJNHWwP^#36TIN#Kl zHX65H`VqI9GB?_ee-?H!Yb?FpyYadu!+UaImNKBnpF_sZf6ay)B7}^R1hodXNP?eK z4UhCNG=>^Ra(w)t-DekO(;#W^pCZ0-I00f84I3?O?7O zB%x)J$UIIl{lRxlFHDbkes}4Xh27aeZ@lufb-e26$_f|NxU&YtVUJG#2x>BxrM_VU z1LCx!(BL?8gDF{Vq$J)xNc>yL)$=)7I*g|%)(&0-;j8CsUSvGa_^S6DVMpH zb8v0T>G{!ohHICj*>1fftNM+zZtws0KCZLv(IK>C_QT1EH@fD(8$2iPv~!>Y4cV!P zSZxtr!>L43HPE+4<>ftO;-5eywKK$aj&E__@NZF$Ub2O545&GURXRcHZf+@4Q*sxY zWp376swn?@b?YH5czxG41HZOjt)n5ymnfWVn}~l0v!W9f09Qb$zl@4>j!2BD$PIWy zG%tHq1co&qIS~ddbB3;u@9Dn~xdsYnr5s8^`W*i3m@VDEnOB&F?o#)Rs5v1eUah$w>#9 z(>0sd(bH1S1!0KMO_Fm9-(30B*tAvEi!I8bj@kN6Z10~`=5`eh*Oh@TSgc~GARo=W z<9@k$y19A1xpq3jbDRG4LD38!4XW&4?>FThiiaoIiVSTRo?|YzPPb-muv!>myEIOW zt#-bt4&U((ZdDWewL`sy(~|m2`BN@QF+Q{|G9ZCrd6ta$KC*E*TQ_G)_3NXw*H*CY zbEL^@$wN>XGaLNe4bu&0*GJMUg5zS=CN)LQyqHShcMq=mcw_4h9+%ozHC=V~`$%?N z`DWW#&TppMgR}4%!g!nK9J8-_y1Mk=F&oUrC@E68`W@5@I(HpHbiw(p1ld9~Keub^ z`qq-^lE(GMES@?`16xSt_yAA?b$A0;omip zd;&xiYAZP+=TTDO@|)ZHN*1!_{_wQ@i@zy5-UG{`HCbB7dqN5AgmRL@R~5 z-KAmZe7J3gow^U;9@e_R+QBj&j{H=={FCM3!&hwmwI9#NDh>OjBmRdo%0A!wRKaXY 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