yieldCurve.h

Go to the documentation of this file.

#pragma once
#ifndef yieldCurve_h
#define yieldCurve_h

#include "../common/types.h"
#include "../common/date.h"
#include "../common/interpolator.h" 
#include "../common/matrix.h" 
#include "..\common\utils.h"
#include <string>
#include <math.h>
#include <algorithm>
#include<time.h>

using namespace std;

#define YC_NAME_STRLEN 128
#define YC_DEFAULT_NUMER_POINTS 15
#define YC_MAX_NUMBER_POINTS 50

enum interestComposition {
                Discrete,               // 
                Continuous              //
};
        
enum TypeOfRate {
        // Zero Coupon rate
     Cash,
         // rate quoted on a sawp rate basis : for maturity T = fixed rate so that the annualy compounded swap is 0
     Swap 
};


class yieldPoint
{
public:

        yieldPoint(void);

        yieldPoint(Real r,Real T,TypeOfRate type=Cash,DayCountConvention dayCount=ACT_360);

        ~yieldPoint(void);

        Real    getRate()     { return _rate;}

        Real    getMaturity() { return _maturity;}

        TypeOfRate     getType()     { return _type;}

        DayCountConvention getDayCount() { return _dayCount;}

        void     setRate(Real r)     { _rate = r;}

        void     setMaturity(Real m) { _maturity = m;}

        void     setType(TypeOfRate t)     { _type = t;}

        void     setDayCount(DayCountConvention d) { _dayCount = d;}

        static char *TypeAsString(TypeOfRate t);


        private:
                Real    _rate;
                Real    _maturity;
                TypeOfRate     _type;
                DayCountConvention _dayCount;
};


static const Real defaultshiftfactorForShortRate = 0.0001 ;//1 bp

class yieldCurve
{
        friend ostream& operator << (ostream &os, const yieldCurve& c);
        friend ostream& operator << (ostream &os, const yieldCurve* c) {
                return os << *c;
        }

        public:
                yieldCurve(void);
            
                yieldCurve(Real flatRate);
        
                void assignFlatRate(Real r=0.0);

                void assignZCBrateAtIndex(Real rate,Natural i);

                yieldCurve shiftZCBRateCurve(Real shift=defaultshiftfactorForShortRate);

                yieldCurve rotateZCBRateCurve(Real moveInShortestRate=defaultshiftfactorForShortRate,Real maturityOfRotation=7);
            
                yieldCurve(valarray<yieldPoint> yieldPoints,char *name = "unnamed");

                ~yieldCurve(void);

                virtual Real spotRate(Real maturity) const;

                virtual valarray<Real> getMaturitiesInTheMarketCurve() const;

                virtual valarray<Real> getMaturitiesInTheZCBCurve() const;

                virtual Real spotRate(Date maturityDate) const;

                virtual Real discountFactor(Real maturity,interestComposition composition=Continuous);
            
                virtual Real discountFactor(Date maturityDate,interestComposition composition=Continuous);


                virtual Real forwardDiscountFactor(Real forwardstart,Real lengthofcontractafterstart,interestComposition composition=Continuous);
            

                virtual Real forwardRate(Real forwardStart,Real effectiveLengthOfTheContractAfterStart,interestComposition composition=Continuous);

                virtual Real forwardRate(Date forwardStart,Date forwardEnd,interestComposition composition=Continuous);

                virtual yieldCurve forwardZCBCurve(Real forwardStart);
            
                char *getName() {return &_name[0];}
                
                virtual bool operator==(const yieldCurve& yours);

                virtual bool operator!=(const yieldCurve& yours);

        private :
                valarray<yieldPoint> _marketRates;     
                valarray<yieldPoint> _zcbRates; 
                char _name[YC_NAME_STRLEN];   

                yieldPoint getPointAtMaturity(Real maturity);

                void sortMarketRatesByMaturity();

                void sortCashSwap();

                valarray<yieldPoint> getSwapRates();


                valarray<yieldPoint> getSequentSwapRates();

                void computeZCBRatesBootstrap();

                valarray<Real> SequentDiscountFactorsByInvertSwapMatrix();

};


#endif

---