FXTriangulation Class Reference

#include <ored/marketdata/fxtriangulation.hpp>

Collaboration diagram for FXTriangulation:

Public Member Functions
	FXTriangulation ()
	FXTriangulation (std::map< std::string, QuantLib::Handle< QuantLib::Quote > > quotes)
QuantLib::Handle< QuantLib::Quote >	getQuote (const std::string &pair) const
QuantLib::Handle< QuantExt::FxIndex >	getIndex (const std::string &indexOrPair, const Market *market, const std::string &configuration) const

Private Member Functions
std::vector< std::string >	getPath (const std::string &forCcy, const std::string &domCcy) const
Handle< Quote >	getQuote (const std::string &forCcy, const std::string &domCcy) const
std::string	getAllQuotes () const

Private Attributes
std::map< std::string, QuantLib::Handle< QuantLib::Quote > >	quotes_
std::map< std::string, QuantLib::Handle< QuantLib::Quote > >	quoteCache_
std::map< std::pair< std::string, std::string >, QuantLib::Handle< QuantExt::FxIndex > >	indexCache_
std::vector< std::string >	nodeToCcy_
std::map< std::string, std::size_t >	ccyToNode_
std::vector< std::set< std::size_t > >	neighbours_

Detailed Description

Definition at line 39 of file fxtriangulation.hpp.

Constructor & Destructor Documentation

FXTriangulation() [1/2]

FXTriangulation

(

)

Set up empty repository

Definition at line 42 of file fxtriangulation.hpp.

{}

FXTriangulation() [2/2]

FXTriangulation ( std::map< std::string, QuantLib::Handle< QuantLib::Quote > >  quotes )

explicit

Set up fx quote repository with available market quotes ccypair => quote

Member Function Documentation

getQuote() [1/2]

Handle< Quote > getQuote

(

const std::string &

pair

)

const

Get quote, possibly via triangulation If you need an exact handling of spot lag differences, use getIndex() instead.

Definition at line 115 of file fxtriangulation.cpp.

                                                                   {
 
    // do we have a cached result?
 
    if (auto it = quoteCache_.find(pair); it != quoteCache_.end())
        return it->second;
 
    // we need to construct the quote from the input quotes
 
    Handle<Quote> result;
    auto [ccy1, ccy2] = splitPair(pair);
 
    // handle trivial case
 
    if (ccy1 == ccy2)
        return Handle<Quote>(QuantLib::ext::make_shared<SimpleQuote>(1.0));
 
    // get the path from ccy1 to ccy2
 
    auto path = getPath(ccy1, ccy2);
 
    if (path.size() == 2) {
 
        // we can use a direct or inverted quote, but do not need a composite
 
        result = getQuote(path[0], path[1]);
 
    } else {
 
        // we need a composite quote
 
        std::vector<Handle<Quote>> quotes;
 
        // collect the quotes on the path and check consistency of the settlement dates
 
        for (Size i = 0; i < path.size() - 1; ++i) {
            quotes.push_back(getQuote(path[i], path[i + 1]));
        }
 
        // build the composite quote
 
        auto f = [](const std::vector<Real>& quotes) {
            return std::accumulate(quotes.begin(), quotes.end(), 1.0, std::multiplies());
        };
        result = Handle<Quote>(QuantLib::ext::make_shared<CompositeVectorQuote<decltype(f)>>(quotes, f));
    }
 
    // add the result to the lookup cache and return it
 
    quoteCache_[pair] = result;
    return result;
}

Here is the caller graph for this function:

getIndex()

Handle< FxIndex > getIndex	(	const std::string &	indexOrPair,
		const Market *	market,
		const std::string &	configuration
	)		const

Get fx index, possibly via triangulation. The index name can be of the form FX-TAG-CCY1-CCY2 or also be just a currency pair CCY1CCY2. In the latter case, the fixing source is set to TAG = GENERIC. The fx index requires discount curves from a market. The assumption is that the market provides discount curves consistent with cross-currency discounting under the specified configuration. If the triangulation is not possible or required curves are not available an exception is thrown.

Definition at line 168 of file fxtriangulation.cpp.

                                                                                {
 
    // do we have a cached result?
 
    if (auto it = indexCache_.find(std::make_pair(indexOrPair, configuration)); it != indexCache_.end()) {
        return it->second;
    }
 
    // otherwise we need to construct the index
 
    Handle<FxIndex> result;
 
    std::string familyName;
    std::string forCcy;
    std::string domCcy;
 
    if (isFxIndex(indexOrPair)) {
        auto ind = parseFxIndex(indexOrPair);
        familyName = ind->familyName();
        forCcy = ind->sourceCurrency().code();
        domCcy = ind->targetCurrency().code();
    } else {
        familyName = "GENERIC";
        std::tie(forCcy, domCcy) = splitPair(indexOrPair);
    }
 
    // get the conventions of the result index
 
    auto [fixingDays, fixingCalendar, bdc] = getFxIndexConventions(indexOrPair);
 
    // get the discount curves for the result index
 
    auto sourceYts = getMarketDiscountCurve(market, forCcy, configuration);
    auto targetYts = getMarketDiscountCurve(market, domCcy, configuration);
 
    // get the path from ccy1 to ccy2
 
    auto path = getPath(forCcy, domCcy);
 
    if (path.size() == 2) {
 
        // we can use a direct or inverted quote, but do not need a composite
 
        auto fxSpot = getQuote(path[0], path[1]);
        result = Handle<FxIndex>(QuantLib::ext::make_shared<FxIndex>(familyName, fixingDays, parseCurrency(forCcy),
                                                             parseCurrency(domCcy), fixingCalendar, fxSpot, sourceYts,
                                                             targetYts));
 
    } else {
 
        // we need a composite quote
 
        std::vector<Handle<Quote>> quotes;
 
        // collect the quotes on the path and store them as FxRate quotes ("as of today" - quotes)
 
        for (Size i = 0; i < path.size() - 1; ++i) {
 
            auto q = getQuote(path[i], path[i + 1]);
 
            // we store a quote "as of today" to account for possible spot lag differences
 
            auto [fd, fc, bdc] = getFxIndexConventions(path[i] + path[i + 1]);
            auto s_yts = getMarketDiscountCurve(market, path[i], configuration);
            auto t_yts = getMarketDiscountCurve(market, path[i + 1], configuration);
            quotes.push_back(Handle<Quote>(QuantLib::ext::make_shared<FxRateQuote>(q, s_yts, t_yts, fd, fc)));
        }
 
        // build the composite quote "as of today"
 
        auto f = [](const std::vector<Real>& quotes) {
            return std::accumulate(quotes.begin(), quotes.end(), 1.0, std::multiplies());
        };
        Handle<Quote> compQuote(QuantLib::ext::make_shared<CompositeVectorQuote<decltype(f)>>(quotes, f));
 
        // build the spot quote
 
        Handle<Quote> spotQuote(
            QuantLib::ext::make_shared<FxSpotQuote>(compQuote, sourceYts, targetYts, fixingDays, fixingCalendar));
 
        // build the idnex
 
        result = Handle<FxIndex>(QuantLib::ext::make_shared<FxIndex>(familyName, fixingDays, parseCurrency(forCcy),
                                                             parseCurrency(domCcy), fixingCalendar, spotQuote,
                                                             sourceYts, targetYts));
    }
 
    // add the result to the lookup cache and return it
 
    indexCache_[std::make_pair(indexOrPair, configuration)] = result;
    return result;
}

Here is the call graph for this function:

getPath()

std::vector< std::string > getPath ( const std::string &  forCcy, const std::string &  domCcy  ) const

private

Definition at line 262 of file fxtriangulation.cpp.

                                                                                                    {
 
    // see https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm
 
    Size sourceNode, targetNode;
 
    if (auto it = ccyToNode_.find(forCcy); it != ccyToNode_.end()) {
        sourceNode = it->second;
    } else {
        QL_FAIL("FXTriangulation: no conversion from '"
                << forCcy << "' to '" << domCcy << "' possible, since '" << forCcy
                << "' is not available as one of the currencies in any of the quotes (" << getAllQuotes() << ")");
    }
 
    if (auto it = ccyToNode_.find(domCcy); it != ccyToNode_.end()) {
        targetNode = it->second;
    } else {
        QL_FAIL("FXTriangulation: no conversion from '"
                << forCcy << "' to '" << domCcy << "' possible, since '" << domCcy
                << "' is not available as one of the currencies in any of the quotes (" << getAllQuotes() << ")");
    }
 
    // previous node on the current shortest path
    std::vector<Size> prev(nodeToCcy_.size(), Null<Size>());
    // distance per node
    std::vector<Size> dist(nodeToCcy_.size(), std::numeric_limits<Size>::max());
    // visited flag
    std::vector<bool> visited(nodeToCcy_.size(), false);
 
    // init source
    dist[sourceNode] = 0;
 
    // main loop
    Size noVisited = 0;
    while (noVisited < nodeToCcy_.size()) {
        Size u = Null<Size>(), min = std::numeric_limits<Size>::max();
        for (Size i = 0; i < dist.size(); ++i) {
            if (!visited[i] && dist[i] < min) {
                u = i;
                min = dist[i];
            }
        }
        QL_REQUIRE(u != Null<Size>(), "FXTriangulation: internal error, no minimum found in dist array for '"
                                          << forCcy << "' to '" << domCcy << "'. Quotes = " << getAllQuotes());
        if (u == targetNode)
            break;
        visited[u] = true;
        ++noVisited;
        for (auto const& n : neighbours_[u]) {
            if (visited[n])
                continue;
            Size alt = dist[u] + 1;
            if (alt < dist[n]) {
                dist[n] = alt;
                prev[n] = u;
            }
        }
    }
 
    // did we find a path?
    if (dist[targetNode] < std::numeric_limits<Size>::max()) {
        std::vector<std::string> result;
        Size u = targetNode;
        while (u != sourceNode) {
            result.insert(result.begin(), nodeToCcy_[u]);
            u = prev[u];
            QL_REQUIRE(u != Null<Size>(), "FXTriangulation: internal error u == null for '"
                                              << forCcy << "' to '" << domCcy
                                              << "'. Contact dev. Quotes = " << getAllQuotes() << ".");
        }
        result.insert(result.begin(), nodeToCcy_[sourceNode]);
        TLOG("FXTriangulation: found path of length "
             << result.size() - 1 << " from '" << forCcy << "' to '" << domCcy << "': "
             << std::accumulate(
                    result.begin(), result.end(), std::string(),
                    [](const std::string& s1, const std::string& s2) { return s1.empty() ? s2 : s1 + "-" + s2; }));
        return result;
    }
 
    QL_FAIL("FXTriangulation: no path from '" << forCcy << "' to '" << domCcy
                                              << "' found. Quotes = " << getAllQuotes());
}

Here is the call graph for this function:

getQuote() [2/2]

Handle< Quote > getQuote ( const std::string &  forCcy, const std::string &  domCcy  ) const

private

Definition at line 345 of file fxtriangulation.cpp.

                                                                                              {
    if (auto it = quotes_.find(forCcy + domCcy); it != quotes_.end()) {
        return it->second;
    }
    if (auto it = quotes_.find(domCcy + forCcy); it != quotes_.end()) {
        auto f = [](Real x) { return 1.0 / x; };
        return Handle<Quote>(QuantLib::ext::make_shared<DerivedQuote<decltype(f)>>(it->second, f));
    }
    QL_FAIL(
        "FXTriangulation::getQuote(" << forCcy << domCcy
                                     << ") - no such quote available. This is an internal error. Contact dev. Quotes = "
                                     << getAllQuotes());
}

getAllQuotes()

std::string getAllQuotes ( ) const

private

Definition at line 359 of file fxtriangulation.cpp.

                                              {
    std::string result;
    if (quotes_.size() > 0) {
        for (auto const& d : quotes_) {
            result += d.first + ",";
        }
        result.erase(std::next(result.end(), -1));
    }
    return result;
}

Member Data Documentation

quotes_

std::map<std::string, QuantLib::Handle<QuantLib::Quote> > quotes_

private

Definition at line 73 of file fxtriangulation.hpp.

quoteCache_

std::map<std::string, QuantLib::Handle<QuantLib::Quote> > quoteCache_

mutableprivate

Definition at line 76 of file fxtriangulation.hpp.

indexCache_

std::map<std::pair<std::string, std::string>, QuantLib::Handle<QuantExt::FxIndex> > indexCache_

mutableprivate

Definition at line 77 of file fxtriangulation.hpp.

nodeToCcy_

std::vector<std::string> nodeToCcy_

private

Definition at line 80 of file fxtriangulation.hpp.

ccyToNode_

std::map<std::string, std::size_t> ccyToNode_

private

Definition at line 81 of file fxtriangulation.hpp.

neighbours_

std::vector<std::set<std::size_t> > neighbours_

private

Definition at line 82 of file fxtriangulation.hpp.