Meilleure façon d'allouer de la matrice R, NULL vs NA?

Je suis en train d'écrire R code pour créer une matrice carrée. Donc, mon approche est la suivante:

Allouer une matrice de taille correcte
Boucle sur chaque élément de ma matrice et le remplir avec une valeur appropriée

Ma question est simple: quel est le meilleur moyen de pré-allouer de cette matrice? Jusqu'à présent, j'ai deux façons:

> x <- matrix(data=NA,nrow=3,ncol=3)
> x
     [,1] [,2] [,3]
[1,]   NA   NA   NA
[2,]   NA   NA   NA
[3,]   NA   NA   NA

> x <- list()
> length(x) <- 3^2
> dim(x) <- c(3,3)
> x
     [,1] [,2] [,3]
[1,] NULL NULL NULL
[2,] NULL NULL NULL
[3,] NULL NULL NULL

Aussi loin que je peux voir, le premier est plus concis que le dernier. Aussi, l'ancien remplit la matrice avec NAs, tandis que le second est rempli avec des valeurs Null.

Qui est la "meilleure" façon de le faire? Dans ce cas, je suis à la définition de "mieux" en tant que "meilleure performance", parce que c'est l'informatique statistique et de cette opération aura lieu avec de grands ensembles de données.

Alors que le premier est plus concis, il n'est pas à couper le souffle plus facile à comprendre, donc j'ai l'impression que cela pourrait aller de toute façon.

Aussi, quelle est la différence entre NA et NULLE dans R? ?Et NA ?NULL me dire que "NA" a une longueur égale à "1" alors que la valeur NULL a une longueur égale à "0" - mais est-il plus là? Ou de meilleures pratiques? Cela va affecter la méthode que j'utilise pour créer mes matrice.

Pas demandé, pourquoi voulez-vous faire une boucle sur les éléments de la matrice? Est-il possible que vous pouvez utiliser un vectorisé opération à la place? Que devrait être votre prochaine question ici! 🙂
c'est en gros ce que je veux en venir à cette question ici: stackoverflow.com/questions/1719447/.... Si vous avez des suggestions, je serais ravi de l'entendre!

InformationsquelleAutor poundifdef | 2009-11-16

matrix r

46

En cas de doute, testez vous-même. La première approche est à la fois plus facile et plus rapide.
```
> create.matrix <- function(size) {
+ x <- matrix()
+ length(x) <- size^2
+ dim(x) <- c(size,size)
+ x
+ }
> 
> system.time(x <- matrix(data=NA,nrow=10000,ncol=10000))
   user  system elapsed 
   4.59    0.23    4.84 
> system.time(y <- create.matrix(size=10000))
   user  system elapsed 
   0.59    0.97   15.81 
> identical(x,y)
[1] TRUE
```
Ce qui concerne la différence entre NA et NULS:

Il y a en fait quatre constantes.

En outre, il y a quatre constantes, NULL, NA, Inf, et NaN.

NULL est utilisé pour indiquer l'objet vide. NA est utilisé pour les absents (“Non Disponible”) de valeurs de données. Inf désigne l'infini et NaN n'est pas un nombre en virgule flottante IEEE de calcul (les résultats des opérations, respectivement 1/0 et 0/0, par exemple).

Vous pouvez en lire plus dans la R manuel sur la définition de langage.
- hein, aussi ne saviez pas sur le système.temps. merci beaucoup!
- Si vous allez être en comparant les méthodes ne devriez-vous pas avoir enveloppé les deux méthodes dans une fonction? Il existe une surcharge ajoutée avec l'appel de la fonction.
- Dans la pratique, si l'on devait utiliser la méthode plus souvent, ne serait-il pas probablement être enveloppé dans une fonction? Alors que matrix restera comme il est.
InformationsquelleAutor Shane
4

Selon cet article nous pouvons faire mieux que preallocating avec NA par preallocating avec NA_real_. De l'article:

dès que vous vous en attribuer une valeur numérique à une des cellules de 'x', la matrice doivent d'abord être converties en numérique lorsqu'une nouvelle valeur est affectée. Le allouée à l'origine logique de la matrice a été alloué, en vain, et ajoute inutilement de la mémoire et du travail supplémentaire pour le garbage collector.
Au lieu d'allouer à l'aide de NA_real_ (ou NA_integer_ pour les entiers)

Recommandée: nous allons le tester.
```
testfloat = function(mat){
  n=nrow(mat)
  for(i in 1:n){
    mat[i,] = 1.2
  }
}

>system.time(testfloat(matrix(data=NA,nrow=1e4,ncol=1e4)))
user  system elapsed 
3.08    0.24    3.32 
> system.time(testfloat(matrix(data=NA_real_,nrow=1e4,ncol=1e4)))
user  system elapsed 
2.91    0.23    3.14 
```
Et pour les entiers:
```
testint = function(mat){
  n=nrow(mat)
  for(i in 1:n){
    mat[i,] = 3
  }
}

> system.time(testint(matrix(data=NA,nrow=1e4,ncol=1e4)))
user  system elapsed 
2.96    0.29    3.31 
> system.time(testint(matrix(data=NA_integer_,nrow=1e4,ncol=1e4)))
user  system elapsed 
2.92    0.35    3.28 
```
La différence est faible dans mon cas de test, mais il est là.
- 3 est de classe numeric vous signifiait probablement 3L. Néanmoins, je ne vois pas les performances mesurables de l'impact de l'utilisation de NA (même si la mesure pour 20 s chacun et faire en sorte gc fait son travail)
InformationsquelleAutor David Marx

rows<-3
cols<-3    
x<-rep(NA, rows*cols)
x1 <- matrix(x,nrow=rows,ncol=cols)

InformationsquelleAutor Odysseus Ithaca

Vous devez vous connecter pour publier un commentaire.