A Recursive approach to construction of ...NCubicSpline classes (a missing part)
Posted by RGProlog on
URL: http://quantlib.414.s1.nabble.com/A-Recursive-approach-to-construction-of-NCubicSpline-classes-a-missing-part-tp2336.html
// BicubicSpline.hpp
// Copyright (C) 2002, 2003 Roman Gitlin
#ifndef bicubicspline_hpp
#define bicubicspline_hpp
#include <CubicSpline\CubicSpline.hpp>
namespace QuantLib {
namespace Math {
template<class X1, class X2, typename X3>
class BicubicSpline :
public std::binary_function <QL_ITERATOR_TRAITS<X1>::value_type,
QL_ITERATOR_TRAITS<X2>::value_type,
X3>
{
public:
typedef typename
std::vector<result_type>::iterator iterator;
typedef typename
std::vector<result_type>::const_iterator const_iterator;
typedef typename
std::vector<std::vector<result_type> > data_table;
BicubicSpline(int,
const X1 &,
const X2 &,
const data_table &,
const data_table &,
int,
int,
bool);
BicubicSpline(const X1 &,
const X2 &,
const data_table &,
const data_table &,
int,
int,
bool);
virtual ~BicubicSpline(){}
result_type operator()(first_argument_type,
second_argument_type) const;
private:
// data
const int m_;
const int n_;
const X1 &x1_;
const X2 &x2_;
const data_table &y_;
const data_table &y2_;
bool allow_extrapolation_;
};
template<class X1, class X2, typename X3>
BicubicSpline<X1, X2, X3>::BicubicSpline(const X1 &x1,
const X2 &x2,
const data_table &y,
const data_table &y2,
int m,
int n,
bool extrapolation)
: m_(m), n_(n), x1_(x1), x2_(x2), y_(y), y2_(y2),
allow_extrapolation_(extrapolation) {
try {
for(int i = 0; i < m_; ++i)
CubicSpline<X2, const_iterator>(x2_,
y_[i].begin(),
(iterator)y2_[i].begin(),
n_,
allow_extrapolation_);
}
catch(std::exception &e) {
std::cerr << "BicubicSpline<X1, X2, X3>::BicubicSpline(const "
"X1 &, const X2 &, const std::vector<std::vector"
<< "<X3> > &, int, int, bool) : "
<< e.what() << std::endl;
throw;
}
}
template<class X1, class X2, typename X3>
BicubicSpline<X1, X2, X3>::BicubicSpline(int,
const X1 &x1,
const X2 &x2,
const data_table &y,
const data_table &y2,
int m,
int n,
bool extrapolation)
: m_(m), n_(n), x1_(x1), x2_(x2), y_(y), y2_(y2),
allow_extrapolation_(extrapolation) {}
template<class X1, class X2, typename X3>
BicubicSpline<X1, X2, X3>::result_type
BicubicSpline<X1, X2, X3>::operator()(first_argument_type x,
second_argument_type y) const {
try {
std::vector<result_type> temp1(m_),
temp2(m_);
iterator ya = temp1.begin(),
y2 = temp2.begin();
for(int i = 0; i < m_; ++i)
ya[i] = CubicSpline<X2, const_iterator>(0,
x2_,
y_[i].begin(),
(iterator)y2_[i].begin(),
n_,
allow_extrapolation_)(y);
return CubicSpline<X1, const_iterator>(x1_,
ya,
y2,
m_,
allow_extrapolation_)(x);
}
catch(std::exception &e) {
std::cerr << "BiCubicInterpolation<X1, X2, X3>::operator() : "
<< e.what() << std::endl;
throw;
}
}
}
}
#endif
// TricubicSpline.hpp
// Copyright (C) 2002, 2003 Roman Gitlin
#ifndef tricubicspline_hpp
#define tricubicspline_hpp
#include <BicubicSpline\BicubicSpline.hpp>
namespace QuantLib {
namespace Math {
template<class X1, class X2, typename X3, class X4>
class TricubicSpline
{
public:
typedef typename
QL_ITERATOR_TRAITS<X1>::value_type first_argument_type;
typedef typename
QL_ITERATOR_TRAITS<X2>::value_type second_argument_type;
typedef typename
QL_ITERATOR_TRAITS<X3>::value_type third_argument_type;
typedef typename
X4 result_type;
typedef typename
std::vector<result_type>::iterator iterator;
typedef typename
std::vector<result_type>::const_iterator const_iterator;
typedef typename
std::vector<std::vector<result_type> > D2data_table;
typedef typename
std::vector<D2data_table> D3data_table;
TricubicSpline(int,
const X1 &,
const X2 &,
const X3 &,
const D3data_table &,
const D3data_table &,
int,
int,
int,
bool);
TricubicSpline(const X1 &,
const X2 &,
const X3 &,
const D3data_table &,
const D3data_table &,
int,
int,
int,
bool);
virtual ~TricubicSpline(){}
result_type operator()(first_argument_type,
second_argument_type,
third_argument_type) const;
private:
// data
const int m_;
const int n_;
const int o_;
const X1 &x1_;
const X2 &x2_;
const X3 &x3_;
const D3data_table &y_;
const D3data_table &y2_;
bool allow_extrapolation_;
};
template<class X1, class X2, class X3, typename X4>
TricubicSpline<X1, X2, X3, X4>::TricubicSpline(const X1 &x1,
const X2 &x2,
const X3 &x3,
const D3data_table &y,
const D3data_table &y2,
int m,
int n,
int o,
bool extrapolation)
: m_(m), n_(n), o_(o), x1_(x1), x2_(x2), x3_(x3), y_(y), y2_(y2),
allow_extrapolation_(extrapolation) {
try {
for(int i = 0; i < m_; ++i)
BicubicSpline<X2, X3, X4>(x2_,
x3_,
y_[i],
y2_[i],
n_,
o_,
allow_extrapolation_);
}
catch(std::exception &e) {
std::cerr << "TricubicSpline<X1, X2, X3, X4>::TricubicSpline"
"(const X1 &, const X2 &, const X3 &, conststd::vector<" "std::vector<std::vector<X3> > >&, const std::vector<"
"std::vector<std::vector<X3> > >&, int, int, int, bool) : "
<< e.what() << std::endl;
throw;
}
}
template<class X1, class X2, class X3, typename X4>
TricubicSpline<X1, X2, X3, X4>::TricubicSpline(int,
const X1 &x1,
const X2 &x2,
const X3 &x3,
const D3data_table &y,
const D3data_table &y2,
int m,
int n,
int o,
bool extrapolation)
: m_(m), n_(n), o_(o), x1_(x1), x2_(x2), x3_(x3), y_(y), y2_(y2),
allow_extrapolation_(extrapolation) {}
template<class X1, class X2, class X3, typename X4>
TricubicSpline<X1, X2, X3, X4>::result_type
TricubicSpline<X1, X2, X3, X4>::operator()(first_argument_type x,
second_argument_type y,
third_argument_type z) const {
try {
std::vector<result_type> temp1(m_),
temp2(m_);
iterator ya = temp1.begin(),
y2 = temp2.begin();
for(int i = 0; i < m_; ++i)
ya[i] = BicubicSpline<X2, X3, X4>(0,
x2_,
x3_,
y_[i],
y2_[i],
n_,
o_,
allow_extrapolation_)(y, z);
return CubicSpline<X1, const_iterator>(x1_,
ya,
y2,
m_,
allow_extrapolation_)(x);
}
catch(std::exception &e) {
std::cerr << "BiCubicInterpolation<X1, X2, X3>::operator() : "
<< e.what() << std::endl;
throw;
}
}
}
}
#endif