Last updated on 2020-02-19 10:49:07 CET.
| Flavor | Version | Tinstall | Tcheck | Ttotal | Status | Flags |
|---|---|---|---|---|---|---|
| r-devel-linux-x86_64-debian-clang | 1.1 | 10.80 | 79.94 | 90.74 | ERROR | |
| r-devel-linux-x86_64-debian-gcc | 1.1 | 9.04 | 62.03 | 71.07 | ERROR | |
| r-devel-linux-x86_64-fedora-clang | 1.1 | 106.20 | ERROR | |||
| r-devel-linux-x86_64-fedora-gcc | 1.1 | 105.36 | ERROR | |||
| r-devel-windows-ix86+x86_64 | 1.1 | 20.00 | 117.00 | 137.00 | OK | |
| r-devel-windows-ix86+x86_64-gcc8 | 1.1 | 28.00 | 162.00 | 190.00 | OK | |
| r-patched-linux-x86_64 | 1.1 | 9.52 | 72.94 | 82.46 | OK | |
| r-patched-solaris-x86 | 1.1 | 145.10 | OK | |||
| r-release-linux-x86_64 | 1.1 | 8.52 | 72.12 | 80.64 | OK | |
| r-release-windows-ix86+x86_64 | 1.1 | 19.00 | 109.00 | 128.00 | OK | |
| r-release-osx-x86_64 | 1.1 | OK | ||||
| r-oldrel-windows-ix86+x86_64 | 1.1 | 10.00 | 111.00 | 121.00 | OK | |
| r-oldrel-osx-x86_64 | 1.1 | OK |
Version: 1.1
Check: examples
Result: ERROR
Running examples in 'RFgroove-Ex.R' failed
The error most likely occurred in:
> base::assign(".ptime", proc.time(), pos = "CheckExEnv")
> ### Name: selectFunctional
> ### Title: Grouped variable selection procedure for functional data
> ### Aliases: selectFunctional
>
> ### ** Examples
>
> data(toyRegFD)
> varSel <- selectFunctional( toyRegFD$FDlist, toyRegFD$Y, normalize=FALSE,
+ dimensionReductionMethod="fpca", nbasisInit=16,
+ verbose=FALSE, ntree=10)
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
----------- FAILURE REPORT --------------
--- failure: the condition has length > 1 ---
--- srcref ---
:
--- package (from environment) ---
RFgroove
--- call from context ---
varImpGroup(object = forest, xdata = design[idxTr, survivalIndexes],
ngroups = i, nvarGroup = nvarGroup[varNames.iter], idxGroup = idxGroup,
groupsNames = varNames.iter, ...)
--- call from argument ---
if (class(xdata) == "data.frame") xdata <- as.matrix(xdata)
--- R stacktrace ---
where 1: varImpGroup(object = forest, xdata = design[idxTr, survivalIndexes],
ngroups = i, nvarGroup = nvarGroup[varNames.iter], idxGroup = idxGroup,
groupsNames = varNames.iter, ...)
where 2: selectGroup(designMatrix, ydata, varNames, nvarGroup, verbose = verbose,
...)
where 3: selectFunctional(toyRegFD$FDlist, toyRegFD$Y, normalize = FALSE,
dimensionReductionMethod = "fpca", nbasisInit = 16, verbose = FALSE,
ntree = 10)
--- value of length: 2 type: logical ---
[1] FALSE FALSE
--- function from context ---
function (object, xdata, ngroups = length(nvarGroup), nvarGroup,
idxGroup, groupsNames = names(nvarGroup), normalize = (length(unique(nvarGroup)) !=
1))
{
if (is.list(idxGroup))
idxGroup <- unlist(idxGroup)
if (!is.numeric(idxGroup) | min(idxGroup) != 0)
stop("'idxGroup' must contain the indexes of the grouped variables starting from 0")
if (is.null(forest <- object$forest))
stop("Error: keepForest")
if (is.null(object$inbag))
stop("Error: keepInbag")
if (class(xdata) == "data.frame")
xdata <- as.matrix(xdata)
if (!is.null(groupsNames)) {
if (length(nvarGroup) != length(groupsNames))
stop("Error: length nvarGroup and groupsNames")
}
M <- object$ntree
Y <- object$y
n <- nrow(xdata)
p <- ncol(xdata)
if (length(nvarGroup) != ngroups) {
stop("Error: number of groups")
}
xdata <- t(xdata)
storage.mode(xdata) <- "double"
if (is.factor(Y)) {
obj <- .C("R_varImpGroup", varImpGroup = numeric(ngroups),
xdata, as.integer(Y), n = as.integer(n), p = as.integer(p),
ntree = as.integer(M), as.integer(aperm(forest$treemap,
c(2, 1, 3))), as.integer(forest$nodestatus),
as.double(forest$xbestsplit), as.integer(forest$bestvar),
as.integer(forest$nodepred), as.integer(forest$ndbigtree),
as.integer(forest$ncat), as.integer(forest$maxcat),
as.integer(length(unique(Y))), ngroups = as.integer(ngroups),
as.integer(nvarGroup), as.integer(max(nvarGroup)),
as.integer(idxGroup), as.integer(object$inbag), as.integer(forest$nrnodes),
PACKAGE = "RFgroove")
}
else {
obj <- .C("R_varImpGroup_Reg", varImpGroup = numeric(ngroups),
xdata, as.double(Y), n = as.integer(n), p = as.integer(p),
ntree = as.integer(M), as.integer(forest$leftDaughter),
as.integer(forest$rightDaughter), as.integer(forest$nodestatus),
as.double(forest$xbestsplit), as.integer(forest$bestvar),
as.double(forest$nodepred), as.integer(forest$ndbigtree),
as.integer(forest$ncat), as.integer(max(forest$ncat)),
ngroups = as.integer(ngroups), as.integer(nvarGroup),
as.integer(max(nvarGroup)), as.integer(idxGroup),
as.integer(object$inbag), as.integer(forest$nrnodes),
PACKAGE = "RFgroove")
}
if (normalize) {
IMP <- obj$varImpGroup/nvarGroup
}
else {
IMP <- obj$varImpGroup
}
if (is.null(groupsNames)) {
names(IMP) <- paste("Gr", 1:ngroups, sep = "")
}
else {
names(IMP) <- groupsNames
}
class(IMP) <- "importance"
return(IMP)
}
<bytecode: 0x7e9cbf8>
<environment: namespace:RFgroove>
--- function search by body ---
Function varImpGroup in namespace RFgroove has this body.
----------- END OF FAILURE REPORT --------------
Error in if (class(xdata) == "data.frame") xdata <- as.matrix(xdata) :
the condition has length > 1
Calls: selectFunctional -> selectGroup -> varImpGroup
Execution halted
Flavor: r-devel-linux-x86_64-debian-clang
Version: 1.1
Check: examples
Result: ERROR
Running examples in ‘RFgroove-Ex.R’ failed
The error most likely occurred in:
> base::assign(".ptime", proc.time(), pos = "CheckExEnv")
> ### Name: selectFunctional
> ### Title: Grouped variable selection procedure for functional data
> ### Aliases: selectFunctional
>
> ### ** Examples
>
> data(toyRegFD)
> varSel <- selectFunctional( toyRegFD$FDlist, toyRegFD$Y, normalize=FALSE,
+ dimensionReductionMethod="fpca", nbasisInit=16,
+ verbose=FALSE, ntree=10)
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
----------- FAILURE REPORT --------------
--- failure: the condition has length > 1 ---
--- srcref ---
:
--- package (from environment) ---
RFgroove
--- call from context ---
varImpGroup(object = forest, xdata = design[idxTr, survivalIndexes],
ngroups = i, nvarGroup = nvarGroup[varNames.iter], idxGroup = idxGroup,
groupsNames = varNames.iter, ...)
--- call from argument ---
if (class(xdata) == "data.frame") xdata <- as.matrix(xdata)
--- R stacktrace ---
where 1: varImpGroup(object = forest, xdata = design[idxTr, survivalIndexes],
ngroups = i, nvarGroup = nvarGroup[varNames.iter], idxGroup = idxGroup,
groupsNames = varNames.iter, ...)
where 2: selectGroup(designMatrix, ydata, varNames, nvarGroup, verbose = verbose,
...)
where 3: selectFunctional(toyRegFD$FDlist, toyRegFD$Y, normalize = FALSE,
dimensionReductionMethod = "fpca", nbasisInit = 16, verbose = FALSE,
ntree = 10)
--- value of length: 2 type: logical ---
[1] FALSE FALSE
--- function from context ---
function (object, xdata, ngroups = length(nvarGroup), nvarGroup,
idxGroup, groupsNames = names(nvarGroup), normalize = (length(unique(nvarGroup)) !=
1))
{
if (is.list(idxGroup))
idxGroup <- unlist(idxGroup)
if (!is.numeric(idxGroup) | min(idxGroup) != 0)
stop("'idxGroup' must contain the indexes of the grouped variables starting from 0")
if (is.null(forest <- object$forest))
stop("Error: keepForest")
if (is.null(object$inbag))
stop("Error: keepInbag")
if (class(xdata) == "data.frame")
xdata <- as.matrix(xdata)
if (!is.null(groupsNames)) {
if (length(nvarGroup) != length(groupsNames))
stop("Error: length nvarGroup and groupsNames")
}
M <- object$ntree
Y <- object$y
n <- nrow(xdata)
p <- ncol(xdata)
if (length(nvarGroup) != ngroups) {
stop("Error: number of groups")
}
xdata <- t(xdata)
storage.mode(xdata) <- "double"
if (is.factor(Y)) {
obj <- .C("R_varImpGroup", varImpGroup = numeric(ngroups),
xdata, as.integer(Y), n = as.integer(n), p = as.integer(p),
ntree = as.integer(M), as.integer(aperm(forest$treemap,
c(2, 1, 3))), as.integer(forest$nodestatus),
as.double(forest$xbestsplit), as.integer(forest$bestvar),
as.integer(forest$nodepred), as.integer(forest$ndbigtree),
as.integer(forest$ncat), as.integer(forest$maxcat),
as.integer(length(unique(Y))), ngroups = as.integer(ngroups),
as.integer(nvarGroup), as.integer(max(nvarGroup)),
as.integer(idxGroup), as.integer(object$inbag), as.integer(forest$nrnodes),
PACKAGE = "RFgroove")
}
else {
obj <- .C("R_varImpGroup_Reg", varImpGroup = numeric(ngroups),
xdata, as.double(Y), n = as.integer(n), p = as.integer(p),
ntree = as.integer(M), as.integer(forest$leftDaughter),
as.integer(forest$rightDaughter), as.integer(forest$nodestatus),
as.double(forest$xbestsplit), as.integer(forest$bestvar),
as.double(forest$nodepred), as.integer(forest$ndbigtree),
as.integer(forest$ncat), as.integer(max(forest$ncat)),
ngroups = as.integer(ngroups), as.integer(nvarGroup),
as.integer(max(nvarGroup)), as.integer(idxGroup),
as.integer(object$inbag), as.integer(forest$nrnodes),
PACKAGE = "RFgroove")
}
if (normalize) {
IMP <- obj$varImpGroup/nvarGroup
}
else {
IMP <- obj$varImpGroup
}
if (is.null(groupsNames)) {
names(IMP) <- paste("Gr", 1:ngroups, sep = "")
}
else {
names(IMP) <- groupsNames
}
class(IMP) <- "importance"
return(IMP)
}
<bytecode: 0x55b578990fe8>
<environment: namespace:RFgroove>
--- function search by body ---
Function varImpGroup in namespace RFgroove has this body.
----------- END OF FAILURE REPORT --------------
Error in if (class(xdata) == "data.frame") xdata <- as.matrix(xdata) :
the condition has length > 1
Calls: selectFunctional -> selectGroup -> varImpGroup
Execution halted
Flavor: r-devel-linux-x86_64-debian-gcc
Version: 1.1
Check: compiled code
Result: NOTE
File ‘RFgroove/libs/RFgroove.so’:
Found no calls to: ‘R_registerRoutines’, ‘R_useDynamicSymbols’
It is good practice to register native routines and to disable symbol
search.
See ‘Writing portable packages’ in the ‘Writing R Extensions’ manual.
Flavors: r-devel-linux-x86_64-fedora-clang, r-devel-linux-x86_64-fedora-gcc
Version: 1.1
Check: examples
Result: ERROR
Running examples in ‘RFgroove-Ex.R’ failed
The error most likely occurred in:
> ### Name: selectFunctional
> ### Title: Grouped variable selection procedure for functional data
> ### Aliases: selectFunctional
>
> ### ** Examples
>
> data(toyRegFD)
> varSel <- selectFunctional( toyRegFD$FDlist, toyRegFD$Y, normalize=FALSE,
+ dimensionReductionMethod="fpca", nbasisInit=16,
+ verbose=FALSE, ntree=10)
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
----------- FAILURE REPORT --------------
--- failure: the condition has length > 1 ---
--- srcref ---
:
--- package (from environment) ---
RFgroove
--- call from context ---
varImpGroup(object = forest, xdata = design[idxTr, survivalIndexes],
ngroups = i, nvarGroup = nvarGroup[varNames.iter], idxGroup = idxGroup,
groupsNames = varNames.iter, ...)
--- call from argument ---
if (class(xdata) == "data.frame") xdata <- as.matrix(xdata)
--- R stacktrace ---
where 1: varImpGroup(object = forest, xdata = design[idxTr, survivalIndexes],
ngroups = i, nvarGroup = nvarGroup[varNames.iter], idxGroup = idxGroup,
groupsNames = varNames.iter, ...)
where 2: selectGroup(designMatrix, ydata, varNames, nvarGroup, verbose = verbose,
...)
where 3: selectFunctional(toyRegFD$FDlist, toyRegFD$Y, normalize = FALSE,
dimensionReductionMethod = "fpca", nbasisInit = 16, verbose = FALSE,
ntree = 10)
--- value of length: 2 type: logical ---
[1] FALSE FALSE
--- function from context ---
function (object, xdata, ngroups = length(nvarGroup), nvarGroup,
idxGroup, groupsNames = names(nvarGroup), normalize = (length(unique(nvarGroup)) !=
1))
{
if (is.list(idxGroup))
idxGroup <- unlist(idxGroup)
if (!is.numeric(idxGroup) | min(idxGroup) != 0)
stop("'idxGroup' must contain the indexes of the grouped variables starting from 0")
if (is.null(forest <- object$forest))
stop("Error: keepForest")
if (is.null(object$inbag))
stop("Error: keepInbag")
if (class(xdata) == "data.frame")
xdata <- as.matrix(xdata)
if (!is.null(groupsNames)) {
if (length(nvarGroup) != length(groupsNames))
stop("Error: length nvarGroup and groupsNames")
}
M <- object$ntree
Y <- object$y
n <- nrow(xdata)
p <- ncol(xdata)
if (length(nvarGroup) != ngroups) {
stop("Error: number of groups")
}
xdata <- t(xdata)
storage.mode(xdata) <- "double"
if (is.factor(Y)) {
obj <- .C("R_varImpGroup", varImpGroup = numeric(ngroups),
xdata, as.integer(Y), n = as.integer(n), p = as.integer(p),
ntree = as.integer(M), as.integer(aperm(forest$treemap,
c(2, 1, 3))), as.integer(forest$nodestatus),
as.double(forest$xbestsplit), as.integer(forest$bestvar),
as.integer(forest$nodepred), as.integer(forest$ndbigtree),
as.integer(forest$ncat), as.integer(forest$maxcat),
as.integer(length(unique(Y))), ngroups = as.integer(ngroups),
as.integer(nvarGroup), as.integer(max(nvarGroup)),
as.integer(idxGroup), as.integer(object$inbag), as.integer(forest$nrnodes),
PACKAGE = "RFgroove")
}
else {
obj <- .C("R_varImpGroup_Reg", varImpGroup = numeric(ngroups),
xdata, as.double(Y), n = as.integer(n), p = as.integer(p),
ntree = as.integer(M), as.integer(forest$leftDaughter),
as.integer(forest$rightDaughter), as.integer(forest$nodestatus),
as.double(forest$xbestsplit), as.integer(forest$bestvar),
as.double(forest$nodepred), as.integer(forest$ndbigtree),
as.integer(forest$ncat), as.integer(max(forest$ncat)),
ngroups = as.integer(ngroups), as.integer(nvarGroup),
as.integer(max(nvarGroup)), as.integer(idxGroup),
as.integer(object$inbag), as.integer(forest$nrnodes),
PACKAGE = "RFgroove")
}
if (normalize) {
IMP <- obj$varImpGroup/nvarGroup
}
else {
IMP <- obj$varImpGroup
}
if (is.null(groupsNames)) {
names(IMP) <- paste("Gr", 1:ngroups, sep = "")
}
else {
names(IMP) <- groupsNames
}
class(IMP) <- "importance"
return(IMP)
}
<bytecode: 0x9190d00>
<environment: namespace:RFgroove>
--- function search by body ---
Function varImpGroup in namespace RFgroove has this body.
----------- END OF FAILURE REPORT --------------
Error in if (class(xdata) == "data.frame") xdata <- as.matrix(xdata) :
the condition has length > 1
Calls: selectFunctional -> selectGroup -> varImpGroup
Execution halted
Flavor: r-devel-linux-x86_64-fedora-clang
Version: 1.1
Check: examples
Result: ERROR
Running examples in ‘RFgroove-Ex.R’ failed
The error most likely occurred in:
> ### Name: selectFunctional
> ### Title: Grouped variable selection procedure for functional data
> ### Aliases: selectFunctional
>
> ### ** Examples
>
> data(toyRegFD)
> varSel <- selectFunctional( toyRegFD$FDlist, toyRegFD$Y, normalize=FALSE,
+ dimensionReductionMethod="fpca", nbasisInit=16,
+ verbose=FALSE, ntree=10)
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
Warning in if (class(Lmat) == "try-error") { :
the condition has length > 1 and only the first element will be used
----------- FAILURE REPORT --------------
--- failure: the condition has length > 1 ---
--- srcref ---
:
--- package (from environment) ---
RFgroove
--- call from context ---
varImpGroup(object = forest, xdata = design[idxTr, survivalIndexes],
ngroups = i, nvarGroup = nvarGroup[varNames.iter], idxGroup = idxGroup,
groupsNames = varNames.iter, ...)
--- call from argument ---
if (class(xdata) == "data.frame") xdata <- as.matrix(xdata)
--- R stacktrace ---
where 1: varImpGroup(object = forest, xdata = design[idxTr, survivalIndexes],
ngroups = i, nvarGroup = nvarGroup[varNames.iter], idxGroup = idxGroup,
groupsNames = varNames.iter, ...)
where 2: selectGroup(designMatrix, ydata, varNames, nvarGroup, verbose = verbose,
...)
where 3: selectFunctional(toyRegFD$FDlist, toyRegFD$Y, normalize = FALSE,
dimensionReductionMethod = "fpca", nbasisInit = 16, verbose = FALSE,
ntree = 10)
--- value of length: 2 type: logical ---
[1] FALSE FALSE
--- function from context ---
function (object, xdata, ngroups = length(nvarGroup), nvarGroup,
idxGroup, groupsNames = names(nvarGroup), normalize = (length(unique(nvarGroup)) !=
1))
{
if (is.list(idxGroup))
idxGroup <- unlist(idxGroup)
if (!is.numeric(idxGroup) | min(idxGroup) != 0)
stop("'idxGroup' must contain the indexes of the grouped variables starting from 0")
if (is.null(forest <- object$forest))
stop("Error: keepForest")
if (is.null(object$inbag))
stop("Error: keepInbag")
if (class(xdata) == "data.frame")
xdata <- as.matrix(xdata)
if (!is.null(groupsNames)) {
if (length(nvarGroup) != length(groupsNames))
stop("Error: length nvarGroup and groupsNames")
}
M <- object$ntree
Y <- object$y
n <- nrow(xdata)
p <- ncol(xdata)
if (length(nvarGroup) != ngroups) {
stop("Error: number of groups")
}
xdata <- t(xdata)
storage.mode(xdata) <- "double"
if (is.factor(Y)) {
obj <- .C("R_varImpGroup", varImpGroup = numeric(ngroups),
xdata, as.integer(Y), n = as.integer(n), p = as.integer(p),
ntree = as.integer(M), as.integer(aperm(forest$treemap,
c(2, 1, 3))), as.integer(forest$nodestatus),
as.double(forest$xbestsplit), as.integer(forest$bestvar),
as.integer(forest$nodepred), as.integer(forest$ndbigtree),
as.integer(forest$ncat), as.integer(forest$maxcat),
as.integer(length(unique(Y))), ngroups = as.integer(ngroups),
as.integer(nvarGroup), as.integer(max(nvarGroup)),
as.integer(idxGroup), as.integer(object$inbag), as.integer(forest$nrnodes),
PACKAGE = "RFgroove")
}
else {
obj <- .C("R_varImpGroup_Reg", varImpGroup = numeric(ngroups),
xdata, as.double(Y), n = as.integer(n), p = as.integer(p),
ntree = as.integer(M), as.integer(forest$leftDaughter),
as.integer(forest$rightDaughter), as.integer(forest$nodestatus),
as.double(forest$xbestsplit), as.integer(forest$bestvar),
as.double(forest$nodepred), as.integer(forest$ndbigtree),
as.integer(forest$ncat), as.integer(max(forest$ncat)),
ngroups = as.integer(ngroups), as.integer(nvarGroup),
as.integer(max(nvarGroup)), as.integer(idxGroup),
as.integer(object$inbag), as.integer(forest$nrnodes),
PACKAGE = "RFgroove")
}
if (normalize) {
IMP <- obj$varImpGroup/nvarGroup
}
else {
IMP <- obj$varImpGroup
}
if (is.null(groupsNames)) {
names(IMP) <- paste("Gr", 1:ngroups, sep = "")
}
else {
names(IMP) <- groupsNames
}
class(IMP) <- "importance"
return(IMP)
}
<bytecode: 0x826aaa0>
<environment: namespace:RFgroove>
--- function search by body ---
Function varImpGroup in namespace RFgroove has this body.
----------- END OF FAILURE REPORT --------------
Error in if (class(xdata) == "data.frame") xdata <- as.matrix(xdata) :
the condition has length > 1
Calls: selectFunctional -> selectGroup -> varImpGroup
Execution halted
Flavor: r-devel-linux-x86_64-fedora-gcc