Last updated on 2026-06-25 12:00:42 CEST.
| Flavor | Version | Tinstall | Tcheck | Ttotal | Status | Flags |
|---|---|---|---|---|---|---|
| r-devel-linux-x86_64-debian-clang | 2026.6-1 | 1.96 | 39.49 | 41.45 | OK | |
| r-devel-linux-x86_64-debian-gcc | 2026.6-1 | 1.53 | 29.28 | 30.81 | OK | |
| r-devel-linux-x86_64-fedora-clang | 2026.6-1 | 65.87 | OK | |||
| r-devel-linux-x86_64-fedora-gcc | 2026.6-1 | 221.38 | OK | |||
| r-devel-windows-x86_64 | 2026.6-1 | 7.00 | 65.00 | 72.00 | OK | |
| r-patched-linux-x86_64 | 2026.6-1 | 2.01 | 36.88 | 38.89 | OK | |
| r-release-linux-x86_64 | 2025.7-1 | 1.83 | 35.88 | 37.71 | ERROR | |
| r-release-macos-arm64 | 2026.6-1 | 1.00 | 57.00 | 58.00 | OK | |
| r-release-macos-x86_64 | 2026.6-1 | 2.00 | 265.00 | 267.00 | OK | |
| r-release-windows-x86_64 | 2026.6-1 | 6.00 | 83.00 | 89.00 | OK | |
| r-oldrel-macos-arm64 | 2026.6-1 | 1.00 | 55.00 | 56.00 | OK | |
| r-oldrel-macos-x86_64 | 2026.6-1 | 2.00 | 308.00 | 310.00 | OK | |
| r-oldrel-windows-x86_64 | 2026.6-1 | 6.00 | 69.00 | 75.00 | OK |
Version: 2025.7-1
Check: tests
Result: ERROR
Running ‘rotations.R’ [2s/3s]
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] "/home/hornik/tmp/scratch/RtmpBxerg9/RLIBS_11b4782fd081a"
> library()
Packages in library '/home/hornik/tmp/scratch/RtmpBxerg9/RLIBS_11b4782fd081a':
GPArotateDF Derivative Free Gradient Projection Factor
Rotation
GPArotation Gradient Projection Factor Rotation
Packages in library '/home/hornik/tmp/R.check/r-release-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.12+deb14.1-amd64"
version
"#1 SMP PREEMPT_DYNAMIC Debian 7.0.12-2 (2026-06-12)"
nodename
"gimli2"
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
Flavor: r-release-linux-x86_64