Wählen Sie eine Funktion aus einer Liste nach dem Zufallsprinzip aus und führen Sie sie aus. Wiederholen Sie den Vorgang und speichern Sie die Ausgänge

Question

Ich habe mehrere Funktionen, die Zufallszahlen generieren. Alle diese Funktionen beschreiben den gleichen Prozess. Ich möchte eine Funktion 100 Mal zufällig auswählen, sie ausführen und die Ergebnisse (100 Zeilen pro Funktionsausführung) in einer Tabelle speichern.

Für die Funktionen, die ich den folgenden Code geschrieben haben:

# AKBAS u.a. (2009) 
akbas <- function(n){ 
    x.m=se.m=x.st=se.st=NULL 
    for(i in 1:n){ 
    print(x.m[i] <- runif(n = 1, min = 0, max = 1)) 
    se.m[i] <- 0.17 * (x.m[i]^2) - 0.03 * x.m[i] 
    print(x.st[i] <- runif(n = 1, min = 1, max = 5)) 
    se.st[i] <- 0.17 * (x.st[i]^2) - 0.03 * x.st[i] 
    } 
    return(list(se.m, se.st)) 
} 
se.akbas <- matrix(unlist(akbas(100)),100, 2) 

# FUCHS u.a.(2007) 
fuchs07 <- function(n){ 
    x.m=se.m=x.st=se.st=NULL #solves indexing problem 
    for(i in 1:n){ 
    print(x.m[i] <- runif(n = 1, min = 0, max = 1)) 
    se.m[i] <- 0.11 * (x.m[i]^2) - 0.02 * x.m[i] 
    print(x.st[i] <- runif(n = 1, min = 1, max = 5)) 
    se.st[i] <- 0.11 * (x.st[i]^2) - 0.02 * x.st[i] 
    } 
    return(list(se.m, se.st)) 
} 
se.fuchs07 <- matrix(unlist(fuchs07(100)),100, 2) 

# BELL AND GLADE (2004) 
bell.glade <- function(n){ 
    x.m=se.m=x.st=se.st=NULL 
    for(i in 1:n){ 
    se.m[i] <- runif(n = 1, min = 0, max = 1) 
    se.m[i] <- 0.2 
    se.st[i] <- runif(n = 1, min = 1, max = 5) 
    se.st[i] <- 0.5 
    } 
    return(list(se.m, se.st)) 
} 
se.bell.glade <- matrix(unlist(bell.glade(100)),100, 2) 

# BORTER (1999b,a) 
borter <- function(n){ 
    x.m=se.m=x.st=se.st=NULL 
    for(i in 1:n){ 
    se.m[i] <- runif(n = 1, min = 0, max = 1) 
    se.m[i] <- 0.1 
    se.st[i] <- runif(n = 1, min = 1, max = 5) 
    se.st[i] <- 0.5 
    } 
    return(list(se.m, se.st)) 
} 
se.borter <- matrix(unlist(borter(100)),100, 2) 

# FELL UND HARTFORD (1997) 
fell.hartford <- function(n){ 
    x.m=se.m=x.st=se.st=NULL 
    for(i in 1:n){ 
    se.m[i] <- ifelse (runif(n = 1, min = 0, max = 1) < 0.25, 0.1, 0.4) 
    se.st[i] <- ifelse (runif(n = 1, min = 1, max = 5) < 1.5, 0.4, 0.7) 
    } 
    return(list(se.m, se.st)) 
} 
se.fell.hartford <- matrix(unlist(fell.hartford(100)),100, 2) 

funktionen <- list(se.akbas, se.bell.glade, se.borter, se.fell.hartford, se.fuchs07) 
murgang <- do.call(rbind, funktionen) 

Die endgültige Ausgabe in einem langen Format sein sollte - se.m und se.st gestapelt. Ich schließe eine Indikatorspalte mit den Werten 1 für se.m und 2 für se.st. Hier ist ein kleiner Teil des Ausgangs:

495   1 0.0228 
496   1 0.0494 
497   1 0.0158 
498   1 0.0169 
499   1 0.0357 
500   1 0.0436 
501   2 0.3459 
502   2 2.7998 
503   2 3.6571 
504   2 3.1501 
505   2 2.7418 
506   2 0.5286 

aber ich bin fest auf dem Prozess der Zufallsfunktion Auswahl get.f. Ich dachte an etwas wie:

get.f <- function(m){ 
    sample(funktionen, 100, replace = TRUE) 
} 

Wie bekomme ich, um die Ergebnisse zu speichern?

Irgendwelche Vorschläge, um diesen Prozess zu vereinfachen? Ich bin mir sicher, dass es einen effizienteren Weg gibt, aber ich habe es noch nicht gefunden.

Ich bin neu in R und werde jede konstruktive Kommentare und/oder Kritik sehr schätzen.

PS: Dies war vielleicht nicht die beste Frage, die jemals gestellt wurde, ich verstehe, dass Sie mich bewerten -1. Aber wenn du es tust, sag mir bitte warum, damit ich mich verbessern kann und nicht die gleichen Fehler in der Zukunft mache.

Answer 1

Zuerst eine Verbesserung der Funktionen. Sie brauchen keine for-Schleife 1: n dann Runif (n = 1 ...), sondern nur Runif (n ...), wobei n als Argument für Ihre Funktion zur Verfügung gestellt wird.

Sie müssen auch nicht die Ergebnisse se.m und se.st innerhalb der Funktion auflisten, dann nach unlist und als Matrix setzen. Übergeben Sie stattdessen eine cbind der Ergebnisse. Siehe unten:

bell.glade <- function(n){ 
    x.m=se.m=x.st=se.st=NULL 
    se.m <- runif(n, min = 0, max = 1) 
    se.st <- runif(n, min = 1, max = 5) 
    return(cbind(se.m, se.st)) 
} 
bell.grade(4) # where n=4 

Zweitens, ich glaube, Sie die Konstanten in bell.grade und borter entfernen vergessen, dass Sie setzen se.m und se.st an, Sie verwenden sie wahrscheinlich zu beheben, ich tat sie in der Endfassung unten.

Hier werden die Funktionen sind jetzt (Ich habe einen Druck von Funktionsnamen für die Prüfung):

# AKBAS u.a. (2009) 
akbas <- function(n){ 
    x.m=se.m=x.st=se.st=NULL 
    print(x.m <- runif(n, min = 0, max = 1)) 
    se.m <- 0.17 * (x.m^2) - 0.03 * x.m 
    print(x.st <- runif(n, min = 1, max = 5)) 
    se.st <- 0.17 * (x.st^2) - 0.03 * x.st 
    print("akbas") 
    return(cbind(se.m, se.st)) 
} 
# FUCHS u.a.(2007) 
fuchs07 <- function(n){ 
    x.m=se.m=x.st=se.st=NULL #solves indexing problem 
    print(x.m <- runif(n, min = 0, max = 1)) 
    se.m <- 0.11 * (x.m^2) - 0.02 * x.m 
    print(x.st <- runif(n, min = 1, max = 5)) 
    se.st <- 0.11 * (x.st^2) - 0.02 * x.st 
    print("fuchs07") 
    return(cbind(se.m, se.st)) 
} 
# BELL AND GLADE (2004) 
bell.glade <- function(n){ 
    x.m=se.m=x.st=se.st=NULL 
    se.m <- runif(n, min = 0, max = 1) 
    se.st <- runif(n, min = 1, max = 5) 
    print("bell.glade") 
    return(cbind(se.m, se.st)) 
} 
# BORTER (1999b,a) 
borter <- function(n){ 
    x.m=se.m=x.st=se.st=NULL 
    se.m <- runif(n, min = 0, max = 1) 
    se.st <- runif(n, min = 1, max = 5) 
    print("borter") 
    return(cbind(se.m, se.st)) 
} 
# FELL UND HARTFORD (1997) 
fell.hartford <- function(n){ 
    x.m=se.m=x.st=se.st=NULL 
    se.m <- ifelse (runif(n, min = 0, max = 1) < 0.25, 0.1, 0.4) 
    se.st <- ifelse (runif(n, min = 1, max = 5) < 1.5, 0.4, 0.7) 
    print("fell.hartford") 
    return(cbind(se.m, se.st)) 
} 

Und hier ist die Liste der Funktionen:

funktionen <- list(akbas, bell.glade, borter, fell.hartford, fuchs07) 

Beachten Sie die Verwendung von do.call zu Zugriff auf die Liste der Funktionen in funktionen, hier testen wir borter

do.call(funktionen[[3]], args=list(n=1)) # borter 
[1] "borter" 
      se.m se.st 
[1,] 0.7996913 1.505884 

Nun bedeutet es, dass der Index funktionen 1: 5 ist, was 100 Mal abgetastet werden muss, um einen Anruf zufällig entweder an eine der 5 Funktionen in der Liste 100 Mal zurückzugeben.

fxn_list_sample <- sample(1:5, 100, replace=T) 
fxn_list_result <- sapply(fxn_list_sample, function(x) do.call(funktionen[[x]], args=list(n=1))) 
fxn_list_result 

Dies druckt die zufällige Reihenfolge der Funktionen, die aufgerufen werden.fxn_list_result liefert eine 2x100-Matrix mit 1. Reihe Se.m-Werten, 2. Reihe Se.St.-Werten. Sie können sich einfach in eine lange Form verwandeln. Setze den Samen set.seed, falls dies für die Reproduzierbarkeit erforderlich ist.