Creo que el trabajo de Simon Peyton Jones y Jean Marc Eber es el más impresionante debido a "Contratos de composición: una aventura en ingeniería financiera" y todo lo que deriva de eso: "LexiFi and MLFi".
Found Shahbaz Chaudhary's La implementación de Scala es la más atractiva, dado que MLFi no está generalmente disponible (y porque Scala como el lenguaje funcional es más accesible que Haskell).
Consulte "Adventures in financial and software engineering" y el otro material al que se hace referencia desde allí.
Me atrevo a replicar un recorte para tener una idea de lo que esta implementación puede hacer.
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)
}
}
El excellent work of Tomas Petricek en F # merece mucho la pena explorar.
Más allá del paradigma "DSL", sugiero que necesitaríamos contribuciones de otros paradigmas poderosos para tener una forma completa de representar la semántica compleja de los instrumentos financieros y contratos financieros al tiempo que cumplimos con las realidades del "big data".
pena revisar algunas lenguas mencionadas aquí: http://www.dslfin.org/resources.html