Usuarios expertos de R, ¿qué hay en su .Rprofile? [cerrado]

Siempre he encontrado que los archivos de perfil de inicio de otras personas son útiles e instructivos sobre el idioma. Además, aunque tengo algo de personalización para Bash y Vim , no tengo nada para R.

Por ejemplo, una cosa que siempre quise son colores diferentes para el texto de entrada y salida en un terminal de ventana, y tal vez incluso el resaltado de sintaxis.

Aquí esta el mio. No te ayudará con el color, pero lo obtengo de ESS y Emacs ...

options("width"=160)                # wide display with multiple monitors
options("digits.secs"=3)            # show sub-second time stamps

r <- getOption("repos")             # hard code the US repo for CRAN
r["CRAN"] <- "http://cran.us.r-project.org"
options(repos = r)
rm(r)

## put something this is your .Rprofile to customize the defaults
setHook(packageEvent("grDevices", "onLoad"),
        function(...) grDevices::X11.options(width=8, height=8, 
                                             xpos=0, pointsize=10, 
                                             #type="nbcairo"))  # Cairo device
                                             #type="cairo"))    # other Cairo dev
                                             type="xlib"))      # old default

## from the AER book by Zeileis and Kleiber
options(prompt="R> ", digits=4, show.signif.stars=FALSE)


options("pdfviewer"="okular")         # on Linux, use okular as the pdf viewer

options(stringsAsFactors=FALSE)

Aunque en realidad no tengo eso en mi .Rprofile, porque podría romper el código de mis coautores, desearía que fuera el predeterminado. ¿Por qué?

1) Los vectores de caracteres usan menos memoria (pero apenas);

2) Más importante aún, evitaríamos problemas como:

> x <- factor(c("a","b","c"))
> x
[1] a b c
Levels: a b c
> x <- c(x, "d")
> x
[1] "1" "2" "3" "d"

y

> x <- factor(c("a","b","c"))
> x[1:2] <- c("c", "d")
Warning message:
In `[<-.factor`(`*tmp*`, 1:2, value = c("c", "d")) :
  invalid factor level, NAs generated

Los factores son excelentes cuando los necesita (p. Ej., Implementar el ordenamiento en gráficos), pero son una molestia la mayor parte del tiempo.

Odio escribir las palabras completas 'cabeza', 'resumen', 'nombres' cada vez, así que uso alias.

Puede poner alias en su archivo .Rprofile, pero tiene que usar la ruta completa a la función (por ejemplo, utils :: head) de lo contrario no funcionará.

# aliases
s <- base::summary
h <- utils::head
n <- base::names

EDIT: para responder a su pregunta, puede utilizar el colorout paquete para tener diferentes colores en el terminal. ¡Frio! :-)

Aquí está el mío. Siempre uso el repositorio principal de cran, y tengo un código para facilitar la fuente del código del paquete en desarrollo.

.First <- function() {
    library(graphics)
    options("repos" = c(CRAN = "http://cran.r-project.org/"))
    options("device" = "quartz")
}

packages <- list(
  "describedisplay" = "~/ggobi/describedisplay",
  "linval" = "~/ggobi/linval", 

  "ggplot2" =  "~/documents/ggplot/ggplot",
  "qtpaint" =  "~/documents/cranvas/qtpaint", 
  "tourr" =    "~/documents/tour/tourr", 
  "tourrgui" = "~/documents/tour/tourr-gui", 
  "prodplot" = "~/documents/categorical-grammar"
)

l <- function(pkg) {
  pkg <- tolower(deparse(substitute(pkg)))
  if (is.null(packages[[pkg]])) {
    path <- file.path("~/documents", pkg, pkg)
  } else {
    path <- packages[pkg]
  }

  source(file.path(path, "load.r"))  
}

test <- function(path) {
  path <- deparse(substitute(path))
  source(file.path("~/documents", path, path, "test.r"))  
}

Me gusta guardar mi historial de comandos R y tenerlo disponible cada vez que ejecuto R:

En el shell o .bashrc:

export R_HISTFILE=~/.Rhistory

en .Rprofile:

.Last <- function() {
        if (!any(commandArgs()=='--no-readline') && interactive()){
                require(utils)
                try(savehistory(Sys.getenv("R_HISTFILE")))
        }
}

Aquí hay dos funciones que encuentro útiles para trabajar con Windows.

El primero convierte la \s en /.

.repath <- function() {
   cat('Paste windows file path and hit RETURN twice')
   x <- scan(what = "")
   xa <- gsub('\\\\', '/', x)
   writeClipboard(paste(xa, collapse=" "))
   cat('Here\'s your de-windowsified path. (It\'s also on the clipboard.)\n', xa, '\n')
 }

El segundo abre el directorio de trabajo en una nueva ventana del explorador.

getw <- function() {
    suppressWarnings(shell(paste("explorer",  gsub('/', '\\\\', getwd()))))
}

Tengo este truco más dinámico para usar el ancho completo del terminal, que intenta leer desde la variable de entorno COLUMNS (en Linux):

tryCatch(
  {options(
      width = as.integer(Sys.getenv("COLUMNS")))},
  error = function(err) {
    write("Can't get your terminal width. Put ``export COLUMNS'' in your \
           .bashrc. Or something. Setting width to 120 chars",
           stderr());
    options(width=120)}
)

De esta manera, R usará todo el ancho incluso cuando cambie el tamaño de la ventana de su terminal.

La mayoría de mis funciones personales y bibliotecas cargadas están en el script Rfunctions.r

source("c:\\data\\rprojects\\functions\\Rfunctions.r")


.First <- function(){
   cat("\n Rrrr! The statistics program for Pirates !\n\n")

  }

  .Last <- function(){
   cat("\n Rrrr! Avast Ye, YO HO!\n\n")

  }


#===============================================================
# Tinn-R: necessary packages
#===============================================================
library(utils)
necessary = c('svIDE', 'svIO', 'svSocket', 'R2HTML')
if(!all(necessary %in% installed.packages()[, 'Package']))
  install.packages(c('SciViews', 'R2HTML'), dep = T)

options(IDE = 'C:/Tinn-R/bin/Tinn-R.exe')
options(use.DDE = T)

library(svIDE)
library(svIO)
library(svSocket)
library(R2HTML)
guiDDEInstall()
shell(paste("mkdir C:\\data\\rplots\\plottemp", gsub('-','',Sys.Date()), sep=""))
pldir <- paste("C:\\data\\rplots\\plottemp", gsub('-','',Sys.Date()), sep="")

plot.str <-c('savePlot(paste(pldir,script,"\\BeachSurveyFreq.pdf",sep=""),type="pdf")')

Aquí está de mi ~ / .Rprofile , diseñado para Mac y Linux.

Esto hace que los errores sean más fáciles de ver.

options(showWarnCalls=T, showErrorCalls=T)

Odio la elección del menú CRAN, así que configúrelo en uno bueno.

options(repos=c("http://cran.cnr.Berkeley.edu","http://cran.stat.ucla.edu"))

Más historia!

Sys.setenv(R_HISTSIZE='100000')

Lo siguiente es para ejecutar en Mac OSX desde la terminal (que prefiero en gran medida a R.app porque es más estable, y puede organizar su trabajo por directorio; también asegúrese de obtener un buen ~ / .inputrc ). Por defecto, obtienes una pantalla X11, que no se ve tan bien; esto en cambio da una pantalla de cuarzo igual que la GUI. Se ifsupone que la declaración atrapará el caso cuando esté ejecutando R desde el terminal en Mac.

f = pipe("uname")
if (.Platform$GUI == "X11" && readLines(f)=="Darwin") {
  # http://www.rforge.net/CarbonEL/
  library("grDevices")
  library("CarbonEL")
  options(device='quartz')
  Sys.unsetenv("DISPLAY")
}
close(f); rm(f)

Y precargar algunas bibliotecas,

library(plyr)
library(stringr)
library(RColorBrewer)
if (file.exists("~/util.r")) {
  source("~/util.r")
}

donde util.r es una bolsa aleatoria de cosas que uso, bajo flujo.

Además, dado que otras personas mencionaron el ancho de la consola, así es como lo hago.

if ( (numcol <-Sys.getenv("COLUMNS")) != "") {
  numcol = as.integer(numcol)
  options(width= numcol - 1)
} else if (system("stty -a &>/dev/null") == 0) {
  # mac specific?  probably bad in the R GUI too.
  numcol = as.integer(sub(".* ([0-9]+) column.*", "\\1", system("stty -a", intern=T)[1]))
  if (numcol > 0)
    options(width=  numcol - 1 )
}
rm(numcol)

En realidad, esto no se .Rprofiledebe a que debe volver a ejecutarlo cada vez que cambia el tamaño de la ventana del terminal. Lo tengo y util.rluego lo obtengo según sea necesario.

Aquí están los míos:

.First <- function () {
  options(device="quartz")
}

.Last <- function () {
  if (!any(commandArgs() == '--no-readline') && interactive()) {
    require(utils)
    try(savehistory(Sys.getenv("R_HISTFILE")))
  }
}

# Slightly more flexible than as.Date
# my.as.Date("2009-01-01") == my.as.Date(2009, 1, 1) == as.Date("2009-01-01")
my.as.Date <- function (a, b=NULL, c=NULL, ...) {
  if (class(a) != "character")
    return (as.Date(sprintf("%d-%02d-%02d", a, b, c)))
  else
    return (as.Date(a))
}

# Some useful aliases
cd <- setwd
pwd <- getwd
lss <- dir
asd <- my.as.Date # examples: asd("2009-01-01") == asd(2009, 1, 1) == as.Date("2009-01-01")
last <- function (x, n=1, ...) tail(x, n=n, ...)

# Set proxy for all web requests
Sys.setenv(http_proxy="http://192.168.0.200:80/")

# Search RPATH for file <fn>.  If found, return full path to it
search.path <- function(fn,
     paths = strsplit(chartr("\\", "/", Sys.getenv("RPATH")), split =
                switch(.Platform$OS.type, windows = ";", ":"))[[1]]) {
  for(d in paths)
     if (file.exists(f <- file.path(d, fn)))
        return(f)
  return(NULL)
}

# If loading in an environment that doesn't respect my RPATH environment
# variable, set it here
if (Sys.getenv("RPATH") == "") {
  Sys.setenv(RPATH=file.path(path.expand("~"), "Library", "R", "source"))
}

# Load commonly used functions
if (interactive())
  source(search.path("afazio.r"))

# If no R_HISTFILE environment variable, set default
if (Sys.getenv("R_HISTFILE") == "") {
  Sys.setenv(R_HISTFILE=file.path("~", ".Rhistory"))
}

# Override q() to not save by default.
# Same as saying q("no")
q <- function (save="no", ...) {
  quit(save=save, ...)
}

# ---------- My Environments ----------
#
# Rather than starting R from within different directories, I prefer to
# switch my "environment" easily with these functions.  An "environment" is
# simply a directory that contains analysis of a particular topic.
# Example usage:
# > load.env("markets")  # Load US equity markets analysis environment
# > # ... edit some .r files in my environment
# > reload()             # Re-source .r/.R files in my environment
#
# On next startup of R, I will automatically be placed into the last
# environment I entered

# My current environment
.curr.env = NULL

# File contains name of the last environment I entered
.last.env.file = file.path(path.expand("~"), ".Rlastenv")

# Parent directory where all of my "environment"s are contained
.parent.env.dir = file.path(path.expand("~"), "Analysis")

# Create parent directory if it doesn't already exist
if (!file.exists(.parent.env.dir))
  dir.create(.parent.env.dir)

load.env <- function (string, save=TRUE) {
  # Load all .r/.R files in <.parent.env.dir>/<string>/
  cd(file.path(.parent.env.dir, string))
  for (file in lss()) {
    if (substr(file, nchar(file)-1, nchar(file)+1) %in% c(".r", ".R"))
      source(file)
  }
  .curr.env <<- string
  # Save current environment name to file
  if (save == TRUE) writeLines(.curr.env, .last.env.file)
  # Let user know environment switch was successful
  print (paste(" -- in ", string, " environment -- "))
}

# "reload" current environment.
reload <- resource <- function () {
  if (!is.null(.curr.env))
    load.env(.curr.env, save=FALSE)
  else
    print (" -- not in environment -- ")
}

# On startup, go straight to the environment I was last working in
if (interactive() && file.exists(.last.env.file)) {
  load.env(readLines(.last.env.file))
}

sink(file = 'R.log', split=T)

options(scipen=5)

.ls.objects <- function (pos = 1, pattern, order.by = "Size", decreasing=TRUE, head =     TRUE, n = 10) {
  # based on postings by Petr Pikal and David Hinds to the r-help list in 2004
  # modified by: Dirk Eddelbuettel (http://stackoverflow.com/questions/1358003/tricks-to-    manage-the-available-memory-in-an-r-session) 
  # I then gave it a few tweaks (show size as megabytes and use defaults that I like)
  # a data frame of the objects and their associated storage needs.
  napply <- function(names, fn) sapply(names, function(x)
          fn(get(x, pos = pos)))
  names <- ls(pos = pos, pattern = pattern)
  obj.class <- napply(names, function(x) as.character(class(x))[1])
  obj.mode <- napply(names, mode)
  obj.type <- ifelse(is.na(obj.class), obj.mode, obj.class)
  obj.size <- napply(names, object.size) / 10^6 # megabytes
  obj.dim <- t(napply(names, function(x)
            as.numeric(dim(x))[1:2]))
  vec <- is.na(obj.dim)[, 1] & (obj.type != "function")
  obj.dim[vec, 1] <- napply(names, length)[vec]
  out <- data.frame(obj.type, obj.size, obj.dim)
  names(out) <- c("Type", "Size", "Rows", "Columns")
  out <- out[order(out[[order.by]], decreasing=decreasing), ]
  if (head)
    out <- head(out, n)
  out
}

Haga que data.frames se muestre como 'head', solo sin tener que escribir 'head'

print.data.frame <- function(df) {
   if (nrow(df) > 10) {
      base::print.data.frame(head(df, 5))
      cat("----\n")
      base::print.data.frame(tail(df, 5))
   } else {
      base::print.data.frame(df)
   }
}

( ¿Cómo hacer que la 'cabeza' se aplique automáticamente a la salida? )

A menudo tengo una cadena de llamadas de depuración que necesito llamar y descomentarlas puede ser muy tedioso. Con la ayuda de la comunidad SO , busqué la siguiente solución e inserté esto en mi .Rprofile.site.# BROWSERestá allí para mis tareas de Eclipse, de modo que tenga una visión general de las llamadas del navegador en la ventana Vista de tareas.

# turn debugging on or off
# place "browser(expr = isTRUE(getOption("debug"))) # BROWSER" in your function
# and turn debugging on or off by bugon() or bugoff()
bugon <- function() options("debug" = TRUE)
bugoff <- function() options("debug" = FALSE) #pun intended

El mío no es muy elegante:

# So the mac gui can find latex
Sys.setenv("PATH" = paste(Sys.getenv("PATH"),"/usr/texbin",sep=":"))

#Use last(x) instead of x[length(x)], works on matrices too
last <- function(x) { tail(x, n = 1) }

#For tikzDevice caching 
options( tikzMetricsDictionary='/Users/cameron/.tikzMetricsDictionary' )

setwd("C://path//to//my//prefered//working//directory")
library("ggplot2")
library("RMySQL")
library("foreign")
answer <- readline("What database would you like to connect to? ")
con <- dbConnect(MySQL(),user="root",password="mypass", dbname=answer)

Trabajo mucho desde bases de datos mysql, por lo que conectarse de inmediato es una bendición. Solo desearía que hubiera una forma de enumerar las bases de datos disponibles para no tener que recordar todos los nombres diferentes.

Mensaje de Stephen Turner en .Rprofiles tiene varios alias y funciones de inicio útiles.

Me encuentro usando su ht y hh a menudo.

#ht==headtail, i.e., show the first and last 10 items of an object
ht <- function(d) rbind(head(d,10),tail(d,10))

# Show the first 5 rows and first 5 columns of a data frame or matrix
hh <- function(d) d[1:5,1:5]

Aquí está la mía, incluidas algunas de las ideas mencionadas.

Dos cosas que tal vez quieras mirar:

• .set.width () / w () actualiza su ancho de impresión al del terminal. Desafortunadamente, no encontré una manera de hacer esto automáticamente en el cambio de tamaño del terminal: la documentación de R menciona que esto lo hacen algunos intérpretes de R.
• el historial se guarda cada vez junto con una marca de tiempo y el directorio de trabajo

.

.set.width <- function() {
  cols <- as.integer(Sys.getenv("COLUMNS"))
  if (is.na(cols) || cols > 10000 || cols < 10)
    options(width=100)
  options(width=cols)
}

.First <- function() {
  options(digits.secs=3)              # show sub-second time stamps
  options(max.print=1000)             # do not print more than 1000 lines
  options("report" = c(CRAN="http://cran.at.r-project.org"))
  options(prompt="R> ", digits=4, show.signif.stars=FALSE)
}

# aliases
w <- .set.width

.Last <- function() {
  if (!any(commandArgs()=='--no-readline') && interactive()){
    timestamp(,prefix=paste("##------ [",getwd(),"] ",sep=""))
    try(savehistory("~/.Rhistory"))
   }
}

Utilizo lo siguiente para obtener cacheSweave (o pgfSweave) para trabajar con el botón "Compilar PDF" en RStudio:

library(cacheSweave)
assignInNamespace("RweaveLatex", cacheSweave::cacheSweaveDriver, "utils")

Mina incluye options(menu.graphics=FALSE)porque me gusta Desactivar / emergente tcltk suprimir para la selección espejo CRAN en I .

Aquí está el mío. Nada demasiado innovador. Reflexiones sobre por qué elecciones particulares:

• Fui con la configuración de un valor predeterminado para stringsAsFactors porque me resulta extremadamente agotador pasarlo como argumento cada vez que leo un archivo CSV. Dicho esto, ya me ha causado cierta molestia menor al usar el código escrito en mi computadora habitual en una computadora que no tenía mi .Rprofile. Sin embargo, lo mantengo, ya que los problemas que ha causado palidecen en comparación con los problemas que no causa que se configuren todos los días.
• Si no carga el utilspaquete antes options(error=recover), no puede encontrar la recuperación cuando se coloca dentro de uninteractive() bloque.
• Lo usé .dbpara mi configuración de Dropbox en lugar de options(dropbox=...)porque lo uso todo el tiempo dentro file.pathy ahorra mucho tipeo. La guía .evita que aparezca ls().

Sin más preámbulos:

if(interactive()) {
    options(stringsAsFactors=FALSE)
    options(max.print=50)
    options(repos="http://cran.mirrors.hoobly.com")
}

.db <- "~/Dropbox"
# `=` <- function(...) stop("Assignment by = disabled, use <- instead")
options(BingMapsKey="blahblahblah") # Used by taRifx.geo::geocode()

.First <- function() {
    if(interactive()) {
        require(functional)
        require(taRifx)
        require(taRifx.geo)
        require(ggplot2)
        require(foreign)
        require(R.utils)
        require(stringr)
        require(reshape2)
        require(devtools)
        require(codetools)
        require(testthat)
        require(utils)
        options(error=recover)
    }
}

Aquí hay un pequeño fragmento para usar exportando tablas a LaTeX . Cambia todos los nombres de columna al modo matemático para los muchos informes que escribo. El resto de mi .Rprofile es bastante estándar y está cubierto principalmente en la parte superior.

# Puts $dollar signs in front and behind all column names col_{sub} -> $col_{sub}$

amscols<-function(x){
    colnames(x) <- paste("$", colnames(x), "$", sep = "")
    x
}

Configuré mi tema de color de celosía en mi perfil. Aquí hay otros dos ajustes que uso:

# Display working directory in the titlebar
# Note: This causes demo(graphics) to fail
utils::setWindowTitle(base::getwd())
utils::assignInNamespace("setwd",function(dir)   {.Internal(setwd(dir));setWindowTitle(base::getwd())},"base")

# Don't print more than 1000 lines
options(max.print=2000)

Tengo una variable de entorno R_USER_WORKSPACE que apunta al directorio superior de mis paquetes. En .Rprofile defino una función devlib que establece el directorio de trabajo (para que los datos () funcionen) y obtiene todos los archivos .R en el subdirectorio R. Es bastante similar a la función l () de Hadley anterior.

devlib <- function(pkg) {
  setwd(file.path(Sys.getenv("R_USER_WORKSPACE", "."), deparse(substitute(pkg)), "dev"))
  sapply(list.files("R", pattern=".r$", ignore.case=TRUE, full.names=TRUE), source)
  invisible(NULL)
}

.First <- function() {
  setwd(Sys.getenv("R_USER_WORKSPACE", "."))
  options("repos" = c(CRAN = "http://mirrors.softliste.de/cran/", CRANextra="http://www.stats.ox.ac.uk/pub/RWin"))
}

.Last <- function() update.packages(ask="graphics")

Encontré dos funciones realmente necesarias: Primero, cuando configuré debug()varias funciones y resolví el error, así que quiero undebug()todas las funciones, no una por una. La undebug_all()función agregada como la respuesta aceptada aquí es la mejor.

En segundo lugar, cuando he definido muchas funciones y estoy buscando un nombre de variable específico, es difícil encontrarlo en todos los resultados de ls()la función, incluidos los nombres de las funciones. La lsnofun()función publicada aquí es realmente buena.