callable bonds

[Allen Kuo-2]

Hi:

 

I'm trying to build a callable bond class and was wondering what a QL preferred design would be. Two possibilities are below. I liked the economy of the first method but the ConvertibleBond class is designed the second way, so was not sure how to proceed.

Thanks,

Allen

 

(1)

class CallableBond : public Bond {
 public:
     CallableBond(const boost::shared_ptr<Bond> bond&
                      const boost::shared_ptr<PricingEngine>& engine,
                      const CallabilitySchedule& callability,
                      );

 etc.
 }

 

i.e. first need to construct a FixedCouponBond, FloatingRateBond or ZeroCouponBond and then pass it in to the CallableBond constructor (which then implicitly defines the callable bond). Theoretically, a ConvertibleBond could also be passed into the constructor to make it callable, though some equity/interest rate correlations would have to be handled/modeled within it.

 

(2)

Analogous to the ConvertibleBond class, we would have three explicit constructors for
each of three types of bonds ( CallableZeroCouponBond , CallableFloatingRateBond ,
CallableFixedCouponBond ). Doing it this way, in the future though, we might need three more constructors for convertible bonds: CallableConvertibleFloatingRateBond, 
CallableConvertibleFixedCouponBond, CallableConvertibleZeroCouponBond.

 

Example below, analogous to ConvertibleBond class:

class CallableBond : public Bond {
 public:
     CallableBond( .... ); 
}

class CallableZeroCouponBond : public CallableBond {
 public:
     CallableZeroCouponBond( .... ); 
}

class CallableFloatingRateBond : public CallableBond {
 public:
     CallableFloatingRateBond( .... );
}

class CallableFixedCouponBond : public CallableBond {
 public:
     CallableFixedCouponBond( .... ); 
}

---

See the all-new, redesigned Yahoo.com. Check it out.

[Luigi Ballabio]

On 08/01/2006 09:03:20 AM, Allen Kuo wrote:

>   I'm trying to build a callable bond class and was wondering what a
> QL preferred design would be. Two possibilities are below. I liked  
> the economy of the first method but the ConvertibleBond class is  
> designed the second way, so was not sure how to proceed.
>
> (1)
>   class CallableBond : public Bond {
>  public:
>      CallableBond(const boost::shared_ptr<Bond> bond&
>                       const boost::shared_ptr<PricingEngine>& engine,
>                       const CallabilitySchedule& callability,
>                       );
>    etc.
>  }

I like this one, but the problem is that the engine should know what  
kind of bond it's being passed---or at least what kind of coupons it  
contains. I.e., if you choose a tree engine, fixed-rate and  
floating-rate coupons will be discounted in a different way on the  
tree. Therefore, the above mightn't be as generic as it seems.


>   (2)
>   Analogous to the ConvertibleBond class, we would have three  
> explicit constructors for each of three types of bonds (  
> CallableZeroCouponBond , CallableFloatingRateBond ,  
> CallableFixedCouponBond ).

This might be less nice, but it has the advantage of specifying the  
kind of bond to be called. I would go for this one first; after the  
code is done, we might try some refactoring to bring it closer to the  
first design.


> Doing it this way, in the future though, we
> might need three more constructors for convertible bonds:

No, convertible bonds manage callability already. (By the way, you can  
look at the relevant classes---Callability and such---so that you can  
reuse them.)

Later,
        Luigi


----------------------------------------

Cogito ergo I'm right and you're wrong.
-- Blair Houghton

[Toyin Akin]

Hi,

I've just ripped some code out of my current framework which prices callable
or puttable fixed coupon bonds.

I've assumed that callability can only take place on coupon dates.

As I've just stripped out the code pertaining to my infrastructure, you may
find that it doesn't immediatly compile, but the logic is there.

I've tested some prices against FinancialCAD and they match.

It doesn't use some of the latest framework code as this was written towards
the end of last year.

Hope it's useful,
Toy out...

>From: Luigi Ballabio <[hidden email]>
>To: Allen Kuo <[hidden email]>
>CC: [hidden email]
>Subject: Re: [Quantlib-dev] callable bonds
>Date: Thu, 03 Aug 2006 11:48:12 +0200
>
>
>On 08/01/2006 09:03:20 AM, Allen Kuo wrote:
> >   I'm trying to build a callable bond class and was wondering what a
> > QL preferred design would be. Two possibilities are below. I liked
> > the economy of the first method but the ConvertibleBond class is
> > designed the second way, so was not sure how to proceed.
> >
> > (1)
> >   class CallableBond : public Bond {
> >  public:
> >      CallableBond(const boost::shared_ptr<Bond> bond&
> >                       const boost::shared_ptr<PricingEngine>& engine,
> >                       const CallabilitySchedule& callability,
> >                       );
> >    etc.
> >  }
>
>I like this one, but the problem is that the engine should know what
>kind of bond it's being passed---or at least what kind of coupons it
>contains. I.e., if you choose a tree engine, fixed-rate and
>floating-rate coupons will be discounted in a different way on the
>tree. Therefore, the above mightn't be as generic as it seems.
>
>
> >   (2)
> >   Analogous to the ConvertibleBond class, we would have three
> > explicit constructors for each of three types of bonds (
> > CallableZeroCouponBond , CallableFloatingRateBond ,
> > CallableFixedCouponBond ).
>
>This might be less nice, but it has the advantage of specifying the
>kind of bond to be called. I would go for this one first; after the
>code is done, we might try some refactoring to bring it closer to the
>first design.
>
>
> > Doing it this way, in the future though, we
> > might need three more constructors for convertible bonds:
>
>No, convertible bonds manage callability already. (By the way, you can
>look at the relevant classes---Callability and such---so that you can
>reuse them.)
>
>Later,
> Luigi
>
>
>----------------------------------------
>
>Cogito ergo I'm right and you're wrong.
>-- Blair Houghton
>
>-------------------------------------------------------------------------
>Take Surveys. Earn Cash. Influence the Future of IT
>Join SourceForge.net's Techsay panel and you'll get the chance to share
>your
>opinions on IT & business topics through brief surveys -- and earn cash
>http://www.techsay.com/default.php?page=join.php&p=sourceforge&CID=DEVDEV
>_______________________________________________
>QuantLib-dev mailing list
>[hidden email]
>https://lists.sourceforge.net/lists/listinfo/quantlib-dev

[Allen Kuo-2]

Toyin: Yes, it will definitely be useful. Thanks.

 

I will try to put in the Callability schedule and wrap the whole thing up nicely- will let you know how it goes.

 

Best,

A

 

Toyin Akin <[hidden email]> wrote:

Hi,

I've just ripped some code out of my current framework which prices callable
or puttable fixed coupon bonds.

I've assumed that callability can only take place on coupon dates.

As I've just stripped out the code pertaining to my infrastructure, you may
find that it doesn't immediatly compile, but the logic is there.

I've tested some prices against FinancialCAD and they match.

It doesn't use some of the latest framework code as this was written towards
the end of last year.

Hope it's useful,
Toy out...

>From: Luigi Ballabio
>To: Allen Kuo
>CC: [hidden email]
>Subject: Re: [Quantlib-dev] callable bonds
>Date: Thu, 03 Aug 2006 11:48:12 +0200
>
>
>On 08/01/2006 09:03:20 AM, Allen Kuo wrote:
> > I'm trying to build a callable bond class and was wondering what a
> > QL preferred design would be. Two possibilities are below. I liked
> > the economy of the first method but the ConvertibleBond class is
> > designed the second way, so was not sure how to proceed.
> >
> > (1)
> > class CallableBond : public Bond {
> > public:
> > CallableBond(const boost::shared_ptr bond&
> > const boost::shared_ptr& engine,
> > const CallabilitySchedule& callability,
> > );
> > etc.
> > }
>
>I like this one, but the problem is that the engine should know what
>kind of bond it's being passed---or at least what kind of coupons it
>contains. I.e., if you choose a tree engine, fixed-rate and
>floating-rate coupons will be discounted in a different way on the
>tree. Therefore, the above mightn't be as generic as it seems.
>
>
> > (2)
> > Analogous to the ConvertibleBond class, we would have three
> > explicit constructors for each of three types of bonds (
> > CallableZeroCouponBond , CallableFloatingRateBond ,
> > CallableFixedCouponBond ).
>
>This might be less nice, but it has the advantage of specifying the
>kind of bond to be called. I would go for this one first; after the
>code is done, we might try some refactoring to bring it closer to the
>first design.
>
>
> > Doing it this way, in the future though, we
> > might need three more constructors for convertible bonds:
>
>No, convertible bonds manage callability already. (By the way, you can
>look at the relevant classes---Callability and such---so that you can
>reuse them.)
>
>Later,
> Luigi
>
>
>----------------------------------------
>
>Cogito ergo I'm right and you're wrong.
>-- Blair Houghton
>
>-------------------------------------------------------------------------
>Take Surveys. Earn Cash. Influence the Future of IT
>Join SourceForge.net's Techsay panel and you'll get the chance to share
>your
>opinions on IT & business topics through brief surveys -- and earn cash
>http://www.techsay.com/default.php?page=join.php&p=sourceforge&CID=DEVDEV
>_______________________________________________
>QuantLib-dev mailing list
>[hidden email]
>https://lists.sourceforge.net/lists/listinfo/quantlib-dev

#include
#include <../QuantLib-0.3.8/ql/option.hpp>

namespace QuantLib {

DiscretizedCallableBond::DiscretizedCallableBond(const
CallableBond::arguments& args)
: arguments_(args)
{
}

void DiscretizedCallableBond::reset(Size size)
{
values_ = Array(size, 0.0);
adjustValues();
}

std::vector DiscretizedCallableBond::mandatoryTimes() const
{
std::vector times;
Time t;
Size i;

times.push_back(0.0);

for (i=0; i {
t = arguments_.fixedResetTimes[i];
if (t >= 0.0)
times.push_back(t);
}

for (i=0; i {
t = arguments_.fixedPayTimes[i];
if (t >= 0.0)
times.push_back(t);
}

return times;
}

void DiscretizedCallableBond::preAdjustValuesImpl()
{
Size i, nTotalSize;
double dAccured = arguments_.accuredAmount;

// fixed payments
nTotalSize = arguments_.fixedPayTimes.size();
for (i=0; i {
Time t = arguments_.fixedPayTimes[i];
Time reset = arguments_.fixedResetTimes[i];
if (t >= 0.0 && isOnTime(t))
{
Real fixedCoupon = arguments_.fixedCoupons[i];

// Process the remdeption payment.
if (i == nTotalSize-1)
{
for (Size j=0; j {
double redemption = arguments_.redemption;
values_[j] += redemption;
}
}

// Test if we should replace
bool bTest = false;
double dStrike = 0.0;
Option::Type OptionType;

for (Size j=0; j {
if (arguments_.stoppingTimes[j] == t)
{
dStrike = arguments_.arrStrikes[j];
OptionType = arguments_.arrOptionType[j];
bTest = true;
break;
}
}

// Should we apply callability...
if (bTest == true)
{
for (Size j=0; j {
if (OptionType == Option::Type::Call)
values_[j] = std::min(values_[j], dStrike);
else if (OptionType == Option::Type::Put)
values_[j] = std::max(values_[j], dStrike);
}
}

// Now add on the coupons
values_ += fixedCoupon;
}
}
}

void DiscretizedCallableBond::postAdjustValuesImpl()
{
}
}

/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
*/

#ifndef quantlib_pricers_ctbondoption_pricer_hpp
#define quantlib_pricers_ctbondoption_pricer_hpp

#include
#include <../QuantLib-0.3.8/ql/discretizedasset.hpp>

namespace QuantLib {

class DiscretizedCallableBond : public DiscretizedAsset {
public:
DiscretizedCallableBond(const CallableBond::arguments&);
void reset(Size size);
std::vector mandatoryTimes() const;

protected:
void preAdjustValuesImpl();
void postAdjustValuesImpl();
private:
CallableBond::arguments arguments_;
};
}


#endif



#include
#include

namespace QuantLib {

TreeCallableBondEngine::TreeCallableBondEngine(
const boost::shared_ptr&
model,
Size timeSteps)
: LatticeShortRateModelEngineCallableBond::results>
(model, timeSteps)
{
}

TreeCallableBondEngine::TreeCallableBondEngine(
const boost::shared_ptr&
model,
const TimeGrid& timeGrid)
: LatticeShortRateModelEngineCallableBond::results>
(model, timeGrid)
{
}

void TreeCallableBondEngine::calculate() const {

QL_REQUIRE(model_, "no model specified");

DiscretizedCallableBond callableBond(arguments_);

boost::shared_ptr lattice;
std::vector times = callableBond.mandatoryTimes();

if (lattice_)
{
lattice = lattice_;
}
else
{
TimeGrid timeGrid(times.begin(), times.end(), timeSteps_);
lattice = model_->tree(timeGrid);
}

callableBond.initialize(lattice, times.back());
callableBond.rollback(0.0);

CallableBond::results* results =
dynamic_cast(&results_);

QL_ENSURE(results != 0,
"no results returned from pricing engine");

results->callPrice_ = callableBond.presentValue();
}
}


#ifndef quantlib_pricers_ct_tree_bondoption_hpp
#define quantlib_pricers_ct_tree_bondoption_hpp

#include
#include
<../QuantLib-0.3.8/ql/PricingEngines/latticeshortratemodelengine.hpp>

namespace QuantLib {

class TreeCallableBondEngine
: public LatticeShortRateModelEngine CallableBond::results> {
public:
TreeCallableBondEngine(const boost::shared_ptr&,
Size timeSteps);
TreeCallableBondEngine(const boost::shared_ptr&,
const TimeGrid& timeGrid) ;
void calculate() const;
};

}


#endif

---

Talk is cheap. Use Yahoo! Messenger to make PC-to-Phone calls. Great rates starting at 1¢/min.