Configuración de la programación de un flotador amortizable en QuantLib

Question

No estoy seguro de los argumentos exactos requeridos para la función Schedule para un flotador amortizante - mi código se encuentra a continuación. Específicamente, mi pregunta se refiere a si el cronograma debe comenzar siempre a partir de la fecha de emisión del bono o si debe comenzar a partir de la fecha de liquidación si el bono está maduro. Parece que he visto el uso de ambas maneras en algunos de los ejemplos en la web, así que estoy un poco confundido.

Yo esperaría que las funciones de VAN indexen el flujo de caja correcto en base a la fecha de liquidación proporcionada, pero sólo lo estoy comprobando.

Además, si alguien tiene un ejemplo de trabajo de un AmortizingFloatingRateBond que calcule el DM dado un precio (o viceversa) utilizando un calendario nocional, sería muy apreciado.

Fragmento de código:

QuantLib::JointCalendar calendar = QuantLib::JointCalendar(QuantLib::UnitedStates(),QuantLib::UnitedKingdom(),
        JoinBusinessDays);
QuantLib::DayCounter dayCounter = QuantLib::Actual360();

QuantLib::Integer fixingDays = 1;
QuantLib::Natural settlementDays = 3;

QuantLib::Date tradeDate(20, QuantLib::September, 2013);
QuantLib::Date settlementDate = calendar.advance(tradeDate, settlementDays, QuantLib::Days);
settlementDate = calendar.adjust(settlementDate);
QuantLib::Settings::instance().evaluationDate() = tradeDate;

QuantLib::Date issueDate(25,QuantLib::July,2013);

QuantLib::Period p1m = QuantLib::Period(1,QuantLib::Months);

// Number of payments
int num_cashflows = 120;
QuantLib::Date maturityDate = issueDate + num_cashflows * p1m;

QuantLib::Schedule mySchedule(issueDate,
    maturityDate,
    QuantLib::Period(QuantLib::Monthly),
    calendar,
    QuantLib::BusinessDayConvention::Unadjusted,
    QuantLib::BusinessDayConvention::ModifiedFollowing,
    QuantLib::DateGeneration::Forward,
    false);

QuantLib::AmortizingFloatingRateBond MyFloater(settlementDays,
                                     Notional,
                                     mySchedule,
                                     libor,
                                     QuantLib::Actual360(),
                                     QuantLib::BusinessDayConvention::ModifiedFollowing,
                                     fixingDays,
                                     std::vector<QuantLib::Real>(1,1.0),
                                     std::vector<QuantLib::Spread>(1,Spread),
                                     std::vector<QuantLib::Rate>(),
                                     std::vector<QuantLib::Rate>(),
                                     true,
                                     issueDate);

MyFloater.setPricingEngine(bondEngine);

std::vector<QuantLib::Date> paySchedule = mySchedule.dates();
std::vector<QuantLib::Date>::iterator pIter;
QuantLib::Date priorDate;

for (pIter = paySchedule.begin(); pIter != paySchedule.end() && *pIter < settlementDate; ++pIter){
     priorDate = *pIter;
     libor->addFixing(calendar.advance(priorDate, QuantLib::Period(-fixingDays,QuantLib::Days)), 0.1805/100);
}

Answer 1

En cuanto a la primera pregunta, el calendario debe comenzar a partir de la fecha de emisión. El bono gestionará correctamente los flujos de caja a partir de la fecha de evaluación.

La segunda es un poco más complicada, y no creo que tenga a mano el código de trabajo. La idea general es: si quieres añadir un diferencial al tipo de interés del bono (para pasar de margen de descuento a precio) tendrás que modificar la estructura de plazos que pasas a tu instancia de Libor. En lugar de vincular el manejador de la estructura de plazos a la curva del Libor, crea una instancia de ForwardSpreadedTermStructure pasando por la curva del Libor y una comilla que mantiene el diferencial; algo así como

boost::shared_ptr<SimpleQuote> spread(new SimpleQuote(0.0));
boost::shared_ptr<YieldTermStructure> spreadedCurve(
    new ForwardSpreadedTermStructure(liborCurve,
                                     Handle<Quote>(spread)));
libor = boost::shared_ptr<IborIndex>(
    new USDLibor(1*Months,
                 Handle<YieldTermStructure>(spreadedCurve)));

Si se inicializa el bono con la instancia de Libor anterior, se debería poder escribir:

spread->setValue(0.002);

y ver que el precio del bono cambia en consecuencia.

Para pasar del precio al DM, hay que invertir lo anterior de alguna manera. Lo más fácil es probablemente crear un objeto función que tome un spread y devuelva la diferencia entre el precio objetivo y el precio calculado con el DM actual (probablemente tendrá que mantener una referencia al bono y realizar el cálculo que he indicado). Una vez que tenga el objeto de función, puede pasarlo a cualquiera de los solucionadores 1-D disponibles en la biblioteca. El solucionador devolverá el spread que da una diferencia de precio nula; es decir, el spread para el que el precio es igual al precio objetivo.

Actualización: según Cálculo del margen de descuento de un bono a tipo variable con QuantLib En este caso, se debe utilizar la curva original del LIBOR para la previsión y la curva más el diferencial para el descuento; así, algo como

shared_ptr<SimpleQuote> spread = make_shared<SimpleQuote>(0.0);
shared_ptr<YieldTermStructure> spreadedCurve =
    make_shared<ForwardSpreadedTermStructure>(liborCurve,
                                              Handle<Quote>(spread));
libor = make_shared<USDLibor>(1*Months,
                              Handle<YieldTermStructure>(liborCurve));
bondEngine = make_shared<DiscountingBondEngine>(
                           Handle<YieldTermStructure>(spreadedCurve));