#include <qle/models/carrmadanarbitragecheck.hpp>

Collaboration diagram for CarrMadanSurface:

Public Member Functions
	CarrMadanSurface (const std::vector< Real > &times, const std::vector< Real > &moneyness, const Real spot, const std::vector< Real > &forwards, const std::vector< std::vector< Real > > &callPrices)

const std::vector< Real > &	times () const

const std::vector< Real > &	moneyness () const

Real	spot () const

const std::vector< Real > &	forwards () const

const std::vector< std::vector< Real > > &	callPrices () const

bool	arbitrageFree () const

const std::vector< CarrMadanMarginalProbability > &	timeSlices () const

const std::vector< std::vector< bool > > &	callSpreadArbitrage () const

const std::vector< std::vector< bool > > &	butterflyArbitrage () const

const std::vector< std::vector< bool > > &	calendarArbitrage () const

Private Attributes
std::vector< Real >	times_

std::vector< Real >	moneyness_

Real	spot_

std::vector< Real >	forwards_

std::vector< std::vector< Real > >	callPrices_

std::vector< CarrMadanMarginalProbability >	timeSlices_

bool	surfaceIsArbitrageFree_

std::vector< std::vector< bool > >	callSpreadArbitrage_

std::vector< std::vector< bool > >	butterflyArbitrage_

std::vector< std::vector< bool > >	calendarArbitrage_

Detailed Description

Definition at line 101 of file carrmadanarbitragecheck.hpp.

Constructor & Destructor Documentation

◆ CarrMadanSurface()

CarrMadanSurface	(	const std::vector< Real > &	times,
		const std::vector< Real > &	moneyness,
		const Real	spot,
		const std::vector< Real > &	forwards,
		const std::vector< std::vector< Real > > &	callPrices
	)

The moneyness is defined as K / F, K = strike, F = forward at the relevant time. The times and moneyness should be strictly increasing. The outer vectors for call prices and the calendarAbritrage() result represent times, the inner strikes.

Definition at line 181 of file carrmadanarbitragecheck.cpp.

    : times_(times), moneyness_(moneyness), spot_(spot), forwards_(forwards), callPrices_(callPrices) {
 
    // checks
 
    QL_REQUIRE(times_.size() == callPrices_.size(),
               "CarrMadanSurface: times size (" << times_.size() << ") does not match callPrices outer vector size ("
                                                << callPrices_.size() << ")");
    QL_REQUIRE(times.size() == forwards_.size(), "CarrMadanSurface: times size (" << times_.size()
                                                                                  << ") does not match forwards size ("
                                                                                  << forwards_.size() << ")");
 
    QL_REQUIRE(!times_.empty(), "CarrMadanSurface: times are empty");
 
    for (Size i = 1; i < times_.size(); ++i) {
        QL_REQUIRE(times_[i] > times_[i - 1] && !close_enough(times_[i], times_[i - 1]),
                   "CarrMadanSurface: times not increasing at index " << (i - 1) << ", " << i << ": " << times_[i - 1]
                                                                      << ", " << times_[i]);
    }
 
    QL_REQUIRE(times_.front() > 0.0 || close_enough(times_.front(), 0.0),
               "CarrMadanSurface: all input times must be positive or zero, got " << times_.front());
 
    for (Size i = 0; i < times_.size(); ++i) {
        QL_REQUIRE(callPrices_[i].size() == moneyness_.size(), "CarrMadanSurface: callPrices at time "
                                                                   << times_[i] << "(" << callPrices_[i].size()
                                                                   << ") should match moneyness size ("
                                                                   << moneyness_.size() << ")");
    }
 
    // construct the time slices
 
    surfaceIsArbitrageFree_ = true;
    for (Size i = 0; i < times_.size(); ++i) {
        std::vector<Real> strikes(moneyness_.size());
        Real f = forwards_[i];
        std::transform(moneyness_.begin(), moneyness_.end(), strikes.begin(), [&f](Real m) { return m * f; });
        timeSlices_.push_back(CarrMadanMarginalProbability(strikes, forwards_[i], callPrices_[i]));
        surfaceIsArbitrageFree_ = surfaceIsArbitrageFree_ && timeSlices_.back().arbitrageFree();
        callSpreadArbitrage_.push_back(timeSlices_.back().callSpreadArbitrage());
        butterflyArbitrage_.push_back(timeSlices_.back().butterflyArbitrage());
    }
 
    // check for calendar arbitrage
 
    calendarArbitrage_ = std::vector<std::vector<bool>>(times_.size(), std::vector<bool>(moneyness_.size()));
    for (Size i = 0; i < moneyness_.size(); ++i) {
        for (Size j = 0; j < times_.size() - 1; ++j) {
            Real c2 = callPrices_[j + 1][i] * spot_ / forwards_[j + 1];
            Real c1 = callPrices_[j][i] * spot_ / forwards_[j];
            bool af = c2 > c1 || close_enough(c1, c2);
            if (!af) {
                calendarArbitrage_[j][i] = true;
                calendarArbitrage_[j + 1][i] = true;
                surfaceIsArbitrageFree_ = false;
            }
        }
    }
}