Jaka jest najbardziej przydatna sztuczka R? [zamknięte]

Jedną z bardzo przydatnych funkcji, której często używam, jest dput (), która pozwala na zrzut obiektu w postaci kodu R.

# Use the iris data set
R> data(iris)
# dput of a numeric vector
R> dput(iris$Petal.Length)
c(1.4, 1.4, 1.3, 1.5, 1.4, 1.7, 1.4, 1.5, 1.4, 1.5, 1.5, 1.6, 
1.4, 1.1, 1.2, 1.5, 1.3, 1.4, 1.7, 1.5, 1.7, 1.5, 1, 1.7, 1.9, 
1.6, 1.6, 1.5, 1.4, 1.6, 1.6, 1.5, 1.5, 1.4, 1.5, 1.2, 1.3, 1.4, 
1.3, 1.5, 1.3, 1.3, 1.3, 1.6, 1.9, 1.4, 1.6, 1.4, 1.5, 1.4, 4.7, 
4.5, 4.9, 4, 4.6, 4.5, 4.7, 3.3, 4.6, 3.9, 3.5, 4.2, 4, 4.7, 
3.6, 4.4, 4.5, 4.1, 4.5, 3.9, 4.8, 4, 4.9, 4.7, 4.3, 4.4, 4.8, 
5, 4.5, 3.5, 3.8, 3.7, 3.9, 5.1, 4.5, 4.5, 4.7, 4.4, 4.1, 4, 
4.4, 4.6, 4, 3.3, 4.2, 4.2, 4.2, 4.3, 3, 4.1, 6, 5.1, 5.9, 5.6, 
5.8, 6.6, 4.5, 6.3, 5.8, 6.1, 5.1, 5.3, 5.5, 5, 5.1, 5.3, 5.5, 
6.7, 6.9, 5, 5.7, 4.9, 6.7, 4.9, 5.7, 6, 4.8, 4.9, 5.6, 5.8, 
6.1, 6.4, 5.6, 5.1, 5.6, 6.1, 5.6, 5.5, 4.8, 5.4, 5.6, 5.1, 5.1, 
5.9, 5.7, 5.2, 5, 5.2, 5.4, 5.1)
# dput of a factor levels
R> dput(levels(iris$Species))
c("setosa", "versicolor", "virginica")

Bardzo przydatne może być publikowanie łatwo powtarzalnych fragmentów danych, gdy prosisz o pomoc, lub edytowanie lub zmiana kolejności poziomów czynnika.

Head() i tail (), aby uzyskać pierwszą i ostatnią część ramki danych, wektora, macierzy, funkcji itp. Szczególnie w przypadku dużych ramek danych jest to szybki sposób na sprawdzenie, czy załadowano ok.

Jedna fajna funkcja: odczyt danych wykorzystuje połączenia mogą to być pliki lokalne, pliki zdalne dostępne przez http, rury z innych programów lub więcej.

Jako prosty przykład rozważ ten Dostęp dla N = 10 losowych liczb całkowitych między min = 100 a max=200 z random.org (który dostarcza prawdziwe liczby losowe oparte na szumie atmosferycznym, a nie pseudo generatorze liczb losowych):

R> site <- "http://random.org/integers/"         # base URL
R> query <- "num=10&min=100&max=200&col=2&base=10&format=plain&rnd=new"
R> txt <- paste(site, query, sep="?")            # concat url and query string
R> nums <- read.table(file=txt)                  # and read the data
R> nums                                          # and show it
   V1  V2
1 165 143
2 107 118
3 103 132
4 191 100
5 138 185
R>

Na marginesie pakiet random zapewnia kilka funkcje ułatwiające dostęp random.org .

Uważam, że używam with() i within() coraz więcej. Koniec z $ zaśmiecaniem kodu i nie trzeba zaczynać dołączania obiektów do ścieżki wyszukiwania. Bardziej poważnie, uważam, że with() itd sprawiają, że intencja moich skryptów analizy danych jest znacznie jaśniejsza.

> df <- data.frame(A = runif(10), B = rnorm(10))
> A <- 1:10 ## something else hanging around...
> with(df, A + B) ## I know this will use A in df!
 [1]  0.04334784 -0.40444686  1.99368816  0.13871605 -1.17734837
 [6]  0.42473812  2.33014226  1.61690799  1.41901860  0.8699079

with() ustawia środowisko, w którym oceniane jest wyrażenie R. within() robi to samo, ale pozwala na modyfikację obiektu danych użytego do utworzenia środowiska.

> df <- within(df, C <- rpois(10, lambda = 2))
> head(df)
           A          B C
1 0.62635571 -0.5830079 1
2 0.04810539 -0.4525522 1
3 0.39706979  1.5966184 3
4 0.95802501 -0.8193090 2
5 0.76772541 -1.9450738 2
6 0.21335006  0.2113881 4

Coś, czego nie zdawałem sobie sprawy kiedy po raz pierwszy użyłem within() jest to, że musisz wykonać przypisanie jako część wyrażenia ocenianego i przypisać zwracany obiekt (jak wyżej), aby uzyskać pożądany efekt.

Data Input trick = pakiet RGoogleDocs

Http://www.omegahat.org/RGoogleDocs/

Znalazłem arkusze kalkulacyjne Google być fantastyczny sposób dla wszystkich współpracowników, aby być na tej samej stronie. Ponadto Formularze Google umożliwiają przechwytywanie danych od respondentów i łatwe zapisywanie ich w arkuszu kalkulacyjnym google. Ponieważ dane zmieniają się często i prawie nigdy nie są ostateczne, zdecydowanie lepiej jest, aby R odczytał arkusz kalkulacyjny google bezpośrednio niż futz z pobieraniem plików csv i odczytać je.

# Get data from google spreadsheet
library(RGoogleDocs)
ps <-readline(prompt="get the password in ")
auth = getGoogleAuth("[email protected]", ps, service="wise")
sheets.con <- getGoogleDocsConnection(auth)
ts2=getWorksheets("Data Collection Repos",sheets.con)
names(ts2)
init.consent <-sheetAsMatrix(ts2$Sheet1,header=TRUE, as.data.frame=TRUE, trim=TRUE)

Nie pamiętam, które z poniższych poleceń zajmuje kilka sekund.

1. GetGoogleAuth

2. GetGoogleDocsConnection

3. GetWorksheets

Używaj backsticów, aby odwoływać się do niestandardowych nazw.

> df <- data.frame(x=rnorm(5),y=runif(5))
> names(df) <- 1:2
> df
           1         2
1 -1.2035003 0.6989573
2 -1.2146266 0.8272276
3  0.3563335 0.0947696
4 -0.4372646 0.9765767
5 -0.9952423 0.6477714
> df$1
Error: unexpected numeric constant in "df$1"
> df$`1`
[1] -1.2035003 -1.2146266  0.3563335 -0.4372646 -0.9952423

W tym przypadku DF [,"1"] również zadziała. Ale tylne kleszcze działają wewnątrz formuł!

> lm(`2`~`1`,data=df)

Call:
lm(formula = `2` ~ `1`, data = df)

Coefficients:
(Intercept)          `1`  
     0.4087      -0.3440  

[edytuj] Dirk pyta, Dlaczego ktoś miałby podawać nieprawdziwe nazwiska? Nie wiem! Ale z pewnością napotykam ten problem w praktyce dość często. Na przykład, używając pakietu hadley ' a:

> library(reshape)
> df$z <- c(1,1,2,2,2)
> recast(df,z~.,id.var="z")
Aggregation requires fun.aggregate: length used as default
  z (all)
1 1     4
2 2     6
> recast(df,z~.,id.var="z")$(all)
Error: unexpected '(' in "recast(df,z~.,id.var="z")$("
> recast(df,z~.,id.var="z")$`(all)`
Aggregation requires fun.aggregate: length used as default
[1] 4 6

Nie wiem, jak dobrze to jest/nie jest, ale coś, co zdecydowanie wykorzystałem, to możliwości pass-by-reference środowisk.

zz <- new.env()
zz$foo <- c(1,2,3,4,5)
changer <- function(blah) {
   blah$foo <- 5
}
changer(zz)
zz$foo

W tym przykładzie nie ma sensu, dlaczego byłby przydatny, ale jeśli przekazujesz duże obiekty, może to pomóc.

Moją nową ulubioną rzeczą jest biblioteka foreach. Pozwala to na wykonywanie wszystkich przyjemnych rzeczy, ale z nieco łatwiejszą składnią:

list_powers <- foreach(i = 1:100) %do% {
  lp <- x[i]^i
  return (lp)
}

Najlepsze jest to, że jeśli robisz coś, co faktycznie wymaga znacznej ilości czasu, możesz przełączyć się z %do% na %dopar% (z odpowiednią biblioteką zaplecza), aby natychmiast zrównoleglować, nawet w całym klastrze. Bardzo sprytne.

Wykonuję wiele podstawowych manipulacji danymi, więc oto dwie wbudowane funkcje (transform , subset ) oraz jedną bibliotekę ( sqldf), której używam codziennie.

Tworzenie przykładowych danych sprzedaży

sales <- expand.grid(country = c('USA', 'UK', 'FR'),
                     product = c(1, 2, 3))
sales$revenue <- rnorm(dim(sales)[1], mean=100, sd=10)

> sales
  country product   revenue
1     USA       1 108.45965
2      UK       1  97.07981
3      FR       1  99.66225
4     USA       2 100.34754
5      UK       2  87.12262
6      FR       2 112.86084
7     USA       3  95.87880
8      UK       3  96.43581
9      FR       3  94.59259

Użyj transform (), aby dodać kolumnę

## transform currency to euros
usd2eur <- 1.434
transform(sales, euro = revenue * usd2eur)

>
  country product   revenue     euro
1     USA       1 108.45965 155.5311
2      UK       1  97.07981 139.2125
3      FR       1  99.66225 142.9157
...

Użyj subset () do wycinania danych

subset(sales, 
       country == 'USA' & product %in% c(1, 2), 
       select = c('product', 'revenue'))

>
  product  revenue
1       1 108.4597
4       2 100.3475

Użyj sqldf () do wycinania i agregowania z SQL

Pakiet sqldf zapewnia interfejs SQL do ramek danych R

##  recast the previous subset() expression in SQL
sqldf('SELECT product, revenue FROM sales \
       WHERE country = "USA" \
       AND product IN (1,2)')

>
  product  revenue
1       1 108.4597
2       2 100.3475

Wykonaj agregacja lub grupa przez

sqldf('select country, sum(revenue) revenue \ 
       FROM sales \
       GROUP BY country')

>
  country  revenue
1      FR 307.1157
2      UK 280.6382
3     USA 304.6860

Aby uzyskać bardziej wyrafinowaną funkcję map-reduce w ramkach danych, zapoznaj się z pakietem plyr . A jeśli chcesz wyciągnąć włosy, zalecam sprawdzenie manipulacji danymi za pomocą R.

?ave

Podzbiory "x []" są uśrednione, gdzie każdy podzbiór składa się z tych obserwacje z tymi samymi poziomami czynnika. Użycie: ave (x, ..., Zabawa = średnia)

Sposób na przyspieszenie kodu i wyeliminowanie pętli for.

Zamiast pętli for, która przenika przez ramkę danych szukając wartości. wystarczy wziąć podzbiór df z tymi wartościami, znacznie szybciej.

Więc zamiast:

for(i in 1:nrow(df)){
  if (df$column[i] == x) {
    df$column2[i] <- y
    or any other similiar code
  }
}

Zrób coś takiego:

df$column2[df$column1 == x] <- y

Ta podstawowa koncepcja ma zastosowanie bardzo często i jest świetnym sposobem na pozbycie się pętli for

Czasami trzeba rbind wiele ramek danych. do.call() pozwoli Ci to zrobić (ktoś musiał mi to wyjaśnić, gdy zadałem to pytanie, ponieważ nie wydaje się to być oczywistym zastosowaniem).

foo <- list()

foo[[1]] <- data.frame(a=1:5, b=11:15)
foo[[2]] <- data.frame(a=101:105, b=111:115)
foo[[3]] <- data.frame(a=200:210, b=300:310)

do.call(rbind, foo)

W programowaniu R (Nie sesje interaktywne), używam if (bad.condition) stop("message") a lot. Każda funkcja zaczyna się od kilku z nich, a gdy pracuję nad obliczeniami, również je wprowadzam. Chyba nabrałem nawyku od używania assert() W C. korzyści są dwojakie. Po pierwsze, o wiele szybciej jest uzyskać działający kod z tymi czekami. Po drugie, i prawdopodobnie ważniejsze, o wiele łatwiej jest pracować z istniejącym kodem, gdy widzisz te kontrole na każdym ekranie w edytorze. Nie będziesz miał zastanawiać się, czy x>0, czy zaufać komentarzowi stwierdzającemu, że tak ... na pierwszy rzut oka dowiesz się, że tak jest.

PS. mój pierwszy post tutaj. Bądź delikatny!

Funkcja traceback() jest koniecznością, gdy masz gdzieś błąd i nie rozumiesz go łatwo. Wyświetli ślad stosu, co jest bardzo pomocne, ponieważ R domyślnie nie jest zbyt gadatliwy.

Następnie ustawienie options(error=recover) pozwoli Ci "wejść" do funkcji podnoszącej błąd i spróbować zrozumieć, co dokładnie się dzieje, tak jakbyś miał pełną kontrolę nad nią i mógł umieścić w niej browser().

Te trzy funkcje mogą naprawdę pomóc w debugowaniu kodu.

Jestem naprawdę zaskoczony, że nikt nie napisał o apply, tapply, lapply i sapply. Ogólną zasadą używam podczas robienia rzeczy w R jest to, że jeśli mam pętlę for, która wykonuje przetwarzanie danych lub symulacje, staram się to uwzględnić i zastąpić go * apply. Niektórzy ludzie unikają funkcji * apply, ponieważ uważają, że tylko pojedyncze funkcje parametru mogą być przekazywane. Nic bardziej mylnego! Jak przekazywanie funkcji o parametrach jako obiektów pierwszej klasy w Javascript, robisz to w R z anonimowymi funkcjami. Na przykład:

 > sapply(rnorm(100, 0, 1), round)
  [1]  1  1  0  1  1 -1 -2  0  2  2 -2 -1  0  1 -1  0  1 -1  0 -1  0  0  0  0  0
 [26]  2  0 -1 -2  0  0  1 -1  1  5  1 -1  0  1  1  1  2  0 -1  1 -1  1  0 -1  1
 [51]  2  1  1 -2 -1  0 -1  2 -1  1 -1  1 -1  0 -1 -2  1  1  0 -1 -1  1  1  2  0
 [76]  0  0  0 -2 -1  1  1 -2  1 -1  1  1  1  0  0  0 -1 -3  0 -1  0  0  0  1  1


> sapply(rnorm(100, 0, 1), round(x, 2)) # How can we pass a parameter?
Error in match.fun(FUN) : object 'x' not found


# Wrap your function call in an anonymous function to use parameters
> sapply(rnorm(100, 0, 1), function(x) {round(x, 2)})
  [1] -0.05 -1.74 -0.09 -1.23  0.69 -1.43  0.76  0.55  0.96 -0.47 -0.81 -0.47
 [13]  0.27  0.32  0.47 -1.28 -1.44 -1.93  0.51 -0.82 -0.06 -1.41  1.23 -0.26
 [25]  0.22 -0.04 -2.17  0.60 -0.10 -0.92  0.13  2.62  1.03 -1.33 -1.73 -0.08
 [37]  0.45 -0.93  0.40  0.05  1.09 -1.23 -0.35  0.62  0.01 -1.08  1.70 -1.27
 [49]  0.55  0.60 -1.46  1.08 -1.88 -0.15  0.21  0.06  0.53 -1.16 -2.13 -0.03
 [61]  0.33 -1.07  0.98  0.62 -0.01 -0.53 -1.17 -0.28 -0.95  0.71 -0.58 -0.03
 [73] -1.47 -0.75 -0.54  0.42 -1.63  0.05 -1.90  0.40 -0.01  0.14 -1.58  1.37
 [85] -1.00 -0.90  1.69 -0.11 -2.19 -0.74  1.34 -0.75 -0.51 -0.99 -0.36 -1.63
 [97] -0.98  0.61  1.01  0.55

# Note that anonymous functions aren't being called, but being passed.
> function() {print('hello #rstats')}()
function() {print('hello #rstats')}()
> a = function() {print('hello #rstats')}
> a
function() {print('hello #rstats')}
> a()
[1] "hello #rstats"

(dla tych, którzy podążają za #rstats, też to tam zamieściłem).

N = 10000
l = numeric()
for (i in seq(1:N)) {
    sim <- rnorm(1, 0, 1)
    l <- rbind(l, sim)
}

Nie tylko nie jest to wektoryzowane, ale struktura tablicy w R nie jest rozwijana tak, jak w Pythonie (podwajanie rozmiaru, gdy przestrzeń się wyczerpie, IIRC). Więc każdy krok rbind musi najpierw rosnąć l wystarczy, aby zaakceptować wyniki z rbind (), a następnie skopiować całą zawartość poprzedniej l. Dla Zabawy, wypróbuj powyższe w R. zauważ, jak długo to trwa (nie potrzebujesz nawet Rprof ani żadnej funkcji pomiaru czasu). Następnie spróbuj

N=10000
l <- rnorm(N, 0, 1)

Następująca wersja jest lepsza od pierwszej wersji:

N = 10000
l = numeric(N)
for (i in seq(1:N)) {
    sim <- rnorm(1, 0, 1)
    l[i] <- sim
}

Za radą Dirka zamieszczam pojedyncze przykłady. Mam nadzieję, że nie są zbyt "słodkie" [sprytne, ale nie obchodzi mnie to] lub trywialne dla tej publiczności.

Modele liniowe są chlebem powszednim R. Gdy liczba zmiennych niezależnych jest duża, jeden ma dwa wyjścia. Pierwszym z nich jest użycie lm.fit (), która otrzymuje macierz projektową x i odpowiedź y jako argumenty, podobnie jak Matlab. Wadą tego podejścia jest to, że wartością zwracaną jest lista obiektów (współczynniki dopasowane, residuals, etc), a nie obiekt klasy "lm", który można ładnie podsumować, wykorzystać do przewidywania, stopniowego wyboru itp. Drugim podejściem jest utworzenie wzoru:

> A
           X1         X2          X3         X4         y
1  0.96852363 0.33827107 0.261332257 0.62817021 1.6425326
2  0.08012755 0.69159828 0.087994158 0.93780481 0.9801304
3  0.10167545 0.38119304 0.865209832 0.16501662 0.4830873
4  0.06699458 0.41756415 0.258071616 0.34027775 0.7508766
   ...

> (f=paste("y ~",paste(names(A)[1:4],collapse=" + ")))
[1] "y ~ X1 + X2 + X3 + X4"

> lm(formula(f),data=A)

Call:
lm(formula = formula(f), data = A)

Coefficients:
(Intercept)           X1           X2           X3           X4  
    0.78236      0.95406     -0.06738     -0.43686     -0.06644  

Możesz przypisać wartość zwracaną z bloku if-else.

Zamiast, np.

condition <- runif(1) > 0.5
if(condition) x <- 1 else x <- 2

You can do

x <- if(condition) 1 else 2

Jako totalny noob do R i nowicjusz w stats I love unclass() aby wydrukować wszystkie elementy ramki danych jako zwykłą listę.

Jest to bardzo przydatne, aby spojrzeć na kompletny zestaw danych za jednym razem, aby szybko wykryć potencjalne problemy.

CrossTable() Pakiet gmodels zapewnia łatwy dostęp do crosstabów w stylu SAS i SPSS, wraz ze zwykłymi testami (Chisq, McNemar, itp.). Zasadniczo jest to xtabs() z fantazyjnym wyjściem i dodatkowymi testami - ale ułatwia dzielenie się wyjściem z poganami.

Definitywnie system(). Możliwość dostępu do wszystkich narzędzi uniksowych (przynajmniej pod Linuksem/MacOSX) ze środowiska R szybko stała się nieoceniona w moim codziennym przepływie pracy.

Oto irytujące obejście konwersji czynnika na liczbę. (Podobnie w przypadku innych typów danych)

old.var <- as.numeric(levels(old.var))[as.numeric(old.var)]

Chociaż to pytanie jest już od jakiegoś czasu, niedawno odkryłem na blogu SAS i R świetną sztuczkę z użyciem polecenia cut. Polecenie służy do dzielenia danych na kategorie, a ja użyję zestawu danych iris jako przykładu i podzielę go na 10 kategorii:

> irisSL <- iris$Sepal.Length
> str(irisSL)
 num [1:150] 5.1 4.9 4.7 4.6 5 5.4 4.6 5 4.4 4.9 ...
> cut(irisSL, 10)
  [1] (5.02,5.38] (4.66,5.02] (4.66,5.02] (4.3,4.66]  (4.66,5.02] (5.38,5.74] (4.3,4.66]  (4.66,5.02] (4.3,4.66]  (4.66,5.02]
 [11] (5.38,5.74] (4.66,5.02] (4.66,5.02] (4.3,4.66]  (5.74,6.1]  (5.38,5.74] (5.38,5.74] (5.02,5.38] (5.38,5.74] (5.02,5.38]
 [21] (5.38,5.74] (5.02,5.38] (4.3,4.66]  (5.02,5.38] (4.66,5.02] (4.66,5.02] (4.66,5.02] (5.02,5.38] (5.02,5.38] (4.66,5.02]
 [31] (4.66,5.02] (5.38,5.74] (5.02,5.38] (5.38,5.74] (4.66,5.02] (4.66,5.02] (5.38,5.74] (4.66,5.02] (4.3,4.66]  (5.02,5.38]
 [41] (4.66,5.02] (4.3,4.66]  (4.3,4.66]  (4.66,5.02] (5.02,5.38] (4.66,5.02] (5.02,5.38] (4.3,4.66]  (5.02,5.38] (4.66,5.02]
 [51] (6.82,7.18] (6.1,6.46]  (6.82,7.18] (5.38,5.74] (6.46,6.82] (5.38,5.74] (6.1,6.46]  (4.66,5.02] (6.46,6.82] (5.02,5.38]
 [61] (4.66,5.02] (5.74,6.1]  (5.74,6.1]  (5.74,6.1]  (5.38,5.74] (6.46,6.82] (5.38,5.74] (5.74,6.1]  (6.1,6.46]  (5.38,5.74]
 [71] (5.74,6.1]  (5.74,6.1]  (6.1,6.46]  (5.74,6.1]  (6.1,6.46]  (6.46,6.82] (6.46,6.82] (6.46,6.82] (5.74,6.1]  (5.38,5.74]
 [81] (5.38,5.74] (5.38,5.74] (5.74,6.1]  (5.74,6.1]  (5.38,5.74] (5.74,6.1]  (6.46,6.82] (6.1,6.46]  (5.38,5.74] (5.38,5.74]
 [91] (5.38,5.74] (5.74,6.1]  (5.74,6.1]  (4.66,5.02] (5.38,5.74] (5.38,5.74] (5.38,5.74] (6.1,6.46]  (5.02,5.38] (5.38,5.74]
[101] (6.1,6.46]  (5.74,6.1]  (6.82,7.18] (6.1,6.46]  (6.46,6.82] (7.54,7.9]  (4.66,5.02] (7.18,7.54] (6.46,6.82] (7.18,7.54]
[111] (6.46,6.82] (6.1,6.46]  (6.46,6.82] (5.38,5.74] (5.74,6.1]  (6.1,6.46]  (6.46,6.82] (7.54,7.9]  (7.54,7.9]  (5.74,6.1] 
[121] (6.82,7.18] (5.38,5.74] (7.54,7.9]  (6.1,6.46]  (6.46,6.82] (7.18,7.54] (6.1,6.46]  (5.74,6.1]  (6.1,6.46]  (7.18,7.54]
[131] (7.18,7.54] (7.54,7.9]  (6.1,6.46]  (6.1,6.46]  (5.74,6.1]  (7.54,7.9]  (6.1,6.46]  (6.1,6.46]  (5.74,6.1]  (6.82,7.18]
[141] (6.46,6.82] (6.82,7.18] (5.74,6.1]  (6.46,6.82] (6.46,6.82] (6.46,6.82] (6.1,6.46]  (6.46,6.82] (6.1,6.46]  (5.74,6.1] 
10 Levels: (4.3,4.66] (4.66,5.02] (5.02,5.38] (5.38,5.74] (5.74,6.1] (6.1,6.46] (6.46,6.82] (6.82,7.18] ... (7.54,7.9]

Kolejna sztuczka. Niektóre pakiety, takie jak glmnet, Tylko przyjmują jako wejścia macierz projektową i zmienną odpowiedzi. Jeśli ktoś chce dopasować model do wszystkich interakcji między funkcjami, nie może użyć formuły " y ~ .^2". Użycie expand.grid() pozwala nam skorzystać z potężnego indeksowania tablicy i operacji wektorowych r.

interArray=function(X){
    n=ncol(X)
    ind=expand.grid(1:n,1:n)
    return(X[,ind[,1]]*X[,ind[,2]])
}

> X
          X1         X2
1 0.96852363 0.33827107
2 0.08012755 0.69159828
3 0.10167545 0.38119304
4 0.06699458 0.41756415
5 0.08187816 0.09805104

> interArray(X)
           X1          X2        X1.1        X2.1
1 0.938038022 0.327623524 0.327623524 0.114427316
2 0.006420424 0.055416073 0.055416073 0.478308177
3 0.010337897 0.038757974 0.038757974 0.145308137
4 0.004488274 0.027974536 0.027974536 0.174359821
5 0.006704033 0.008028239 0.008028239 0.009614007

Jedną z moich ulubionych, jeśli nie nieco niekonwencjonalnych sztuczek, jest użycie eval() i parse(). Ten przykład może ilustrować, w jaki sposób może być pomocny

NY.Capital <- 'Albany'
state <- 'NY'
parameter <- 'Capital'
eval(parse(text=paste(state, parameter, sep='.')))

[1] "Albany"

Tego typu sytuacja występuje częściej niż nie, a użycie eval() i parse() może pomóc rozwiązać ten problem. Oczywiście z zadowoleniem przyjmuję wszelkie opinie na temat alternatywnych sposobów kodowania tego.

set.seed() ustawia stan generatora liczb losowych.

Na przykład:

> set.seed(123)
> rnorm(1)
[1] -0.5604756
> rnorm(1)
[1] -0.2301775
> set.seed(123)
> rnorm(1)
[1] -0.5604756

Dla tych, którzy piszą C, aby nazywać się od R: .Internal(inspect(...)) jest przydatne. Na przykład:

> .Internal(inspect(quote(a+2)))
  @867dc28 06 LANGSXP g0c0 [] 
  @8436998 01 SYMSXP g1c0 [MARK,gp=0x4000] "+"
  @85768b0 01 SYMSXP g1c0 [MARK,NAM(2)] "a"
  @8d7bf48 14 REALSXP g0c1 [] (len=1, tl=0) 2

D = '~ / R Code / Library/ '

Files = list.files (d,'.r$')

For (f w plikach) { if (!(f = = " mysource.r" )) { print(paste ('Sourcing', f)) source (paste (d, f, sep=")) } }

Używam powyższego kodu do pozyskiwania wszystkich plików w katalogu przy starcie z różnych programów użytkowych używam w mojej interaktywnej sesji z R. jestem pewien, że są lepsze sposoby, ale uważam, że jest to przydatne dla mojej pracy. Linia, która to robi, jest następująca.

Source ("~/R Code / Library / mysource.r")

Aby wykonać operację na wielu zmiennych w ramce danych. To jest kradzione z podzbioru.data.rama.

get.vars<-function(vars,data){
    nl <- as.list(1L:ncol(data))
    names(nl) <- names(data)
    vars <- eval(substitute(vars), nl, parent.frame())
    data[,vars]
    #do stuff here
}

get.vars(c(cyl:hwy,class),mpg)

Już to kiedyś zamieściłem, ale używam go tak często, że pomyślałem, że opublikuję go ponownie. To tylko mała funkcja zwracająca nazwy i numery pozycji danych.rama. Jego nic specjalnego, aby być pewnym, ale prawie nigdy nie zrobić to przez sesję bez używania go wiele razy.

##creates an object from a data.frame listing the column names and location

Namesind=function(DF) {

temp1=names(df)
temp2=seq(1,length(temp1))
temp3=data.frame(temp1,temp2)
names(temp3)=c("VAR","COL")
return(temp3)
rm(temp1,temp2,temp3)

}

Ni