Beispiel #1
0
LongstaffSchwartzExerciseStrategy::LongstaffSchwartzExerciseStrategy(
    const Clone<MarketModelBasisSystem>& basisSystem,
    const std::vector<std::vector<Real> >& basisCoefficients,
    const EvolutionDescription& evolution,
    const std::vector<Size>& numeraires,
    const Clone<MarketModelExerciseValue>& exercise,
    const Clone<MarketModelExerciseValue>& control)
    : basisSystem_(basisSystem), basisCoefficients_(basisCoefficients),
      exercise_(exercise), control_(control),
      numeraires_(numeraires) {

    checkCompatibility(evolution, numeraires);
    relevantTimes_ = evolution.evolutionTimes();

    isBasisTime_.resize(relevantTimes_.size());
    isBasisTime_ = isInSubset(relevantTimes_,
                              basisSystem_->evolution().evolutionTimes());
    isRebateTime_.resize(relevantTimes_.size());
    isRebateTime_ = isInSubset(relevantTimes_,
                               exercise_->evolution().evolutionTimes());
    isControlTime_.resize(relevantTimes_.size());
    isControlTime_ = isInSubset(relevantTimes_,
                                control_->evolution().evolutionTimes());

    exerciseIndex_ = std::vector<Size>(relevantTimes_.size());
    isExerciseTime_.resize(relevantTimes_.size(), false);
    std::valarray<bool> v = exercise_->isExerciseTime();
    Size exercises = 0, idx = 0;
    Size i;
    for (i=0; i<relevantTimes_.size(); ++i) {
        exerciseIndex_[i] = exercises;
        if (isRebateTime_[i]) {
            isExerciseTime_[i] = v[idx++];
            if (isExerciseTime_[i]) {
                exerciseTimes_.push_back(relevantTimes_[i]);
                ++exercises;
            }
        }
    }

    std::vector<Time> rateTimes = evolution.rateTimes();
    std::vector<Time> rebateTimes = exercise_->possibleCashFlowTimes();
    rebateDiscounters_.reserve(rebateTimes.size());
    for (i=0; i<rebateTimes.size(); ++i)
        rebateDiscounters_.push_back(
            MarketModelDiscounter(rebateTimes[i], rateTimes));

    std::vector<Time> controlTimes = control_->possibleCashFlowTimes();
    controlDiscounters_.reserve(controlTimes.size());
    for (i=0; i<controlTimes.size(); ++i)
        controlDiscounters_.push_back(
            MarketModelDiscounter(controlTimes[i], rateTimes));

    std::vector<Size> basisSizes = basisSystem_->numberOfFunctions();
    basisValues_.resize(basisSystem_->numberOfExercises());
    for (i=0; i<basisValues_.size(); ++i)
        basisValues_[i].resize(basisSizes[i]);
}
ProxyGreekEngine::ProxyGreekEngine(
    const boost::shared_ptr<MarketModelEvolver>& evolver,
    const std::vector<
    std::vector<boost::shared_ptr<ConstrainedEvolver> > >&
    constrainedEvolvers,
    const std::vector<std::vector<std::vector<Real> > >& diffWeights,
    const std::vector<Size>& startIndexOfConstraint,
    const std::vector<Size>& endIndexOfConstraint,
    const Clone<MarketModelMultiProduct>& product,
    Real initialNumeraireValue)
    : originalEvolver_(evolver), constrainedEvolvers_(constrainedEvolvers),
      diffWeights_(diffWeights),
      startIndexOfConstraint_(startIndexOfConstraint),
      endIndexOfConstraint_(endIndexOfConstraint),
      product_(product),
      initialNumeraireValue_(initialNumeraireValue),
      numberProducts_(product->numberOfProducts()),
      numerairesHeld_(product->numberOfProducts()),
      numberCashFlowsThisStep_(product->numberOfProducts()),
      cashFlowsGenerated_(product->numberOfProducts()) {
    for (Size i=0; i<numberProducts_; ++i)
        cashFlowsGenerated_[i].resize(
            product_->maxNumberOfCashFlowsPerProductPerStep());

    const std::vector<Time>& cashFlowTimes =
        product_->possibleCashFlowTimes();
    const std::vector<Rate>& rateTimes = product_->evolution().rateTimes();
    Size n = cashFlowTimes.size();
    discounters_.reserve(n);
    for (Size j=0; j<n; ++j)
        discounters_.push_back(MarketModelDiscounter(cashFlowTimes[j],
                               rateTimes));
    const std::vector<Rate>& evolutionTimes =
        product_->evolution().evolutionTimes();
    constraints_.resize(evolutionTimes.size());
    constraintsActive_.resize(evolutionTimes.size());
}
Beispiel #3
0
    void collectNodeData(MarketModelEvolver& evolver,
                         MarketModelMultiProduct& product,
                         MarketModelNodeDataProvider& dataProvider,
                         MarketModelExerciseValue& rebate,
                         MarketModelExerciseValue& control,
                         Size numberOfPaths,
                         std::vector<std::vector<NodeData> >& collectedData) {

        std::vector<Real> numerairesHeld;

        QL_REQUIRE(product.numberOfProducts() == 1,
                   "a single product is required");

        // TODO: check that all objects have compatible evolutions
        // (same rate times; evolution times for product, basis
        // system, rebate and control must be subsets of the passed
        // evolution times; rebate, control and basis system must have
        // the same exercise---not evolution---times)

        std::vector<Size> numberCashFlowsThisStep(1);
        std::vector<std::vector<CashFlow> > cashFlowsGenerated(1);
        cashFlowsGenerated[0].resize(
                           product.maxNumberOfCashFlowsPerProductPerStep());


        std::vector<Time> rateTimes = product.evolution().rateTimes();

        std::vector<Time> cashFlowTimes = product.possibleCashFlowTimes();
        std::vector<Time> rebateTimes = rebate.possibleCashFlowTimes();
        std::vector<Time> controlTimes = control.possibleCashFlowTimes();

        Size i, n;

        n = cashFlowTimes.size();
        std::vector<MarketModelDiscounter> productDiscounters;
        productDiscounters.reserve(n);
        for (i=0; i<n; ++i)
            productDiscounters.push_back(
                                     MarketModelDiscounter(cashFlowTimes[i],
                                                           rateTimes));

        n = rebateTimes.size();
        std::vector<MarketModelDiscounter> rebateDiscounters;
        rebateDiscounters.reserve(n);
        for (i=0; i<n; ++i)
            rebateDiscounters.push_back(
                                     MarketModelDiscounter(rebateTimes[i],
                                                           rateTimes));
        n = controlTimes.size();
        std::vector<MarketModelDiscounter> controlDiscounters;
        controlDiscounters.reserve(n);
        for (i=0; i<n; ++i)
            controlDiscounters.push_back(
                                     MarketModelDiscounter(controlTimes[i],
                                                           rateTimes));

        EvolutionDescription evolution = product.evolution();
        const std::vector<Size>& numeraires = evolver.numeraires();

        std::vector<Time> evolutionTimes = evolution.evolutionTimes();

        std::valarray<bool> isProductTime =
            isInSubset(evolutionTimes,
                       product.evolution().evolutionTimes());
        std::valarray<bool> isRebateTime =
            isInSubset(evolutionTimes,
                       rebate.evolution().evolutionTimes());
        std::valarray<bool> isControlTime =
            isInSubset(evolutionTimes,
                       control.evolution().evolutionTimes());
        std::valarray<bool> isBasisTime =
            isInSubset(evolutionTimes,
                       dataProvider.evolution().evolutionTimes());
        std::valarray<bool> isExerciseTime(false,evolutionTimes.size());
        std::valarray<bool> v = rebate.isExerciseTime();
        Size exercises = 0;
        for (i=0; i<evolutionTimes.size(); ++i) {
            if (isRebateTime[i]) {
                isExerciseTime[i] = v[exercises];
                ++exercises;
            }
        }

        collectedData.resize(exercises+1);
        for (i=0; i<collectedData.size(); ++i)
            collectedData[i].resize(numberOfPaths);


        for (i=0; i<numberOfPaths; ++i) {
            evolver.startNewPath();
            product.reset();
            rebate.reset();
            control.reset();
            dataProvider.reset();
            Real principalInNumerairePortfolio = 1.0;

            bool done = false;
            Size nextExercise = 0;
            collectedData[0][i].cumulatedCashFlows = 0.0;
            do {
                Size currentStep = evolver.currentStep();
                evolver.advanceStep();
                const CurveState& currentState = evolver.currentState();
                Size numeraire = numeraires[currentStep];

                if (isRebateTime[currentStep])
                    rebate.nextStep(currentState);
                if (isControlTime[currentStep])
                    control.nextStep(currentState);
                if (isBasisTime[currentStep])
                    dataProvider.nextStep(currentState);

                if (isExerciseTime[currentStep]) {
                    NodeData& data = collectedData[nextExercise+1][i];

                    CashFlow exerciseValue = rebate.value(currentState);
                    data.exerciseValue =
                        exerciseValue.amount *
                        rebateDiscounters[exerciseValue.timeIndex]
                           .numeraireBonds(currentState, numeraire) /
                        principalInNumerairePortfolio;

                    dataProvider.values(currentState,
                                        data.values);

                    CashFlow controlValue = control.value(currentState);
                    data.controlValue =
                        controlValue.amount *
                        controlDiscounters[controlValue.timeIndex]
                           .numeraireBonds(currentState, numeraire) /
                        principalInNumerairePortfolio;

                    data.cumulatedCashFlows = 0.0;

                    data.isValid = true;

                    ++nextExercise;
                }

                if (isProductTime[currentStep]) {
                    done = product.nextTimeStep(currentState,
                                                numberCashFlowsThisStep,
                                                cashFlowsGenerated);

                    for (Size j=0; j<numberCashFlowsThisStep[0]; ++j) {
                        const CashFlow& cf = cashFlowsGenerated[0][j];
                        collectedData[nextExercise][i].cumulatedCashFlows +=
                            cf.amount *
                            productDiscounters[cf.timeIndex]
                                .numeraireBonds(currentState, numeraire) /
                            principalInNumerairePortfolio;
                    }
                }

                if (!done) {
                    Size nextNumeraire = numeraires[currentStep+1];
                    principalInNumerairePortfolio *=
                        currentState.discountRatio(numeraire,
                                                   nextNumeraire);
                }
            }
            while (!done);

            // fill the remaining (un)collected data with nulls
            for (Size j = nextExercise; j < exercises; ++j) {
                NodeData& data = collectedData[j+1][i];
                data.exerciseValue = data.controlValue = 0.0;
                data.cumulatedCashFlows = 0.0;
                data.isValid = false;
            }
        }
    }