Addition dans R à l'intérieur de la fonction

Je suis en train d'écrire une fonction dans R qui a pour calculer les valeurs de deux vecteurs avant d'aller de l'avant et faire quelques autres trucs de fantaisie. Les deux vecteurs, R et B, sont donnés par la suite des conclusions finales:

où $\beta$ est une constante et la ts sont passés à la fonction et sont la survenue temps d'un événement. Donc, en gros, lorsque le i-ème événement se produit (au moment t_i), je calcule B(i) et R(i) qui sont des sommes réalisé en utilisant l'occurrence précédente fois t_k de mon cas jusqu'à ce moment.

Je voudrais trouver quelque chose de plus efficace que cette

r <- rep(0,length(t))
for(i in 2:length(t)) {
    r[i] <- sum((t[i]-t[which(t<t[i])])*exp(beta*(t[i]-t[which(t<t[i])])))
}
b <- rep(0,length(t))
for(i in 2:length(t)) {
    b[i] <- sum(((t[i]-t[which(t<t[i])])^2)*exp(beta*(t[i]-t[which(t<t[i])])))
}

qui, fondamentalement, calcule tout deux fois, même si la seule différence entre les deux est la place devant l'exponentielle. Des idées? Merci!

Quelle sera t généralement être? Si elle n'est pas trop gros, vous pouvez utiliser outer à la place de ceux for boucles.
Ils n'avaient tout simplement pas fourni un exemple de l'vecteur t, donc R pense que vous voulez sous-ensemble de la fonction t.
Uhhhh, ces boucles sont moches. La vectorisation est le Nom du jeu... Vous devriez être à l'aide d'un dataframe avec les colonnes t_i et t_k. Ensuite, on calcule la différence. Par la suite, l'utilisation ifelse sur la différence. Cela peut être fait sans boucles et devrait être calculé instantanément.
t est plutôt grand: plusieurs centaines de milliers d'entrées... @Pierre: je ne suis pas sûr de comprendre: ne doit faire deux colonnes? Aussi, dans le cas où il fait une différence, je viens d'ajouter dans la question de la définition de ce que mon ts sont.
Ok, semble être un peu plus complexe que je ne le pensais initialement. Créer une matrice avec la ligne de vecteur répété dans chaque ligne permettrait d'éviter la boucle, mais le but de devenir trop volumineux pour la mémoire... Pas une bonne affaire pour la force brute. Avez-vous pensé à trier le vecteur d'origine avec la position " i " conservé dans une deuxième colonne?
Si c'est vraiment destiné à être une somme sur tous les éléments de tk qui sont à moins de ti, alors il n'est pas bien définie de l'opération. Est-ce censé être une somme de plus de ti[j]<tk[j] ? Qu'est-ce que l'indice sur lequel vous souhaitez somme?
Ensuite, il y aurait cumsum fonctionnement, ... Si vous commencez avec le plus grand élément de ce qui devrait être faisable dans le temps linéaire, je pense 😉
Je vais au lit 😉 hâte de voir une solution d'ici demain @Carl_Witthoft
à chaque occurrence, de temps t_i (qui désigne la i-ème de la survenance d'un événement), je vais faire la sommation sur toutes les occurrence de fois AVANT que le temps t_i, dont j'ai noté que les t_k.
Facile, si l't_k sont triés 😉
J'ai en quelque sorte à eux quand je les passe à la fonction 🙂
Après avoir regardé d'un peu plus près en cela, je trouve que @Carl_Witthoft est droit. Sont les équations vraiment correcte? Peut-être vous pouvez nous donner également une intuition de ce que le problème est vraiment?
J'ai édité la question d'ajouter plus d'informations sur le problème. À chaque occurrence, de mon cas, je calcule B et R qui utilisent l'occurrence précédente de fois jusqu'à ce moment.

InformationsquelleAutor g_puffo | 2014-09-19

function r

En raison de la taille du vecteur d'entrée, vous ne pouvez pas faire mieux que l'utilisation explicite d'une boucle (sinon, vous auriez besoin de trop de mémoire). Mais de toute évidence, vous avez besoin seulement d'une boucle et le problème est parallèle gênant.

C'est ma compréhension de votre problème:

library(doParallel)

cl <- makeCluster(4)
registerDoParallel(cl)

fun_r <- function(t, beta) {
  res <- foreach(i = seq_along(t)[-1], .combine = cbind) %dopar% {
    d <- t[i] - t[seq_len(i - 1)]
    c(sum(d^2 * exp(-beta * d)),
      sum(d * exp(-beta * d)))
  }
  cbind(0, unname(res))
}

set.seed(42)
t <- sort(rnorm(1e4))

ttt <- fun_r(t, 0.5)
ttt[,1:10]
#     [,1]      [,2]      [,3]      [,4]      [,5]      [,6]      [,7]      [,8]      [,9]     [,10]
#[1,]    0 0.3223427 0.3571912 0.5101723 0.5369059 0.6072245 0.6420904 0.6625009 0.7287196 0.8478711
#[2,]    0 0.4800071 0.5391521 0.8341596 0.8901340 1.0569168 1.1455994 1.2034259 1.3972700 1.7177646

library(microbenchmark)
microbenchmark(fun_r(t, 0.5), times=5)
#Unit: seconds
#         expr      min       lq   median       uq      max neval
#fun_r(t, 0.5) 5.538867 5.558164 5.562138 5.567474 5.642002     5

stopCluster(cl)

Si c'est encore trop lent, vous pouvez essayer de les mettre en œuvre avec Rcpp.

Wow, j'ai appris une tonne de nouvelles commandes utiles merci pour votre réponse (seq_along, seq_len, etc...) et foreach est une façon très intéressante de la mise en œuvre d'une boucle. Merci!

InformationsquelleAutor Roland

0

Si je comprends votre équations correctement, vous avez juste besoin de calculer t[i] - t[1:i-1] séparément d'abord, puis d'utiliser ces valeurs dans les calculs ultérieurs.
```
t <- rnorm(10)
i <- 10
beta <- 1

tdiffs <- t[i]-t[1:i-1]
betaexp <- exp(-beta*tdiffs)
B <- sum(tdiffs^2*betaexp)
R <- sum(tdiffs*betaexp)
```
- C'est mon interprétation, trop. J'espère que c'est ce qu'il voulait.
InformationsquelleAutor rmccloskey

Vous devez vous connecter pour publier un commentaire.