On 04/14/05 15:51:37,
[hidden email] wrote:
> I am looking into reducing the number of parameters
Theo,
I'm just throwing in some suggestions (i.e., don't take the
following as the Chosen Interface.)
A first attempt might be:
class ConvertibleBond: public FixedCouponBond {
public:
ConvertibleBond(Real conversionRatio,
// underlying parameters
const boost::shared_ptr<StochasticProcess>& process,
const DividendSchedule& dividends,
// issuer parameters
const Handle<Quote>& creditSpread,
// callability
const CallabilitySchedule& callability,
// bond parameters
const Date& issueDate,
const Date& datedDate,
const Date& bondMaturityDate,
Integer settlementDays,
Rate coupon,
Frequency couponFrequency,
const DayCounter& dayCounter,
const Calendar& calendar,
BusinessDayConvention convention,
Real redemption = 100.0);
// inspectors
...
private:
// data members---see above, except those already stored in base class
...
};
where we got down to 15; we might further group datedDate, maturityDate,
couponFrequency and calendar into a single Schedule object and get down to
12 if we made the corresponding change in FixedCouponBond (from which
ConvertibleBond should inherit, rather than Bond.) Further reduction might
be difficult, as the specification of a convertible bond does have a number
of parameters---and not all of them can be grouped in a natural way
("natural" as opposed to forcibly aggregate unrelated parameters into a
Parameters struct which wouldn't correspond to a clear concept in the
domain.)
The DividendSchedule class could be implemented in several ways. One
possibility is:
struct Dividend {
enum Type { Cash, Yield };
Real amount;
Type type;
Date date;
};
typedef std::vector<Dividend> DividendSchedule;
Another is:
struct Dividend {
enum Type { Cash, Yield };
Real amount;
Type type;
};
typedef std::vector<std::pair<Date,Dividend> > DividendSchedule;
Yet another uses the latter struct with:
typedef std::map<Date,Dividend> DividendSchedule;
And others might choose to encapsulate the container, in order to restrict
access (the full vector or map interface might be too large):
class DividendSchedule {
public:
...
const Dividend& operator[](const Date&) const;
private:
std::map<Date,Dividend> schedule_;
};
The same applies to CallabilitySchedule, with some added fields; for
instance,
struct Price {
enum Type { Dirty, Clean };
Real price;
Type type;
};
struct Callability {
enum Type { Call, Put };
Price price;
Type type;
Date date;
};
typedef std::vector<Callability> CallabilitySchedule;
or again:
struct Callability {
enum Type { Call, Put };
Price price;
Type type;
};
typedef std::vector<std::pair<Date,Callability> > CallabilitySchedule;
(using a map might not work, since there might be a callability and a
puttability on the same date; a multimap would be required.)
Later,
Luigi
----------------------------------------
I hate quotations.
-- Ralph Waldo Emerson
Locked
convertible_bond.txt (2K)