#include <qle/models/carrmadanarbitragecheck.hpp>

Collaboration diagram for CarrMadanMarginalProbability:

Public Member Functions
	CarrMadanMarginalProbability (const std::vector< Real > &strikes, const Real forward, const std::vector< Real > &callPrices, const VolatilityType volType=ShiftedLognormal, const Real shift=0.0)

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

Real	forward () const

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

VolatilityType	volatilityType () const

Real	shift () const

bool	arbitrageFree () const

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

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

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

Private Attributes
std::vector< Real >	strikes_

Real	forward_

std::vector< Real >	callPrices_

VolatilityType	volType_

Real	shift_

std::vector< bool >	callSpreadArbitrage_

std::vector< bool >	butterflyArbitrage_

std::vector< Real >	q_

bool	smileIsArbitrageFree_

Detailed Description

Definition at line 36 of file carrmadanarbitragecheck.hpp.

Constructor & Destructor Documentation

◆ CarrMadanMarginalProbability()

CarrMadanMarginalProbability	(	const std::vector< Real > &	strikes,
		const Real	forward,
		const std::vector< Real > &	callPrices,
		const VolatilityType	volType = `ShiftedLognormal`,
		const Real	shift = `0.0`
	)

The callPrices should be non-discounted

Definition at line 29 of file carrmadanarbitragecheck.cpp.

    : strikes_(strikes), forward_(forward), callPrices_(callPrices), volType_(volType), shift_(shift) {
 
    // check input
 
    QL_REQUIRE(close_enough(shift_, 0.0) || shift_ > 0.0,
               "CarrMadanMarginalProbability: shift (" << shift_ << ") must be non-negative");
 
    QL_REQUIRE(strikes_.size() == callPrices_.size(), "CarrMadanMarginalProbability: strikes ("
                                                          << strikes_.size() << ") inconsistent to callPrices ("
                                                          << callPrices_.size() << ")");
 
    QL_REQUIRE(!strikes_.empty(), "CarrMadanMarginalProbability: input moneyness is empty");
 
    // build sort permutation for strikes
 
    std::vector<Size> perm(strikes.size());
    std::iota(perm.begin(), perm.end(), 0);
    std::sort(perm.begin(), perm.end(), [this](Size a, Size b) { return strikes_[a] < strikes_[b]; });
 
    // check strikes are different (and increasing for the found permutation)
 
    for (Size i = 1; i < strikes_.size(); ++i) {
        QL_REQUIRE(strikes_[perm[i]] > strikes_[perm[i - 1]] && !close_enough(strikes_[perm[i]], strikes_[perm[i - 1]]),
                   "CarrMadanMarginalProbability: duplicate strikes at "
                       << perm[i - 1] << ", " << perm[i] << ": " << strikes[perm[i - 1]] << ", " << strikes[perm[i]]);
    }
 
    QL_REQUIRE(volType_ == Normal || strikes_[perm[0]] > -shift_ || close_enough(strikes_[perm[0]], -shift_),
               "CarrMadanMarginalProbability: all input strikes (" << strikes_[perm[0]] << ") plus shift (" << shift
                                                                   << ") must be positive or zero, got "
                                                                   << strikes_[perm[0]] + shift);
 
    /* add strike -shift and corresponding call price (= forward + shift), if not already present
       this is only done for ShiftedLognormal vols, not for Normal */
    bool minusShiftStrikeAdded = false;
    if (volType_ == ShiftedLognormal) {
        if (!close_enough(strikes_[perm[0]], 0.0)) {
            strikes_.push_back(-shift);
            callPrices_.push_back(forward_);
            perm.insert(perm.begin(), strikes_.size() - 1);
            minusShiftStrikeAdded = true;
        } else {
            QL_REQUIRE(close_enough(callPrices_[perm[0]], forward_ + shift_),
                       "CarrMadanMarginalProbability: call price ("
                           << callPrices_.front() << ") for strike -shift (" << -shift_ << ") should match forward ("
                           << forward_ << ") + shift (" << shift_ << ") = " << forward_ + shift_);
        }
    }
 
    // check we have two strikes at least
 
    QL_REQUIRE(strikes_.size() >= 2,
               "CarrMadanMarginalProbability: at least two strikes levels required (after adding -shift)");
 
    // compute Q
 
    std::vector<Real> Q(strikes_.size() - 1);
    for (Size i = 1; i < strikes_.size(); ++i) {
        Q[i - 1] = (callPrices_[perm[i - 1]] - callPrices_[perm[i]]) / (strikes_[perm[i]] - strikes_[perm[i - 1]]);
    }
 
    // compute BS
 
    std::vector<Real> BS(strikes_.size() - 2);
    for (Size i = 1; i < strikes_.size() - 1; ++i) {
        BS[i - 1] = callPrices_[perm[i - 1]] -
                    (strikes_[perm[i + 1]] - strikes_[perm[i - 1]]) / (strikes_[perm[i + 1]] - strikes_[perm[i]]) *
                        callPrices_[perm[i]] +
                    (strikes_[perm[i]] - strikes_[perm[i - 1]]) / (strikes_[perm[i + 1]] - strikes_[perm[i]]) *
                        callPrices_[perm[i + 1]];
    }
 
    // perform the checks 1, 2 from the paper, and populate the set of arbitrage
 
    smileIsArbitrageFree_ = true;
    callSpreadArbitrage_.resize(strikes_.size());
    butterflyArbitrage_.resize(strikes_.size());
 
    // check 1: Q(i,j) in [0,1]
 
    for (Size i = 0; i < Q.size(); ++i) {
        if (Q[i] < -1.0E-10 || Q[i] > 1.0 + 1.0E-10) {
            callSpreadArbitrage_[perm[i]] = true;
            callSpreadArbitrage_[perm[i + 1]] = true;
            smileIsArbitrageFree_ = false;
        }
    }
 
    // check 2: BS(i,j) >= 0
 
    for (Size i = 0; i < BS.size(); ++i) {
        if (BS[i] < -1.0E-10) {
            butterflyArbitrage_[perm[i]] = true;
            butterflyArbitrage_[perm[i + 1]] = true;
            butterflyArbitrage_[perm[i + 2]] = true;
            smileIsArbitrageFree_ = false;
        }
    }
 
    // compute the density q
 
    q_.resize(strikes_.size());
    q_[perm[0]] = 1.0 - Q.front();
    for (Size i = 0; i < Q.size() - 1; ++i) {
        q_[perm[i + 1]] = Q[i] - Q[i + 1];
    }
    q_[perm.back()] = Q.back();
 
    // remove zero strike again, if not present from the start
 
    if (minusShiftStrikeAdded) {
        strikes_.erase(std::next(strikes_.end(), -1));
        callPrices_.erase(std::next(callPrices_.end(), -1));
        callSpreadArbitrage_.erase(std::next(callSpreadArbitrage_.begin(), perm.front()));
        butterflyArbitrage_.erase(std::next(butterflyArbitrage_.begin(), perm.front()));
        q_.erase(std::next(q_.begin(), perm.front()));
    }
}