Quelle est l'astuce R la plus utile? [fermé]

Afin de partager d'autres trucs et astuces pour R , quelle est votre fonctionnalité ou astuce la plus utile? Vectorisation intelligente? Entrée / sortie de données? Visualisation et graphisme? Analyses statistiques? Fonctions spéciales? L'environnement interactif lui-même?

Un article par article, et nous verrons si nous obtenons un gagnant au moyen de votes.

[Edit 25-Aug 2008]: Donc après une semaine, il semble que le simple ait str()gagné le sondage. Comme j'aime la recommander moi-même, c'est une réponse facile à accepter.

str() vous indique la structure de n'importe quel objet.

Une fonction très utile que j'utilise souvent est dput (), qui vous permet de vider un objet sous la forme de code 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")

Il peut être très utile de publier des blocs de données facilement reproductibles lorsque vous demandez de l'aide, ou pour modifier ou réorganiser les niveaux d'un facteur.

head () et tail () pour obtenir la première et la dernière partie d'un dataframe, d'un vecteur, d'une matrice, d'une fonction, etc. Surtout avec de grandes trames de données, c'est un moyen rapide de vérifier qu'il a bien chargé.

Une fonctionnalité intéressante: la lecture des données utilise des connexions qui peuvent être des fichiers locaux, des fichiers distants accessibles via http, des tubes à partir d'autres programmes ou plus.

À titre d'exemple simple, considérons cet accès pour N = 10 entiers aléatoires entre min = 100 et max = 200 de random.org (qui fournit de vrais nombres aléatoires basés sur le bruit atmosphérique plutôt qu'un générateur de nombres pseudo aléatoires):

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>

En passant, le package random fournit plusieurs fonctions pratiques pour accéder à random.org .

Je trouve que je me sers with()et de within()plus en plus. Plus $besoin de jeter mon code et il n'est pas nécessaire de commencer à attacher des objets au chemin de recherche. Plus sérieusement, je trouve que with()etc. rendent l' intention de mes scripts d'analyse de données beaucoup plus claire.

> 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()met en place un environnement dans lequel l'expression R est évaluée. within()fait la même chose mais vous permet de modifier l'objet de données utilisé pour créer l'environnement.

> 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

Ce que je n'avais pas réalisé lors de ma première utilisation, within()c'est que vous devez faire une affectation dans le cadre de l'expression évaluée et affecter l'objet renvoyé (comme ci-dessus) pour obtenir l'effet souhaité.

Astuce d'entrée de données = package RGoogleDocs

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

J'ai trouvé que les feuilles de calcul Google étaient un moyen fantastique pour tous les collaborateurs d'être sur la même page. En outre, Google Forms permet de capturer les données des répondants et de les écrire sans effort dans une feuille de calcul Google. Étant donné que les données changent fréquemment et ne sont presque jamais définitives, il est de loin préférable que R lise directement une feuille de calcul Google plutôt que de télécharger des fichiers csv et de les lire.

# Get data from google spreadsheet
library(RGoogleDocs)
ps <-readline(prompt="get the password in ")
auth = getGoogleAuth("me@gmail.com", 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)

Je ne peux pas me souvenir de laquelle mais une ou deux des commandes suivantes prend plusieurs secondes.

1. getGoogleAuth

2. getGoogleDocsConnection

3. getWorksheets

Utilisez des accolades pour référencer des noms non standard.

> 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

Dans ce cas, df [, "1"] fonctionnerait également. Mais les tiques arrière fonctionnent à l'intérieur des formules!

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

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

Coefficients:
(Intercept)          `1`  
     0.4087      -0.3440  

[Modifier] Dirk demande pourquoi on donnerait des noms invalides? Je ne sais pas! Mais je rencontre certainement ce problème assez souvent dans la pratique. Par exemple, en utilisant le package reshape de hadley:

> 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

Je ne sais pas à quel point cela est / n'est pas connu, mais j'ai certainement profité des capacités de passage par référence des environnements.

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

Pour cet exemple, la raison pour laquelle ce serait utile n'a pas de sens, mais si vous passez de gros objets autour, cela peut aider.

Ma nouvelle chose préférée est la bibliothèque foreach. Il vous permet de faire toutes les bonnes choses d'application, mais avec une syntaxe un peu plus simple:

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

La meilleure partie est que si vous faites quelque chose qui prend en fait beaucoup de temps, vous pouvez passer de %do%à %dopar%(avec la bibliothèque backend appropriée) pour paralléliser instantanément, même à travers un cluster. Très lisse.

Je fais beaucoup de manipulation de base des données, voici donc deux fonctions intégrées ( transformation , sous - ensemble ) et une bibliothèque ( sqldf ) que j'utilise quotidiennement.

créer des exemples de données de vente

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

utilisez transform () pour ajouter une colonne

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

utilisez subset () pour découper les données

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

>
  product  revenue
1       1 108.4597
4       2 100.3475

utiliser sqldf () pour découper et agréger avec SQL

Le package sqldf fournit une interface SQL aux trames de données 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

Effectuer une agrégation ou 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

Pour une fonctionnalité de réduction de carte plus sophistiquée sur les trames de données, consultez le package plyr . Et si vous trouvez vouloir tirer vos cheveux, je vous recommande de vérifier Manipulation de données avec R .

?ave

Les sous-ensembles de «x []» sont moyennés, chaque sous-ensemble étant constitué de ces observations avec les mêmes niveaux de facteurs. Utilisation: ave (x, ..., FUN = mean)

Je l'utilise tout le temps. (par exemple dans cette réponse ici à so )

Un moyen d'accélérer le code et d'éliminer les boucles for.

au lieu de boucles for qui parcourent une trame de données à la recherche de valeurs. prenez simplement un sous-ensemble du df avec ces valeurs, beaucoup plus rapidement.

donc au lieu de:

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

faites quelque chose comme ça:

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

ce concept de base s'applique extrêmement souvent et constitue un excellent moyen de se débarrasser des boucles for

Parfois, vous avez besoin de rbindplusieurs trames de données. do.call()vous laissera faire cela (quelqu'un a dû m'expliquer cela lorsque bind j'ai posé cette question, car cela ne semble pas être une utilisation évidente).

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)

Dans la programmation R (pas de sessions interactives), j'utiliser if (bad.condition) stop("message")un grand nombre . Chaque fonction commence par quelques-uns de ceux-ci, et au fur et à mesure que je travaille sur des calculs, je les ajoute également. Je suppose que j'ai pris l'habitude d'utiliser assert()en C. Les avantages sont doubles. Premièrement, il est beaucoup plus rapide d'obtenir du code fonctionnel avec ces vérifications en place. Deuxièmement, et probablement plus important, il est beaucoup plus facile de travailler avec du code existant lorsque vous voyez ces vérifications sur chaque écran de votre éditeur. Vous n'aurez pas à se demander si x>0, ou faire confiance à un commentaire indiquant qu'il est ... vous savez , d'un coup d' oeil, que ce soit.

PS. mon premier message ici. Sois gentil!

La traceback()fonction est indispensable lorsque vous avez une erreur quelque part et que vous ne la comprenez pas facilement. Il imprimera une trace de la pile, très utile car R n'est pas très verbeux par défaut.

Ensuite, le paramétrage options(error=recover)vous permettra "d'entrer" dans la fonction générant l'erreur et d'essayer de comprendre ce qui se passe exactement, comme si vous en aviez le contrôle total et que vous pouviez y mettre un browser().

Ces trois fonctions peuvent vraiment vous aider à déboguer votre code.

Je suis vraiment surpris que personne n'ait posté sur Apply, Tapply, Laply, and Sapply. Une règle générale que j'utilise lorsque je fais des choses dans R est que si j'ai une boucle for qui traite des données ou des simulations, j'essaye de la factoriser et de la remplacer par un * apply. Certaines personnes hésitent à utiliser les fonctions * apply parce qu'elles pensent que seules des fonctions à paramètre unique peuvent être transmises. Rien ne pourrait être plus éloigné de la vérité! Comme pour transmettre des fonctions avec des paramètres en tant qu'objets de première classe en Javascript, vous faites cela en R avec des fonctions anonymes. Par exemple:

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

(Pour ceux qui suivent #rstats, je l'ai également posté ici).

N'oubliez pas, utilisez apply, sapply, lapply, tapply et do.call! Profitez de la vectorisation de R. Vous ne devriez jamais marcher jusqu'à un tas de code R et voir:

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

Non seulement cela n'est pas vectorisé, mais la structure du tableau dans R n'est pas développée comme elle l'est en Python (doubler la taille lorsque l'espace est épuisé, IIRC). Donc, chaque étape de rbind doit d'abord croître suffisamment pour accepter les résultats de rbind (), puis copier tout le contenu précédent. Pour le plaisir, essayez ce qui précède dans R. Notez combien de temps cela prend (vous n'aurez même pas besoin de Rprof ou de toute fonction de minutage). Puis essayez

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

Ce qui suit est également meilleur que la première version:

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

Sur les conseils de Dirk, je publie des exemples uniques. J'espère qu'ils ne sont pas trop "mignons" [intelligents, mais je m'en fiche] ou triviaux pour ce public.

Les modèles linéaires sont le pain et le beurre de R. Lorsque le nombre de variables indépendantes est élevé, on a deux choix. La première consiste à utiliser lm.fit (), qui reçoit la matrice de conception x et la réponse y comme arguments, de la même manière que Matlab. L'inconvénient de cette approche est que la valeur de retour est une liste d'objets (coefficients ajustés, résidus, etc.), pas un objet de classe "lm", qui peut être bien résumé, utilisé pour la prédiction, la sélection par étapes, etc. l'approche consiste à créer une formule:

> 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  

Vous pouvez attribuer une valeur renvoyée par un bloc if-else.

Au lieu de, par exemple

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

tu peux faire

x <- if(condition) 1 else 2

La façon exacte dont cela fonctionne est une magie profonde.

En tant que noob total pour R et novice en statistiques que j'aime unclass() imprimer tous les éléments d'un bloc de données sous forme de liste ordinaire.

C'est très pratique pour jeter un coup d'œil à un ensemble de données complet en une seule fois afin de détecter rapidement tout problème potentiel.

CrossTable()du gmodelspackage fournit un accès facile aux tableaux croisés de type SAS et SPSS, ainsi qu'aux tests habituels (Chisq, McNemar, etc.). Fondamentalement, c'est xtabs()avec une sortie sophistiquée et des tests supplémentaires - mais cela facilite le partage de la sortie avec les païens.

Définitivement system(). Pouvoir accéder à tous les outils unix (au moins sous Linux / MacOSX) depuis l'intérieur de l'environnement R est rapidement devenu inestimable dans mon flux de travail quotidien.

Voici une solution de contournement ennuyeuse pour convertir un facteur en numérique. (Similaire pour d'autres types de données également)

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

Bien que cette question soit posée depuis un certain temps, j'ai récemment découvert une excellente astuce sur le blog SAS et R pour utiliser la commande cut. La commande est utilisée pour diviser les données en catégories et je vais utiliser le jeu de données iris comme exemple et le diviser en 10 catégories:

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

Un autre truc. Certains packages, comme glmnet, ne prennent comme entrées que la matrice de conception et la variable de réponse. Si l'on veut ajuster un modèle avec toutes les interactions entre les caractéristiques, elle ne peut pas utiliser la formule "y ~. ^ 2". L'utilisation expand.grid()nous permet de tirer parti de la puissante indexation de tableau et des opérations vectorielles de 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

L'une de mes astuces préférées, sinon quelque peu peu orthodoxes, est l'utilisation de eval()et parse(). Cet exemple illustre peut-être comment cela peut être utile

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

[1] "Albany"

Ce type de situation se produit le plus souvent et l'utilisation de eval() et parse()peut aider à y remédier. Bien sûr, je suis heureux de recevoir vos commentaires sur d'autres moyens de coder cela.

set.seed() définit l'état du générateur de nombres aléatoires.

Par exemple:

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

Pour ceux qui écrivent C pour être appelé à partir de R: .Internal(inspect(...))est pratique. Par exemple:

> .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 / Bibliothèque /'

fichiers = liste.fichiers (d, '. r $')

for (f in files) {if (! (f == 'mysource.r')) {print (paste ('Sourcing', f)) source (paste (d, f, sep = ''))}}

J'utilise le code ci-dessus pour rechercher tous les fichiers dans un répertoire au démarrage avec divers programmes utilitaires que j'utilise dans ma session interactive avec R. Je suis sûr qu'il existe de meilleures façons, mais je le trouve utile pour mon travail. La ligne qui fait cela est la suivante.

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

Pour effectuer une opération sur un certain nombre de variables dans un bloc de données. Ceci est volé de subset.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)

Je l'ai déjà posté une fois mais je l'utilise tellement que j'ai pensé le poster à nouveau. C'est juste une petite fonction pour renvoyer les noms et les numéros de position d'un data.frame. Il n'y a rien de spécial pour être sûr, mais je n'arrive presque jamais à traverser une session sans l'utiliser plusieurs fois.

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

namesind = fonction (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