Made Linux CUDA discovery robust to toolkit root and
targets/* layouts, added compile-and-link validation for
CUDA Runtime, cuBLAS, cuSOLVER, and cuRAND, and added strict and
diagnostic-only build modes. The new cuda_info() function
distinguishes functional, unavailable, and diagnostic-only CUDA
installations without silently falling back to CPU.
Made latent-space linear discriminant analysis
(classifier = "lda") the default classification head for
direct fitting, single cross-validation, and nested cross-validation.
Response-score argmax remains available through
classifier = "argmax".
Added binary AUROC selection to single and nested cross-validation. AUROC is calculated from pooled held-out continuous class scores, including explicit constant scores from single-class training folds. CV results now report degenerate inner folds, constant-class fallback use, minimum positive and negative training counts, component-selection informativeness, and non-estimable outer discrimination folds.
Removed backend = "auto". Backend resolution now
consistently follows an explicit function argument, the session
backend option, the FASTPLS_BACKEND
environment variable, and finally the CPU default.
Direct PLS-LDA fits now retain every requested component position
when the estimable rank is smaller than the requested path. CPU, float32
CPU/Metal, and resident CUDA prediction evaluate each effective prefix
once and repeat the last estimable labels and discriminant scores for
capped positions. Fitted objects expose aligned
requested_ncomp and effective_ncomp
paths.
Added optional return_splits = TRUE output to
pls.single.cv() and pls.double.cv(). The
returned split_index matrix records sample-level
training/test membership for every single, outer, and inner fold while
the default avoids the additional allocation.
Removed the hidden fit_data attribute from single
and nested cross-validation results. CV outputs no longer retain copies
of the training predictors or responses; final models are refitted
explicitly with the original data and the returned
tuning_config and best_parameters.
Direct SIMPLS-family regression fits now retain the complete
requested component path when fewer response-associated directions are
estimable. Constant-response fits return an intercept-only model with
zero coefficients, mean predictions, NA response-variance
metrics, and explicit effective component diagnostics.
Extended fastPLS_blas() to report the
numerical-library version, configuration, selected CPU core, parallel
runtime, thread count, and resolved library path when available. The
former scalar backend name remains available through
fastPLS_blas(details = FALSE).
Reduced single and nested cross-validation overhead without changing their public arguments or statistical procedure. Classification folds now reuse label sufficient statistics, large LDA score paths use compiled matrix multiplication, fold metrics are accumulated while predictions are resident, and training indices are materialized only for routes that require them.
Accelerated OPLS single and nested cross-validation with task-aware compiled routes. OpenBLAS classification uses direct compact class products, while regression and eligible accelerator routes reuse fold sufficient statistics and predictor moments. The public fold assignments, component path, predictions, metrics, and API are unchanged.
Routed CUDA PLS-SVD and linear kernel-PLS cross-validation through the same resident compiled workflow used by CUDA SIMPLS, avoiding repeated fold-level transfers without changing the requested family or kernel.
Removed the Biobase and BiocStyle dependencies. The vignettes use
base R example data and the standard
rmarkdown::html_vignette format.
Added a dedicated installation vignette with platform-specific source-build instructions for macOS, Ubuntu/Debian, Fedora, Windows x86-64, Windows ARM64, CUDA, Metal, OpenBLAS, capability verification, and troubleshooting.
Made Windows OpenBLAS discovery target-architecture aware. ARM64 builds no longer select x86-64 Rtools archives and instead use a matching ARM64 OpenBLAS or the R-supplied BLAS/LAPACK fallback. CUDA x86-64 libraries are likewise excluded from Windows ARM64 builds.
Made the sufficient-statistics cross-validation parity test robust to harmless last-digit differences in floating-point reductions across BLAS implementations.
Added standard roxygen version metadata and corrected source and
vignette formatting reported by BiocCheck().
Corrected the installation guide to describe OpenBLAS as an optional, recommended CPU library on Linux and Windows, including explicit controls for requiring it or selecting the R-supplied BLAS/LAPACK libraries.
Fixed portable Windows float32 rSVD by routing QR and reduced SVD
through the compiled float32 core rather than unsupported base-R
coercion of float32 S4 matrices.
Fixed compact float32 LDA prediction on portable Windows builds
so both native bit matrices and float32 S4 coefficient
storage are accepted.
Reduced temporary score and response materialization in label-aware PLS-SVD, SIMPLS, OPLS, and kernel-PLS classification paths while preserving public predictions and requested component prefixes.
Added persistent operation-level workspaces and reduced synchronization for eligible Metal matrix-product sequences without changing the documented CPU/Metal operation split.
Reduced synchronization in the float32 Metal implicit
cross-covariance transpose operator. Consecutive X V and
Y^T (X V) products now share one command buffer and
persistent per-fit matrix workspaces, with one wait before the existing
CPU response-centering correction. The general synchronous
matrix-product interface and the mathematical CPU/Metal operation split
are unchanged.
Replaced the repository README with a focused installation guide for macOS, Windows, Ubuntu, and Fedora. The guide documents platform toolchains, OpenBLAS installation and verification, Apple Accelerate and Metal defaults, and explicit accelerator failure behavior.
Audited the public API, vignette, and reference documentation
after the CV selection update. Corrected the vignette to distinguish
fitted-response R2Y from held-out Q2Y and
removed avoidable condition-message diagnostics reported by
BiocCheck().
Fixed Unix and Windows configuration so
FASTPLS_USE_OPENBLAS=1 accepts a detected OpenBLAS
installation instead of incorrectly treating the value as invalid.
Forced installations still fail clearly when OpenBLAS is
absent.
Made cross-validation selection names explicit and task safe.
R2Y, Q2Y, and RMSD now use the
same public spelling as the PLS outputs; ambiguous "r2" and
"q2" inputs are rejected. Selecting R2Y
automatically enables the fitted-response path, while Q2Y
remains fold-aware and predictive. Task-incompatible choices now fail
before fitting.
Extended selection to task-appropriate
evaluate() metrics. Classification supports lift accuracy,
macro precision/recall/F1, and kappa in addition to accuracy and
balanced accuracy. Regression supports MAE, MAPE, RPD, and Pearson or
Spearman correlation in addition to Q2Y and RMSD; this includes
aggregate selection for large multivariate responses such as NMR. Signed
bias and signed mean relative error remain evaluation outputs but are
not exposed as one-sided tuning criteria.
Renamed the public cross-validation tuning argument from
selection_metric to the shorter selection in
pls.single.cv() and pls.double.cv(). Returned
audit fields selection_metric and
selection_metrics are unchanged.
Simplified evaluate() by removing task
and top_k. The task is now always inferred from the
observed and predicted values, ranked depth is inferred from score or
ranked-label columns, and complete predict() results can be
evaluated directly. Multi-component prediction results return a metric
row and a complete evaluation for each component count.
predict() now passes its predictions through
evaluate() whenever Ytest is supplied. The
complete component-wise evaluation is returned in metrics
consistently across CPU, CUDA, Metal, float32, and float64
routes.
Standardized CPU parallelism as n.cores. The
explicit argument is available in pls(),
pls.single.cv(), pls.double.cv(),
fastsvd(), predict(), and
fastcor() and takes precedence over the session-wide
options(n.cores = ...) value. Nested CV, refitting,
permutation, and prediction paths retain the resolved request; CUDA and
Metal device parallelism remains controlled by their native
runtimes.
Simplified ranked classification prediction to one
top argument. Its default is NULL, which
returns one predicted class per sample; a positive integer requests that
many ranked classes. The redundant top5 and inactive
flash.block_size arguments were removed, and regression
prediction now warns when top is supplied.
Aligned float64 and float32 ranked prediction so both use bounded
row blocks and retain only the requested ranks unless
raw_scores = TRUE.
Removed the redundant method argument from
fastsvd(). The function now selects native rSVD directly
and automatically preserves float64 execution for ordinary R matrices or
end-to-end float32 execution for float32 matrices.
Corrected the portable Windows float32 SVD dispatch so it no longer expects the retired solver argument.
Shortened the pls() reference details to practical
model, precision, backend, and diagnostic guidance; mathematical
derivations remain outside the function manual.
Removed the deprecated lda_ridge argument from all
public PLS functions and the obsolete xprod argument from
pls.single.cv(). LDA stabilization and matrix-free route
selection are now exclusively automatic.
fastPLS_backend() setter/getter.
Backends are now selected through an explicit backend =
argument or the session-wide options(backend = ...)
setting.Removed the redundant svd.method argument from
pls(), pls.single.cv(), and
pls.double.cv(). These functions now select the native rSVD
implementation automatically for the requested CPU, CUDA, or Metal
backend; rSVD accuracy controls remain available through
....
Removed the solver field from cross-validation tuning output and automatic refit calls. Calls that still supply the retired argument fail with a clear migration message rather than silently ignoring it.
Corrected nested-CV endpoint handling so explicit R2 and Q2
selection can no longer substitute for one another. An R2 permutation
test now uses the held-out R2 endpoint rather than descriptive training
R2Y.
Corrected nested-CV metric assembly so run-level and response-wise Q2 values retain their fold-training denominators. Single-CV metric paths are now named by component count consistently.
Synchronized the README, vignette, and reference manual with the current CPU, CUDA, and Metal cross-validation coordinators.
Made omitted prediction backends follow the same explicit argument, session option, environment variable, and CPU precedence as fitting functions.
Made OpenBLAS optional at installation so standard Bioconductor
Linux and Windows builders can use the BLAS/LAPACK supplied by R.
Automatic detection still prefers OpenBLAS, while
FASTPLS_USE_OPENBLAS=1 provides a fail-fast requirement for
benchmark builds. Added fastPLS_blas() to report whether
the package was compiled with Accelerate, OpenBLAS, or R
BLAS/LAPACK.
Removed unresolved float32 BLAS/LAPACK dependencies from fallback builds. Without Accelerate or OpenBLAS, float32 Gram, QR, eigenvalue, and SVD routes now use the package’s portable compiled numerical kernels.
Added a persistent float32 CUDA matrix workspace for compiled
cross-validation. Device buffers, the CUDA stream, and the cuBLAS handle
are reused across folds; strided padded matrices are transferred
correctly with two-dimensional copies. Sample-response Gram matrices use
direct cublasSsyrk and retain only the lower triangle when
that is all the downstream fold extractor consumes. The hybrid Metal
route evaluates this host-visible symmetric product with Accelerate
SYRK.
Added precision- and shape-aware CPU dispatch between GEMM and direct SSYRK/DSYRK self-products. Symmetric routes retain one triangle when the caller does not require a complete matrix, avoiding unnecessary mirroring.
Generalized bounded sample-response Gram reuse in wide-response SIMPLS cross-validation to all CPU platforms. The raw Gram matrix is computed once, each fold is recovered by principal-submatrix extraction and exact double centering, and centering/output workspaces are retained across folds. Wide gathered response matrices use aligned storage with 64-byte column padding.
Added direct OpenBLAS discovery on Linux and Windows, with
explicit FASTPLS_USE_OPENBLAS=1 fail-fast behavior for
controlled benchmark builds.
Reduced repeated setup in every compiled cross-validation backend. Eligible CPU and Metal classification folds now recover both SIMPLS and PLS-SVD predictor and class moments from bounded full-data sufficient statistics; PLS-SVD can assemble its latent Gram matrix without materializing the training-score matrix. CUDA now retains configured cuBLAS, cuSOLVER, cuRAND, and device-pointer handles across all folds in one CV call. The Metal route sends small reduced products to Accelerate while retaining large assigned sample-matrix products on Metal. Fold membership, fold-specific preprocessing, component requests, seeds, predictions, and selection semantics are unchanged.
Restored the fresh block randomized operator route for wide-response SIMPLS cross-validation when a bounded sample-response Gram matrix is not advantageous. Candidate blocks are generated from the current deflated operator and consumed through the existing sequential SIMPLS orthogonalization and deflation equations; no preceding component direction is reused.
Reduced multivariate-regression CV work without changing its folds or model fits. Large implicit PLS-SVD and SIMPLS routes now compute predictor and response marginal moments once and recover each training fold by subtracting its held-out contribution. Aggregate float32 CV metrics are calculated on the native out-of-fold predictions before conversion to R, including an exact four-pass float32 Spearman rank calculation. Contiguous prediction paths are transferred to R with bulk conversion rather than element-wise indexing.
Accelerated wide-response SIMPLS cross-validation on Apple Accelerate with a bounded sample-space response Gram matrix. When the arithmetic estimate predicts a gain, the native CV engine forms the response Gram matrix once, extracts and training-centers each fold submatrix, and reuses it throughout that fold’s sequential direction updates. This is algebraically equivalent to the implicit predictor-response products and leaves fold-specific preprocessing, seeds, component requests, and prediction semantics unchanged. OpenBLAS and CUDA retain their faster implicit or resident route.
Moved grouped fold construction, prediction evaluation, top-k
summaries, fastcor() and VIP trajectories into the
dependency-free C++ core. The R functions now validate inputs and format
native results. Fold construction retains the existing seeded
assignments while avoiding repeated scans of every sample for every
constraint group.
Removed the optional RhpcBLASctl dependency.
options(cores = n) now uses an internal compiled bridge to
configure loaded OpenBLAS, MKL, BLIS and OpenMP runtimes when they
expose thread-control functions, while retaining environment-based
requests for Apple Accelerate and other BLAS libraries.
Reused fold matrix allocations in the compiled cross-validation engine, including predictor, response, held-out, and predictor-Gram workspaces.
Made OpenBLAS the CPU numerical library on Linux and Windows.
Completed the MIT-licensed core migration by removing the remaining Rcpp, RcppArmadillo and Armadillo source boundaries, generated wrappers and superseded numerical implementations.
Made the dependency-free C++17 headers installable through the
standalone fastpls::core CMake target and verified them
from an external consumer. Platform BLAS/LAPACK, CUDA and Metal adapters
remain private to the R package and do not cross the core
interface.
Removed obsolete compiled routes and bundled third-party example datasets, retained strict registered native calls, and preserved CPU, CUDA and Metal behavior across PLS-SVD, SIMPLS, OPLS, kernel PLS and LDA tests.
Reused bounded full-data sufficient statistics in eligible SIMPLS classification cross-validation. Fold predictor Gram matrices and class predictor sums now provide the score moments required by LDA without materializing each training-fold score matrix; fold assignment, preprocessing, selected components and classifier semantics are unchanged.
Added a resident CUDA SIMPLS cross-validation route that uploads each task once and retains fold gathering, standardization, fitting, projection, prediction and metric reduction on the device. Unsupported accelerator configurations continue to fail explicitly rather than falling back to CPU.
Added resident CUDA PLS-SVD cross-validation for large multivariate regression responses. The automatic dispatcher retains the faster fold-local CUDA route for classification and smaller responses, while the resident route avoids repeated transfer of NMR-scale response matrices.
Corrected numerical-rank detection in the implicit PLS-SVD rSVD operator. The Gram-matrix shortcut now applies the squared singular-value tolerance and is accepted only when it supplies the requested retained rank; otherwise the implementation uses the direct reduced-SVD fallback.
Reused one fitted PLS response-score path when argmax and LDA are tuned together, and accumulated requested prediction prefixes in place on CPU and Metal to avoid rebuilding each prefix from the first component.
Prevented Linux BLAS symbol interposition from routing the standalone float32/float64 CPU matrix-product adapter through a slower BLAS than the OpenBLAS library selected at package configuration. The fixed CIFAR-100 performance gate retains identical predictions and restores the prior same-host runtime.
Corrected CUDA cross-validation dispatch for linear kernel PLS so that it reuses the intended direct SIMPLS route rather than entering the nonlinear kernel constructor.
Replaced six generated RcppArmadillo wrappers for double-precision CPU LDA fitting, sufficient-statistics fitting, projection and prediction with a hand-written R C-API boundary over the MIT core and optimized CPU GEMM.
Removed the superseded Rcpp projection and prediction implementations. Old and new boundaries return the same model fields and labels, while a representative BLAS-backed LDA workload retained its previous median time.
Consolidated double- and single-precision pooled-covariance LDA training in the dependency-free MIT C++17 core, including a sufficient-statistics entry point for compiled cross-validation.
Removed the superseded Armadillo LDA implementation and its duplicate test. Double-precision coefficients and discriminant scores agree with the former implementation to near machine precision, with identical predictions and deterministic regularization selection.
Migrated the internal CUDA matrix-product bridge from RcppArmadillo to a precision-aware C ABI over cuBLAS, preserving prediction behavior while removing the superseded Armadillo implementation.
Added a dependency-free, templated pooled-covariance LDA implementation to the MIT C++17 core and routed CPU float32 LDA through the direct R C-API. This removes the former Windows-specific LDA restriction, the Armadillo float32 implementation and two generated wrappers.
Made the CMake fastpls::core target independently
configurable, testable and installable without Armadillo, BLAS or
LAPACK. The current Armadillo-based model layer is now an explicitly
optional transitional target.
Added an installed-consumer test that compiles against only the
public dependency-free headers and fastpls::core, providing
a direct ABI and packaging gate for the future standalone
library.
Moved float64 kernel-matrix construction from the generated RcppArmadillo interface to the hand-written R C-API and dependency-free kernel core.
Added a narrow runtime BLAS adapter for double-precision matrix products, using Accelerate or OpenBLAS where configured and R’s portable BLAS ABI on other package builds. This preserves optimized kernel construction without exposing a BLAS implementation in the standalone core ABI.
Added a dependency-free, templated C++17 implementation of linear, polynomial and radial-basis kernel transformations and train/test kernel centering for the future standalone core.
Routed the transitional Armadillo kernel layer through the shared MIT core and moved float32 and float64 kernel-centering entry points to the hand-written R C-API bridge, removing four more generated Rcpp wrappers and the duplicated Windows implementation.
Preserved all kernel-PLS and OPLS tests and the fixed CIFAR-100 SIMPLS/rSVD accuracy and prediction checksum.
Migrated float32 argmax, top-rank selection, column operations and standardization from generated Rcpp/Armadillo adapters to the dependency-free C++17 core and hand-written R C-API bridge.
Moved label-aware scaled class cross-products and rSVD audit diagnostics into the dependency-free core, and removed their obsolete generated wrappers and duplicate implementations.
Preserved the fixed CIFAR-100 float32 SIMPLS/rSVD prediction checksum and accuracy while further reducing the transitional Rcpp interface.
Moved capability detection and Spearman correlation from generated Rcpp adapters to a small hand-written R C-API layer. R2 and dummy-response helpers now use dependency-free C++ or R implementations.
Added dependency-free C++17 statistics primitives and tests to the public core, and removed obsolete matrix-view fits, unused LDA helpers, and stale CUDA/Metal capability wrappers.
Preserved the tested SIMPLS/rSVD component path and CIFAR-100 predictions while reducing the transitional Rcpp interface by five native wrappers.
Introduced a dependency-free C++17 core interface with non-owning matrix views, owned buffers, reference matrix products, and label-aware response cross-products. The interface contains no R, Rcpp, RcppArmadillo, or Armadillo types and provides the ABI-neutral foundation for the ongoing standalone-core migration.
Routed the production float32 CPU matrix-product bridge through the new core interface while retaining Apple Accelerate, configured OpenBLAS, and the portable reference implementation as private execution details.
Removed four unreachable CUDA and Metal entry points and their generated R wrappers. CIFAR-100 predictions remain bit-for-bit stable after these changes, and the native CMake suite now tests both the independent core and the transitional Armadillo-based numerical layer.
Accelerated the float32 CPU sample-matrix products used by SIMPLS
and PLS-SVD through an explicitly configured OpenBLAS runtime on
supported Linux installations. The native kernels honor
OPENBLAS_NUM_THREADS, while macOS continues to use Apple’s
optimized Accelerate framework.
Added shape-appropriate reuse of predictor cross-products, batched score/loading geometry, deferred training-score materialization, and sufficient-statistics reuse in eligible cross-validation folds. These changes preserve requested component and fold semantics while reducing repeated dense products and allocations.
Extended numerical route diagnostics and platform tests for the optimized CPU, CUDA, and Metal paths.
Replaced the fully resident public Metal PLS route with the
faster fixed CPU/Metal operation split. backend = "metal"
now retains preprocessing, reduced decompositions, sequential component
updates, LDA and prediction on CPU while persistent Metal workspaces
execute all sample-matrix products: explicit cross-covariance formation,
fused score/loading geometry, and randomized range-finder products for
implicit cross-covariance operators. The public
metal_hybrid name was removed, and the assignment never
changes with dataset shape.
Added route validation, grouped cross-validation coverage, and
documentation for hybrid PLS-SVD, SIMPLS, OPLS, and kernel-PLS fitting.
Standalone fastsvd() remains restricted to its existing
backends.
Compacted fold-specific active labels before LDA fitting and mapped predictions back to the original factor levels. Cross-validation now remains defined when a rare class is absent from an inner training fold, while ordinary PLS-LDA drops unused factor levels before fitting.
Stabilized float32 CUDA and Metal rSVD power iterations with alternating orthonormalization of the left and right sketches. This keeps large class-sum cross-covariance calculations in single precision without the overflow and rank collapse caused by unnormalized repeated products.
Changed the automatic massive-cross-covariance SIMPLS-family rSVD profile from 10 oversampling directions and one power iteration to 12 directions and two iterations. Matched NMR tests across multiple seeds restored the stated prediction-agreement tolerance on CPU and Metal while retaining the fast fresh-start implementation; CUDA timing was unchanged.
Corrected rSVD control resolution so diagnostic qualification metadata is generated after shape-specific controls are selected and therefore always describes the settings that were executed.
Made the massive CUDA rank-one refresh execute the requested power-iteration count and report the same value. The automatic fast profile remains two iterations, so its execution path and benchmark workload are unchanged.
Enforced strict accelerator selection across public and native fitting, prediction, SVD, LDA, and cross-validation routes. Requests for unavailable CUDA or Metal backends now stop with an explicit error; CPU is never used as an implicit substitute.
Added independent CUDA and Metal regression tests for unavailable-backend handling, including PLS-SVD, SIMPLS, OPLS, kernel PLS, prediction, and single- and double-cross-validation entry points.
Strengthened automatic rSVD controls for SIMPLS, OPLS, and kernel PLS. Ordinary problems use 32 oversampling directions and five power iterations; high-response regression uses 48 and six; sparse many-class classification uses 64 and seven. Cross-covariances larger than 512 MiB retain the separate 10/1 massive-matrix fast path. Explicit user controls remain unchanged.
Kept backend selection strict: unavailable CUDA or Metal requests raise an informative error and are never silently executed on CPU.
Made fastPLS_backend() validate accelerator
availability when a session backend is set or retrieved, so an
unavailable CUDA or Metal choice fails immediately.
Made accelerator dispatch strict across fitting, prediction, SVD, LDA, and cross-validation. A selected CUDA or Metal backend now raises an informative error when unavailable instead of silently running the operation on CPU.
Restored the fast device-resident CUDA SIMPLS path for massive
predictor-response cross-covariance matrices, using a fresh rank-one
randomized start for every component and the 10/1 massive-matrix
profile. Ordinary accelerated SIMPLS-family routes used a 32/2 profile.
PLS-SVD and standalone fastsvd() use the more conservative
32/5 defaults across backends.
Removed obsolete benchmark and publication artifacts that were generated by earlier package versions. The retained publication workflow records the package version and exact solver controls for every result.
Unified randomized SIMPLS initialization across CPU, CUDA, and Metal. Every refresh now generates a new seeded random direction or sketch from the current deflated cross-covariance state.
Replaced the package-specific session option with
options(backend = ...). Explicit function arguments retain
precedence, followed by the session option,
FASTPLS_BACKEND, and the CPU default.
Added options(cores = n) CPU thread control. fastPLS
forwards the requested positive integer to common BLAS and OpenMP
runtimes; eligible matrix products can use those threads when supported
by the linked numerical library.
Added a CUDA-specific batched randomized direction refresh for dummy-coded classification. The route consumes at most eight candidates through the sequential orthogonalization path while retaining rank-one refresh for regression, CPU, and Metal execution.
Retained the faster resident Metal rank-one implementation after an alternative fused initializer was slower in matched CIFAR-100 testing.
Added explicit diagnostics for backend-specific direction batching and audited CPU, multithreaded-BLAS CPU, CUDA, and Metal execution separately.
Restored an explicitly approximate accelerated-SIMPLS profile with seeded, component-specific randomized directions generated from the current deflated cross-covariance state.
Added task-aware internal rSVD controls without adding public
arguments: oversampling 10 with two power iterations for classification
and one for numeric regression. Explicit controls supplied through
... still win.
Separated the accelerated profile from claims of deterministic de Jong estimator preservation in diagnostics and documentation.
Corrected the rSVD case audit so a near-tied retained/omitted singular-value boundary remains diagnostic rather than triggering repeated deterministic recovery. The singular-triplet residual tolerance is unchanged.
Batched the matrix-free left/right residual products and reused the computed retained-plus-one Ritz boundary, avoiding repeated full operator probes on very wide multivariate responses.
Added a near-tied-spectrum regression test and clarified Metal rSVD warning text.
Resolved the BiocCheck source-formatting notes by limiting package-facing lines to 80 characters and refactoring functions to at most 50 coding lines.
Fixed float32 single-cross-validation argument forwarding and completed the resident Metal SIMPLS model-assembly helpers.
Preserved the public PLS, cross-validation, metric, and permutation contracts. The complete package test suite passes.
Added direct support for Biobase::ExpressionSet
predictor inputs in pls() and predict(). Assay
rows are interpreted as variables and assay columns as samples, and are
transposed internally to the sample-by-variable layout used by
fastPLS.
Added a Bioconductor-native classification example to the package
vignette and expanded automated tests for fitting and predicting from
ExpressionSet objects.
Reformatted R and vignette sources to improve Bioconductor style compliance.
Synchronized the exported API, vignette, manual, README, and
manuscript capability descriptions. Removed stale PCA references and
deprecated the ignored lda_ridge compatibility argument;
supplying it now warns, and it is no longer included in cross-validation
tuning records.
Standardized response-variance metrics across the public API.
Training R2Y, independent-test Q2Y,
fold-training-mean single-CV Q2Y, and outer-fold
Q2Y now use explicit, documented denominators;
dummy-response PLS-DA values are labelled separately from classification
accuracy. evaluate() returns NA for Q2 when no
training response is supplied rather than silently reproducing
R2.
Corrected finite Monte Carlo permutation inference to use
(b + 1) / (B + 1), preventing zero p-values. Grouped nested
validation now permutes complete constraint blocks within equal-size
exchangeability strata, holds folds and randomized-solver seeds fixed,
and records failed null fits.
Clarified that returning the sequential SIMPLS component path is
standard behavior also provided by pls::simpls.fit and is
not claimed as a fastPLS novelty.
Defined the fastPLS contribution as compiled, shape-dependent execution and storage: cached deflation and cross-products, incremental coefficient and fitted-value updates, compact latent prediction, and implicit cross-covariance products.
Added a minimally optimized compiled SIMPLS baseline and explicit asymptotic time/storage expressions to the implementation mapping and vignette, while documenting that the retained optimizations are not uniformly faster.
Standardized the public SIMPLS direction-refresh rule across CPU, CUDA, and Metal. Every component now receives a fresh rank-one IRLBA solve or oversampled rSVD sketch from the current deflated cross-covariance; no candidate block or preceding latent direction is reused.
Removed unused experimental direction controls from the backend-control registry. All backends generate new randomized directions from the current deflated state.
Added fitted-model diagnostics and unit tests that identify the
active fresh_per_component rule and retained execution
optimizations.
Changed the randomized-SVD default to
(oversample = 20, power = 2) on CPU and CUDA. This stronger
setting met all 585 CPU and 40 CUDA component-level checks across five
prespecified random seeds in the release-candidate audits; the prior
(10, 2) setting failed five of 255 screening checks and is
not treated as qualified.
Added an explicit warning and fitted-model diagnostic status whenever a user requests randomized controls that were not qualified on the prespecified backend validation panel. Metal randomized SVD remains marked as unqualified pending a dedicated multi-seed audit.
Aligned non-exported C++ bridge defaults with the qualified CPU controls and expanded release tests for backend-specific dispatch and diagnostics.
Made the numerically qualified randomized-SVD configuration the package-wide default: oversampling is 10 and the number of power iterations is 2.
Removed undocumented, matrix-shape-dependent SIMPLS overrides
that could silently reduce randomized-SVD oversampling or power
iterations. Explicit controls supplied through ... still
take precedence and are recorded in fitted-model diagnostics.
Added release tests that verify the effective randomized-SVD
defaults used by fastsvd(), pls(), and
cross-validation.
Strengthened benchmark provenance records with Git worktree support and source tree and tag identifiers.
Made randomized SVD the effective default throughout the public PLS and cross-validation APIs, including the internal cross-validation tuning grid and the refit path used by stored CV configurations.
Corrected single-split permutation p-values for multi-component models so each permuted Q2 distribution is compared with the corresponding observed component rather than a recycled full Q2 vector.
Expanded the permanent input-grid tests across all four PLS families, regression and classification, argmax and LDA, IRLBA and rSVD, and both single and double cross-validation. CPU, CUDA, Metal, and float32 grids were also exercised during release validation.
pls.double.cv() calls now receive the public
"lda" classifier name and resolve it for the selected
backend internally, instead of leaking the CPU-specific internal
identifier "lda_cpp" through the public API.Corrected portable Windows float32 classification prediction so argmax decoding no longer calls an unavailable native single-precision kernel.
Made float32 capability-policy tests platform-independent by explicitly testing Unix accelerator policies separately from Windows availability.
Simplified the fastcor() example to use ten numeric
rows from iris.
Removed retired classification and class-bias native ABI branches, including CPU and CUDA kernels, generated Rcpp wrappers, registrations, and unreachable compiled cross-validation code. Classification remains limited to the documented argmax and latent-space LDA heads.
Preserved compact top-k argmax prediction through a bias-free CPU/CUDA implementation, including optional top-5 output.
Removed retired classifier variants and tuning controls from active benchmark generators.
Fixed compilation of CPU-only Windows builds. An unavailable native-float32 argmax route now raises the documented platform error through a type-correct integer-vector entry point instead of returning a list.
Removed the public PCA API and its S3 methods. Principal
component analysis remains available through dedicated R packages;
fastsvd() remains the package’s public standalone
decomposition interface.
Synchronized the public API and documentation around the two supported classification heads, argmax and latent-space LDA.
pls.single.cv() and pls.double.cv() can
now select classification models with
selection_metric = "balanced_accuracy". Nested permutation
tests use the same selected endpoint, preventing classification analyses
tuned and reported by balanced accuracy from being tested against
dummy-response Q2.
macOS installation now detects the system Metal frameworks even
when xcrun --show-sdk-path is unavailable, and configure
output reports CUDA and Metal status independently.
Float32 capability reporting now distinguishes validated,
experimental, hybrid, unavailable, and measured failed routes. The
public pls() interface emits route-specific warnings or
errors before allocation, and benchmark summaries separate input
storage, baseline and incremental host RSS, sampled GPU use, runtime,
and predictive differences from float64.
Added public PLS, SVD, prediction, evaluation and cross-validation interfaces for CPU, optional CUDA and optional Apple Metal backends.
Added optional classification heads for PLS-DA using argmax decoding or latent-space LDA.
Added package datasets, examples, benchmark scripts and a single user vignette.
CUDA and Metal builds are optional; CPU-only installation remains the default.
Float32 SIMPLS now retains the latent scores already produced by the compiled recurrence. LDA reuses these scores instead of centering, scaling and projecting the full training matrix a second time, reducing peak memory and runtime without changing predictions.
Float32 fitting now reports shape-based warnings for precision-sensitive classification, extreme multivariate responses, and nonlinear kernel routes. Float64 remains the numerical reference.