00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #ifndef O2SCL_FIT_BASE_H
00024 #define O2SCL_FIT_BASE_H
00025
00026 #include <string>
00027 #include <o2scl/collection.h>
00028 #include <o2scl/omatrix_tlate.h>
00029 #include <o2scl/text_file.h>
00030
00031 #ifndef DOXYGENP
00032 namespace o2scl {
00033 #endif
00034
00035
00036
00037
00038 template<class param_t, class vec_t=ovector_view> class fit_funct {
00039 public:
00040
00041 fit_funct() {}
00042 virtual ~fit_funct() {}
00043
00044
00045
00046 virtual int operator()(size_t np, vec_t &p, double x, double &y,
00047 param_t &pa) {
00048 set_err_ret("Empty fit_funct::operator()",gsl_nobase);
00049 }
00050
00051 #ifndef DOXYGEN_INTERNAL
00052
00053 private:
00054
00055 fit_funct(const fit_funct &);
00056 fit_funct& operator=(const fit_funct&);
00057
00058 #endif
00059 };
00060
00061
00062
00063
00064 template<class param_t, class vec_t=ovector_view> class fit_funct_fptr :
00065 public fit_funct<param_t,vec_t> {
00066
00067 public:
00068
00069
00070
00071 fit_funct_fptr(int (*fp)(size_t np, vec_t &p, double x,
00072 double &y, param_t &pa)) {
00073 fptr=fp;
00074 }
00075
00076 virtual ~fit_funct_fptr() {}
00077
00078
00079
00080 virtual int operator()(size_t np, vec_t &p, double x, double &y,
00081 param_t &pa) {
00082 return fptr(np,p,x,y,pa);
00083 }
00084
00085 #ifndef DOXYGEN_INTERNAL
00086
00087 protected:
00088
00089 fit_funct_fptr() {};
00090
00091
00092 int (*fptr)(size_t np, vec_t &p, double x, double &y, param_t &pa);
00093
00094 private:
00095
00096 fit_funct_fptr(const fit_funct_fptr &);
00097 fit_funct_fptr& operator=(const fit_funct_fptr&);
00098
00099 #endif
00100
00101 };
00102
00103
00104
00105
00106 template <class tclass, class param_t, class vec_t=ovector_view>
00107 class fit_funct_mfptr : public fit_funct<param_t,vec_t> {
00108 public:
00109
00110
00111
00112 fit_funct_mfptr(tclass *tp,
00113 int (tclass::*fp)(size_t np, vec_t &p, double x,
00114 double &y, param_t &pa)) {
00115 tptr=tp;
00116 fptr=fp;
00117 }
00118
00119 virtual ~fit_funct_mfptr() {};
00120
00121
00122
00123 virtual int operator()(size_t np, vec_t &p, double x, double &y,
00124 param_t &pa) {
00125 return (*tptr.*fptr)(np,p,x,y,pa);
00126 }
00127
00128 #ifndef DOXYGEN_INTERNAL
00129
00130 protected:
00131
00132
00133 int (tclass::*fptr)(size_t np, vec_t &p, double x, double &y, param_t &pa);
00134
00135
00136 tclass *tptr;
00137
00138 private:
00139
00140 fit_funct_mfptr(const fit_funct_mfptr &);
00141 fit_funct_mfptr& operator=(const fit_funct_mfptr&);
00142
00143 #endif
00144
00145 };
00146
00147
00148
00149
00150
00151
00152
00153
00154 template<class param_t, size_t nvar> class fit_vfunct {
00155 public:
00156
00157 fit_vfunct() {}
00158 virtual ~fit_vfunct() {}
00159
00160
00161
00162 virtual int operator()(size_t np, double p[], double x, double &y,
00163 param_t &pa) {
00164 set_err_ret("Empty fit_vfunct::operator()",gsl_nobase);
00165 }
00166
00167 #ifndef DOXYGEN_INTERNAL
00168
00169 private:
00170
00171 fit_vfunct(const fit_vfunct &);
00172 fit_vfunct& operator=(const fit_vfunct&);
00173
00174 #endif
00175 };
00176
00177
00178
00179
00180 template<class param_t, size_t nvar> class fit_vfunct_fptr :
00181 public fit_vfunct<param_t,nvar> {
00182
00183 public:
00184
00185
00186
00187 fit_vfunct_fptr(int (*fp)(size_t np, double p[], double x,
00188 double &y, param_t &pa)) {
00189 fptr=fp;
00190 }
00191
00192 virtual ~fit_vfunct_fptr() {}
00193
00194
00195
00196 virtual int operator()(size_t np, double p[], double x, double &y,
00197 param_t &pa) {
00198 return fptr(np,p,x,y,pa);
00199 }
00200
00201 #ifndef DOXYGEN_INTERNAL
00202
00203 protected:
00204
00205 fit_vfunct_fptr() {};
00206
00207
00208 int (*fptr)(size_t np, double p[], double x, double &y, param_t &pa);
00209
00210 private:
00211
00212 fit_vfunct_fptr(const fit_vfunct_fptr &);
00213 fit_vfunct_fptr& operator=(const fit_vfunct_fptr&);
00214
00215 #endif
00216
00217 };
00218
00219
00220
00221
00222 template <class tclass, class param_t, size_t nvar>
00223 class fit_vfunct_mfptr : public fit_vfunct<param_t,nvar> {
00224 public:
00225
00226
00227
00228 fit_vfunct_mfptr(tclass *tp,
00229 int (tclass::*fp)(size_t np, double p[], double x,
00230 double &y, param_t &pa)) {
00231 tptr=tp;
00232 fptr=fp;
00233 }
00234
00235 virtual ~fit_vfunct_mfptr() {};
00236
00237
00238
00239 virtual int operator()(size_t np, double p[], double x, double &y,
00240 param_t &pa) {
00241 return (*tptr.*fptr)(np,p,x,y,pa);
00242 }
00243
00244 #ifndef DOXYGEN_INTERNAL
00245
00246 protected:
00247
00248
00249 int (tclass::*fptr)(size_t np, double p[], double x, double &y,
00250 param_t &pa);
00251
00252
00253 tclass *tptr;
00254
00255 private:
00256
00257 fit_vfunct_mfptr(const fit_vfunct_mfptr &);
00258 fit_vfunct_mfptr& operator=(const fit_vfunct_mfptr&);
00259
00260 #endif
00261
00262 };
00263
00264
00265
00266
00267
00268
00269
00270
00271
00272 template<class param_t, class func_t,
00273 class vec_t=ovector_view, class mat_t=omatrix_view> class fit_base {
00274 public:
00275
00276 fit_base() {
00277 verbose=0;
00278 }
00279
00280 virtual ~fit_base() {}
00281
00282
00283
00284
00285
00286
00287
00288
00289
00290
00291
00292 virtual int print_iter(size_t nv, vec_t &x, double y, int iter,
00293 double value=0.0, double limit=0.0) {
00294 if (verbose<=0) return 0;
00295
00296 size_t i;
00297 char ch;
00298
00299 std::cout << "Iteration: " << iter << std::endl;
00300 text_out_file outs(&std::cout,79);
00301 outs.word_out("x:");
00302 for(i=0;i<nv;i++) outs.double_out(x[i]);
00303 outs.end_line();
00304 std::cout << "y: " << y << " Val: " << value << " Lim: " << limit
00305 << std::endl;
00306 if (verbose>1) {
00307 std::cout << "Press a key and type enter to continue. ";
00308 std::cin >> ch;
00309 }
00310
00311 return 0;
00312 }
00313
00314
00315
00316
00317
00318
00319
00320
00321 virtual int fit(size_t ndat, vec_t &xdat, vec_t &ydat, vec_t &yerr,
00322 size_t npar, vec_t &par, mat_t &covar, double &chi2,
00323 param_t &pa, func_t &fitfun) {
00324 set_err_ret("Empty fit_base::fit()",gsl_nobase);
00325 }
00326
00327
00328
00329 int verbose;
00330
00331
00332 virtual const char *type() { return "fit_base"; }
00333
00334
00335 size_t n_dat;
00336
00337
00338 size_t n_par;
00339
00340
00341 };
00342
00343 #ifndef DOXYGENP
00344 }
00345 #endif
00346
00347 #endif