ref (version 0.95)

deref: dereferencing references

Description

This functions allow to access a referenced object. deref(ref) returns the object, and deref(ref) <- value assigns to the referenced object.

Usage

deref(ref)
deref(ref) <- value
#the following does not pass R CMD CHECK
#deref<-(ref, value)
#deref(ref)[1] <- value  # subsetted assignment appears to be inefficent in S+.

Arguments

ref

a reference as returned by ref or as.ref

value

a value to be assigned to the reference

Value

• deref returns the referenced object. "deref<-" returns a reference to the modified object, see ref.

Details

deref and deref<- provide convenient access to objects in other environments/frames. In fact they are wrappers to get and assign. However, convenient does not neccessarily means efficient. If performance is an issue, the direct use of new.env, substitute and eval may give better results. See the examples below.

References

Writing R Extensions

See Also

ref, as.ref, get, assign, substitute, eval

Examples

# Simple usage example
  x <- cbind(1:5, 1:5)          # take some object
  rx <- as.ref(x)               # wrap it into a reference
  deref(rx)                     # read it through the reference
  deref(rx) <- rbind(1:5, 1:5)  # replace the object in the reference by another one
  deref(rx)[1, ]                # read part of the object
  deref(rx)[1, ] <- 5:1         # replace part of the object
  deref(rx)                     # see the change
  cat("For examples how to pass by references see the Performance test examples at the help pages
")

 ## Performance test examples showing actually passing by reference
  # define test size
  nmatrix <- 1000   # matrix size of nmatrix by nmatrix
  nloop   <- 10     # you might want to use less loops in S+, you might want more in R versions before 1.8

  # Performance test using ref
  t1 <- function(){ # outer function
    m <- matrix(nrow=nmatrix, ncol=nmatrix)
    a <- as.ref(m)
      t2(a)
    m[1,1]
  }
  # subsetting deref is slower (by factor 75 slower since R 1.8 compared to previous versions, and much, much slower in S+) ...
  t2 <- function(ref){ # inner function
    cat("timing", timing.wrapper(
      for(i in 1:nloop)
        deref(ref)[1,1] <- i
    ), "\n")
  }
  if (is.R())gc()
  t1()
  # ... than using substitute
  t2 <- function(ref){
    obj <- as.name(ref$name)
    loc <- ref$loc
    cat("timing", timing.wrapper(
      for(i in 1:nloop)
        eval(substitute(x[1,1] <- i, list(x=obj, i=i)), loc)
    ), "\n")
  }
  if (is.R())gc()
  t1()


  # Performance test using Object (R only)
  # see Henrik Bengtsson package(oo)
  Object <- function(){
    this <- list(env.=new.env());
    class(this) <- "Object";
    this;
  }
  "$.Object" <- function(this, name){
    get(name, envir=unclass(this)$env.);
  }
  "$<-.Object" <- function(this, name, value){
    assign(name, value, envir=unclass(this)$env.);
    this;
  }
  # outer function
  t1 <- function(){
    o <- Object()
    o$m <- matrix(nrow=nmatrix, ncol=nmatrix)
      t2(o)
    o$m[1,1]
  }
  # subsetting o$m is slower ...
  t2 <- function(o){
    cat("timing", timing.wrapper(
      for(i in 1:nloop)
        o$m[1,1] <- i
    ), "\n")
  }
  if (is.R())gc()
  t1()
  # ... than using substitute
  t2 <- function(o){
    env <- unclass(o)$env.
    cat("timing", timing.wrapper(
      for(i in 1:nloop)
        eval(substitute(m[1,1] <- i, list(i=i)), env)
    ), "\n")
  }
  if (is.R())gc()
  t1()