Los usuarios expertos R, lo que está en su .Rprofile? [cerrado]

StackOverflow https://stackoverflow.com/questions/1189759

Pregunta

Siempre he encontrado inicio archivos de perfiles de otras personas a la vez útil e instructivo sobre la lengua. Por otra parte, mientras tenga algún tipo de personalización para Bash y Vim , no tengo nada para R.

Por ejemplo, una cosa que siempre he querido es diferentes colores para la entrada y salida de texto en una ventana de terminal, y tal vez incluso el resaltado de sintaxis.

¿Fue útil?

Solución

Esta es la mía. No te va a ayudar con la coloración pero me da que a partir 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

Otros consejos

No me gusta escribir las palabras completas 'cabeza', 'Resumen', 'nombres' cada vez, así que utilizar alias.

Se puede poner alias en el archivo de .Rprofile, pero usted tiene que utilizar la ruta completa de la función (por ejemplo, utilidades :: cabeza) de lo contrario no funcionará. 

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

EDIT: para responder a su pregunta, puede utilizar el href="http://cran.r-project.org/web/packages/colorout/" rel="noreferrer"> colorout paquete tener diferentes colores en el terminal. ¡Bueno! : -) 

options(stringsAsFactors=FALSE)

A pesar de que en realidad no tienen que en mi .Rprofile, ya que podría rompe código de mis coautores, me gustaría que fuera el valor predeterminado. ¿Por qué?

1) vectores de caracteres utilizan menos memoria (pero sólo apenas);

2) Más importante aún, queremos evitar problemas tales 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 grandes cuando los necesite (por ejemplo, la implementación de ordenación en los gráficos), pero una molestia mayor parte del tiempo.

Esta es la mía. Yo siempre uso el repositorio principal cran, y tienen código para hacerlo más fácil de la fuente en el desarrollo de código paquete. 

.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 tenerla disponible cada vez que funciono R:

En la carcasa 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 muy útil para trabajar con ventanas.

El primero convierte los \s a /. 

.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 se abre el directorio de trabajo en una nueva ventana del explorador. 

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

Tengo esto, truco más dinámico de utilizar el ancho de terminal completo, que intenta leer la variable de entorno COLUMNAS (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 utilizará todo el ancho incluso a medida que cambia el tamaño de la ventana de terminal.

La mayoría de mis funciones personales y las bibliotecas son cargados en el guión 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")')

Esto es de mi ~ / .Rprofile , diseñado para Mac y Linux.

Esto hace más fácil ver los errores. 

options(showWarnCalls=T, showErrorCalls=T)

No me gusta la opción de menú CRAN, por lo establecido en una buena. 

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

Más historia! 

Sys.setenv(R_HISTSIZE='100000')

La siguiente es para ejecutar en Mac OS X desde el terminal (que yo prefiero mucho R.app porque es más estable, y se puede organizar su trabajo por el directorio; también asegurarse de obtener una buena ~ / .inputrc ). Por defecto, se obtiene una pantalla de X11, que no se ve tan bonito; este lugar ofrece una pantalla de cuarzo misma que la interfaz gráfica de usuario. La declaración if se supone que coger el caso cuando se 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 un par de bibliotecas, 

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

util.r es una bolsa de cosas al azar que utilizo , bajo flujo.

Además, dado que otras personas mencionaban 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 es en .Rprofile porque hay que volver a ejecutar cada vez que se cambia el tamaño de la ventana de terminal. Lo tengo en util.r entonces sólo fuente si es necesario.

Aquí es mío; 

.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
}

Hacer data.frames mostrar algo así como 'cabeza', sólo que sin tener que escribir 'cabeza' 

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 'cabeza' se aplica automáticamente a la salida? )

A menudo tengo una cadena de llamadas de depuración que necesito para llamar y eliminando el comentario de ellos puede ser muy tedioso. Con la ayuda de la comunidad SO , fui por la siguiente solución y se inserta en este mi .Rprofile.site. # BROWSER hay para mis tareas Eclipse de modo que tenga una visión general de llamadas de navegador en la ventana de 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

La mía no es demasiado 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)

hago mucho trabajo de bases de datos MySQL, por lo que la conexión de inmediato es un regalo del cielo. Sólo deseo que había una manera de enumerar las bases de datos avaialble para no tener que recordar todos los nombres.

posterior de Stephen Turner en .Rprofiles tiene varios alias útiles y funciones del arrancador.

Me encuentro con 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]

Esta es la mía, incluyendo algunas de las ideas mencionadas.

Hay dos cosas que puede que desee tener en cuenta:

  • .set.width () / w () actualizar el ancho de impresión a la de la terminal. Por desgracia no he encontrado una manera de hacer esto de forma automática el cambio de tamaño del terminal -. R documentación menciona esto se hace por algunos intérpretes R
  • historia se guarda cada vez que 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"))
   }
}

Yo uso el 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 / suprimir tcltk emergente para la selección de espejo en CRAN R .

Esta es la mía. Nada demasiado innovador. Reflexiones sobre qué opciones particulares:

  • I fue con el establecimiento de un valor predeterminado para stringsAsFactors porque encuentro que sea extremadamente drenaje para pasarlo como un argumento cada vez que leo un CSV en. Dicho esto, ya me ha causado cierta irritación leve cuando use el código escrito en mi equipo habitual en un equipo que no tenía mi .Rprofile. Me quedo con ella, sin embargo, como los problemas que ha causado palidecen en comparación con los problemas no tener que crear todos los días utiliza para provocar.
  • Si no se carga el paquete antes de utils options(error=recover), que no puede encontrar a recuperarse cuando se coloca dentro de un bloque de interactive().
  • utilicé .db para establecer mi cuadro de selección en lugar de options(dropbox=...) porque yo lo uso todo el tiempo dentro de file.path y se ahorra mucho escribir. El líder . evita que aparece con 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 de código para su uso exportar las tablas LaTeX . Cambia todos los nombres de las columnas a modo de matemáticas para los muchos informes que escribo. El resto de mi .Rprofile es bastante estándar y en su mayoría cubiertas anteriormente. 

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

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

Me puse mi tema del enrejado del color en mi perfil. Aquí hay otros dos ajustes que utilizo: 

# 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 R_USER_WORKSPACE variable de entorno que apunta al directorio superior de mis paquetes. En .Rprofile defino un devlib función que establece el directorio de trabajo (por lo que los datos () funciona) y las fuentes de todos los archivos en el subdirectorio .R R. Es muy similar a la función anterior l de Hadley (). 

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")

He encontrado dos funciones realmente necesario: En primer lugar, cuando he puesto debug() en varias funciones y he resuelto el error, así que quiero undebug() todas las funciones - no uno por uno. La función undebug_all() añadió que la respuesta aceptada aquí es el mejor.

En segundo lugar, cuando he definido muchas funciones y estoy en busca de un nombre de variable específica, que es difícil de encontrar dentro de todos los resultados de la la ls(), incluyendo los nombres de las funciones. La función lsnofun() publicada aquí es realmente bueno.

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top