A Random Walk Around .Net

Black Scholes F#

Yezdaan Baber — Tue, 10 Jun 2008 02:15:11 GMT

F# is a relatively new .NET technology that is worthy of a developer’s arsenal. It provides quite a few benefits such as type inference, native non-mutable states for concurrency, pattern matching and script-esque capabilities.

One thing I would love is the ability to write unit tests in F#. I believe the resulting code would be succinct and reusable. Though, I have not figured out such a framework, here is my first attempt at F# through the famous Black Scholes .

Without much of a history, finance or math lesson, Black Scholes is an equation to price options. Basically, an option is a financial instrument that gives the buyer the option to buy or sell another underlying asset at a certain price in the future for a premium paid today. Black Scholes is a closed form equation to help estimate the premium to charge for such an option.

#light
open System type PutOrCall = | Call = 1 | Put = 2
let CumulativeNormalDistribution (x: double) = let
L = abs(x)
let K = 1.0 / (1.0 + 0.2316419 * L)
let dcnd = 1.0 - 1.0 / sqrt(2.0 * Math.PI) * exp(-L * L / 2.0) * (0.31938153 * K + -0.356563782 * K * K + 1.781477937 * Math.Pow(K,
3.0) + -1.821255978 * Math.Pow(K,
4.0) + 1.330274429 * Math.Pow(K,
5.0)) if x
< 0.0 then 1.0 - dcnd else dcnd
let BlackScholes (pc: PutOrCall) stock strike time interestRate vol = let
d1 = (log(stock / strike) + (interestRate + vol * vol / 2.0) * time) / (vol * sqrt(time))
let d2 = d1 - vol * sqrt(time) if pc = PutOrCall.Call
then stock * CumulativeNormalDistribution(d1) - strike * exp(-interestRate * time) * CumulativeNormalDistribution(d2) else strike * exp(-interestRate * time) * CumulativeNormalDistribution(-d2) - stock * CumulativeNormalDistribution(-d1)

This weblog is sponsored by IFinancialSystems.

A New Laptop. . .

Yezdaan Baber — Sun, 08 Jun 2008 02:24:15 GMT

I finally decided to get a new laptop to support at my home development process. My previous laptop was a three year old IBM Think Pad. Unfortunately, trying to run Visual Studio 2008 (with many of the new additions) and Office 2007 was painfully slow. Basically, I found myself waiting 5-10 minutes between builds on large scale projects.

While researching which laptop to get, the hardware was the easy part. My dream choice was an Intel Core 2 Duo, 4 GB Ram and 200 GB @ 7200 rpm. The much harder question was which brand: IBM, Dell, Sony or another computer. After quite a bit of research, I decided why not a MAC?

One might think; how does one run Visual Studio on a Mac? Vmware fusion is the answer. If you have never tried developing on a virtual machine, it is must. Moreover, when you can run Windows Server 2008 and Vista Ultimate simultaneously to replicate a SOA environment is amazing. Furthermore, debugging the SOA environment is a breeze with the .NET remote debugger.

Another benefit of virtual machines is the ability to save states. The obvious reason is recovery; however, two other reasons are more useful in daily development. First, the ability to suspend a development session and restart, at a later time, exactly where you left off. Furthermore, the restarting of session seems faster than restarting the operating system and visual studio. Second, the ability pass a session to a fellow developer is quite useful. Basically, this saves quite a bit of time explaining setup procedures to another developer.

Finally, I choose Vmware over Parallels mainly because of the dual core support. The Unity view allows me to seamlessly browse the web in safari and program in visual studio. Though I don’t do much website design, I could imagine such a scenario could be quite useful.

All in all, I am very happy with my current enviorment.

This weblog is sponsored by IFinancialSystems.

A Better ReaderWriterLock Wrapper

Yezdaan Baber — Sat, 03 May 2008 03:24:10 GMT

Due to the fact my background is in financial markets (trading systems to be exact), I find my self continuously trying to scrounge up milliseconds by code improvements. My weapon of choice is parallel processing or otherwise called threading. Over the years it has been both my greatest asset any my most malevolent foe. Many have commented on the impeding doom of mutable states and many core processors in software design; hence functional programming.

I have aspiration to neither speak about functional programming nor give a class on threading best practices. Instead, I am interested in providing an easier ReaderWriterLock schematic; most likely to the joy of my team.

The “lock{}” keyword (or “SyncLock” keyword for VB.NET) is very useful and concise in its usage; though anyone trying to squeeze milliseconds knows the performance benefits of a ReaderWriterLock in many cases. (Stop here if the previous statement doesn’t make sense to you and go Google the ReaderWriterLock.) However, the implementation of a ReaderWriterLock requires much more code and can cause dead locks if implemented incorrectly.

Thus, I came up with the attached solution. It offers improvements on two fronts. One, it allows a user to retry a function N number of times before raising an exception. Second, it ensures the locks are acquired and released correctly.

I am not exactly thrilled with this design because the use of anonymous methods makes for a non simple solution. Nevertheless, I think it is better then writing the internalized code in ever method that needs to be locked. Finally, I have not performance tested this yet; but I will post later with results.

public class ClassThanNeedsLocking
{ ReTryReaderWriterLock _rw = new ReTryReaderWriterLock(); private Dictionary<double, double>
_valueMap; public ClassThanNeedsLocking()
{ this._valueMap = new Dictionary<double, double>();
} public void AddSomething(double key, double value)
{ ReTryReaderWriterLock.FunctionalityToLock temp = delegate { this._valueMap.Add(key,
value); }; this._rw.WriterLockFunction(temp,
100, 5, 10); } public double GetSomething(double key)
{ double value = 0;
ReTryReaderWriterLock.FunctionalityToLock temp = delegate { if (this._valueMap.TryGetValue(key, out value))
{ throw new ArgumentException("Key
Does Not Exist.", "key");
} }; this._rw.ReaderLockFunction(temp,
100, 5, 10); return value;
} } public class ReTryReaderWriterLock
{ public delegate void FunctionalityToLock(); private delegate void RepeatTryLock(int timesTried); private ReaderWriterLock
_rw = new ReaderWriterLock(); private ILock
_reader = new ReaderLock(); private ILock
_writer = new WriterLock(); public void ReaderLockFunction(FunctionalityToLock
function, int timeOutPerTry, int timesToTry, int timeToWaitBeforeTryingAgain)
{ LockFunction(function, timeOutPerTry, timesToTry, timeToWaitBeforeTryingAgain, this._reader);
} public void WriterLockFunction(FunctionalityToLock
function, int timeOutPerTry, int timesToTry, int timeToWaitBeforeTryingAgain)
{ LockFunction(function, timeOutPerTry, timesToTry, timeToWaitBeforeTryingAgain, this._writer);
} private void LockFunction(FunctionalityToLock
function, int timeOutPerTry, int timesToTry, int timeToWaitBeforeTryingAgain,
ILock typeOfLock) { RepeatTryLock repeater = null;
repeater = delegate(int timesTried)
{ try {
typeOfLock.Acquire(this._rw,
timeOutPerTry); function(); } catch (ApplicationException)
{ if (timesTried
< timesToTry) { Thread.Sleep(timeToWaitBeforeTryingAgain); timesTried += 1; repeater(timesTried); return;
} throw;
} finally {
typeOfLock.Release(this._rw);
} }; repeater(0); } private interface ILock
{ void Acquire(ReaderWriterLock
rw, int timeOutPerTry); void Release(ReaderWriterLock
rw); } private class ReaderLock
: ILock { public void Acquire(ReaderWriterLock
rw, int timeOutPerTry)
{ rw.AcquireReaderLock(timeOutPerTry); } public void Release(ReaderWriterLock
rw) { if (rw.IsReaderLockHeld
== true)
{ rw.ReleaseReaderLock(); } } } private class WriterLock
: ILock { public void Acquire(ReaderWriterLock
rw, int timeOutPerTry)
{ rw.AcquireWriterLock(timeOutPerTry); } public void Release(ReaderWriterLock
rw) { if (rw.IsWriterLockHeld
== true)
{ rw.ReleaseWriterLock(); } } } }

This weblog is sponsored by IFinancialSystems.