Wie die gleichen Parameter an mehrere Funktionen übergeben?

Question

Ich habe eine Reihe von Funktionen, die ich mit den gleichen Eingaben berechnen möchte. Gibt es eine bessere Möglichkeit, die Ergebnisse zu sehen, als die, die ich unten gewählt habe?

open MathNet.Numerics.Distributions 

// The functions 
let EuVanillaPut S0 K T r sigma = 
    let d1 = (log(S0/K) + (r + sigma ** 2.0/2.0) * T)/(sqrt(T)*sigma) 
    let d2 = d1 - sqrt(T)*sigma 
    K*exp(-r*T)*Normal.CDF(0.0,1.0,-d2) - S0*Normal.CDF(0.0,1.0,-d1) 

let BSMdelta S0 K T r sigma = 
    let d1 = (log(S0/K) + (r + sigma ** 2.0/2.0) * T)/(sqrt(T)*sigma) 
    Normal.CDF(0.0,1.0,d1) 

let BSMgamma S0 K T r sigma = 
    let d1 = (log(S0/K) + (r + sigma ** 2.0/2.0) * T)/(sqrt(T)*sigma) 
    Normal.PDF(0.0,1.0,d1)/(S0 * sigma * sqrt(T)) 

let BSMvega S0 K T r sigma = 
    let d1 = (log(S0/K) + (r + sigma ** 2.0/2.0) * T)/(sqrt(T)*sigma) 
    Normal.PDF(0.0,1.0,d1) * S0 * sqrt(T) 

let BSMthetacall S0 K T r sigma = 
    let d1 = (log(S0/K) + (r + sigma ** 2.0/2.0) * T)/(sqrt(T)*sigma) 
    let d2 = d1 - sqrt(T)*sigma 
    -S0 * Normal.PDF(0.0,1.0,d1) * sigma/(2.0*sqrt(T)) - r*K*exp(-r*T)*Normal.CDF(0.0,1.0,d2) 

let BSMthetaput S0 K T r sigma = 
    let d1 = (log(S0/K) + (r + sigma ** 2.0/2.0) * T)/(sqrt(T)*sigma) 
    let d2 = d1 - sqrt(T)*sigma 
    -S0 * Normal.PDF(0.0,1.0,d1) * sigma/(2.0*sqrt(T)) + r*K*exp(-r*T)*Normal.CDF(0.0,1.0,-d2) 

// Calling them all at once on the same inputs 
// So ugly! Is there a better way? 
(30.0, 25.0, 5.0, 0.02, 0.05) 
|> fun (S0, K, T, r, sigma) -> [EuVanillaPut S0 K T r sigma; 
           BSMdelta S0 K T r sigma; 
           BSMgamma S0 K T r sigma; 
           BSMvega S0 K T r sigma; 
           BSMthetacall S0 K T r sigma; 
           BSMthetaput S0 K T r sigma] 

Ich bin zu F # ziemlich neu, sollte ich einen Typ für diese machen? Soll ich eine andere Datenstruktur als Eingabe für die Funktionen verwenden? Alle und alle Zeiger sind sehr geschätzt.

Answer 1

Wie in den Kommentaren vorgeschlagen, eine Möglichkeit ist, eine Liste von Funktionen zu erstellen und dann List.map über alle Funktionen zu durchlaufen benutzen und nennen sie:

let results = 
    [ EuVanillaPut; BSMdelta; BSMgamma ] 
    |> List.map (fun f -> f 30.0 25.0 5.0 0.02 0.05) 

Ich nehme an, Sie würden dann wollen auch extrahieren die einzelnen Ergebnisse - das zu tun, können Sie Muster verwenden passende (aber Sie werden eine Warnung erhalten, da der Compiler nicht, dass die Anzahl der Elemente in der Liste korrekt ist wissen kann):

let [euVanillaPut; bsmdelta; bsmgamma] = results 

die Warnung zu vermeiden, Sie müssten schreiben:

match results with 
| [euVanillaPut; bsmdelta; bsmgamma] -> // all good 
| _ -> failwith "This should not happen..." 

Alternativ können Sie die Funktionsdefinition ändern Tupel zu verwenden (oder eine Aufzeichnung):

let EuVanillaPut (S0, K, T, r, sigma) = 
    let d1 = (log(S0/K) + (r + sigma ** 2.0/2.0) * T)/(sqrt(T)*sigma) 
    let d2 = d1 - sqrt(T)*sigma 
    K*exp(-r*T)*Normal.CDF(0.0,1.0,-d2) - S0*Normal.CDF(0.0,1.0,-d1) 

Dann können Sie ein einzelnes Tupel definieren, um die Parameter zu halten und es als Argument für mehr verwenden Funktionen:

let ps = (30.0, 25.0, 5.0, 0.02, 0.05) 

let euVanillaPut = EuVanillaPut ps 
let bsmdelta = BSMdelta ps 
let bsmgamma = BSMgamma ps 

der erste Ansatz ist ein kluger Trick, aber wenn man dies oft tut, dann die einzelne Ergebnisse aus der Liste extrahieren wird ein bisschen hässlich. Der zweite Ansatz ist einfacher und macht mehr Sinn, wenn Sie viele Funktionen mit derselben Parametergruppe haben.