CreateFloatLeg Example CPP

C++ Example - CreateFloatLeg

// ##################################################################################

// The first function here CreateFloatLeg(), contains a series of

// function calls leading upto the main function call, the second function

// within this file ( CreateFloatLegPart() ).

// which contains the answer that we are looking for.

// The first function here is simply an example of how to construct the parameters

// in order acquire either a string Key (that is to be passed to other functions)

// or a computed result.

// If you are viewing this source code from the chm or web help file you can use the

// outlining features to collapse certain sections of the code for better readability.

// ##################################################################################

#include <string>

#include <exception>

#include <sstream>

#include <iomanip>

// Point the "additional includes directory" within your editor to the following paths ( where <InstallFolder> is your installation folder)

// <InstallFolder>/Libs/Headers/ (For the library header files)

// <InstallFolder>/Libs/Client/ (For the client helper header and source files)

// The helper files are optional and you can include only those files needed for your functionality

// Each helper header/source file pair corresponds to a single QuantTools category of functions.

// Include QuantTools library header files

#include <QuantTools_all.hpp>

// Include Client Helper QuantTools header files

#include <QuantToolsClient_all.hpp>

// For Debug builds add a reference to the CTQuantToolsCPPAPI20D.lib

// For Release builds add a reference to the CTQuantToolsCPPAPI20.lib

// You add a reference via the ProjectProperties->Linker->Input menu item

// Some global parameter in order to append to user defined keys.

// We use it here to ensure that we have unique Keys (in the case several of our examples

// use the same key-name)

// In normal use, a user defined string will be used and so this variable will be pointless.

static long nCTLegsGlobal = 0;

// Used by parameters that take an optional range value.

// In Excel we simply omit the value, within the API functions,

// we pass an empty range object

CTRangeDataCPP oEmptyRange;

std::string szTickedKeyName;

std::ostringstream szTemp;

std::string CPP_EX_CreateFloatLeg()

{

nCTLegsGlobal += 1;

std::string szErrorMsg = "";

try

{

// EURO calendar used for holiday adjustments.

std::string MyEuroCal;

MyEuroCal =

CALEUROPart();

// UK date calendar used within the UK stock exchange.

std::string MyCALUKExchange;

MyCALUKExchange =

CALUKExchangePart();

// Creates a centralized valuation date object.

std::string MyValuationDate;

MyValuationDate =

ValueDateObjPart();

// Generates a schedule of start and end dates, given the initial

// start date and unadjusted final end dates.

std::string MySchedule;

MySchedule =

MakeSchedulePart(

MyEuroCal);

// Creates a Deposit template which is almost identical to a Libor

// Index, but without the YieldCurve information.

std::string MyDepoTPL;

MyDepoTPL =

CreateDepoTemplatePart(

MyCALUKExchange,

MyEuroCal);

// Creates a Swap template which is almost identical to the definition

// of the parameters of a swap contract, but without the swap duration,

// buysell, and YieldCurve information.

std::string MySwapTPL;

MySwapTPL =

CreateSwapTemplatePart(

MyEuroCal,

MyDepoTPL);

// Creates a SABR curve to model the dynamics of the volatility

// curve (smile).

std::string MySABRVolCurve;

MySABRVolCurve =

SABRVolCurvePart(

MyValuationDate,

MyDepoTPL,

MySwapTPL);

// Creates a yield curve using market rates (No cross-currency

// Swaps).

std::string MyYCInterpOnDCF;

MyYCInterpOnDCF =

MKTYC_DPart(

MyValuationDate,

MyDepoTPL,

MySwapTPL);

// Creates a new Index code.

std::string MyNewIndex;

MyNewIndex =

CreateIndexPart(

MyCALUKExchange,

MyEuroCal,

MyYCInterpOnDCF);

// Creates a market object which is an aggregate of interest rate

// market objects (Discounting curve and Interest rate volatility

// curve (volcurve)).

std::string MyMarket;

MyMarket =

CreateMKTPart(

MyYCInterpOnDCF,

MySABRVolCurve);

// Creates a floating rate leg.

std::string MyCreateFloatLeg;

MyCreateFloatLeg =

CreateFloatLegPart(

MySchedule,

MyNewIndex,

MyMarket);

// This is the result we are looking for.

return MyCreateFloatLeg;

}

catch(std::exception e)

{

szErrorMsg = e.what();

throw;

}

catch(...)

{

throw;

}

// ///////////////////////////////////////////////////////////////////

std::string CreateFloatLegPart(

std::string MySchedule,

std::string MyNewIndex,

std::string MyMarket)

{

// Create example range for parameter CreateFloatLeg_Notional

// Column vector of 20 rows (indexed from 0, highest index of 19)

CTRangeDataCPP CreateFloatLeg_Notional(20, 1);

CreateFloatLeg_Notional.SetValue(0, 0, 5000000);

CreateFloatLeg_Notional.SetValue(1, 0, 5000000);

CreateFloatLeg_Notional.SetValue(2, 0, 5000000);

CreateFloatLeg_Notional.SetValue(3, 0, 5000000);

CreateFloatLeg_Notional.SetValue(4, 0, 5000000);

CreateFloatLeg_Notional.SetValue(5, 0, 5000000);

CreateFloatLeg_Notional.SetValue(6, 0, 5000000);

CreateFloatLeg_Notional.SetValue(7, 0, 5000000);

CreateFloatLeg_Notional.SetValue(8, 0, 5000000);

CreateFloatLeg_Notional.SetValue(9, 0, 5000000);

CreateFloatLeg_Notional.SetValue(10, 0, 5000000);

CreateFloatLeg_Notional.SetValue(11, 0, 5000000);

CreateFloatLeg_Notional.SetValue(12, 0, 5000000);

CreateFloatLeg_Notional.SetValue(13, 0, 5000000);

CreateFloatLeg_Notional.SetValue(14, 0, 5000000);

CreateFloatLeg_Notional.SetValue(15, 0, 5000000);

CreateFloatLeg_Notional.SetValue(16, 0, 5000000);

CreateFloatLeg_Notional.SetValue(17, 0, 5000000);

CreateFloatLeg_Notional.SetValue(18, 0, 5000000);

CreateFloatLeg_Notional.SetValue(19, 0, 5000000);

// Create example range for parameter CreateFloatLeg_PrincipalPayments

// Column vector of 20 rows (indexed from 0, highest index of 19)

CTRangeDataCPP CreateFloatLeg_PrincipalPayments(20, 1);

CreateFloatLeg_PrincipalPayments.SetValue(0, 0, 0);

CreateFloatLeg_PrincipalPayments.SetValue(1, 0, 0);

CreateFloatLeg_PrincipalPayments.SetValue(2, 0, 0);

CreateFloatLeg_PrincipalPayments.SetValue(3, 0, 0);

CreateFloatLeg_PrincipalPayments.SetValue(4, 0, 0);

CreateFloatLeg_PrincipalPayments.SetValue(5, 0, 0);

CreateFloatLeg_PrincipalPayments.SetValue(6, 0, 0);

CreateFloatLeg_PrincipalPayments.SetValue(7, 0, 0);

CreateFloatLeg_PrincipalPayments.SetValue(8, 0, 0);

CreateFloatLeg_PrincipalPayments.SetValue(9, 0, 0);

CreateFloatLeg_PrincipalPayments.SetValue(10, 0, 0);

CreateFloatLeg_PrincipalPayments.SetValue(11, 0, 0);

CreateFloatLeg_PrincipalPayments.SetValue(12, 0, 0);

CreateFloatLeg_PrincipalPayments.SetValue(13, 0, 0);

CreateFloatLeg_PrincipalPayments.SetValue(14, 0, 0);

CreateFloatLeg_PrincipalPayments.SetValue(15, 0, 0);

CreateFloatLeg_PrincipalPayments.SetValue(16, 0, 0);

CreateFloatLeg_PrincipalPayments.SetValue(17, 0, 0);

CreateFloatLeg_PrincipalPayments.SetValue(18, 0, 0);

CreateFloatLeg_PrincipalPayments.SetValue(19, 0, 0);

// Create example range for parameter CreateFloatLeg_Margin

// Column vector of 20 rows (indexed from 0, highest index of 19)

CTRangeDataCPP CreateFloatLeg_Margin(20, 1);

CreateFloatLeg_Margin.SetValue(0, 0, 0.0002);

CreateFloatLeg_Margin.SetValue(1, 0, 0.0002);

CreateFloatLeg_Margin.SetValue(2, 0, 0.0002);

CreateFloatLeg_Margin.SetValue(3, 0, 0.0002);

CreateFloatLeg_Margin.SetValue(4, 0, 0.0002);

CreateFloatLeg_Margin.SetValue(5, 0, 0.0002);

CreateFloatLeg_Margin.SetValue(6, 0, 0.0002);

CreateFloatLeg_Margin.SetValue(7, 0, 0.0002);

CreateFloatLeg_Margin.SetValue(8, 0, 0.0002);

CreateFloatLeg_Margin.SetValue(9, 0, 0.0002);

CreateFloatLeg_Margin.SetValue(10, 0, 0.0002);

CreateFloatLeg_Margin.SetValue(11, 0, 0.0002);

CreateFloatLeg_Margin.SetValue(12, 0, 0.0002);

CreateFloatLeg_Margin.SetValue(13, 0, 0.0002);

CreateFloatLeg_Margin.SetValue(14, 0, 0.0002);

CreateFloatLeg_Margin.SetValue(15, 0, 0.0002);

CreateFloatLeg_Margin.SetValue(16, 0, 0.0002);

CreateFloatLeg_Margin.SetValue(17, 0, 0.0002);

CreateFloatLeg_Margin.SetValue(18, 0, 0.0002);

CreateFloatLeg_Margin.SetValue(19, 0, 0.0002);

std::ostringstream szTemp; szTemp.str("");

szTemp << std::setw(0) << nCTLegsGlobal;

// Key value to use as a handle for the created object

std::string MyCreateFloatLeg = std::string("MyCreateFloatLeg") + std::string("_") + szTemp.str();

// When creating this object for the first time, set this parameter

// to a positive value.

long Reload = 1;

// Whether you would like to PAY or REC this leg.

PAYRECEnum PayRec = PAYREC_REC;

// A positive factor value you wish to multiply the Floating-Reset

// Rate/Fixed-Coupon Rate by (Usually 1).

long Gearing = 1;

// Currency of the Notional amount.

CCYEnum Ccy = CCY_EUR;

// Payment Business Day Convention.

BDCEnum BusDayConv = BDC_modifiedfollowing;

// Payment DayCounter.

DayCountEnum DayCount = DayCount_actual365_fixed;

// Whether you wish to exchange the principal amount(s) at the

// start and termination of the leg contract.

bool ExchangePrincipal = false;

// If a CMS index is specified (within the parameter 'IndexKey')

// and the 'CMSAlgo' parameter within this CMS Index has been set

// to 'Hull' then the correlation between swap rates and fwd rates

// is required.

double SMPFWDRho = 0.8;

// Excel function call would be this - "CT.LEG.CreateFloatLeg()"

// Creates a floating rate leg.

std::string rCreateFloatLeg;

rCreateFloatLeg = CTLegsSA::CreateFloatLeg(

MyCreateFloatLeg,

Reload,

PayRec,

Gearing,

CreateFloatLeg_Notional,

CreateFloatLeg_PrincipalPayments,

Ccy,

MySchedule,

BusDayConv,

DayCount,

MyNewIndex,

CreateFloatLeg_Margin,

ExchangePrincipal,

MyMarket,

SMPFWDRho);

return rCreateFloatLeg;

}