PayLog Class Reference

#include <ored/scripting/paylog.hpp>

Collaboration diagram for PayLog:

Public Member Functions
void	write (RandomVariable value, const Filter &filter, const Date &obs, const Date &pay, const std::string &ccy, const Size legNo, const std::string &cashflowType, const Size slot=0)
void	consolidateAndSort ()
Size	size () const
const std::vector< RandomVariable > &	amounts () const
const std::vector< Date > &	dates () const
const std::vector< std::string > &	currencies () const
const std::vector< Size > &	legNos () const
const std::vector< std::string > &	cashflowTypes () const

Private Attributes
std::vector< Size >	slots_
std::vector< RandomVariable >	amounts_
std::vector< Date >	dates_
std::vector< std::string >	currencies_
std::vector< Size >	legNos_
std::vector< std::string >	cashflowTypes_

Detailed Description

Definition at line 36 of file paylog.hpp.

Member Function Documentation

write()

void write	(	RandomVariable	value,
		const Filter &	filter,
		const Date &	obs,
		const Date &	pay,
		const std::string &	ccy,
		const Size	legNo,
		const std::string &	cashflowType,
		const Size	slot = 0
	)

Definition at line 25 of file paylog.cpp.

                                                                                     {
 
    // if a slot is given, we erase the results that we already have for this slot
 
    if (slot != 0) {
        for (Size i = 0; i < slots_.size(); ++i) {
            if (slot == slots_[i]) {
                amounts_[i] = applyInverseFilter(amounts_[i], filter);
            }
        }
    }
 
    // determine the index where the result belongs, i.e. look for an existing entry for the given
    // pay date, ccy, legNo, cashflowType and slot
 
    Size idx = Null<Size>();
    for (Size i = 0; i < slots_.size(); ++i) {
        if (dates_[i] == pay && currencies_[i] == ccy && legNos_[i] == legNo && cashflowTypes_[i] == cashflowType &&
            (slot == slots_[i]))
            idx = i;
    }
 
    // if we did not find a slot, we create one
 
    if (idx == Null<Size>()) {
        slots_.push_back(slot);
        amounts_.push_back(RandomVariable(value.size(), 0.0));
        dates_.push_back(pay);
        currencies_.push_back(ccy);
        legNos_.push_back(legNo);
        cashflowTypes_.push_back(cashflowType);
        idx = slots_.size() - 1;
    }
 
    // add the value
 
    amounts_[idx] += applyFilter(value, filter);
}

Here is the call graph for this function:

consolidateAndSort()

void consolidateAndSort

(

)

Definition at line 65 of file paylog.cpp.

                                {
 
    // Create set of (legNo, payDate, payCcy, cfType),  index in amounts / dates / ... vectors.
    // This will also create the sorting we want. Ignore slots from here on.
 
    std::set<std::tuple<Size, Date, std::string, std::string, Size>> dates;
    for (Size i = 0; i < slots_.size(); ++i) {
        dates.insert(std::make_tuple(legNos_[i], dates_[i], currencies_[i], cashflowTypes_[i], i));
    }
 
    // build consolidated and sorted vector
 
    std::vector<Date> resultDates;
    std::vector<std::string> resultCurrencies;
    std::vector<Size> resultLegNos;
    std::vector<std::string> resultCashflowTypes;
    std::vector<RandomVariable> resultAmounts;
    Date lastDate = Null<Date>();
    std::string lastCurrency;
    Size lastLegNo = Null<Size>();
    std::string lastCashflowType;
    for (auto const& d : dates) {
        if (std::get<1>(d) == lastDate && std::get<2>(d) == lastCurrency && std::get<0>(d) == lastLegNo &&
            std::get<3>(d) == lastCashflowType)
            resultAmounts.back() += amounts_[std::get<4>(d)];
        else {
            resultAmounts.push_back(amounts_[std::get<4>(d)]);
            resultDates.push_back(std::get<1>(d));
            resultCurrencies.push_back(std::get<2>(d));
            resultLegNos.push_back(std::get<0>(d));
            resultCashflowTypes.push_back(std::get<3>(d));
        }
        lastDate = std::get<1>(d);
        lastCurrency = std::get<2>(d);
        lastLegNo = std::get<0>(d);
        lastCashflowType = std::get<3>(d);
    }
 
    // overwrite the existing members
 
    amounts_ = std::move(resultAmounts);
    dates_ = std::move(resultDates);
    currencies_ = std::move(resultCurrencies);
    legNos_ = std::move(resultLegNos);
    cashflowTypes_ = std::move(resultCashflowTypes);
 
    // reset slots
 
    slots_ = std::vector<Size>(amounts_.size(), 0);
}

Here is the call graph for this function:

size()

Size size

(

)

const

Definition at line 46 of file paylog.hpp.

{ return slots_.size(); }

amounts()

const std::vector< RandomVariable > & amounts

(

)

const

Definition at line 47 of file paylog.hpp.

{ return amounts_; }

dates()

const std::vector< Date > & dates

(

)

const

Definition at line 48 of file paylog.hpp.

{ return dates_; }

Here is the caller graph for this function:

currencies()

const std::vector< std::string > & currencies

(

)

const

Definition at line 49 of file paylog.hpp.

{ return currencies_; }

legNos()

const std::vector< Size > & legNos

(

)

const

Definition at line 50 of file paylog.hpp.

{ return legNos_; }

cashflowTypes()

const std::vector< std::string > & cashflowTypes

(

)

const

Definition at line 51 of file paylog.hpp.

{ return cashflowTypes_; }

Member Data Documentation

slots_

std::vector<Size> slots_

private

Definition at line 54 of file paylog.hpp.

amounts_

std::vector<RandomVariable> amounts_

private

Definition at line 55 of file paylog.hpp.

dates_

std::vector<Date> dates_

private

Definition at line 56 of file paylog.hpp.

currencies_

std::vector<std::string> currencies_

private

Definition at line 57 of file paylog.hpp.

legNos_

std::vector<Size> legNos_

private

Definition at line 58 of file paylog.hpp.

cashflowTypes_

std::vector<std::string> cashflowTypes_

private

Definition at line 59 of file paylog.hpp.