Utilities

Files
file	calendaradjustmentconfig.hpp
	Interface for calendar modifications, additional holidays and business days.
file	iborfallbackconfig.hpp
	ibor fallback configuration
file	blackscholesmodelbuilder.hpp
	builder for an array of black scholes processes
file	blackscholesmodelbuilderbase.hpp
	builder for an array of black scholes processes
file	calibrationpointcache.hpp
	cache for relevant points on curve / vol surfaces
file	localvolmodelbuilder.hpp
	builder for an array of local vol processes
file	commodityapomodelbuilder.hpp
	model builder for commodityapos
file	ast.hpp
	abstract syntax tree for payoff scripting
file	astprinter.hpp
	ast printer
file	asttoscriptconverter.hpp
	ast to script converter
file	computationgraphbuilder.hpp
	computation graph builder
file	context.hpp
	script engine context holding variable names and values
file	grammar.hpp
	payoff script grammar
file	amcmodel.hpp
	additional interface for amc enabled models
file	blackscholes.hpp
	black scholes model for n underlyings (fx, equity or commodity)
file	blackscholesbase.hpp
	black scholes model base class for n underlyings (fx, equity or commodity)
file	blackscholescg.hpp
	black scholes model for n underlyings (fx, equity or commodity)
file	blackscholescgbase.hpp
	black scholes model base class for n underlyings (fx, equity or commodity)
file	dummymodel.hpp
	dummy model implementation
file	fdgaussiancam.hpp
	fd gaussian cross asset model for single underlying ir model
file	gaussiancam.hpp
	gaussian cross asset model for ir, fx, eq, com
file	gaussiancamcg.hpp
	Gaussian CAM model.
file	localvol.hpp
	local vol model for n underlyings (fx, equity or commodity)
file	model.hpp
	interface for model against which a script can be run
file	modelcg.hpp
	interface for model against which a script can be run
file	modelcgimpl.hpp
	basis implementation for a script engine model
file	modelimpl.hpp
	basis implementation for a script engine model
file	randomastgenerator.hpp
	random ast generator for testing purposes
file	safestack.hpp
	stack with safety checks and pop() that returns rvalue reference of top element
file	scriptengine.hpp
	scriptengine
file	scriptparser.hpp
	script parser
file	staticanalyser.hpp
	static script analyser
file	utilities.hpp
	some utility functions
file	value.hpp
	value type and operations
file	bondindexbuilder.hpp
	Interface for building a bond index.
file	calendaradjustmentconfig.hpp
	Interface for calendar modifications, additional holidays and business days.
file	calendarparser.hpp
	calendar parser singleton class
file	calendarparser.hpp
	calendar parser singleton class
file	conventionsbasedfutureexpiry.hpp
	Base class for classes that perform date calculations for future contracts.
file	correlationmatrix.hpp
	configuration class for building correlation matrices
file	csvfilereader.hpp
	utility class to access CSV files
file	calendarparser.hpp
	calendar parser singleton class
file	currencyparser.hpp
	currency parser singleton class
file	fileio.hpp
	Wrapper class for retrying file IO operations.
file	flowanalysis.hpp
	Extended QuantLib flow analysis.
file	indexnametranslator.hpp
	translates between QuantLib::Index::name() and ORE names
file	indexparser.cpp
file	indexparser.hpp
	Map text representations to QuantLib/QuantExt types.
file	indexparser.hpp
	Map text representations to QuantLib/QuantExt types.
file	log.hpp
	Classes and functions for log message handling.
file	marketdata.hpp
	market data related utilties
file	osutils.hpp
	Various OS specific utilities.
file	parsers.cpp
file	parsers.hpp
	Map text representations to QuantLib/QuantExt types.
file	progressbar.hpp
	Classes for progress reporting.
file	serializationdate.hpp
	support for QuantLib::Date serialization
file	serializationdaycounter.hpp
	support for QuantLib::DayCounter serialization
file	serializationperiod.hpp
	support for QuantLib::Period serialization
file	strike.hpp
	strike description
file	timeperiod.hpp
	non-contiguous time period handling
file	to_string.cpp
file	to_string.hpp
	string conversion utilities
file	vectorutils.hpp
	Utilities for sorting vectors using permutations.
file	wildcard.hpp
	utilities for wildcard handling
file	wildcard.hpp
	utilities for wildcard handling
file	xmlutils.cpp
file	xmlutils.hpp
	XML utility functions.

Classes
class	CorrelationMatrixBuilder
class	Logger
	The Base Custom Log Handler class. More...
class	StderrLogger
	Stderr Logger. More...
class	FileLogger
	FileLogger. More...
class	BufferLogger
	BufferLogger. More...
class	IndependentLogger
	Base Log handler class that utilises Boost logging to create log sinks. More...
class	Log
	Global static Log class. More...
class	ProgressIndicator
	Abstract Base class for a Progress Indicator. More...
class	ProgressReporter
	Base class for a Progress Reporter. More...
class	SimpleProgressBar
	Simple Progress Bar. More...
class	ProgressLog
	Progress Logger that writes the progress using the LOG macro. More...
class	TimePeriod
	Handles non-contiguous time period. More...
class	xml_node< Ch >
	XML Node. More...
class	xml_document< Ch >
	XML Document. More...
class	XMLDocument
	Small XML Document wrapper class. More...
class	XMLSerializable
	Base class for all serializable classes. More...
class	XMLUtils
	XML Utilities Class. More...

Functions
bool	tryParseCdsInformation (string strInfo, CdsReferenceInformation &cdsInfo)
vector< vector< string > >	flowAnalysis (const QuantLib::Leg &)
	Flow Analysis. More...
QuantLib::ext::shared_ptr< FxIndex >	parseFxIndex (const string &s, const Handle< Quote > &fxSpot=Handle< Quote >(), const Handle< YieldTermStructure > &sourceYts=Handle< YieldTermStructure >(), const Handle< YieldTermStructure > &targetYts=Handle< YieldTermStructure >(), const bool useConventions=false)
	Convert std::string to QuantExt::FxIndex. More...
QuantLib::ext::shared_ptr< IborIndex >	parseIborIndex (const string &s, const Handle< YieldTermStructure > &h=Handle< YieldTermStructure >())
	Convert std::string to QuantLib::IborIndex. More...
QuantLib::ext::shared_ptr< IborIndex >	parseIborIndex (const std::string &strIndex, std::string &outTenor, const QuantLib::Handle< QuantLib::YieldTermStructure > &h=QuantLib::Handle< QuantLib::YieldTermStructure >())
	Convert std::string to QuantLib::IborIndex and return the tenor string component of the index. More...
bool	tryParseIborIndex (const string &s, QuantLib::ext::shared_ptr< IborIndex > &index)
	Try to convert std::string to QuantLib::IborIndex. More...
bool	isGenericIborIndex (const string &indexName)
	Return true if the indexName is that of a generic ibor index, otherwise false. More...
pair< bool, QuantLib::ext::shared_ptr< ZeroInflationIndex > >	isInflationIndex (const string &indexName)
bool	isEquityIndex (const std::string &indexName)
	Return true if the indexName is that of an EquityIndex, otherwise false. More...
bool	isCommodityIndex (const std::string &indexName)
	Return true if the indexName is that of an CommodityIndex, otherwise false. More...
bool	isGenericIndex (const string &indexName)
QuantLib::ext::shared_ptr< QuantExt::EquityIndex2 >	parseEquityIndex (const string &s)
	Convert std::string (e.g SP5) to QuantExt::EquityIndex. More...
QuantLib::ext::shared_ptr< SwapIndex >	parseSwapIndex (const string &s, const Handle< YieldTermStructure > &forwarding=Handle< YieldTermStructure >(), const Handle< YieldTermStructure > &discounting=Handle< YieldTermStructure >())
	Convert std::string to QuantLib::SwapIndex. More...
QuantLib::ext::shared_ptr< ZeroInflationIndex >	parseZeroInflationIndex (const string &s, const Handle< ZeroInflationTermStructure > &h=Handle< ZeroInflationTermStructure >())
	Convert std::string to QuantLib::ZeroInflationIndex. More...
QuantLib::ext::shared_ptr< BondIndex >	parseBondIndex (const string &s)
	Convert std::string to QuantExt::BondIndex. More...
QuantLib::ext::shared_ptr< ConstantMaturityBondIndex >	parseConstantMaturityBondIndex (const string &s)
	Convert std::string to QuantExt::ConstantMaturityBondIndex. More...
QuantLib::ext::shared_ptr< QuantExt::CommodityIndex >	parseCommodityIndex (const std::string &name, bool hasPrefix=true, const QuantLib::Handle< QuantExt::PriceTermStructure > &ts=QuantLib::Handle< QuantExt::PriceTermStructure >(), const QuantLib::Calendar &cal=QuantLib::NullCalendar(), const bool enforceFutureIndex=true)
QuantLib::ext::shared_ptr< QuantLib::Index >	parseGenericIndex (const string &s)
	Convert std::string (GENERIC-...) to QuantExt::Index. More...
QuantLib::ext::shared_ptr< Index >	parseIndex (const string &s)
	Convert std::string to QuantLib::Index. More...
bool	isOvernightIndex (const std::string &indexName)
	Return true if the indexName is that of an overnight index, otherwise false. More...
bool	isBmaIndex (const std::string &indexName)
	Return true if the indexName is that of an bma/sifma index, otherwise false. More...
string	internalIndexName (const string &indexName)
string	getOsName ()
	Returns the OS Name. More...
string	getOsVersion ()
	Returns the OS Version. More...
string	getCpuName ()
	Returns the CPU name (e.g. "Intel(R) Core(TM) i7-3720QM CPU @ 2.60GHz". More...
unsigned int	getNumberCores ()
	Returns the number of Cores available to the OS. More...
string	getMemoryRAM ()
	Returns the total amount of memory available (installed RAM) More...
string	getMemoryUsage ()
	Returns the current process memory usage. More...
string	getPeakMemoryUsage ()
	Returns the current process peak memory usage. More...
unsigned long long	getMemoryUsageBytes ()
unsigned long long	getPeakMemoryUsageBytes ()
	Returns the current process peak memory usage in bytes. More...
string	getUsername ()
	Returns the current username. More...
string	getHostname ()
	Returns the machine name. More...
string	getSystemDetails ()
	Returns all the above system details in a single string. More...
void	dumpStacktrace ()
	Write the current stacktrace to stderr and LOG() with level = ALERT. More...
void	setAssertHandler ()
	Set an assert handler that logs the stacktrace. More...
Date	parseDate (const string &s)
	Convert std::string to QuantLib::Date. More...
Real	parseReal (const string &s)
	Convert text to Real. More...
Real	parseRealOrNull (const string &s)
	Convert text to Real, empty string to Null<Real>() More...
bool	tryParseReal (const string &s, QuantLib::Real &result)
	Attempt to convert text to Real. More...
Integer	parseInteger (const string &s)
	Convert text to QuantLib::Integer. More...
bool	parseBool (const string &s)
	Convert text to bool. More...
Calendar	parseCalendar (const string &s)
	Convert text to QuantLib::Calendar. More...
Period	parsePeriod (const string &s)
	Convert text to QuantLib::Period. More...
BusinessDayConvention	parseBusinessDayConvention (const string &s)
	Convert text to QuantLib::BusinessDayConvention. More...
DayCounter	parseDayCounter (const string &s)
	Convert text to QuantLib::DayCounter. More...
Currency	parseCurrency (const string &s)
	Convert text to QuantLib::Currency. More...
QuantExt::ConfigurableCurrency::Type	parseCurrencyType (const string &s)
	Convert text to QuantExt::ConfigurableCurrency::Type (Major, Minor, Metal, Crypto) More...
Currency	parseMinorCurrency (const string &s)
	Convert text to QuantLib::Currency for minor currencies e.g GBp -> GBPCurrency() More...
Currency	parseCurrencyWithMinors (const string &s)
	Convert text to QuantLib::Currency. More...
pair< Currency, Currency >	parseCurrencyPair (const string &s, const string &delimiters)
	Convert text to std::pair<QuantLib::Currency, QuantLib::Currency> More...
bool	checkCurrency (const string &code)
	check for vaid currency code, including minors and pseudo currencies More...
bool	isPseudoCurrency (const string &code)
	check for pseudo currency = precious metal or crypto currency *‍/ More...
bool	isPreciousMetal (const string &code)
	check for precious metal *‍/ More...
bool	isCryptoCurrency (const string &code)
	check for crypto currency *‍/ More...
QuantLib::Real	convertMinorToMajorCurrency (const std::string &s, QuantLib::Real value)
	Convert a value from a minor ccy to major. More...
DateGeneration::Rule	parseDateGenerationRule (const string &s)
	Convert text to QuantLib::DateGeneration::Rule. More...
Frequency	parseFrequency (const string &s)
	Convert text to QuantLib::Frequency. More...
Compounding	parseCompounding (const string &s)
	Convert text to QuantLib::Compounding;. More...
Position::Type	parsePositionType (const string &s)
	Convert text to QuantLib::Position::Type. More...
Protection::Side	parseProtectionSide (const string &s)
	Convert text to QuantLib::Protection::Side. More...
Settlement::Type	parseSettlementType (const string &s)
	Convert text to QuantLib::Settlement::Type. More...
Settlement::Method	parseSettlementMethod (const string &s)
	Convert text to QuantLib::Settlement::Method. More...
Exercise::Type	parseExerciseType (const string &s)
	Convert text to QuantLib::Exercise::Type. More...
Option::Type	parseOptionType (const string &s)
	Convert text to QuantLib::Option::Type. More...
QuantLib::Bond::Price::Type	parseBondPriceType (const string &s)
	Convert text to QuantLib::Bond::Price::Type. More...
boost::variant< QuantLib::Date, QuantLib::Period >	parseDateOrPeriod (const string &s)
	Convert text to QuantLib::Period or QuantLib::Date. More...
void	parseDateOrPeriod (const string &s, QuantLib::Date &d, QuantLib::Period &p, bool &isDate)
	Convert text to QuantLib::Period or QuantLib::Date (deprecated version) More...
QuantLib::LsmBasisSystem::PolynomialType	parsePolynomType (const std::string &s)
	Convert text to QuantLib::LsmBasisSystem::PolynomialType. More...
std::ostream &	operator<< (std::ostream &os, QuantLib::LsmBasisSystem::PolynomialType a)
	Write QuantLib::LsmBasisSystem::PolynomialType to stream. More...
SobolBrownianGenerator::Ordering	parseSobolBrownianGeneratorOrdering (const std::string &s)
	Convert text to QuantLib::SobolBrownianGenerator::Ordering. More...
SobolRsg::DirectionIntegers	parseSobolRsgDirectionIntegers (const std::string &s)
	Convert text to QuantLib::SobolRsg::DirectionIntegers. More...
Weekday	parseWeekday (const string &s)
Month	parseMonth (const string &s)
PaymentLag	parsePaymentLag (const string &s)
	Convert text to PaymentLag. More...
template<class T >
std::vector< T >	parseListOfValues (string s, std::function< T(string)> parser)
	Convert comma separated list of values to vector of values. More...
SequenceType	parseSequenceType (const std::string &s)
	Convert string to sequence type. More...
QuantLib::CPI::InterpolationType	parseObservationInterpolation (const std::string &s)
	Convert string to observation interpolation. More...
FdmSchemeDesc	parseFdmSchemeDesc (const std::string &s)
	Convert string to fdm scheme desc. More...
AssetClass	parseAssetClass (const std::string &s)
	Convert text to ore::data::AssetClass. More...
std::ostream &	operator<< (std::ostream &os, AssetClass a)
	Write ore::data::AssetClass to stream. More...
DeltaVolQuote::AtmType	parseAtmType (const std::string &s)
	Convert text to QuantLib::DeltaVolQuote::AtmType. More...
DeltaVolQuote::DeltaType	parseDeltaType (const std::string &s)
	Convert text to QuantLib::DeltaVolQuote::DeltaType. More...
QuantLib::Rounding::Type	parseRoundingType (const std::string &s)
	Convert text to QuantLib::Rounding. More...
Barrier::Type	parseBarrierType (const string &s)
	Convert std::string to QuantLib::BarrierType. More...
DoubleBarrier::Type	parseDoubleBarrierType (const string &s)
	Convert std::string to QuantLib::DoubleBarrierType. More...
template<class T >
bool	tryParse (const std::string &str, T &obj, std::function< T(const std::string &)> parser)
VolatilityType	parseVolatilityQuoteType (const string &s)
CapFloor::Type	parseCapFloorType (const string &s)
YoYInflationCapFloor::Type	parseYoYInflationCapFloorType (const string &s)
QuantExt::CrossAssetModel::AssetType	parseCamAssetType (const string &s)
pair< string, string >	parseBoostAny (const boost::any &anyType, Size precision)
CdsOption::StrikeType	parseCdsOptionStrikeType (const string &s)
Average::Type	parseAverageType (const std::string &s)
QuantExt::BondIndex::PriceQuoteMethod	parsePriceQuoteMethod (const std::string &s)
string	fxDominance (const string &s1, const string &s2)
	Convert FX pair to market standard dominance. More...
MomentType	parseMomentType (const std::string &s)
	Convert text to ore::data::MomentType. More...
QuantLib::Pillar::Choice	parsePillarChoice (const std::string &s)
	Convert text to QuantLib::Pillar::Choice. More...
QuantExt::McMultiLegBaseEngine::RegressorModel	parseRegressorModel (const std::string &s)
	Convert text to QuantExt::McMultiLegBaseEngine::RegressorModel. More...
MporCashFlowMode	parseMporCashFlowMode (const std::string &s)
	Convert text to MporCashFlowMode. More...
std::ostream &	operator<< (std::ostream &os, MporCashFlowMode t)
	Write MporCashFlowMode to stream. More...
SabrParametricVolatility::ModelVariant	parseSabrParametricVolatilityModelVariant (const std::string &s)
	Parse SabrParametricVolatility::ModelVariant. More...
std::ostream &	operator<< (std::ostream &out, QuantExt::SabrParametricVolatility::ModelVariant m)
	Write SabrParametricVolatility::ModelVariant. More...
std::ostream &	operator<< (std::ostream &os, QuantLib::Exercise::Type type)
	Write QuantLib::Exercise::Type. More...
template<class Archive >
void	serialize (Archive &ar, QuantLib::Date &d, const unsigned int)
	Allow for serialization of QuantLib::Date without amending its class (non-intrusive) More...
template<class Archive >
void	serialize (Archive &ar, QuantLib::DayCounter &dc, const unsigned int)
	Allow for serialization of QuantLib::Period without amending its class (non-intrusive) More...
template<class Archive >
void	serialize (Archive &ar, QuantLib::Period &p, const unsigned int)
	Allow for serialization of QuantLib::Period without amending its class (non-intrusive) More...
Strike	parseStrike (const std::string &s)
	Convert text to Strike. More...
std::ostream &	operator<< (std::ostream &out, const Strike &s)
	Convert Strike to text. More...
bool	operator== (const Strike &s1, const Strike &s2)
	Logical comparison of strikes. More...
QuantLib::Real	computeAbsoluteStrike (const Strike &s, const QuantLib::Real atm, const QuantLib::Real atmf)
	Convenience function that computes an absolute strike. More...
std::string	to_string (const QuantLib::Date &date)
	Convert QuantLib::Date to std::string. More...
string	to_string (bool aBool)
	Convert bool to std::string. More...
std::string	to_string (const QuantLib::Period &period)
	Convert QuantLib::Period to std::string. More...
template<class T >
std::string	to_string (const std::vector< T > &vec, const std::string &sep=",")
	Convert vector to std::string. More...
template<class T >
std::string	to_string (const std::set< T > &set, const std::string &sep=",")
	Convert set to std::string. More...
template<class T >
std::string	to_string (const T &t)
	Convert type to std::string. More...
template<typename T , typename Compare >
std::vector< std::size_t >	sort_permutation (const std::vector< T > &vec, Compare &compare)
template<typename T >
std::vector< T >	apply_permutation (const std::vector< T > &vec, const std::vector< std::size_t > &p)
template<typename T >
void	apply_permutation_in_place (std::vector< T > &vec, const std::vector< std::size_t > &p)

Detailed Description

Grouping of all utility related classes, functions and files

Reference: http://stackoverflow.com/questions/17074324/how-can-i-sort-two-vectors-in-the-same-way-with-criteria-that-uses-only-one-of

Function Documentation

tryParseCdsInformation()

bool tryParseCdsInformation	(	std::string	strInfo,
		CdsReferenceInformation &	cdsInfo
	)

Attempt to parse string to CdsReferenceInformation

Parameters

[in]	strInfo	The string we wish to convert to CdsReferenceInformation
[out]	cdsInfo	The resulting CdsReferenceInformation if the parsing was successful.

Returns

true if the parsing was successful and false if not.

If the function receives a strInfo of the form ID|TIER|CCY|DOCCLAUSE with CCY being a valid ISO currency code, TIER being a valid CDS debt tier and DOCCLAUSE being a valid CDS documentation clause, the parsing should be successful. Here, DOCCLAUSE is optional.

Definition at line 449 of file creditdefaultswapdata.cpp.

                                                                              {
 
    DLOG("tryParseCdsInformation: attempting to parse " << strInfo);
 
    // As in documentation comment, expect strInfo of form ID|TIER|CCY(|DOCCLAUSE)
    vector<string> tokens;
    boost::split(tokens, strInfo, boost::is_any_of("|"));
 
    if (tokens.size() != 4 && tokens.size() != 3) {
        TLOG("String " << strInfo << " not of form ID|TIER|CCY(|DOCCLAUSE) so parsing failed");
        return false;
    }
 
    CdsTier cdsTier;
    if (!tryParse<CdsTier>(tokens[1], cdsTier, &parseCdsTier)) {
        return false;
    }
 
    Currency ccy;
    if (!tryParseCurrency(tokens[2], ccy)) {
        return false;
    }
 
    boost::optional<CdsDocClause> cdsDocClause;
    if (tokens.size() == 4) {
        CdsDocClause tmp;
        if (!tryParse<CdsDocClause>(tokens[3], tmp, &parseCdsDocClause)) {
            return false;
        }
        cdsDocClause = tmp;
    }
 
    cdsInfo = CdsReferenceInformation(tokens[0], cdsTier, ccy, cdsDocClause);
 
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

flowAnalysis()

std::vector< std::vector< std::string > > flowAnalysis

(

const QuantLib::Leg &

leg

)

Flow Analysis.

Definition at line 158 of file flowanalysis.cpp.

                                                            {
    AnalysisGenerator generator;
    for (QuantLib::Size i = 0; i < leg.size(); ++i)
        leg[i]->accept(generator);
    return generator.analysis();
}

Here is the call graph for this function:

parseFxIndex()

QuantLib::ext::shared_ptr< QuantExt::FxIndex > parseFxIndex	(	const string &	s,
		const Handle< Quote > &	fxSpot,
		const Handle< YieldTermStructure > &	sourceYts,
		const Handle< YieldTermStructure > &	targetYts,
		const bool	useConventions
	)

Convert std::string to QuantExt::FxIndex.

Definition at line 208 of file indexparser.cpp.

                                                                                                                {
    std::vector<string> tokens;
    split(tokens, s, boost::is_any_of("-"));
    QL_REQUIRE(tokens.size() == 4, "four tokens required in " << s << ": FX-TAG-CCY1-CCY2");
    QL_REQUIRE(tokens[0] == "FX", "expected first token to be FX");
    Natural fixingDays = 0;
    Calendar fixingCalendar = NullCalendar();
    BusinessDayConvention bdc;
    if (useConventions)
        std::tie(fixingDays, fixingCalendar, bdc) = getFxIndexConventions(s);
    auto index = QuantLib::ext::make_shared<FxIndex>(tokens[1], fixingDays, parseCurrency(tokens[2]), parseCurrency(tokens[3]),
                                             fixingCalendar, fxSpot, sourceYts, targetYts);
 
    IndexNameTranslator::instance().add(index->name(), s);
    return index;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parseIborIndex() [1/2]

QuantLib::ext::shared_ptr< IborIndex > parseIborIndex	(	const string &	s,
		const Handle< YieldTermStructure > &	h
	)

Convert std::string to QuantLib::IborIndex.

Definition at line 254 of file indexparser.cpp.

                                                                                                      {
    string dummy;
    return parseIborIndex(s, dummy, h);
}

Here is the call graph for this function:

Here is the caller graph for this function:

parseIborIndex() [2/2]

QuantLib::ext::shared_ptr< IborIndex > parseIborIndex	(	const std::string &	strIndex,
		std::string &	outTenor,
		const QuantLib::Handle< QuantLib::YieldTermStructure > &	h = QuantLib::Handle< QuantLib::YieldTermStructure >()
	)

Convert std::string to QuantLib::IborIndex and return the tenor string component of the index.

In some cases, after parsing the IborIndex, we would like to know the exact tenor string that was part of the strIndex that was parsed. If we ask the resulting index for its tenor via the method Period InterestRateIndex::tenor(), it can be difficult to deduce the original tenor string. A simple example of this is MXN-TIIE-28D where if you call tenor() and then to_string(), you get 4W which is different than the original 28D that is passed in.

Warning:

If the strIndex does not have a tenor component, as is the usual case for overnight indices, outTenor will be populated with the empty string.

tryParseIborIndex()

bool tryParseIborIndex	(	const string &	s,
		QuantLib::ext::shared_ptr< IborIndex > &	index
	)

Try to convert std::string to QuantLib::IborIndex.

Definition at line 244 of file indexparser.cpp.

                                                                                 {
    try {
        index = parseIborIndex(s, Handle<YieldTermStructure>());
    } catch (const std::exception& e) {
    DLOG("tryParseIborIndex(" << s << ") failed: " << e.what());
        return false;
    }
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

isGenericIborIndex()

bool isGenericIborIndex

(

const string &

indexName

)

Return true if the indexName is that of a generic ibor index, otherwise false.

Definition at line 442 of file indexparser.cpp.

{ return indexName.find("-GENERIC-") != string::npos; }

Here is the caller graph for this function:

isInflationIndex()

std::pair< bool, QuantLib::ext::shared_ptr< QuantLib::ZeroInflationIndex > > isInflationIndex

(

const std::string &

indexName

)

Returns true as the first element in the pair if the indexName is that of an InflationIndex. The second element in the pair is an instance of the inflation index. If indexName is not an inflation index, the first element in the pair is false and the second element is a nullptr.

If inflation indices have been set up via ZeroInflationIndex entries in the Conventions, the conventions should be passed here. If not, the default nullptr parameter will be sufficient.

Definition at line 444 of file indexparser.cpp.

                                                                                                {
 
    QuantLib::ext::shared_ptr<ZeroInflationIndex> index;
    try {
        // Currently, only way to have an inflation index is to have a ZeroInflationIndex
        index = parseZeroInflationIndex(indexName, Handle<ZeroInflationTermStructure>());
    } catch (...) {
        return make_pair(false, nullptr);
    }
    return make_pair(true, index);
}

Here is the call graph for this function:

Here is the caller graph for this function:

isEquityIndex()

bool isEquityIndex

(

const string &

indexName

)

Return true if the indexName is that of an EquityIndex, otherwise false.

Definition at line 456 of file indexparser.cpp.

                                            {
    try {
        parseEquityIndex(indexName);
    } catch (...) {
        return false;
    }
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

isCommodityIndex()

bool isCommodityIndex

(

const string &

indexName

)

Return true if the indexName is that of an CommodityIndex, otherwise false.

Definition at line 465 of file indexparser.cpp.

                                               {
    try {
        parseCommodityIndex(indexName);
    } catch (...) {
        return false;
    }
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

isGenericIndex()

bool isGenericIndex

(

const std::string &

indexName

)

Return true if the indexName is that of an GenericIndex, otherwise false

Definition at line 474 of file indexparser.cpp.

                                             {
    try {
        parseGenericIndex(indexName);
    }
    catch (...) {
        return false;
    }
    return true;
}

Here is the call graph for this function:

parseEquityIndex()

QuantLib::ext::shared_ptr< QuantExt::EquityIndex2 > parseEquityIndex

(

const string &

s

)

Convert std::string (e.g SP5) to QuantExt::EquityIndex.

Definition at line 227 of file indexparser.cpp.

                                                                              {
    std::vector<string> tokens;
    split(tokens, s, boost::is_any_of("-"));
    QL_REQUIRE(tokens.size() == 2, "two tokens required in " << s << ": EQ-NAME");
    QL_REQUIRE(tokens[0] == "EQ", "expected first token to be EQ");
    auto index = QuantLib::ext::make_shared<QuantExt::EquityIndex2>(tokens[1], NullCalendar(), Currency());
    IndexNameTranslator::instance().add(index->name(), s);
    return index;
}

Here is the caller graph for this function:

parseSwapIndex()

QuantLib::ext::shared_ptr< SwapIndex > parseSwapIndex	(	const string &	s,
		const Handle< YieldTermStructure > &	f,
		const Handle< YieldTermStructure > &	d
	)

Convert std::string to QuantLib::SwapIndex.

Definition at line 501 of file indexparser.cpp.

                                                                                 {
 
    std::vector<string> tokens;
    split(tokens, s, boost::is_any_of("-"));
    QL_REQUIRE(tokens.size() == 3 || tokens.size() == 4,
               "three or four tokens required in " << s << ": CCY-CMS-TENOR or CCY-CMS-TAG-TENOR");
    QL_REQUIRE(tokens[0].size() == 3, "invalid currency code in " << s);
    QL_REQUIRE(tokens[1] == "CMS", "expected CMS as middle token in " << s);
    Period p = parsePeriod(tokens.back());
    // use default family name, if none is given
    string familyName = tokens.size() == 4 ? tokens[0] + "-CMS-" + tokens[2] : tokens[0] + "LiborSwapIsdaFix";
    Currency ccy = parseCurrency(tokens[0]);
 
    const QuantLib::ext::shared_ptr<Conventions>& conventions = InstrumentConventions::instance().conventions();
    QuantLib::ext::shared_ptr<SwapIndexConvention> swapIndexConvention;
    QuantLib::ext::shared_ptr<IRSwapConvention> irSwapConvention;
    QuantLib::ext::shared_ptr<OisConvention> oisCompConvention;
    QuantLib::ext::shared_ptr<AverageOisConvention> oisAvgConvention;
    if (conventions && conventions->has(s, Convention::Type::SwapIndex)) {
        swapIndexConvention = QuantLib::ext::dynamic_pointer_cast<SwapIndexConvention>(conventions->get(s));
        QL_REQUIRE(swapIndexConvention, "internal error: could not cast to SwapIndexConvention");
        QL_REQUIRE(conventions->has(swapIndexConvention->conventions(), Convention::Type::Swap) ||
                       conventions->has(swapIndexConvention->conventions(), Convention::Type::OIS) ||
                       conventions->has(swapIndexConvention->conventions(), Convention::Type::AverageOIS),
                   "do not have swap or ois conventions for '"
                       << swapIndexConvention->conventions() << "', required from swap index convention '" << s << "'");
        irSwapConvention =
            QuantLib::ext::dynamic_pointer_cast<IRSwapConvention>(conventions->get(swapIndexConvention->conventions()));
        oisCompConvention =
            QuantLib::ext::dynamic_pointer_cast<OisConvention>(conventions->get(swapIndexConvention->conventions()));
        oisAvgConvention =
            QuantLib::ext::dynamic_pointer_cast<AverageOisConvention>(conventions->get(swapIndexConvention->conventions()));
        QL_REQUIRE(irSwapConvention || oisCompConvention || oisAvgConvention,
                   "internal error: could not cast to IRSwapConvention, OisConvention, AverageOisConvention");
    } else {
        // set default conventions using a generic ibor index
        irSwapConvention = QuantLib::ext::make_shared<IRSwapConvention>("dummy_swap_conv_" + tokens[0], tokens[0], "Annual",
                                                                "MF", "A365", tokens[0] + "-GENERIC-3M");
        swapIndexConvention = QuantLib::ext::make_shared<SwapIndexConvention>("dummy_swapindex_conv_" + tokens[0],
                                                                      "dummy_swap_conv_" + tokens[0], "");
    }
 
    QuantLib::ext::shared_ptr<SwapIndex> index;
    if (irSwapConvention) {
        Calendar fixingCalendar = swapIndexConvention->fixingCalendar().empty()
                                      ? irSwapConvention->fixedCalendar()
                                      : parseCalendar(swapIndexConvention->fixingCalendar());
        index = QuantLib::ext::make_shared<SwapIndex>(familyName, p, irSwapConvention->index()->fixingDays(), ccy,
                                              fixingCalendar, Period(irSwapConvention->fixedFrequency()),
                                              irSwapConvention->fixedConvention(), irSwapConvention->fixedDayCounter(),
                                              irSwapConvention->index()->clone(f), d);
    } else if (oisCompConvention) {
        Calendar fixingCalendar = swapIndexConvention->fixingCalendar().empty()
                                      ? oisCompConvention->index()->fixingCalendar()
                                      : parseCalendar(swapIndexConvention->fixingCalendar());
        index = QuantLib::ext::make_shared<OvernightIndexedSwapIndex>(
            familyName, p, oisCompConvention->spotLag(), ccy,
            QuantLib::ext::dynamic_pointer_cast<OvernightIndex>(oisCompConvention->index()->clone(f)), true,
            RateAveraging::Compound, Period(oisCompConvention->fixedFrequency()), d);
    } else if (oisAvgConvention) {
        Calendar fixingCalendar = swapIndexConvention->fixingCalendar().empty()
                                      ? oisAvgConvention->index()->fixingCalendar()
                                      : parseCalendar(swapIndexConvention->fixingCalendar());
        auto index = QuantLib::ext::make_shared<OvernightIndexedSwapIndex>(
            familyName, p, oisAvgConvention->spotLag(), ccy,
            QuantLib::ext::dynamic_pointer_cast<OvernightIndex>(oisAvgConvention->index()->clone(f)), true,
            RateAveraging::Simple, Period(oisAvgConvention->fixedFrequency()), d);
        IndexNameTranslator::instance().add(index->name(), s);
        return index;
    } else {
        QL_FAIL("internal error: expected irSwapConvention, oisConvention, averageOisConvention to be not null");
    }
    IndexNameTranslator::instance().add(index->name(), s);
    return index;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parseZeroInflationIndex()

QuantLib::ext::shared_ptr< ZeroInflationIndex > parseZeroInflationIndex	(	const string &	s,
		const Handle< ZeroInflationTermStructure > &	h
	)

Convert std::string to QuantLib::ZeroInflationIndex.

Definition at line 616 of file indexparser.cpp.

                                                                                                           {
    const QuantLib::ext::shared_ptr<Conventions>& conventions = InstrumentConventions::instance().conventions();
 
    // If conventions are non-null and we have provided a convention of type InflationIndex with a name equal to the
    // string s, we use that convention to construct the inflation index.
    if (conventions) {
        pair<bool, QuantLib::ext::shared_ptr<Convention>> p = conventions->get(s, Convention::Type::ZeroInflationIndex);
        if (p.first) {
            auto c = QuantLib::ext::dynamic_pointer_cast<ZeroInflationIndexConvention>(p.second);
            auto index = QuantLib::ext::make_shared<ZeroInflationIndex>(s, c->region(), c->revised(),
                                                                c->frequency(), c->availabilityLag(), c->currency(), h);
            IndexNameTranslator::instance().add(index->name(), s);
            return index;
        }
    }
 
    static map<string, QuantLib::ext::shared_ptr<ZeroInflationIndexParserBase>> m = {
        {"AUCPI", QuantLib::ext::make_shared<ZeroInflationIndexParserWithFrequency<AUCPI>>(Quarterly)},
        {"AU CPI", QuantLib::ext::make_shared<ZeroInflationIndexParserWithFrequency<AUCPI>>(Quarterly)},
        {"BEHICP", QuantLib::ext::make_shared<ZeroInflationIndexParser<BEHICP>>()},
        {"BE HICP", QuantLib::ext::make_shared<ZeroInflationIndexParser<BEHICP>>()},
        {"EUHICP", QuantLib::ext::make_shared<ZeroInflationIndexParser<EUHICP>>()},
        {"EU HICP", QuantLib::ext::make_shared<ZeroInflationIndexParser<EUHICP>>()},
        {"EUHICPXT", QuantLib::ext::make_shared<ZeroInflationIndexParser<EUHICPXT>>()},
        {"EU HICPXT", QuantLib::ext::make_shared<ZeroInflationIndexParser<EUHICPXT>>()},
        {"FRHICP", QuantLib::ext::make_shared<ZeroInflationIndexParser<FRHICP>>()},
        {"FR HICP", QuantLib::ext::make_shared<ZeroInflationIndexParser<FRHICP>>()},
        {"FRCPI", QuantLib::ext::make_shared<ZeroInflationIndexParser<FRCPI>>()},
        {"FR CPI", QuantLib::ext::make_shared<ZeroInflationIndexParser<FRCPI>>()},
        {"UKRPI", QuantLib::ext::make_shared<ZeroInflationIndexParser<UKRPI>>()},
        {"UK RPI", QuantLib::ext::make_shared<ZeroInflationIndexParser<UKRPI>>()},
        {"USCPI", QuantLib::ext::make_shared<ZeroInflationIndexParser<USCPI>>()},
        {"US CPI", QuantLib::ext::make_shared<ZeroInflationIndexParser<USCPI>>()},
        {"ZACPI", QuantLib::ext::make_shared<ZeroInflationIndexParser<ZACPI>>()},
        {"ZA CPI", QuantLib::ext::make_shared<ZeroInflationIndexParser<ZACPI>>()},
        {"SECPI", QuantLib::ext::make_shared<ZeroInflationIndexParser<SECPI>>()},
        {"DKCPI", QuantLib::ext::make_shared<ZeroInflationIndexParser<DKCPI>>()},
        {"CACPI", QuantLib::ext::make_shared<ZeroInflationIndexParser<CACPI>>()},
        {"ESCPI", QuantLib::ext::make_shared<ZeroInflationIndexParser<ESCPI>>()},
        {"DECPI", QuantLib::ext::make_shared<ZeroInflationIndexParser<DECPI>>()},
        {"DE CPI", QuantLib::ext::make_shared<ZeroInflationIndexParser<DECPI>>()}};
 
    auto it = m.find(s);
    if (it != m.end()) {
        auto index = it->second->build(h);
        IndexNameTranslator::instance().add(index->name(), s);
        return index;
    } else {
        QL_FAIL("parseZeroInflationIndex: \"" << s << "\" not recognized");
    }
}

Here is the caller graph for this function:

parseBondIndex()

QuantLib::ext::shared_ptr< QuantExt::BondIndex > parseBondIndex

(

const string &

name

)

Convert std::string to QuantExt::BondIndex.

Definition at line 728 of file indexparser.cpp.

                                                                    {
 
    // Make sure the prefix is correct
    string prefix = name.substr(0, 5);
    QL_REQUIRE(prefix == "BOND-", "A bond index string must start with 'BOND-' but got " << prefix);
 
    // Now take the remainder of the string
    // for spot indices, this should just be the bond name
    // for future indices, this is of the form NAME-YYYY-MM or NAME-YYYY-MM-DD where NAME is the commodity name
    // (possibly containing hyphens) and YYYY-MM(-DD) is the expiry date of the futures contract
    Date expiry;
    string nameWoPrefix = name.substr(5);
    string bondName = nameWoPrefix;
 
    // Check for form NAME-YYYY-MM-DD
    if (nameWoPrefix.size() > 10) {
        string test = nameWoPrefix.substr(nameWoPrefix.size() - 10);
        if (boost::regex_match(test, boost::regex("\\d{4}-\\d{2}-\\d{2}"))) {
            expiry = parseDate(test);
            bondName = nameWoPrefix.substr(0, nameWoPrefix.size() - test.size() - 1);
        }
    }
 
    // Check for form NAME-YYYY-MM if NAME-YYYY-MM-DD failed
    if (expiry == Date() && nameWoPrefix.size() > 7) {
        string test = nameWoPrefix.substr(nameWoPrefix.size() - 7);
        if (boost::regex_match(test, boost::regex("\\d{4}-\\d{2}"))) {
            expiry = parseDate(test + "-01");
            bondName = nameWoPrefix.substr(0, nameWoPrefix.size() - test.size() - 1);
        }
    }
 
    // Create and return the required future index
    QuantLib::ext::shared_ptr<BondIndex> index;
    if (expiry != Date()) {
        index= QuantLib::ext::make_shared<BondFuturesIndex>(expiry, bondName);
    } else {
        index= QuantLib::ext::make_shared<BondIndex>(bondName);
    }
    IndexNameTranslator::instance().add(index->name(), name);
    return index;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parseConstantMaturityBondIndex()

QuantLib::ext::shared_ptr< QuantExt::ConstantMaturityBondIndex > parseConstantMaturityBondIndex

(

const string &

name

)

Convert std::string to QuantExt::ConstantMaturityBondIndex.

Definition at line 771 of file indexparser.cpp.

                                                                                                    {
    // Expected bondId structure with at least three tokens, separated by "-", of the form CMB-FAMILY-TERM, for example:
    // CMB-US-CMT-5Y, CMB-US-TIPS-10Y, CMB-UK-GILT-5Y, CMB-DE-BUND-10Y
    // with two tokens in the middle to define the family 
    std::vector<string> tokens;
    split(tokens, name, boost::is_any_of("-"));
    QL_REQUIRE(tokens.size() >= 3, "Generic Bond ID with at least two tokens separated by - expected, found " << name);
 
    // Make sure the prefix is correct
    std::string prefix = tokens[0];
    QL_REQUIRE(prefix == "CMB", "A constant maturity bond yield index string must start with 'CMB' but got " << prefix);
 
    std::string securityFamily = tokens[1];
    for (Size i = 2; i < tokens.size() - 1; ++i)
        securityFamily = securityFamily + "-" + tokens[i];
    Period underlyingPeriod = parsePeriod(tokens.back());
    QuantLib::ext::shared_ptr<ConstantMaturityBondIndex> i;
    try {
        i = QuantLib::ext::make_shared<ConstantMaturityBondIndex>(prefix + "-" + securityFamily, underlyingPeriod); 
    } catch(std::exception& e) {
        ALOG("error creating CMB index: " << e.what());
    }
    IndexNameTranslator::instance().add(i->name(), name);
    return i;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parseCommodityIndex()

QuantLib::ext::shared_ptr< QuantExt::CommodityIndex > parseCommodityIndex	(	const std::string &	name,
		bool	hasPrefix = true,
		const QuantLib::Handle< QuantExt::PriceTermStructure > &	ts = QuantLib::Handle< QuantExt::PriceTermStructure >(),
		const QuantLib::Calendar &	cal = QuantLib::NullCalendar(),
		const bool	enforceFutureIndex = true
	)

Convert std::string to QuantExt::ComodityIndex

This function can be used to parse commodity spot indices or commodity future indices:

• for spot indices, the name is of the form COMM-EXCHANGE:COMMODITY
• for future indices, the name is of the form COMM-EXCHANGE:CONTRACT:YYYY-MM or COMM-EXCHANGE:CONTRACT:YYYY-MM-DD

parseGenericIndex()

QuantLib::ext::shared_ptr< QuantLib::Index > parseGenericIndex

(

const string &

s

)

Convert std::string (GENERIC-...) to QuantExt::Index.

Definition at line 237 of file indexparser.cpp.

                                                                        {
    QL_REQUIRE(boost::starts_with(s, "GENERIC-"), "generic index expected to be of the form GENERIC-*");
    auto index = QuantLib::ext::make_shared<GenericIndex>(s);
    IndexNameTranslator::instance().add(index->name(), s);
    return index;
}

Here is the caller graph for this function:

parseIndex()

QuantLib::ext::shared_ptr< Index > parseIndex

(

const string &

s

)

Convert std::string to QuantLib::Index.

Definition at line 909 of file indexparser.cpp.

                                                         {
    QuantLib::ext::shared_ptr<QuantLib::Index> ret_idx;
    try {
        ret_idx = parseEquityIndex(s);
    } catch (...) {
    }
    if (!ret_idx) {
        try {
            ret_idx = parseBondIndex(s);
        } catch (...) {
        }
    }
    if (!ret_idx) {
        try {
            ret_idx = parseCommodityIndex(s, true, QuantLib::Handle<QuantExt::PriceTermStructure>(), QuantLib::NullCalendar(), false);
        } catch (...) {
        }
    }
    if (!ret_idx) {
        try {
            ret_idx = parseFxIndex(s);
        } catch (...) {
        }
    }
    if (!ret_idx) {
        try {
            ret_idx = parseGenericIndex(s);
        } catch (...) {
        }
    }
    if (!ret_idx) {
        try {
            ret_idx = parseConstantMaturityBondIndex(s);
        } catch (...) {
        }
    }
    if (!ret_idx) {
        try {
            ret_idx = parseIborIndex(s);
        } catch (...) {
        }
    }
    if (!ret_idx) {
        try {
            ret_idx = parseSwapIndex(s, Handle<YieldTermStructure>(), Handle<YieldTermStructure>());
        } catch (...) {
        }
    }
    if (!ret_idx) {
        try {
            ret_idx = parseZeroInflationIndex(s, Handle<ZeroInflationTermStructure>());
        } catch (...) {
        }
    }
    QL_REQUIRE(ret_idx, "parseIndex \"" << s << "\" not recognized");
    return ret_idx;
}

Here is the call graph for this function:

Here is the caller graph for this function:

isOvernightIndex()

bool isOvernightIndex

(

const string &

indexName

)

Return true if the indexName is that of an overnight index, otherwise false.

Definition at line 967 of file indexparser.cpp.

                                               {
    
    QuantLib::ext::shared_ptr<IborIndex> index;
    if (tryParseIborIndex(indexName, index)) {
        auto onIndex = QuantLib::ext::dynamic_pointer_cast<OvernightIndex>(index);
        if (onIndex)
            return true;
    }
 
    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

isBmaIndex()

bool isBmaIndex

(

const string &

indexName

)

Return true if the indexName is that of an bma/sifma index, otherwise false.

Definition at line 979 of file indexparser.cpp.

                                         {
    QuantLib::ext::shared_ptr<IborIndex> index;
    if (tryParseIborIndex(indexName, index)) {
        // in ore a bma index is parsed to a BMAIndexWrapper instance!
        return QuantLib::ext::dynamic_pointer_cast<BMAIndexWrapper>(index) != nullptr;
    }
    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

internalIndexName()

std::string internalIndexName

(

const std::string &

indexName

)

In some cases, we allow multiple external ibor index names to represent the same QuantLib index. This function returns the unique index name that we use internally to represent the QuantLib index.

For example, we allow:

• USD-FedFunds-1D and USD-FedFunds externally but we use USD-FedFunds internally
• CAD-BA-tenor and CAD-CDOR-tenor externally but we use CAD-CDOR-tenor internally

Definition at line 988 of file indexparser.cpp.

                                                  {
 
    // Check that the indexName string is of the required form
    vector<string> tokens;
    split(tokens, indexName, boost::is_any_of("-"));
    QL_REQUIRE(tokens.size() == 2 || tokens.size() == 3,
               "Two or three tokens required in " << indexName << ": CCY-INDEX or CCY-INDEX-TERM");
 
    // Static map of allowable alternative external names to our unique internal name
    static map<string, string> m = {{"DKK-TNR", "DKK-DKKOIS"}, {"EUR-EURIB", "EUR-EURIBOR"}, {"CAD-BA", "CAD-CDOR"},
                                    {"EUR-ESTR", "EUR-ESTER"}, {"EUR-STR", "EUR-ESTER"},     {"JPY-TONA", "JPY-TONAR"},
                                    {"JPY-TORF", "JPY-TONAR"}};
 
    // Is start of indexName covered by the map? If so, update it.
    string tmpName = tokens[0] + "-" + tokens[1];
    if (m.count(tmpName) == 1) {
        tmpName = m.at(tmpName);
    }
 
    // If there were only two tokens, return the possibly updated two tokens.
    if (tokens.size() == 2) {
        return tmpName;
    }
 
    // Check if we have an overnight index
    // This covers cases like USD-FedFunds-1D and returns USD-FedFunds
    // (no need to check convention based overnight indices, they are always of the form CCY-INDEX)
    if (parsePeriod(tokens[2]) == 1 * Days && isOvernightIndex(tmpName)) {
        return tmpName;
    }
 
    // Allow USD-SIFMA-1W or USD-SIFMA-7D externally. USD-SIFMA is used internally.
    if (tmpName == "USD-SIFMA" && (tokens[2] == "1W" || tokens[2] == "7D")) {
        return tmpName;
    }
 
    return tmpName + "-" + tokens[2];
}

Here is the call graph for this function:

Here is the caller graph for this function:

getOsName()

std::string getOsName

(

)

Returns the OS Name.

Definition at line 284 of file osutils.cpp.

                   {
#if defined(__unix) || defined(__unix__)
    return "Unix";
#elif __linux__
    return "Linux";
#elif __FreeBSD__
    return "FreeBSD";
#else
    return "Other";
#endif
}

Here is the caller graph for this function:

getOsVersion()

std::string getOsVersion

(

)

Returns the OS Version.

Definition at line 296 of file osutils.cpp.

                      {
    struct utsname unameData;
    if (uname(&unameData))
        return "?"; // error
    else
        return unameData.release;
}

Here is the caller graph for this function:

getCpuName()

std::string getCpuName

(

)

Returns the CPU name (e.g. "Intel(R) Core(TM) i7-3720QM CPU @ 2.60GHz".

Definition at line 327 of file osutils.cpp.

{ return parseProcFile("/proc/cpuinfo", "model name"); }

Here is the caller graph for this function:

getNumberCores()

unsigned int getNumberCores

(

)

Returns the number of Cores available to the OS.

Definition at line 329 of file osutils.cpp.

                              {
    long n = sysconf(_SC_NPROCESSORS_ONLN);
    if (n < 0) // error
        return 0;
    else
        return n;
}

Here is the caller graph for this function:

getMemoryRAM()

std::string getMemoryRAM

(

)

Returns the total amount of memory available (installed RAM)

Definition at line 350 of file osutils.cpp.

{ return parseProcFile("/proc/meminfo", "MemTotal"); }

Here is the caller graph for this function:

getMemoryUsage()

std::string getMemoryUsage

(

)

Returns the current process memory usage.

Definition at line 99 of file osutils.cpp.

{ return memoryString(getMemoryUsageBytes()); }

Here is the call graph for this function:

Here is the caller graph for this function:

getPeakMemoryUsage()

std::string getPeakMemoryUsage

(

)

Returns the current process peak memory usage.

Definition at line 101 of file osutils.cpp.

{ return memoryString(getPeakMemoryUsageBytes()); }

Here is the call graph for this function:

getMemoryUsageBytes()

unsigned long long getMemoryUsageBytes

(

)

Returns the current process memory usage in bytes Parts of code taken from: http://nadeausoftware.com/articles/2012/07/c_c_tip_how_get_process_resident_set_size_physical_memory_use

Definition at line 337 of file osutils.cpp.

                                         {
    unsigned long long rss = 0ULL;
    FILE* fp = NULL;
    if ((fp = fopen("/proc/self/statm", "r")) == NULL)
        return 0ULL; /* Can't open? */
    if (fscanf(fp, "%*s%llu", &rss) != 1) {
        fclose(fp);
        return 0ULL; /* Can't read? */
    }
    fclose(fp);
    return (unsigned long long)rss * (unsigned long long)sysconf(_SC_PAGESIZE);
}

Here is the caller graph for this function:

getPeakMemoryUsageBytes()

unsigned long long getPeakMemoryUsageBytes

(

)

Returns the current process peak memory usage in bytes.

Definition at line 207 of file osutils.cpp.

                                             {
    rusage ru;
    getrusage(RUSAGE_SELF, &ru);
#if defined __APPLE__
    return (size_t)ru.ru_maxrss;
#else
    return (size_t)(ru.ru_maxrss * 1024L);
#endif
}

Here is the caller graph for this function:

getUsername()

std::string getUsername

(

)

Returns the current username.

Definition at line 217 of file osutils.cpp.

                     {
    char* login = getlogin();
#ifdef __linux__
    if (!login)
        login = cuserid(NULL);
#endif
    return login;
}

Here is the caller graph for this function:

getHostname()

std::string getHostname

(

)

Returns the machine name.

Definition at line 226 of file osutils.cpp.

                     {
    char buf[100];
    size_t buflen = 100;
    gethostname(buf, buflen);
    buf[buflen - 1] = '\0';
    return buf;
}

Here is the caller graph for this function:

getSystemDetails()

std::string getSystemDetails

(

)

Returns all the above system details in a single string.

Definition at line 82 of file osutils.cpp.

                          {
    ostringstream oss;
    oss << "System Details:" << endl;
    oss << "  OS                     : " << os::getOsName() << endl;
    oss << "  OS Version             : " << os::getOsVersion() << endl;
    oss << "  CPU                    : " << os::getCpuName() << endl;
    oss << "  Cores                  : " << os::getNumberCores() << endl;
    oss << "  Memory (Available)     : " << os::getMemoryRAM() << endl;
    oss << "  Memory (Process)       : " << os::getMemoryUsage() << endl;
    oss << "  Hostname               : " << os::getHostname() << endl;
    oss << "  Username               : " << os::getUsername() << endl;
    oss << "  ORE Version : " << OPEN_SOURCE_RISK_VERSION << endl;
    oss << "  QuantLib Version       : " << QL_VERSION << endl;
    oss << "  Boost Version          : " << BOOST_LIB_VERSION << endl;
    return oss.str();
}

Here is the call graph for this function:

dumpStacktrace()

void dumpStacktrace

(

)

Write the current stacktrace to stderr and LOG() with level = ALERT.

Definition at line 361 of file osutils.cpp.

                      {
 
    // we overload st here...
#if defined(_WIN32) || defined(_WIN64)
#if BOOST_VERSION > 106500
    boost::stacktrace::stacktrace st = boost::stacktrace::stacktrace();
    unsigned st_size = st.size();
#else
    char** st = NULL;
    unsigned st_size = 0;
#endif
#else
    char** st;
    unsigned st_size = 0;
    void* callstack[1024];
    st_size = backtrace(callstack, 1024);
    st = backtrace_symbols(callstack, st_size);
#endif
 
    // Write st_size and st[] to both std::cerr and ALOG
    std::cerr << "Stacktrace " << st_size << " frames:" << std::endl;
    ALOG("Stacktrace " << st_size << " frames:")
    for (unsigned int i = 0; i < st_size; i++) {
        std::cerr << "#" << i << "  " << st[i] << std::endl;
        ALOG("#" << i << "  " << st[i]);
    }
 
#if defined(_WIN32) || defined(_WIN64)
#else
    if (st)
        free(st);
#endif
}

setAssertHandler()

void setAssertHandler

(

)

Set an assert handler that logs the stacktrace.

Definition at line 405 of file osutils.cpp.

                        {
    ALOG("Setting ORE+ SigAction handler to intercept SIGABRT signals");
 
    // Just in case someone calls this twice
    static bool sigaction_is_set = false;
    if (!sigaction_is_set) {
        struct sigaction psa;
        psa.sa_handler = _oreplus_handler;
        sigaction(SIGABRT, &psa, NULL);
        sigaction(SIGSEGV, &psa, NULL);
        sigaction_is_set = true;
    }
}

parseDate()

QuantLib::Date parseDate

(

const string &

s

)

Convert std::string to QuantLib::Date.

Definition at line 51 of file parsers.cpp.

                                {
    // TODO: review
 
    if (s == "")
        return Date();
 
    // guess formats from token number and sizes
    // check permissible lengths
    QL_REQUIRE((s.size() >= 3 && s.size() <= 6) || s.size() == 8 || s.size() == 10,
               "invalid date format of \"" << s << "\", date string length 8 or 10 or between 3 and 6 required");
 
    vector<string> tokens;
    boost::split(tokens, s, boost::is_any_of("-/.:"));
 
    if (tokens.size() == 1) {
        if (s.size() == 8) {
            // yyyymmdd
            int y = parseInteger(s.substr(0, 4));
            int m = parseInteger(s.substr(4, 2));
            int d = parseInteger(s.substr(6, 2));
            return Date(d, Month(m), y);
        } else if (s.size() >= 3 && s.size() <= 6) {
            // Excel format
            // Boundaries will be checked by Date constructor
            // Boundaries are minDate = 367 i.e. Jan 1st, 1901
            // and maxDate = 109574 i.e. Dec 31st, 2199
            BigInteger serial = parseInteger(s);
            return Date(serial);
        }
    } else if (tokens.size() == 3) {
        if (tokens[0].size() == 4) {
            // yyyy-mm-dd
            // yyyy/mm/dd
            // yyyy.mm.dd
            int y = parseInteger(tokens[0]);
            int m = parseInteger(tokens[1]);
            int d = parseInteger(tokens[2]);
            return Date(d, Month(m), y);
        } else if (tokens[0].size() == 2) {
            // dd-mm-yy
            // dd/mm/yy
            // dd.mm.yy
            // dd-mm-yyyy
            // dd/mm/yyyy
            // dd.mm.yyyy
            int d = parseInteger(tokens[0]);
            int m = parseInteger(tokens[1]);
            int y = parseInteger(tokens[2]);
            if (y < 100) {
                if (y > 80)
                    y += 1900;
                else
                    y += 2000;
            }
            return Date(d, Month(m), y);
        }
    }
 
    QL_FAIL("Cannot convert \"" << s << "\" to Date.");
}

Here is the call graph for this function:

Here is the caller graph for this function:

parseReal()

QuantLib::Real parseReal

(

const string &

s

)

Convert text to Real.

Definition at line 112 of file parsers.cpp.

                                {
    try {
        return std::stod(s);
    } catch (const std::exception& ex) {
        QL_FAIL("Failed to parseReal(\"" << s << "\") " << ex.what());
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

parseRealOrNull()

Real parseRealOrNull

(

const string &

s

)

Convert text to Real, empty string to Null<Real>()

Definition at line 120 of file parsers.cpp.

                                      {
    if(s.empty())
        return Null<Real>();
    return parseReal(s);
}

Here is the call graph for this function:

Here is the caller graph for this function:

tryParseReal()

bool tryParseReal	(	const string &	s,
		QuantLib::Real &	result
	)

Attempt to convert text to Real.

Attempts to convert text to Real

Parameters

[in]	s	The string we wish to convert to a Real
[out]	result	The result of the conversion if it is valid. Null<Real>() if conversion fails

Returns

True if the conversion was successful, False if not

Definition at line 126 of file parsers.cpp.

                                                         {
    try {
        result = std::stod(s);
    } catch (...) {
        result = Null<Real>();
        return false;
    }
    return true;
}

Here is the caller graph for this function:

parseInteger()

QuantLib::Integer parseInteger

(

const string &

s

)

Convert text to QuantLib::Integer.

Definition at line 136 of file parsers.cpp.

                                      {
    try {
        return boost::lexical_cast<Integer>(s.c_str());
    } catch (std::exception& ex) {
        QL_FAIL("Failed to parseInteger(\"" << s << "\") " << ex.what());
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

parseBool()

bool parseBool

(

const string &

s

)

Convert text to bool.

Definition at line 144 of file parsers.cpp.

                                {
    static map<string, bool> b = {{"Y", true},      {"YES", true},    {"TRUE", true},   {"True", true},
                                  {"true", true},   {"1", true},      {"N", false},     {"NO", false},
                                  {"FALSE", false}, {"False", false}, {"false", false}, {"0", false}};
 
    auto it = b.find(s);
    if (it != b.end()) {
        return it->second;
    } else {
        QL_FAIL("Cannot convert \"" << s << "\" to bool");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

parseCalendar()

QuantLib::Calendar parseCalendar

(

const string &

s

)

Convert text to QuantLib::Calendar.

For a joint calendar, the separate calendar names should be comma-delimited.

Definition at line 157 of file parsers.cpp.

{ return CalendarParser::instance().parseCalendar(s); }

Here is the caller graph for this function:

parsePeriod()

QuantLib::Period parsePeriod

(

const string &

s

)

Convert text to QuantLib::Period.

Definition at line 171 of file parsers.cpp.

{ return PeriodParser::parse(s); }

Here is the caller graph for this function:

parseBusinessDayConvention()

QuantLib::BusinessDayConvention parseBusinessDayConvention

(

const string &

s

)

Convert text to QuantLib::BusinessDayConvention.

Definition at line 173 of file parsers.cpp.

                                                                  {
    static map<string, BusinessDayConvention> m = {{"F", Following},
                                                   {"Following", Following},
                                                   {"FOLLOWING", Following},
                                                   {"MF", ModifiedFollowing},
                                                   {"ModifiedFollowing", ModifiedFollowing},
                                                   {"Modified Following", ModifiedFollowing},
                                                   {"MODIFIEDF", ModifiedFollowing},
                                                   {"MODFOLLOWING", ModifiedFollowing},
                                                   {"P", Preceding},
                                                   {"Preceding", Preceding},
                                                   {"PRECEDING", Preceding},
                                                   {"MP", ModifiedPreceding},
                                                   {"ModifiedPreceding", ModifiedPreceding},
                                                   {"Modified Preceding", ModifiedPreceding},
                                                   {"MODIFIEDP", ModifiedPreceding},
                                                   {"U", Unadjusted},
                                                   {"Unadjusted", Unadjusted},
                                                   {"INDIFF", Unadjusted},
                                                   {"HalfMonthModifiedFollowing", HalfMonthModifiedFollowing},
                                                   {"HMMF", HalfMonthModifiedFollowing},
                                                   {"Half Month Modified Following", HalfMonthModifiedFollowing},
                                                   {"HALFMONTHMF", HalfMonthModifiedFollowing},
                                                   {"HalfMonthMF", HalfMonthModifiedFollowing},
                                                   {"NEAREST", Nearest},
                                                   {"NONE", Unadjusted},
                                                   {"NotApplicable", Unadjusted}};
 
    auto it = m.find(s);
    if (it != m.end()) {
        return it->second;
    } else {
        QL_FAIL("Cannot convert \"" << s << "\" to BusinessDayConvention");
    }
}

Here is the caller graph for this function:

parseDayCounter()

QuantLib::DayCounter parseDayCounter

(

const string &

s

)

Convert text to QuantLib::DayCounter.

Definition at line 209 of file parsers.cpp.

                                            {
    static map<string, DayCounter> m = {{"A360", Actual360()},
                                        {"Actual/360", Actual360()},
                                        {"ACT/360", Actual360()},
                                        {"Act/360", Actual360()},
                                        {"A360 (Incl Last)", Actual360(true)},
                                        {"Actual/360 (Incl Last)", Actual360(true)},
                                        {"ACT/360 (Incl Last)", Actual360(true)},
                                        {"Act/360 (Incl Last)", Actual360(true)},
                                        {"A365", Actual365Fixed()},
                                        {"A365F", Actual365Fixed()},
                                        {"Actual/365 (Fixed)", Actual365Fixed()},
                                        {"Actual/365 (fixed)", Actual365Fixed()},
                                        {"ACT/365.FIXED", Actual365Fixed()},
                                        {"ACT/365", Actual365Fixed()},
                                        {"ACT/365L", Actual365Fixed()},
                                        {"Act/365", Actual365Fixed()},
                                        {"Act/365L", Actual365Fixed()},
                                        {"Act/365 (Canadian Bond)", Actual365Fixed(Actual365Fixed::Canadian)},
                                        {"T360", Thirty360(Thirty360::USA)},
                                        {"30/360", Thirty360(Thirty360::USA)},
                                        {"30/360 US", Thirty360(Thirty360::USA)},
                                        {"30/360 (US)", Thirty360(Thirty360::USA)},
                                        {"30U/360", Thirty360(Thirty360::USA)},
                                        {"30US/360", Thirty360(Thirty360::USA)},
                                        {"30/360 (Bond Basis)", Thirty360(Thirty360::BondBasis)},
                                        {"ACT/nACT", Thirty360(Thirty360::USA)},
                                        {"30E/360 (Eurobond Basis)", Thirty360(Thirty360::European)},
                                        {"30/360 AIBD (Euro)", Thirty360(Thirty360::European)},
                                        {"30E/360.ICMA", Thirty360(Thirty360::European)},
                                        {"30E/360 ICMA", Thirty360(Thirty360::European)},
                                        {"30E/360", Thirty360(Thirty360::European)},
                                        {"30E/360E", Thirty360(Thirty360::German)},
                                        {"30E/360.ISDA", Thirty360(Thirty360::German)},
                                        {"30E/360 ISDA", Thirty360(Thirty360::German)},
                                        {"30/360 German", Thirty360(Thirty360::German)},
                                        {"30/360 (German)", Thirty360(Thirty360::German)},
                                        {"30/360 Italian", Thirty360(Thirty360::Italian)},
                                        {"30/360 (Italian)", Thirty360(Thirty360::Italian)},
                                        {"ActActISDA", ActualActual(ActualActual::ISDA)},
                                        {"ACT/ACT.ISDA", ActualActual(ActualActual::ISDA)},
                                        {"Actual/Actual (ISDA)", ActualActual(ActualActual::ISDA)},
                                        {"ActualActual (ISDA)", ActualActual(ActualActual::ISDA)},
                                        {"ACT/ACT", ActualActual(ActualActual::ISDA)},
                                        {"Act/Act", ActualActual(ActualActual::ISDA)},
                                        {"ACT29", ActualActual(ActualActual::AFB)},
                                        {"ACT", ActualActual(ActualActual::ISDA)},
                                        {"ActActISMA", ActualActual(ActualActual::ISMA)},
                                        {"Actual/Actual (ISMA)", ActualActual(ActualActual::ISMA)},
                                        {"ActualActual (ISMA)", ActualActual(ActualActual::ISMA)},
                                        {"ACT/ACT.ISMA", ActualActual(ActualActual::ISMA)},
                                        {"ActActICMA", ActualActual(ActualActual::ISMA)},
                                        {"Actual/Actual (ICMA)", ActualActual(ActualActual::ISMA)},
                                        {"ActualActual (ICMA)", ActualActual(ActualActual::ISMA)},
                                        {"ACT/ACT.ICMA", ActualActual(ActualActual::ISMA)},
                                        {"ActActAFB", ActualActual(ActualActual::AFB)},
                                        {"ACT/ACT.AFB", ActualActual(ActualActual::AFB)},
                                        {"Actual/Actual (AFB)", ActualActual(ActualActual::AFB)},
                                        {"1/1", OneDayCounter()},
                                        {"BUS/252", Business252()},
                                        {"Business/252", Business252()},
                                        {"Actual/365 (No Leap)", Actual365Fixed(Actual365Fixed::NoLeap)},
                                        {"Act/365 (NL)", Actual365Fixed(Actual365Fixed::NoLeap)},
                                        {"NL/365", Actual365Fixed(Actual365Fixed::NoLeap)},
                                        {"Actual/365 (JGB)", Actual365Fixed(Actual365Fixed::NoLeap)},
                                        {"Simple", SimpleDayCounter()},
                                        {"Year", YearCounter()},
                                        {"A364", QuantLib::Actual364()},
                                        {"Actual/364", Actual364()},
                                        {"Act/364", Actual364()},
                                        {"ACT/364", Actual364()}};
 
    auto it = m.find(s);
    if (it != m.end()) {
        return it->second;
 
    } else {
        QL_FAIL("DayCounter \"" << s << "\" not recognized");
    }
}

Here is the caller graph for this function:

parseCurrency()

QuantLib::Currency parseCurrency

(

const string &

s

)

Convert text to QuantLib::Currency.

Definition at line 290 of file parsers.cpp.

{ return CurrencyParser::instance().parseCurrency(s); }

Here is the caller graph for this function:

parseCurrencyType()

QuantExt::ConfigurableCurrency::Type parseCurrencyType

(

const string &

s

)

Convert text to QuantExt::ConfigurableCurrency::Type (Major, Minor, Metal, Crypto)

Definition at line 292 of file parsers.cpp.

                                                                    {
    static map<string, QuantExt::ConfigurableCurrency::Type> m = {
        {"Major", QuantExt::ConfigurableCurrency::Type::Major}, {"Fiat Currency", QuantExt::ConfigurableCurrency::Type::Major},
        {"Fiat", QuantExt::ConfigurableCurrency::Type::Major}, {"Metal", QuantExt::ConfigurableCurrency::Type::Metal}, 
        {"Precious Metal", QuantExt::ConfigurableCurrency::Type::Metal}, {"Crypto", QuantExt::ConfigurableCurrency::Type::Crypto},
        {"Cryptocurrency", QuantExt::ConfigurableCurrency::Type::Crypto}};
 
    auto it = m.find(s);
    if (it != m.end()) {
        return it->second;
    } else {
        QL_FAIL("Currency type \"" << s << "\" not recognised");
    }
}

Here is the caller graph for this function:

parseMinorCurrency()

QuantLib::Currency parseMinorCurrency

(

const string &

s

)

Convert text to QuantLib::Currency for minor currencies e.g GBp -> GBPCurrency()

Definition at line 308 of file parsers.cpp.

{ return CurrencyParser::instance().parseMinorCurrency(s); }

parseCurrencyWithMinors()

QuantLib::Currency parseCurrencyWithMinors

(

const string &

s

)

Convert text to QuantLib::Currency.

Definition at line 310 of file parsers.cpp.

{ return CurrencyParser::instance().parseCurrencyWithMinors(s); }

Here is the caller graph for this function:

parseCurrencyPair()

std::pair< QuantLib::Currency, QuantLib::Currency > parseCurrencyPair	(	const string &	s,
		const string &	delimiters
	)

Convert text to std::pair<QuantLib::Currency, QuantLib::Currency>

Definition at line 312 of file parsers.cpp.

                                                                                      {
    return CurrencyParser::instance().parseCurrencyPair(s, delimiters);
}

checkCurrency()

bool checkCurrency

(

const string &

code

)

check for vaid currency code, including minors and pseudo currencies

Definition at line 316 of file parsers.cpp.

{ return CurrencyParser::instance().isValidCurrency(code); }

isPseudoCurrency()

bool isPseudoCurrency

(

const string &

code

)

check for pseudo currency = precious metal or crypto currency *‍/

Definition at line 318 of file parsers.cpp.

{ return CurrencyParser::instance().isPseudoCurrency(code); }

Here is the caller graph for this function:

isPreciousMetal()

bool isPreciousMetal

(

const string &

code

)

check for precious metal *‍/

Definition at line 320 of file parsers.cpp.

{ return CurrencyParser::instance().isPreciousMetal(code); }

isCryptoCurrency()

bool isCryptoCurrency

(

const string &

code

)

check for crypto currency *‍/

Definition at line 322 of file parsers.cpp.

{ return CurrencyParser::instance().isCryptoCurrency(code); }

convertMinorToMajorCurrency()

QuantLib::Real convertMinorToMajorCurrency	(	const std::string &	s,
		QuantLib::Real	value
	)

Convert a value from a minor ccy to major.

.i.e 100 GBp to 1 GBP

Definition at line 324 of file parsers.cpp.

                                                                                 {
    return CurrencyParser::instance().convertMinorToMajorCurrency(s, value);
}

Here is the caller graph for this function:

parseDateGenerationRule()

QuantLib::DateGeneration::Rule parseDateGenerationRule

(

const string &

s

)

Convert text to QuantLib::DateGeneration::Rule.

Definition at line 328 of file parsers.cpp.

                                                            {
    static map<string, DateGeneration::Rule> m = {{"Backward", DateGeneration::Backward},
                                                  {"Forward", DateGeneration::Forward},
                                                  {"Zero", DateGeneration::Zero},
                                                  {"ThirdWednesday", DateGeneration::ThirdWednesday},
                                                  {"Twentieth", DateGeneration::Twentieth},
                                                  {"TwentiethIMM", DateGeneration::TwentiethIMM},
                                                  {"OldCDS", DateGeneration::OldCDS},
                                                  {"CDS2015", DateGeneration::CDS2015},
                                                  {"CDS", DateGeneration::CDS},
                                                  {"LastWednesday", DateGeneration::LastWednesday}};
 
    auto it = m.find(s);
    if (it != m.end()) {
        return it->second;
    } else {
        QL_FAIL("Date Generation Rule \"" << s << "\" not recognized");
    }
}

Here is the caller graph for this function:

parseFrequency()

QuantLib::Frequency parseFrequency

(

const string &

s

)

Convert text to QuantLib::Frequency.

Definition at line 348 of file parsers.cpp.

                                          {
    static map<string, Frequency> m = {{"Z", Once},
                                       {"Once", Once},
                                       {"A", Annual},
                                       {"Annual", Annual},
                                       {"S", Semiannual},
                                       {"Semiannual", Semiannual},
                                       {"Q", Quarterly},
                                       {"Quarterly", Quarterly},
                                       {"B", Bimonthly},
                                       {"Bimonthly", Bimonthly},
                                       {"M", Monthly},
                                       {"Monthly", Monthly},
                                       {"L", EveryFourthWeek},
                                       {"Lunarmonth", EveryFourthWeek},
                                       {"W", Weekly},
                                       {"Weekly", Weekly},
                                       {"D", Daily},
                                       {"Daily", Daily}};
 
    auto it = m.find(s);
    if (it != m.end()) {
        return it->second;
    } else {
        QL_FAIL("Frequency \"" << s << "\" not recognized");
    }
}

Here is the caller graph for this function:

parseCompounding()

QuantLib::Compounding parseCompounding

(

const string &

s

)

Convert text to QuantLib::Compounding;.

Definition at line 376 of file parsers.cpp.

                                              {
    static map<string, Compounding> m = {
        {"Simple", Simple},
        {"Compounded", Compounded},
        {"Continuous", Continuous},
        {"SimpleThenCompounded", SimpleThenCompounded},
    };
 
    auto it = m.find(s);
    if (it != m.end()) {
        return it->second;
    } else {
        QL_FAIL("Compounding \"" << s << "\" not recognized");
    }
}

Here is the caller graph for this function:

parsePositionType()

QuantLib::Position::Type parsePositionType

(

const std::string &

s

)

Convert text to QuantLib::Position::Type.

Definition at line 404 of file parsers.cpp.

                                                   {
    static map<string, Position::Type> m = {
        {"Long", Position::Long},
        {"Short", Position::Short},
        {"L", Position::Long},
        {"S", Position::Short},
    };
 
    auto it = m.find(s);
    if (it != m.end()) {
        return it->second;
    } else {
        QL_FAIL("Position type \"" << s << "\" not recognized");
    }
}

Here is the caller graph for this function:

parseProtectionSide()

QuantLib::Protection::Side parseProtectionSide

(

const std::string &

s

)

Convert text to QuantLib::Protection::Side.

Definition at line 420 of file parsers.cpp.

                                                       {
    static map<string, Protection::Side> m = {{"Buyer", Protection::Buyer},
                                              {"Seller", Protection::Seller},
                                              {"B", Protection::Buyer},
                                              {"S", Protection::Seller}};
 
    auto it = m.find(s);
    if (it != m.end()) {
        return it->second;
    } else {
        QL_FAIL("Protection side \"" << s << "\" not recognized");
    }
}

parseSettlementType()

QuantLib::Settlement::Type parseSettlementType

(

const std::string &

s

)

Convert text to QuantLib::Settlement::Type.

Definition at line 434 of file parsers.cpp.

                                                       {
    static map<string, Settlement::Type> m = {
        {"Cash", Settlement::Cash},
        {"Physical", Settlement::Physical},
        {"C", Settlement::Cash},
        {"P", Settlement::Physical},
    };
 
    auto it = m.find(s);
    if (it != m.end()) {
        return it->second;
    } else {
        QL_FAIL("Settlement type \"" << s << "\" not recognized");
    }
}

Here is the caller graph for this function:

parseSettlementMethod()

QuantLib::Settlement::Method parseSettlementMethod

(

const std::string &

s

)

Convert text to QuantLib::Settlement::Method.

Definition at line 450 of file parsers.cpp.

                                                           {
    static map<string, Settlement::Method> m = {
        {"PhysicalOTC", Settlement::PhysicalOTC},
        {"PhysicalCleared", Settlement::PhysicalCleared},
        {"CollateralizedCashPrice", Settlement::CollateralizedCashPrice},
        {"ParYieldCurve", Settlement::ParYieldCurve},
    };
 
    auto it = m.find(s);
    if (it != m.end()) {
        return it->second;
    } else {
        QL_FAIL("Settlement method \"" << s << "\" not recognized");
    }
}

Here is the caller graph for this function:

parseExerciseType()

QuantLib::Exercise::Type parseExerciseType

(

const std::string &

s

)

Convert text to QuantLib::Exercise::Type.

Definition at line 466 of file parsers.cpp.

                                                   {
    static map<string, Exercise::Type> m = {
        {"European", Exercise::European},
        {"Bermudan", Exercise::Bermudan},
        {"American", Exercise::American},
    };
 
    auto it = m.find(s);
    if (it != m.end()) {
        return it->second;
    } else {
        QL_FAIL("Exercise type \"" << s << "\" not recognized");
    }
}

Here is the caller graph for this function:

parseOptionType()

QuantLib::Option::Type parseOptionType

(

const std::string &

s

)

Convert text to QuantLib::Option::Type.

Definition at line 481 of file parsers.cpp.

                                               {
    static map<string, Option::Type> m = {{"Put", Option::Put}, {"Call", Option::Call}};
 
    QL_REQUIRE(!s.empty(), "Option type not given.");
    auto it = m.find(s);
    if (it != m.end()) {
        return it->second;
    } else {
        QL_FAIL("Option type \"" << s << "\" not recognized");
    }
}

Here is the caller graph for this function:

parseBondPriceType()

QuantLib::Bond::Price::Type parseBondPriceType

(

const string &

s

)

Convert text to QuantLib::Bond::Price::Type.

Definition at line 392 of file parsers.cpp.

                                                          {
    static map<string, QuantLib::Bond::Price::Type> m = {{"Clean", QuantLib::Bond::Price::Type::Clean},
                                                         {"Dirty", QuantLib::Bond::Price::Type::Dirty}};
 
    auto it = m.find(s);
    if (it != m.end()) {
        return it->second;
    } else {
        QL_FAIL("BondPriceType \"" << s << "\" not recognized");
    }
}

Here is the caller graph for this function:

parseDateOrPeriod() [1/2]

boost::variant< QuantLib::Date, QuantLib::Period > parseDateOrPeriod

(

const string &

s

)

Convert text to QuantLib::Period or QuantLib::Date.

Definition at line 493 of file parsers.cpp.

                                                                              {
    QL_REQUIRE(!s.empty(), "Cannot parse empty string as date or period");
    string c(1, s.back());
    bool isPeriod = c.find_first_of("DdWwMmYy") != string::npos;
    if (isPeriod) {
        return ore::data::parsePeriod(s);
    } else {
        return ore::data::parseDate(s);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

parseDateOrPeriod() [2/2]

void parseDateOrPeriod	(	const string &	s,
		QuantLib::Date &	d,
		QuantLib::Period &	p,
		bool &	isDate
	)

Convert text to QuantLib::Period or QuantLib::Date (deprecated version)

parsePolynomType()

QuantLib::LsmBasisSystem::PolynomialType parsePolynomType

(

const std::string &

s

)

Convert text to QuantLib::LsmBasisSystem::PolynomialType.

Definition at line 527 of file parsers.cpp.

                                                                          {
    static map<string, LsmBasisSystem::PolynomialType> poly = {
        {"Monomial", LsmBasisSystem::PolynomialType::Monomial},
        {"Laguerre", LsmBasisSystem::PolynomialType::Laguerre},
        {"Hermite", LsmBasisSystem::PolynomialType::Hermite},
        {"Hyperbolic", LsmBasisSystem::PolynomialType::Hyperbolic},
        {"Legendre", LsmBasisSystem::PolynomialType::Legendre},
        {"Chebyshev", LsmBasisSystem::PolynomialType::Chebyshev},
        {"Chebyshev2nd", LsmBasisSystem::PolynomialType::Chebyshev2nd},
    };
 
    auto it = poly.find(s);
    if (it != poly.end()) {
        return it->second;
    } else {
        QL_FAIL("Polynom type \"" << s << "\" not recognized");
    }
}

Here is the caller graph for this function:

operator<<() [1/6]

std::ostream & operator<<	(	std::ostream &	os,
		QuantLib::LsmBasisSystem::PolynomialType	a
	)

Write QuantLib::LsmBasisSystem::PolynomialType to stream.

Definition at line 546 of file parsers.cpp.

                                                                               {
    switch (a) {
    case LsmBasisSystem::PolynomialType::Monomial:
        return os << "Monomial";
    case LsmBasisSystem::PolynomialType::Laguerre:
        return os << "Laguerre";
    case LsmBasisSystem::PolynomialType::Hermite:
        return os << "Hermite";
    case LsmBasisSystem::PolynomialType::Hyperbolic:
        return os << "Hyperbolic";
    case LsmBasisSystem::PolynomialType::Legendre:
        return os << "Legendre";
    case LsmBasisSystem::PolynomialType::Chebyshev:
        return os << "Chebychev";
    case LsmBasisSystem::PolynomialType::Chebyshev2nd:
        return os << "Chebychev2nd";
    default:
        QL_FAIL("unknown LsmBasisSystem::PolynomialType '" << static_cast<int>(a) << "'");
    }
}

parseSobolBrownianGeneratorOrdering()

QuantLib::SobolBrownianGenerator::Ordering parseSobolBrownianGeneratorOrdering

(

const std::string &

s

)

Convert text to QuantLib::SobolBrownianGenerator::Ordering.

Definition at line 567 of file parsers.cpp.

                                                                                       {
    static map<string, SobolBrownianGenerator::Ordering> m = {{"Factors", SobolBrownianGenerator::Ordering::Factors},
                                                              {"Steps", SobolBrownianGenerator::Ordering::Steps},
                                                              {"Diagonal", SobolBrownianGenerator::Ordering::Diagonal}};
    auto it = m.find(s);
    if (it != m.end()) {
        return it->second;
    } else {
        QL_FAIL("SobolBrownianGenerator ordering \"" << s << "\" not recognized");
    }
}

Here is the caller graph for this function:

parseSobolRsgDirectionIntegers()

QuantLib::SobolRsg::DirectionIntegers parseSobolRsgDirectionIntegers

(

const std::string &

s

)

Convert text to QuantLib::SobolRsg::DirectionIntegers.

Definition at line 579 of file parsers.cpp.

                                                                             {
    static map<string, SobolRsg::DirectionIntegers> m = {
        {"Unit", SobolRsg::DirectionIntegers::Unit},
        {"Jaeckel", SobolRsg::DirectionIntegers::Jaeckel},
        {"SobolLevitan", SobolRsg::DirectionIntegers::SobolLevitan},
        {"SobolLevitanLemieux", SobolRsg::DirectionIntegers::SobolLevitanLemieux},
        {"JoeKuoD5", SobolRsg::DirectionIntegers::JoeKuoD5},
        {"JoeKuoD6", SobolRsg::DirectionIntegers::JoeKuoD6},
        {"JoeKuoD7", SobolRsg::DirectionIntegers::JoeKuoD7},
        {"Kuo", SobolRsg::DirectionIntegers::Kuo},
        {"Kuo2", SobolRsg::DirectionIntegers::Kuo2},
        {"Kuo3", SobolRsg::DirectionIntegers::Kuo3}};
    auto it = m.find(s);
    if (it != m.end()) {
        return it->second;
    } else {
        QL_FAIL("SobolRsg direction integers \"" << s << "\" not recognized");
    }
}

Here is the caller graph for this function:

parseWeekday()

QuantLib::Weekday parseWeekday

(

const std::string &

s

)

Convert text to QuantLib::Weekday

Definition at line 599 of file parsers.cpp.

                                      {
 
    static map<string, Weekday> m = {{"Sun", Weekday::Sunday},    {"Mon", Weekday::Monday},   {"Tue", Weekday::Tuesday},
                                     {"Wed", Weekday::Wednesday}, {"Thu", Weekday::Thursday}, {"Fri", Weekday::Friday},
                                     {"Sat", Weekday::Saturday}};
 
    auto it = m.find(s);
    if (it != m.end()) {
        return it->second;
    } else {
        QL_FAIL("The string \"" << s << "\" is not recognized as a Weekday");
    }
}

Here is the caller graph for this function:

parseMonth()

QuantLib::Month parseMonth

(

const std::string &

s

)

Convert text to QuantLib::Month

Definition at line 613 of file parsers.cpp.

                                  {
 
    static map<string, Month> m = {{"Jan", Month::January}, {"Feb", Month::February}, {"Mar", Month::March},
                                   {"Apr", Month::April},   {"May", Month::May},      {"Jun", Month::June},
                                   {"Jul", Month::July},    {"Aug", Month::August},   {"Sep", Month::September},
                                   {"Oct", Month::October}, {"Nov", Month::November}, {"Dec", Month::December}};
 
    auto it = m.find(s);
    if (it != m.end()) {
        return it->second;
    } else {
        QL_FAIL("The string \"" << s << "\" is not recognized as a Month");
    }
}

Here is the caller graph for this function:

parsePaymentLag()

PaymentLag parsePaymentLag

(

const string &

s

)

Convert text to PaymentLag.

Definition at line 628 of file parsers.cpp.

                                            {
    Period p;
    Natural n;
    if (tryParse<Period>(s, p, parsePeriod))
        return p;
    else if (tryParse<Natural>(s, n, parseInteger))
        return n;
    else
        return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parseListOfValues()

std::vector< T > parseListOfValues	(	string	s,
		std::function< T(string)>	parser
	)

Convert comma separated list of values to vector of values.

Definition at line 323 of file parsers.hpp.

                                                                                           {
    boost::trim(s);
    std::vector<T> vec;
    boost::char_separator<char> sep(",");
    boost::tokenizer<boost::char_separator<char>> tokens(s, sep);
    for (auto r : tokens) {
        boost::trim(r);
        vec.push_back(parser(r));
    }
    return vec;
}

parseSequenceType()

QuantExt::SequenceType parseSequenceType

(

const std::string &

s

)

Convert string to sequence type.

Definition at line 668 of file parsers.cpp.

                                                   {
    static map<string, SequenceType> seq = {
        {"MersenneTwister", SequenceType::MersenneTwister},
        {"MersenneTwisterAntithetic", SequenceType::MersenneTwisterAntithetic},
        {"Sobol", SequenceType::Sobol},
        {"SobolBrownianBridge", SequenceType::SobolBrownianBridge},
        {"Burley2020SobolBrownianBridge", SequenceType::Burley2020SobolBrownianBridge}};
    auto it = seq.find(s);
    if (it != seq.end())
        return it->second;
    else
        QL_FAIL("sequence type \"" << s << "\" not recognised");
}

Here is the caller graph for this function:

parseObservationInterpolation()

QuantLib::CPI::InterpolationType parseObservationInterpolation

(

const std::string &

s

)

Convert string to observation interpolation.

Definition at line 682 of file parsers.cpp.

                                                                               {
    static map<string, CPI::InterpolationType> seq = {
        {"Flat", CPI::Flat}, {"Linear", CPI::Linear}, {"AsIndex", CPI::AsIndex}};
    auto it = seq.find(s);
    if (it != seq.end())
        return it->second;
    else
        QL_FAIL("observation interpolation type \"" << s << "\" not recognised");
}

Here is the caller graph for this function:

parseFdmSchemeDesc()

QuantLib::FdmSchemeDesc parseFdmSchemeDesc

(

const std::string &

s

)

Convert string to fdm scheme desc.

Definition at line 692 of file parsers.cpp.

                                                     {
    static std::map<std::string, FdmSchemeDesc> m = {{"CrankNicolson", FdmSchemeDesc::CrankNicolson()},
                                                     {"Hundsdorfer", FdmSchemeDesc::Hundsdorfer()},
                                                     {"Douglas", FdmSchemeDesc::Douglas()},
                                                     {"CraigSneyd", FdmSchemeDesc::CraigSneyd()},
                                                     {"ModifiedCraigSneyd", FdmSchemeDesc::ModifiedCraigSneyd()},
                                                     {"ImplicitEuler", FdmSchemeDesc::ImplicitEuler()},
                                                     {"ExplicitEuler", FdmSchemeDesc::ExplicitEuler()},
                                                     {"MethodOfLines", FdmSchemeDesc::MethodOfLines()},
                                                     {"TrBDF2", FdmSchemeDesc::TrBDF2()}};
 
    auto it = m.find(s);
    if (it != m.end())
        return it->second;
    else
        QL_FAIL("fdm scheme \"" << s << "\" not recognised");
}

Here is the caller graph for this function:

parseAssetClass()

AssetClass parseAssetClass

(

const std::string &

s

)

Convert text to ore::data::AssetClass.

Definition at line 710 of file parsers.cpp.

                                               {
    static map<string, AssetClass> assetClasses = {{"EQ", AssetClass::EQ},     {"FX", AssetClass::FX},
                                                   {"COM", AssetClass::COM},   {"IR", AssetClass::IR},
                                                   {"INF", AssetClass::INF},   {"CR", AssetClass::CR},
                                                   {"BOND", AssetClass::BOND}, {"BOND_INDEX", AssetClass::BOND_INDEX}};
    auto it = assetClasses.find(s);
    if (it != assetClasses.end()) {
        return it->second;
    } else {
        QL_FAIL("AssetClass \"" << s << "\" not recognized");
    }
}

operator<<() [2/6]

std::ostream & operator<<	(	std::ostream &	os,
		AssetClass	a
	)

Write ore::data::AssetClass to stream.

Definition at line 723 of file parsers.cpp.

                                                     {
    switch (a) {
    case AssetClass::EQ:
        return os << "EQ";
    case AssetClass::FX:
        return os << "FX";
    case AssetClass::COM:
        return os << "COM";
    case AssetClass::IR:
        return os << "IR";
    case AssetClass::INF:
        return os << "INF";
    case AssetClass::CR:
        return os << "CR";
    case AssetClass::BOND:
        return os << "BOND";
    case AssetClass::BOND_INDEX:
        return os << "BOND_INDEX";
    default:
        QL_FAIL("Unknown AssetClass");
    }
}

parseAtmType()

QuantLib::DeltaVolQuote::AtmType parseAtmType

(

const std::string &

s

)

Convert text to QuantLib::DeltaVolQuote::AtmType.

Definition at line 746 of file parsers.cpp.

                                                      {
    static map<string, DeltaVolQuote::AtmType> m = {{"AtmNull", DeltaVolQuote::AtmNull},
                                                    {"AtmSpot", DeltaVolQuote::AtmSpot},
                                                    {"AtmFwd", DeltaVolQuote::AtmFwd},
                                                    {"AtmDeltaNeutral", DeltaVolQuote::AtmDeltaNeutral},
                                                    {"AtmVegaMax", DeltaVolQuote::AtmVegaMax},
                                                    {"AtmGammaMax", DeltaVolQuote::AtmGammaMax},
                                                    {"AtmPutCall50", DeltaVolQuote::AtmPutCall50}};
 
    auto it = m.find(s);
    if (it != m.end()) {
        return it->second;
    } else {
        QL_FAIL("ATM type \"" << s << "\" not recognized");
    }
}

Here is the caller graph for this function:

parseDeltaType()

QuantLib::DeltaVolQuote::DeltaType parseDeltaType

(

const std::string &

s

)

Convert text to QuantLib::DeltaVolQuote::DeltaType.

Definition at line 763 of file parsers.cpp.

                                                          {
    static map<string, DeltaVolQuote::DeltaType> m = {{"Spot", DeltaVolQuote::Spot},
                                                      {"Fwd", DeltaVolQuote::Fwd},
                                                      {"PaSpot", DeltaVolQuote::PaSpot},
                                                      {"PaFwd", DeltaVolQuote::PaFwd}};
 
    auto it = m.find(s);
    if (it != m.end()) {
        return it->second;
    } else {
        QL_FAIL("Delta type \"" << s << "\" not recognized");
    }
}

Here is the caller graph for this function:

parseRoundingType()

QuantLib::Rounding::Type parseRoundingType

(

const std::string &

s

)

Convert text to QuantLib::Rounding.

Definition at line 1027 of file parsers.cpp.

                                                           {
    static map<string, QuantLib::Rounding::Type> m = {{"Up", QuantLib::Rounding::Type::Up},
                                                      {"Down", QuantLib::Rounding::Type::Down},
                                                      {"Closest", QuantLib::Rounding::Type::Closest},
                                                      {"Floor", QuantLib::Rounding::Type::Floor},
                                                      {"Ceiling", QuantLib::Rounding::Type::Ceiling}};
 
    auto it = m.find(s);
    if (it != m.end()) {
        return it->second;
    } else {
        QL_FAIL("Rounding type \"" << s << "\" not recognized");
    }
}

Here is the caller graph for this function:

parseBarrierType()

QuantLib::Barrier::Type parseBarrierType

(

const std::string &

s

)

Convert std::string to QuantLib::BarrierType.

Definition at line 1042 of file parsers.cpp.

                                                 {
    static map<string, Barrier::Type> type = {{"DownAndIn", Barrier::Type::DownIn},
                                              {"UpAndIn", Barrier::Type::UpIn},
                                              {"DownAndOut", Barrier::Type::DownOut},
                                              {"UpAndOut", Barrier::Type::UpOut},
                                              // Maintain old versions for backwards compatibility
                                              {"Down&In", Barrier::Type::DownIn},
                                              {"Up&In", Barrier::Type::UpIn},
                                              {"Down&Out", Barrier::Type::DownOut},
                                              {"Up&Out", Barrier::Type::UpOut}};
 
    auto it = type.find(s);
    if (it != type.end()) {
        return it->second;
    } else {
        QL_FAIL("Barrier type \"" << s << "\" not recognized");
    }
}

Here is the caller graph for this function:

parseDoubleBarrierType()

QuantLib::DoubleBarrier::Type parseDoubleBarrierType

(

const std::string &

s

)

Convert std::string to QuantLib::DoubleBarrierType.

Definition at line 1061 of file parsers.cpp.

                                                             {
    static map<string, DoubleBarrier::Type> type = {
        {"KnockIn", DoubleBarrier::Type::KnockIn},
        {"KnockOut", DoubleBarrier::Type::KnockOut},
        {"KIKO", DoubleBarrier::Type::KIKO},
        {"KOKI", DoubleBarrier::Type::KOKI},
    };
 
    auto it = type.find(s);
    if (it != type.end()) {
        return it->second;
    } else {
        QL_FAIL("DoubleBarrier type \"" << s << "\" not recognized");
    }
}

Here is the caller graph for this function:

tryParse()

bool tryParse	(	const std::string &	str,
		T &	obj,
		std::function< T(const std::string &)>	parser
	)

Attempt to parse string str to obj of type T using parser

Parameters

[in]	str	The string we wish to parse.
[out]	obj	The resulting object if the parsing was successful.
[in]	parser	The function to use to attempt to parse str. This function may throw.

Returns

true if the parsing was successful and false if not.

Definition at line 427 of file parsers.hpp.

                                                                                                        {
    DLOG("tryParse: attempting to parse " << str);
    try {
        obj = parser(str);
    } catch (...) {
        TLOG("String " << str << " could not be parsed");
        return false;
    }
    return true;
}

Here is the caller graph for this function:

parseVolatilityQuoteType()

QuantLib::VolatilityType parseVolatilityQuoteType

(

const std::string &

s

)

Convert text to QuantLib::VolatilityType

Definition at line 804 of file parsers.cpp.

                                                         {
 
    if (s == "Normal") {
        return Normal;
    } else if (s == "ShiftedLognormal") {
        return ShiftedLognormal;
    } else {
        QL_FAIL("Unknown volatility quote type " << s);
    }
}

parseCapFloorType()

QuantLib::CapFloor::Type parseCapFloorType

(

const std::string &

s

)

Convert text to QuantLib::CapFloor::Type

Definition at line 815 of file parsers.cpp.

                                                {
    if (s == "Cap") {
        return CapFloor::Cap;
    } else if (s == "Floor") {
        return CapFloor::Floor;
    } else if (s == "Collar") {
        return CapFloor::Collar;
    } else {
        QL_FAIL("Unknown cap floor type " << s);
    }
}

Here is the caller graph for this function:

parseYoYInflationCapFloorType()

QuantLib::YoYInflationCapFloor::Type parseYoYInflationCapFloorType

(

const std::string &

s

)

Convert text to QuantLib::YoYInflationCapFloor::Type

Definition at line 827 of file parsers.cpp.

                                                                        {
    if (s == "Cap" || s == "YoYInflationCap") {
        return YoYInflationCapFloor::Cap;
    } else if (s == "Floor" || s == "YoYInflationFloor") {
        return YoYInflationCapFloor::Floor;
    } else if (s == "Collar" || s == "YoYInflationCollar") {
        return YoYInflationCapFloor::Collar;
    } else {
        QL_FAIL("Unknown year on year inflation cap floor type " << s);
    }
}

Here is the caller graph for this function:

parseCamAssetType()

QuantExt::CrossAssetModel::AssetType parseCamAssetType

(

const std::string &

s

)

Convert text to QuantExt::CrossAssetModelTypes::AssetType

Definition at line 839 of file parsers.cpp.

                                                                    {
    if (s == "IR") {
        return QuantExt::CrossAssetModel::AssetType::IR;
    } else if (s == "FX") {
        return QuantExt::CrossAssetModel::AssetType::FX;
    } else if (s == "INF") {
        return QuantExt::CrossAssetModel::AssetType::INF;
    } else if (s == "CR") {
        return QuantExt::CrossAssetModel::AssetType::CR;
    } else if (s == "EQ") {
        return QuantExt::CrossAssetModel::AssetType::EQ;
    } else if (s == "COM") {
        return QuantExt::CrossAssetModel::AssetType::COM;
    } else if (s == "CrState") {
        return QuantExt::CrossAssetModel::AssetType::CrState;
    } else {
        QL_FAIL("Unknown cross asset model type " << s);
    }
}

Here is the caller graph for this function:

parseBoostAny()

std::pair< string, string > parseBoostAny	(	const boost::any &	anyType,
		Size	precision = 8
	)

Convert boost::any to pair<string,string>, including the valueType and the value

Definition at line 859 of file parsers.cpp.

                                                                            {
    string resultType;
    std::ostringstream oss;
 
    if (anyType.type() == typeid(int)) {
        resultType = "int";
        int r = boost::any_cast<int>(anyType);
        oss << std::fixed << std::setprecision(precision) << r;
    } else if (anyType.type() == typeid(Size)) {
        resultType = "size";
        int r = boost::any_cast<Size>(anyType);
        oss << std::fixed << std::setprecision(precision) << r;
    } else if (anyType.type() == typeid(double)) {
        resultType = "double";
        double r = boost::any_cast<double>(anyType);
        if (r != Null<Real>())
            oss << std::fixed << std::setprecision(precision) << r;
    } else if (anyType.type() == typeid(std::string)) {
        resultType = "string";
        std::string r = boost::any_cast<std::string>(anyType);
        oss << std::fixed << std::setprecision(precision) << r;
    } else if (anyType.type() == typeid(Date)) {
        resultType = "date";
        oss << io::iso_date(boost::any_cast<Date>(anyType));
    } else if (anyType.type() == typeid(bool)) {
        resultType = "bool";
        oss << std::boolalpha << boost::any_cast<bool>(anyType);
    } else if (anyType.type() == typeid(std::vector<bool>)) {
        resultType = "vector_bool";
        std::vector<bool> r = boost::any_cast<std::vector<bool>>(anyType);
        if (r.size() == 0) {
            oss << "";
        } else {
            oss << std::boolalpha << "\"" << boost::any_cast<bool>(anyType);
            for (Size i = 1; i < r.size(); i++) {
                oss << ", " << r[i];
            }
            oss << "\"";
        }
    } else if (anyType.type() == typeid(std::vector<double>)) {
        resultType = "vector_double";
        std::vector<double> r = boost::any_cast<std::vector<double>>(anyType);
        if (r.size() == 0) {
            oss << "";
        } else {
            oss << std::fixed << std::setprecision(precision) << "\"";
            if (r[0] != Null<Real>())
                oss << r[0];
            for (Size i = 1; i < r.size(); i++) {
                oss << ", ";
                if (r[i] != Null<Real>())
                    oss << r[i];
            }
            oss << "\"";
        }
    } else if (anyType.type() == typeid(std::vector<Date>)) {
        resultType = "vector_date";
        std::vector<Date> r = boost::any_cast<std::vector<Date>>(anyType);
        if (r.size() == 0) {
            oss << "";
        } else {
            oss << std::fixed << std::setprecision(precision) << "\"" << to_string(r[0]);
            for (Size i = 1; i < r.size(); i++) {
                oss << ", " << to_string(r[i]);
            }
            oss << "\"";
        }
    } else if (anyType.type() == typeid(std::vector<std::string>)) {
        resultType = "vector_string";
        std::vector<std::string> r = boost::any_cast<std::vector<std::string>>(anyType);
        if (r.size() == 0) {
            oss << "";
        } else {
            oss << std::fixed << std::setprecision(precision) << "\"" << r[0];
            for (Size i = 1; i < r.size(); i++) {
                oss << ", " << r[i];
            }
            oss << "\"";
        }
    } else if (anyType.type() == typeid(std::vector<CashFlowResults>)) {
        resultType = "vector_cashflows";
        std::vector<CashFlowResults> r = boost::any_cast<std::vector<CashFlowResults>>(anyType);
        if (!r.empty()) {
            oss << std::fixed << std::setprecision(precision) << "\"" << r[0];
            for (Size i = 1; i < r.size(); ++i) {
                oss << ", " << r[i];
            }
            oss << "\"";
        }
    } else if (anyType.type() == typeid(QuantLib::Matrix)) {
        resultType = "matrix";
        QuantLib::Matrix r = boost::any_cast<QuantLib::Matrix>(anyType);
        std::regex pattern("\n");
        std::ostringstream tmp;
        tmp << std::setprecision(precision) << r;
        oss << std::fixed << std::regex_replace(tmp.str(), pattern, std::string(""));
    } else if (anyType.type() == typeid(QuantLib::Array)) {
        resultType = "array";
        QuantLib::Array r = boost::any_cast<QuantLib::Array>(anyType);
        oss << std::fixed << std::setprecision(precision) << r;
    } else if (anyType.type() == typeid(QuantLib::Currency)) {
        resultType = "currency";
        QuantLib::Currency r = boost::any_cast<QuantLib::Currency>(anyType);
        oss << r;
    } else {
        ALOG("Unsupported Boost::Any type");
        resultType = "unsupported_type";
    }
    return make_pair(resultType, oss.str());
}

Here is the call graph for this function:

Here is the caller graph for this function:

parseCdsOptionStrikeType()

QuantExt::CdsOption::StrikeType parseCdsOptionStrikeType

(

const std::string &

s

)

Convert text to QuantExt::CdsOption::StrikeType

Definition at line 1240 of file parsers.cpp.

                                                              {
    using ST = CdsOption::StrikeType;
    if (s == "Spread") {
        return ST::Spread;
    } else if (s == "Price") {
        return ST::Price;
    } else {
        QL_FAIL("CdsOption::StrikeType \"" << s << "\" not recognized");
    }
}

Here is the caller graph for this function:

parseAverageType()

QuantLib::Average::Type parseAverageType

(

const std::string &

s

)

Convert text to QuantLib::Average::Type

Definition at line 1251 of file parsers.cpp.

                                                 {
    if (s == "Arithmetic") {
        return Average::Type::Arithmetic;
    } else if (s == "Geometric") {
        return Average::Type::Geometric;
    } else {
        QL_FAIL("Average::Type '" << s << "' not recognized. Should be Arithmetic or Geometric");
    }
}

parsePriceQuoteMethod()

QuantExt::BondIndex::PriceQuoteMethod parsePriceQuoteMethod

(

const std::string &

s

)

Convert text to QuantExt::BondData::PriceQuoteMethod

Definition at line 1261 of file parsers.cpp.

                                                                            {
    if (s == "CurrencyPerUnit")
        return QuantExt::BondIndex::PriceQuoteMethod::CurrencyPerUnit;
    else if (s == "PercentageOfPar")
        return QuantExt::BondIndex::PriceQuoteMethod::PercentageOfPar;
    else {
        QL_FAIL("PriceQuoteMethod '" << s << "' not recognized. Expected CurrencyPerUnit or PercentageOfPar.");
    }
}

Here is the caller graph for this function:

fxDominance()

string fxDominance	(	const string &	s1,
		const string &	s2
	)

Convert FX pair to market standard dominance.

Convert FX pair to market standard dominance, e.g. "USD" & "GBP" -> "GBPUSD", "USD" & "JPY" -> "USDJPY"

Definition at line 1296 of file parsers.cpp.

                                                       {
 
    // short cut for trivial inputs EUR,EUR => EUREUR
 
    if (s1 == s2)
        return s1 + s2;
 
    // This should run even if we don't have s1 or s2 in our table, it should not throw
    // It will also work if s1 == s2
 
    static vector<string> dominance = {// Precious Metals (always are before currencies, Metal crosses are not
                                       // common so the ordering of the actual 4 here is just the standard order we see
                                       "XAU", "XAG", "XPT", "XPD",
                                       // The majors (except JPY)
                                       "EUR", "GBP", "AUD", "NZD", "USD", "CAD", "CHF", "ZAR",
                                       // The rest - not really sure about some of these (MXNSEK anyone)
                                       "MYR", "SGD",               // not sure of order here
                                       "DKK", "NOK", "SEK",        // order here is correct
                                       "HKD", "THB", "TWD", "MXN", // not sure of order here
                                       "CNY", "CNH",
 
                                       // JPY at the end (of majors)
                                       "JPY",
                                       // JPYIDR and JPYKRW - who knew!
                                       "IDR", "KRW"};
 
    auto p1 = std::find(dominance.begin(), dominance.end(), s1);
    auto p2 = std::find(dominance.begin(), dominance.end(), s2);
 
    // if both on the list - we return the first one first
    if (p1 != dominance.end() && p2 != dominance.end()) {
        if (p1 > p2)
            return s2 + s1;
        else
            return s1 + s2;
    }
    // if nether on the list - we return s1+s2
    if (p1 == dominance.end() && p2 == dominance.end()) {
        WLOG("No dominance for either " << s1 << " or " << s2 << " assuming " << s1 + s2);
        return s1 + s2;
    }
 
    // if one on the list - we return that first (unless it's JPY - in which case it's last)
    if (s1 == "JPY")
        return s2 + s1;
    else if (s2 == "JPY")
        return s1 + s2;
    else {
        if (p1 != dominance.end())
            return s1 + s2;
        else
            return s2 + s1;
    }
}

Here is the caller graph for this function:

parseMomentType()

MomentType parseMomentType

(

const std::string &

s

)

Convert text to ore::data::MomentType.

Definition at line 1361 of file parsers.cpp.

                                               {
    static map<string, MomentType> momentTypes = {
        {"Variance", MomentType::Variance},
        {"Volatility", MomentType::Volatility},
    };
    auto it = momentTypes.find(s);
    if (it != momentTypes.end()) {
        return it->second;
    } else {
        QL_FAIL("momentTypes \"" << s << "\" not recognized");
    }
}

Here is the caller graph for this function:

parsePillarChoice()

QuantLib::Pillar::Choice parsePillarChoice

(

const std::string &

s

)

Convert text to QuantLib::Pillar::Choice.

Definition at line 1403 of file parsers.cpp.

                                                           {
    /* we support
       - the string corresponding to the enum label (preferred, first alternative below)
       - the string generated by operator<<() in QuantLib */
    if (s == "MaturityDate" || s == "MaturityPillarDate")
        return QuantLib::Pillar::MaturityDate;
    else if (s == "LastRelevantDate" || s == "LastRelevantPillarDate")
        return QuantLib::Pillar::LastRelevantDate;
    else if (s == "CustomDate" || s == "CustomPillarDate")
        return QuantLib::Pillar::CustomDate;
    else {
        QL_FAIL("PillarChoice '" << s << "' not recognized, expected MaturityDate, LastRelevantDate, CustomDate");
    }
}

Here is the caller graph for this function:

parseRegressorModel()

QuantExt::McMultiLegBaseEngine::RegressorModel parseRegressorModel

(

const std::string &

s

)

Convert text to QuantExt::McMultiLegBaseEngine::RegressorModel.

Definition at line 1418 of file parsers.cpp.

                                                                                   {
    if (s == "Simple")
        return McMultiLegBaseEngine::RegressorModel::Simple;
    else if (s == "LaggedFX")
        return McMultiLegBaseEngine::RegressorModel::LaggedFX;
    else {
        QL_FAIL("RegressorModel '" << s << "' not recognized, expected Simple, LaggedFX");
    }
}

Here is the caller graph for this function:

parseMporCashFlowMode()

MporCashFlowMode parseMporCashFlowMode

(

const string &

s

)

Convert text to MporCashFlowMode.

Definition at line 1428 of file parsers.cpp.

                                                       {
    static map<string, MporCashFlowMode> m = {{"Unspecified", MporCashFlowMode::Unspecified},
                                              {"NonePay", MporCashFlowMode::NonePay},
                                              {"BothPay", MporCashFlowMode::BothPay},
                                              {"WePay", MporCashFlowMode::WePay},
                                              {"TheyPay", MporCashFlowMode::TheyPay}};
    auto it = m.find(s);
    if (it != m.end()) {
        return it->second;
    } else {
        QL_FAIL("Mpor cash flow mode \"" << s << "\" not recognized");
    }
}

operator<<() [3/6]

std::ostream & operator<<	(	std::ostream &	out,
		MporCashFlowMode	t
	)

Write MporCashFlowMode to stream.

Definition at line 1441 of file parsers.cpp.

                                                            {
    if (t == MporCashFlowMode::Unspecified)
        out << "Unspecified";
    else if (t == MporCashFlowMode::NonePay)
        out << "NonePay";
    else if (t == MporCashFlowMode::BothPay)
        out << "BothPay";
    else if (t == MporCashFlowMode::WePay)
        out << "WePay";
    else if (t == MporCashFlowMode::TheyPay)
        out << "TheyPay";
    else
        QL_FAIL("Mpor cash flow mode not covered, expected one of 'Unspecified', 'NonePay', 'BothPay', 'WePay', "
                "'TheyPay'.");
    return out;
}

parseSabrParametricVolatilityModelVariant()

QuantExt::SabrParametricVolatility::ModelVariant parseSabrParametricVolatilityModelVariant

(

const std::string &

s

)

Parse SabrParametricVolatility::ModelVariant.

Definition at line 1458 of file parsers.cpp.

                                                                                                   {
    static map<string, SabrParametricVolatility::ModelVariant> m = {
        {"Hagan2002Lognormal", SabrParametricVolatility::ModelVariant::Hagan2002Lognormal},
        {"Hagan2002Normal", SabrParametricVolatility::ModelVariant::Hagan2002Normal},
        {"Hagan2002NormalZeroBeta", SabrParametricVolatility::ModelVariant::Hagan2002NormalZeroBeta},
        {"Antonov2015FreeBoundaryNormal", SabrParametricVolatility::ModelVariant::Antonov2015FreeBoundaryNormal},
        {"KienitzLawsonSwaynePde", SabrParametricVolatility::ModelVariant::KienitzLawsonSwaynePde},
        {"FlochKennedy", SabrParametricVolatility::ModelVariant::FlochKennedy}};
    auto it = m.find(s);
    if (it != m.end()) {
        return it->second;
    } else {
        QL_FAIL(
            "SabrParametricVolatilityModelVariant '"
            << s
            << "' not recognized, expected one of 'Hagan2002Lognormal', 'Hagan2002Normal', 'Hagan2002NormalZeroBeta', "
               "'Antonov2015FreeBoundaryNormal', 'KienitzLawsonSwaynePde', 'FlochKennedy'.");
    }
}

Here is the caller graph for this function:

operator<<() [4/6]

std::ostream & operator<<	(	std::ostream &	out,
		SabrParametricVolatility::ModelVariant	m
	)

Write SabrParametricVolatility::ModelVariant.

Definition at line 1478 of file parsers.cpp.

                                                                                {
    if (m == SabrParametricVolatility::ModelVariant::Hagan2002Lognormal) {
        out << "Hagan2002Lognormal";
    } else if (m == SabrParametricVolatility::ModelVariant::Hagan2002Normal) {
        out << "Hagan2002Normal";
    } else if (m == SabrParametricVolatility::ModelVariant::Hagan2002NormalZeroBeta) {
        out << "Hagan200NormalZeroBeta";
    } else if (m == SabrParametricVolatility::ModelVariant::Antonov2015FreeBoundaryNormal) {
        out << "AntonovNormalZeroBeta";
    } else if (m == SabrParametricVolatility::ModelVariant::KienitzLawsonSwaynePde) {
        out << "KienitzLawsonSwaynePde";
    } else if (m == SabrParametricVolatility::ModelVariant::FlochKennedy) {
        out << "FlochKennedy";
    } else {
        QL_FAIL("SabrParametricVolatility::ModelVariant (" << static_cast<int>(m)
                                                           << ") not recognized. This is an internal error.");
    }
    return out;
}

operator<<() [5/6]

std::ostream & operator<<	(	std::ostream &	os,
		QuantLib::Exercise::Type	type
	)

Write QuantLib::Exercise::Type.

serialize() [1/3]

void serialize	(	Archive &	ar,
		QuantLib::Date &	d,
		const unsigned int
	)

Allow for serialization of QuantLib::Date without amending its class (non-intrusive)

Definition at line 37 of file serializationdate.hpp.

                                                                                          {
    QuantLib::Date::serial_type big;
    if (Archive::is_saving::value) {
        // When serializing, convert to long and save
        big = d.serialNumber();
        ar& big;
    } else {
        // When deserializing, write out saved long and convert to Date
        ar& big;
        if (big == 0)
            d = QuantLib::Date();
        else
            d = QuantLib::Date(big);
    }
}

serialize() [2/3]

void serialize	(	Archive &	ar,
		QuantLib::DayCounter &	dc,
		const unsigned int
	)

Allow for serialization of QuantLib::Period without amending its class (non-intrusive)

Definition at line 39 of file serializationdaycounter.hpp.

                                                                                                 {
    // handle the day counter via the name
    std::string dcName;
    if (Archive::is_saving::value) {
        dcName = dc.empty() ? "" : dc.name();
        ar& dcName;
    } else {
        ar& dcName;
        if (!dcName.empty()) {
            try {
                dc = ore::data::parseDayCounter(dcName);
            } catch (const std::exception& e) {
                QL_FAIL("could not deserialize day counter, please extend parseDayCounter(): " << e.what());
            }
        }
    }
}

Here is the call graph for this function:

serialize() [3/3]

void serialize	(	Archive &	ar,
		QuantLib::Period &	p,
		const unsigned int
	)

Allow for serialization of QuantLib::Period without amending its class (non-intrusive)

Definition at line 37 of file serializationperiod.hpp.

                                                                                            {
    QuantLib::Integer length;
    QuantLib::TimeUnit units;
    if (Archive::is_saving::value) {
        length = p.length();
        units = p.units();
        ar& length;
        ar& units;
    } else {
        ar& length;
        ar& units;
        p = QuantLib::Period(length, units);
    }
}

parseStrike()

Strike parseStrike

(

const std::string &

s

)

Convert text to Strike.

Definition at line 30 of file strike.cpp.

                                       {
    static boost::mutex mutex_;
    boost::lock_guard<boost::mutex> lock(mutex_);
 
    boost::regex m1("^(ATM|atm)");
    boost::regex m1b("^(ATMF|atmf)");
    boost::regex m2("^(ATM|atm)(\\+|\\-)([0-9]+[.]?[0-9]*)");
    boost::regex m3("^(\\+|\\-)?([0-9]+[.]?[0-9]*)");
    boost::regex m4("^(\\+|\\-)?([0-9]+[.]?[0-9]*)(d|D)");
    boost::regex m4b("(d|D)");
    boost::regex m5("^(\\+|\\-)?([0-9]+[.]?[0-9]*)(c|C)");
    boost::regex m5b("^(c|C)");
    boost::regex m6("^(\\+|\\-)?([0-9]+[.]?[0-9]*)(p|P)");
    boost::regex m6b("^(p|P)");
    boost::regex m7("^(\\+|\\-)?([0-9]+[.]?[0-9]*)(bf|BF)");
    boost::regex m7b("^(bf|BF)");
    boost::regex m8("^(\\+|\\-)?([0-9]+[.]?[0-9]*)(rr|RR)");
    boost::regex m8b("^(rr|RR)");
    boost::regex m9("^(\\+|\\-)?([0-9]+[.]?[0-9]*)(ATMF|atmf)");
    boost::regex m9b("(ATMF|atmf)");
    boost::regex m10("^(\\+|\\-)?([0-9]+[.]?[0-9]*)(ATM|atm)");
    boost::regex m10b("(ATM|atm)");
    Strike result;
    if (boost::regex_match(s, m1)) {
        result.type = Strike::Type::ATM;
        result.value = 0.0;
        return result;
    }
    if (boost::regex_match(s, m1b)) {
        result.type = Strike::Type::ATMF;
        result.value = 0.0;
        return result;
    }
    if (boost::regex_match(s, m2)) {
        result.type = Strike::Type::ATM_Offset;
        result.value = parseReal(regex_replace(s, m1, std::string("")));
        return result;
    }
    if (boost::regex_match(s, m3)) {
        result.type = Strike::Type::Absolute;
        result.value = parseReal(s);
        return result;
    }
    if (boost::regex_match(s, m4)) {
        result.type = Strike::Type::Delta;
        result.value = parseReal(regex_replace(s, m4b, std::string("")));
        return result;
    }
    if (boost::regex_match(s, m5)) {
        result.type = Strike::Type::DeltaCall;
        result.value = parseReal(regex_replace(s, m5b, std::string("")));
        return result;
    }
    if (boost::regex_match(s, m6)) {
        result.type = Strike::Type::DeltaPut;
        result.value = parseReal(regex_replace(s, m6b, std::string("")));
        return result;
    }
    if (boost::regex_match(s, m7)) {
        result.type = Strike::Type::BF;
        result.value = parseReal(regex_replace(s, m7b, std::string("")));
        return result;
    }
    if (boost::regex_match(s, m8)) {
        result.type = Strike::Type::RR;
        result.value = parseReal(regex_replace(s, m8b, std::string("")));
        return result;
    }
    if (boost::regex_match(s, m9)) {
        result.type = Strike::Type::ATMF_Moneyness;
        result.value = parseReal(regex_replace(s, m9b, std::string("")));
        return result;
    }
    if (boost::regex_match(s, m10)) {
        result.type = Strike::Type::ATM_Moneyness;
        result.value = parseReal(regex_replace(s, m10b, std::string("")));
        return result;
    }
    QL_FAIL("could not parse strike given by " << s);
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator<<() [6/6]

std::ostream & operator<<	(	std::ostream &	out,
		const Strike &	s
	)

Convert Strike to text.

Definition at line 111 of file strike.cpp.

                                                         {
    switch (s.type) {
    case Strike::Type::ATM:
        out << "ATM";
        break;
    case Strike::Type::ATMF:
        out << "ATMF";
        break;
    case Strike::Type::ATM_Offset:
        out << "ATM_Offset";
        break;
    case Strike::Type::Absolute:
        out << "Absolute";
        break;
    case Strike::Type::Delta:
        out << "Delta";
        break;
    case Strike::Type::ATMF_Moneyness:
        out << "ATMF_Moneyness";
        break;
    case Strike::Type::ATM_Moneyness:
        out << "ATM_Moneyness";
        break;
    default:
        out << "UNKNOWN";
        break;
    }
    if (s.type == Strike::Type::ATM_Offset || s.type == Strike::Type::Absolute || s.type == Strike::Type::Delta ||
        s.type == Strike::Type::ATMF_Moneyness || s.type == Strike::Type::ATM_Moneyness) {
        if (s.value >= 0.0)
            out << "+";
        else
            out << "-";
        out << s.value;
    }
    return out;
}

operator==()

bool operator==	(	const Strike &	s1,
		const Strike &	s2
	)

Logical comparison of strikes.

Definition at line 161 of file strike.cpp.

                                                    {
    Strike tmp1 = normaliseStrike(s1);
    Strike tmp2 = normaliseStrike(s2);
    return (tmp1.type == tmp2.type && QuantLib::close_enough(tmp1.value, tmp2.value));
}

computeAbsoluteStrike()

QuantLib::Real computeAbsoluteStrike	(	const Strike &	s,
		const QuantLib::Real	atm,
		const QuantLib::Real	atmf
	)

Convenience function that computes an absolute strike.

Definition at line 167 of file strike.cpp.

                                                                                                     {
    switch (s.type) {
    case Strike::Type::ATM:
        return atm;
    case Strike::Type::ATMF:
        return atmf;
    case Strike::Type::ATM_Offset:
        return atm + s.value;
    case Strike::Type::Absolute:
        return s.value;
    case Strike::Type::Delta:
        QL_FAIL("can not compute absolute strike for type delta");
    case Strike::Type::ATMF_Moneyness:
        return atmf * s.value;
    case Strike::Type::ATM_Moneyness:
        return atm * s.value;
    default:
        QL_FAIL("can not compute strike for unknown type " << s);
    }
}

to_string() [1/6]

std::string to_string

(

const QuantLib::Date &

date

)

Convert QuantLib::Date to std::string.

Returns date as a string in YYYY-MM-DD format, which matches QuantLib::io::iso_date() However that function can have issues with locale so we have a local snprintf() based version.

If date == Date() returns 1900-01-01 so the above format is preserved.

Here is the call graph for this function:

to_string() [2/6]

std::string to_string

(

bool

aBool

)

Convert bool to std::string.

Returns "true" for true and "false" for false

Definition at line 57 of file to_string.cpp.

{ return aBool ? "true" : "false"; }

Here is the call graph for this function:

to_string() [3/6]

std::string to_string

(

const QuantLib::Period &

period

)

Convert QuantLib::Period to std::string.

Returns Period as a string as up to QuantLib 1.25, e.g. 13M is written as 1Y1M etc.

Here is the call graph for this function:

to_string() [4/6]

std::string to_string	(	const std::vector< T > &	vec,
		const std::string &	sep = ","
	)

Convert vector to std::string.

Returns a vector into a single string, with elemenst separated by Period as a string as up to QuantLib 1.25, e.g. 13M is written as 1Y1M etc.

Definition at line 66 of file to_string.hpp.

                                                                                             {
    std::ostringstream oss;
    for (std::size_t i = 0; i < vec.size(); ++i) {
        oss << vec[i];
        if (i < vec.size() - 1)
            oss << sep;
    }
    return oss.str();    
}

Here is the call graph for this function:

to_string() [5/6]

std::string to_string	(	const std::set< T > &	set,
		const std::string &	sep = ","
	)

Convert set to std::string.

Definition at line 80 of file to_string.hpp.

                                                                                          {
    std::ostringstream oss;
    std::size_t count = 1;
    for (auto s: set) {
        oss << s;
        if (count < set.size())
            oss << sep;
        count++;
    }
    return oss.str();    
}

Here is the call graph for this function:

to_string() [6/6]

std::string to_string

(

const T &

t

)

Convert type to std::string.

Utility to give to_string() interface to classes and enums that have ostream<< operators defined.

Definition at line 97 of file to_string.hpp.

                                                   {
    std::ostringstream oss;
    oss << t;
    return oss.str();
}

Here is the call graph for this function:

sort_permutation()

std::vector< std::size_t > sort_permutation	(	const std::vector< T > &	vec,
		Compare &	compare
	)

Definition at line 38 of file vectorutils.hpp.

                                                                                 {
    std::vector<std::size_t> p(vec.size());
    std::iota(p.begin(), p.end(), 0);
    std::sort(p.begin(), p.end(), [&](std::size_t i, std::size_t j) { return compare(vec[i], vec[j]); });
    return p;
}

Here is the caller graph for this function:

apply_permutation()

std::vector< T > apply_permutation	(	const std::vector< T > &	vec,
		const std::vector< std::size_t > &	p
	)

Definition at line 45 of file vectorutils.hpp.

                                                                                                             {
    std::vector<T> sorted_vec(vec.size());
    std::transform(p.begin(), p.end(), sorted_vec.begin(), [&](std::size_t i) { return vec[i]; });
    return sorted_vec;
}

apply_permutation_in_place()

void apply_permutation_in_place	(	std::vector< T > &	vec,
		const std::vector< std::size_t > &	p
	)

Definition at line 51 of file vectorutils.hpp.

                                                                                                        {
    std::vector<bool> done(vec.size());
    for (std::size_t i = 0; i < vec.size(); ++i) {
        if (done[i])
            continue;
        done[i] = true;
        for (std::size_t j = p[i]; i != j; j = p[j]) {
            std::swap(vec[i], vec[j]);
            done[j] = true;
        }
    }
}

Here is the caller graph for this function: