Last updated on 2026-07-23 20:51:36 CEST.
| Flavor | Version | Tinstall | Tcheck | Ttotal | Status | Flags |
|---|---|---|---|---|---|---|
| r-devel-linux-x86_64-debian-clang | 2026.6-1 | 5.51 | 191.34 | 196.85 | NOTE | |
| r-devel-linux-x86_64-debian-gcc | 2026.6-1 | 3.46 | 109.59 | 113.05 | ERROR | |
| r-devel-linux-x86_64-fedora-clang | 2026.6-1 | 264.03 | NOTE | |||
| r-devel-linux-x86_64-fedora-gcc | 2026.6-1 | 932.95 | NOTE | |||
| r-devel-windows-x86_64 | 2026.6-1 | 8.00 | 226.00 | 234.00 | NOTE | |
| r-patched-linux-x86_64 | 2026.6-1 | 5.70 | 182.83 | 188.53 | OK | |
| r-release-linux-x86_64 | 2026.6-1 | 4.44 | 179.98 | 184.42 | OK | |
| r-release-macos-arm64 | 2026.6-1 | 1.00 | 308.00 | 309.00 | OK | |
| r-release-macos-x86_64 | 2026.6-1 | 4.00 | 1465.00 | 1469.00 | OK | |
| r-release-windows-x86_64 | 2026.6-1 | 13.00 | 214.00 | 227.00 | OK | |
| r-oldrel-macos-arm64 | 2026.6-1 | 1.00 | 276.00 | 277.00 | OK | |
| r-oldrel-macos-x86_64 | 2026.6-1 | 4.00 | 1490.00 | 1494.00 | OK | |
| r-oldrel-windows-x86_64 | 2026.6-1 | 13.00 | 277.00 | 290.00 | OK |
Version: 2026.6-1
Check: R code for possible problems
Result: NOTE
Found calls to structure() using deprecated special names:
GPArotation/tests/Revelle.R (.Dim: 1, .Dimnames: 1)
'.Dim' should be changed to 'dim'.
'.Dimnames' should be changed to 'dimnames'.
Flavors: r-devel-linux-x86_64-debian-clang, r-devel-linux-x86_64-debian-gcc, r-devel-linux-x86_64-fedora-clang, r-devel-linux-x86_64-fedora-gcc, r-devel-windows-x86_64
Version: 2026.6-1
Check: tests
Result: ERROR
Running ‘Harman.R’ [0s/0s]
Running ‘Jennrich2002.R’ [0s/0s]
Running ‘KaiserNormalization.R’ [0s/0s]
Running ‘MASSoblimin.R’ [0s/0s]
Running ‘Revelle.R’ [0s/0s]
Running ‘Thurstone.R’ [0s/0s]
Running ‘WansbeekMeijer.R’ [0s/0s]
Running ‘algorithmTests.R’ [1s/1s]
Running ‘errormessages.R’ [0s/0s]
Running ‘legacyVsBB.R’ [1s/1s]
Running ‘legacyVsNew.R’ [1s/1s]
Running ‘lp.R’ [5s/5s]
Running ‘normalizationTests.R’ [0s/0s]
Running ‘print-GPArotation.R’ [0s/0s]
Running ‘rotations.R’ [10s/11s]
Running ‘rotationsRS.R’ [4s/5s]
Running ‘rotbbcayley.R’ [1s/1s]
Running ‘tableTests.r’ [0s/0s]
Running ‘target_vs_bb_clash.R’ [6s/6s]
Running ‘varimaxVarimax.R’ [0s/1s]
Running ‘vgQOLD.R’ [0s/0s]
Running ‘vgQtestOldVsNew.R’ [1s/1s]
Running the tests in ‘tests/legacyVsNew.R’ failed.
Complete output:
> # Regression tests: GPForth and GPFoblq against legacy implementations.
> # Tests that the 2027 updates produce results equivalent to the
> # original 2008 implementations within numerical tolerance.
> # Uses tolerance-based comparison (1e-5) for loadings and Th,
> # identical() only for convergence indicators and Table structure.
>
> require("GPArotation")
Loading required package: GPArotation
>
> all.ok <- TRUE
> tol <- 1e-5 # numerical tolerance for loadings/Th comparisons
>
> # Helper: strip all attributes except dim for bare matrix comparison
> .strip <- function(x) {
+ x <- unclass(x)
+ attributes(x) <- list(dim = dim(x))
+ x
+ }
>
> # Test matrices
> data(Harman, package = "GPArotation")
> data(Thurstone, package = "GPArotation")
>
> A2 <- Harman8 # 8 x 2
> A3 <- box26 # 26 x 3
>
> # --- Test 1: GPForth vs GPForth.legacy, varimax, identity start ---
> r1 <- GPForth(A2, method = "varimax", algorithm = "legacy", fwindow = 1)
> r1L <- GPArotation:::GPForth.legacy(A2, method = "varimax")
>
> if (max(abs(.strip(r1$loadings) - .strip(r1L$loadings))) > tol) {
+ cat("Test 1 failed: GPForth varimax loadings not equivalent to legacy\n")
+ cat("max difference:", max(abs(r1$loadings - r1L$loadings)), "\n")
+ all.ok <- FALSE
+ }
> if (max(abs(r1$Th - r1L$Th)) > tol) {
+ cat("Test 1 failed: GPForth varimax Th not equivalent to legacy\n")
+ cat("max difference:", max(abs(r1$Th - r1L$Th)), "\n")
+ all.ok <- FALSE
+ }
> if (!identical(r1$convergence, r1L$convergence)) {
+ cat("Test 1 failed: GPForth varimax convergence not identical to legacy\n")
+ all.ok <- FALSE
+ }
>
> # --- Test 2: GPForth vs GPForth.legacy, quartimax, 3 factors ---
> r2 <- GPForth(A3, method = "quartimax", algorithm = "legacy", fwindow = 1)
> r2L <- GPArotation:::GPForth.legacy(A3, method = "quartimax")
>
> if (max(abs(.strip(r2$loadings) - .strip(r2L$loadings))) > tol) {
+ cat("Test 2 failed: GPForth quartimax loadings not equivalent to legacy\n")
+ cat("max difference:", max(abs(r2$loadings - r2L$loadings)), "\n")
+ all.ok <- FALSE
+ }
> if (max(abs(r2$Th - r2L$Th)) > tol) {
+ cat("Test 2 failed: GPForth quartimax Th not equivalent to legacy\n")
+ cat("max difference:", max(abs(r2$Th - r2L$Th)), "\n")
+ all.ok <- FALSE
+ }
> if (!identical(r2$convergence, r2L$convergence)) {
+ cat("Test 2 failed: GPForth quartimax convergence not identical to legacy\n")
+ all.ok <- FALSE
+ }
>
> # --- Test 3: GPForth vs GPForth.legacy, random start ---
> set.seed(42)
> Tmat2 <- Random.Start(2)
> r3 <- GPForth(A2, Tmat = Tmat2, method = "varimax", algorithm = "legacy",
+ fwindow = 1)
> set.seed(42)
> Tmat2 <- Random.Start(2)
> r3L <- GPArotation:::GPForth.legacy(A2, Tmat = Tmat2, method = "varimax")
>
> if (max(abs(.strip(r3$loadings) - .strip(r3L$loadings))) > tol) {
+ cat("Test 3 failed: GPForth random start loadings not equivalent to legacy\n")
+ cat("max difference:", max(abs(r3$loadings - r3L$loadings)), "\n")
+ all.ok <- FALSE
+ }
> if (max(abs(r3$Th - r3L$Th)) > tol) {
+ cat("Test 3 failed: GPForth random start Th not equivalent to legacy\n")
+ cat("max difference:", max(abs(r3$Th - r3L$Th)), "\n")
+ all.ok <- FALSE
+ }
>
> # --- Test 4: GPForth vs GPForth.legacy, with normalization ---
> r4 <- GPForth(A2, method = "varimax", normalize = TRUE,
+ algorithm = "legacy", fwindow = 1)
> r4L <- GPArotation:::GPForth.legacy(A2, method = "varimax", normalize = TRUE)
>
> if (max(abs(.strip(r4$loadings) - .strip(r4L$loadings))) > tol) {
+ cat("Test 4 failed: GPForth normalized loadings not equivalent to legacy\n")
+ cat("max difference:", max(abs(r4$loadings - r4L$loadings)), "\n")
+ all.ok <- FALSE
+ }
> if (max(abs(r4$Th - r4L$Th)) > tol) {
+ cat("Test 4 failed: GPForth normalized Th not equivalent to legacy\n")
+ cat("max difference:", max(abs(r4$Th - r4L$Th)), "\n")
+ all.ok <- FALSE
+ }
>
> # --- Test 5: GPForth vs GPForth.legacy, methodArgs ---
> r5 <- GPForth(A2, method = "cf", methodArgs = list(kappa = 0.3),
+ algorithm = "legacy", fwindow = 1)
> r5L <- GPArotation:::GPForth.legacy(A2, method = "cf",
+ methodArgs = list(kappa = 0.3))
>
> if (max(abs(.strip(r5$loadings) - .strip(r5L$loadings))) > tol) {
+ cat("Test 5 failed: GPForth cf kappa=0.3 loadings not equivalent to legacy\n")
+ cat("max difference:", max(abs(r5$loadings - r5L$loadings)), "\n")
+ all.ok <- FALSE
+ }
> if (max(abs(r5$Th - r5L$Th)) > tol) {
+ cat("Test 5 failed: GPForth cf kappa=0.3 Th not equivalent to legacy\n")
+ cat("max difference:", max(abs(r5$Th - r5L$Th)), "\n")
+ all.ok <- FALSE
+ }
>
> # --- Test 6: GPFoblq vs GPFoblq.legacy, quartimin, identity start ---
> r6 <- GPFoblq(A2, method = "quartimin", algorithm = "legacy", fwindow = 1)
> r6L <- GPArotation:::GPFoblq.legacy(A2, method = "quartimin")
>
> if (max(abs(.strip(r6$loadings) - .strip(r6L$loadings))) > tol) {
+ cat("Test 6 failed: GPFoblq quartimin loadings not equivalent to legacy\n")
+ cat("max difference:", max(abs(r6$loadings - r6L$loadings)), "\n")
+ all.ok <- FALSE
+ }
> if (max(abs(r6$Phi - r6L$Phi)) > tol) {
+ cat("Test 6 failed: GPFoblq quartimin Phi not equivalent to legacy\n")
+ cat("max difference:", max(abs(r6$Phi - r6L$Phi)), "\n")
+ all.ok <- FALSE
+ }
> if (max(abs(r6$Th - r6L$Th)) > tol) {
+ cat("Test 6 failed: GPFoblq quartimin Th not equivalent to legacy\n")
+ cat("max difference:", max(abs(r6$Th - r6L$Th)), "\n")
+ all.ok <- FALSE
+ }
> if (!identical(r6$convergence, r6L$convergence)) {
+ cat("Test 6 failed: GPFoblq quartimin convergence not identical to legacy\n")
+ all.ok <- FALSE
+ }
>
> # --- Test 7: GPFoblq vs GPFoblq.legacy, oblimin, 3 factors ---
> r7 <- GPFoblq(A3, method = "oblimin", algorithm = "legacy", fwindow = 1)
> r7L <- GPArotation:::GPFoblq.legacy(A3, method = "oblimin")
>
> if (max(abs(.strip(r7$loadings) - .strip(r7L$loadings))) > tol) {
+ cat("Test 7 failed: GPFoblq oblimin loadings not equivalent to legacy\n")
+ cat("max difference:", max(abs(r7$loadings - r7L$loadings)), "\n")
+ all.ok <- FALSE
+ }
> if (max(abs(r7$Phi - r7L$Phi)) > tol) {
+ cat("Test 7 failed: GPFoblq oblimin Phi not equivalent to legacy\n")
+ cat("max difference:", max(abs(r7$Phi - r7L$Phi)), "\n")
+ all.ok <- FALSE
+ }
> if (!identical(r7$convergence, r7L$convergence)) {
+ cat("Test 7 failed: GPFoblq oblimin convergence not identical to legacy\n")
+ all.ok <- FALSE
+ }
>
> # --- Test 8: GPFoblq vs GPFoblq.legacy, random start ---
> set.seed(42)
> Tmat3 <- Random.Start(3)
> r8 <- GPFoblq(A3, Tmat = Tmat3, method = "quartimin",
+ algorithm = "legacy", fwindow = 1)
> set.seed(42)
> Tmat3 <- Random.Start(3)
> r8L <- GPArotation:::GPFoblq.legacy(A3, Tmat = Tmat3, method = "quartimin")
>
> if (max(abs(.strip(r8$loadings) - .strip(r8L$loadings))) > tol) {
+ cat("Test 8 failed: GPFoblq random start loadings not equivalent to legacy\n")
+ cat("max difference:", max(abs(r8$loadings - r8L$loadings)), "\n")
+ all.ok <- FALSE
+ }
> if (max(abs(r8$Phi - r8L$Phi)) > tol) {
+ cat("Test 8 failed: GPFoblq random start Phi not equivalent to legacy\n")
+ cat("max difference:", max(abs(r8$Phi - r8L$Phi)), "\n")
+ all.ok <- FALSE
+ }
> if (max(abs(r8$Th - r8L$Th)) > tol) {
+ cat("Test 8 failed: GPFoblq random start Th not equivalent to legacy\n")
+ cat("max difference:", max(abs(r8$Th - r8L$Th)), "\n")
+ all.ok <- FALSE
+ }
>
> # --- Test 9: GPFoblq vs GPFoblq.legacy, with normalization ---
> r9 <- GPFoblq(A2, method = "quartimin", normalize = TRUE,
+ algorithm = "legacy", fwindow = 1)
> r9L <- GPArotation:::GPFoblq.legacy(A2, method = "quartimin",
+ normalize = TRUE)
>
> if (max(abs(.strip(r9$loadings) - .strip(r9L$loadings))) > tol) {
+ cat("Test 9 failed: GPFoblq normalized loadings not equivalent to legacy\n")
+ cat("max difference:", max(abs(r9$loadings - r9L$loadings)), "\n")
+ all.ok <- FALSE
+ }
> if (max(abs(r9$Phi - r9L$Phi)) > tol) {
+ cat("Test 9 failed: GPFoblq normalized Phi not equivalent to legacy\n")
+ cat("max difference:", max(abs(r9$Phi - r9L$Phi)), "\n")
+ all.ok <- FALSE
+ }
>
> # --- Test 10: convergence indicators agree ---
> if (!identical(r1$convergence, r1L$convergence)) {
+ cat("Test 10 failed: GPForth convergence indicator not identical to legacy\n")
+ all.ok <- FALSE
+ }
> if (!identical(r6$convergence, r6L$convergence)) {
+ cat("Test 10 failed: GPFoblq convergence indicator not identical to legacy\n")
+ all.ok <- FALSE
+ }
>
> # --- Test 11: Table structure for non-converged case ---
> r11 <- GPForth(A3, method = "simplimax", maxit = 3,
+ algorithm = "legacy", fwindow = 1)
Warning message:
In GPForth(A3, method = "simplimax", maxit = 3, algorithm = "legacy", :*** buffer overflow detected ***: terminated
Aborted
Running the tests in ‘tests/rotations.R’ failed.
Complete output:
> # Tests here only compare against values computed previously with this code,
> # to ensure there was no accidental change. It would be better to have
> # comparisons with known correct values.
>
> # Test for oblimax is commented out as it appears to be unstable.
>
>
> Sys.getenv("R_LIBS")
[1] "/home/hornik/tmp/scratch/RtmpEO26BF/RLIBS_32650911e44ce9"
> library()
Packages in library '/home/hornik/tmp/scratch/RtmpEO26BF/RLIBS_32650911e44ce9':
GPArotation Gradient Projection Factor Rotation
Packages in library '/home/hornik/tmp/R.check/r-devel-gcc/Work/build/library':
KernSmooth Functions for Kernel Smoothing Supporting Wand
& Jones (1995)
MASS Support Functions and Datasets for Venables and
Ripley's MASS
Matrix Sparse and Dense Matrix Classes and Methods
base The R Base Package
boot Bootstrap Functions
class Functions for Classification
cluster "Finding Groups in Data": Cluster Analysis
Extended Rousseeuw et al.
codetools Code Analysis Tools for R
compiler The R Compiler Package
datasets The R Datasets Package
foreign Read Data Stored by 'Minitab', 'S', 'SAS',
'SPSS', 'Stata', 'Systat', 'Weka', 'dBase', ...
grDevices The R Graphics Devices and Support for Colours
and Fonts
graphics The R Graphics Package
grid The Grid Graphics Package
lattice Trellis Graphics for R
methods Formal Methods and Classes
mgcv Mixed GAM Computation Vehicle with Automatic
Smoothness Estimation
nlme Linear and Nonlinear Mixed Effects Models
nnet Feed-Forward Neural Networks and Multinomial
Log-Linear Models
parallel Support for Parallel Computation in R
rpart Recursive Partitioning and Regression Trees
spatial Functions for Kriging and Point Pattern
Analysis
splines Regression Spline Functions and Classes
stats The R Stats Package
stats4 Statistical Functions using S4 Classes
survival Survival Analysis
tcltk Tcl/Tk Interface
tools Tools for Package Development
utils The R Utils Package
> require("GPArotation")
Loading required package: GPArotation
> search()
[1] ".GlobalEnv" "package:GPArotation" "package:stats"
[4] "package:graphics" "package:grDevices" "package:utils"
[7] "package:datasets" "package:methods" "Autoloads"
[10] "package:base"
> Sys.info()
sysname
"Linux"
release
"7.1.3+deb14-amd64"
version
"#1 SMP PREEMPT_DYNAMIC Debian 7.1.3-1 (2026-07-04)"
nodename
"gimli1"
machine
"x86_64"
login
"hornik"
user
"hornik"
effective_user
"hornik"
>
> require("stats")
> require("GPArotation")
>
> fuzz <- 1e-6 # updated to 1-e5 from 1e-6 on May 7 2026
> all.ok <- TRUE
>
>
> data(ability.cov)
> L <- loadings(factanal(factors = 2, covmat=ability.cov))
>
>
> if( 0.001 < max(abs(varimax(L, normalize=FALSE)$loadings -
+ Varimax(L, normalize=FALSE)$loadings))) {
+ cat("Calculated difference exceeds tolerance\n")
+ cat("difference:\n")
+ print(varimax(L, normalize=FALSE)$loadings -
+ Varimax(L, normalize=FALSE)$loadings, digits=18)
+ all.ok <- FALSE
+ }
>
> if( 0.01 < max(abs(varimax(L, normalize=TRUE)$loadings -
+ Varimax(L, normalize=TRUE, eps=1e-5)$loadings))) {
+ cat("Calculated difference exceeds tolerance\n")
+ cat("difference:\n")
+ print(varimax(L, normalize=TRUE)$loadings -
+ Varimax(L, normalize=TRUE, eps=1e-5)$loadings, digits=18)
+ all.ok <- FALSE
+ }
>
>
> v <- oblimin(L, eps=1e-8)$loadings
> tst <- t(matrix(c(
+ 0.3863615904740822504, 0.4745127741495974161,
+ -0.0110059418769087539, 0.6458720769633764514,
+ -0.0262926272350604423, 0.8961141105684561348,
+ -0.0180200526810754824, 0.4882928281695405048,
+ 0.9900944939102318543, -0.0370718282544326011,
+ 0.7905657274265397438, 0.0526109550054999417
+ ), 2, 6))
>
> if( fuzz < max(abs(v - tst))) {
+ cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
+ print(v, digits=18)
+ cat("difference:\n")
+ print(v - tst, digits=18)
+ all.ok <- FALSE
+ }
>
> v <- oblimin(L, gam = 1, eps=1e-8)$loadings
> tst <- t(matrix(c(
+ 0.2160827, 0.5403732,
+ -0.4787025, 1.0224006,
+ -0.6800410, 1.4244177,
+ -0.3758706, 0.7781390,
+ 1.4517362, -0.5873946,
+ 1.1002585, -0.3396290
+ ), 2, 6))
>
> if( fuzz < max(abs(v - tst))) {
+ cat("Calculated value is not the same as test value in test rotations 1-gam=1. Value:\n")
+ print(v, digits=18)
+ cat("difference:\n")
+ print(v - tst, digits=18)
+ all.ok <- FALSE
+ }
>
> v <- oblimin(L, gam = .1, eps=1e-8)$loadings
> tst <- t(matrix(c(
+ 0.37893531, 0.47408606,
+ -0.02465543, 0.65257986,
+ -0.04530330, 0.90557045,
+ -0.02840333, 0.49349573,
+ 0.99740452, -0.05088932,
+ 0.79467442, 0.04241284
+ ), 2, 6))
>
> if( fuzz < max(abs(v - tst))) {
+ cat("Calculated value is not the same as test value in test rotations 1-gam=.1. Value:\n")
+ print(v, digits=18)
+ cat("difference:\n")
+ print(v - tst, digits=18)
+ all.ok <- FALSE
+ }
>
>
>
> v <- quartimin(L, eps=1e-8)$loadings
> tst <- t(matrix(c(
+ 0.3863615904740822504, 0.4745127741495974161,
+ -0.0110059418769087539, 0.6458720769633764514,
+ -0.0262926272350604423, 0.8961141105684561348,
+ -0.0180200526810754824, 0.4882928281695405048,
+ 0.9900944939102318543, -0.0370718282544326011,
+ 0.7905657274265397438, 0.0526109550054999417
+ ), 2, 6))
>
> if( fuzz < max(abs(v - tst))) {
+ cat("Calculated value is not the same as test value in test rotations 2. Value:\n")
+ print(v, digits=18)
+ cat("difference:\n")
+ print(v - tst, digits=18)
+ all.ok <- FALSE
+ }
>
>
> v <- targetT(L, Target=matrix(c(rep(1,3),rep(0,6),rep(1,3)), 6,2),
+ eps=1e-5, algorithm = "legacy", fwindow = 1)$loadings
> tst <- t(matrix(c(
+ 0.551529228817982942, 0.4905002767031292898,
+ 0.217748645523411000, 0.6027046291262584399,
+ 0.291173432863349457, 0.8348885228488550636,
+ 0.154994397662456290, 0.4544843569140373241,
+ 0.969702339393929247, 0.0850652965070581996,
+ 0.803390575440818822, 0.1448091121037717866
+ ), 2, 6))
>
> if( fuzz < max(abs(v - tst))) {
+ cat("Calculated value is not the same as test value in test rotations 3. Value:\n")
+ print(v, digits=18)
+ cat("difference:\n")
+ print(v - tst, digits=18)
+ all.ok <- FALSE
+ }
>
> v <- targetT(L = L, Target=matrix(c(rep(1,3),rep(0,6),rep(1,3)), 6,2),
+ eps=1e-5, algorithm = "legacy", fwindow = 1)$loadings
Warning message:
Argument 'L' is deprecated; using 'A' instead.
> if( fuzz < max(abs(v - tst))) {
+ cat("Calculated value is not the same as test value in test rotations 3L. Value:\n")
+ print(v, digits=18)
+ cat("difference:\n")
+ print(v - tst, digits=18)
+ all.ok <- FALSE
+ }
>
>
> v <- targetQ(L, Target=matrix(c(rep(1,3),rep(0,6),rep(1,3)), 6,2),
+ eps=1e-5, algorithm = "legacy", fwindow = 1)$loadings
> tst <- t(matrix(c(
+ 0.735795682866631218, 0.565351705145453853,
+ 0.433590223819374398, 0.664644550038417159,
+ 0.589924557708411568, 0.920006940799857786,
+ 0.317543426981046928, 0.500590650032113116,
+ 1.021758247914384077, 0.155121528590726393,
+ 0.872521244896209747, 0.208735706420634437
+ ), 2, 6))
>
> if( fuzz < max(abs(v - tst))) {
+ cat("Calculated value is not the same as test value in test rotations 4. Value:\n")
+ print(v, digits=18)
+ cat("difference:\n")
+ print(v - tst, digits=18)
+ all.ok <- FALSE
+ }
>
> v <- targetQ(L = L, Target=matrix(c(rep(1,3),rep(0,6),rep(1,3)), 6,2),
+ eps=1e-5, algorithm = "legacy", fwindow = 1)$loadings
Warning message:
Argument 'L' is deprecated; using 'A' instead.
> if( fuzz < max(abs(v - tst))) {
+ cat("Calculated value is not the same as test value in test rotations 4L. Value:\n")
+ print(v, digits=18)
+ cat("difference:\n")
+ print(v - tst, digits=18)
+ all.ok <- FALSE
+ }
>
>
> #Does not converge even with maxit=10000, but the loadings matrix is not
> # changing. Possibly the gradient is extremely large even very close to opt.
> v <- pstT(L, W = matrix(c(rep(.4,6),rep(.6,6)), 6,2),
+ Target= matrix(c(rep(1,3),rep(0,6),rep(1,3)), 6,2),
+ maxit=15000, eps=1e-5, algorithm = "legacy", fwindow = 1)$loadings
Warning message:
In engine(A, Tmat = current_Tmat, normalize = normalize, eps = eps, :*** buffer overflow detected ***: terminated
Aborted
Flavor: r-devel-linux-x86_64-debian-gcc