Utilisateurs experts R, Ce qu'il y a dans votre.Rprofile? [fermé]

je déteste taper les mots "chef", "sommaire", "noms" à chaque fois, j'ai donc utiliser des alias.

Vous pouvez mettre des alias dans votre .RPROFILE file, mais vous devez utiliser le chemin complet de la fonction (par exemple utils::head) sinon ça ne marchera pas.

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

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

options(stringsAsFactors=FALSE)

bien que je ne l'ai pas vraiment dans mon .Rprofile, parce qu'il pourrait briser le code de mes co-auteurs, je souhaite qu'il soit le 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

facteurs sont grands lorsque vous avez besoin d'eux (par exemple la mise en œuvre de l'ordre dans les graphiques), mais un la nuisance la plupart du temps.

voici le mien. J'utilise toujours le dépôt principal du cran, et j'ai du code pour le rendre facile à trouver.

.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 l'historique de ma commande R et la rendre disponible chaque fois que J'exécute R:

Dans le shell ou .bashrc:

export R_HISTFILE=~/.Rhistory

in .Rprofile:

.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 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 ce, truc plus dynamique pour utiliser la largeur de terminal complète, qui essaie de lire à partir de la variable D'environnement colonnes (sur 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 pleine largeur même si vous redimensionnez votre fenêtre de terminal.

la plupart de mes fonctions personnelles et des bibliothèques chargées sont dans les Rfunctions.R script

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

c'est à partir de mon ~/.Rprofile , conçu pour Mac et Linux.

ceux-ci rendent les erreurs plus faciles à voir.

options(showWarnCalls=T, showErrorCalls=T)

je déteste le choix de menu de CRAN, donc 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 exécuter sur Mac OSX à 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'avoir un bon ~/.inputrc ). Par défaut, vous obtenez un affichage X11, qui n'a pas l'air aussi agréable; cela donne plutôt un affichage à quartz identique à L'interface graphique. La déclaration if est censée saisir l'affaire quand 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 choses I l'utilisation, en vertu de flux.

aussi, puisque d'autres personnes mentionnaient la largeur de la console, voici comment je 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 parce que vous devez le relancer chaque fois que vous redimensionnez la fenêtre du terminal. Je l'ai dans util.r alors je l'ai juste source comme nécessaire.

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
}

Rendre les données.les cadres affichent un peu comme 'tête', seulement 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 de la "tête" de s'appliquer 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 so community , je suis allé chercher la solution suivante et l'ai insérée dans mon .Rprofile.site . # BROWSER est là pour mes tâches Eclipse de sorte que j'ai un aperçu des appels de navigateur dans la fenêtre de 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 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 de bases de données mysql, donc se connecter tout de suite est une aubaine. J'aimerais qu'il y ait un moyen de lister les bases de données disponibles pour ne pas avoir à me souvenir de tous les noms différents.

Stephen's post on .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]

j'utilise ce qui suit pour faire fonctionner cacheSweave (ou pgfSweave) 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 popup pour CRAN miroir de sélection dans la R .

voici le mien. Rien de trop innovant. Réflexions sur le pourquoi des choix particuliers:

• j'ai utilisé le paramètre par défaut pour stringsAsFactors parce que je trouve il est extrêmement épuisant de passer comme un argument chaque fois que je lis un CSV dans. Cela dit, il m'a déjà causé une certaine vexation mineure lors de l'utilisation du code écrit sur mon ordinateur habituel sur un ordinateur qui n'avait pas mon .Rprofile. Je le garde, bien que, comme les troubles qu'il a causé pâle en comparaison de les perturbations ne l'ayant pas fixé tous les jours utilisés pour causer.
• si vous ne chargez pas le paquet utils avant options(error=recover) , il ne peut pas retrouver recover lorsqu'il est placé dans un bloc interactive() .
• j'ai utilisé .db pour mon réglage de dropbox plutôt que options(dropbox=...) parce que je l'utilise tout le temps dans file.path et il économise beaucoup de Dactylographie. Le premier . l'empêche d'apparaître avec ls() .

sans autre ado:

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 des tables vers LaTeX . Il change tous les noms de colonne en mode mathématique pour les nombreux rapports que j'écris. Le reste de ma .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
}

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

Deux choses que vous pourriez vouloir regarder:

• .définir.width () / w () mettez à jour votre largeur d'impression sur celle du terminal. Malheureusement, je n'ai pas trouvé le moyen de le faire automatiquement sur la documentation terminal resize - R mentionne que cela est fait par certains interprètes R.
• l'histoire est sauvée à chaque fois avec un timestamp 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'ai mis mon thème couleur treillis dans mon profil. Voici deux autres modifications 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 paquets. Dans. Rprofile I définit une fonction devlib qui définit le répertoire de travail (de sorte que data () fonctionne) et les sources .Fichiers R dans le sous-répertoire R. Il 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 quand j'ai mis debug() sur plusieurs fonctions et j'ai résolu le bug, donc je veux undebug() toutes les fonctions - pas une par une. La fonction undebug_all() ajoutée comme réponse acceptée ici est la meilleure.

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