Utilisateurs Expert R, que contient votre profil. [fermé]

J'ai toujours trouvé des fichiers de profil de démarrage d'autres personnes à la fois utiles et instructifs sur la langue. De plus, même si j'ai une certaine personnalisation pour Bash et Vim , je n'ai rien pour R.

Par exemple, une chose que j'ai toujours voulu, ce sont des couleurs différentes pour le texte d'entrée et de sortie dans un terminal de fenêtre, et peut-être même la coloration syntaxique.

Voici le mien. Cela ne vous aidera pas avec la coloration, mais je l'obtiens d'ESS et d'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)

Bien que je n'aie pas réellement cela dans mon .Rprofile, car cela pourrait casser le code de mes co-auteurs, je souhaite que ce soit la valeur par défaut. Pourquoi?

1) Les vecteurs de caractères utilisent moins de mémoire (mais à peine);

2) Plus important encore, nous éviterions des problèmes tels que:

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

et

> 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

Les facteurs sont importants lorsque vous en avez besoin (par exemple, implémenter la commande dans les graphiques) mais ils sont la plupart du temps une nuisance.

Je déteste taper les mots complets «tête», «résumé», «noms» à chaque fois, donc j'utilise des alias.

Vous pouvez mettre des alias dans votre fichier .Rprofile, mais vous devez utiliser le chemin complet de la fonction (par exemple utils :: head) sinon cela ne fonctionnera pas.

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

EDIT: pour répondre à votre question, vous pouvez utiliser le pack colorout pour avoir différentes couleurs dans le terminal. Cool! :-)

Voici la mienne. J'utilise toujours le référentiel principal de Cran et j'ai du code pour faciliter la source du code du package en cours de développement.

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

J'aime sauvegarder mon historique de commandes R et le rendre disponible à chaque fois que je lance R:

Dans le shell ou .bashrc:

export R_HISTFILE=~/.Rhistory

dans .Profile:

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

Voici deux fonctions que je trouve utiles pour travailler avec des fenêtres.

Le premier convertit le \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')
 }

Le second ouvre le répertoire de travail dans une nouvelle fenêtre d'explorateur.

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

J'ai cette astuce, plus dynamique, pour utiliser toute la largeur du terminal, qui essaie de lire à partir de la variable d'environnement COLUMNS (sous 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 cette façon, R utilisera toute la largeur même si vous redimensionnez votre fenêtre de terminal.

La plupart de mes fonctions personnelles et bibliothèques chargées sont dans le 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")')

Voici mon ~ / .Rprofile , conçu pour Mac et Linux.

Cela rend les erreurs plus faciles à voir.

options(showWarnCalls=T, showErrorCalls=T)

Je déteste le choix du menu CRAN, alors mis à un bon.

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

Plus d'histoire!

Sys.setenv(R_HISTSIZE='100000')

Ce qui suit est pour fonctionner sur Mac OSX à partir du terminal (que je préfère grandement à R.app car il est plus stable et vous pouvez organiser votre travail par répertoire; assurez-vous également d'obtenir un bon ~ / .inputrc ). Par défaut, vous obtenez un écran X11, qui n'est pas aussi joli; cela donne à la place un affichage à quartz identique à l'interface graphique. L' ifinstruction est censée attraper le cas lorsque vous exécutez R à partir du terminal sur 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)

Et préchargez quelques bibliothèques,

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

où util.r est un sac aléatoire de trucs que j'utilise, sous flux.

De plus, comme d'autres personnes mentionnaient la largeur de la console, voici comment je le fais.

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)

Ce n'est pas le cas .Rprofilecar vous devez le réexécuter à chaque fois que vous redimensionnez la fenêtre du terminal. Je l'ai en util.rmoi puis je le source au besoin.

Voici les miennes:

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

Faire en sorte que les cadres de données s'affichent un peu comme «tête», uniquement sans avoir à taper «tête»

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 Comment faire pour que la «tête» soit appliquée automatiquement à la sortie? )

J'ai souvent une chaîne d'appels de débogage que je dois appeler et les décommenter peut être très fastidieux. Avec l'aide de la communauté SO , j'ai opté pour la solution suivante et l'ai insérée dans mon .Rprofile.site. # BROWSERest là pour mes tâches Eclipse afin que j'aie un aperçu des appels du navigateur dans la fenêtre d'affichage des tâches.

# 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

Le mien n'est pas trop chic:

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

Je fais beaucoup de travail à partir de bases de données mysql, donc se connecter tout de suite est une aubaine. Je souhaite seulement qu'il y ait un moyen de lister les bases de données disponibles pour ne pas avoir à me souvenir de tous les différents noms.

Le post de Stephen Turner sur .Rprofiles a plusieurs alias et fonctions de démarrage utiles.

Je me retrouve à utiliser son ht et hh souvent.

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

Voici le mien, y compris certaines des idées mentionnées.

Deux choses que vous voudrez peut-être examiner:

• .set.width () / w () met à jour votre largeur d'impression à celle du terminal. Malheureusement, je n'ai pas trouvé de moyen de le faire automatiquement lors du redimensionnement du terminal - la documentation R mentionne que cela est fait par certains interprètes R.
• l'historique est sauvegardé à chaque fois avec un horodatage et le répertoire de travail

.

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

J'utilise ce qui suit pour que cacheSweave (ou pgfSweave) fonctionne avec le bouton "Compile PDF" dans RStudio:

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

Le mien comprend options(menu.graphics=FALSE)parce que je aime Désactiver / Supprimer tcltk pop - up pour la sélection miroir en R CRAN .

Voici la mienne. Rien de trop innovant. Réflexions sur pourquoi des choix particuliers:

• J'ai choisi de définir une valeur par défaut stringsAsFactorscar je trouve extrêmement épuisant de le passer comme argument chaque fois que je lis un fichier CSV. Cela dit, cela m'a déjà causé quelques ennuis mineurs lors de l'utilisation de code écrit sur mon ordinateur habituel sur un ordinateur qui n'avait pas mon .Rprofile. Je le garde, cependant, car les problèmes qu'il a causés pâlissent par rapport aux problèmes de ne pas le régler tous les jours.
• Si vous ne chargez pas le utilspackage auparavant options(error=recover), il ne trouvera pas de récupération lorsqu'il est placé dans un interactive()bloc.
• J'ai utilisé .dbpour mon paramètre dropbox plutôt que options(dropbox=...)parce que je l'utilise tout le temps à l'intérieur file.pathet cela économise beaucoup de frappe. Le leader l' .empêche d'apparaître avec ls().

Sans plus tarder:

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

Voici un petit extrait à utiliser pour exporter des tables vers LaTeX . Il change tous les noms de colonnes en mode mathématique pour les nombreux rapports que j'écris. Le reste de mon .Rprofile est assez standard et principalement couvert ci-dessus.

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

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

J'ai défini mon thème de couleur de réseau dans mon profil. Voici deux autres réglages que j'utilise:

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

J'ai une variable d'environnement R_USER_WORKSPACE qui pointe vers le répertoire supérieur de mes packages. Dans .Rprofile, je définis une fonction devlib qui définit le répertoire de travail (pour que data () fonctionne) et source tous les fichiers .R dans le sous-répertoire R. Elle est assez similaire à la fonction l () de Hadley ci-dessus.

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

J'ai trouvé deux fonctions vraiment nécessaires: d'abord lorsque j'ai défini debug()plusieurs fonctions et que j'ai résolu le bogue, je veux donc undebug()toutes les fonctions - pas une par une. La undebug_all()fonction ajoutée comme réponse acceptée ici est la meilleure.

Deuxièmement, lorsque j'ai défini de nombreuses fonctions et que je recherche un nom de variable spécifique, il est difficile de le trouver dans tous les résultats de la ls(), y compris les noms de fonction. La lsnofun()fonction affichée ici est vraiment bonne.