r - R6类中的parLapply

我正在寻找在parLapply()对象内的Windows上使用R6，并且注意到(至少在某些情况下)我不需要将R6函数或数据导出到节点。

这是一个我可以在parLapply()中访问私有(private)方法的示例:

require(R6);require(parallel)
square <-
R6Class("square",
        public = list(
            numbers = NA,
            squares = NA,
            initialize = function(numbers,integer) {
                self$numbers <- numbers
                squares <- private$square.numbers()
            }
        ),
        private = list(
            square = function(x) {
                return(x^2)
            },
            square.numbers = function() {
                cl <- makeCluster(detectCores())
                self$squares <- parLapply(cl,
                                          self$numbers,
                                          function (x) private$square(x)
                                          )
                stopCluster(cl)
            }
        ))
##Test
test <- square$new(list(1,2,3))
print(test$squares)
# [[1]]
# [1] 1
#
# [[2]]
# [1] 4
#
# [[3]]
# [1] 9

第二个示例，我还可以访问公共(public)成员:

square2 <-
R6Class("square2",
        public = list(
            numbers = NA,
            squares = NA,
            integer = NA,
            initialize = function(numbers,integer) {
                self$numbers <- numbers
                self$integer <- integer
                squares <- private$square.numbers()
            }
        ),
        private = list(
            square = function(x) {
                return(x^2)
            },
            square.numbers = function() {
                cl <- makeCluster(detectCores())
                self$squares <- parLapply(cl,
                                          self$numbers,
                                          function (x) private$square(x)+self$integer
                                          )
                stopCluster(cl)
            }
        ))
##Test
test2 <- square2$new(list(1,2,3),2)
print(test2$squares)
#[[1]]
#[1] 3
#
#[[2]]
#[1] 6
#
#[[3]]
#[1] 11

我的问题有两个方面:(1)R6怎样使之成为可能，这样我就不需要导出数据对象和函数了； (2)我可以依靠这种行为还是这是这些特定示例的产物？

更新:

在实例化对象之后，此行为似乎也可以使用公共(public)方法和成员起作用:

square3 <- R6Class(
    classname = "square3",
    public = list(
        numbers = NA,
        squares = NA,
        integer = NA,
        square = function(x) {
           return(x^2)
        },
        square.numbers = function() {
            cl <- makeCluster(detectCores())
            self$squares <- parLapply(cl,
                                      self$numbers,
                                   function (x) self$square(x)+self$integer
                                  )
        stopCluster(cl)
    },
    initialize = function(numbers,integer) {
        self$numbers <- numbers
        self$integer <- integer
    }
    )
)
test3.obj <- square3$new(list(1,2,3),2)
test3.obj$square.numbers()
test3.obj$squares

# [[1]]
# [1] 3
#
# [[2]]
# [1] 6
#
# [[3]]
# [1] 11

最佳答案

使用R6类，每次实例化一个对象时，该对象都会在修改后的环境中获取每个函数/方法的副本。这些函数被分配了一个环境，其中self指向对象的公共(public)环境(这是对象的公共(public)外观)，而private指向对象的私有(private)环境。

这与S3方法不同，后者不会在对象的每次实例化时都被复制。

总结:使用R6，一切都包含在对象中；对于S3，该对象不包含方法。

我对使用parLapply不太熟悉，但是我认为依靠parLapply这样的工作是安全的。

关于r - R6类中的parLapply，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/34784932/