#include <qle/methods/projectedvariatemultipathgenerator.hpp>

Inheritance diagram for ProjectedVariateMultiPathGenerator:

Collaboration diagram for ProjectedVariateMultiPathGenerator:

Public Member Functions
	ProjectedVariateMultiPathGenerator (const QuantLib::ext::shared_ptr< StochasticProcess > &process, const TimeGrid &timeGrid, const std::vector< Size > &stateProcessProjection, const QuantLib::ext::shared_ptr< MultiPathVariateGeneratorBase > &variateGenerator)

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 QuantLib::ext::shared_ptr< StochasticProcess >	process_

const TimeGrid	timeGrid_

const std::vector< Size >	stateProcessProjection_

const QuantLib::ext::shared_ptr< MultiPathVariateGeneratorBase >	variateGenerator_

Size	maxTargetIndex_

Sample< MultiPath >	next_

Detailed Description

Definition at line 32 of file projectedvariatemultipathgenerator.hpp.

Constructor & Destructor Documentation

◆ ProjectedVariateMultiPathGenerator()

ProjectedVariateMultiPathGenerator	(	const QuantLib::ext::shared_ptr< StochasticProcess > &	process,
		const TimeGrid &	timeGrid,
		const std::vector< Size > &	stateProcessProjection,
		const QuantLib::ext::shared_ptr< MultiPathVariateGeneratorBase > &	variateGenerator
	)

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 projectedvariatemultipathgenerator.cpp.

    : process_(process), timeGrid_(timeGrid), stateProcessProjection_(stateProcessProjection),
      variateGenerator_(variateGenerator), next_(MultiPath(process->size(), timeGrid), 1.0) {
 
    for (Size s = 0; s < process_->size(); ++s)
        next_.value[s][0] = process_->initialValues()[s];
 
    QL_REQUIRE(stateProcessProjection.size() == process->factors(),
               "ProjectedVariateMultiPathGenerator: state process projection source size ("
                   << stateProcessProjection.size() << ") does not match process factors (" << process->factors());
    QL_REQUIRE(!stateProcessProjection.empty(),
               "ProjectedVariateMultiPathGenerator: state process projection is empty");
 
    maxTargetIndex_ = *std::max_element(stateProcessProjection.begin(), stateProcessProjection.end());
}

Member Function Documentation

◆ next()

const Sample< MultiPath > & next ( ) const

overridevirtual

Implements MultiPathGeneratorBase.

Definition at line 42 of file projectedvariatemultipathgenerator.cpp.

                                                                        {
 
    Sample<std::vector<Array>> v = variateGenerator_->next();
    next_.weight = v.weight;
 
    QL_REQUIRE(v.value.size() == timeGrid_.size() - 1,
               "ProjectedVariateMultiPathGenerator::next(): variate generator returns "
                   << v.value.size() << " variates for " << (timeGrid_.size() - 1) << " time steps to evolve");
 
    QL_REQUIRE(v.value.size() == 0 || maxTargetIndex_ < v.value.front().size(),
               "ProjectedVariateMultiPathGenerator::next(): variate generator returns variate of size "
                   << v.value.front().size() << ", this is required to be > max target index (" << maxTargetIndex_
                   << ")");
 
    Size dim = process_->factors();
    Size stateSize = process_->size();
 
    Array dw(dim, 0.0);
    Array state = process_->initialValues();
    for (Size i = 0; i < timeGrid_.size() - 1; ++i) {
        for (Size d = 0; d < dim; ++d)
            dw[d] = v.value[i][stateProcessProjection_[d]];
        state = process_->evolve(timeGrid_[i], state, timeGrid_.dt(i), dw);
        for (Size s = 0; s < stateSize; ++s)
            next_.value[s][i + 1] = state[s];
    }
    return next_;
}