DSL (Domain Specific Languages) in Finanza

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

  •  09-06-2019
  •  | 
  •  

Domanda

Qualcuno ha lavorato con DSL (linguaggi specifici del dominio) nel settore finanziario?Sto progettando di introdurre un qualche tipo di supporto DSL nell'applicazione su cui sto lavorando e vorrei condividere alcune idee.

Sono in una fase di identificazione di quali sono gli elementi del dominio più stabili e di selezione delle funzionalità che potrebbero essere meglio implementate con la DSL.Non ho ancora definito la sintassi per questa prima caratteristica.

È stato utile?

Soluzione

Jay Fields e Obie Fernandez hanno scritto e parlato ampiamente sull'argomento.

Negli scritti di Martin Fowler troverai anche materiale generale sull'implementazione della DSL (ma non specifico sulla finanza).

Altri suggerimenti

I contratti finanziari sono stati modellati elegantemente come DSL da Simon Peyton Jones e Jean-Marc-Erby.Il loro DSL, incorporato in Haskell, è presentato nel documento Come scrivere un contratto finanziario.

I linguaggi specifici del dominio (DSL) sono più comunemente usati per rappresentare gli strumenti finanziari.L'articolo canonico è di Simon Peyton Jones Composizione di contratti:un'avventura in ingegneria finanziaria che rappresenta i contratti utilizzando una libreria combinatore in Haskell.L'uso più importante dell'approccio combinatore è Il linguaggio MLFi di LexiFi, che è costruito sulla base di OCaml (il loro CEO, Jean-Marc Eber, è un coautore del documento Comusing Contracts).Barclay's a un certo punto ha copiato l'approccio e ha descritto alcuni vantaggi aggiuntivi, come la capacità di generare formule matematiche di determinazione dei prezzi leggibili dall'uomo (Usi commerciali:Diventare operativi nei commerci esotici).

I DSL per i contratti finanziari vengono generalmente realizzati utilizzando l'incorporamento in un linguaggio funzionale come Haskell, Scala o OCaml.L’adozione di linguaggi di programmazione funzionale nel settore finanziario continuerà a rendere attraente questo approccio.

Oltre a rappresentare strumenti finanziari, i DSL vengono utilizzati anche in finanza per:

Mantengo un elenco completo di documenti, discorsi e altre risorse finanziarie DSL su http://www.dslfin.org/resources.html.

Se desideri incontrare professionisti e ricercatori che lavorano con i DSL per i sistemi finanziari, c'è un prossimo workshop il 1° ottobre alla conferenza MODELS 2013 a Miami, Florida: http://www.dslfin.org/

Abbiamo lavorato sull'idea di creare un DSL di valutazione finanziaria con Fairmat ( http://www.fairmat.com )

-espone una DSL che può essere utilizzata per esprimere i pay-off e le dipendenze di pagamento -contiene un modello di estensione per la creazione di nuovi tipi di analisi e implementazioni di dinamiche teoriche usando .NET/C# con la nostra libreria matematica sottostante (vedi alcuni esempi open source su https://github.com/fairmat

Penso che il lavoro di Simon Peyton Jones e Jean Marc Eber sia il più impressionante grazie a "Comusing Contracts:an Adventure in Financial Engineering" e tutto ciò che ne deriva:"LexiFi e MLFi".

Trovato Shahbaz Chaudhary L'implementazione di Scala è la più interessante dato che MLFi non è generalmente disponibile (e perché Scala come linguaggio funzionale è più accessibile di Haskell).

Vedere "Avventure nell'ingegneria finanziaria e del software" e l'altro materiale a cui si fa riferimento da lì.

Oserò replicare un ritaglio per avere un'idea di cosa può fare questa implementazione.

  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)
  }

}

IL ottimo lavoro di Tomas Petricek in Fa# vale davvero la pena esplorarlo.

Al di là del paradigma “DSL”, suggerisco che avremmo bisogno del contributo di una serie di altri potenti paradigmi per avere un modo completo di rappresentare la complessa semantica degli strumenti finanziari e dei contratti finanziari soddisfacendo al tempo stesso le realtà dei “big data”.

Vale la pena rivedere alcune lingue menzionate qui: http://www.dslfin.org/resources.html

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top