#include <qle/indexes/fxindex.hpp>

Inheritance diagram for FxIndex:

Collaboration diagram for FxIndex:

Public Member Functions
	FxIndex (const std::string &familyName, Natural fixingDays, const Currency &source, const Currency &target, const Calendar &fixingCalendar, const Handle< YieldTermStructure > &sourceYts=Handle< YieldTermStructure >(), const Handle< YieldTermStructure > &targetYts=Handle< YieldTermStructure >(), bool fixingTriangulation=false)

	FxIndex (const std::string &familyName, Natural fixingDays, const Currency &source, const Currency &target, const Calendar &fixingCalendar, const Handle< Quote > fxSpot, const Handle< YieldTermStructure > &sourceYts=Handle< YieldTermStructure >(), const Handle< YieldTermStructure > &targetYts=Handle< YieldTermStructure >(), bool fixingTriangulation=true)

Index interface
std::string	name () const override

Calendar	fixingCalendar () const override

bool	isValidFixingDate (const Date &fixingDate) const override

Real	fixing (const Date &fixingDate, bool forecastTodaysFixing=false) const override

Observer interface
void	update () override

Inspectors
std::string	familyName () const

std::string	oreName () const

Natural	fixingDays () const

Date	fixingDate (const Date &valueDate) const

const Currency &	sourceCurrency () const

const Currency &	targetCurrency () const

const Handle< YieldTermStructure > &	sourceCurve () const

const Handle< YieldTermStructure > &	targetCurve () const

const Handle< Quote >	fxQuote (bool withSettlementLag=false) const
	fxQuote returns instantaneous Quote by default, otherwise settlement after fixingDays More...

const bool	useQuote () const

Date calculations
virtual Date	valueDate (const Date &fixingDate) const

Public Member Functions inherited from EqFxIndexBase
virtual	~EqFxIndexBase ()

virtual Real	forecastFixing (const Time &fixingTime) const =0
	returns the fixing at the given time More...

virtual Real	pastFixing (const Date &fixingDate) const =0
	returns a past fixing at the given date More...

Fixing calculations
std::string	familyName_

std::string	oreName_

Natural	fixingDays_

Currency	sourceCurrency_

Currency	targetCurrency_

const Handle< YieldTermStructure >	sourceYts_

const Handle< YieldTermStructure >	targetYts_

std::string	name_

const Handle< Quote >	fxSpot_

Handle< Quote >	fxRate_

bool	useQuote_

Calendar	fixingCalendar_

bool	fixingTriangulation_

virtual Real	forecastFixing (const Time &fixingTime) const override
	It can be overridden to implement particular conventions. More...

virtual Real	forecastFixing (const Date &fixingDate) const

Real	pastFixing (const Date &fixingDate) const override
	returns a past fixing at the given date More...

QuantLib::ext::shared_ptr< FxIndex >	clone (const Handle< Quote > fxQuote=Handle< Quote >(), const Handle< YieldTermStructure > &sourceYts=Handle< YieldTermStructure >(), const Handle< YieldTermStructure > &targetYts=Handle< YieldTermStructure >(), const std::string &familyName=std::string())
	clone the index, the clone will be linked to the provided handles More...

void	initialise ()

Detailed Description

FX Index.

Definition at line 94 of file fxindex.hpp.

Constructor & Destructor Documentation

◆ FxIndex() [1/2]

FxIndex	(	const std::string &	familyName,
		Natural	fixingDays,
		const Currency &	source,
		const Currency &	target,
		const Calendar &	fixingCalendar,
		const Handle< YieldTermStructure > &	sourceYts = `Handle<YieldTermStructure>()`,
		const Handle< YieldTermStructure > &	targetYts = `Handle<YieldTermStructure>()`,
		bool	fixingTriangulation = `false`
	)

familyName may be e.g. ECB fixingDays determine the spot date of the currency pair source is the asset or foreign currency target is the numeraire or domestic currency fixingCalendar is the calendar defining good days for the pair this class uses the exchange rate manager to retrieve spot values fxSpot is the fx rate settled at today + fixingDays

Definition at line 101 of file fxindex.cpp.

    : familyName_(familyName), fixingDays_(fixingDays), sourceCurrency_(source), targetCurrency_(target),
      sourceYts_(sourceYts), targetYts_(targetYts), useQuote_(false), fixingCalendar_(fixingCalendar),
      fixingTriangulation_(fixingTriangulation) {
 
    initialise();
}

Here is the call graph for this function:

◆ FxIndex() [2/2]

FxIndex	(	const std::string &	familyName,
		Natural	fixingDays,
		const Currency &	source,
		const Currency &	target,
		const Calendar &	fixingCalendar,
		const Handle< Quote >	fxSpot,
		const Handle< YieldTermStructure > &	sourceYts = `Handle<YieldTermStructure>()`,
		const Handle< YieldTermStructure > &	targetYts = `Handle<YieldTermStructure>()`,
		bool	fixingTriangulation = `true`
	)

Definition at line 111 of file fxindex.cpp.

    : familyName_(familyName), fixingDays_(fixingDays), sourceCurrency_(source), targetCurrency_(target),
      sourceYts_(sourceYts), targetYts_(targetYts), fxSpot_(fxSpot), useQuote_(true), fixingCalendar_(fixingCalendar),
      fixingTriangulation_(fixingTriangulation) {
 
    initialise();
}

Here is the call graph for this function:

Member Function Documentation

◆ name()

std::string name ( ) const

override

Definition at line 267 of file fxindex.cpp.

267{ return name_; }

QuantExt::FxIndex::name_

std::string name_

Definition: fxindex.hpp:159

Here is the caller graph for this function:

◆ fixingCalendar()

Calendar fixingCalendar ( ) const

override

Definition at line 269 of file fxindex.cpp.

269{ return fixingCalendar_; }

Here is the caller graph for this function:

◆ isValidFixingDate()

bool isValidFixingDate ( const Date & fixingDate ) const

override

Definition at line 271 of file fxindex.cpp.

271{ return fixingCalendar().isBusinessDay(d); }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fixing()

Real fixing	(	const Date &	fixingDate,
		bool	forecastTodaysFixing = `false`
	)		const

override

Definition at line 158 of file fxindex.cpp.

                                                                            {
 
    Date adjustedFixingDate = fixingCalendar().adjust(fixingDate, Preceding);
 
    Date today = Settings::instance().evaluationDate();
 
    Real result = Null<Real>();
 
    if (adjustedFixingDate > today || (adjustedFixingDate == today && forecastTodaysFixing))
        result = forecastFixing(adjustedFixingDate);
 
    if (result == Null<Real>()) {
        if (adjustedFixingDate < today || Settings::instance().enforcesTodaysHistoricFixings()) {
            // must have been fixed
            // do not catch exceptions
            result = pastFixing(adjustedFixingDate);
            QL_REQUIRE(result != Null<Real>(), "Missing " << name() << " fixing for " << adjustedFixingDate);
        } else {
            try {
                // might have been fixed
                result = pastFixing(adjustedFixingDate);
            } catch (Error&) {
                ; // fall through and forecast
            }
            if (result == Null<Real>())
                result = forecastFixing(adjustedFixingDate);
        }
    }
 
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update()

void update ( )

override

Definition at line 273 of file fxindex.cpp.

                     {
    fxRate_ = Handle<Quote>();
    notifyObservers();
}

◆ familyName()

std::string familyName ( ) const

Definition at line 125 of file fxindex.hpp.

125{ return familyName_; }

Here is the caller graph for this function:

◆ oreName()

std::string oreName ( ) const

Definition at line 126 of file fxindex.hpp.

126{ return oreName_; }

QuantExt::FxIndex::oreName_

std::string oreName_

Definition: fxindex.hpp:155

◆ fixingDays()

Natural fixingDays ( ) const

Definition at line 127 of file fxindex.hpp.

127{ return fixingDays_; }

◆ fixingDate()

Date fixingDate ( const Date & valueDate ) const

Definition at line 278 of file fxindex.cpp.

                                                    {
    Date fixingDate = fixingCalendar().advance(valueDate, -static_cast<Integer>(fixingDays_), Days);
    return fixingDate;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sourceCurrency()

const Currency & sourceCurrency ( ) const

Definition at line 129 of file fxindex.hpp.

129{ return sourceCurrency_; }

◆ targetCurrency()

const Currency & targetCurrency ( ) const

Definition at line 130 of file fxindex.hpp.

130{ return targetCurrency_; }

◆ sourceCurve()

const Handle< YieldTermStructure > & sourceCurve ( ) const

Definition at line 131 of file fxindex.hpp.

131{ return sourceYts_; }

◆ targetCurve()

const Handle< YieldTermStructure > & targetCurve ( ) const

Definition at line 132 of file fxindex.hpp.

132{ return targetYts_; }

◆ fxQuote()

const Handle< Quote > fxQuote ( bool withSettlementLag = false ) const

fxQuote returns instantaneous Quote by default, otherwise settlement after fixingDays

Definition at line 135 of file fxindex.cpp.

                                                                 {
    Handle<Quote> quote;
    if (withSettlementLag || fixingDays_ == 0)
        quote = fxSpot_;
 
    if (quote.empty()) {
        if (fxRate_.empty()) {
            Handle<Quote> tmpQuote;
            if (!useQuote_)
                tmpQuote = Handle<Quote>(QuantLib::ext::make_shared<SimpleQuote>(
                    ExchangeRateManager::instance().lookup(sourceCurrency_, targetCurrency_).rate()));
            else
                tmpQuote = fxSpot_;
 
            // adjust for spot
            fxRate_ = Handle<Quote>(
                QuantLib::ext::make_shared<FxRateQuote>(tmpQuote, sourceYts_, targetYts_, fixingDays_, fixingCalendar_));
        }
        quote = fxRate_;
    }
    return quote;
}

Here is the caller graph for this function:

◆ useQuote()

const bool useQuote ( ) const

Definition at line 136 of file fxindex.hpp.

136{ return useQuote_; }

◆ valueDate()

Date valueDate ( const Date & fixingDate ) const

virtual

Definition at line 283 of file fxindex.cpp.

                                                    {
    QL_REQUIRE(isValidFixingDate(fixingDate),
               "FxIndex::valueDate(): " << fixingDate << " is not a valid fixing date for " << name()
                                        << " (calendar is " << fixingCalendar().name() << ")");
    return fixingCalendar().advance(fixingDate, fixingDays_, Days);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ forecastFixing() [1/2]

Real forecastFixing ( const Time & fixingTime ) const

overridevirtual

It can be overridden to implement particular conventions.

Implements EqFxIndexBase.

Definition at line 190 of file fxindex.cpp.

                                                         {
    QL_REQUIRE(!sourceYts_.empty() && !targetYts_.empty(),
               "FxIndex::forecastFixing(): null term structure set to this instance of " << name());
 
    // we base the forecast always on the exchange rate (and not on today's fixing)
    Real rate;
    if (!useQuote_) {
        rate = ExchangeRateManager::instance().lookup(sourceCurrency_, targetCurrency_).rate();
    } else {
        QL_REQUIRE(!fxSpot_.empty(), "FxIndex::forecastFixing(): fx quote required for " << name());
        rate = fxSpot_->value();
    }
 
    // TODO: do we need to add this a class variable?
    DayCounter dc = Actual365Fixed();
 
    // to make the spot adjustment we get the time to spot, and also add this to fixing time
    Date refDate = sourceYts_->referenceDate();
    Date spotValueDate = valueDate(fixingCalendar().adjust(refDate));
 
    // time from ref to spot date
    Real spotTime = dc.yearFraction(refDate, spotValueDate);
    Real forwardTime = spotTime + fixingTime;
 
    QL_REQUIRE(forwardTime > 0.0 || close_enough(forwardTime, 0.0),
               "FxIndex::forecastFixing(" << fixingTime << "): forwardTime (" << forwardTime << ") is negative for "
                                          << name());
 
    // compute the forecast applying the usual no arbitrage principle
    Real forward = rate * sourceYts_->discount(forwardTime) * targetYts_->discount(spotTime) /
                   (targetYts_->discount(forwardTime) * sourceYts_->discount(spotTime));
    return forward;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ forecastFixing() [2/2]

Real forecastFixing ( const Date & fixingDate ) const

virtual

Definition at line 224 of file fxindex.cpp.

                                                         {
    QL_REQUIRE(!sourceYts_.empty() && !targetYts_.empty(), "null term structure set to this instance of " << name());
 
    // we base the forecast always on the exchange rate (and not on today's
    // fixing)
    Real rate;
    if (!useQuote_) {
        rate = ExchangeRateManager::instance().lookup(sourceCurrency_, targetCurrency_).rate();
    } else {
        QL_REQUIRE(!fxSpot_.empty(), "FxIndex::forecastFixing(): fx quote required for " << name());
        rate = fxSpot_->value();
    }
 
    // the exchange rate is interpreted as the spot rate w.r.t. the index's
    // settlement date
    Date refValueDate = valueDate(fixingCalendar().adjust(sourceYts_->referenceDate()));
 
    // the fixing is obeying the settlement delay as well
    Date fixingValueDate = valueDate(fixingDate);
 
    // we can assume fixingValueDate >= valueDate
    QL_REQUIRE(fixingValueDate >= refValueDate, "value date for requested fixing as of "
                                                    << fixingDate << " (" << fixingValueDate
                                                    << ") must be greater or equal to today's fixing value date ("
                                                    << refValueDate << ") for " << name());
 
    // compute the forecast applying the usual no arbitrage principle
    Real forward = rate * sourceYts_->discount(fixingValueDate) * targetYts_->discount(refValueDate) /
                   (sourceYts_->discount(refValueDate) * targetYts_->discount(fixingValueDate));
 
    return forward;
}

Here is the call graph for this function:

◆ pastFixing()

Real pastFixing ( const Date & fixingDate ) const

overridevirtual

returns a past fixing at the given date

the date passed as arguments must be the actual calendar date of the fixing; no settlement days must be used.

Implements EqFxIndexBase.

Definition at line 290 of file fxindex.cpp.

                                                     {
    QL_REQUIRE(isValidFixingDate(fixingDate), fixingDate << "FxIndex::pastFixing(): is not a valid fixing date for "
                                                         << name() << " (calendar is " << fixingCalendar().name()
                                                         << ")");
 
    Real fixing = timeSeries()[fixingDate];
    if (fixing != Null<Real>())
        return fixing;
 
    if (fixingTriangulation_) {
        // check reverse
        string revName = familyName_ + " " + targetCurrency_.code() + "/" + sourceCurrency_.code();
        if (IndexManager::instance().hasHistoricalFixing(revName, fixingDate))
            return 1.0 / IndexManager::instance().getHistory(revName)[fixingDate];
 
        // Now we search for a pair of quotes that we can combine to construct the quote required.
        // We only search for a pair of quotes a single step apart.
        //
        // Suppose we want a USDJPY quote and we have EUR based data, there are 4 combinations to
        // consider:
        // EURUSD, EURJPY  => we want EURJPY / EURUSD [Triangulation]
        // EURUSD, JPYEUR  => we want 1 / (EURUSD * JPYEUR) [InverseProduct]
        // USDEUR, EURJPY  => we want USDEUR * EURJPY [Product]
        // USDEUR, JPYEUR  => we want USDEUR / JPYEUR [Triangulation (but in the reverse order)]
        //
        // Loop over the map, look for domestic then use the map to find the other side of the pair.
 
        // Loop over all the possible Indexes
        vector<string> availIndexes = IndexManager::instance().histories();
        for (auto i : availIndexes) {
            if (boost::starts_with(i, familyName_)) {
                // check for a fixing
                Real fixing = IndexManager::instance().getHistory(i)[fixingDate];
                if (fixing != Null<Real>()) {
 
                    Size l = i.size();
                    string keyDomestic = i.substr(l - 7, 3);
                    string keyForeign = i.substr(l - 3);
                    string domestic = sourceCurrency_.code();
                    string foreign = targetCurrency_.code();
 
                    if (domestic == keyDomestic) {
                        // we have domestic, now look for foreign/keyForeign
                        // USDEUR, JPYEUR  => we want USDEUR / JPYEUR [Triangulation (but in the reverse order)]
                        string forName = familyName_ + " " + foreign + "/" + keyForeign;
                        if (IndexManager::instance().hasHistoricalFixing(forName, fixingDate)) {
                            Real forFixing = IndexManager::instance().getHistory(forName)[fixingDate];
                            return fixing / forFixing;
                        }
 
                        // USDEUR, EURJPY  => we want USDEUR * EURJPY [Product]
                        forName = familyName_ + " " + keyForeign + "/" + foreign;
                        if (IndexManager::instance().hasHistoricalFixing(forName, fixingDate)) {
                            Real forFixing = IndexManager::instance().getHistory(forName)[fixingDate];
                            return fixing * forFixing;
                        }
                    }
 
                    if (domestic == keyForeign) {
                        // we have fixing, now look for foreign/keyDomestic
                        // EURUSD, JPYEUR  => we want 1 / (EURUSD * JPYEUR) [InverseProduct]
                        string forName = familyName_ + " " + foreign + "/" + keyDomestic;
                        if (IndexManager::instance().hasHistoricalFixing(forName, fixingDate)) {
                            Real forFixing = IndexManager::instance().getHistory(forName)[fixingDate];
                            return 1 / (fixing * forFixing);
                        }
 
                        // EURUSD, EURJPY  => we want EURJPY / EURUSD [Triangulation]
                        forName = familyName_ + " " + keyDomestic + "/" + foreign;
                        if (IndexManager::instance().hasHistoricalFixing(forName, fixingDate)) {
                            Real forFixing = IndexManager::instance().getHistory(forName)[fixingDate];
                            return forFixing / fixing;
                        }
                    }
                }
            }
        }
    }
    return fixing;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clone()

QuantLib::ext::shared_ptr< FxIndex > clone	(	const Handle< Quote >	fxQuote = `Handle<Quote>()`,
		const Handle< YieldTermStructure > &	sourceYts = `Handle<YieldTermStructure>()`,
		const Handle< YieldTermStructure > &	targetYts = `Handle<YieldTermStructure>()`,
		const std::string &	familyName = `std::string()`
	)

clone the index, the clone will be linked to the provided handles

Definition at line 257 of file fxindex.cpp.

                                                                                                                 {
    Handle<Quote> quote = fxQuote.empty() ? fxSpot_ : fxQuote;
    Handle<YieldTermStructure> source = sourceYts.empty() ? sourceYts_ : sourceYts;
    Handle<YieldTermStructure> target = targetYts.empty() ? targetYts_ : targetYts;
    string famName = familyName.empty() ? familyName_ : familyName;
    return QuantLib::ext::make_shared<FxIndex>(famName, fixingDays_, sourceCurrency_, targetCurrency_, fixingCalendar_, quote,
                                       source, target);
}

Here is the call graph for this function:

◆ initialise()

void initialise ( )

private

Definition at line 122 of file fxindex.cpp.

                         {
    std::ostringstream tmp;
    tmp << familyName_ << " " << sourceCurrency_.code() << "/" << targetCurrency_.code();
    name_ = tmp.str();
 
    oreName_ = "FX-" + familyName_ + "-" + sourceCurrency_.code() + "-" + targetCurrency_.code();
 
    registerWith(IndexManager::instance().notifier(name()));
    registerWith(fxSpot_);
    registerWith(sourceYts_);
    registerWith(targetYts_);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ familyName_

std::string familyName_

protected

Definition at line 155 of file fxindex.hpp.

◆ oreName_

std::string oreName_

protected

Definition at line 155 of file fxindex.hpp.

◆ fixingDays_

Natural fixingDays_

protected

Definition at line 156 of file fxindex.hpp.

◆ sourceCurrency_

Currency sourceCurrency_

protected

Definition at line 157 of file fxindex.hpp.

◆ targetCurrency_

Currency targetCurrency_

protected

Definition at line 157 of file fxindex.hpp.

◆ sourceYts_

const Handle<YieldTermStructure> sourceYts_

protected

Definition at line 158 of file fxindex.hpp.

◆ targetYts_

const Handle<YieldTermStructure> targetYts_

protected

Definition at line 158 of file fxindex.hpp.

◆ name_

std::string name_

protected

Definition at line 159 of file fxindex.hpp.

◆ fxSpot_

const Handle<Quote> fxSpot_

protected

Definition at line 161 of file fxindex.hpp.

◆ fxRate_

Handle<Quote> fxRate_

mutableprotected

Definition at line 163 of file fxindex.hpp.

◆ useQuote_

bool useQuote_

protected

Definition at line 164 of file fxindex.hpp.

◆ fixingCalendar_

Calendar fixingCalendar_

private

Definition at line 167 of file fxindex.hpp.

◆ fixingTriangulation_

bool fixingTriangulation_

private

Definition at line 168 of file fxindex.hpp.

Public Member Functions

Fixing calculations

Detailed Description

Constructor & Destructor Documentation

◆ FxIndex() [1/2]

◆ FxIndex() [2/2]

Member Function Documentation

◆ name()

◆ fixingCalendar()

◆ isValidFixingDate()

◆ fixing()

◆ update()

◆ familyName()

◆ oreName()

◆ fixingDays()

◆ fixingDate()

◆ sourceCurrency()

◆ targetCurrency()

◆ sourceCurve()

◆ targetCurve()

◆ fxQuote()

◆ useQuote()

◆ valueDate()

◆ forecastFixing() [1/2]

◆ forecastFixing() [2/2]

◆ pastFixing()

◆ clone()

◆ initialise()

Member Data Documentation

◆ familyName_

◆ oreName_

◆ fixingDays_

◆ sourceCurrency_

◆ targetCurrency_

◆ sourceYts_

◆ targetYts_

◆ name_

◆ fxSpot_

◆ fxRate_

◆ useQuote_

◆ fixingCalendar_

◆ fixingTriangulation_