[Quantlib-dev] Again with the Convertible Bonds

[John M. <jwm...@ya...>]

For those that are interested, this is a potential patch for an issue I've found
with the Convertible Bond classes. Basically the weights that are being assigned
to calculate the discounting rate in TsiveriotisFernandesLattice::stepback skew
the results for high credit spreads, so that a callable convertible bond will be
more expensive than an equivalent non-callable convertible bond. See "More More
More Convertible Bonds" in gmane.comp.finance.quantlib.user for more details.

Changes would be made to TsiveriotisFernandesLattice::stepback and
DiscretizedConvertible::applyConvertibility(). Would like input on these changes
and see if people agree/disagree, or know of a better way to do this. Originally
the adjusted discount rate was ConversionProbability * risk free rate + (1 -
ConversionProbability) * (risk free rate + spread). A higher conversion
probability (~1) means that you're probably going to convert, and should
discount the convert like a stock. A lower conversion probability (~0) means the
convert is trading like a bond, and should be discounted as such. I'll keep this
approach, but change how the conversion probability is computed. Basically
instead of assigning an initial probability of 1 if the convert is convertible
and the value is below parity, and later blending the probabilities, the
conversion probabilities will simply be delta (which I took from "Global
Convertible Investing" by Hart Woodson). New code below:

In DiscretedConvertible.cpp:

   void DiscretizedConvertible::applyConvertibility() {
        Array grid = adjustedGrid();
		Array ratio = divAdjustedRatio();
        for (Size j=0; j<values_.size(); j++) {
            Real payoff = ratio[j]*grid[j];
            if (values_[j] <= payoff) {
                values_[j] = payoff;
                // old method
                //conversionProbability_[j] = 1.0;
            }
        }

		for (Size j=0; j<values_.size()-1; j++) {
			conversionProbability_[j] = ((values_[j+1]  - values_[j])/(grid[j+1] -
grid[j]))*(1/ratio[j]);
                        //some values are slightly above 1, must be due to rounding
			if(conversionProbability_[j] > 1.0)
				conversionProbability_[j] = 1.0;
		}
 
                //always assume that will convert at highest stock price
		conversionProbability_[values_.size() - 1] = 1.0;

    }


In TFLattice.hpp:

  template <class T>
    void TsiveriotisFernandesLattice<T>::stepback(
              Size i, const Array& values, const Array& conversionProbability,
              const Array& spreadAdjustedRate, Array& newValues,
              Array& newConversionProbability,
              Array& newSpreadAdjustedRate) const {

	    Real localRiskFreeRate = riskFreeRate_.at(i);
		Real localcreditSpread = creditSpread_.at(i);
		Real down = TFtree_->probability(0,0,0);
		Real up = TFtree_->probability(0,0,1);

        for (Size j=0; j<this->size(i); j++) {

            // new conversion probability is calculated via backward
            // induction using up and down probabilities on tree on
            // previous conversion probabilities, ie weighted average
            // of previous probabilities.

            //don't blend the probabilties
            newConversionProbability[j] = conversionProbability[j];
                /*down*conversionProbability[j]+ up*conversionProbability[j+1];*/

            // Use blended discounting rate
            newSpreadAdjustedRate[j] =
                newConversionProbability[j] * localRiskFreeRate +
               
(1-newConversionProbability[j])*(localRiskFreeRate+localcreditSpread);

            newValues[j] =
                (down*values[j]/(1+(spreadAdjustedRate[j]*dt_)))
              + (up*values[j+1]/(1+(spreadAdjustedRate[j+1]*dt_)));

        }

    }


Looking forward to input.