path.hpp

Go to the documentation of this file.

/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 
/*
 Copyright (C) 2000, 2001, 2002, 2003 RiskMap srl
 Copyright (C) 2003, 2004, 2005, 2006 StatPro Italia srl
 Copyright (C) 2003 Ferdinando Ametrano
 
 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.
*/
 
/*! \file path.hpp
    \brief single factor random walk
*/
 
#ifndef quantlib_montecarlo_path_hpp
#define quantlib_montecarlo_path_hpp
 
#include <ql/math/array.hpp>
#include <ql/timegrid.hpp>
#include <utility>
 
namespace QuantLib {
 
    //! single-factor random walk
    /*! \ingroup mcarlo
 
        \note the path includes the initial asset value as its first point.
    */
    class Path {
      public:
        Path(TimeGrid timeGrid, Array values = Array());
        //! \name inspectors
        //@{
        bool empty() const;
        Size length() const;
        //! asset value at the \f$ i \f$-th point
        Real operator[](Size i) const;
        Real at(Size i) const;
        Real& operator[](Size i);
        Real& at(Size i);
        Real value(Size i) const;
        Real& value(Size i);
        //! time at the \f$ i \f$-th point
        Time time(Size i) const;
        //! initial asset value
        Real front() const;
        Real& front();
        //! final asset value
        Real back() const;
        Real& back();
        //! time grid
        const TimeGrid& timeGrid() const;
        //@}
        //! \name iterators
        //@{
        typedef Array::const_iterator iterator;
        typedef Array::const_reverse_iterator reverse_iterator;
        iterator begin() const;
        iterator end() const;
        reverse_iterator rbegin() const;
        reverse_iterator rend() const;
        //@}
      private:
        TimeGrid timeGrid_;
        Array values_;
    };
 
 
    // inline definitions
 
    inline Path::Path(TimeGrid timeGrid, Array values)
    : timeGrid_(std::move(timeGrid)), values_(std::move(values)) {
        if (values_.empty())
            values_ = Array(timeGrid_.size());
        QL_REQUIRE(values_.size() == timeGrid_.size(),
                   "different number of times and asset values");
    }
 
    inline bool Path::empty() const {
        return timeGrid_.empty();
    }
 
    inline Size Path::length() const {
        return timeGrid_.size();
    }
 
    inline Real Path::operator[](Size i) const {
        return values_[i];
    }
 
    inline Real Path::at(Size i) const {
        return values_.at(i);
    }
 
    inline Real& Path::operator[](Size i) {
        return values_[i];
    }
 
    inline Real& Path::at(Size i) {
        return values_.at(i);
    }
 
    inline Real Path::value(Size i) const {
        return values_[i];
    }
 
    inline Real& Path::value(Size i) {
        return values_[i];
    }
 
    inline Real Path::front() const {
        return values_[0];
    }
 
    inline Real& Path::front() {
        return values_[0];
    }
 
    inline Real Path::back() const {
        return values_[values_.size()-1];
    }
 
    inline Real& Path::back() {
        return values_[values_.size()-1];
    }
 
    inline Time Path::time(Size i) const {
        return timeGrid_[i];
    }
 
    inline const TimeGrid& Path::timeGrid() const {
        return timeGrid_;
    }
 
    inline Path::iterator Path::begin() const {
        return values_.begin();
    }
 
    inline Path::iterator Path::end() const {
        return values_.end();
    }
 
    inline Path::reverse_iterator Path::rbegin() const {
        return values_.rbegin();
    }
 
    inline Path::reverse_iterator Path::rend() const {
        return values_.rend();
    }
 
}
 
 
#endif