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

271

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.

Peter Mortensen
źródło
29
Niestety pytanie jest zamknięte, ale uważam, że prawidłowa odpowiedź to „nic”. Zamiast używać .Rprofile, sugeruję utrzymywanie skryptu inicjującego na najwyższym poziomie każdego projektu, który zostanie wywołany na początku każdego skryptu w twoim projekcie. Dzięki temu praca jest odtwarzalna dla innych użytkowników dzięki kontroli źródła. Ale są tutaj świetne odpowiedzi! Umieszczę niektóre z tych pomysłów we własnych skryptach inicjujących.
genorama
18
@geneorama - Dobry komentarz, ale nieco poprawiłbym twoją odpowiedź: Nie .Rprofilepowinien zawierać żadnego kodu, który zmienia wyniki. Możesz dołączyć rzeczy, które zmieniają wygląd R (np. options("width"=160)) Lub domyślne lustro CRAN (np options(repos = c(CRAN = "http://cran.rstudio.com")).). Nie należy jednak ładować pakietów, zmieniać domyślnych opcji regularnie używanych funkcji, definiować funkcji itp. Kod powinien być samodzielny i odtwarzać wyniki bez określonego .Rprofilepliku.
user2503795
@geneorama, gdzie powinienem umieścić niestandardowe funkcje? Być może w osobnym pakiecie / przestrzeni nazw? Czy to jest łatwe / możliwe w środku .Rprofile?
Aaron McDaid
2
@ aaron-mcdaid First @ user2503795 ma absolutną rację, .Rprofilejest odpowiednim miejscem do wprowadzania zmian w aplikacji. Po drugie, twoje pytanie powinno być osobnym pytaniem SO. Próbuję użyć wzorca podobnego do tego, co zrobiliśmy w naszym projekcie kontroli żywności (zobacz układ kodu i kroki inicjalizacji u góry każdego skryptu).
genorama

Odpowiedzi:

96

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
Dirk Eddelbuettel
źródło
Nie jestem pewien, ale myślę, że teraz X11.options zostało zastąpione przez windows.options. Czy to prawda?
Manuel Ramón,
Zamiast go tworzyć, ra następnie rmdodawać, możesz umieścić to w local({ })bloku. Dobra odpowiedź, uwielbiam konfigurację X11!
Aaron McDaid
Tak, local({ ... })jak pokazano w help(Startup)tym, co zwykle robię w tych dniach Rprofile.site. Od jakiegoś czasu nie potrzebowałem
hacka
59
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.

Eduardo Leoni
źródło
Eduardo - Ciekawe, jakie są zalety nieużywania czynników?
medriscoll
28
+1 Chciałbym, żeby było to domyślne w R.
Iterator
5
Zauważ, że wektory znaków wydają się zużywać mniej pamięci (około dwustu bajtów) w systemach 32-bitowych. W systemach 64-bitowych czynniki zużywają znacznie mniej. stat.ethz.ch/pipermail/r-help/2012-August/321919.html
Ari B. Friedman
+1 Dziękujemy za wskazanie niektórych głównych problemów związanych z czynnikami. System formatowania SAS ma wiele zalet w tym zakresie, imo. Podczas czytania z tekstu parametr stringSsFactors jest zawsze ustawiony na wartość false. Jednak w przypadku przesyłania danych unikam w miarę możliwości czytania z arkusza kalkulacyjnego.
AdamO,
58

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! :-)

dalloliogm
źródło
8
Myślę, nże ugryzłby mnie osobiście w tył podczas debugowania.
Roman Luštrik,
2
Świetnie nadaje się do interaktywnego użytku w R, ale nie są one przenośne - nie umieszczaj ich w swoim (napisanym) kodzie!
Vince
25
Jeśli kiedykolwiek usuniesz wszystkie obiekty w środowisku globalnym, powyższe aliasy również zostaną usunięte. Można temu zapobiec, ukrywając je w środowisku. .startup <- new.env() assign("h", utils::head, env=.startup) assign("n", base::names, env=.startup) assign("ht", function(d) rbind(head(d,6),tail(d,6)) , env=.startup) assign("s", base::summary, env=.startup) attach(.startup)
Kevin Wright
12
Wypróbowałem ten świetny pomysł, ale już go użyłem, więc zrobiłem to sum <- base::summary. To nie był taki świetny pomysł.
Tom
1
re colorout: "" "Ten pakiet został zarchiwizowany: wykorzystał punkty wejścia inne niż API, które nie są dozwolone przez zasady CRAN." ""
izomorfizm
26

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"))  
}
Hadley
źródło
26

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")))
        }
}
Jeff
źródło
23

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()))))
}
Tomek
źródło
2
To .repathjest tak wsiada do mojego .Rprofile.
Waldir Leoncio
1
Napisałem dodatek RStudio, który zawierał tę funkcję. Po prostu skopiuj ścieżkę, kliknij menu z RStudio, a przekonwertowana ścieżka zostanie wstawiona do położenia kursora. To powinno zaoszczędzić trochę naciśnięć klawiszy.
dracodoc
1
Nienawidzę problemu SOOO ze ścieżką Windows. Myślę, że mogę mieć jeszcze lepsze rozwiązanie. Dodałem fragment kodu. więc wszystko, co muszę zrobić, to wpisać wpp, a następnie nacisnąć tab, a pojawi się moja skopiowana ścieżka. Oto kod. snippet wpp `r paste("\"", gsub("\\\\", "/", readClipboard()), "\"", sep = "")`
jamesguy0121
18

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.

Branimir Dolicki
źródło
1
Jeśli COLUMNSnie jest ustawiony, możesz spróbować zastosować width = as.integer(system('tput cols',intern=TRUE)mechanizm ochronny.
shabbychef
17

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")')
kpierce8
źródło
1
Heh, myślałem o nazwie R GUI „Arrr” - jest to o wiele łatwiejszy sposób na dodanie pirackiej dobroci.
Sharpie
2
Ah dziękuję. Dobrze wiedzieć, że nie jestem jedynym, który myśli o piracie podczas odpalania R. :-) Przysięgam, że kiedyś się z tym pogodzę.
ars
1
Wyjaśnia, dlaczego @Dirk ustawił hak w swoim skrypcie ...
James
1
„Avast Ye” to niestandardowy pirat . Wolę, aby mój Pirat był zgodny ze standardami. Oznacza to również ~ „trzymaj mocno”, więc czy nie miałoby to większego sensu na początku? : P
naught101
2
Właściwie to ma sens na końcu. Po wyjściu z domeny r wracamy do mniejszego środowiska wokół niej i znów musimy poradzić sobie z arkuszami kalkulacyjnymi i plikami tekstowymi ad-hoc.
kpierce8 26.04.13
17

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.

Brendan OConnor
źródło
Jeśli otworzę R w oknie Xterm (wpisując „R”), czy powinien on otworzyć okno podobne do GU? Nie mogę odróżnić, dodając ten .Rprofile do mojego katalogu domowego.
Richard Herron
Nie. Zachowuje wszystko w konsoli. Jednak podczas kreślenia rzeczy używa inteligentniejszego urządzenia wyświetlającego niż domyślne urządzenie wyświetlające X11.
Brendan OConnor,
Wydaje mi się, że te skrypty zmieniające rozmiar okna mogą być użytecznym pakietem. Czy sie zgadzasz?
izomorfizm
16

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))
}
Alfred J Fazio
źródło
1
nie należy zamieszczać adresu proxy swojej instytucji na publicznej stronie internetowej.
dalloliogm
13
dalloliogm, jest to prywatny (niepubliczny) adres IP. Istnieją setki tysięcy komputerów na całym świecie z tym samym adresem IP. Powodzenia, próbując dowiedzieć się, który jest mój!
Alfred J Fazio
2
alfred, czy znalazłeś sposób na zdefiniowanie funkcji w .Rprofile (tak jak tutaj) bez wyświetlania ich podczas wykonywania ls (), oprócz nazywania początkowym „.”? Mam za dużo bałaganu z funkcji, które zdefiniowałem, gdy Is (). Dzięki
Keith,
4
@Keith przypisz je do środowiska i dołącz środowisko do ścieżki wyszukiwania, a następnie posprzątaj. Jeśli funkcje znajdują się w osobnym pliku, możesz je bezpośrednio pobrać do środowiska. Zobacz ?new.env, ?assigna ?sys.source. Jeśli nie możesz go uruchomić, opublikuj nowe Q na SO, a jestem pewien, że otrzymasz odpowiedzi.
Gavin Simpson
Twój pakiet my.as.Datemoże zostać zastąpiony Lubridate. Czy mam rację?
izomorfizm
11
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
}
Patrick McCann
źródło
11

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

Hugh Perkins
źródło
10

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
Roman Luštrik
źródło
9

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' )
cameron.bracken
źródło
8
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.

Brandon Bertelsen
źródło
4
głupie mnie dbGetQuery (con, „pokaż bazy danych;”)
Brandon Bertelsen
8

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]
Ram Narasimhan
źródło
Jest pakiet o nazwie BurStMisc, który zawiera wywoływaną funkcję, cornerktóra robi to samo co twoja hhfunkcja i trochę więcej. ;)
Waldir Leoncio
7

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"))
   }
}
Florian Bw
źródło
7

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")
ROLO
źródło
7

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)
    }
}
Ari B. Friedman
źródło
7

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
}
N8TRO
źródło
5

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)
Kevin Wright
źródło
1
Ta setwdzamiana będzie działać lepiej w wersji:utils::assignInNamespace("setwd",function(dir) {on.exit(setWindowTitle(base::getwd())); .Internal(setwd(dir))}, "base")
Marek
5

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")
Karsten W.
źródło
5

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.

Ali
źródło