bond.hpp

/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 
/*
 Copyright (C) 2004 Jeff Yu
 Copyright (C) 2004 M-Dimension Consulting Inc.
 Copyright (C) 2005, 2006, 2007, 2008 StatPro Italia srl
 Copyright (C) 2007, 2008, 2009 Ferdinando Ametrano
 Copyright (C) 2007 Chiara Fornarola
 Copyright (C) 2008 Simon Ibbotson
 
 This file is part of QuantLib, a free-software/open-source library
 for financial quantitative analysts and developers - http://quantlib.org/
 
 QuantLib is free software: you can redistribute it and/or modify it
 under the terms of the QuantLib license.  You should have received a
 copy of the license along with this program; if not, please email
 <quantlib-dev@lists.sf.net>. The license is also available online at
 <http://quantlib.org/license.shtml>.
 
 This program is distributed in the hope that it will be useful, but WITHOUT
 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 FOR A PARTICULAR PURPOSE.  See the license for more details.
*/
 
#ifndef quantlib_bond_hpp
#define quantlib_bond_hpp
 
#include <ql/instrument.hpp>
 
#include <ql/time/calendar.hpp>
#include <ql/cashflow.hpp>
#include <ql/compounding.hpp>
 
#include <vector>
 
namespace QuantLib {
 
    class DayCounter;
 
 
    class Bond : public Instrument {
      public:
        class Price {
          public:
            enum Type { Dirty, Clean };
            Price() : amount_(Null<Real>()) {}
            Price(Real amount, Type type) : amount_(amount), type_(type) {}
            Real amount() const {
                QL_REQUIRE(amount_ != Null<Real>(), "no amount given");
                return amount_;
            }
            Type type() const { return type_; }
          private:
            Real amount_;
            Type type_;
        };
 
 
        Bond(Natural settlementDays,
             Calendar calendar,
             const Date& issueDate = Date(),
             const Leg& coupons = Leg());
 
 
        Bond(Natural settlementDays,
             Calendar calendar,
             Real faceAmount,
             const Date& maturityDate,
             const Date& issueDate = Date(),
             const Leg& cashflows = Leg());
 
        class arguments;
        class results;
        class engine;
 
 
        bool isExpired() const override;
 
        void deepUpdate() override;
 
        Natural settlementDays() const;
        const Calendar& calendar() const;
 
        const std::vector<Real>& notionals() const;
        virtual Real notional(Date d = Date()) const;
 
        const Leg& cashflows() const;
        const Leg& redemptions() const;
        const ext::shared_ptr<CashFlow>& redemption() const;
 
        Date startDate() const;
        Date maturityDate() const;
        Date issueDate() const;
 
        bool isTradable(Date d = Date()) const;
        Date settlementDate(Date d = Date()) const;
 
 
 
 
        Real cleanPrice() const;
 
 
        Real dirtyPrice() const;
 
 
        Real settlementValue() const;
 
 
        Rate yield(const DayCounter& dc,
                   Compounding comp,
                   Frequency freq,
                   Real accuracy = 1.0e-8,
                   Size maxEvaluations = 100,
                   Real guess = 0.05,
                   Bond::Price::Type priceType = Bond::Price::Clean) const;
 
 
        Real cleanPrice(Rate yield,
                        const DayCounter& dc,
                        Compounding comp,
                        Frequency freq,
                        Date settlementDate = Date()) const;
 
 
        Real dirtyPrice(Rate yield,
                        const DayCounter& dc,
                        Compounding comp,
                        Frequency freq,
                        Date settlementDate = Date()) const;
 
 
        Real settlementValue(Real cleanPrice) const;
 
 
        Rate yield(Real price,
                   const DayCounter& dc,
                   Compounding comp,
                   Frequency freq,
                   Date settlementDate = Date(),
                   Real accuracy = 1.0e-8,
                   Size maxEvaluations = 100,
                   Real guess = 0.05,
                   Bond::Price::Type priceType = Bond::Price::Clean) const;
 
 
        virtual Real accruedAmount(Date d = Date()) const;
 
        virtual Rate nextCouponRate(Date d = Date()) const;
 
 
        Rate previousCouponRate(Date d = Date()) const;
 
        Date nextCashFlowDate(Date d = Date()) const;
        Date previousCashFlowDate(Date d = Date()) const;
 
      protected:
        void setupExpired() const override;
        void setupArguments(PricingEngine::arguments*) const override;
        void fetchResults(const PricingEngine::results*) const override;
 
        void addRedemptionsToCashflows(const std::vector<Real>& redemptions
                                                       = std::vector<Real>());
 
        void setSingleRedemption(Real notional,
                                 Real redemption,
                                 const Date& date);
 
        void setSingleRedemption(Real notional,
                                 const ext::shared_ptr<CashFlow>& redemption);
 
        void calculateNotionalsFromCashflows();
 
        Natural settlementDays_;
        Calendar calendar_;
        std::vector<Date> notionalSchedule_;
        std::vector<Real> notionals_;
        Leg cashflows_; // all cashflows
        Leg redemptions_; // the redemptions
 
        Date maturityDate_, issueDate_;
        mutable Real settlementValue_;
    };
 
    class Bond::arguments : public PricingEngine::arguments {
      public:
        Date settlementDate;
        Leg cashflows;
        Calendar calendar;
        void validate() const override;
    };
 
    class Bond::results : public Instrument::results {
      public:
        Real settlementValue;
        void reset() override {
            settlementValue = Null<Real>();
            Instrument::results::reset();
        }
    };
 
    class Bond::engine : public GenericEngine<Bond::arguments,
                                              Bond::results> {};
 
 
    // inline definitions
 
    inline Natural Bond::settlementDays() const {
        return settlementDays_;
    }
 
    inline const Calendar& Bond::calendar() const {
        return calendar_;
    }
 
    inline const std::vector<Real>& Bond::notionals() const {
        return notionals_;
    }
 
    inline const Leg& Bond::cashflows() const {
        return cashflows_;
    }
 
    inline const Leg& Bond::redemptions() const {
        return redemptions_;
    }
 
    inline Date Bond::issueDate() const {
        return issueDate_;
    }
 
}
 
#endif