Les utilisateurs experts de R, ce qui est dans votre .Rprofile? [fermé]

https://stackoverflow.com/questions/1189759

19-09-2019
|

Question

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

Par exemple, une chose que je voulais toujours est des couleurs différentes pour l'entrée et le texte de sortie dans un terminal de fenêtre, et peut-être même la coloration syntaxique.

La solution

Voici la mienne. Il ne vous aidera pas avec la couleur mais je reçois que de l'ESS et 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

Autres conseils

Je déteste taper la tête de la «mots pleins, « résumé », « noms » à chaque fois, donc j'utiliser des alias.

Vous pouvez mettre des alias dans votre fichier .Rprofile, mais vous devez utiliser le chemin complet à la fonction (par exemple utils :: tête) sinon il ne fonctionnera pas.

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

EDIT: Pour répondre à votre question, vous pouvez utiliser le package colorout d'avoir des couleurs différentes dans le terminal. Cool! : -)

options(stringsAsFactors=FALSE)

Bien que je n'ai pas fait dans mon .Rprofile, car il pourrait brise le code de mes co-auteurs, je souhaiterais que ce soit la valeur par défaut. Pourquoi?

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

2) Plus important encore, nous évitons 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"

> 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 grands quand vous en avez besoin (par exemple la mise en œuvre commande sous forme de graphiques), mais une nuisance la plupart du temps.

Voici le mien. J'utiliser toujours le principal référentiel de Cran, et avoir le code pour le rendre facile à code source de package 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 sauver mon historique des commandes de R et de l'avoir disponible chaque fois que je lance R:

Dans le shell ou .bashrc:

export R_HISTFILE=~/.Rhistory

.Rprofile:

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

Voici deux fonctions que je trouve à portée de main pour travailler avec des fenêtres.

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

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

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

J'ai cela, truc plus dynamique à utiliser toute la largeur du terminal, qui essaie de lire 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 la même largeur que vous redimensionnez votre fenêtre de terminal.

La plupart de mes fonctions personnelles et les 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 de mon ~ / .Rprofile , conçu pour Mac et Linux.

Ces erreurs rendent plus faciles à voir.

options(showWarnCalls=T, showErrorCalls=T)

Je déteste le choix du menu CRAN, donc réglé 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 en cours d'exécution pour Mac OS X à partir du terminal (que je préfère grandement R.app parce qu'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 affichage X11, ce qui ne semble pas aussi agréable; cela donne lieu un affichage à quartz identique à l'interface utilisateur graphique. La déclaration de if est censé attraper le cas lorsque vous utilisez 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")
}

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

En outre, étant donné que 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)

est en fait pas .Rprofile parce que vous devez exécuter à nouveau chaque fois que vous redimensionnez la fenêtre de terminal. Je l'ai dans util.r je SoURce juste si nécessaire.

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

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 data.frames afficher un peu comme la « tête », mais 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 la « tête » est automatiquement appliquée à la sortie? )

J'ai souvent une chaîne d'appels de débogage je dois appeler et leur décommentant peut être très fastidieux. Avec l'aide de la SO communautaire, je suis allé à la solution suivante et inséré dans ce mon .Rprofile.site. # BROWSER est là pour mes tâches Eclipse pour que j'ai un aperçu du navigateur appelle dans la fenêtre Afficher la tâche.

# 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 est pas trop de fantaisie:

# 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 des bases de données MySQL, si la connexion est tout de suite un don du ciel. Je voudrais seulement il y avait un moyen d'énumérer les bases de données avaialble donc je ne voudrais pas se souvenir de tous les noms différents.

poste de Stephen Turner sur .Rprofiles a plusieurs alias utiles et les fonctions de démarrage.

Je me retrouve avec 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 regarder:

.set.width () / p () mettre à jour la largeur d'impression à l'une de la borne. Malheureusement, je ne l'ai pas trouvé un moyen de le faire automatiquement au terminal de Redimensionner -. Documentation R mentionne ceci est fait par certains interprètes R
l'histoire est enregistré 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 obtenir cacheSweave (ou pgfSweave) pour travailler avec le bouton « Compiler PDF » dans rstudio:

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

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

Voici le mien. Rien de trop novateur. Réflexions sur la raison pour laquelle certains choix:

je suis allé à la mise en valeur par défaut pour stringsAsFactors parce que je trouve il drainant extrêmement de le transmettre comme argument à chaque fois que je lis un fichier CSV dans. Cela dit, il m'a déjà causé quelques vexations mineures lors de l'utilisation du code écrit sur mon ordinateur habituel sur un ordinateur qui n'a pas eu mon .Rprofile. Je le garde, cependant, que les problèmes qu'il a causé pâle par rapport aux problèmes ne pas l'avoir utilisé tous les jours set pour provoquer.
Si vous ne chargez pas le paquet utils avant options(error=recover), il ne peut pas trouver récupérer lorsqu'il est placé à l'intérieur d'un bloc interactive().
je .db pour mon dropbox plutôt que par rapport options(dropbox=...) parce que je l'utilise tout le temps à l'intérieur file.path et il enregistre beaucoup frappe. Le . principal empêche de paraître avec ls().

Sans plus attendre:

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 pour l'exportation vers les tables LATEX. Il change tous les noms de colonnes en mode mathématiques pour les nombreux rapports que j'écris. Le reste de mon .Rprofile est assez standard et la plupart du temps 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
}

Je mis mon thème de couleur en treillis 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 R_USER_WORKSPACE variable d'environnement qui pointe vers le répertoire haut de mes paquets. Dans .Rprofile je définis une devlib fonction qui définit le répertoire de travail (afin que les données () fonctionne) et sources tous les fichiers .R dans le sous-répertoire R. Il est tout à fait similaire à la fonction de l () 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écessaire: Tout d'abord quand j'ai mis debug() sur plusieurs fonctions et je l'ai résolu le bug, donc je veux undebug() toutes les fonctions - et non un par un. La fonction undebug_all() a ajouté que la réponse acceptée est le meilleur.

En second lieu, quand je l'ai défini de nombreuses fonctions et je suis à la recherche d'un nom de variable spécifique, il est difficile de trouver dans les résultats de l'ls(), y compris les noms de fonctions. La fonction lsnofun() affichée ici est vraiment bon.

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow