Conditionnel somme (R)

Je suis en train de créer une somme conditionnelle, afin de calculer une moyenne. L'idée est qu'une fonction (ou une applique déclaration) vérifie si une certaine valeur est true (par exemple x > 0), alors la somme de toutes les valeurs de x où supérieures à zéro. La dernière étape serait de diviser cette somme par le nombre d'instances qui sont supérieures à zéro. Recherche pour conditionnels somme(ming) ne m'a donné de l'information utilisable.

C'est une partie des données:

> tmpData
   Instrument TradeResult.Currency.
1         JPM                    -3
2         JPM                   264
3         JPM                   284
4         JPM                    69
5         JPM                   283
11        KFT                    -8
12        KFT                   -48
13        KFT                   125
14        KFT                  -150
15        KFT                  -206
16        KFT                   107

Des fonctions que j'ai essayé, la suite la plus prometteuse:

avgProfit <- function(x) {
    ifelse(x > 0,
    sum(x) / length(which(x > 0)),
    return(0))
    }

Cependant, la sortie de cette fonction est 0:

> with(tmpData, tapply(TradeResult.Currency., Instrument, avgProfit))
JPM KFT 
  0   0     
> avgProfit(tmpData$TradeResult.Currency.)
[1] 0
> x
 [1] 1 1 2 1 2 3 3 3 4 4

(Les valeurs doivent être 225 pour JPM (total de 900 divisé par 4 des cas où une plus grande que zéro) et 116 pour KFT)

Même si je calcule la somme de x (qui, si je comprends bien, devrait être la somme des valeurs individuelles dans les données.image) dans la fonction, la sortie de la variable " x " qui m'intrigue, c'. Je ne peux pas trouver où ces 1,2,3 et fours sont venant de.

Comment puis-je calculer une somme conditionnelle? D'ailleurs, je dois utiliser une fonction ou suis-je en faire trop compliqué (il y a peut être une accumulation de la fonction R pour ce dont j'ai oublié?)

Toutes les pensées sont plus que bienvenus,

Ce qui concerne,

Si l'Instrument ne joue aucun rôle ici, non?
Salut Romain, non, l'instrument joue un rôle pour le calcul de la moyenne par instrument (c'est à dire la moyenne de JPM, et un pour KFT). Je pense que le sous-ensemble de la solution de Kohske est une solution élégante pour cette. Merci pour votre commentaire/intérêt!

OriginalL'auteur Jura | 2010-12-06

conditional r sum

9

probablement, il est facile à la baisse lignes inutilisées d'abord, puis de les agréger:
```
aggregate(TradeResult.Currency.~Instrument,
  mean,
  data=subset(tmpData,TradeResult.Currency.>0))
```
Grâce Kohske! C'est beaucoup plus facile et plus rapide que d'écrire des fonctions personnalisées. 🙂

OriginalL'auteur kohske

Vous avez été près de là, je pense que ifelse était le mauvais sens puisque vous voulez le dire, pas un élément-sage de comparaison.

Vous pouvez envisager si vous risquez de rencontrer des valeurs manquantes, de sorte que vous pouvez gérer correctement les.

tmpData <- read.table(textConnection("  Instrument TradeResult.Currency.
1         JPM                    -3
2         JPM                   264
3         JPM                   284
4         JPM                    69
5         JPM                   283
11        KFT                    -8
12        KFT                   -48
13        KFT                   125
14        KFT                  -150
15        KFT                  -206
16        KFT                   107"))



with(tmpData, tapply(TradeResult.Currency., Instrument, function(x) mean(x[x > 0])))

JPM KFT
225 116

Grâce Mdsumner pour la correction de ma fonction, et dans une belle forme courte. C'est une bonne idée de vérifier les valeurs manquantes avant de calculer les valeurs. Merci!
+1 pour la solution la plus rapide

OriginalL'auteur mdsumner

4

Il y a eu un certain nombre de ces agrégation de données /conditionnel analyse de la question ces derniers temps. Il est toujours intéressant de voir les différentes approches utilisées. J'ai pensé que je voudrais ajouter, dans une approche à l'aide plyr. J'aime la plyr fonctions parce qu'ils fournissent une syntaxe standard pour toutes les fonctions et vous permettent de spécifier la structure à la fois l'entrée et la sortie. Ici, nous allons utiliser ddply puisque nous sommes de passage dans un data.frame et que vous voulez une data.frame de retour sur l'autre côté. Nous utilisons le summarise fonction pour calculer la moyenne pour chaque instrument, où les valeurs sont positives.
```
library(plyr)
ddply(tmpData, .(instrument), summarise, avgProfit = mean(TCurr[TCurr > 0]))
```
À suivre sur @Joris comparaison de performance, ddply semble fonctionner aussi bien si pas mieux que les autres approches:
```
> tmpData <- data.frame(
+      instrument = rep(c("JPM","KFT"),each=10e6),
+      TCurr = runif(20e6,-10,100)
+  )
> 
>  system.time(
+ ddply(tmpData, .(instrument), summarise, avgProfit = mean(TCurr[TCurr > 0]))
+  )
   user  system elapsed 
   4.43    0.89    5.32 
>  
>  avgProfit <- function(x) { mean(x[x>0])}
>  
>  system.time(
+ with(tmpData,tapply(TCurr,instrument,avgProfit))
+ )
   user  system elapsed 
   7.88    0.47    8.36 
>  
> system.time(
+ aggregate(TCurr~instrument,mean,data=subset(tmpData,TCurr>0))
+ )
   user  system elapsed 
  28.29    2.35   30.65 
```
+1 pour le ddply, et en effet, ddply est un peu plus rapide que tapply ici.

OriginalL'auteur Chase
2

globale est la façon la plus simple sans doute, mais je ne suis pas d'accord avec le "plus propre parce que vous n'avez pas à écrire une fonction personnalisée." Lisibilité monte lors de la définition claire des fonctions. Surtout si vous avez besoin, en moyenne, un couple de fois dans vos scripts.

Globale est un peu plus rapide que votre fonction personnalisée, parce que vous avez oublié sur les indices. Vous vouliez faire cela :
```
avgProfit <- function(x){
  mean(x[x>0])
}
```
C'est encore une fois plus vite que le total, en raison de l'absence de surcharge :
```
> tmpData <- data.frame(
+     instrument = rep(c("JPM","KFT"),each=10000),
+     TCurr = runif(20000,-10,100)
+ )

> system.time(
+   with(tmpData,tapply(TCurr,instrument,avgProfit)))
   user  system elapsed 
   0.02    0.00    0.02 

> system.time(
+   aggregate(TCurr~instrument,mean,data=subset(tmpData,TCurr>0)))
   user  system elapsed 
   0.09    0.00    0.10 
```
Dans la plupart des cas, vous pouvez simplement ignorer cette différence. Sur d'énormes ensembles de données (n > 100 000 habitants), vous commencerez à sentir, surtout si vous avez besoin de faire cela pour un ensemble de variables.

EDIT : viens de voir que mdsummer eu exactement la même solution caché soigneusement entre la sortie :-). Je laisse cela comme un calendrier de référence.

+1 pour la comparaison des performances. Si vous avez le temps, allez-vous ajouter de la ddply solution à votre test? Il a testé la manière la plus rapide sur ma machine..
avec mon dataframe, c'est à peu près aussi rapide. Avec plus dataframes, c'est un peu plus rapide. tapply est un peu plus lent que ddply.

OriginalL'auteur Joris Meys

Il est vraiment simple et rapide data.table approche:

library(data.table)

setDT(dt)[, .(avg = mean(TradeResult.Currency.[which(TradeResult.Currency.>0 )])), by= Instrument]

#    Instrument avg
# 1:        JPM 225
# 2:        KFT 116

Référence:
À l'aide de @Joris et @Chase de comparaison des performances, cette solution est presque cinq fois plus vite que la ddply approche et 40 fois plus rapide que la aggregate approche.

tmpData <- data.frame(
        instrument = rep(c("JPM","KFT"),each=10e6),
        TCurr = runif(20e6,-10,100))

system.time( ddply(tmpData, .(instrument), summarise, avgProfit = mean(TCurr[TCurr > 0]))  )
# user  system elapsed 
# 1.41    0.62    2.03 

system.time( setDT(tmpData)[, .(avg = mean(TCurr[which(TCurr>0 )])), by= instrument]  )
# user  system elapsed 
# 0.36    0.18    0.43

system.time( aggregate(TCurr~instrument, mean, data=subset(tmpData,TCurr>0)) )
#  user  system elapsed 
# 16.07    1.81   17.20

OriginalL'auteur rafa.pereira

-1

Je serais probablement juste de cette approche à partir d'un processus itératif de style. Avoir une variable locale appelée "accumulateur" ou que ce soit, en boucle sur tous les éléments de la liste, et d'avoir un bloc si une sorte de
```
if (x[index] > 0)
    accumulator = accumulator + x[index]
```
et retour accumulateur de valeur lorsque vous avez terminé.

Je n'ai pas pensé à l'aide de valeurs de l'indice pour une telle question, mais je suppose que cette méthode est un peu lourd pour un débutant (comme moi). 🙂 Merci pour la réponse quand même!
très lent. Très, très lent...

OriginalL'auteur DGH

Vous devez vous connecter pour publier un commentaire.