asianoption.hpp

/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 
/*
 Copyright (C) 2003, 2004 Ferdinando Ametrano
 Copyright (C) 2004, 2007 StatPro Italia srl
 
 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_asian_option_hpp
#define quantlib_asian_option_hpp
 
#include <ql/instruments/oneassetoption.hpp>
#include <ql/instruments/payoffs.hpp>
#include <ql/instruments/averagetype.hpp>
#include <ql/time/date.hpp>
#include <vector>
 
namespace QuantLib {
 
 
    class ContinuousAveragingAsianOption : public OneAssetOption {
      public:
        class arguments;
        class engine;
        ContinuousAveragingAsianOption(
                Average::Type averageType,
                const ext::shared_ptr<StrikedTypePayoff>& payoff,
                const ext::shared_ptr<Exercise>& exercise);
        void setupArguments(PricingEngine::arguments*) const override;
 
      protected:
        Average::Type averageType_;
    };
 
 
    class DiscreteAveragingAsianOption : public OneAssetOption {
      public:
        class arguments;
        class engine;
        DiscreteAveragingAsianOption(Average::Type averageType,
                                     Real runningAccumulator,
                                     Size pastFixings,
                                     std::vector<Date> fixingDates,
                                     const ext::shared_ptr<StrikedTypePayoff>& payoff,
                                     const ext::shared_ptr<Exercise>& exercise);
 
        DiscreteAveragingAsianOption(Average::Type averageType,
                                     std::vector<Date> fixingDates,
                                     const ext::shared_ptr<StrikedTypePayoff>& payoff,
                                     const ext::shared_ptr<Exercise>& exercise,
                                     std::vector<Real> allPastFixings = std::vector<Real>());
 
        void setupArguments(PricingEngine::arguments*) const override;
 
      protected:
        Average::Type averageType_;
        Real runningAccumulator_;
        Size pastFixings_;
        std::vector<Date> fixingDates_;
 
        // For backwards compatibility with the traditional interface, we keep track of
        // whether this option was initialised using the full array of seasoned fixings
        // (even if empty) or if a pastFixings and a runningAccumulator was provided
        bool allPastFixingsProvided_;
        std::vector<Real> allPastFixings_;
    };
 
    class DiscreteAveragingAsianOption::arguments
        : public OneAssetOption::arguments {
      public:
        arguments() : averageType(Average::Type(-1)),
                      runningAccumulator(Null<Real>()),
                      pastFixings(Null<Size>()) {}
        void validate() const override;
        Average::Type averageType;
        Real runningAccumulator;
        Size pastFixings;
        std::vector<Date> fixingDates;
    };
 
    class ContinuousAveragingAsianOption::arguments
        : public OneAssetOption::arguments {
      public:
        arguments() : averageType(Average::Type(-1)) {}
        void validate() const override;
        Average::Type averageType;
    };
 
    class DiscreteAveragingAsianOption::engine
        : public GenericEngine<DiscreteAveragingAsianOption::arguments,
                               DiscreteAveragingAsianOption::results> {};
 
    class ContinuousAveragingAsianOption::engine
        : public GenericEngine<ContinuousAveragingAsianOption::arguments,
                               ContinuousAveragingAsianOption::results> {};
 
}
 
 
#endif