static void Main(string[] args)
{
try
{
Option.Type type = Option.Type.Put;
double underlying = 36.0;
double spreadRate = 0.005;
double dividendYield = 0.02;
double riskFreeRate = 0.06;
double volatility = 0.2;
int settlementDays = 3;
int length = 5;
double redemption = 100.0;
double conversionRatio = redemption / underlying; // at the money
// set up dates/schedules
Calendar calendar = new TARGET();
Date today = calendar.adjust(Date.Today);
Settings.setEvaluationDate(today);
Date settlementDate = calendar.advance(today, settlementDays, TimeUnit.Days);
Date exerciseDate = calendar.advance(settlementDate, length, TimeUnit.Years);
Date issueDate = calendar.advance(exerciseDate, -length, TimeUnit.Years);
BusinessDayConvention convention = BusinessDayConvention.ModifiedFollowing;
Frequency frequency = Frequency.Annual;
Schedule schedule = new Schedule(issueDate, exerciseDate,
new Period(frequency), calendar, convention, convention,
DateGeneration.Rule.Backward, false);
DividendSchedule dividends = new DividendSchedule();
CallabilitySchedule callability = new CallabilitySchedule();
List <double> coupons = new InitializedList <double>(1, 0.05);
DayCounter bondDayCount = new Thirty360();
int[] callLength = { 2, 4 }; // Call dates, years 2,4.
int[] putLength = { 3 }; // Put dates year 3.
double[] callPrices = { 101.5, 100.85 };
double[] putPrices = { 105.0 };
// Load call schedules
for (int i = 0; i < callLength.Length; i++)
{
SoftCallability s = new SoftCallability(
new Callability.Price(callPrices[i], Callability.Price.Type.Clean), schedule.date(callLength[i]),
1.20);
callability.Add(s);
}
for (int j = 0; j < putLength.Length; j++)
{
Callability s = new Callability(new Callability.Price(putPrices[j], Callability.Price.Type.Clean),
Callability.Type.Put, schedule.date(putLength[j]));
callability.Add(s);
}
// Assume dividends are paid every 6 months .
for (Date d = today + new Period(6, TimeUnit.Months); d < exerciseDate; d += new Period(6, TimeUnit.Months))
{
Dividend div = new FixedDividend(1.0, d);
dividends.Add(div);
}
DayCounter dayCounter = new Actual365Fixed();
double maturity = dayCounter.yearFraction(settlementDate, exerciseDate);
Console.WriteLine("option type = " + type);
Console.WriteLine("Time to maturity = " + maturity);
Console.WriteLine("Underlying price = " + underlying);
Console.WriteLine("Risk-free interest rate = {0:0.0%}", riskFreeRate);
Console.WriteLine("Dividend yield = {0:0.0%}%", dividendYield);
Console.WriteLine("Volatility = {0:0.0%}%", volatility);
Console.WriteLine("");
// write column headings
int[] widths = { 35, 14, 14 };
int totalWidth = widths[0] + widths[1] + widths[2];
string rule = new string('-', totalWidth);
string dblrule = new string('=', totalWidth);
Console.WriteLine(dblrule);
Console.WriteLine("Tsiveriotis-Fernandes method");
Console.WriteLine(dblrule);
Console.WriteLine("Tree Type European American ");
Console.WriteLine(rule);
Exercise exercise = new EuropeanExercise(exerciseDate);
Exercise amexercise = new AmericanExercise(settlementDate, exerciseDate);
Handle <Quote> underlyingH = new Handle <Quote>(new SimpleQuote(underlying));
Handle <YieldTermStructure> flatTermStructure =
new Handle <YieldTermStructure>(new FlatForward(settlementDate, riskFreeRate, dayCounter));
Handle <YieldTermStructure> flatDividendTS =
new Handle <YieldTermStructure>(new FlatForward(settlementDate, dividendYield, dayCounter));
Handle <BlackVolTermStructure> flatVolTS =
new Handle <BlackVolTermStructure>(new BlackConstantVol(settlementDate, calendar, volatility,
dayCounter));
BlackScholesMertonProcess stochasticProcess =
new BlackScholesMertonProcess(underlyingH, flatDividendTS, flatTermStructure, flatVolTS);
int timeSteps = 801;
Handle <Quote> creditSpread = new Handle <Quote>(new SimpleQuote(spreadRate));
Quote rate = new SimpleQuote(riskFreeRate);
Handle <YieldTermStructure> discountCurve =
new Handle <YieldTermStructure>(new FlatForward(today, new Handle <Quote>(rate), dayCounter));
IPricingEngine engine = new BinomialConvertibleEngine <JarrowRudd>(stochasticProcess, timeSteps);
ConvertibleFixedCouponBond europeanBond = new ConvertibleFixedCouponBond(exercise, conversionRatio,
dividends, callability, creditSpread, issueDate, settlementDays, coupons, bondDayCount, schedule,
redemption);
europeanBond.setPricingEngine(engine);
ConvertibleFixedCouponBond americanBond = new ConvertibleFixedCouponBond(amexercise, conversionRatio,
dividends, callability, creditSpread, issueDate, settlementDays, coupons, bondDayCount, schedule,
redemption);
americanBond.setPricingEngine(engine);
Console.WriteLine("Jarrow-Rudd {0:0.000000} {1:0.000000}", europeanBond.NPV(), americanBond.NPV());
americanBond.setPricingEngine(new BinomialConvertibleEngine <CoxRossRubinstein>(stochasticProcess, timeSteps));
europeanBond.setPricingEngine(new BinomialConvertibleEngine <CoxRossRubinstein>(stochasticProcess, timeSteps));
Console.WriteLine("CoxRossRubinstein {0:0.000000} {1:0.000000}", europeanBond.NPV(), americanBond.NPV());
americanBond.setPricingEngine(new BinomialConvertibleEngine <AdditiveEQPBinomialTree>(stochasticProcess, timeSteps));
europeanBond.setPricingEngine(new BinomialConvertibleEngine <AdditiveEQPBinomialTree>(stochasticProcess, timeSteps));
Console.WriteLine("AdditiveEQPBinomialTree {0:0.000000} {1:0.000000}", europeanBond.NPV(), americanBond.NPV());
americanBond.setPricingEngine(new BinomialConvertibleEngine <Trigeorgis>(stochasticProcess, timeSteps));
europeanBond.setPricingEngine(new BinomialConvertibleEngine <Trigeorgis>(stochasticProcess, timeSteps));
Console.WriteLine("Trigeorgis {0:0.000000} {1:0.000000}", europeanBond.NPV(), americanBond.NPV());
americanBond.setPricingEngine(new BinomialConvertibleEngine <Tian>(stochasticProcess, timeSteps));
europeanBond.setPricingEngine(new BinomialConvertibleEngine <Tian>(stochasticProcess, timeSteps));
Console.WriteLine("Tian {0:0.000000} {1:0.000000}", europeanBond.NPV(), americanBond.NPV());
americanBond.setPricingEngine(new BinomialConvertibleEngine <LeisenReimer>(stochasticProcess, timeSteps));
europeanBond.setPricingEngine(new BinomialConvertibleEngine <LeisenReimer>(stochasticProcess, timeSteps));
Console.WriteLine("LeisenReimer {0:0.000000} {1:0.000000}", europeanBond.NPV(), americanBond.NPV());
americanBond.setPricingEngine(new BinomialConvertibleEngine <Joshi4>(stochasticProcess, timeSteps));
europeanBond.setPricingEngine(new BinomialConvertibleEngine <Joshi4>(stochasticProcess, timeSteps));
Console.WriteLine("Joshi4 {0:0.000000} {1:0.000000}", europeanBond.NPV(), americanBond.NPV());
Console.WriteLine("===========================================================================");
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
Console.ReadKey();
}
public void testCallableEquityPricing()
{
// Testing the pricing of a callable equity product
/*
* For the definition of the example product see
* Alexander Giese, On the Pricing of Auto-Callable Equity
* Structures in the Presence of Stochastic Volatility and
* Stochastic Interest Rates .
* http://workshop.mathfinance.de/2006/papers/giese/slides.pdf
*/
int maturity = 7;
DayCounter dc = new Actual365Fixed();
Date today = Date.Today;
Settings.Instance.setEvaluationDate(today);
Handle <Quote> spot = new Handle <Quote>(new SimpleQuote(100.0));
SimpleQuote qRate = new SimpleQuote(0.04);
Handle <YieldTermStructure> qTS = new Handle <YieldTermStructure>(Utilities.flatRate(today, qRate, dc));
SimpleQuote rRate = new SimpleQuote(0.04);
Handle <YieldTermStructure> rTS = new Handle <YieldTermStructure>(Utilities.flatRate(today, rRate, dc));
HestonProcess hestonProcess = new HestonProcess(rTS, qTS, spot, 0.0625, 1.0, 0.24 * 0.24, 1e-4, 0.0);
// FLOATING_POINT_EXCEPTION
HullWhiteForwardProcess hwProcess = new HullWhiteForwardProcess(rTS, 0.00883, 0.00526);
hwProcess.setForwardMeasureTime(dc.yearFraction(today, today + new Period(maturity + 1, TimeUnit.Years)));
HybridHestonHullWhiteProcess jointProcess = new HybridHestonHullWhiteProcess(hestonProcess, hwProcess, -0.4);
Schedule schedule = new Schedule(today, today + new Period(maturity, TimeUnit.Years), new Period(1, TimeUnit.Years),
new TARGET(), BusinessDayConvention.Following, BusinessDayConvention.Following, DateGeneration.Rule.Forward, false);
List <double> times = new InitializedList <double>(maturity + 1);
for (int i = 0; i <= maturity; ++i)
{
times[i] = i;
}
TimeGrid grid = new TimeGrid(times, times.Count);
List <double> redemption = new InitializedList <double>(maturity);
for (int i = 0; i < maturity; ++i)
{
redemption[i] = 1.07 + 0.03 * i;
}
ulong seed = 42;
IRNG rsg = (InverseCumulativeRsg <RandomSequenceGenerator <MersenneTwisterUniformRng>
, InverseCumulativeNormal>)
new PseudoRandom().make_sequence_generator(jointProcess.factors() * (grid.size() - 1), seed);
MultiPathGenerator <IRNG> generator = new MultiPathGenerator <IRNG>(jointProcess, grid, rsg, false);
GeneralStatistics stat = new GeneralStatistics();
double antitheticPayoff = 0;
int nrTrails = 40000;
for (int i = 0; i < nrTrails; ++i)
{
bool antithetic = (i % 2) != 0;
Sample <IPath> path = antithetic ? generator.antithetic() : generator.next();
MultiPath value = path.value as MultiPath;
Utils.QL_REQUIRE(value != null, () => "Invalid Path");
double payoff = 0;
for (int j = 1; j <= maturity; ++j)
{
if (value[0][j] > spot.link.value())
{
Vector states = new Vector(3);
for (int k = 0; k < 3; ++k)
{
states[k] = value[k][j];
}
payoff = redemption[j - 1] / jointProcess.numeraire(grid[j], states);
break;
}
else if (j == maturity)
{
Vector states = new Vector(3);
for (int k = 0; k < 3; ++k)
{
states[k] = value[k][j];
}
payoff = 1.0 / jointProcess.numeraire(grid[j], states);
}
}
if (antithetic)
{
stat.add(0.5 * (antitheticPayoff + payoff));
}
else
{
antitheticPayoff = payoff;
}
}
double expected = 0.938;
double calculated = stat.mean();
double error = stat.errorEstimate();
if (Math.Abs(expected - calculated) > 3 * error)
{
QAssert.Fail("Failed to reproduce auto-callable equity structure price"
+ "\n calculated: " + calculated
+ "\n error: " + error
+ "\n expected: " + expected);
}
}
static void Main(string[] args)
{
const int xSteps = 100;
const int tSteps = 25;
const int dampingSteps = 0;
Date today = new Date(15, Month.January, 2020);
Settings.instance().setEvaluationDate(today);
DayCounter dc = new Actual365Fixed();
YieldTermStructureHandle rTS = new YieldTermStructureHandle(
new FlatForward(today, 0.06, dc));
YieldTermStructureHandle qTS = new YieldTermStructureHandle(
new FlatForward(today, 0.02, dc));
const double strike = 110.0;
StrikedTypePayoff payoff = new PlainVanillaPayoff(Option.Type.Put, strike);
Date maturityDate = today.Add(new Period(1, TimeUnit.Years));
double maturity = dc.yearFraction(today, maturityDate);
Exercise exercise = new AmericanExercise(today, maturityDate);
Instrument vanillaOption = new VanillaOption(payoff, exercise);
QuoteHandle spot = new QuoteHandle(new SimpleQuote(100.0));
BlackVolTermStructureHandle volatility = new BlackVolTermStructureHandle(
new BlackConstantVol(today, new TARGET(), 0.20, dc));
BlackScholesMertonProcess process =
new BlackScholesMertonProcess(spot, qTS, rTS, volatility);
vanillaOption.setPricingEngine(new FdBlackScholesVanillaEngine(
process, tSteps, xSteps, dampingSteps));
double expected = vanillaOption.NPV();
// build an PDE engine from scratch
Fdm1dMesher equityMesher = new FdmBlackScholesMesher(
xSteps, process, maturity, strike,
nullDouble(), nullDouble(), 0.0001, 1.5,
new DoublePair(strike, 0.1));
FdmMesherComposite mesher = new FdmMesherComposite(equityMesher);
FdmLinearOpComposite op = new FdmBlackScholesOp(mesher, process, strike);
FdmInnerValueCalculator calc = new FdmLogInnerValue(payoff, mesher, 0);
QlArray x = new QlArray(equityMesher.size());
QlArray rhs = new QlArray(equityMesher.size());
FdmLinearOpIterator iter = mesher.layout().begin();
for (uint i = 0; i < rhs.size(); ++i, iter.increment())
{
x.set(i, mesher.location(iter, 0));
rhs.set(i, calc.avgInnerValue(iter, maturity));
}
FdmBoundaryConditionSet bcSet = new FdmBoundaryConditionSet();
FdmStepConditionComposite stepCondition =
FdmStepConditionComposite.vanillaComposite(
new DividendSchedule(), exercise, mesher, calc, today, dc);
FdmLinearOpComposite proxyOp = new FdmLinearOpCompositeProxy(
new FdmBSDelegate(op));
FdmBackwardSolver solver = new FdmBackwardSolver(
proxyOp, bcSet, stepCondition, FdmSchemeDesc.Douglas());
solver.rollback(rhs, maturity, 0.0, tSteps, dampingSteps);
double logS = Math.Log(spot.value());
double calculated = new CubicNaturalSpline(x, rhs).call(logS);
Console.WriteLine("Homebrew PDE engine : {0:0.0000}", calculated);
Console.WriteLine("FdBlackScholesVanillaEngine: {0:0.0000}", expected);
}