Какой самый полезный трюк?

Ответ 1

str() указывает структуру любого объекта.

Ответ 2

Одной очень полезной функцией, которую я часто использую, является dput(), которая позволяет сбрасывать объект в виде 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")

Очень удобно размещать легко воспроизводимые фрагменты данных, когда вы обращаетесь за помощью или редактируете или изменяете уровни фактора.

Ответ 3

head() и tail(), чтобы получить первую и последнюю части фрейма данных, вектора, матрицы, функции и т.д. Особенно с большими кадрами данных это быстрый способ проверить, что он загружен нормально.

Ответ 4

Одна приятная функция: Чтение данных использует соединения, которые могут быть локальными файлами, удаленные файлы, доступ к которым осуществляется через http, каналы из других программ или более.

В качестве простого примера рассмотрим этот доступ для N = 10 случайных чисел между min = 100 и max = 200 из random.org ( который поставляет истинные случайные числа на основе атмосферного шума, а не генератора псевдослучайных чисел):

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>

В стороне, random пакет предоставляет несколько удобных функций для доступа к random.org.

Ответ 5

Я нахожу, что использую with() и within() все больше и больше. Не более $ забивает мой код, и не нужно начинать прикреплять объекты к пути поиска. Более серьезно, я нахожу, что with() и т.д. Значительно улучшают мои сценарии анализа данных.

> 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() устанавливает среду, в которой оценивается выражение R. within() делает то же самое, но позволяет вам изменять объект данных, используемый для создания среды.

> 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

Что-то, чего я не понимал при первом использовании within(), заключается в том, что вам нужно выполнить присваивание как часть выражения, оцененного и, назначить возвращенный объект (как указано выше), чтобы получить желаемый эффект.

Ответ 6

Титка ввода данных = пакет RGoogleDocs

http://www.omegahat.org/RGoogleDocs/

Я нашел таблицы Google, чтобы быть фантастическим способом для всех соавторов быть на одной странице. Кроме того, Google Forms позволяет захватывать данные от респондентов и легко записывать их в электронную таблицу google. Поскольку данные часто меняются и почти никогда не являются окончательными, для R лучше всего читать электронную таблицу google, а не futz с загрузкой файлов csv и их чтением.

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

Я не могу повторить, но одна или две из следующих команд занимают несколько секунд.

• getGoogleAuth

• getGoogleDocsConnection

• getWorksheets

Ответ 7

Используйте обратные ссылки для ссылки на нестандартные имена.

> 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

В этом случае также будет работать df [, "1" ]. Но обратные клещи работают внутри формул!

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

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

Coefficients:
(Intercept)          `1`  
     0.4087      -0.3440  

[Изменить] Дирк спрашивает, почему можно было бы назвать недопустимые имена? Я не знаю! Но я определенно сталкиваюсь с этой проблемой на практике довольно часто. Например, используя пакет hasley reshape:

> 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

Ответ 8

Не знаю, насколько хорошо это известно/нет, но что-то, что я определенно использовал, - это возможности передачи по ссылке для сред.

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

В этом примере не имеет смысла, почему это было бы полезно, но если вы проезжаете большие объекты вокруг него, это может помочь.

Ответ 9

Моя новая любимая вещь - библиотека foreach. Он позволяет вам выполнять все приятные приложения, но с несколько упрощенным синтаксисом:

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

Самое приятное то, что если вы делаете то, что на самом деле требует значительного количества времени, вы можете переключиться с %do% на %dopar% (с соответствующей библиотекой), чтобы мгновенно распараллелить даже в кластере. Очень гладкий.

Ответ 10

Я делаю много базовых манипуляций с данными, поэтому здесь есть две встроенные функции (transform, подмножество) и одна библиотека ( sqldf), который я использую ежедневно.

создать образцы данных продаж

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

используйте transform(), чтобы добавить столбец

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

использовать подмножество() для обработки данных

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

>
  product  revenue
1       1 108.4597
4       2 100.3475

использовать sqldf() для среза и агрегирования с помощью SQL

sqldf package предоставляет интерфейс SQL для кадров данных 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

Выполните агрегацию или GROUP BY

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

Для более сложных функций уменьшения числа карт в кадрах данных проверьте plyr. И если вы хотите вытащить свои волосы, я рекомендую проверить Манипуляция данными с R.

Ответ 11

?ave

Подмножества 'x []' усредняются, причем каждое подмножество состоит из таких    наблюдений с одинаковыми уровнями факторов. Применение:    ave (x,..., FUN = среднее значение)

Я использую его все время. (например, в этом ответе здесь, так)

Ответ 12

Способ ускорения кода и исключения для циклов.

а не для циклов, которые проходят через фрейм данных, ищущих значения. просто возьмите подмножество df с этими значениями намного быстрее.

поэтому вместо:

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

сделайте что-нибудь вроде этого:

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

эта базовая концепция применима очень часто и является отличным способом избавиться от циклов

Ответ 13

Иногда вам нужно rbind несколько кадров данных. do.call() позволит вам это сделать (кто-то должен был объяснить это мне, когда связал, я задал этот вопрос, поскольку он не кажется очевидным).

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)

Ответ 14

В программировании R (не интерактивные сессии) я много использую if (bad.condition) stop("message"). Каждая функция начинается с нескольких из них, и когда я работаю с вычислениями, я тоже их переплющиваю. Наверное, я привык использовать assert() в C. Преимущества в два раза. Во-первых, гораздо быстрее получить рабочий код с этими проверками. Во-вторых, и, что еще важнее, гораздо проще работать с существующим кодом, когда вы видите эти проверки на каждом экране своего редактора. Вам не нужно задаваться вопросом, есть ли x>0, или доверять комментарию, заявив, что это... вы будете знать, с первого взгляда, что это так.

PS. мой первый пост здесь. Будьте осторожны!

Ответ 15

Функция traceback() является обязательной, когда вы где-то ошибаетесь и не понимаете ее легко. Он будет печатать трассировку стека, очень полезно, так как R по умолчанию не очень многословно.

Затем установка options(error=recover) позволит вам "enter" в функцию, поднимающую ошибку, и попытаться понять, что происходит точно, как если бы вы полностью контролировали ее и могли вставить в нее browser().

Эти три функции могут действительно помочь отладить ваш код.

Ответ 16

Я действительно удивлен, что никто не опубликовал информацию о применении, наплечях, лапках и притирании. Общее правило, которое я использую, когда делаю вещи в R, состоит в том, что если у меня есть цикл for, который выполняет обработку данных или моделирование, я пытаюсь его исключить и заменить на *. Некоторые люди уклоняются от функций * apply, потому что они думают, что могут быть переданы только функции одного параметра. Ничто не может быть дальше от истины! Подобно прохождению функций с параметрами в качестве объектов первого класса в Javascript, вы делаете это в R с анонимными функциями. Например:

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

(Для тех, кто следует за #rstats, я также разместил это там).

Помните, что используйте apply, sapply, lapply, tapply и do.call! Воспользуйтесь преимуществами вектора R. Вы никогда не должны подходить к кучу R-кода и видеть:

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

Не только это не векторизация, но структура массива в R не вырастает, как в Python (размер удвоения, когда пространство заканчивается, IIRC). Поэтому каждый шаг rbind должен сначала увеличиться на l, чтобы принять результаты от rbind(), а затем скопировать все содержимое предыдущего содержимого. Для удовольствия попробуйте приведенное выше в R. Обратите внимание, сколько времени потребуется (вам даже не понадобится Rprof или какая-либо функция синхронизации). Затем попробуйте

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

Следующее лучше, чем первая версия:

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

Ответ 17

По совету Дирка я отправляю отдельные примеры. Надеюсь, они не слишком "милые" [умные, но мне все равно] или тривиальны для этой аудитории.

Линейные модели - это хлеб и масло R. Когда число независимых переменных велико, у вас есть два варианта. Во-первых, он использует lm.fit(), который получает матрицу дизайна x и ответ y в качестве аргументов, аналогично Matlab. Недостатком этого подхода является то, что возвращаемое значение представляет собой список объектов (установленные коэффициенты, остатки и т.д.), А не объект класса "lm", который может быть хорошо скомпонован, используется для прогнозирования, поэтапного выбора и т.д. Второй подход создает формулу:

> 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  

Ответ 18

Вы можете присвоить значение, возвращаемое из блока if-else.

Вместо, например,

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

вы можете сделать

x <- if(condition) 1 else 2

Точно, как это работает, это глубокая магия.

Ответ 19

Как полный noob для R и новичок в статистике, я люблю unclass() для печати всех элементов кадра данных в виде обычного списка.

Это очень удобно для просмотра полного набора данных, и все это позволяет быстро выявить любые потенциальные проблемы.

Ответ 20

CrossTable() из пакета gmodels обеспечивает легкий доступ к кросс файлам SAS и SPSS, а также к обычным тестам (Chisq, McNemar и т.д.). В основном, это xtabs() с фантастическим выходом и некоторыми дополнительными тестами - но это облегчает обмен информацией с язычниками.

Ответ 21

Определенно system(). Уметь иметь доступ ко всем инструментам unix (по крайней мере, под Linux/MacOSX) изнутри среды R быстро становится бесценным в моем ежедневном рабочем процессе.

Ответ 22

Вот раздражающее обходное решение для преобразования фактора в числовое. (Аналогично для других типов данных)

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

Ответ 23

Несмотря на то, что этот вопрос возник некоторое время, я недавно обнаружил отличный трюк в Блог SAS и R для использования команды cut. Команда используется для разделения данных по категориям, и я буду использовать набор данных диафрагмы в качестве примера и разделить его на 10 категорий:

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

Ответ 24

Еще один трюк. Некоторые пакеты, такие как glmnet, принимают только в качестве исходной матрицы дизайна и переменной ответа. Если вы хотите соответствовать модели со всеми взаимодействиями между функциями, она не может использовать формулу "y ~. ^ 2". Использование expand.grid() позволяет нам воспользоваться мощным индексированием массивов и векторными операциями 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

Ответ 25

Один из моих любимых, если не несколько неортодоксальных трюков, - это использование eval() и parse(). Этот пример, возможно, иллюстрирует, как это может быть полезно

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

[1] "Albany"

Этот тип ситуации встречается чаще, чем нет, и использование eval() и parse() может помочь в его решении. Конечно, я приветствую любые отзывы об альтернативных способах кодирования.

Ответ 26

set.seed() задает состояние генератора случайных чисел.

Например:

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

Ответ 27

Для тех, кто пишет C для вызова из R: .Internal(inspect(...)), удобно. Например:

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

Ответ 28

d = '~/R Код /Library/ '

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

для (f в файлах) {   if (! (f == 'mysource.r')) {       печать (паста ( 'Sourcing', е))       Источник (паста (д, е, сентябрь = ''))   } }

Я использую приведенный выше код для запуска всех файлов в каталоге при запуске с помощью различных служебных программ, которые я использую в своем интерактивном сеансе с R. Я уверен, что есть лучшие способы, но я считаю это полезным для моей работы. Строка, которая делает это, выглядит следующим образом.

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

Ответ 29

Выполнять операцию над несколькими переменными в кадре данных. Это украдено из подмножества .data.frame.

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)

Ответ 30

Я уже писал это раньше, но я использую его так, как я думал, я отправлю его еще раз. Его просто небольшая функция, чтобы вернуть имена и номера позиций в data.frame. Его ничего особенного, чтобы быть уверенным, но я почти никогда не делаю это через сеанс, не используя его несколько раз.

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

namesind = функция (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 < - namesind