00001 00004 #ifndef __RBF_H__ 00005 #define __RBF_H__ 00006 00007 #include "linalg.hpp" 00008 #include "error.hpp" 00009 #include "func.hpp" 00010 00011 00012 namespace error_handling{ 00014 struct badDimension : public badArgument{ 00015 badDimension() {}; 00016 badDimension(string r, string f, int l) : badArgument(r,f,l){}; 00017 size_t actual_dimension; 00018 size_t given_dimension; 00019 }; 00020 } 00021 00023 namespace rbf{ 00024 using namespace linalg; 00025 00027 class radial_basis_function : public bvp::realfunc{ 00028 public: 00030 radial_basis_function(); 00031 virtual ~radial_basis_function(); 00032 00034 static void set_dimension(size_t dim); 00035 00037 radial_basis_function(const point& c); 00039 void set_centre(const point& c); 00040 00042 double at(const point& x) const; 00044 double operator()(const point& x) const; 00045 00047 double d(const point& x, size_t k) const; 00048 00050 double d2(const point& x, size_t k1, size_t k2) const ; 00051 00053 friend size_t hash_value(const radial_basis_function&); 00054 00055 //For std::set 00056 bool operator<(const radial_basis_function& phi) const; 00057 00058 protected: 00059 00061 virtual double operator()(double r) const = 0; 00063 virtual double d(double r) const = 0; 00065 virtual double d2(double r) const = 0; 00066 00067 private: 00068 00071 void bad_dimension(string file, int line, size_t dim) const; 00072 00074 point centre; 00075 00077 static size_t dimension; 00078 }; 00079 00080 } 00081 00082 //Two important subclasses 00083 namespace rbf{ 00085 class piecewise_smooth_rbf : public radial_basis_function{ 00086 public: 00087 piecewise_smooth_rbf(); 00088 piecewise_smooth_rbf(const point &c) :radial_basis_function(c) {;}; 00089 virtual ~piecewise_smooth_rbf(); 00090 }; 00091 00093 class c_infty_rbf : public radial_basis_function{ 00094 public: 00095 c_infty_rbf(); 00096 c_infty_rbf(const point &c) :radial_basis_function(c) {;}; 00097 00098 virtual ~c_infty_rbf(); 00099 00100 static void set_epsilon(double e); 00101 protected: 00103 static double eps; 00104 }; 00105 } 00106 00107 00108 //Specific rbf's follow... 00109 namespace rbf{ 00110 00112 class piecewise_polynomial : public piecewise_smooth_rbf{ 00113 public: 00114 static void set_n(size_t new_n); 00115 00116 public: 00117 piecewise_polynomial(){}; 00118 piecewise_polynomial(const point& c) : piecewise_smooth_rbf(c){;}; 00119 00120 using radial_basis_function::operator(); 00121 using radial_basis_function::d; 00122 using radial_basis_function::d2; 00123 00124 00125 private: 00127 static size_t n; 00128 double operator()(double r) const; 00129 double d(double r) const; 00130 double d2(double r) const; 00131 00132 }; 00133 00135 typedef piecewise_polynomial conical; 00136 } 00137 00138 namespace rbf{ 00140 class thin_plate_spline : public piecewise_smooth_rbf{ 00141 public: 00142 static void set_n(size_t new_n); 00143 00144 public: 00145 thin_plate_spline(){}; 00146 thin_plate_spline(const point& c) : piecewise_smooth_rbf(c){;}; 00147 00148 using radial_basis_function::operator(); 00149 using radial_basis_function::d; 00150 using radial_basis_function::d2; 00151 00152 private: 00154 static size_t n; 00155 double operator()(double r) const; 00156 double d(double r) const; 00157 double d2(double r) const; 00158 }; 00159 } 00160 00161 00162 namespace rbf{ 00164 class multiquadric : public c_infty_rbf{ 00165 public: 00166 multiquadric(){}; 00167 multiquadric(const point& c) : c_infty_rbf(c){;}; 00168 00169 using radial_basis_function::operator(); 00170 using radial_basis_function::d; 00171 using radial_basis_function::d2; 00172 00173 private: 00174 double operator()(double r) const; 00175 double d(double r) const; 00176 double d2(double r) const; 00177 }; 00178 } 00179 00180 namespace rbf{ 00182 class inverse_multiquadric : public c_infty_rbf{ 00183 public: 00184 inverse_multiquadric(){}; 00185 inverse_multiquadric(const point& c) : c_infty_rbf(c){;}; 00186 00187 using radial_basis_function::operator(); 00188 using radial_basis_function::d; 00189 using radial_basis_function::d2; 00190 00191 private: 00192 double operator()(double r) const; 00193 double d(double r) const; 00194 double d2(double r) const; 00195 }; 00196 } 00197 00198 namespace rbf{ 00200 class inverse_quadratic : public c_infty_rbf{ 00201 public: 00202 inverse_quadratic(){}; 00203 inverse_quadratic(const point& c) : c_infty_rbf(c){;}; 00204 00205 using radial_basis_function::operator(); 00206 using radial_basis_function::d; 00207 using radial_basis_function::d2; 00208 00209 private: 00210 double operator()(double r) const; 00211 double d(double r) const; 00212 double d2(double r) const; 00213 }; 00214 } 00215 00216 namespace rbf{ 00218 class gaussian : public c_infty_rbf{ 00219 public: 00220 gaussian(){}; 00221 gaussian(const point& c) : c_infty_rbf(c){;}; 00222 00223 using radial_basis_function::operator(); 00224 using radial_basis_function::d; 00225 using radial_basis_function::d2; 00226 00227 private: 00228 double operator()(double r) const; 00229 double d(double r) const; 00230 double d2(double r) const; 00231 }; 00232 } 00233 00234 00235 #endif // __RBF_H__