/** \brief Constructor.
@param[in] parlist is a parameter list specifying inputs
parlist should contain sublists "SOL"->"Risk Measure"->"Convex Combination Risk Measure" and
within the "Convex Combination Risk Measure" sublist should have the following parameters
\li "Convex Combination Parameters" (greater than 0 and sum to 1)
\li Sublists labeled 1 to n with risk measure definitions.
*/
ConvexCombinationRiskMeasure(Teuchos::ParameterList &parlist)
: RiskMeasure<Real>(), size_(0), firstReset_(true) {
Teuchos::ParameterList &list
= parlist.sublist("SOL").sublist("Risk Measure").sublist("Convex Combination Risk Measure");
// Get convex combination parameters
Teuchos::Array<Real> lambda
= Teuchos::getArrayFromStringParameter<Real>(list,"Convex Combination Parameters");
lambda_ = lambda.toVector();
size_ = lambda_.size();
// Build risk measures
risk_.clear(); risk_.resize(size_,Teuchos::null);
parlist_.clear(); parlist_.resize(size_);
for (uint i = 0; i < size_; ++i) {
std::ostringstream convert;
convert << i;
std::string si = convert.str();
Teuchos::ParameterList &ilist = list.sublist(si);
std::string name = ilist.get<std::string>("Name");
parlist_[i].sublist("SOL").sublist("Risk Measure").set("Name",name);
parlist_[i].sublist("SOL").sublist("Risk Measure").sublist(name) = ilist;
risk_[i] = RiskMeasureFactory<Real>(parlist_[i]);
}
// Check inputs
checkInputs();
}
// fixed reference date, fixed market data
CapFloorTermVolSurface::CapFloorTermVolSurface(
const Date& settlementDate,
const Calendar& calendar,
BusinessDayConvention bdc,
const std::vector<Period>& optionTenors,
const std::vector<Rate>& strikes,
const Matrix& vols,
const DayCounter& dc)
: CapFloorTermVolatilityStructure(settlementDate, calendar, bdc, dc),
nOptionTenors_(optionTenors.size()),
optionTenors_(optionTenors),
optionDates_(nOptionTenors_),
optionTimes_(nOptionTenors_),
nStrikes_(strikes.size()),
strikes_(strikes),
volHandles_(vols.rows()),
vols_(vols)
{
checkInputs();
initializeOptionDatesAndTimes();
// fill dummy handles to allow generic handle-based computations later
for (Size i=0; i<nOptionTenors_; ++i) {
volHandles_[i].resize(nStrikes_);
for (Size j=0; j<nStrikes_; ++j)
volHandles_[i][j] = Handle<Quote>(boost::shared_ptr<Quote>(new
SimpleQuote(vols_[i][j])));
}
interpolate();
}
///////////////////////////////////////////////////////////////////////////
// Main entry point to a MEX function
///////////////////////////////////////////////////////////////////////////
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
// Ensure MATLAB's GPU support is available.
mxInitGPU();
// Check inputs to mex function
checkInputs(nrhs, prhs);
// Convert mxArray inputs into OpenCV types
cv::Ptr<cv::gpu::GpuMat> frame1 = ocvMxGpuArrayToGpuMat_uint8(prhs[0]);
cv::Ptr<cv::gpu::GpuMat> frame2 = ocvMxGpuArrayToGpuMat_uint8(prhs[1]);
// Allocate output matrix
int outRows = frame1->rows ;
int outCols = frame1->cols ;
cv::gpu::GpuMat flowx((int)outRows, (int)outCols, CV_32FC1);
cv::gpu::GpuMat flowy((int)outRows, (int)outCols, CV_32FC1);
cv::gpu::FarnebackOpticalFlow d_calc;
// Run the OpenCV template matching routine
d_calc(*frame1, *frame2, flowx, flowy);
// Put the data back into the output MATLAB gpuArray
plhs[0] = ocvMxGpuArrayFromGpuMat_single(flowx);
plhs[1] = ocvMxGpuArrayFromGpuMat_single(flowy);
}
// Supports arbitrary batch dimensions for self and A
std::tuple<Tensor,Tensor> gesv(const Tensor& self, const Tensor& A) {
if (self.dim() <= 2 && A.dim() <= 2) {
// TODO: #7102: It's not necessary to have gesv (single) bindings for both
// TH and ATen. We should remove the TH gesv bindings, especially
// since the lapackGesv function is already in ATen.
return at::_gesv_single(self, A);
}
checkInputs(self, A);
// broadcast the batch dimensions of self and A.
IntList self_batch_sizes(self.sizes().data(), self.ndimension() - 2);
IntList A_batch_sizes(A.sizes().data(), A.ndimension() - 2);
std::vector<int64_t> expand_batch_portion =
infer_size(self_batch_sizes, A_batch_sizes);
std::vector<int64_t> self_expand_size({expand_batch_portion});
self_expand_size.insert(self_expand_size.end(),
{ self.size(-2), self.size(-1) });
std::vector<int64_t> A_expand_size({expand_batch_portion});
A_expand_size.insert(A_expand_size.end(),
{ A.size(-2), A.size(-1) });
Tensor self_broadcasted = self.expand(self_expand_size);
Tensor A_broadcasted = A.expand(A_expand_size);
return self.type()._gesv_helper(self_broadcasted, A_broadcasted);
}
void SQICInternal::evaluate() {
if (inputs_check_) checkInputs();
std::copy(input(QP_SOLVER_X0).begin(), input(QP_SOLVER_X0).end(), x_.begin());
std::fill(x_.begin()+n_, x_.end(), 0);
std::transform(input(QP_SOLVER_LAM_X0).begin(), input(QP_SOLVER_LAM_X0).end(), rc_.begin(),
negate<double>());
std::fill(rc_.begin()+n_, rc_.end(), 0);
std::copy(input(QP_SOLVER_LBX).begin(), input(QP_SOLVER_LBX).end(), bl_.begin());
std::copy(input(QP_SOLVER_UBX).begin(), input(QP_SOLVER_UBX).end(), bu_.begin());
std::copy(input(QP_SOLVER_LBA).begin(), input(QP_SOLVER_LBA).end(), bl_.begin()+n_);
std::copy(input(QP_SOLVER_UBA).begin(), input(QP_SOLVER_UBA).end(), bu_.begin()+n_);
for (int i=0;i<n_+nc_+1;++i) {
if (bl_[i]==-std::numeric_limits<double>::infinity()) bl_[i]=-inf_;
if (bu_[i]==std::numeric_limits<double>::infinity()) bu_[i]=inf_;
}
formatA_.setInput(input(QP_SOLVER_A), 0);
formatA_.setInput(input(QP_SOLVER_G), 1);
formatA_.evaluate();
sqicSolve(&output(QP_SOLVER_COST).data()[0]);
std::copy(x_.begin(), x_.begin()+n_, output(QP_SOLVER_X).begin());
std::transform(rc_.begin(), rc_.begin()+n_, output(QP_SOLVER_LAM_X).begin(), negate<double>());
std::transform(rc_.begin()+n_, rc_.begin()+n_+nc_, output(QP_SOLVER_LAM_A).begin(),
negate<double>());
output(QP_SOLVER_COST)[0]+= x_[n_+nc_];
}
SceneType MainCharacter::animate(Scene &scene, float delta) {
checkInputs();
move(scene, delta);
createTransformationMatrix();
return scene.sceneType;
}
// fixed reference date, floating market data
SwaptionVolatilityMatrix::SwaptionVolatilityMatrix(
const Date& refDate,
const Calendar& cal,
BusinessDayConvention bdc,
const std::vector<Period>& optionT,
const std::vector<Period>& swapT,
const std::vector<std::vector<Handle<Quote> > >& vols,
const DayCounter& dc,
const bool flatExtrapolation,
const std::vector<std::vector<Real> >& shifts)
: SwaptionVolatilityDiscrete(optionT, swapT, refDate, cal, bdc, dc),
volHandles_(vols), shiftValues_(shifts),
volatilities_(vols.size(), vols.front().size()),
shifts_(vols.size(), vols.front().size(), 0.0) {
checkInputs(volatilities_.rows(), volatilities_.columns(),
shifts.size(), shifts.size() == 0 ? 0 : shifts.front().size());
registerWithMarketData();
if (flatExtrapolation) {
interpolation_ =
FlatExtrapolator2D(boost::make_shared<BilinearInterpolation>(
swapLengths_.begin(), swapLengths_.end(),
optionTimes_.begin(), optionTimes_.end(), volatilities_));
interpolationShifts_ =
FlatExtrapolator2D(boost::make_shared<BilinearInterpolation>(
swapLengths_.begin(), swapLengths_.end(),
optionTimes_.begin(), optionTimes_.end(), shifts_));
} else {
interpolation_ = BilinearInterpolation(
swapLengths_.begin(), swapLengths_.end(), optionTimes_.begin(),
optionTimes_.end(), volatilities_);
interpolationShifts_ = BilinearInterpolation(
swapLengths_.begin(), swapLengths_.end(), optionTimes_.begin(),
optionTimes_.end(), shifts_);
}
}
/** \brief Constructor.
@param[in] parlist is a parameter list specifying inputs
parlist should contain sublists "SOL"->"Risk Measures"->"Exponential Utility"
and withing the "Exponential Utility" sublist should have
\li "Rate" (greater than 0).
*/
ExpUtility(Teuchos::ParameterList &parlist)
: RiskMeasure<Real>(), firstReset_(true) {
Teuchos::ParameterList &list
= parlist.sublist("SOL").sublist("Risk Measure").sublist("Exponential Utility");
coeff_ = list.get<Real>("Rate");
checkInputs();
}
/** \brief Constructor.
@param[in] parlist is a parameter list specifying inputs
parlist should contain sublists "SOL"->"Risk Measures"->"Log-Exponential Quadrangle"
and withing the "Log-Exponential Quadrangle" sublist should have
\li "Rate" (greater than 0).
*/
LogExponentialQuadrangle(Teuchos::ParameterList &parlist)
: ExpectationQuad<Real>() {
Teuchos::ParameterList &list
= parlist.sublist("SOL").sublist("Risk Measure").sublist("Log-Exponential Quadrangle");
coeff_ = list.get<Real>("Rate");
checkInputs();
}
stList *getMatchingWithCyclicConstraints(stSortedSet *nodes,
stList *adjacencyEdges, stList *stubEdges, stList *chainEdges,
bool makeStubCyclesDisjoint,
stList *(*matchingAlgorithm)(stList *edges, int64_t nodeNumber)) {
/*
* Check the inputs.
*/
checkInputs(nodes, adjacencyEdges, stubEdges, chainEdges);
st_logDebug("Checked the inputs\n");
if (stSortedSet_size(nodes) == 0) { //Some of the following functions assume there are at least 2 nodes.
return stList_construct();
}
stList *chosenEdges = getPerfectMatching(nodes, adjacencyEdges, matchingAlgorithm);
stSortedSet *allAdjacencyEdges = stList_getSortedSet(adjacencyEdges,
(int(*)(const void *, const void *)) stIntTuple_cmpFn);
stList *nonZeroWeightAdjacencyEdges = getEdgesWithGreaterThanZeroWeight(
adjacencyEdges);
stList *updatedChosenEdges = makeMatchingObeyCyclicConstraints(nodes, chosenEdges, allAdjacencyEdges, nonZeroWeightAdjacencyEdges, stubEdges, chainEdges, makeStubCyclesDisjoint);
stList_destruct(chosenEdges);
chosenEdges = updatedChosenEdges;
stList_destruct(nonZeroWeightAdjacencyEdges);
stSortedSet_destruct(allAdjacencyEdges);
return chosenEdges;
}
// floating reference date, fixed market data
SwaptionVolatilityHullWhite::SwaptionVolatilityHullWhite(const Real reversion, const Handle<YieldTermStructure>& yts, const boost::shared_ptr<SwapIndex> indexBase,
const Calendar& cal,
BusinessDayConvention bdc,
const std::vector<Period>& optionT,
const std::vector<Period>& swapT,
const Matrix& vols,
const DayCounter& dc)
: reversion_(reversion),yts_(yts),indexBase_(indexBase),SwaptionVolatilityDiscrete(optionT, swapT, 0, cal, bdc, dc),
volHandles_(vols.rows()),
hwsigmas_(vols.rows(), vols.columns()),
volatilities_(vols.rows(), vols.columns()) {
checkInputs(vols.rows(), vols.columns());
// fill dummy handles to allow generic handle-based
// computations later on
for (Size i=0; i<vols.rows(); ++i) {
volHandles_[i].resize(vols.columns());
for (Size j=0; j<vols.columns(); ++j)
volHandles_[i][j] = Handle<Quote>(boost::shared_ptr<Quote>(new
SimpleQuote(vols[i][j])));
}
interpolation_ =
BilinearInterpolation(swapLengths_.begin(), swapLengths_.end(),
optionTimes_.begin(), optionTimes_.end(),
volatilities_);
interpolationSigma_ =
BilinearInterpolation(swapLengths_.begin(), swapLengths_.end(),
optionTimes_.begin(), optionTimes_.end(),
hwsigmas_);
}
// fixed reference date, floating market data
CapFloorTermVolSurface::CapFloorTermVolSurface(
const Date& settlementDate,
const Calendar& calendar,
BusinessDayConvention bdc,
const std::vector<Period>& optionTenors,
const std::vector<Rate>& strikes,
const std::vector<std::vector<Handle<Quote> > >& vols,
const DayCounter& dc)
: CapFloorTermVolatilityStructure(settlementDate, calendar, bdc, dc),
nOptionTenors_(optionTenors.size()),
optionTenors_(optionTenors),
optionDates_(nOptionTenors_),
optionTimes_(nOptionTenors_),
nStrikes_(strikes.size()),
strikes_(strikes),
volHandles_(vols),
vols_(vols.size(), vols[0].size())
{
checkInputs();
initializeOptionDatesAndTimes();
for (Size i=0; i<nOptionTenors_; ++i)
QL_REQUIRE(volHandles_[i].size()==nStrikes_,
io::ordinal(i+1) << " row of vol handles has size " <<
volHandles_[i].size() << " instead of " << nStrikes_);
registerWithMarketData();
for (Size i=0; i<vols_.rows(); ++i)
for (Size j=0; j<vols_.columns(); ++j)
vols_[i][j] = volHandles_[i][j]->value();
interpolate();
}
// fixed reference date, fixed market data
SwaptionVolatilityMatrix::SwaptionVolatilityMatrix(
const Date& refDate,
const Calendar& cal,
BusinessDayConvention bdc,
const std::vector<Period>& optionT,
const std::vector<Period>& swapT,
const Matrix& vols,
const DayCounter& dc)
: SwaptionVolatilityDiscrete(optionT, swapT, refDate, cal, bdc, dc),
volHandles_(vols.rows()),
volatilities_(vols.rows(), vols.columns()) {
checkInputs(vols.rows(), vols.columns());
// fill dummy handles to allow generic handle-based
// computations later on
for (Size i=0; i<vols.rows(); ++i) {
volHandles_[i].resize(vols.columns());
for (Size j=0; j<vols.columns(); ++j)
volHandles_[i][j] = Handle<Quote>(boost::shared_ptr<Quote>(new
SimpleQuote(vols[i][j])));
}
interpolation_ =
BilinearInterpolation(swapLengths_.begin(), swapLengths_.end(),
optionTimes_.begin(), optionTimes_.end(),
volatilities_);
}
MixedQuantileQuadrangle(const std::vector<Real> &prob,
const std::vector<Real> &coeff,
const Teuchos::RCP<PlusFunction<Real> > &pf )
: RiskMeasure<Real>(), plusFunction_(pf), prob_(prob), coeff_(coeff), firstReset_(true) {
checkInputs();
initialize();
}
// floating reference date, floating market data
AbcdAtmVolCurve::AbcdAtmVolCurve(
Natural settlDays,
const Calendar& cal,
const std::vector<Period>& optionTenors,
const std::vector<Handle<Quote> >& volsHandles,
const std::vector<bool> inclusionInInterpolationFlag,
BusinessDayConvention bdc,
const DayCounter& dc)
: BlackAtmVolCurve(settlDays, cal, bdc, dc),
nOptionTenors_(optionTenors.size()),
optionTenors_(optionTenors),
optionDates_(nOptionTenors_),
optionTimes_(nOptionTenors_),
actualOptionTimes_(nOptionTenors_),
volHandles_(volsHandles),
vols_(volsHandles.size()),
actualVols_(volsHandles.size()),
inclusionInInterpolation_(inclusionInInterpolationFlag),
interpolation_(boost::shared_ptr<AbcdInterpolation>()) // do not initialize with nOptionTenors_
{
checkInputs();
initializeOptionDatesAndTimes();
initializeVolatilities();
registerWithMarketData();
for (Size i=0; i<vols_.size(); ++i)
vols_[i] = volHandles_[i]->value();
interpolate();
}
SingletonKusuoka( const std::vector<Real> &pts, const std::vector<Real> &wts,
const Teuchos::RCP<PlusFunction<Real> > &pf)
: RiskMeasure<Real>() {
buildMixedQuantile(pts,wts,pf);
// Check inputs
checkInputs();
}
/** \brief Constructor.
@param[in] parlist is a parameter list specifying inputs
parlist should contain sublists "SOL"->"Risk Measure"->"Mean-Variance Quadrangle" and
within the "Mean-Variance Quadrangle" sublist should have the following parameters
\li "Coefficient" (array of positive scalars).
*/
MeanVarianceQuadrangle(Teuchos::ParameterList &parlist)
: ExpectationQuad<Real>() {
Teuchos::ParameterList &list
= parlist.sublist("SOL").sublist("Risk Measure").sublist("Mean-Variance Quadrangle");
coeff_ = list.get<Real>("Coefficient");
checkInputs();
}
SuperQuantileQuadrangle(const Real alpha,
const int nQuad,
const Teuchos::RCP<PlusFunction<Real> > &pf,
const bool useGauss = true)
: SpectralRisk<Real>(), plusFunction_(pf),
alpha_(alpha), nQuad_(nQuad), useGauss_(useGauss) {
// Check inputs
checkInputs();
initialize();
}
QuantileRadiusQuadrangle( Teuchos::ParameterList &parlist )
: RiskMeasure<Real>(), firstReset_(true) {
Teuchos::ParameterList &list
= parlist.sublist("SOL").sublist("Risk Measure").sublist("Quantile-Radius Quadrangle");
// Grab probability and coefficient arrays
prob_ = list.get<Real>("Confidence Level");
coeff_ = list.get<Real>("Coefficient");
// Build (approximate) plus function
plusFunction_ = Teuchos::rcp(new PlusFunction<Real>(list));
checkInputs();
initialize();
}
SingletonKusuoka( const Teuchos::RCP<Distribution<Real> > &dist,
const int nQuad,
const Teuchos::RCP<PlusFunction<Real> > &pf)
: RiskMeasure<Real>() {
// Build generalized trapezoidal rule
std::vector<Real> wts(nQuad), pts(nQuad);
buildQuadFromDist(pts,wts,nQuad,dist);
// Build mixed quantile quadrangle risk measure
buildMixedQuantile(pts,wts,pf);
// Check inputs
checkInputs(dist);
}
CVaR( Teuchos::ParameterList &parlist )
: RiskMeasure<Real>(), xvar_(0), vvar_(0), firstReset_(true) {
Teuchos::ParameterList &list
= parlist.sublist("SOL").sublist("Risk Measure").sublist("CVaR");
// Check CVaR inputs
prob_ = list.get<Real>("Confidence Level");
coeff_ = list.get<Real>("Convex Combination Parameter");
// Build (approximate) plus function
plusFunction_ = Teuchos::rcp(new PlusFunction<Real>(list));
// Check Inputs
checkInputs();
}
/** \brief Constructor.
@param[in] parlist is a parameter list specifying inputs
parlist should contain sublists "SOL"->"Risk Measures"->"Log-Quantile Quadrangle"
and withing the "Log-Quantile Quadrangle" sublist should have
\li "Slope for Linear Growth" (between 0 and 1)
\li "Rate for Exponential Growth" (must be positive)
\li "Smoothing Parameter" (must be positive)
\li A sublist for plus function information.
*/
LogQuantileQuadrangle(Teuchos::ParameterList &parlist)
: ExpectationQuad<Real>() {
Teuchos::ParameterList& list
= parlist.sublist("SOL").sublist("Risk Measure").sublist("Log-Quantile Quadrangle");
// Check CVaR inputs
alpha_ = list.get<Real>("Slope for Linear Growth");
rate_ = list.get<Real>("Rate for Exponential Growth");
eps_ = list.get<Real>("Smoothing Parameter");
// Build plus function
pf_ = Teuchos::rcp( new PlusFunction<Real>(list) );
checkInputs();
}
MixedQuantileQuadrangle( Teuchos::ParameterList &parlist )
: RiskMeasure<Real>(), firstReset_(true) {
Teuchos::ParameterList &list
= parlist.sublist("SOL").sublist("Risk Measure").sublist("Mixed-Quantile Quadrangle");
// Grab probability and coefficient arrays
prob_ = Teuchos::getArrayFromStringParameter<Real>(list,"Probability Array");
coeff_ = Teuchos::getArrayFromStringParameter<Real>(list,"Coefficient Array");
plusFunction_ = Teuchos::rcp(new PlusFunction<Real>(list));
// Check inputs
checkInputs();
initialize();
}
LogQuantileQuadrangle(Teuchos::ParameterList &parlist)
: ExpectationQuad<Real>() {
Teuchos::ParameterList& list
= parlist.sublist("SOL").sublist("Risk Measure").sublist("Log-Quantile Quadrangle");
// Check CVaR inputs
prob_ = list.get<Real>("Confidence Level");
scale_ = list.get<Real>("Growth Constant");
eps_ = list.get<Real>("Smoothing Parameter");
// Build plus function
pf_ = Teuchos::rcp( new PlusFunction<Real>(list) );
checkInputs();
}
QuantileQuadrangle(Teuchos::ParameterList &parlist) : ExpectationQuad<Real>() {
Teuchos::ParameterList& list
= parlist.sublist("SOL").sublist("Risk Measure").sublist("Quantile-Based Quadrangle");
// Get CVaR parameters
prob_ = list.get<Real>("Confidence Level");
lam_ = list.get<Real>("Convex Combination Parameter");
eps_ = list.get<Real>("Smoothing Parameter");
// Build plus function
pf_ = Teuchos::rcp( new PlusFunction<Real>(list) );
// Check inputs
checkInputs();
setParameters();
}
SuperQuantileQuadrangle( Teuchos::ParameterList &parlist )
: SpectralRisk<Real>() {
Teuchos::ParameterList &list
= parlist.sublist("SOL").sublist("Risk Measure").sublist("Super Quantile Quadrangle");
// Grab confidence level and quadrature order
alpha_ = list.get<Real>("Confidence Level");
nQuad_ = list.get("Number of Quadrature Points",5);
useGauss_ = list.get("Use Gauss-Legendre Quadrature",true);
plusFunction_ = Teuchos::rcp(new PlusFunction<Real>(list));
// Check inputs
checkInputs();
initialize();
}
// fixed reference date, fixed market data
SwaptionVolatilityMatrix::SwaptionVolatilityMatrix(
const Date& refDate,
const Calendar& cal,
BusinessDayConvention bdc,
const std::vector<Period>& optionT,
const std::vector<Period>& swapT,
const Matrix& vols,
const DayCounter& dc,
const bool flatExtrapolation,
const VolatilityType type,
const Matrix& shifts)
: SwaptionVolatilityDiscrete(optionT, swapT, refDate, cal, bdc, dc),
volHandles_(vols.rows()), shiftValues_(vols.rows()),
volatilities_(vols.rows(), vols.columns()),
shifts_(shifts.rows(), shifts.columns(), 0.0), volatilityType_(type) {
checkInputs(vols.rows(), vols.columns(), shifts.rows(), shifts.columns());
// fill dummy handles to allow generic handle-based
// computations later on
for (Size i=0; i<vols.rows(); ++i) {
volHandles_[i].resize(vols.columns());
shiftValues_[i].resize(vols.columns());
for (Size j=0; j<vols.columns(); ++j) {
volHandles_[i][j] = Handle<Quote>(boost::shared_ptr<Quote>(new
SimpleQuote(vols[i][j])));
shiftValues_[i][j] = shifts.rows() > 0 ? shifts[i][j] : 0.0;
}
}
if (flatExtrapolation) {
interpolation_ =
FlatExtrapolator2D(boost::make_shared<BilinearInterpolation>(
swapLengths_.begin(), swapLengths_.end(),
optionTimes_.begin(), optionTimes_.end(), volatilities_));
interpolationShifts_ =
FlatExtrapolator2D(boost::make_shared<BilinearInterpolation>(
swapLengths_.begin(), swapLengths_.end(),
optionTimes_.begin(), optionTimes_.end(), shifts_));
} else {
interpolation_ = BilinearInterpolation(
swapLengths_.begin(), swapLengths_.end(), optionTimes_.begin(),
optionTimes_.end(), volatilities_);
interpolationShifts_ = BilinearInterpolation(
swapLengths_.begin(), swapLengths_.end(), optionTimes_.begin(),
optionTimes_.end(), shifts_);
}
}
// floating reference date, floating market data
SwaptionVolatilityMatrix::SwaptionVolatilityMatrix(
const Calendar& cal,
BusinessDayConvention bdc,
const std::vector<Period>& optionT,
const std::vector<Period>& swapT,
const std::vector<std::vector<Handle<Quote> > >& vols,
const DayCounter& dc)
: SwaptionVolatilityDiscrete(optionT, swapT, 0, cal, bdc, dc),
volHandles_(vols),
volatilities_(vols.size(), vols.front().size()) {
checkInputs(volatilities_.rows(), volatilities_.columns());
registerWithMarketData();
interpolation_ =
BilinearInterpolation(swapLengths_.begin(), swapLengths_.end(),
optionTimes_.begin(), optionTimes_.end(),
volatilities_);
}
SingletonKusuoka(Teuchos::ParameterList &parlist)
: RiskMeasure<Real>() {
// Parse parameter list
Teuchos::ParameterList &list
= parlist.sublist("SOL").sublist("Risk Measure").sublist("Singleton Kusuoka");
int nQuad = list.get("Number of Quadrature Points",5);
// Build distribution
Teuchos::RCP<Distribution<Real> > dist = DistributionFactory<Real>(list);
// Build plus function approximation
Teuchos::RCP<PlusFunction<Real> > pf = Teuchos::rcp(new PlusFunction<Real>(list));
// Build generalized trapezoidal rule
std::vector<Real> wts(nQuad), pts(nQuad);
buildQuadFromDist(pts,wts,nQuad,dist);
// Build mixed quantile quadrangle risk measure
buildMixedQuantile(pts,wts,pf);
// Check inputs
checkInputs(dist);
}
PoseVelocityState RK4Integrator::calcStates(const PoseVelocityState &states, const base::Vector6d &control_input)
{
checkInputs(states, control_input);
PoseVelocityState system_states = states;
// Runge-Kuta coefficients
PoseVelocityState k1 = deriv(system_states, control_input);
PoseVelocityState k2 = deriv(system_states + ((integration_step/2)*k1), control_input);
PoseVelocityState k3 = deriv(system_states + ((integration_step/2)*k2), control_input);
PoseVelocityState k4 = deriv(system_states + (integration_step*k3), control_input);
// Calculating the system states
system_states += (integration_step/6)*(k1 + 2*k2 + 2*k3 + k4);
//Brute force normalization of quaternions due the RK4 integration.
system_states.orientation.normalize();
return system_states;
}
