DSLs (linguagens específicas de domínio) em finanças

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

  •  09-06-2019
  •  | 
  •  

Pergunta

Alguém já trabalhou com DSLs (linguagens específicas de domínio) no domínio financeiro?Estou planejando introduzir algum tipo de suporte DSL na aplicação em que estou trabalhando e gostaria de compartilhar algumas idéias.

Estou na fase de identificar quais são os elementos de domínio mais estáveis ​​e selecionar os recursos que seriam melhor implementados com o DSL.Ainda não defini a sintaxe deste primeiro recurso.

Foi útil?

Solução

Jay Fields e Obie Fernandez escreveram e falaram extensivamente sobre o assunto.

Você também encontrará informações gerais sobre a implementação de DSL nos escritos de Martin Fowler (mas não específicas para finanças).

Outras dicas

Os contratos financeiros foram elegantemente modelados como DSL por Simon Peyton Jones e Jean-Marc-Erby.Seu DSL, incorporado em Haskell, é apresentado no artigo Como redigir um contrato financeiro.

Linguagens específicas de domínio (DSLs) são mais comumente usadas para representar instrumentos financeiros.O artigo canônico é de Simon Peyton Jones Compondo Contratos:uma aventura em engenharia financeira que representa contratos usando uma biblioteca combinadora em Haskell.O uso mais proeminente da abordagem do combinador é Linguagem MLFi da LexiFi, que é baseado no OCaml (seu CEO, Jean-Marc Eber, é coautor do artigo Composing Contracts).A certa altura, o Barclay's copiou a abordagem e descreveu alguns benefícios adicionais, como a capacidade de gerar fórmulas matemáticas de preços legíveis por humanos (Usos comerciais:Tornando-se funcional em negociações exóticas).

DSLs para contratos financeiros são normalmente construídas usando incorporação em uma linguagem funcional como Haskell, Scala ou OCaml.A adoção de linguagens de programação funcionais no setor financeiro continuará a tornar esta abordagem atraente.

Além de representar instrumentos financeiros, as DSLs também são utilizadas em finanças para:

Eu mantenho uma lista completa de documentos, palestras e outros recursos sobre DSLs financeiros em http://www.dslfin.org/resources.html.

Se você quiser conhecer profissionais e pesquisadores que trabalham com DSLs para sistemas financeiros, haverá um workshop no dia 1º de outubro na conferência MODELS 2013 em Miami, Flórida: http://www.dslfin.org/

Trabalhamos na ideia de criar uma DSL de avaliação financeira com Fairmat ( http://www.fairmat.com )

-Vete um DSL que pode ser usado para expressar pagamentos e dependências de pagamento -contém um modelo de extensão para criar novos tipos de analíticos e implementações da dinâmica teórica usando .NET/ C# com nossa biblioteca de matemática subjacente (consulte alguns exemplos de código aberto no https://github.com/fairmat

Acho que o trabalho de Simon Peyton Jones e Jean Marc Eber é o mais impressionante por causa de "Composing Contracts:uma Aventura em Engenharia Financeira" e tudo que deriva disso:"LexiFi e MLFi".

Encontrado Shahbaz Chaudhary A implementação do Scala é a mais atraente, visto que o MLFi não está geralmente disponível (e porque o Scala como linguagem funcional é mais acessível que o Haskell).

Ver "Aventuras em engenharia financeira e de software" e o outro material referenciado a partir daí.

Ousarei replicar um recorte para ter uma ideia do que essa implementação pode fazer.

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

}

O excelente trabalho de Tomas Petricek em F# vale muito a pena explorar.

Além do paradigma "DSL", sugiro que precisaríamos de contribuições de uma série de outros paradigmas poderosos para ter uma maneira completa de representar a semântica complexa dos instrumentos financeiros e dos contratos financeiros, ao mesmo tempo em que atendemos às realidades do "big data".

Vale a pena revisar alguns idiomas mencionados aqui: http://www.dslfin.org/resources.html

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top