मुझे लगता है कि साइमन के काम पेटन जोन्स और जीन मार्क एबर "रचनात्मक अनुबंध: वित्तीय प्रबंधन में एक साहसिक" और उससे प्राप्त सब कुछ के कारण सबसे प्रभावशाली है: "LexiFi and MLFi"।
मिला Shahbaz Chaudhary's स्कैला कार्यान्वयन सबसे आकर्षक है कि एमएलएफआई आम तौर पर उपलब्ध नहीं है (और क्योंकि कार्यात्मक भाषा के रूप में स्कैला हास्केल के लिए अधिक सुलभ है)।
"Adventures in financial and software engineering" और वहां से संदर्भित अन्य सामग्री देखें।
मैं इस कार्यान्वयन के बारे में एक विचार के लिए छीनने की हिम्मत करूंगा।
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)
}
}
excellent work of Tomas Petricek एफ # में बहुत ज्यादा की खोज के लायक है।
"डीएसएल" क्रांतिकारी मेरा सुझाव है हम "बिग डाटा" वास्तविकताओं को पूरा करते हुए वित्तीय साधनों और वित्तीय अनुबंधों की जटिल अर्थ विज्ञान का प्रतिनिधित्व करने के लिए एक पूर्ण तरीके से करने के लिए अन्य शक्तिशाली मानदंड के एक नंबर से योगदान आवश्यकता होगी परे
।
कुछ भाषाओं का उल्लेख यहाँ की समीक्षा करने के लायक: http://www.dslfin.org/resources.html