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_FUNCT_H
00024 #define O2SCL_FUNCT_H
00025
00026 #include <string>
00027 #include <o2scl/collection.h>
00028
00029 #ifndef DOXYGENP
00030 namespace o2scl {
00031 #endif
00032
00033
00034
00035
00036
00037 template<class param_t>
00038 class funct {
00039
00040 public:
00041
00042 funct() {}
00043
00044 virtual ~funct() {}
00045
00046
00047
00048 virtual int operator()(double x, double &y, param_t &pa) {
00049 set_err_ret("Empty base function called in funct::operator()",
00050 gsl_nobase);
00051 }
00052
00053
00054
00055 virtual double operator()(double x, param_t &pa) {
00056 double y;
00057 operator()(x,y,pa);
00058 return y;
00059 }
00060
00061 #ifndef DOXYGENP
00062
00063 private:
00064
00065 funct(const funct &);
00066
00067 funct& operator=(const funct&);
00068
00069 #endif
00070
00071 };
00072
00073
00074
00075 template<class param_t>
00076 class funct_fptr : public funct<param_t> {
00077 public:
00078
00079
00080
00081 funct_fptr(int (*fp)(double x, double &y, param_t &pa)) {
00082 fptr=fp;
00083 }
00084
00085 virtual ~funct_fptr() {}
00086
00087 virtual int operator()(double x, double &y, param_t &pa) {
00088 return fptr(x,y,pa);
00089 }
00090
00091
00092
00093 virtual double operator()(double x, param_t &pa) {
00094 double y;
00095 operator()(x,y,pa);
00096 return y;
00097 }
00098
00099 #ifndef DOXYGEN_INTERNAL
00100
00101 protected:
00102
00103 friend class io_tlate<funct_fptr>;
00104
00105 funct_fptr() {};
00106
00107
00108 int (*fptr)(double x, double &y, param_t &pa);
00109
00110 #endif
00111 #ifndef DOXYGENP
00112
00113 private:
00114
00115 funct_fptr(const funct_fptr &);
00116 funct_fptr& operator=(const funct_fptr&);
00117
00118 #endif
00119
00120 };
00121
00122
00123
00124 template<class param_t>
00125 class funct_fptr_noerr : public funct<param_t> {
00126 public:
00127
00128
00129
00130 funct_fptr_noerr(double (*fp)(double x, param_t &pa)) {
00131 fptr=fp;
00132 }
00133
00134 virtual ~funct_fptr_noerr() {}
00135
00136 virtual int operator()(double x, double &y, param_t &pa) {
00137 y=fptr(x,pa);
00138 return 0;
00139 }
00140
00141
00142
00143 virtual double operator()(double x, param_t &pa) {
00144 double y;
00145 operator()(x,y,pa);
00146 return y;
00147 }
00148
00149 #ifndef DOXYGEN_INTERNAL
00150
00151 protected:
00152
00153
00154 double (*fptr)(double x, param_t &pa);
00155
00156 #endif
00157 #ifndef DOXYGENP
00158
00159 private:
00160
00161 funct_fptr_noerr(const funct_fptr_noerr &);
00162 funct_fptr_noerr& operator=(const funct_fptr_noerr&);
00163
00164 #endif
00165
00166 };
00167
00168
00169
00170 template<class param_t>
00171 class funct_fptr_nopar : public funct<param_t> {
00172 public:
00173
00174
00175
00176 funct_fptr_nopar(double (*fp)(double x)) {
00177 fptr=fp;
00178 }
00179
00180 virtual ~funct_fptr_nopar() {}
00181
00182 virtual int operator()(double x, double &y, param_t &pa) {
00183 y=fptr(x);
00184 return 0;
00185 }
00186
00187
00188
00189 virtual double operator()(double x, param_t &pa) {
00190 double y;
00191 operator()(x,y,pa);
00192 return y;
00193 }
00194
00195 #ifndef DOXYGEN_INTERNAL
00196
00197 protected:
00198
00199
00200 double (*fptr)(double x);
00201
00202 #endif
00203 #ifndef DOXYGENP
00204
00205 private:
00206
00207 funct_fptr_nopar(const funct_fptr_nopar &);
00208 funct_fptr_nopar& operator=(const funct_fptr_nopar&);
00209
00210 #endif
00211
00212 };
00213
00214
00215
00216
00217 template <class tclass, class param_t> class funct_mfptr :
00218 public funct<param_t> {
00219 public:
00220
00221
00222
00223 funct_mfptr(tclass *tp, int (tclass::*fp)(double x, double &y,
00224 param_t &pa)) {
00225 tptr=tp;
00226 fptr=fp;
00227 }
00228
00229 virtual ~funct_mfptr() {};
00230
00231 virtual int operator()(double x, double &y, param_t &pa) {
00232 return (*tptr.*fptr)(x,y,pa);
00233 }
00234
00235
00236
00237 virtual double operator()(double x, param_t &pa) {
00238 double y;
00239 operator()(x,y,pa);
00240 return y;
00241 }
00242
00243 #ifndef DOXYGEN_INTERNAL
00244
00245 protected:
00246
00247
00248 int (tclass::*fptr)(double x, double &y, param_t &pa);
00249
00250
00251 tclass *tptr;
00252
00253 #endif
00254 #ifndef DOXYGENP
00255
00256 private:
00257
00258 funct_mfptr(const funct_mfptr &);
00259 funct_mfptr& operator=(const funct_mfptr&);
00260
00261 #endif
00262
00263 };
00264
00265
00266
00267 template <class tclass, class param_t> class funct_mfptr_noerr :
00268 public funct<param_t> {
00269 public:
00270
00271
00272
00273 funct_mfptr_noerr(tclass *tp,
00274 double (tclass::*fp)(double x, param_t &pa)) {
00275 tptr=tp;
00276 fptr=fp;
00277 }
00278
00279 virtual ~funct_mfptr_noerr() {};
00280
00281 virtual int operator()(double x, double &y, param_t &pa) {
00282 y=(*tptr.*fptr)(x,pa);
00283 return 0;
00284 }
00285
00286
00287
00288 virtual double operator()(double x, param_t &pa) {
00289 double y;
00290 operator()(x,y,pa);
00291 return y;
00292 }
00293
00294 #ifndef DOXYGEN_INTERNAL
00295
00296 protected:
00297
00298
00299 double (tclass::*fptr)(double x, param_t &pa);
00300
00301
00302 tclass *tptr;
00303
00304 #endif
00305 #ifndef DOXYGENP
00306
00307 private:
00308
00309 funct_mfptr_noerr(const funct_mfptr_noerr &);
00310 funct_mfptr_noerr& operator=(const funct_mfptr_noerr&);
00311
00312 #endif
00313
00314 };
00315
00316
00317
00318 template <class tclass, class param_t> class funct_mfptr_nopar :
00319 public funct<param_t> {
00320 public:
00321
00322
00323
00324 funct_mfptr_nopar(tclass *tp, double (tclass::*fp)(double x)) {
00325 tptr=tp;
00326 fptr=fp;
00327 }
00328
00329 virtual ~funct_mfptr_nopar() {};
00330
00331 virtual int operator()(double x, double &y, param_t &pa) {
00332 y=(*tptr.*fptr)(x);
00333 return 0;
00334 }
00335
00336
00337
00338 virtual double operator()(double x, param_t &pa) {
00339 double y;
00340 operator()(x,y,pa);
00341 return y;
00342 }
00343
00344 #ifndef DOXYGEN_INTERNAL
00345
00346 protected:
00347
00348
00349 double (tclass::*fptr)(double x);
00350
00351 tclass *tptr;
00352
00353 #endif
00354 #ifndef DOXYGENP
00355
00356 private:
00357
00358 funct_mfptr_nopar(const funct_mfptr_nopar &);
00359 funct_mfptr_nopar& operator=(const funct_mfptr_nopar&);
00360
00361 #endif
00362
00363 };
00364
00365 #ifndef DOXYGENP
00366 }
00367 #endif
00368
00369 #endif