Utilisateurs Expert R, qu’y a-t-il dans votre .Rprofile?
J'ai toujours trouvé les fichiers de profil de démarrage d'autres personnes utiles et instructifs sur le langage. De plus, alors que j'ai quelques personnalisations pour Bash et Vim , je n'ai rien pour R.
Par exemple, une chose que j'ai toujours voulue, 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 à colorier, mais ESS et Emacs me donnent ça ...
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
Je n'aime pas taper les mots entiers '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 paquetage colorout pour avoir différentes couleurs dans le terminal. Cool! :-)
options(stringsAsFactors=FALSE)
Bien que je n'ai pas réellement cela dans mon .Rprofile, parce que cela pourrait casser le code de mes coauteurs, j'aimerais que ce soit le cas 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 intéressants lorsque vous en avez besoin (par exemple, la mise en œuvre de commandes dans des graphiques), mais sont gênants la plupart du temps.
Voici la mienne. J'utilise toujours le référentiel principal Cran, et j'ai du code pour faciliter la source du code du paquet en 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 garder disponible chaque fois que je lance R:
Dans le shell ou .bashrc:
export R_HISTFILE=~/.Rhistory
dans .Profil:
.Last <- function() {
if (!any(commandArgs()=='--no-readline') && interactive()){
require(utils)
try(savehistory(Sys.getenv("R_HISTFILE")))
}
}
Voici deux fonctions que je trouve pratiques pour travailler avec Windows.
Le premier convertit le \s à /.
.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')
}
La seconde ouvre le répertoire de travail dans une nouvelle fenêtre de l'explorateur.
getw <- function() {
suppressWarnings(Shell(paste("Explorer", gsub('/', '\\\\', getwd()))))
}
J'ai cette astuce plus dynamique pour utiliser la largeur de terminal complète, qui tente 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 la fenêtre de votre terminal.
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 de menu CRAN, alors définissez-le sur 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 destiné à une exécution sur Mac OSX à partir du terminal (ce que je préfère grandement à R.app car il est plus stable et que vous pouvez organiser votre travail par répertoire; assurez-vous également d’obtenir un bon ~/.inputrc ). Par défaut, vous obtenez un affichage X11, qui ne ressemble pas à Nice; Cela donne un affichage à quartz identique à celui de l'interface graphique. L'instruction if est censée intercepter 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écharger quelques bibliothèques,
library(plyr)
library(stringr)
library(RColorBrewer)
if (file.exists("~/util.r")) {
source("~/util.r")
}
où til.r est un sac aléatoire de choses que j'utilise, sous flux.
De plus, comme d'autres personnes ont mentionné 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 en fait pas dans .Rprofile _ car vous devez le réexécuter à chaque fois que vous redimensionnez la fenêtre du terminal. Je l'ai dans util.r alors je source juste comme nécessaire.
La plupart de mes fonctions personnelles et des 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 les miens:
.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))
}
Faire en sorte que data.frames s’affiche un peu comme 'head', sans avoir à taper '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)
}
}
(De Comment faire en sorte que 'head' soit automatiquement appliqué à la sortie? )
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
}
J'ai souvent une chaîne d'appels de débogage que j'ai besoin d'appeler et les supprimer peut être très fastidieux. Avec l’aide de SO community , j’ai choisi la solution suivante et l’a insérée dans mon .Rprofile.site. # BROWSER est là pour mes tâches Eclipse afin que je puisse avoir une vue d'ensemble des appels du navigateur dans la fenêtre Vue 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 travaille beaucoup à partir de bases de données MySQL, la connexion immédiate est donc une aubaine. J'aimerais seulement qu'il y ait un moyen de lister les bases de données disponibles afin de ne pas avoir à mémoriser tous les noms.
Le post de Stephen Turner sur .Rprofiles a plusieurs alias utiles et fonctions de démarrage.
Je me retrouve souvent à utiliser ses ht et hh.
#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 un petit extrait pour l’utilisation des tables d’exportation 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
}
Voici la mienne. Rien de trop innovant. Réflexions sur pourquoi des choix particuliers:
- Je suis allé avec définir un défaut pour
stringsAsFactorsparce que je trouve extrêmement pénible de le passer comme argument à chaque fois que je lis un fichier CSV. ordinateur habituel sur un ordinateur qui n’avait pas mon .Rprofile. Je le garde cependant, car les problèmes qu’il a causés ont été minimes par rapport aux problèmes causés par le fait de ne pas les régler tous les jours. - Si vous ne chargez pas le paquetage
utilsavantoptions(error=recover), il ne peut pas être récupéré lorsqu'il est placé dans un blocinteractive(). - J'ai utilisé
.dbPour mon paramètre de boîte de dépôt plutôt queoptions(dropbox=...)parce que je l'utilise tout le temps à l'intérieur defile.pathEt cela économise beaucoup de frappe. Le premier.L'empêche d'apparaître avecls().
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 le mien, y compris certaines des idées mentionnées.
Deux choses que vous pourriez vouloir regarder:
- .set.width ()/w() met à jour votre largeur d'impression avec celle du terminal. Malheureusement, je n'ai pas trouvé le moyen de le faire automatiquement lors du redimensionnement du terminal - la documentation R le mentionne 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"))
}
}
Le mien comprend options(menu.graphics=FALSE) parce que j'aime bien désactiver/supprimer le menu contextuel tcltk pour la sélection du miroir CRAN dans R .
J'utilise ce qui suit pour que cacheSweave (ou pgfSweave) fonctionne avec le bouton "Compiler PDF" dans RStudio:
library(cacheSweave)
assignInNamespace("RweaveLatex", cacheSweave::cacheSweaveDriver, "utils")
J'ai une variable d'environnement R_USER_WORKSPACE qui pointe vers le répertoire racine de mes paquets. 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 du sous-répertoire R. Il est assez similaire à la fonction de Hadley l() 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 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 trouvé deux fonctions vraiment nécessaires: d’abord quand j’ai placé debug() sur plusieurs fonctions et que j’ai résolu le bogue, je veux donc undebug() toutes les fonctions - pas une par une. La fonction undebug_all() ajoutée en tant que 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 fonctions. La fonction lsnofun() postée ici est vraiment bonne.