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