usuários experientes R, que está em seu .Rprofile? [fechadas]

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

Pergunta

Eu sempre achei arquivos de perfis de arranque de outras pessoas, tanto úteis e instrutivos sobre a língua. Além disso, enquanto eu tiver alguma personalização para Bash e Vim , não tenho nada para R.

Por exemplo, uma coisa que eu sempre quis é cores diferentes para entrada e saída de texto em um terminal janela, e destaque talvez até sintaxe.

Foi útil?

Solução

Aqui é meu. Não irá ajudá-lo com a coloração, mas eu começar a partir de ESS e 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

Outras dicas

Eu odeio a digitar as palavras cheias 'cabeça', 'resumo', 'nomes' de cada vez, então eu uso aliases.

Você pode colocar apelidos em seu arquivo .Rprofile, mas você tem que usar o caminho completo para a função (por exemplo cabeça utils ::), caso contrário não vai funcionar. 

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

EDIT: para responder à sua pergunta, você pode usar o href="http://cran.r-project.org/web/packages/colorout/" rel="noreferrer"> pacote ter cores diferentes no terminal. Legal! : -) 

options(stringsAsFactors=FALSE)

Embora eu realmente não têm que na minha .Rprofile, porque poderia Código quebra dos meus co-autores, eu gostaria que fosse o padrão. Por quê?

1) vetores de caracteres usar menos memória (mas apenas mal);

2) Mais importante, gostaríamos de evitar problemas, tais 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"

e 

> 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

Os fatores são grandes quando você precisar deles (por exemplo, a implementação de pedidos em gráficos), mas um incômodo maior parte do tempo.

Aqui é meu. Eu uso sempre o principal repositório cran, e tem o código para torná-lo fácil de código fonte pacote em desenvolvimento. 

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

eu como salvar meu histórico de comandos R e tê-lo disponível cada vez que eu corro R:

No shell ou .bashrc: 

export R_HISTFILE=~/.Rhistory

em .Rprofile: 

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

Aqui estão duas funções acho útil para trabalhar com janelas.

Os primeiros convertidos os \s para /. 

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

O segundo abre a pasta de trabalho em uma nova janela do Explorer. 

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

Eu tenho esse truque, mais dinâmica para usar largura do terminal completo, que tenta ler a partir da variável de ambiente COLUMNS (no 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)}
)

Desta forma R usará a largura total, mesmo quando você redimensionar a janela do terminal.

A maioria das minhas funções pessoais e bibliotecas carregadas estão no roteiro 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")')

Aqui está do meu ~ / .Rprofile , projetado para Mac e Linux.

Estes fazem erros mais fáceis de ver. 

options(showWarnCalls=T, showErrorCalls=T)

Eu odeio a escolha do menu CRAN, de modo definido para uma boa. 

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

Mais história! 

Sys.setenv(R_HISTSIZE='100000')

O seguinte é para execução no Mac OSX a partir do terminal (que eu prefiro muito para R.app porque é mais estável, e você pode organizar seu trabalho por diretório, também certifique-se de ter uma boa ~ / .inputrc ). Por padrão, você tem um display X11, que não fica tão agradável; esta vez dá um visor de quartzo mesmo que o GUI. A declaração if é suposto para pegar o caso quando você está correndo R partir do terminal no 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)

E pré-carregar algumas bibliotecas, 

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

util.r é um saco aleatório do uso de coisas que eu , sob fluxo.

Além disso, uma vez que outras pessoas estavam mencionando largura console, aqui está como eu fazê-lo. 

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)

Isso realmente não está na .Rprofile porque você tem que re-executá-lo cada vez que você redimensionar a janela do terminal. Eu tê-lo em util.r então eu só fonte-lo conforme necessário.

Aqui é meu; 

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

data.frames Fazer exibir um pouco como 'cabeça', só que sem ter que digitar 'cabeça' 

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

(De Como fazer 'cabeça' ser aplicado automaticamente para a saída? )

Eu muitas vezes têm uma cadeia de chamadas de depuração eu preciso chamar e descomentando-los pode ser muito tedioso. Com a ajuda do SO comunidade , eu fui para a seguinte solução e inserido isso em minha .Rprofile.site. # BROWSER está lá para as minhas tarefas do Eclipse para que eu tenha uma visão geral de chamadas do navegador na janela de exibição de tarefas. 

# 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

O meu não é muito extravagante: 

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

Eu faço um monte de trabalho a partir de bancos de dados MySQL, de modo que liga de imediato é uma dádiva de Deus. Eu só gostaria que houvesse uma maneira de listar os bancos de dados avaialble para que eu não teria que se lembrar de todos os nomes diferentes.

Aqui é meu, incluindo algumas das ideias mencionadas.

Duas coisas que você pode querer olhar:

  • .set.width () / w () atualizar sua largura de impressão para a do terminal. Infelizmente eu não encontrar uma maneira de fazer isso automaticamente no redimensionamento do terminal -. A documentação R menciona isso é feito por alguns intérpretes R
  • história é salvo a cada vez em conjunto com um timestamp eo diretório de trabalho

. 

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

Eu uso o seguinte para obter cacheSweave (ou pgfSweave) ao trabalho com o botão "Compile PDF" no rstudio: 

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

Aqui é meu. Nada muito inovador. Pensamentos sobre escolhas por particulares:

  • Eu fui com a criação de um padrão para stringsAsFactors porque acho extremamente drenagem para passá-lo como um argumento cada vez que leio um CSV em. Dito isto, já me causou alguma irritação menor quando usando o código escrito no meu computador normal em um computador que não tinha a minha .Rprofile. Eu estou mantendo-lo, porém, como os problemas que tem causado pálido em comparação com os problemas não tê-la set todos os dias utilizados para a causa.
  • Se você não carregar o pacote utils antes options(error=recover), ele não pode encontrar recuperar quando colocado dentro de um bloco interactive().
  • Eu costumava .db para minha configuração dropbox em vez de options(dropbox=...) porque eu usá-lo o tempo todo dentro file.path e economiza muita digitação. O . levando o impede de aparecer com ls().

Sem mais delongas: 

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

Aqui está um pequeno trecho para uso exportar tabelas para LaTeX . Ele muda todos os nomes das colunas para o modo de matemática para os muitos relatórios que escrevo. O resto da minha .Rprofile é bastante normal e principalmente coberto acima. 

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

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

Eu defini o meu tema de cor rede no meu perfil. Aqui estão dois outros ajustes que eu 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)

Eu tenho um R_USER_WORKSPACE variável de ambiente que aponta para o diretório superior dos meus pacotes. Em .Rprofile I definir uma função devlib que define o diretório de trabalho (de modo que os dados () funciona) e fontes de todos os arquivos .R no subdiretório R. É bastante semelhante ao l de Hadley () acima. 

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

Eu encontrei duas funções realmente necessário: primeiro quando tenho debug() conjunto em várias funções e eu ter resolvido o bug, então eu quero undebug() todas as funções - não um por um. A função undebug_all() adicionado como a resposta aceita aqui é o melhor.

Em segundo lugar, quando eu tiver definido várias funções e estou à procura de um nome de variável específico, é difícil encontrá-lo dentro de todos os resultados da o ls(), incluindo os nomes das funções. A função lsnofun() postou aqui é realmente bom.

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top