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_MM_FUNCT_H
00024 #define O2SCL_MM_FUNCT_H
00025
00026 #include <string>
00027 #include <o2scl/collection.h>
00028 #include <o2scl/ovector_tlate.h>
00029
00030 #ifndef DOXYGENP
00031 namespace o2scl {
00032 #endif
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044 template<class param_t, class vec_t=ovector_view>
00045 class mm_funct {
00046 public:
00047
00048 mm_funct() {}
00049
00050 virtual ~mm_funct() {}
00051
00052
00053
00054
00055 virtual int operator()(size_t nv, const vec_t &x, vec_t &y, param_t &pa) {
00056 set_err_ret("Missing base in mm_funct::operator().",gsl_nobase);
00057 }
00058
00059 #ifndef DOXYGENP
00060
00061 private:
00062
00063 mm_funct(const mm_funct &);
00064 mm_funct& operator=(const mm_funct&);
00065
00066 #endif
00067
00068 };
00069
00070
00071
00072 template<class param_t, class vec_t=ovector_view>
00073 class mm_funct_fptr : public mm_funct<param_t,vec_t> {
00074
00075 public:
00076
00077 mm_funct_fptr() {}
00078
00079 virtual ~mm_funct_fptr() {}
00080
00081
00082
00083 mm_funct_fptr(int (*fp)(size_t nv, const vec_t &x, vec_t &y,
00084 param_t &pa)) {
00085 fptr=fp;
00086 }
00087
00088
00089
00090 int set_function(int (*fp)(size_t nv, const vec_t &x, vec_t &y,
00091 param_t &pa)) {
00092 fptr=fp;
00093 return 0;
00094 }
00095
00096
00097
00098
00099 virtual int operator()(size_t nv, const vec_t &x, vec_t &y, param_t &pa) {
00100 return fptr(nv,x,y,pa);
00101 }
00102
00103
00104 #ifndef DOXYGEN_INTERNAL
00105
00106 protected:
00107
00108 friend class io_tlate<mm_funct_fptr>;
00109
00110
00111 int (*fptr)(size_t nv, const vec_t &x, vec_t &y, param_t &pa);
00112
00113 private:
00114
00115 mm_funct_fptr(const mm_funct_fptr &);
00116 mm_funct_fptr& operator=(const mm_funct_fptr&);
00117
00118 #endif
00119
00120 };
00121
00122
00123
00124
00125 template<class param_t, class vec_t=ovector_view>
00126 class mm_funct_fptr_nopar : public mm_funct<param_t,vec_t> {
00127
00128 public:
00129
00130 mm_funct_fptr_nopar() {}
00131
00132 virtual ~mm_funct_fptr_nopar() {}
00133
00134
00135
00136 mm_funct_fptr_nopar(int (*fp)(size_t nv, const vec_t &x, vec_t &y)) {
00137 fptr=fp;
00138 }
00139
00140
00141
00142 int set_function(int (*fp)(size_t nv, const vec_t &x, vec_t &y)) {
00143 fptr=fp;
00144 return 0;
00145 }
00146
00147
00148
00149
00150 virtual int operator()(size_t nv, const vec_t &x, vec_t &y, param_t &pa) {
00151 return fptr(nv,x,y);
00152 }
00153
00154
00155 #ifndef DOXYGEN_INTERNAL
00156
00157 protected:
00158
00159 friend class io_tlate<mm_funct_fptr_nopar>;
00160
00161
00162 int (*fptr)(size_t nv, const vec_t &x, vec_t &y);
00163
00164 private:
00165
00166 mm_funct_fptr_nopar(const mm_funct_fptr_nopar &);
00167 mm_funct_fptr_nopar& operator=(const mm_funct_fptr_nopar&);
00168
00169 #endif
00170
00171 };
00172
00173
00174
00175
00176
00177
00178
00179
00180 template<class param_t, class vec_t=ovector_view>
00181 class mm_funct_gsl : public mm_funct<param_t,vec_t> {
00182 public:
00183
00184
00185
00186 mm_funct_gsl(int (*fp)(const gsl_vector *x, param_t &pa, gsl_vector *f)) {
00187 fptr=fp;
00188 }
00189
00190
00191
00192
00193 virtual int operator()(size_t nv, const vec_t &x, vec_t &y, param_t &pa) {
00194 const gsl_vector *gx=(const gsl_vector *)(&x);
00195 gsl_vector *gy=(gsl_vector *)(&y);
00196 return fptr(gx,pa,gy);
00197 }
00198
00199 #ifndef DOXYGEN_INTERNAL
00200
00201 protected:
00202
00203 friend class io_tlate<mm_funct_gsl>;
00204
00205
00206 int (*fptr)(const gsl_vector *x, param_t &pa, gsl_vector *f);
00207
00208 private:
00209
00210 mm_funct_gsl(const mm_funct_gsl &);
00211 mm_funct_gsl& operator=(const mm_funct_gsl&);
00212
00213 #endif
00214
00215 };
00216
00217
00218
00219
00220 template<class tclass, class param_t, class vec_t=ovector_view>
00221 class mm_funct_mfptr : public mm_funct<param_t,vec_t> {
00222 public:
00223
00224
00225
00226 mm_funct_mfptr() {
00227 }
00228
00229
00230
00231 mm_funct_mfptr(tclass *tp, int (tclass::*fp)
00232 (size_t nv, const vec_t &x, vec_t &y, param_t &pa)) {
00233 tptr=tp;
00234 fptr=fp;
00235 }
00236
00237
00238
00239 int set_function(tclass *tp, int (tclass::*fp)
00240 (size_t nv, const vec_t &x, vec_t &y, param_t &pa))
00241 {
00242 tptr=tp;
00243 fptr=fp;
00244 return 0;
00245 }
00246
00247 virtual ~mm_funct_mfptr() {};
00248
00249
00250
00251
00252 virtual int operator()(size_t nv, const vec_t &x, vec_t &y, param_t &pa) {
00253 return (*tptr.*fptr)(nv,x,y,pa);
00254 }
00255
00256 #ifndef DOXYGEN_INTERNAL
00257
00258 protected:
00259
00260
00261 int (tclass::*fptr)(size_t nv, const vec_t &x, vec_t &y, param_t &pa);
00262
00263
00264 tclass *tptr;
00265
00266 private:
00267
00268 mm_funct_mfptr(const mm_funct_mfptr &);
00269 mm_funct_mfptr& operator=(const mm_funct_mfptr&);
00270
00271 #endif
00272
00273 };
00274
00275
00276
00277
00278 template<class tclass, class param_t, class vec_t=ovector_view>
00279 class mm_funct_mfptr_nopar : public mm_funct<param_t,vec_t> {
00280 public:
00281
00282
00283
00284 mm_funct_mfptr_nopar() {
00285 }
00286
00287
00288
00289 mm_funct_mfptr_nopar(tclass *tp, int (tclass::*fp)
00290 (size_t nv, const vec_t &x, vec_t &y)) {
00291 tptr=tp;
00292 fptr=fp;
00293 }
00294
00295
00296
00297 int set_function(tclass *tp, int (tclass::*fp)
00298 (size_t nv, const vec_t &x, vec_t &y))
00299 {
00300 tptr=tp;
00301 fptr=fp;
00302 return 0;
00303 }
00304
00305 virtual ~mm_funct_mfptr_nopar() {};
00306
00307
00308
00309
00310 virtual int operator()(size_t nv, const vec_t &x, vec_t &y, param_t &pa) {
00311 return (*tptr.*fptr)(nv,x,y);
00312 }
00313
00314 #ifndef DOXYGEN_INTERNAL
00315
00316 protected:
00317
00318
00319 int (tclass::*fptr)(size_t nv, const vec_t &x, vec_t &y);
00320
00321
00322 tclass *tptr;
00323
00324 private:
00325
00326 mm_funct_mfptr_nopar(const mm_funct_mfptr_nopar &);
00327 mm_funct_mfptr_nopar& operator=(const mm_funct_mfptr_nopar&);
00328
00329 #endif
00330
00331 };
00332
00333
00334
00335
00336
00337
00338
00339
00340
00341
00342
00343
00344 template<class param_t, size_t nv>
00345 class mm_vfunct {
00346 public:
00347
00348 mm_vfunct() {}
00349
00350 virtual ~mm_vfunct() {}
00351
00352
00353
00354
00355 virtual int operator()(size_t nvar, const double x[nv],
00356 double y[nv], param_t &pa) {
00357 set_err_ret("Missing base in mm_vfunct::operator().",gsl_nobase);
00358 }
00359
00360 #ifndef DOXYGENP
00361
00362 private:
00363
00364 mm_vfunct(const mm_vfunct &);
00365 mm_vfunct& operator=(const mm_vfunct&);
00366
00367 #endif
00368
00369 };
00370
00371
00372
00373
00374 template<class param_t, size_t nv> class mm_vfunct_fptr :
00375 public mm_vfunct<param_t,nv> {
00376 public:
00377
00378
00379
00380 mm_vfunct_fptr(int (*fp)(size_t nvar, const double x[nv], double y[nv],
00381 param_t &pa)) {
00382 fptr=fp;
00383 }
00384
00385
00386 virtual ~mm_vfunct_fptr() {};
00387
00388
00389
00390
00391 virtual int operator()(size_t nvar, const double x[nv], double y[nv],
00392 param_t &pa) {
00393 return fptr(nv,x,y,pa);
00394 }
00395
00396
00397 #ifndef DOXYGEN_INTERNAL
00398
00399 protected:
00400
00401 friend class io_tlate<mm_vfunct_fptr>;
00402
00403 mm_vfunct_fptr() {};
00404
00405
00406 int (*fptr)(size_t nvar, const double x[nv], double y[nv], param_t &pa);
00407
00408 private:
00409
00410 mm_vfunct_fptr(const mm_vfunct_fptr &);
00411 mm_vfunct_fptr& operator=(const mm_vfunct_fptr&);
00412
00413 #endif
00414
00415 };
00416
00417
00418
00419
00420 template<class param_t, size_t nv> class mm_vfunct_fptr_nopar :
00421 public mm_vfunct<param_t,nv>
00422 {
00423 public:
00424
00425
00426
00427 mm_vfunct_fptr_nopar(int (*fp)(size_t nvar, const double x[nv],
00428 double y[nv])) {
00429 fptr=fp;
00430 }
00431
00432
00433 virtual ~mm_vfunct_fptr_nopar() {};
00434
00435
00436
00437
00438 virtual int operator()(size_t nvar, const double x[nv], double y[nv],
00439 param_t &pa) {
00440 return fptr(nv,x,y);
00441 }
00442
00443
00444 #ifndef DOXYGEN_INTERNAL
00445
00446 protected:
00447
00448 friend class io_tlate<mm_vfunct_fptr_nopar>;
00449
00450 mm_vfunct_fptr_nopar() {};
00451
00452
00453 int (*fptr)(size_t nvar, const double x[nv], double y[nv]);
00454
00455 private:
00456
00457 mm_vfunct_fptr_nopar(const mm_vfunct_fptr_nopar &);
00458 mm_vfunct_fptr_nopar& operator=(const mm_vfunct_fptr_nopar&);
00459
00460 #endif
00461
00462 };
00463
00464
00465
00466 template<class param_t, size_t nv>
00467 class mm_vfunct_gsl : public mm_vfunct<param_t,nv> {
00468 public:
00469
00470
00471
00472 mm_vfunct_gsl(int (*fp)(const gsl_vector *x, param_t &pa, gsl_vector *f)) {
00473 fptr=fp;
00474 }
00475
00476
00477
00478
00479 virtual int operator()(size_t nvar, const double x[nv],
00480 double y[nv], param_t &pa) {
00481 const gsl_vector *gx=(const gsl_vector *)(&x);
00482 gsl_vector *gy=(gsl_vector *)(&y);
00483 return fptr(gx,pa,gy);
00484 }
00485
00486 #ifndef DOXYGEN_INTERNAL
00487
00488 protected:
00489
00490 friend class io_tlate<mm_vfunct_gsl>;
00491
00492
00493 int (*fptr)(const gsl_vector *x, param_t &pa, gsl_vector *f);
00494
00495 private:
00496
00497 mm_vfunct_gsl(const mm_vfunct_gsl &);
00498 mm_vfunct_gsl& operator=(const mm_vfunct_gsl&);
00499
00500 #endif
00501
00502 };
00503
00504
00505
00506
00507 template<class tclass, class param_t, size_t nv>
00508 class mm_vfunct_mfptr : public mm_vfunct<param_t,nv> {
00509 public:
00510
00511
00512
00513 mm_vfunct_mfptr(tclass *tp, int (tclass::*fp)
00514 (size_t nvar, const double x[nv], double y[nv],
00515 param_t &pa)) {
00516 tptr=tp;
00517 fptr=fp;
00518 }
00519
00520 virtual ~mm_vfunct_mfptr() {};
00521
00522
00523
00524
00525 virtual int operator()(size_t nvar, const double x[nv], double y[nv],
00526 param_t &pa) {
00527 return (*tptr.*fptr)(nv,x,y,pa);
00528 }
00529
00530 #ifndef DOXYGEN_INTERNAL
00531
00532 protected:
00533
00534
00535 int (tclass::*fptr)(size_t nvar, const double x[nv], double y[nv],
00536 param_t &pa);
00537
00538
00539 tclass *tptr;
00540
00541 private:
00542
00543 mm_vfunct_mfptr(const mm_vfunct_mfptr &);
00544 mm_vfunct_mfptr& operator=(const mm_vfunct_mfptr&);
00545
00546 #endif
00547
00548 };
00549
00550
00551
00552
00553 template<class tclass, class param_t, size_t nv>
00554 class mm_vfunct_mfptr_nopar : public mm_vfunct<param_t,nv> {
00555
00556 public:
00557
00558
00559
00560 mm_vfunct_mfptr_nopar(tclass *tp, int (tclass::*fp)
00561 (size_t nvar, const double x[nv], double y[nv])) {
00562 tptr=tp;
00563 fptr=fp;
00564 }
00565
00566 virtual ~mm_vfunct_mfptr_nopar() {};
00567
00568
00569
00570
00571 virtual int operator()(size_t nvar, const double x[nv], double y[nv],
00572 param_t &pa) {
00573 return (*tptr.*fptr)(nv,x,y);
00574 }
00575
00576 #ifndef DOXYGEN_INTERNAL
00577
00578 protected:
00579
00580
00581 int (tclass::*fptr)(size_t nvar, const double x[nv], double y[nv]);
00582
00583
00584 tclass *tptr;
00585
00586 private:
00587
00588 mm_vfunct_mfptr_nopar(const mm_vfunct_mfptr_nopar &);
00589 mm_vfunct_mfptr_nopar& operator=(const mm_vfunct_mfptr_nopar&);
00590
00591 #endif
00592
00593 };
00594
00595 #ifndef DOXYGENP
00596 }
00597 #endif
00598
00599 #endif