Running ‘rotations.R’ [1s/1s]
Running the tests in ‘tests/rotations.R’ failed.
Complete output:
  > #   Tests here only compare against values computed with GPArotation code,
  > #   to ensure the regular and DF versions give the same result
  > 
  > 
  >  Sys.getenv("R_LIBS")
  [1] "/tmp/Rtmp1hCgG2/RLIBS_c26894e97ef63"
  >  library()
  Packages in library '/tmp/Rtmp1hCgG2/RLIBS_c26894e97ef63':
  
  GPArotateDF             Derivative Free Gradient Projection Factor
                          Rotation
  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
  >  require("GPArotateDF")
  Loading required package: GPArotateDF
  >  search()
   [1] ".GlobalEnv"          "package:GPArotateDF" "package:GPArotation"
   [4] "package:stats"       "package:graphics"    "package:grDevices"  
   [7] "package:utils"       "package:datasets"    "package:methods"    
  [10] "Autoloads"           "package:base"       
  >  Sys.info()
                                                sysname 
                                                "Linux" 
                                                release 
                                   "7.0.10+deb14-amd64" 
                                                version 
  "#1 SMP PREEMPT_DYNAMIC Debian 7.0.10-1 (2026-05-27)" 
                                               nodename 
                                               "gimli1" 
                                                machine 
                                               "x86_64" 
                                                  login 
                                               "hornik" 
                                                   user 
                                               "hornik" 
                                         effective_user 
                                               "hornik" 
  > 
  > require("stats")  
  > 
  > fuzz <- 1e-6 
  > all.ok <- TRUE  
  > 
  > 
  >   data(ability.cov)
  >   L <- loadings(factanal(factors = 2, covmat=ability.cov))
  > 
  > # quartimax
  > 
  > LG <- quartimax(L, normalize = FALSE, eps=1e-5)
  > LGDF <- GPForth.df(L, normalize = FALSE, eps=1e-5, method = "quartimax")  
  > 
  >   if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  +     all.ok <- FALSE  
  +     } 
  Calculated value is not the same as test value in test rotations 1. Value:
  difference:
  
  Loadings:
          Factor1       Factor2      
  general                            
  picture                            
  blocks                             
  maze                               
  reading                            
  vocab                              
  
                   Factor1     Factor2
  SS loadings 2.071172e-10 2.57213e-10
  > LG <- quartimax(L, normalize = TRUE, eps=1e-5)
  > LGDF <- GPForth.df(L, normalize = TRUE, eps=1e-5, method = "quartimax")  
  > 
  >   if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  +     all.ok <- FALSE  
  +     } 	  
  Calculated value is not the same as test value in test rotations 1. Value:
  difference:
  
  Loadings:
          Factor1       Factor2      
  general                            
  picture                            
  blocks                             
  maze                               
  reading                            
  vocab                              
  
                   Factor1      Factor2
  SS loadings 3.594091e-11 3.001116e-11
  >  
  > 	  
  >     
  > # quartimin
  > 
  > LG <- quartimin(L, normalize = FALSE, eps=1e-5)
  > LGDF <- GPFoblq.df(L, normalize = FALSE, eps=1e-5, method = "quartimin")  
  > 
  >   if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  +     all.ok <- FALSE  
  +     } 
  Calculated value is not the same as test value in test rotations 1. Value:
  difference:
  
  Loadings:
          Factor1       Factor2      
  general                            
  picture                            
  blocks                             
  maze                               
  reading                            
  vocab                              
  
                   Factor1      Factor2
  SS loadings 2.399083e-11 2.122768e-12
  >   if( fuzz < max(abs(unclass(LGDF)$Phi - unclass(LG)$Phi))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$Phi - unclass(LG)$Phi), digits=18)
  +     all.ok <- FALSE  
  +     } 
  Calculated value is not the same as test value in test rotations 1. Value:
  difference:
                           Factor1                  Factor2
  Factor1  0.00000000000000000e+00 -2.40939117168714745e-06
  Factor2 -2.40939117168714745e-06  0.00000000000000000e+00
  >     
  > LG <- quartimin(L, normalize = TRUE, eps=1e-5)
  > LGDF <- GPFoblq.df(L, normalize = TRUE, eps=1e-5, method = "quartimin")  
  > 
  >   if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  +     all.ok <- FALSE  
  +     } 	  
  Calculated value is not the same as test value in test rotations 1. Value:
  difference:
  
  Loadings:
          Factor1       Factor2      
  general                            
  picture                            
  blocks                             
  maze                               
  reading                            
  vocab                              
  
                   Factor1      Factor2
  SS loadings 1.159026e-12 1.261096e-11
  >   if( fuzz < max(abs(unclass(LGDF)$Phi - unclass(LG)$Phi))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$Phi - unclass(LG)$Phi), digits=18)
  +     all.ok <- FALSE  
  +     } 
  Calculated value is not the same as test value in test rotations 1. Value:
  difference:
                           Factor1                  Factor2
  Factor1  0.00000000000000000e+00 -1.61240317597677318e-06
  Factor2 -1.61240317597677318e-06  0.00000000000000000e+00
  >       
  > # oblimax commented out as it is gives problem quite consistently
  >    
  > #LG <- oblimax(L, normalize = FALSE, eps=1e-5)
  > #LGDF <- GPFoblq.df(L, normalize = FALSE, eps=1e-5, method = "oblimax")  
  > # Oblimax fails for fuzz = 1e-6. But succeeds for 0.01
  > #  if( 0.01 < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  > #    cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  > #    cat("difference:\n")
  > #    print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  > #    all.ok <- FALSE  
  > #    } 
  > #  if( fuzz < max(abs(unclass(LGDF)$Phi - unclass(LG)$Phi))) {
  > #    cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  > #    cat("difference:\n")
  > #    print((unclass(LGDF)$Phi - unclass(LG)$Phi), digits=18)
  > #    all.ok <- FALSE  
  > #    } 
  >     
  > #LG <- oblimax(L, normalize = TRUE, eps=1e-5)
  > #LGDF <- GPFoblq.df(L, normalize = TRUE, eps=1e-5, method = "oblimax")  
  > #  if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  > #    cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  > #    cat("difference:\n")
  > #    print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  > #    all.ok <- FALSE  
  > #    } 	  
  > #  if( fuzz < max(abs(unclass(LGDF)$Phi - unclass(LG)$Phi))) {
  > #    cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  > #    cat("difference:\n")
  > #    print((unclass(LGDF)$Phi - unclass(LG)$Phi), digits=18)
  > #    all.ok <- FALSE  
  > #    } 
  >  
  >  
  > # entropy
  > 
  > LG <- entropy(L, normalize = FALSE, eps=1e-5)
  > LGDF <- GPForth.df(L, normalize = FALSE, eps=1e-5, method = "entropy")  
  > 
  >   if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  +     all.ok <- FALSE  
  +     } 
  Calculated value is not the same as test value in test rotations 1. Value:
  difference:
  
  Loadings:
          Factor1       Factor2      
  general                            
  picture                            
  blocks                             
  maze                               
  reading                            
  vocab                              
  
                   Factor1      Factor2
  SS loadings 2.380919e-10 2.879861e-10
  > LG <- entropy(L, normalize = TRUE, eps=1e-5)
  > LGDF <- GPForth.df(L, normalize = TRUE, eps=1e-5, method = "entropy")  
  > 
  >   if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  +     all.ok <- FALSE  
  +     } 	  
  Calculated value is not the same as test value in test rotations 1. Value:
  difference:
  
  Loadings:
          Factor1       Factor2      
  general                            
  picture                            
  blocks                             
  maze                               
  reading                            
  vocab                              
  
                   Factor1      Factor2
  SS loadings 2.954305e-12 2.090064e-12
  >  
  >  
  >  
  > # simplimax
  >    
  > LG <- simplimax(L, normalize = FALSE, eps=1e-5)
  > LGDF <- GPFoblq.df(L, normalize = FALSE, eps=1e-5, method = "simplimax")  
  > 
  >   if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  +     all.ok <- FALSE  
  +     } 
  >   if( fuzz < max(abs(unclass(LGDF)$Phi - unclass(LG)$Phi))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$Phi - unclass(LG)$Phi), digits=18)
  +     all.ok <- FALSE  
  +     } 
  >     
  > LG <- simplimax(L, normalize = TRUE, eps=1e-5)
  > LGDF <- GPFoblq.df(L, normalize = TRUE, eps=1e-5, method = "simplimax")  
  > 
  >   if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  +     all.ok <- FALSE  
  +     } 	  
  >   if( fuzz < max(abs(unclass(LGDF)$Phi - unclass(LG)$Phi))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$Phi - unclass(LG)$Phi), digits=18)
  +     all.ok <- FALSE  
  +     } 
  >  
  >  
  > # bentlerQ
  >    
  > LG <- bentlerQ(L, normalize = FALSE, eps=1e-5)
  > LGDF <- GPFoblq.df(L, normalize = FALSE, eps=1e-5, method = "bentler")  
  > 
  >   if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  +     all.ok <- FALSE  
  +     } 
  Calculated value is not the same as test value in test rotations 1. Value:
  difference:
  
  Loadings:
          Factor1       Factor2      
  general                            
  picture                            
  blocks                             
  maze                               
  reading                            
  vocab                              
  
                   Factor1      Factor2
  SS loadings 5.007946e-09 1.588765e-10
  >   if( fuzz < max(abs(unclass(LGDF)$Phi - unclass(LG)$Phi))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$Phi - unclass(LG)$Phi), digits=18)
  +     all.ok <- FALSE  
  +     } 
  Calculated value is not the same as test value in test rotations 1. Value:
  difference:
                           Factor1                  Factor2
  Factor1  0.00000000000000000e+00 -3.94838404905728524e-05
  Factor2 -3.94838404905728524e-05 -3.33066907387546962e-16
  >     
  > LG <- bentlerQ(L, normalize = TRUE, eps=1e-5)
  > LGDF <- GPFoblq.df(L, normalize = TRUE, eps=1e-5, method = "bentler")  
  > 
  >   if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  +     all.ok <- FALSE  
  +     } 	  
  Calculated value is not the same as test value in test rotations 1. Value:
  difference:
  
  Loadings:
          Factor1       Factor2      
  general                            
  picture                            
  blocks                             
  maze                               
  reading                            
  vocab                              
  
                   Factor1      Factor2
  SS loadings 7.240893e-09 6.148903e-08
  >   if( fuzz < max(abs(unclass(LGDF)$Phi - unclass(LG)$Phi))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$Phi - unclass(LG)$Phi), digits=18)
  +     all.ok <- FALSE  
  +     } 
  Calculated value is not the same as test value in test rotations 1. Value:
  difference:
                           Factor1                  Factor2
  Factor1 -2.22044604925031308e-16 -1.01274249892813195e-04
  Factor2 -1.01274249892813195e-04  4.44089209850062616e-16
  >  
  > 
  > # bentlerT
  > 
  > LG <- bentlerT(L, normalize = FALSE, eps=1e-5)
  > LGDF <- GPForth.df(L, normalize = FALSE, eps=1e-5, method = "bentler")  
  > 
  >   if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  +     all.ok <- FALSE  
  +     } 
  Calculated value is not the same as test value in test rotations 1. Value:
  difference:
  
  Loadings:
          Factor1       Factor2      
  general                            
  picture                            
  blocks                             
  maze                               
  reading                            
  vocab                              
  
                   Factor1      Factor2
  SS loadings 1.091502e-10 1.295173e-10
  > LG <- bentlerT(L, normalize = TRUE, eps=1e-5)
  > LGDF <- GPForth.df(L, normalize = TRUE, eps=1e-5, method = "bentler")  
  > 
  >   if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  +     all.ok <- FALSE  
  +     } 	  
  Calculated value is not the same as test value in test rotations 1. Value:
  difference:
  
  Loadings:
          Factor1       Factor2      
  general                            
  picture                            
  blocks                             
  maze                               
  reading                            
  vocab                              
  
                   Factor1      Factor2
  SS loadings 2.900089e-09 2.613755e-09
  >  
  > 
  > # geominQ
  >    
  > LG <- geominQ(L, normalize = FALSE, eps=1e-5)
  > LGDF <- GPFoblq.df(L, normalize = FALSE, eps=1e-5, method = "geomin")  
  > 
  >   if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  +     all.ok <- FALSE  
  +     } 
  >   if( fuzz < max(abs(unclass(LGDF)$Phi - unclass(LG)$Phi))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$Phi - unclass(LG)$Phi), digits=18)
  +     all.ok <- FALSE  
  +     } 
  >     
  > LG <- geominQ(L, normalize = TRUE, eps=1e-5)
  > LGDF <- GPFoblq.df(L, normalize = TRUE, eps=1e-5, method = "geomin")  
  > 
  >   if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  +     all.ok <- FALSE  
  +     } 	  
  >   if( fuzz < max(abs(unclass(LGDF)$Phi - unclass(LG)$Phi))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$Phi - unclass(LG)$Phi), digits=18)
  +     all.ok <- FALSE  
  +     } 
  >  
  > 
  > # geominT
  > 
  > LG <- geominT(L, normalize = FALSE, eps=1e-5)
  > LGDF <- GPForth.df(L, normalize = FALSE, eps=1e-5, method = "geomin")  
  > 
  >   if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  +     all.ok <- FALSE  
  +     } 
  Calculated value is not the same as test value in test rotations 1. Value:
  difference:
  
  Loadings:
          Factor1       Factor2      
  general                            
  picture                            
  blocks                             
  maze                               
  reading                            
  vocab                              
  
                   Factor1      Factor2
  SS loadings 2.031329e-12 2.959919e-12
  > LG <- geominT(L, normalize = TRUE, eps=1e-5)
  > LGDF <- GPForth.df(L, normalize = TRUE, eps=1e-5, method = "geomin")  
  > 
  >   if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  +     all.ok <- FALSE  
  +     } 	  
  >  
  > 
  > # infomaxQ
  >    
  > LG <- infomaxQ(L, normalize = FALSE, eps=1e-5)
  > LGDF <- GPFoblq.df(L, normalize = FALSE, eps=1e-5, method = "infomax")  
  > 
  >   if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  +     all.ok <- FALSE  
  +     } 
  Calculated value is not the same as test value in test rotations 1. Value:
  difference:
  
  Loadings:
          Factor1       Factor2      
  general                            
  picture                            
  blocks                             
  maze                               
  reading                            
  vocab                              
  
                Factor1      Factor2
  SS loadings 8.975e-15 5.708275e-12
  >   if( fuzz < max(abs(unclass(LGDF)$Phi - unclass(LG)$Phi))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$Phi - unclass(LG)$Phi), digits=18)
  +     all.ok <- FALSE  
  +     } 
  Calculated value is not the same as test value in test rotations 1. Value:
  difference:
                          Factor1                 Factor2
  Factor1 0.00000000000000000e+00 1.70503978286218327e-06
  Factor2 1.70503978286218327e-06 0.00000000000000000e+00
  >     
  >     # changed to eps 1e-6 in order to pass the test.
  > LG <- infomaxQ(L, normalize = TRUE, eps=1e-6)
  > LGDF <- GPFoblq.df(L, normalize = TRUE, eps=1e-6, method = "infomax")  
  > 
  >   if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  +     all.ok <- FALSE  
  +     } 	  
  >   if( fuzz < max(abs(unclass(LGDF)$Phi - unclass(LG)$Phi))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$Phi - unclass(LG)$Phi), digits=18)
  +     all.ok <- FALSE  
  +     } 
  >  
  > 
  > # infomaxT
  > 
  > LG <- infomaxT(L, normalize = FALSE, eps=1e-5)
  > LGDF <- GPForth.df(L, normalize = FALSE, eps=1e-5, method = "infomax")  
  > 
  >   if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  +     all.ok <- FALSE  
  +     } 
  Calculated value is not the same as test value in test rotations 1. Value:
  difference:
  
  Loadings:
          Factor1       Factor2      
  general                            
  picture                            
  blocks                             
  maze                               
  reading                            
  vocab                              
  
                   Factor1      Factor2
  SS loadings 4.178387e-12 4.433292e-12
  > LG <- infomaxT(L, normalize = TRUE, eps=1e-5)
  > LGDF <- GPForth.df(L, normalize = TRUE, eps=1e-5, method = "infomax")  
  > 
  >   if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  +     all.ok <- FALSE  
  +     } 	  
  Calculated value is not the same as test value in test rotations 1. Value:
  difference:
  
  Loadings:
          Factor1       Factor2      
  general                            
  picture                            
  blocks                             
  maze                               
  reading                            
  vocab                              
  
                   Factor1      Factor2
  SS loadings 2.276025e-11 2.200358e-11
  >  
  > 
  > # CF Equamax Q
  >    
  > LG <- GPFoblq(L, normalize = FALSE, eps=1e-5,  method = "cf", methodArgs=list(kappa=2/12))
  > LGDF <- GPFoblq.df(L, normalize = FALSE, eps=1e-5, method = "cf", methodArgs=list(kappa=2/12))  
  > 
  >   if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  +     all.ok <- FALSE  
  +     } 
  Calculated value is not the same as test value in test rotations 1. Value:
  difference:
  
  Loadings:
          Factor1       Factor2      
  general                            
  picture                            
  blocks                             
  maze                               
  reading                            
  vocab                              
  
                   Factor1     Factor2
  SS loadings 5.955028e-12 3.25221e-13
  >   if( fuzz < max(abs(unclass(LGDF)$Phi - unclass(LG)$Phi))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$Phi - unclass(LG)$Phi), digits=18)
  +     all.ok <- FALSE  
  +     } 
  Calculated value is not the same as test value in test rotations 1. Value:
  difference:
                           [,1]                     [,2]
  [1,] -4.44089209850062616e-16  1.40617309019042125e-06
  [2,]  1.40617309019042125e-06 -2.22044604925031308e-16
  >     
  > LG <- GPFoblq(L, normalize = TRUE, eps=1e-5,  method = "cf", methodArgs=list(kappa=2/12))
  > LGDF <- GPFoblq.df(L, normalize = TRUE, eps=1e-5, method = "cf", methodArgs=list(kappa=2/12))  
  > 
  >   if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  +     all.ok <- FALSE  
  +     } 	  
  Calculated value is not the same as test value in test rotations 1. Value:
  difference:
  
  Loadings:
          Factor1       Factor2      
  general                            
  picture                            
  blocks                             
  maze                               
  reading                            
  vocab                              
  
                   Factor1      Factor2
  SS loadings 7.097006e-12 2.832944e-11
  >   if( fuzz < max(abs(unclass(LGDF)$Phi - unclass(LG)$Phi))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$Phi - unclass(LG)$Phi), digits=18)
  +     all.ok <- FALSE  
  +     } 
  Calculated value is not the same as test value in test rotations 1. Value:
  difference:
                           [,1]                     [,2]
  [1,]  3.33066907387546962e-16 -1.64903800370375109e-06
  [2,] -1.64903800370375109e-06  4.44089209850062616e-16
  >  
  > 
  > # CF equamax T
  > 
  > LG <- GPForth(L, normalize = FALSE, eps=1e-5, method = "cf", methodArgs=list(kappa=2/12))
  > LGDF <- GPForth.df(L, normalize = FALSE, eps=1e-5, method = "cf", methodArgs=list(kappa=2/12))  
  > 
  >   if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  +     all.ok <- FALSE  
  +     } 
  Calculated value is not the same as test value in test rotations 1. Value:
  difference:
  
  Loadings:
          Factor1       Factor2      
  general                            
  picture                            
  blocks                             
  maze                               
  reading                            
  vocab                              
  
                   Factor1     Factor2
  SS loadings 4.167409e-11 4.79377e-11
  > LG <- GPForth(L, normalize = TRUE, eps=1e-5, method = "cf", methodArgs=list(kappa=2/12))
  > LGDF <- GPForth.df(L, normalize = TRUE, eps=1e-5, method = "cf", methodArgs=list(kappa=2/12))  
  > 
  >   if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  +     all.ok <- FALSE  
  +     } 
  >     
  > 
  > # targetQ
  > LG <- targetQ(L, Target=matrix(c(rep(1,3),rep(0,6),rep(1,3)), 6,2), normalize=FALSE, eps=1e-5)
  > LGDF <- GPFoblq.df(L, normalize = FALSE, eps=1e-5, method = "target", 
  +  	methodArgs=list(Target=matrix(c(rep(1,3),rep(0,6),rep(1,3)), 6,2)))  
  > 
  >   if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  +     all.ok <- FALSE  
  +     } 
  Calculated value is not the same as test value in test rotations 1. Value:
  difference:
  
  Loadings:
          Factor1       Factor2      
  general                            
  picture                            
  blocks                             
  maze                               
  reading                            
  vocab                              
  
                  Factor1      Factor2
  SS loadings 3.94618e-11 3.993706e-11
  >   if( fuzz < max(abs(unclass(LGDF)$Phi - unclass(LG)$Phi))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$Phi - unclass(LG)$Phi), digits=18)
  +     all.ok <- FALSE  
  +     } 
  >     
  > LG <- targetQ(L, Target=matrix(c(rep(1,3),rep(0,6),rep(1,3)), 6,2), normalize=TRUE, eps=1e-5)
  > LGDF <- GPFoblq.df(L, normalize = TRUE, eps=1e-5, method = "target", 
  +  	methodArgs=list(Target=matrix(c(rep(1,3),rep(0,6),rep(1,3)), 6,2)))  
  > 
  >   if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  +     all.ok <- FALSE  
  +     } 
  Calculated value is not the same as test value in test rotations 1. Value:
  difference:
  
  Loadings:
          Factor1       Factor2      
  general                            
  picture                            
  blocks                             
  maze                               
  reading                            
  vocab                              
  
                   Factor1     Factor2
  SS loadings 3.719858e-12 5.00393e-12
  >   if( fuzz < max(abs(unclass(LGDF)$Phi - unclass(LG)$Phi))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$Phi - unclass(LG)$Phi), digits=18)
  +     all.ok <- FALSE  
  +     }   	  
  >  
  > # targetT
  > 
  > LG <- targetT(L, Target=matrix(c(rep(1,3),rep(0,6),rep(1,3)), 6,2), normalize=FALSE, eps=1e-5)
  > LGDF <- GPForth.df(L, normalize = FALSE, eps=1e-5, method = "target", 
  +  	methodArgs=list(Target=matrix(c(rep(1,3),rep(0,6),rep(1,3)), 6,2)))  
  >   if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  +     all.ok <- FALSE  
  +     } 
  Calculated value is not the same as test value in test rotations 1. Value:
  difference:
  
  Loadings:
          Factor1       Factor2      
  general                            
  picture                            
  blocks                             
  maze                               
  reading                            
  vocab                              
  
                   Factor1      Factor2
  SS loadings 1.885372e-11 2.512166e-11
  > 
  > LG <- targetT(L, Target=matrix(c(rep(1,3),rep(0,6),rep(1,3)), 6,2), normalize=TRUE, eps=1e-5)
  > LGDF <- GPForth.df(L, normalize = TRUE, eps=1e-5, method = "target", 
  +  	methodArgs=list(Target=matrix(c(rep(1,3),rep(0,6),rep(1,3)), 6,2)))  
  >   if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  +     all.ok <- FALSE  
  +     } 
  >  
  > 
  > A <- matrix(c(0.664, 0.688, 0.492,  0.837,  0.705,  0.82,  0.661, 0.457, 0.765,
  +               0.322, 0.248, 0.304, -0.291, -0.314, -0.377, 0.397, 0.294, 0.428,
  +              -0.075, 0.192, 0.224, 0.037, 0.155,  -0.104, 0.077, 0-.488, 0.009),
  +             ncol = 3)
  > T0 <- matrix(NA, ncol = 3, nrow = 9)
  > T0[1, 1] <- T0[2, 1] <- T0[1, 2] <- 0
  > LG <- targetT(A, Target = T0)
  > LGDF <- GPForth.df(A, method="target", methodArgs=list(Target = T0))
  >   if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  +     all.ok <- FALSE  
  +     } 
  Calculated value is not the same as test value in test rotations 1. Value:
  difference:
  
  Loadings:
        [,1]          [,2]          [,3]         
   [1,]                                          
   [2,]                                          
   [3,]                                          
   [4,]                                          
   [5,]                                          
   [6,]                                          
   [7,]                                          
   [8,]                                          
   [9,]                                          
  
                      [,1]        [,2]         [,3]
  SS loadings 4.298329e-09 1.12457e-08 5.386704e-10
  >  
  > fuzz <- 1e-2 # Because loadings to zero, lower the bar to same results
  > LG <- targetQ(A, Target = T0)
  > LGDF <- GPFoblq.df(A, method="target", methodArgs=list(Target = T0))
  >   if( fuzz < max(abs(unclass(LGDF)$loadings - unclass(LG)$loadings))) {
  +     cat("Calculated value is not the same as test value in test rotations 1. Value:\n")
  +     cat("difference:\n")
  +     print((unclass(LGDF)$loadings - unclass(LG)$loadings), digits=18)
  +     all.ok <- FALSE  
  +     } 
  Calculated value is not the same as test value in test rotations 1. Value:
  difference:
  
  Loadings:
        [,1]          [,2]          [,3]         
   [1,]                                          
   [2,]                                          
   [3,] -4.737575e-01  4.441155e-01              
   [4,]  2.013065e+00 -1.875580e+00 -2.990878e-01
   [5,]  1.786464e+00 -1.663424e+00 -2.666271e-01
   [6,]  2.391433e+00 -2.229573e+00 -3.535882e-01
   [7,] -3.829006e-01  3.582927e-01              
   [8,]  2.033391e-01 -1.933861e-01              
   [9,] -2.683019e-01  2.509629e-01              
  
                 [,1]     [,2]      [,3]
  SS loadings 1.28826 2.348151 0.6468996
  >  
  > # pstT
  > # This won't converge properly
  > # No further investigations performed.
  > 
  >  
  >  
  > cat("tests completed.\n")
  tests completed.
  > 
  > 
  > 
  > if (! all.ok) stop("some tests FAILED")
  Error: some tests FAILED
  Execution halted