RandomVariableLsmBasisSystem Class Reference

#include <qle/math/randomvariablelsmbasissystem.hpp>

Collaboration diagram for RandomVariableLsmBasisSystem:

Static Public Member Functions
static std::vector< std::function< RandomVariable(const RandomVariable &)> >	pathBasisSystem (Size order, QuantLib::LsmBasisSystem::PolynomialType type)
static std::vector< std::function< RandomVariable(const std::vector< const RandomVariable * > &)> >	multiPathBasisSystem (Size dim, Size order, QuantLib::LsmBasisSystem::PolynomialType type)
static Real	size (Size dim, Size order)

Detailed Description

Definition at line 34 of file randomvariablelsmbasissystem.hpp.

Member Function Documentation

pathBasisSystem()

VF_R pathBasisSystem ( Size  order, QuantLib::LsmBasisSystem::PolynomialType  type  )

static

Definition at line 141 of file randomvariablelsmbasissystem.cpp.

                                                                                                        {
    VF_R ret(order + 1);
    for (Size i = 0; i <= order; ++i) {
        switch (type) {
        case QuantLib::LsmBasisSystem::Monomial:
            ret[i] = MonomialFct(i);
            break;
        case QuantLib::LsmBasisSystem::Laguerre: {
            GaussLaguerrePolynomial p;
            ret[i] = [=](RandomVariable x) {
                for (std::size_t i = 0; i < x.size(); ++i) {
                    x.set(i, p.weightedValue(i, x[i]));
                }
                return x;
            };
        } break;
        case QuantLib::LsmBasisSystem::Hermite: {
            GaussHermitePolynomial p;
            ret[i] = [=](RandomVariable x) {
                for (std::size_t i = 0; i < x.size(); ++i) {
                    x.set(i, p.weightedValue(i, x[i]));
                }
                return x;
            };
        } break;
        case QuantLib::LsmBasisSystem::Hyperbolic: {
            GaussHyperbolicPolynomial p;
            ret[i] = [=](RandomVariable x) {
                for (std::size_t i = 0; i < x.size(); ++i) {
                    x.set(i, p.weightedValue(i, x[i]));
                }
                return x;
            };
        } break;
        case QuantLib::LsmBasisSystem::Legendre: {
            GaussLegendrePolynomial p;
            ret[i] = [=](RandomVariable x) {
                for (std::size_t i = 0; i < x.size(); ++i) {
                    x.set(i, p.weightedValue(i, x[i]));
                }
                return x;
            };
        } break;
        case QuantLib::LsmBasisSystem::Chebyshev: {
            GaussChebyshevPolynomial p;
            ret[i] = [=](RandomVariable x) {
                for (std::size_t i = 0; i < x.size(); ++i) {
                    x.set(i, p.weightedValue(i, x[i]));
                }
                return x;
            };
        } break;
        case QuantLib::LsmBasisSystem::Chebyshev2nd: {
            GaussChebyshev2ndPolynomial p;
            ret[i] = [=](RandomVariable x) {
                for (std::size_t i = 0; i < x.size(); ++i) {
                    x.set(i, p.weightedValue(i, x[i]));
                }
                return x;
            };
        } break;
        default:
            QL_FAIL("unknown regression type");
        }
    }
    return ret;
}

Here is the caller graph for this function:

multiPathBasisSystem()

VF_A multiPathBasisSystem ( Size  dim, Size  order, QuantLib::LsmBasisSystem::PolynomialType  type  )

static

Definition at line 209 of file randomvariablelsmbasissystem.cpp.

                                                                                                   {
    QL_REQUIRE(dim > 0, "zero dimension");
    // get single factor basis
    VF_R pathBasis = pathBasisSystem(order, type);
    VF_A ret;
    // 0-th order term
    VF_R term(dim, pathBasis[0]);
    ret.push_back(MultiDimFct(term));
    // start with all 0 tuple
    VV tuples(1, std::vector<Size>(dim));
    // add multi-factor terms
    for (Size i = 1; i <= order; ++i) {
        tuples = next_order_tuples(tuples);
        // now we have all tuples of order i
        // for each tuple add the corresponding term
        for (Size j = 0; j < tuples.size(); ++j) {
            for (Size k = 0; k < dim; ++k)
                term[k] = pathBasis[tuples[j][k]];
            ret.push_back(MultiDimFct(term));
        }
    }
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

size()

Real size ( Size  dim, Size  order  )

static

Definition at line 234 of file randomvariablelsmbasissystem.cpp.

                                                            {
    // see e.g. proposition 3 in https://murphmath.wordpress.com/2012/08/22/counting-monomials/
    return boost::math::binomial_coefficient<Real>(
        dim + order, order,
        boost::math::policies::make_policy(
            boost::math::policies::overflow_error<boost::math::policies::ignore_error>()));
}

Here is the caller graph for this function: