DSLs (Domänenspezifische Sprachen) im Finanzwesen

StackOverflow https://stackoverflow.com/questions/23448

  •  09-06-2019
  •  | 
  •  

Frage

Hat jemand damit gearbeitet? DSLs (Domänenspezifische Sprachen) im Finanzbereich?Ich plane, in der Anwendung, an der ich arbeite, eine Art DSL-Unterstützung einzuführen, und möchte einige Ideen mitteilen.

Ich bin gerade dabei, die stabilsten Domänenelemente zu identifizieren und die Funktionen auszuwählen, die mit dem DSL besser implementiert werden könnten.Ich habe die Syntax für diese erste Funktion noch nicht definiert.

War es hilfreich?

Lösung

Jay Fields und Obie Fernandez haben ausführlich zu diesem Thema geschrieben und darüber gesprochen.

In den Schriften von Martin Fowler finden Sie auch allgemeine Informationen zur Implementierung von DSL (jedoch nicht speziell zum Thema Finanzen).

Andere Tipps

Finanzverträge wurden von Simon Peyton Jones und Jean-Marc-Erby elegant als DSL modelliert.Ihr in Haskell eingebettetes DSL wird in der Arbeit vorgestellt So schreiben Sie einen Finanzvertrag.

Domänenspezifische Sprachen (DSLs) werden am häufigsten zur Darstellung von Finanzinstrumenten verwendet.Das kanonische Papier stammt von Simon Peyton Jones Verfassen von Verträgen:ein Abenteuer im Financial Engineering die Verträge mithilfe einer Kombinatorbibliothek in Haskell darstellt.Die bekannteste Anwendung des Kombinator-Ansatzes ist Die MLFi-Sprache von LexiFi, das auf OCaml aufbaut (ihr CEO, Jean-Marc Eber, ist Co-Autor des Papiers „Composing Contracts“).Barclay's kopierte einmal den Ansatz und beschrieb einige zusätzliche Vorteile, wie zum Beispiel die Möglichkeit, für Menschen lesbare mathematische Preisformeln zu erstellen (Kommerzielle Nutzung:Bei exotischen Trades funktionsfähig werden).

DSLs für Finanzverträge werden typischerweise durch Einbettung in eine funktionale Sprache wie Haskell, Scala oder OCaml erstellt.Die Verbreitung funktionaler Programmiersprachen in der Finanzbranche wird diesen Ansatz weiterhin attraktiv machen.

Neben der Darstellung von Finanzinstrumenten werden DSLs auch im Finanzwesen eingesetzt für:

Ich führe eine vollständige Liste der Finanzpapiere, Vorträge und anderen Ressourcen zu DSLs unter http://www.dslfin.org/resources.html.

Wenn Sie Fachleute und Forscher treffen möchten, die mit DSLs für Finanzsysteme arbeiten, gibt es am 1. Oktober einen Workshop auf der MODELS 2013-Konferenz in Miami, Florida: http://www.dslfin.org/

Wir haben mit Fairmat an der Idee gearbeitet, eine Finanzbewertung DSL zu erstellen ( http://www.fairmat.com )

-Es enthält eine DSL, die verwendet werden kann, um Auszahlungen und Zahlungsabhängigkeiten auszudrücken. -Es enthält ein Erweiterungsmodell zum Erstellen neuer Arten von Analyse und Implementierungen der theoretischen Dynamik mit .NET/ C# mit unserer zugrunde liegenden mathematischen Bibliothek (siehe einige Open -Source -Beispiele bei https://github.com/fairmat

Ich denke, dass die Arbeit von Simon Peyton Jones und Jean Marc Eber wegen „Composing Contracts“ am beeindruckendsten ist:an Adventure in Financial Engineering“ und alles daraus abgeleitete:"LexiFi und MLFi".

Gefunden Shahbaz Chaudharys Die Scala-Implementierung ist am attraktivsten, da MLFi nicht allgemein verfügbar ist (und weil Scala als funktionale Sprache leichter zugänglich ist als Haskell).

Sehen „Abenteuer im Finanz- und Software-Engineering“ und das andere Material, auf das von dort verwiesen wird.

Ich werde es wagen, einen Ausschnitt zu reproduzieren, um eine Vorstellung davon zu bekommen, was diese Implementierung bewirken kann.

  object Main extends App {
  //Required for doing LocalDate comparisons...a scalaism
  implicit val LocalDateOrdering = scala.math.Ordering.fromLessThan[java.time.LocalDate]{case (a,b) => (a compareTo b) < 0}

  //custom contract
  def usd(amount:Double) = Scale(Const(amount),One("USD"))
  def buy(contract:Contract, amount:Double) = And(contract,Give(usd(amount)))
  def sell(contract:Contract, amount:Double) = And(Give(contract),usd(amount))
  def zcb(maturity:LocalDate, notional:Double, currency:String) = When(maturity, Scale(Const(notional),One(currency)))
  def option(contract:Contract) = Or(contract,Zero())
  def europeanCallOption(at:LocalDate, c1:Contract, strike:Double) = When(at, option(buy(c1,strike)))
  def europeanPutOption(at:LocalDate, c1:Contract, strike:Double) = When(at, option(sell(c1,strike)))
  def americanCallOption(at:LocalDate, c1:Contract, strike:Double) = Anytime(at, option(buy(c1,strike)))
  def americanPutOption(at:LocalDate, c1:Contract, strike:Double) = Anytime(at, option(sell(c1,strike)))

  //custom observable
  def stock(symbol:String) = Scale(Lookup(symbol),One("USD"))
  val msft = stock("MSFT")


  //Tests
  val exchangeRates = collection.mutable.Map(
    "USD" -> LatticeImplementation.binomialPriceTree(365,1,0),
    "GBP" -> LatticeImplementation.binomialPriceTree(365,1.55,.0467),
    "EUR" -> LatticeImplementation.binomialPriceTree(365,1.21,.0515)
    )
  val lookup = collection.mutable.Map(
    "MSFT" -> LatticeImplementation.binomialPriceTree(365,45.48,.220),
    "ORCL" -> LatticeImplementation.binomialPriceTree(365,42.63,.1048),
    "EBAY" -> LatticeImplementation.binomialPriceTree(365,53.01,.205)
  )
  val marketData = Environment(
    LatticeImplementation.binomialPriceTree(365,.15,.05), //interest rate (use a universal rate for now)
    exchangeRates, //exchange rates
    lookup
  )

  //portfolio test
  val portfolio = Array(
    One("USD")
    ,stock("MSFT")
    ,buy(stock("MSFT"),45)
    ,option(buy(stock("MSFT"),45))
    ,americanCallOption(LocalDate.now().plusDays(5),stock("MSFT"),45)
  )

  for(contract <- portfolio){
    println("===========")
    val propt = LatticeImplementation.contractToPROpt(contract)
    val rp = LatticeImplementation.binomialValuation(propt, marketData)
    println("Contract: "+contract)
    println("Random Process(for optimization): "+propt)
    println("Present val: "+rp.startVal())
    println("Random Process: \n"+rp)
  }

}

Der ausgezeichnete Arbeit von Tomas Petricek in F# ist auf jeden Fall eine Erkundung wert.

Über das „DSL“-Paradigma hinaus schlage ich vor, dass wir Beiträge einer Reihe anderer leistungsstarker Paradigmen benötigen, um eine vollständige Möglichkeit zu haben, die komplexe Semantik von Finanzinstrumenten und Finanzverträgen darzustellen und gleichzeitig den „Big Data“-Realitäten gerecht zu werden.

Es lohnt sich, einige hier erwähnte Sprachen zu überprüfen: http://www.dslfin.org/resources.html

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top