R: Attribute setting by reference

getsetattr {bit} | R Documentation

## Attribute setting by reference

### Description

Function `setattr` sets a singe attribute and function `setattributes` sets a list of attributes.

### Usage

    getsetattr(x, which, value)

    setattr(x, which, value)

    setattributes(x, attributes)

### Arguments

`x` | an R object
`which` | name of the attribute
`value` | value of the attribute, use NULL to remove this attribute
`attributes` | a named list of attribute values

### Details

The attributes of 'x' are changed in place without copying x. function `setattributes` does only change the named attributes, it does not delete the non-names attributes like `attributes` does.

### Value

invisible(), we do not return the changed object to remind you of the fact that this function is called for its side-effect of changing its input object.

### Functions

- `setattr`:

- `setattributes`:

### Author(s)

Jens Oehlschlägel

### References

Writing R extensions – System and foreign language interfaces – Handling R objects in C – Attributes (Version 2.11.1 (2010-06-03 ) R Development)

### See Also

`attr` `unattr`

### Examples

      x <- as.single(runif(10))
      attr(x, "Csingle")

      f <- function(x)attr(x, "Csingle") <- NULL
      g <- function(x)setattr(x, "Csingle", NULL)

      f(x)
      x
      g(x)
      x

     ## Not run:

      # restart R
      library(bit)

      mysingle <- function(length = 0){
        ret <- double(length)
        setattr(ret, "Csingle", TRUE)
        ret
      }

      # show that mysinge gives exactly the same result as single
      identical(single(10), mysingle(10))

      # look at the speedup and memory-savings of mysingle compared to single
      system.time(mysingle(1e7))
      memory.size(max=TRUE)
      system.time(single(1e7))
      memory.size(max=TRUE)

      # look at the memory limits
      # on my win32 machine the first line fails beause of not enough RAM, the second works
      x <- single(1e8)
      x <- mysingle(1e8)

      # .g. performance with factors
      x <- rep(factor(letters), length.out=1e7)
      x[1:10]
      # look how fast one can do this
      system.time(setattr(x, "levels", rev(letters)))
      x[1:10]
      # look at the performance loss in time caused by the non-needed copying
      system.time(levels(x) <- letters)
      x[1:10]

      # restart R
      library(bit)

      simplefactor <- function(n){
        factor(rep(1:2, length.out=n))
      }

      mysimplefactor <- function(n){
        ret <- rep(1:2, length.out=n)
        setattr(ret, "levels", as.character(1:2))
        setattr(ret, "class", "factor")
        ret
      }

      identical(simplefactor(10), mysimplefactor(10))

      system.time(x <- mysimplefactor(1e7))
      memory.size(max=TRUE)
      system.time(setattr(x, "levels", c("a","b")))
      memory.size(max=TRUE)
      x[1:4]
      memory.size(max=TRUE)
      rm(x)
      gc()

      system.time(x <- simplefactor(1e7))
      memory.size(max=TRUE)
      system.time(levels(x) <- c("x","y"))
      memory.size(max=TRUE)
      x[1:4]
      memory.size(max=TRUE)
      rm(x)
      gc()

    ## End(Not run)

[Package bit version 4.0.3 Index]