Użytkownicy Expert R, co jest w Twoim profilu .Rprofile? [Zamknięte]

Zawsze uważałem pliki profilu startowego innych osób za przydatne i pouczające o języku. Co więcej, chociaż mam pewne modyfikacje dla Basha i Vima , nie mam nic dla R.

Na przykład zawsze chciałem mieć różne kolory tekstu wejściowego i wyjściowego w terminalu okna, a może nawet podświetlanie składni.

Tu jest moje. Nie pomoże ci w kolorowaniu, ale dostaję to od ESS i Emacsa ...

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)

Chociaż tak naprawdę nie mam tego w moim .Rprofile, ponieważ może to zepsuć kod moich współautorów, chciałbym, aby był to domyślny. Czemu?

1) Wektory znaków zużywają mniej pamięci (ale tylko ledwo);

2) Co ważniejsze, uniknęlibyśmy takich problemów, jak:

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

i

> 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

Czynniki są świetne, gdy ich potrzebujesz (np. Implementacja zamawiania na wykresach), ale przez większość czasu są uciążliwe.

Nienawidzę za każdym razem wpisywać pełnych słów „głowa”, „podsumowanie”, „imiona”, więc używam aliasów.

Możesz umieścić aliasy w swoim pliku .Rprofile, ale musisz użyć pełnej ścieżki do funkcji (np. Utils :: head), inaczej nie zadziała.

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

EDIT: aby odpowiedzieć na to pytanie, można użyć colorout pakiet mają różne kolory w terminalu. Chłodny! :-)

To moje. Zawsze używam głównego repozytorium Cran i mam kod, aby ułatwić sobie kod źródłowy pakietu programistycznego.

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

Lubię zapisywać moją historię poleceń R i mieć ją dostępną przy każdym uruchomieniu R:

W powłoce lub .bashrc:

export R_HISTFILE=~/.Rhistory

w .Rprofile:

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

Oto dwie funkcje, które uważam za przydatne do pracy z systemem Windows.

Pierwszy konwertuje \s na /.

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

Drugi otwiera katalog roboczy w nowym oknie eksploratora.

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

Mam tę, bardziej dynamiczną sztuczkę, aby użyć pełnej szerokości terminala, która próbuje odczytać ze zmiennej środowiskowej COLUMNS (w systemie 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)}
)

W ten sposób R użyje pełnej szerokości, nawet podczas zmiany rozmiaru okna terminala.

Większość moich osobistych funkcji i załadowanych bibliotek znajduje się w skrypcie 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")')

Oto mój ~ / .Rprofile , zaprojektowany dla komputerów Mac i Linux.

Dzięki temu błędy są lepiej widoczne.

options(showWarnCalls=T, showErrorCalls=T)

Nienawidzę wyboru menu CRAN, więc ustaw na dobry.

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

Więcej historii!

Sys.setenv(R_HISTSIZE='100000')

Poniższe informacje dotyczą uruchamiania w systemie Mac OSX z terminala (który zdecydowanie wolę R.appa, ponieważ jest bardziej stabilny i możesz uporządkować swoją pracę według katalogu; również upewnij się, że masz dobre ~ / .inputrc ). Domyślnie dostajesz wyświetlacz X11, który nie wygląda tak ładnie; to zamiast tego daje wyświetlacz kwarcowy taki sam jak GUI. ifOświadczenie ma złapać przypadek, gdy używasz R z terminalu na 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)

I wstępnie załaduj kilka bibliotek,

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

gdzie util.r to losowa torba rzeczy, których używam, w ciągłym przepływie.

Ponieważ inne osoby wspominały o szerokości konsoli, oto jak to zrobić.

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)

W rzeczywistości tak nie jest, .Rprofileponieważ musisz go ponownie uruchomić za każdym razem, gdy zmieniasz rozmiar okna terminala. Mam to, util.ra następnie po prostu źródła w razie potrzeby.

Oto moje:

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

Spraw, by ramki data.frame wyświetlały się trochę jak „głowa”, tylko bez konieczności wpisywania „głowa”

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

(Od Jak zrobić, aby „głowa” była automatycznie stosowana do wyjścia? )

Często mam ciąg wywołań debugowania, do których muszę zadzwonić, a ich odkomentowanie może być bardzo uciążliwe. Z pomocą społeczności SO wybrałem następujące rozwiązanie i umieściłem to w moim .Rprofile.site. # BROWSERjest dostępny dla moich zadań Eclipse, dzięki czemu mam przegląd wywołań przeglądarki w oknie Widok zadań.

# 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

Mój nie jest zbyt fantazyjny:

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

Wykonuję dużo pracy z baz danych MySQL, więc natychmiastowe połączenie jest darem niebios. Chciałbym tylko, żeby istniał sposób na wylistowanie dostępnych baz danych, aby nie musiałem pamiętać wszystkich różnych nazw.

Wpis Stephena Turnera na .Rprofiles ma kilka przydatnych aliasów i funkcji startowych.

Często używam jego ht i 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]

Oto moje, w tym niektóre ze wspomnianych pomysłów.

Dwie rzeczy, na które możesz chcieć spojrzeć:

• .set.width () / w () zaktualizuj szerokość wydruku do jednego z terminala. Niestety nie znalazłem sposobu, aby zrobić to automatycznie przy zmianie rozmiaru terminala - dokumentacja R wspomina, że ​​robią to niektórzy tłumacze języka R.
• historia jest zapisywana za każdym razem wraz ze znacznikiem czasu i katalogiem roboczym

.

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

Używam następujących poleceń, aby uzyskać cacheSweave (lub pgfSweave) do pracy z przyciskiem „Kompiluj PDF” w RStudio:

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

Kopalnia obejmuje options(menu.graphics=FALSE)bo lubię Wyłącz / stłumić tcltk popup dla CRAN selekcji lustra w badania .

To moje. Nic zbyt innowacyjnego. Myśli o tym, dlaczego poszczególne wybory:

• Poszedłem z ustawieniem domyślnym dla, stringsAsFactorsponieważ uważam, że bardzo wyczerpujące jest przekazywanie go jako argumentu za każdym razem, gdy czytam CSV. To powiedziawszy, już spowodowało to pewne dręczenie podczas używania kodu zapisanego na moim zwykłym komputerze na komputerze, który nie miałem mojego .Rprofile. Trzymam go jednak, ponieważ problemy, które spowodował, są blade w porównaniu z problemami, których codzienne ustawianie nie spowodowało.
• Jeśli utilspakiet nie zostanie załadowany wcześniej options(error=recover), nie można go odzyskać po umieszczeniu w interactive()bloku.
• Użyłem .dbmojego ustawienia Dropbox, a nie options(dropbox=...)dlatego, że używam go cały czas w środku file.pathi oszczędza dużo pisania. Wiodący .zapobiega wyświetlaniu go ls().

Bez ceregieli:

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

Oto mały fragment do eksportowania tabel do LaTeXa . Zmienia wszystkie nazwy kolumn na tryb matematyki dla wielu raportów, które piszę. Reszta mojego .Rprofile jest dość standardowa i głównie opisana powyżej.

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

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

W moim profilu ustawiam motyw kolorów sieci. Oto dwa inne poprawki, których używam:

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

Mam zmienną środowiskową R_USER_WORKSPACE, która wskazuje na górny katalog moich pakietów. W .Rprofile definiuję funkcję devlib, która ustawia katalog roboczy (tak, aby dane () działały) i źródło wszystkich plików .R w podkatalogu R. Jest dość podobny do powyższej funkcji l () Hadleya.

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

Stwierdziłem, że dwie funkcje są naprawdę konieczne: po pierwsze, kiedy ustawiłem debug()kilka funkcji i usunąłem błąd, więc chcę undebug()wszystkich funkcji - nie jedna po drugiej. undebug_all()Funkcja dodana jako Zaakceptowanych odpowiedź tutaj jest najlepsza.

Po drugie, kiedy zdefiniowałem wiele funkcji i szukam konkretnej nazwy zmiennej, trudno jest znaleźć ją we wszystkich wynikach ls(), w tym w nazwach funkcji. lsnofun()Funkcja pisał tutaj jest naprawdę dobra.