#include <qle/methods/projectedbufferedmultipathgenerator.hpp>

Inheritance diagram for ProjectedBufferedMultiPathGenerator:

Collaboration diagram for ProjectedBufferedMultiPathGenerator:

Public Member Functions
	ProjectedBufferedMultiPathGenerator (const std::vector< Size > &stateProcessProjection, const QuantLib::ext::shared_ptr< std::vector< std::vector< QuantLib::Path > > > &bufferedPaths)

const Sample< MultiPath > &	next () const override

void	reset () override

Public Member Functions inherited from MultiPathGeneratorBase
virtual	~MultiPathGeneratorBase ()

virtual const Sample< MultiPath > &	next () const =0

virtual void	reset ()=0

Private Attributes
const std::vector< Size >	stateProcessProjection_

const QuantLib::ext::shared_ptr< std::vector< std::vector< QuantLib::Path > > >	bufferedPaths_

Size	maxTargetIndex_

Size	currentPath_

Sample< MultiPath >	next_

Detailed Description

Definition at line 33 of file projectedbufferedmultipathgenerator.hpp.

Constructor & Destructor Documentation

◆ ProjectedBufferedMultiPathGenerator()

ProjectedBufferedMultiPathGenerator	(	const std::vector< Size > &	stateProcessProjection,
		const QuantLib::ext::shared_ptr< std::vector< std::vector< QuantLib::Path > > > &	bufferedPaths
	)

If projection(j) = i for state process indices i from the projected process and j from the original process, then stateProcessProjection[i] = j, i.e. a state process component index from the projected model is mapped to the state process component index of the original model.

Definition at line 23 of file projectedbufferedmultipathgenerator.cpp.

    : stateProcessProjection_(stateProcessProjection), bufferedPaths_(bufferedPaths), next_(MultiPath(), 1.0) {
 
    QL_REQUIRE(bufferedPaths_, "ProjectedBufferedMultiPathGenerator: no buffered paths given (null)");
    QL_REQUIRE(!bufferedPaths_->empty(), "ProjectedBufferedMultiPathGenerator: at least one buffered path required");
 
    QL_REQUIRE(!stateProcessProjection.empty(),
               "ProjectedBufferedMultiPathGenerator: state process projection is empty");
 
    maxTargetIndex_ = *std::max_element(stateProcessProjection.begin(), stateProcessProjection.end());
 
    reset();
}

Here is the call graph for this function:

Member Function Documentation

◆ next()

const Sample< MultiPath > & next ( ) const

overridevirtual

Implements MultiPathGeneratorBase.

Definition at line 39 of file projectedbufferedmultipathgenerator.cpp.

                                                                         {
    QL_REQUIRE(currentPath_ < bufferedPaths_->size(),
               "ProjectedBufferedMultiPathGenerator: run out of paths (" << bufferedPaths_->size() << ")");
 
    QL_REQUIRE((*bufferedPaths_)[currentPath_].size() > maxTargetIndex_,
               "ProjectedBufferedMultiPathGenerator: buffered path at sample "
                   << currentPath_ << " has insufficient dimension (" << (*bufferedPaths_)[currentPath_].size()
                   << "), need " << (maxTargetIndex_ + 1));
 
    std::vector<Path> tmp;
    for (Size d = 0; d < stateProcessProjection_.size(); ++d) {
        tmp.push_back((*bufferedPaths_)[currentPath_][stateProcessProjection_[d]]);
    }
 
    ++currentPath_;
    next_.value = MultiPath(tmp);
    return next_;
}