huge 2.0.0

• Added explicit input routing for square symmetric observation matrices: R accepts input.type = "data" or "covariance", and Python accepts input_type="data" or "covariance"; the compatible default "auto" retains symmetry-based detection. RIC and StARS refits preserve resolved raw-data routing. TIGER now sends the original matrix and resolved flag directly to C++, where covariance validation, correlation construction, automatic lambda selection, and fitting use one native correlation matrix. For compatibility with existing glasso callers, auto-detected covariance input retains its historical diagonal-sensitive default lambda scale; explicit covariance routing uses the corrected off-diagonal scale.
• Python MB and TIGER now consume the core’s compressed column support directly instead of materializing and discarding an nlambda * d * d dense coefficient cube. The private native entries retain their default dense output for compatibility. RIC also limits its OpenMP team to the number of requested rotations, preventing idle workers from each allocating a d * d scratch matrix. R StARS uses at most two forked workers, limits huge’s native OpenMP code to one thread in each child, disables recursive mclapply, and retains the historical positional verbose argument.
• Repaired the standalone CMake package: it now finds and exports BLAS, installs the real public headers and package configuration, respects the OpenMP option at link time, and has static/shared installed-consumer smoke coverage. The R package now explicitly requests C++17. Its macOS OpenMP probe locates R, compiles C++ rather than C, and loads and executes a representative parallel loop before enabling OpenMP.
• Python release checks now install the generated source distribution outside the checkout, smoke-test native MB and TIGER, exercise compressed binding output on every published CPython ABI from 3.9 through 3.14, and test the installed standalone core on Linux and macOS. Unsupported Python source platforms fail with an explicit message instead of receiving Linux flags.
• Fixed huge.tiger() covariance input being interpreted by the native solver as d raw observations. TIGER now builds one correlation matrix in C++, derives its default lambda path there, and solves the correlation-domain square-root Lasso with full KKT certification. Raw data and cov(data) now produce the same path for the same lambda values. Generated paths stop with a warning at the longest certified prefix instead of returning unstable low-lambda iterates; uncertifiable user-supplied values raise an error.
• TIGER’s native automatic lambda path now reserves its 1e-3 fallback for identity and one-variable inputs. Weak nonzero correlations use their true maximum magnitude, preserving the established path scale in both R and Python while keeping lambda selection entirely in C++.
• TIGER’s C++ automatic lambda grid now handles an unrepresentable lambda_max * lambda_min_ratio in log space and saturates only values below the smallest positive double. Subnormal correlations or ratios no longer produce zero/NaN lambda paths or spurious certification failures.
• Explicit TIGER lambda paths now have one cross-language contract: values must be positive, finite, and non-increasing, with ties allowed. Automatic tied paths can therefore be replayed through R and Python, while increasing paths are rejected by both frontends and both native TIGER entries.
• Explicit path validation now matches method semantics across the public R and Python interfaces. MB and glasso require positive, finite, non-increasing paths with ties allowed. CT retains its independent-threshold contract: finite non-negative values, including zero, run in supplied order; StARS alone requires that path to be non-increasing.
• Explicit lambda inputs now accept only a numeric scalar (including a NumPy 0-D value) or a non-empty one-dimensional sequence. Multidimensional inputs fail closed instead of being flattened in R’s column-major order or Python’s row-major order; valid paths retain their method-specific rules.
• Direct native MB and glasso entries now validate non-empty, positive, finite, non-increasing lambda paths before allocating or solving. R native wrappers also reject mismatched matrix dimensions and path lengths, closing out-of-bounds reads; Python’s native CT threshold entry now rejects non-square matrices and invalid thresholds while preserving supplied order.
• Fixed huge() tiger method returning asymmetric icov matrices: the in-place symmetrization averaged against already-averaged entries.
• Fixed the shared glasso core returning numerically asymmetric precision and graph matrices at finite solver tolerance. Each component is now projected onto the symmetric matrices before it is returned or reused as a warm start; path, df, sparsity, and log-likelihood are derived from that same projected precision matrix in both R and Python. Half-scaled addition avoids overflow when averaging large finite precision entries. Scale-equilibrated Cholesky now computes the log-determinant and rejects non-positive-definite precision estimates without an absolute pivot cutoff. The shared core also rejects non-finite results and covariance/precision pairs whose inverse residual is too large before they can be reused as a warm start or returned through R or Python. Components whose symmetric projection loses inverse consistency receive one tighter solve before final certification.
• Fixed Python raw one-variable inputs being collapsed to a scalar correlation by NumPy. CT, MB, glasso, and TIGER now return well-formed 1 x 1 paths for valid single-variable observations. Raw inputs with only one observation or a constant column are rejected before an undefined sample correlation can reach a solver.
• Aligned Python covariance auto-detection with R’s machine-precision symmetry tolerance. Nearly symmetric square raw observations are no longer misrouted as covariance matrices. TIGER still constructs its correlation matrix and selects automatic lambda values in C++ after receiving the corrected raw/covariance flag.
• Fixed Python RIC selection changing at very small data scales. Standardizing for the rotation criterion now preserves every positive finite sample standard deviation instead of replacing values below 1e-12 with one.
• Fixed Python covariance-to-correlation conversion changing CT graphs under very small uniform rescalings. The conversion now uses the true positive diagonal, rejects non-positive diagonals and pairwise Cauchy–Schwarz violations, and clips only floating-point roundoff at the correlation bound. Covariance symmetrization also avoids overflowing on large finite entries.
• Fixed Python MB/glasso automatic lambda grids applying the 1e-3 zero-signal fallback to weak but nonzero correlations or covariances. TIGER automatic lambda selection remains entirely in C++.
• Fixed Python MB/glasso rejecting lambda_min_ratio = 1, despite the public (0, 1] contract. These automatic paths now retain the requested length as exact ties; explicit non-increasing MB/glasso paths may also contain ties so StARS can refit them, while increasing paths are still rejected.
• Fixed R huge.mb() and huge.tiger() dropping single-variable sparse paths to vectors. Their raw and covariance interfaces now return valid 1 x 1 paths with zero, finite sparsity; MB also constructs zero-edge sparse paths without invalid indices.
• Added shared R estimator input validation. CT, MB, glasso, and TIGER now reject non-matrix, empty, or non-finite input, and reject raw data with fewer than two observations or a constant column before correlation or solver code runs. Covariance input must also have a positive finite diagonal and satisfy pairwise Cauchy–Schwarz bounds, apart from 1e-8 correlation roundoff. Accepted near-symmetric covariance matrices are stably projected before CT, MB, or glasso uses them, preventing one-sided threshold graphs. TIGER still passes the original validated matrix to C++, where symmetric correlation construction and automatic lambda selection remain.
• Covariance validation for CT, MB, and TIGER now also requires the whole matrix to be positive semidefinite instead of checking only pairwise Cauchy–Schwarz bounds. Singular covariance matrices remain valid within a scale-aware roundoff tolerance. TIGER repeats this check in C++ before native correlation, automatic lambda selection, and fitting. Glasso still accepts indefinite pairwise covariance estimates, but returns them only when regularization produces a finite, positive-definite precision estimate and a certified covariance/precision pair.
• TIGER’s C++ covariance symmetrization no longer adds two large finite entries before scaling. Valid covariance matrices near the floating-point maximum now reach native correlation construction and lambda selection without intermediate overflow.
• TIGER covariance normalization now applies the larger inverse standard deviation first. Representable weak correlations between variables with extremely different variances no longer underflow to zero or trigger the native identity-matrix lambda fallback.
• Covariance projection in the R and Python frontends now preserves entries that are already exactly symmetric. In particular, the smallest positive subnormal diagonal is no longer halved to zero before validation.
• R covariance auto-detection and direct native TIGER covariance input now use the same per-entry, scale-aware symmetry tolerance as Python. Materially asymmetric matrices can no longer be routed as covariance input and then averaged into a different, apparently valid problem.
• Covariance symmetry tolerance in R, Python, and native TIGER is now measured on the implied-correlation scale. Raw/covariance routing therefore remains stable across representable finite uniform rescalings, so tiny square raw samples are no longer misclassified as covariance matrices. TIGER still constructs correlation matrices and selects automatic lambda values in C++.
• TIGER now power-of-two rescales and reference-centers raw columns in C++, using compensated sums before constructing their correlation matrix. Finite data from the smallest subnormal through the floating-point maximum no longer look constant or distort native automatic lambda selection.
• R and Python raw-correlation construction for correlation thresholding, MB, and graphical lasso now reference-centers and normalizes columns before forming correlations. It no longer overflows or underflows at extreme finite scales; R also clips correlation roundoff to its mathematical range.
• TIGER with StARS now fails fast with a clear message. Different subsamples can certify different prefixes of the supplied lambda grid; selection is unsafe until a common certified-prefix protocol is implemented. TIGER with RIC remains supported. R StARS also rejects single-variable paths, for which its variability denominator has no edge pairs.
• Python huge_generator().sigmahat now matches R’s empirical correlation matrix, and rejects n = 1 where sample correlation is undefined.
• huge.roc() and Python huge_roc() now reject truth matrices containing only edges or only non-edges, for which ROC/AUC is undefined.
• Python source and wheel distributions now include the GPL-2.0-only license; missing native build dependencies cause a build failure rather than a silently unusable pure-Python wheel.
• Python release publishing is now gated on the full parity suite, artifact content checks, a clean wheel install, and the declared minimum dependency versions.
• Python path sparsity and EBIC edge counting no longer densify every graph along the regularization path.
• Python StARS now streams completed subsample paths into its frequency counts and accumulates sparse coordinates without dense per-graph temporaries. Counts use the smallest safe unsigned integer type for rep_num (normally one byte instead of eight), then convert one lambda layer at a time for the unchanged variability calculation. CT and MB additionally store only the condensed upper triangle; glasso retains both directions for compatibility with previously created or caller-constructed paths. StARS now rejects inputs with fewer than two variables, for which its variability denominator is zero. Python StARS also rejects a subsample ratio whose floored size is below two, rather than silently increasing the requested subsample.
• R StARS now merges each serial subsample path immediately instead of retaining every replication until all fits finish; parallel execution is unchanged.
• R StARS now rejects increasing or unordered lambda paths before subsampling; its first-threshold-crossing rule assumes a non-increasing regularization path. Tied CT thresholds remain supported, and RIC/EBIC are unchanged.
• Python numeric inputs now use strict finite-scalar validation; explicit lambda paths ignore inactive grid controls, CT accepts a zero threshold, and small-dimensional generator defaults cap edge probabilities at one.
• Python ROC, inference, and plotting now reject non-finite secondary matrices and report non-numeric conversion failures consistently.
• Python inference now rejects fewer than two observations, constant columns, non-positive precision diagonals, and numerically non-finite edge p-values. Gaussian inference supports the valid one-variable boundary with the same finite result as R; nonparanormal inference requires at least two variables.
• R inference now applies the same fail-fast data, dimension, precision diagonal, and finite edge-p-value contract. It preserves Gaussian one-variable inference and legal nonparanormal score-test diagonal NaNs, and handles finite rank differences near floating-point limits safely.
• R huge.generator() now rejects invalid n, d, and graph names before printing or consuming random numbers. Empirical correlation requires at least two generated observations.
• R huge.generator() now supports the one-variable boundary for every graph type with zero sparsity, and band graphs support bandwidth d - 1 without dimension-dropping errors.
• R huge.generator() now validates active v, u, g, and prob values before printing or consuming random numbers. Graph-inactive g and prob arguments are ignored, and oversized group counts no longer allocate empty groups.
• R huge.generator() now requires scalar, non-missing logical values for vis and verbose, rejecting invalid flags before output, plotting, or RNG consumption.
• R huge.generator(vis = TRUE) now restores the caller’s graphics parameters after visualization, including when plotting exits with an error.
• R plot.huge() and huge.plot() now restore dependent graphics parameters, including custom figure, plot, and outer regions, in a stable order. EPS output closes its own device on exit and reliably returns to the original caller when multiple graphics devices are open.
• Remaining R plotting entry points (plot.sim(), plot.select(), huge.roc(), and plot.roc()) now use the same dependency-aware graphics-state restoration.
• Python Gaussian inference now ignores its nonparanormal-only method option, and non-EPS plotting ignores inactive output-file arguments.
• Fixed huge.select() RIC criterion scale-dependence: the rotation criterion saw unstandardized data while the lambda path is defined on the correlation scale, so rescaling the input silently changed the selected graph. The Python interface now also preserves R’s empty-graph boundary, including single-variable and exactly uncorrelated inputs, instead of passing a zero lambda back to solvers that require a positive value. Also fixed the R shortcut, which compared against max(cor(data)) (always 1), and made single-variable RIC report zero rather than NaN sparsity.
• Fixed huge.npn(npn.func = "skeptic") erroring on input with row names (n-length row names were assigned to the d x d output); the skeptic correlation matrix now carries variable names on both dimensions.
• Fixed Python nonparanormal skeptic estimation for one- and two-variable input. It now uses a standardized rank crossproduct, preserves the valid nonconstant 1 x 1 boundary, and rejects fewer than two observations or undefined correlations caused by a constant column.
• Solvers now warn when an iteration budget is exhausted instead of silently returning partially converged estimates (new hit_max_iter channel from the shared C++ core).
• Added huge.select(..., num.cores = k): StARS subsamplings can now fit in parallel via parallel::mclapply. The R interface starts at most two forked workers, limits huge’s package-owned OpenMP regions to one thread in each child, and returns results identical to the serial path. External BLAS thread settings remain controlled by the R installation. New Imports: parallel.
• Speedups: RIC selection now uses BLAS matrix products (about 10-20x); mb adds a sequential strong screening rule with full KKT certification (about 1.2x, and estimates now satisfy exact KKT); glasso updates covariance columns over the active set only (about 1.15x) and avoids strided memory access in its log-likelihood computation.
• Speedups in the R layer: correlation matrices are computed via BLAS crossprod (about 40x for the correlation step; huge(method = "ct") about 2x end to end), the nonparanormal skeptic uses rank crossproducts (about 5x), huge.roc uses precomputed edge masks (about 3x), and huge.generator uses symmetric eigenvalue computation and Cholesky-based inversion (about 1.6x at d = 2000).
• Reduced memory: mb/tiger graph symmetrization and StARS variability now stay in sparse matrices instead of densifying d x d intermediates. R and Python glasso adapters derive graph support from precision matrices instead of retaining a duplicate dense native path; Python CT converts native thresholds one lambda at a time.
• Fixed graphics parameter leaks in plot.huge, plot.select, plot.roc, huge.roc, and huge.plot (par is now restored on exit).
• Removed the unused maxdf argument from internal C++ wrappers.
• Documentation fixes: corrected dimension notations, the ct nlambda default (20, not 30), the scr description in huge.glasso, and several typos.
• Added an automated check that the C++ core copies shared with the pyhuge Python package remain identical (tools/check_core_mirrors.sh, CI).

huge 1.6

• Fixed huge.roc() F1 score: precision was computed from rates instead of counts, inflating F1 in sparse graphs (TP rate and FP rate were correct; only F1 was affected).
• Fixed huge.select() missing support for tiger method (no default criterion, RIC/StARS refit, or opt.icov extraction).
• Fixed C++ performance regression for glasso (3-4x) and tiger (7x) vs 1.4: replaced scalar loops with BLAS ddot calls, precomputed column norms, and reverted glasso screening to proven basic method.
• Fixed plot.sim() graphics parameter leak (par() shadowing and missing on.exit() restore).
• Fixed ebic.score field naming mismatch in documentation.
• Fixed scr parameter documentation (incorrectly stated MB not supported).
• Fixed align parameter documentation in plot.huge (logically inverted).
• Removed dead fit$rss matrix from huge.mb() and huge.tiger().
• Added CI workflow for R CMD check on Linux and Windows.

huge 1.5

• BLAS acceleration for graphical lasso and TIGER solvers (2-3x speedup at d >= 200).
• Added strong screening rule for graphical lasso.
• Removed RcppEigen dependency; the package now uses lightweight C++ headers with direct BLAS calls.
• Added testthat test suite.
• Added TIGER to DESCRIPTION text.
• Fixed Makevars.win BLAS linking.
• Fixed nonparanormal transform (huge.npn) rownames bug.
• Fixed documentation typos and parameter reference errors.