dsl www वित्त में डीएसएल

धर्मेंद्र सर (4)

मुझे लगता है कि साइमन पाय्टोन जोन्स और जीन मार्क एबर का काम "कम्पोजिंग कॉन्ट्रैक्ट्स: ए एडवेंचर इन फाइनेंशियल इंजीनियरिंग" और " लिसिकफी और एमएलएफआई " से प्राप्त सभी चीजें के कारण सबसे प्रभावशाली है।

शाहबाज चौधरी के स्कला को सबसे आकर्षक रूप में कार्यान्वित किया गया, जो कि एमएलएफआई आम तौर पर उपलब्ध नहीं है (और क्योंकि स्कैला फंक्शनल भाषा के रूप में अधिक सुविधाजनक है जो हास्केल)।

देखें "एडवेंचर्स इन फाइनेंशियल एंड सॉफ्टवेयर इंजीनियरिंग" और अन्य सामग्री जो वहां से संदर्भित हैं।

मैं यह कार्यान्वयन कैसे कर सकता हूं, इसके विचार के लिए एक स्निप की प्रतिलिपि करने की हिम्मत करेगा।

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

}

एफ # में टॉमस पेट्रीसैक का उत्कृष्ट कार्य अन्वेषण करने के लिए काफी मूल्यवान है।

"डीएसएल" प्रतिमान से परे मेरा सुझाव है कि हमें कई अन्य शक्तिशाली मानदंडों से योगदान की ज़रूरत है ताकि "बड़ी डेटा" वास्तविकताओं को पूरा करते हुए वित्तीय साधनों और वित्तीय अनुबंधों के जटिल शब्दों का प्रतिनिधित्व करने का पूरा तरीका हो।

• संभाव्य प्रोग्रामिंग: फिगारो , स्टेन, आदि
• बिग डेटा एनालिटिक्स: आर, स्पार्क, स्पार्कआर
• स्केलेबल "डाटा फ़ैब्रिक" ("ऑफ हेप मेमोरी", कॉमोडिटी हार्डवेयर में, बल्कि भाषाओं में भी): "स्प्रेड फॉर लार्ज स्केल डेटा साइंस" (आर, स्कला / जावा और पायथन के साथ काम करता है) में डेटाफ्रेम
• शब्दावली वेब: " वित्तीय विषय मॉडल " और ontologies

यहां उल्लिखित कुछ भाषाओं की समीक्षा करने के योग्य: http://www.dslfin.org/resources.html