Erfahrene R-Benutzer, was ist in Ihrem .R-Profil? [geschlossen]

Ich habe immer Startprofildateien anderer Leute gefunden, die sowohl nützlich als auch lehrreich in Bezug auf die Sprache sind. Während ich einige Anpassungen für Bash und Vim habe , habe ich nichts für R.

Zum Beispiel wollte ich immer unterschiedliche Farben für die Eingabe und Ausgabe von Text in einem Fensterterminal und möglicherweise sogar die Hervorhebung der Syntax.

Hier ist mein. Es wird dir beim Färben nicht helfen, aber das bekomme ich von ESS und 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)

Obwohl ich das eigentlich nicht in meinem .Rprofile habe, weil es den Code meiner Mitautoren beschädigen könnte, wünschte ich, es wäre die Standardeinstellung. Warum?

1) Zeichenvektoren verbrauchen weniger Speicher (aber nur knapp);

2) Noch wichtiger ist, wir würden Probleme vermeiden wie:

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

und

> 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

Faktoren sind großartig, wenn Sie sie benötigen (z. B. Implementieren der Reihenfolge in Diagrammen), aber meistens ein Ärgernis.

Ich hasse es, jedes Mal die vollständigen Wörter "Kopf", "Zusammenfassung", "Namen" einzugeben, deshalb verwende ich Aliase.

Sie können Aliase in Ihre .Rprofile-Datei einfügen, müssen jedoch den vollständigen Pfad zur Funktion verwenden (z. B. utils :: head), da dies sonst nicht funktioniert.

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

BEARBEITEN: Um Ihre Frage zu beantworten, können Sie das Colorout- Paket verwenden, um verschiedene Farben im Terminal zu haben. Cool! :-)

Hier ist meins. Ich verwende immer das Haupt-Cran-Repository und habe Code, um die Beschaffung von Code für Entwicklungspakete zu vereinfachen.

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

Ich mag es, meinen R-Befehlsverlauf zu speichern und ihn jedes Mal verfügbar zu haben, wenn ich R ausführe:

In der Shell oder .bashrc:

export R_HISTFILE=~/.Rhistory

in .Rprofil:

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

Hier sind zwei Funktionen, die ich für die Arbeit mit Windows nützlich finde.

Der erste konvertiert das \s in /.

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

Der zweite öffnet das Arbeitsverzeichnis in einem neuen Explorer-Fenster.

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

Ich habe diesen dynamischeren Trick, um die volle Terminalbreite zu verwenden, der versucht, aus der Umgebungsvariablen COLUMNS (unter Linux) zu lesen:

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

Auf diese Weise nutzt R die gesamte Breite, auch wenn Sie die Größe Ihres Terminalfensters ändern.

Die meisten meiner persönlichen Funktionen und geladenen Bibliotheken befinden sich im Skript 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")')

Hier ist mein ~ / .R-Profil , das für Mac und Linux entwickelt wurde.

Dadurch sind Fehler leichter zu erkennen.

options(showWarnCalls=T, showErrorCalls=T)

Ich hasse die CRAN-Menüauswahl, also stellen Sie eine gute ein.

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

Mehr Geschichte!

Sys.setenv(R_HISTSIZE='100000')

Das Folgende ist für die Ausführung unter Mac OSX vom Terminal aus vorgesehen (was ich R.app sehr vorziehe, da es stabiler ist und Sie Ihre Arbeit nach Verzeichnis organisieren können; stellen Sie außerdem sicher, dass Sie ein gutes ~ / .inputrc erhalten ). Standardmäßig erhalten Sie ein X11-Display, das nicht so gut aussieht. Dies ergibt stattdessen eine Quarzanzeige, die der GUI entspricht. Die ifAnweisung soll den Fall erfassen, wenn Sie R vom Terminal auf dem Mac ausführen.

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)

Und laden Sie ein paar Bibliotheken vor,

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

Dabei ist util.r eine zufällige Tüte mit Sachen, die ich benutze, unter Fluss.

Da andere Leute die Konsolenbreite erwähnten, mache ich das auch so.

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)

Dies ist eigentlich nicht der .RprofileFall, da Sie es jedes Mal neu ausführen müssen, wenn Sie die Größe des Terminalfensters ändern. Ich habe es in util.rdann beschaffe ich es einfach nach Bedarf.

Hier sind meine:

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

Lassen Sie data.frames etwas wie 'head' anzeigen, nur ohne 'head' eingeben zu müssen.

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

(Von Wie wird 'Kopf' automatisch auf die Ausgabe angewendet? )

Ich habe oft eine Reihe von Debug-Aufrufen, die ich aufrufen muss, und das Kommentieren kann sehr langwierig sein. Mit Hilfe der SO-Community habe ich mich für die folgende Lösung entschieden und diese in meine eingefügt .Rprofile.site. # BROWSERist für meine Eclipse-Aufgaben vorhanden, damit ich im Fenster "Aufgabenansicht" einen Überblick über die Browseraufrufe habe.

# 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

Meins ist nicht besonders schick:

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

Ich arbeite viel in MySQL-Datenbanken, daher ist es ein Glücksfall, sofort eine Verbindung herzustellen. Ich wünschte nur, es gäbe eine Möglichkeit, die verfügbaren Datenbanken aufzulisten, damit ich mich nicht an all die verschiedenen Namen erinnern müsste.

Stephen Turners Beitrag zu .Rprofiles enthält mehrere nützliche Aliase und Starterfunktionen.

Ich benutze sein ht und hh oft.

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

Hier ist meine, einschließlich einiger der genannten Ideen.

Zwei Dinge, die Sie vielleicht betrachten möchten:

• .set.width () / w () aktualisiert Ihre Druckbreite auf die des Terminals. Leider habe ich beim Ändern der Terminalgröße keine Möglichkeit gefunden, dies automatisch zu tun. In der R-Dokumentation wird erwähnt, dass dies von einigen R-Interpreten durchgeführt wird.
• Der Verlauf wird jedes Mal zusammen mit einem Zeitstempel und dem Arbeitsverzeichnis gespeichert

.

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

Ich verwende Folgendes, um cacheSweave (oder pgfSweave) dazu zu bringen, mit der Schaltfläche "PDF kompilieren" in RStudio zu arbeiten:

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

Meins beinhaltet, options(menu.graphics=FALSE)weil ich das tcltk-Popup für die CRAN-Spiegelauswahl in R deaktivieren / unterdrücken möchte .

Hier ist meins. Nichts zu innovativ. Gedanken darüber, warum bestimmte Entscheidungen:

• Ich habe mich für die Festlegung eines Standardwerts entschieden, stringsAsFactorsda es für mich äußerst anstrengend ist, ihn jedes Mal als Argument zu übergeben, wenn ich eine CSV einlese. Das heißt, es hat mich bereits ein wenig verärgert, wenn ich Code verwendet habe, der auf meinem normalen Computer auf einem Computer geschrieben wurde hatte mein .Rprofil nicht. Ich behalte es jedoch bei, da die Probleme, die es verursacht hat, im Vergleich zu den Problemen, die es nicht jeden Tag verursacht hat, verblasst sind.
• Wenn Sie das utilsPaket zuvor nicht geladen haben options(error=recover), kann es keine Wiederherstellung finden, wenn es in einem interactive()Block platziert wird.
• Ich habe .dbmeine Dropbox-Einstellung verwendet, anstatt options(dropbox=...)sie ständig im Inneren zu verwenden, file.pathund sie spart viel Tipparbeit. Die Führung verhindert, dass .es mit erscheint ls().

Ohne weiteres:

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

Hier ist ein kleiner Ausschnitt zum Exportieren von Tabellen nach LaTeX . Für die vielen Berichte, die ich schreibe, werden alle Spaltennamen in den Mathematikmodus geändert. Der Rest meines .R-Profils ist ziemlich normal und wird oben größtenteils behandelt.

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

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

Ich habe mein Gitterfarbthema in meinem Profil festgelegt. Hier sind zwei weitere Verbesserungen, die ich verwende:

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

Ich habe eine Umgebungsvariable R_USER_WORKSPACE, die auf das oberste Verzeichnis meiner Pakete verweist. In .Rprofile definiere ich eine Funktion devlib, die das Arbeitsverzeichnis festlegt (damit data () funktioniert) und alle .R-Dateien im R-Unterverzeichnis als Quelle bereitstellt. Es ist der obigen l () -Funktion von Hadley ziemlich ähnlich.

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

Ich fand zwei Funktionen wirklich notwendig: Erstens, wenn ich debug()mehrere Funktionen eingestellt und den Fehler behoben habe, möchte ich undebug()alle Funktionen - nicht eine nach der anderen. Die undebug_all()Funktion hinzugefügt , wie die akzeptierte Antwort hier ist das Beste.

Zweitens, wenn ich viele Funktionen definiert habe und nach einem bestimmten Variablennamen suche, ist es schwierig, ihn in allen Ergebnissen der ls(), einschließlich der Funktionsnamen, zu finden. Die hierlsnofun() gepostete Funktion ist wirklich gut.