forward.hpp

/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 
/*
 Copyright (C) 2006 Allen Kuo
 
 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_forward_hpp
#define quantlib_forward_hpp
 
#include <ql/instrument.hpp>
#include <ql/position.hpp>
#include <ql/time/calendar.hpp>
#include <ql/time/daycounter.hpp>
#include <ql/interestrate.hpp>
#include <ql/types.hpp>
#include <ql/handle.hpp>
#include <ql/payoff.hpp>
#include <ql/termstructures/yieldtermstructure.hpp>
 
namespace QuantLib {
 
 
    class Forward : public Instrument {
      public:
 
        virtual Date settlementDate() const;
        const Calendar& calendar() const;
        BusinessDayConvention businessDayConvention() const;
        const DayCounter& dayCounter() const;
        Handle<YieldTermStructure> discountCurve() const;
        Handle<YieldTermStructure> incomeDiscountCurve() const;
        bool isExpired() const override;
 
        virtual Real spotValue() const = 0;
        virtual Real spotIncome(const Handle<YieldTermStructure>&
                                               incomeDiscountCurve) const = 0;
 
 
 
        virtual Real forwardValue() const;
 
        InterestRate impliedYield(Real underlyingSpotValue,
                                  Real forwardValue,
                                  Date settlementDate,
                                  Compounding compoundingConvention,
                                  const DayCounter& dayCounter);
      protected:
        Forward(DayCounter dayCounter,
                Calendar calendar,
                BusinessDayConvention businessDayConvention,
                Natural settlementDays,
                ext::shared_ptr<Payoff> payoff,
                const Date& valueDate,
                const Date& maturityDate,
                Handle<YieldTermStructure> discountCurve = Handle<YieldTermStructure>());
 
        void performCalculations() const override;
        mutable Real underlyingIncome_;
        mutable Real underlyingSpotValue_;
 
        DayCounter dayCounter_;
        Calendar calendar_;
        BusinessDayConvention businessDayConvention_;
        Natural settlementDays_;
        ext::shared_ptr<Payoff> payoff_;
        Date valueDate_;
        Date maturityDate_;
        Handle<YieldTermStructure> discountCurve_;
        Handle<YieldTermStructure> incomeDiscountCurve_;
    };
 
 
    class ForwardTypePayoff : public Payoff {
      public:
        ForwardTypePayoff(Position::Type type, Real strike)
        : type_(type),strike_(strike) {
            QL_REQUIRE(strike >= 0.0,"negative strike given");
        }
        Position::Type forwardType() const { return type_; };
        Real strike() const { return strike_; };
 
        std::string name() const override { return "Forward"; }
        std::string description() const override;
        Real operator()(Real price) const override;
      protected:
        Position::Type type_;
        Real strike_;
    };
 
 
 
    // inline definitions
 
    inline const Calendar& Forward::calendar() const {
        return calendar_;
    }
 
    inline BusinessDayConvention Forward::businessDayConvention() const {
        return businessDayConvention_;
    }
 
    inline const DayCounter& Forward::dayCounter() const {
        return dayCounter_;
    }
 
    inline Handle<YieldTermStructure> Forward::discountCurve() const {
        return discountCurve_;
    }
 
    inline Handle<YieldTermStructure> Forward::incomeDiscountCurve() const {
        return incomeDiscountCurve_;
    }
 
 
    inline std::string ForwardTypePayoff::description() const {
        std::ostringstream result;
        result << name() << ", " << strike() << " strike";
        return result.str();
    }
 
    inline Real ForwardTypePayoff::operator()(Real price) const {
        switch (type_) {
          case Position::Long:
            return (price-strike_);
          case Position::Short:
            return (strike_-price);
          default:
            QL_FAIL("unknown/illegal position type");
        }
    }
 
}
 
 
#endif