ccgsl 2.7.2
C++wrappersforGnuScientificLibrary
movstat_function.hpp
Go to the documentation of this file.
1/*
2 * $Id$
3 * Copyright (C) 2020 John D Lamb
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or (at
8 * your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
19
20#ifndef CCGSL_MOVSTAT_FUNCTION_HPP
21#define CCGSL_MOVSTAT_FUNCTION_HPP
22
23#include<gsl/gsl_movstat.h>
24#include"vector.hpp"
25
26namespace gsl {
27 namespace movstat {
58 class function : public gsl_movstat_function {
59#ifndef DOXYGEN_SKIP
60 private:
64 struct base_F {
68 typedef double (*function_t)(size_t,double*,void*);
72 virtual ~base_F(){};
77 virtual function_t function() = 0;
78 };
82 class Fuvcr : public base_F {
83 public:
88 Fuvcr( double (*const f)(gsl::vector const&) ) : f( f ), xv( static_cast<size_t>(0) ){}
92 function_t function(){ return &fn; }
93 private:
97 double (*const f)(gsl::vector const&);
101 gsl::vector xv;
109 static double fn( size_t n, double* x, void* params ){
110 Fuvcr* ft = reinterpret_cast<Fuvcr*>( params );
111 ft->xv.get()->size = n;
112 ft->xv.get()->data = x;
113 double result = ft->f( ft->xv );
114 ft->xv.get()->data = 0;
115 ft->xv.get()->size = 0;
116 return result;
117 }
118 };
122 class FuvCr : public base_F {
123 public:
128 FuvCr( double (*const f)(gsl::vector const volatile&) ) : f( f ), xv( static_cast<size_t>(0) ){}
132 function_t function(){ return &fn; }
133 private:
137 double (*const f)(gsl::vector const volatile&);
141 gsl::vector xv;
149 static double fn( size_t n, double* x, void* params ){
150 FuvCr* ft = reinterpret_cast<FuvCr*>( params );
151 ft->xv.get()->size = n;
152 ft->xv.get()->data = x;
153 double result = ft->f( ft->xv );
154 ft->xv.get()->data = 0;
155 ft->xv.get()->size = 0;
156 return result;
157 }
158 };
162 class Fcvcr : public base_F {
163 public:
168 Fcvcr( double const (*const f)(gsl::vector const&) ) : f( f ), xv( static_cast<size_t>(0) ){}
172 function_t function(){ return &fn; }
173 private:
177 double const (*const f)(gsl::vector const&);
181 gsl::vector xv;
189 static double fn( size_t n, double* x, void* params ){
190 Fcvcr* ft = reinterpret_cast<Fcvcr*>( params );
191 ft->xv.get()->size = n;
192 ft->xv.get()->data = x;
193 double result = ft->f( ft->xv );
194 ft->xv.get()->data = 0;
195 ft->xv.get()->size = 0;
196 return result;
197 }
198 };
202 class FcvCr : public base_F {
203 public:
208 FcvCr( double const (*const f)(gsl::vector const volatile&) ) : f( f ), xv( static_cast<size_t>(0) ){}
212 function_t function(){ return &fn; }
213 private:
217 double const (*const f)(gsl::vector const volatile&);
221 gsl::vector xv;
229 static double fn( size_t n, double* x, void* params ){
230 FcvCr* ft = reinterpret_cast<FcvCr*>( params );
231 ft->xv.get()->size = n;
232 ft->xv.get()->data = x;
233 double result = ft->f( ft->xv );
234 ft->xv.get()->data = 0;
235 ft->xv.get()->size = 0;
236 return result;
237 }
238 };
242 class Furcr : public base_F {
243 public:
248 Furcr( double& (*const f)(gsl::vector const&) ) : f( f ), xv( static_cast<size_t>(0) ){}
252 function_t function(){ return &fn; }
253 private:
257 double& (*const f)(gsl::vector const&);
261 gsl::vector xv;
269 static double fn( size_t n, double* x, void* params ){
270 Furcr* ft = reinterpret_cast<Furcr*>( params );
271 ft->xv.get()->size = n;
272 ft->xv.get()->data = x;
273 double result = ft->f( ft->xv );
274 ft->xv.get()->data = 0;
275 ft->xv.get()->size = 0;
276 return result;
277 }
278 };
282 class FurCr : public base_F {
283 public:
288 FurCr( double& (*const f)(gsl::vector const volatile&) ) : f( f ), xv( static_cast<size_t>(0) ){}
292 function_t function(){ return &fn; }
293 private:
297 double& (*const f)(gsl::vector const volatile&);
301 gsl::vector xv;
309 static double fn( size_t n, double* x, void* params ){
310 FurCr* ft = reinterpret_cast<FurCr*>( params );
311 ft->xv.get()->size = n;
312 ft->xv.get()->data = x;
313 double result = ft->f( ft->xv );
314 ft->xv.get()->data = 0;
315 ft->xv.get()->size = 0;
316 return result;
317 }
318 };
322 class Fcrcr : public base_F {
323 public:
328 Fcrcr( double const& (*const f)(gsl::vector const&) ) : f( f ), xv( static_cast<size_t>(0) ){}
332 function_t function(){ return &fn; }
333 private:
337 double const& (*const f)(gsl::vector const&);
341 gsl::vector xv;
349 static double fn( size_t n, double* x, void* params ){
350 Fcrcr* ft = reinterpret_cast<Fcrcr*>( params );
351 ft->xv.get()->size = n;
352 ft->xv.get()->data = x;
353 double result = ft->f( ft->xv );
354 ft->xv.get()->data = 0;
355 ft->xv.get()->size = 0;
356 return result;
357 }
358 };
362 class FcrCr : public base_F {
363 public:
368 FcrCr( double const& (*const f)(gsl::vector const volatile&) ) : f( f ), xv( static_cast<size_t>(0) ){}
372 function_t function(){ return &fn; }
373 private:
377 double const& (*const f)(gsl::vector const volatile&);
381 gsl::vector xv;
389 static double fn( size_t n, double* x, void* params ){
390 FcrCr* ft = reinterpret_cast<FcrCr*>( params );
391 ft->xv.get()->size = n;
392 ft->xv.get()->data = x;
393 double result = ft->f( ft->xv );
394 ft->xv.get()->data = 0;
395 ft->xv.get()->size = 0;
396 return result;
397 }
398 };
402 class FVrcr : public base_F {
403 public:
408 FVrcr( double volatile& (*const f)(gsl::vector const&) ) : f( f ), xv( static_cast<size_t>(0) ){}
412 function_t function(){ return &fn; }
413 private:
417 double volatile& (*const f)(gsl::vector const&);
421 gsl::vector xv;
429 static double fn( size_t n, double* x, void* params ){
430 FVrcr* ft = reinterpret_cast<FVrcr*>( params );
431 ft->xv.get()->size = n;
432 ft->xv.get()->data = x;
433 double result = ft->f( ft->xv );
434 ft->xv.get()->data = 0;
435 ft->xv.get()->size = 0;
436 return result;
437 }
438 };
442 class FVrCr : public base_F {
443 public:
448 FVrCr( double volatile& (*const f)(gsl::vector const volatile&) ) : f( f ), xv( static_cast<size_t>(0) ){}
452 function_t function(){ return &fn; }
453 private:
457 double volatile& (*const f)(gsl::vector const volatile&);
461 gsl::vector xv;
469 static double fn( size_t n, double* x, void* params ){
470 FVrCr* ft = reinterpret_cast<FVrCr*>( params );
471 ft->xv.get()->size = n;
472 ft->xv.get()->data = x;
473 double result = ft->f( ft->xv );
474 ft->xv.get()->data = 0;
475 ft->xv.get()->size = 0;
476 return result;
477 }
478 };
482 class FCrcr : public base_F {
483 public:
488 FCrcr( double const volatile& (*const f)(gsl::vector const&) ) : f( f ), xv( static_cast<size_t>(0) ){}
492 function_t function(){ return &fn; }
493 private:
497 double const volatile& (*const f)(gsl::vector const&);
501 gsl::vector xv;
509 static double fn( size_t n, double* x, void* params ){
510 FCrcr* ft = reinterpret_cast<FCrcr*>( params );
511 ft->xv.get()->size = n;
512 ft->xv.get()->data = x;
513 double result = ft->f( ft->xv );
514 ft->xv.get()->data = 0;
515 ft->xv.get()->size = 0;
516 return result;
517 }
518 };
522 class FCrCr : public base_F {
523 public:
528 FCrCr( double const volatile& (*const f)(gsl::vector const volatile&) ) : f( f ), xv( static_cast<size_t>(0) ){}
532 function_t function(){ return &fn; }
533 private:
537 double const volatile& (*const f)(gsl::vector const volatile&);
541 gsl::vector xv;
549 static double fn( size_t n, double* x, void* params ){
550 FCrCr* ft = reinterpret_cast<FCrCr*>( params );
551 ft->xv.get()->size = n;
552 ft->xv.get()->data = x;
553 double result = ft->f( ft->xv );
554 ft->xv.get()->data = 0;
555 ft->xv.get()->size = 0;
556 return result;
557 }
558 };
563 template<typename T>
564 class Fuvcru : public base_F {
565 public:
573 Fuvcru( T& c, double (T::*f)(gsl::vector const&) )
574 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
580 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
584 function_t function(){ return &function_s; }
585 private:
589 gsl::vector xv;
599 static double function_s( size_t n, double* x, void* params ){
600 Fuvcru<T>* const cl = reinterpret_cast<Fuvcru<T>*>( params );
601 cl->xv.get()->size = n;
602 cl->xv.get()->data = x;
603 double result = (cl->c.*cl->f)( cl->xv );
604 cl->xv.get()->data = 0;
605 cl->xv.get()->size = 0;
606 return result;
607 }
611 T& c;
615 double (T::*f)(gsl::vector const&);
616 };
621 template<typename T>
622 class FuvCru : public base_F {
623 public:
631 FuvCru( T& c, double (T::*f)(gsl::vector const volatile&) )
632 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
638 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
642 function_t function(){ return &function_s; }
643 private:
647 gsl::vector xv;
657 static double function_s( size_t n, double* x, void* params ){
658 FuvCru<T>* const cl = reinterpret_cast<FuvCru<T>*>( params );
659 cl->xv.get()->size = n;
660 cl->xv.get()->data = x;
661 double result = (cl->c.*cl->f)( cl->xv );
662 cl->xv.get()->data = 0;
663 cl->xv.get()->size = 0;
664 return result;
665 }
669 T& c;
673 double (T::*f)(gsl::vector const volatile&);
674 };
679 template<typename T>
680 class Fcvcru : public base_F {
681 public:
689 Fcvcru( T& c, double const (T::*f)(gsl::vector const&) )
690 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
696 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
700 function_t function(){ return &function_s; }
701 private:
705 gsl::vector xv;
715 static double function_s( size_t n, double* x, void* params ){
716 Fcvcru<T>* const cl = reinterpret_cast<Fcvcru<T>*>( params );
717 cl->xv.get()->size = n;
718 cl->xv.get()->data = x;
719 double result = (cl->c.*cl->f)( cl->xv );
720 cl->xv.get()->data = 0;
721 cl->xv.get()->size = 0;
722 return result;
723 }
727 T& c;
731 double const (T::*f)(gsl::vector const&);
732 };
737 template<typename T>
738 class FcvCru : public base_F {
739 public:
747 FcvCru( T& c, double const (T::*f)(gsl::vector const volatile&) )
748 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
754 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
758 function_t function(){ return &function_s; }
759 private:
763 gsl::vector xv;
773 static double function_s( size_t n, double* x, void* params ){
774 FcvCru<T>* const cl = reinterpret_cast<FcvCru<T>*>( params );
775 cl->xv.get()->size = n;
776 cl->xv.get()->data = x;
777 double result = (cl->c.*cl->f)( cl->xv );
778 cl->xv.get()->data = 0;
779 cl->xv.get()->size = 0;
780 return result;
781 }
785 T& c;
789 double const (T::*f)(gsl::vector const volatile&);
790 };
795 template<typename T>
796 class Furcru : public base_F {
797 public:
805 Furcru( T& c, double& (T::*f)(gsl::vector const&) )
806 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
812 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
816 function_t function(){ return &function_s; }
817 private:
821 gsl::vector xv;
831 static double function_s( size_t n, double* x, void* params ){
832 Furcru<T>* const cl = reinterpret_cast<Furcru<T>*>( params );
833 cl->xv.get()->size = n;
834 cl->xv.get()->data = x;
835 double result = (cl->c.*cl->f)( cl->xv );
836 cl->xv.get()->data = 0;
837 cl->xv.get()->size = 0;
838 return result;
839 }
843 T& c;
847 double& (T::*f)(gsl::vector const&);
848 };
853 template<typename T>
854 class FurCru : public base_F {
855 public:
863 FurCru( T& c, double& (T::*f)(gsl::vector const volatile&) )
864 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
870 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
874 function_t function(){ return &function_s; }
875 private:
879 gsl::vector xv;
889 static double function_s( size_t n, double* x, void* params ){
890 FurCru<T>* const cl = reinterpret_cast<FurCru<T>*>( params );
891 cl->xv.get()->size = n;
892 cl->xv.get()->data = x;
893 double result = (cl->c.*cl->f)( cl->xv );
894 cl->xv.get()->data = 0;
895 cl->xv.get()->size = 0;
896 return result;
897 }
901 T& c;
905 double& (T::*f)(gsl::vector const volatile&);
906 };
911 template<typename T>
912 class Fcrcru : public base_F {
913 public:
921 Fcrcru( T& c, double const& (T::*f)(gsl::vector const&) )
922 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
928 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
932 function_t function(){ return &function_s; }
933 private:
937 gsl::vector xv;
947 static double function_s( size_t n, double* x, void* params ){
948 Fcrcru<T>* const cl = reinterpret_cast<Fcrcru<T>*>( params );
949 cl->xv.get()->size = n;
950 cl->xv.get()->data = x;
951 double result = (cl->c.*cl->f)( cl->xv );
952 cl->xv.get()->data = 0;
953 cl->xv.get()->size = 0;
954 return result;
955 }
959 T& c;
963 double const& (T::*f)(gsl::vector const&);
964 };
969 template<typename T>
970 class FcrCru : public base_F {
971 public:
979 FcrCru( T& c, double const& (T::*f)(gsl::vector const volatile&) )
980 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
986 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
990 function_t function(){ return &function_s; }
991 private:
995 gsl::vector xv;
1005 static double function_s( size_t n, double* x, void* params ){
1006 FcrCru<T>* const cl = reinterpret_cast<FcrCru<T>*>( params );
1007 cl->xv.get()->size = n;
1008 cl->xv.get()->data = x;
1009 double result = (cl->c.*cl->f)( cl->xv );
1010 cl->xv.get()->data = 0;
1011 cl->xv.get()->size = 0;
1012 return result;
1013 }
1017 T& c;
1021 double const& (T::*f)(gsl::vector const volatile&);
1022 };
1027 template<typename T>
1028 class FVrcru : public base_F {
1029 public:
1037 FVrcru( T& c, double volatile& (T::*f)(gsl::vector const&) )
1038 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
1044 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
1048 function_t function(){ return &function_s; }
1049 private:
1053 gsl::vector xv;
1063 static double function_s( size_t n, double* x, void* params ){
1064 FVrcru<T>* const cl = reinterpret_cast<FVrcru<T>*>( params );
1065 cl->xv.get()->size = n;
1066 cl->xv.get()->data = x;
1067 double result = (cl->c.*cl->f)( cl->xv );
1068 cl->xv.get()->data = 0;
1069 cl->xv.get()->size = 0;
1070 return result;
1071 }
1075 T& c;
1079 double volatile& (T::*f)(gsl::vector const&);
1080 };
1085 template<typename T>
1086 class FVrCru : public base_F {
1087 public:
1095 FVrCru( T& c, double volatile& (T::*f)(gsl::vector const volatile&) )
1096 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
1102 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
1106 function_t function(){ return &function_s; }
1107 private:
1111 gsl::vector xv;
1121 static double function_s( size_t n, double* x, void* params ){
1122 FVrCru<T>* const cl = reinterpret_cast<FVrCru<T>*>( params );
1123 cl->xv.get()->size = n;
1124 cl->xv.get()->data = x;
1125 double result = (cl->c.*cl->f)( cl->xv );
1126 cl->xv.get()->data = 0;
1127 cl->xv.get()->size = 0;
1128 return result;
1129 }
1133 T& c;
1137 double volatile& (T::*f)(gsl::vector const volatile&);
1138 };
1143 template<typename T>
1144 class FCrcru : public base_F {
1145 public:
1153 FCrcru( T& c, double const volatile& (T::*f)(gsl::vector const&) )
1154 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
1160 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
1164 function_t function(){ return &function_s; }
1165 private:
1169 gsl::vector xv;
1179 static double function_s( size_t n, double* x, void* params ){
1180 FCrcru<T>* const cl = reinterpret_cast<FCrcru<T>*>( params );
1181 cl->xv.get()->size = n;
1182 cl->xv.get()->data = x;
1183 double result = (cl->c.*cl->f)( cl->xv );
1184 cl->xv.get()->data = 0;
1185 cl->xv.get()->size = 0;
1186 return result;
1187 }
1191 T& c;
1195 double const volatile& (T::*f)(gsl::vector const&);
1196 };
1201 template<typename T>
1202 class FCrCru : public base_F {
1203 public:
1211 FCrCru( T& c, double const volatile& (T::*f)(gsl::vector const volatile&) )
1212 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
1218 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
1222 function_t function(){ return &function_s; }
1223 private:
1227 gsl::vector xv;
1237 static double function_s( size_t n, double* x, void* params ){
1238 FCrCru<T>* const cl = reinterpret_cast<FCrCru<T>*>( params );
1239 cl->xv.get()->size = n;
1240 cl->xv.get()->data = x;
1241 double result = (cl->c.*cl->f)( cl->xv );
1242 cl->xv.get()->data = 0;
1243 cl->xv.get()->size = 0;
1244 return result;
1245 }
1249 T& c;
1253 double const volatile& (T::*f)(gsl::vector const volatile&);
1254 };
1259 template<typename T>
1260 class Fuvcrc : public base_F {
1261 public:
1269 Fuvcrc( T& c, double (T::*f)(gsl::vector const&) const )
1270 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
1276 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
1280 function_t function(){ return &function_s; }
1281 private:
1285 gsl::vector xv;
1295 static double function_s( size_t n, double* x, void* params ){
1296 Fuvcrc<T>* const cl = reinterpret_cast<Fuvcrc<T>*>( params );
1297 cl->xv.get()->size = n;
1298 cl->xv.get()->data = x;
1299 double result = (cl->c.*cl->f)( cl->xv );
1300 cl->xv.get()->data = 0;
1301 cl->xv.get()->size = 0;
1302 return result;
1303 }
1307 T& c;
1311 double (T::*f)(gsl::vector const&) const;
1312 };
1317 template<typename T>
1318 class FuvCrc : public base_F {
1319 public:
1327 FuvCrc( T& c, double (T::*f)(gsl::vector const volatile&) const )
1328 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
1334 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
1338 function_t function(){ return &function_s; }
1339 private:
1343 gsl::vector xv;
1353 static double function_s( size_t n, double* x, void* params ){
1354 FuvCrc<T>* const cl = reinterpret_cast<FuvCrc<T>*>( params );
1355 cl->xv.get()->size = n;
1356 cl->xv.get()->data = x;
1357 double result = (cl->c.*cl->f)( cl->xv );
1358 cl->xv.get()->data = 0;
1359 cl->xv.get()->size = 0;
1360 return result;
1361 }
1365 T& c;
1369 double (T::*f)(gsl::vector const volatile&) const;
1370 };
1375 template<typename T>
1376 class Fcvcrc : public base_F {
1377 public:
1385 Fcvcrc( T& c, double const (T::*f)(gsl::vector const&) const )
1386 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
1392 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
1396 function_t function(){ return &function_s; }
1397 private:
1401 gsl::vector xv;
1411 static double function_s( size_t n, double* x, void* params ){
1412 Fcvcrc<T>* const cl = reinterpret_cast<Fcvcrc<T>*>( params );
1413 cl->xv.get()->size = n;
1414 cl->xv.get()->data = x;
1415 double result = (cl->c.*cl->f)( cl->xv );
1416 cl->xv.get()->data = 0;
1417 cl->xv.get()->size = 0;
1418 return result;
1419 }
1423 T& c;
1427 double const (T::*f)(gsl::vector const&) const;
1428 };
1433 template<typename T>
1434 class FcvCrc : public base_F {
1435 public:
1443 FcvCrc( T& c, double const (T::*f)(gsl::vector const volatile&) const )
1444 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
1450 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
1454 function_t function(){ return &function_s; }
1455 private:
1459 gsl::vector xv;
1469 static double function_s( size_t n, double* x, void* params ){
1470 FcvCrc<T>* const cl = reinterpret_cast<FcvCrc<T>*>( params );
1471 cl->xv.get()->size = n;
1472 cl->xv.get()->data = x;
1473 double result = (cl->c.*cl->f)( cl->xv );
1474 cl->xv.get()->data = 0;
1475 cl->xv.get()->size = 0;
1476 return result;
1477 }
1481 T& c;
1485 double const (T::*f)(gsl::vector const volatile&) const;
1486 };
1491 template<typename T>
1492 class Furcrc : public base_F {
1493 public:
1501 Furcrc( T& c, double& (T::*f)(gsl::vector const&) const )
1502 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
1508 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
1512 function_t function(){ return &function_s; }
1513 private:
1517 gsl::vector xv;
1527 static double function_s( size_t n, double* x, void* params ){
1528 Furcrc<T>* const cl = reinterpret_cast<Furcrc<T>*>( params );
1529 cl->xv.get()->size = n;
1530 cl->xv.get()->data = x;
1531 double result = (cl->c.*cl->f)( cl->xv );
1532 cl->xv.get()->data = 0;
1533 cl->xv.get()->size = 0;
1534 return result;
1535 }
1539 T& c;
1543 double& (T::*f)(gsl::vector const&) const;
1544 };
1549 template<typename T>
1550 class FurCrc : public base_F {
1551 public:
1559 FurCrc( T& c, double& (T::*f)(gsl::vector const volatile&) const )
1560 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
1566 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
1570 function_t function(){ return &function_s; }
1571 private:
1575 gsl::vector xv;
1585 static double function_s( size_t n, double* x, void* params ){
1586 FurCrc<T>* const cl = reinterpret_cast<FurCrc<T>*>( params );
1587 cl->xv.get()->size = n;
1588 cl->xv.get()->data = x;
1589 double result = (cl->c.*cl->f)( cl->xv );
1590 cl->xv.get()->data = 0;
1591 cl->xv.get()->size = 0;
1592 return result;
1593 }
1597 T& c;
1601 double& (T::*f)(gsl::vector const volatile&) const;
1602 };
1607 template<typename T>
1608 class Fcrcrc : public base_F {
1609 public:
1617 Fcrcrc( T& c, double const& (T::*f)(gsl::vector const&) const )
1618 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
1624 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
1628 function_t function(){ return &function_s; }
1629 private:
1633 gsl::vector xv;
1643 static double function_s( size_t n, double* x, void* params ){
1644 Fcrcrc<T>* const cl = reinterpret_cast<Fcrcrc<T>*>( params );
1645 cl->xv.get()->size = n;
1646 cl->xv.get()->data = x;
1647 double result = (cl->c.*cl->f)( cl->xv );
1648 cl->xv.get()->data = 0;
1649 cl->xv.get()->size = 0;
1650 return result;
1651 }
1655 T& c;
1659 double const& (T::*f)(gsl::vector const&) const;
1660 };
1665 template<typename T>
1666 class FcrCrc : public base_F {
1667 public:
1675 FcrCrc( T& c, double const& (T::*f)(gsl::vector const volatile&) const )
1676 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
1682 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
1686 function_t function(){ return &function_s; }
1687 private:
1691 gsl::vector xv;
1701 static double function_s( size_t n, double* x, void* params ){
1702 FcrCrc<T>* const cl = reinterpret_cast<FcrCrc<T>*>( params );
1703 cl->xv.get()->size = n;
1704 cl->xv.get()->data = x;
1705 double result = (cl->c.*cl->f)( cl->xv );
1706 cl->xv.get()->data = 0;
1707 cl->xv.get()->size = 0;
1708 return result;
1709 }
1713 T& c;
1717 double const& (T::*f)(gsl::vector const volatile&) const;
1718 };
1723 template<typename T>
1724 class FVrcrc : public base_F {
1725 public:
1733 FVrcrc( T& c, double volatile& (T::*f)(gsl::vector const&) const )
1734 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
1740 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
1744 function_t function(){ return &function_s; }
1745 private:
1749 gsl::vector xv;
1759 static double function_s( size_t n, double* x, void* params ){
1760 FVrcrc<T>* const cl = reinterpret_cast<FVrcrc<T>*>( params );
1761 cl->xv.get()->size = n;
1762 cl->xv.get()->data = x;
1763 double result = (cl->c.*cl->f)( cl->xv );
1764 cl->xv.get()->data = 0;
1765 cl->xv.get()->size = 0;
1766 return result;
1767 }
1771 T& c;
1775 double volatile& (T::*f)(gsl::vector const&) const;
1776 };
1781 template<typename T>
1782 class FVrCrc : public base_F {
1783 public:
1791 FVrCrc( T& c, double volatile& (T::*f)(gsl::vector const volatile&) const )
1792 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
1798 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
1802 function_t function(){ return &function_s; }
1803 private:
1807 gsl::vector xv;
1817 static double function_s( size_t n, double* x, void* params ){
1818 FVrCrc<T>* const cl = reinterpret_cast<FVrCrc<T>*>( params );
1819 cl->xv.get()->size = n;
1820 cl->xv.get()->data = x;
1821 double result = (cl->c.*cl->f)( cl->xv );
1822 cl->xv.get()->data = 0;
1823 cl->xv.get()->size = 0;
1824 return result;
1825 }
1829 T& c;
1833 double volatile& (T::*f)(gsl::vector const volatile&) const;
1834 };
1839 template<typename T>
1840 class FCrcrc : public base_F {
1841 public:
1849 FCrcrc( T& c, double const volatile& (T::*f)(gsl::vector const&) const )
1850 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
1856 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
1860 function_t function(){ return &function_s; }
1861 private:
1865 gsl::vector xv;
1875 static double function_s( size_t n, double* x, void* params ){
1876 FCrcrc<T>* const cl = reinterpret_cast<FCrcrc<T>*>( params );
1877 cl->xv.get()->size = n;
1878 cl->xv.get()->data = x;
1879 double result = (cl->c.*cl->f)( cl->xv );
1880 cl->xv.get()->data = 0;
1881 cl->xv.get()->size = 0;
1882 return result;
1883 }
1887 T& c;
1891 double const volatile& (T::*f)(gsl::vector const&) const;
1892 };
1897 template<typename T>
1898 class FCrCrc : public base_F {
1899 public:
1907 FCrCrc( T& c, double const volatile& (T::*f)(gsl::vector const volatile&) const )
1908 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
1914 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
1918 function_t function(){ return &function_s; }
1919 private:
1923 gsl::vector xv;
1933 static double function_s( size_t n, double* x, void* params ){
1934 FCrCrc<T>* const cl = reinterpret_cast<FCrCrc<T>*>( params );
1935 cl->xv.get()->size = n;
1936 cl->xv.get()->data = x;
1937 double result = (cl->c.*cl->f)( cl->xv );
1938 cl->xv.get()->data = 0;
1939 cl->xv.get()->size = 0;
1940 return result;
1941 }
1945 T& c;
1949 double const volatile& (T::*f)(gsl::vector const volatile&) const;
1950 };
1955 template<typename T>
1956 class FuvcrV : public base_F {
1957 public:
1965 FuvcrV( T& c, double (T::*f)(gsl::vector const&) volatile )
1966 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
1972 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
1976 function_t function(){ return &function_s; }
1977 private:
1981 gsl::vector xv;
1991 static double function_s( size_t n, double* x, void* params ){
1992 FuvcrV<T>* const cl = reinterpret_cast<FuvcrV<T>*>( params );
1993 cl->xv.get()->size = n;
1994 cl->xv.get()->data = x;
1995 double result = (cl->c.*cl->f)( cl->xv );
1996 cl->xv.get()->data = 0;
1997 cl->xv.get()->size = 0;
1998 return result;
1999 }
2003 T& c;
2007 double (T::*f)(gsl::vector const&) volatile;
2008 };
2013 template<typename T>
2014 class FuvCrV : public base_F {
2015 public:
2023 FuvCrV( T& c, double (T::*f)(gsl::vector const volatile&) volatile )
2024 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
2030 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
2034 function_t function(){ return &function_s; }
2035 private:
2039 gsl::vector xv;
2049 static double function_s( size_t n, double* x, void* params ){
2050 FuvCrV<T>* const cl = reinterpret_cast<FuvCrV<T>*>( params );
2051 cl->xv.get()->size = n;
2052 cl->xv.get()->data = x;
2053 double result = (cl->c.*cl->f)( cl->xv );
2054 cl->xv.get()->data = 0;
2055 cl->xv.get()->size = 0;
2056 return result;
2057 }
2061 T& c;
2065 double (T::*f)(gsl::vector const volatile&) volatile;
2066 };
2071 template<typename T>
2072 class FcvcrV : public base_F {
2073 public:
2081 FcvcrV( T& c, double const (T::*f)(gsl::vector const&) volatile )
2082 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
2088 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
2092 function_t function(){ return &function_s; }
2093 private:
2097 gsl::vector xv;
2107 static double function_s( size_t n, double* x, void* params ){
2108 FcvcrV<T>* const cl = reinterpret_cast<FcvcrV<T>*>( params );
2109 cl->xv.get()->size = n;
2110 cl->xv.get()->data = x;
2111 double result = (cl->c.*cl->f)( cl->xv );
2112 cl->xv.get()->data = 0;
2113 cl->xv.get()->size = 0;
2114 return result;
2115 }
2119 T& c;
2123 double const (T::*f)(gsl::vector const&) volatile;
2124 };
2129 template<typename T>
2130 class FcvCrV : public base_F {
2131 public:
2139 FcvCrV( T& c, double const (T::*f)(gsl::vector const volatile&) volatile )
2140 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
2146 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
2150 function_t function(){ return &function_s; }
2151 private:
2155 gsl::vector xv;
2165 static double function_s( size_t n, double* x, void* params ){
2166 FcvCrV<T>* const cl = reinterpret_cast<FcvCrV<T>*>( params );
2167 cl->xv.get()->size = n;
2168 cl->xv.get()->data = x;
2169 double result = (cl->c.*cl->f)( cl->xv );
2170 cl->xv.get()->data = 0;
2171 cl->xv.get()->size = 0;
2172 return result;
2173 }
2177 T& c;
2181 double const (T::*f)(gsl::vector const volatile&) volatile;
2182 };
2187 template<typename T>
2188 class FurcrV : public base_F {
2189 public:
2197 FurcrV( T& c, double& (T::*f)(gsl::vector const&) volatile )
2198 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
2204 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
2208 function_t function(){ return &function_s; }
2209 private:
2213 gsl::vector xv;
2223 static double function_s( size_t n, double* x, void* params ){
2224 FurcrV<T>* const cl = reinterpret_cast<FurcrV<T>*>( params );
2225 cl->xv.get()->size = n;
2226 cl->xv.get()->data = x;
2227 double result = (cl->c.*cl->f)( cl->xv );
2228 cl->xv.get()->data = 0;
2229 cl->xv.get()->size = 0;
2230 return result;
2231 }
2235 T& c;
2239 double& (T::*f)(gsl::vector const&) volatile;
2240 };
2245 template<typename T>
2246 class FurCrV : public base_F {
2247 public:
2255 FurCrV( T& c, double& (T::*f)(gsl::vector const volatile&) volatile )
2256 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
2262 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
2266 function_t function(){ return &function_s; }
2267 private:
2271 gsl::vector xv;
2281 static double function_s( size_t n, double* x, void* params ){
2282 FurCrV<T>* const cl = reinterpret_cast<FurCrV<T>*>( params );
2283 cl->xv.get()->size = n;
2284 cl->xv.get()->data = x;
2285 double result = (cl->c.*cl->f)( cl->xv );
2286 cl->xv.get()->data = 0;
2287 cl->xv.get()->size = 0;
2288 return result;
2289 }
2293 T& c;
2297 double& (T::*f)(gsl::vector const volatile&) volatile;
2298 };
2303 template<typename T>
2304 class FcrcrV : public base_F {
2305 public:
2313 FcrcrV( T& c, double const& (T::*f)(gsl::vector const&) volatile )
2314 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
2320 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
2324 function_t function(){ return &function_s; }
2325 private:
2329 gsl::vector xv;
2339 static double function_s( size_t n, double* x, void* params ){
2340 FcrcrV<T>* const cl = reinterpret_cast<FcrcrV<T>*>( params );
2341 cl->xv.get()->size = n;
2342 cl->xv.get()->data = x;
2343 double result = (cl->c.*cl->f)( cl->xv );
2344 cl->xv.get()->data = 0;
2345 cl->xv.get()->size = 0;
2346 return result;
2347 }
2351 T& c;
2355 double const& (T::*f)(gsl::vector const&) volatile;
2356 };
2361 template<typename T>
2362 class FcrCrV : public base_F {
2363 public:
2371 FcrCrV( T& c, double const& (T::*f)(gsl::vector const volatile&) volatile )
2372 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
2378 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
2382 function_t function(){ return &function_s; }
2383 private:
2387 gsl::vector xv;
2397 static double function_s( size_t n, double* x, void* params ){
2398 FcrCrV<T>* const cl = reinterpret_cast<FcrCrV<T>*>( params );
2399 cl->xv.get()->size = n;
2400 cl->xv.get()->data = x;
2401 double result = (cl->c.*cl->f)( cl->xv );
2402 cl->xv.get()->data = 0;
2403 cl->xv.get()->size = 0;
2404 return result;
2405 }
2409 T& c;
2413 double const& (T::*f)(gsl::vector const volatile&) volatile;
2414 };
2419 template<typename T>
2420 class FVrcrV : public base_F {
2421 public:
2429 FVrcrV( T& c, double volatile& (T::*f)(gsl::vector const&) volatile )
2430 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
2436 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
2440 function_t function(){ return &function_s; }
2441 private:
2445 gsl::vector xv;
2455 static double function_s( size_t n, double* x, void* params ){
2456 FVrcrV<T>* const cl = reinterpret_cast<FVrcrV<T>*>( params );
2457 cl->xv.get()->size = n;
2458 cl->xv.get()->data = x;
2459 double result = (cl->c.*cl->f)( cl->xv );
2460 cl->xv.get()->data = 0;
2461 cl->xv.get()->size = 0;
2462 return result;
2463 }
2467 T& c;
2471 double volatile& (T::*f)(gsl::vector const&) volatile;
2472 };
2477 template<typename T>
2478 class FVrCrV : public base_F {
2479 public:
2487 FVrCrV( T& c, double volatile& (T::*f)(gsl::vector const volatile&) volatile )
2488 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
2494 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
2498 function_t function(){ return &function_s; }
2499 private:
2503 gsl::vector xv;
2513 static double function_s( size_t n, double* x, void* params ){
2514 FVrCrV<T>* const cl = reinterpret_cast<FVrCrV<T>*>( params );
2515 cl->xv.get()->size = n;
2516 cl->xv.get()->data = x;
2517 double result = (cl->c.*cl->f)( cl->xv );
2518 cl->xv.get()->data = 0;
2519 cl->xv.get()->size = 0;
2520 return result;
2521 }
2525 T& c;
2529 double volatile& (T::*f)(gsl::vector const volatile&) volatile;
2530 };
2535 template<typename T>
2536 class FCrcrV : public base_F {
2537 public:
2545 FCrcrV( T& c, double const volatile& (T::*f)(gsl::vector const&) volatile )
2546 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
2552 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
2556 function_t function(){ return &function_s; }
2557 private:
2561 gsl::vector xv;
2571 static double function_s( size_t n, double* x, void* params ){
2572 FCrcrV<T>* const cl = reinterpret_cast<FCrcrV<T>*>( params );
2573 cl->xv.get()->size = n;
2574 cl->xv.get()->data = x;
2575 double result = (cl->c.*cl->f)( cl->xv );
2576 cl->xv.get()->data = 0;
2577 cl->xv.get()->size = 0;
2578 return result;
2579 }
2583 T& c;
2587 double const volatile& (T::*f)(gsl::vector const&) volatile;
2588 };
2593 template<typename T>
2594 class FCrCrV : public base_F {
2595 public:
2603 FCrCrV( T& c, double const volatile& (T::*f)(gsl::vector const volatile&) volatile )
2604 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
2610 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
2614 function_t function(){ return &function_s; }
2615 private:
2619 gsl::vector xv;
2629 static double function_s( size_t n, double* x, void* params ){
2630 FCrCrV<T>* const cl = reinterpret_cast<FCrCrV<T>*>( params );
2631 cl->xv.get()->size = n;
2632 cl->xv.get()->data = x;
2633 double result = (cl->c.*cl->f)( cl->xv );
2634 cl->xv.get()->data = 0;
2635 cl->xv.get()->size = 0;
2636 return result;
2637 }
2641 T& c;
2645 double const volatile& (T::*f)(gsl::vector const volatile&) volatile;
2646 };
2651 template<typename T>
2652 class FuvcrC : public base_F {
2653 public:
2661 FuvcrC( T& c, double (T::*f)(gsl::vector const&) const volatile )
2662 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
2668 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
2672 function_t function(){ return &function_s; }
2673 private:
2677 gsl::vector xv;
2687 static double function_s( size_t n, double* x, void* params ){
2688 FuvcrC<T>* const cl = reinterpret_cast<FuvcrC<T>*>( params );
2689 cl->xv.get()->size = n;
2690 cl->xv.get()->data = x;
2691 double result = (cl->c.*cl->f)( cl->xv );
2692 cl->xv.get()->data = 0;
2693 cl->xv.get()->size = 0;
2694 return result;
2695 }
2699 T& c;
2703 double (T::*f)(gsl::vector const&) const volatile;
2704 };
2709 template<typename T>
2710 class FuvCrC : public base_F {
2711 public:
2719 FuvCrC( T& c, double (T::*f)(gsl::vector const volatile&) const volatile )
2720 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
2726 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
2730 function_t function(){ return &function_s; }
2731 private:
2735 gsl::vector xv;
2745 static double function_s( size_t n, double* x, void* params ){
2746 FuvCrC<T>* const cl = reinterpret_cast<FuvCrC<T>*>( params );
2747 cl->xv.get()->size = n;
2748 cl->xv.get()->data = x;
2749 double result = (cl->c.*cl->f)( cl->xv );
2750 cl->xv.get()->data = 0;
2751 cl->xv.get()->size = 0;
2752 return result;
2753 }
2757 T& c;
2761 double (T::*f)(gsl::vector const volatile&) const volatile;
2762 };
2767 template<typename T>
2768 class FcvcrC : public base_F {
2769 public:
2777 FcvcrC( T& c, double const (T::*f)(gsl::vector const&) const volatile )
2778 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
2784 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
2788 function_t function(){ return &function_s; }
2789 private:
2793 gsl::vector xv;
2803 static double function_s( size_t n, double* x, void* params ){
2804 FcvcrC<T>* const cl = reinterpret_cast<FcvcrC<T>*>( params );
2805 cl->xv.get()->size = n;
2806 cl->xv.get()->data = x;
2807 double result = (cl->c.*cl->f)( cl->xv );
2808 cl->xv.get()->data = 0;
2809 cl->xv.get()->size = 0;
2810 return result;
2811 }
2815 T& c;
2819 double const (T::*f)(gsl::vector const&) const volatile;
2820 };
2825 template<typename T>
2826 class FcvCrC : public base_F {
2827 public:
2835 FcvCrC( T& c, double const (T::*f)(gsl::vector const volatile&) const volatile )
2836 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
2842 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
2846 function_t function(){ return &function_s; }
2847 private:
2851 gsl::vector xv;
2861 static double function_s( size_t n, double* x, void* params ){
2862 FcvCrC<T>* const cl = reinterpret_cast<FcvCrC<T>*>( params );
2863 cl->xv.get()->size = n;
2864 cl->xv.get()->data = x;
2865 double result = (cl->c.*cl->f)( cl->xv );
2866 cl->xv.get()->data = 0;
2867 cl->xv.get()->size = 0;
2868 return result;
2869 }
2873 T& c;
2877 double const (T::*f)(gsl::vector const volatile&) const volatile;
2878 };
2883 template<typename T>
2884 class FurcrC : public base_F {
2885 public:
2893 FurcrC( T& c, double& (T::*f)(gsl::vector const&) const volatile )
2894 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
2900 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
2904 function_t function(){ return &function_s; }
2905 private:
2909 gsl::vector xv;
2919 static double function_s( size_t n, double* x, void* params ){
2920 FurcrC<T>* const cl = reinterpret_cast<FurcrC<T>*>( params );
2921 cl->xv.get()->size = n;
2922 cl->xv.get()->data = x;
2923 double result = (cl->c.*cl->f)( cl->xv );
2924 cl->xv.get()->data = 0;
2925 cl->xv.get()->size = 0;
2926 return result;
2927 }
2931 T& c;
2935 double& (T::*f)(gsl::vector const&) const volatile;
2936 };
2941 template<typename T>
2942 class FurCrC : public base_F {
2943 public:
2951 FurCrC( T& c, double& (T::*f)(gsl::vector const volatile&) const volatile )
2952 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
2958 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
2962 function_t function(){ return &function_s; }
2963 private:
2967 gsl::vector xv;
2977 static double function_s( size_t n, double* x, void* params ){
2978 FurCrC<T>* const cl = reinterpret_cast<FurCrC<T>*>( params );
2979 cl->xv.get()->size = n;
2980 cl->xv.get()->data = x;
2981 double result = (cl->c.*cl->f)( cl->xv );
2982 cl->xv.get()->data = 0;
2983 cl->xv.get()->size = 0;
2984 return result;
2985 }
2989 T& c;
2993 double& (T::*f)(gsl::vector const volatile&) const volatile;
2994 };
2999 template<typename T>
3000 class FcrcrC : public base_F {
3001 public:
3009 FcrcrC( T& c, double const& (T::*f)(gsl::vector const&) const volatile )
3010 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
3016 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
3020 function_t function(){ return &function_s; }
3021 private:
3025 gsl::vector xv;
3035 static double function_s( size_t n, double* x, void* params ){
3036 FcrcrC<T>* const cl = reinterpret_cast<FcrcrC<T>*>( params );
3037 cl->xv.get()->size = n;
3038 cl->xv.get()->data = x;
3039 double result = (cl->c.*cl->f)( cl->xv );
3040 cl->xv.get()->data = 0;
3041 cl->xv.get()->size = 0;
3042 return result;
3043 }
3047 T& c;
3051 double const& (T::*f)(gsl::vector const&) const volatile;
3052 };
3057 template<typename T>
3058 class FcrCrC : public base_F {
3059 public:
3067 FcrCrC( T& c, double const& (T::*f)(gsl::vector const volatile&) const volatile )
3068 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
3074 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
3078 function_t function(){ return &function_s; }
3079 private:
3083 gsl::vector xv;
3093 static double function_s( size_t n, double* x, void* params ){
3094 FcrCrC<T>* const cl = reinterpret_cast<FcrCrC<T>*>( params );
3095 cl->xv.get()->size = n;
3096 cl->xv.get()->data = x;
3097 double result = (cl->c.*cl->f)( cl->xv );
3098 cl->xv.get()->data = 0;
3099 cl->xv.get()->size = 0;
3100 return result;
3101 }
3105 T& c;
3109 double const& (T::*f)(gsl::vector const volatile&) const volatile;
3110 };
3115 template<typename T>
3116 class FVrcrC : public base_F {
3117 public:
3125 FVrcrC( T& c, double volatile& (T::*f)(gsl::vector const&) const volatile )
3126 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
3132 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
3136 function_t function(){ return &function_s; }
3137 private:
3141 gsl::vector xv;
3151 static double function_s( size_t n, double* x, void* params ){
3152 FVrcrC<T>* const cl = reinterpret_cast<FVrcrC<T>*>( params );
3153 cl->xv.get()->size = n;
3154 cl->xv.get()->data = x;
3155 double result = (cl->c.*cl->f)( cl->xv );
3156 cl->xv.get()->data = 0;
3157 cl->xv.get()->size = 0;
3158 return result;
3159 }
3163 T& c;
3167 double volatile& (T::*f)(gsl::vector const&) const volatile;
3168 };
3173 template<typename T>
3174 class FVrCrC : public base_F {
3175 public:
3183 FVrCrC( T& c, double volatile& (T::*f)(gsl::vector const volatile&) const volatile )
3184 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
3190 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
3194 function_t function(){ return &function_s; }
3195 private:
3199 gsl::vector xv;
3209 static double function_s( size_t n, double* x, void* params ){
3210 FVrCrC<T>* const cl = reinterpret_cast<FVrCrC<T>*>( params );
3211 cl->xv.get()->size = n;
3212 cl->xv.get()->data = x;
3213 double result = (cl->c.*cl->f)( cl->xv );
3214 cl->xv.get()->data = 0;
3215 cl->xv.get()->size = 0;
3216 return result;
3217 }
3221 T& c;
3225 double volatile& (T::*f)(gsl::vector const volatile&) const volatile;
3226 };
3231 template<typename T>
3232 class FCrcrC : public base_F {
3233 public:
3241 FCrcrC( T& c, double const volatile& (T::*f)(gsl::vector const&) const volatile )
3242 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
3248 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
3252 function_t function(){ return &function_s; }
3253 private:
3257 gsl::vector xv;
3267 static double function_s( size_t n, double* x, void* params ){
3268 FCrcrC<T>* const cl = reinterpret_cast<FCrcrC<T>*>( params );
3269 cl->xv.get()->size = n;
3270 cl->xv.get()->data = x;
3271 double result = (cl->c.*cl->f)( cl->xv );
3272 cl->xv.get()->data = 0;
3273 cl->xv.get()->size = 0;
3274 return result;
3275 }
3279 T& c;
3283 double const volatile& (T::*f)(gsl::vector const&) const volatile;
3284 };
3289 template<typename T>
3290 class FCrCrC : public base_F {
3291 public:
3299 FCrCrC( T& c, double const volatile& (T::*f)(gsl::vector const volatile&) const volatile )
3300 : xv( static_cast<size_t>(0) ), c( c ), f( f ){}
3306 double operator()( gsl::vector const& x ){ return (c.*f)( x ); }
3310 function_t function(){ return &function_s; }
3311 private:
3315 gsl::vector xv;
3325 static double function_s( size_t n, double* x, void* params ){
3326 FCrCrC<T>* const cl = reinterpret_cast<FCrCrC<T>*>( params );
3327 cl->xv.get()->size = n;
3328 cl->xv.get()->data = x;
3329 double result = (cl->c.*cl->f)( cl->xv );
3330 cl->xv.get()->data = 0;
3331 cl->xv.get()->size = 0;
3332 return result;
3333 }
3337 T& c;
3341 double const volatile& (T::*f)(gsl::vector const volatile&) const volatile;
3342 };
3343#endif
3344 base_F* base_f;
3348 size_t* count;
3349 public:
3353 function(){
3354 base_f = 0;
3355 gsl_movstat_function::function = 0;
3356 params = 0;
3357 count = 0; // initially nullptr will do
3358 }
3363 explicit function( double (*const f)(gsl::vector const&) ){
3364 base_f = new Fuvcr( f );
3365 params = base_f;
3366 gsl_movstat_function::function = base_f->function();
3367 // just plausibly we could fail to allocate count: no further action needed.
3368 count = new size_t;
3369 *count = 1; // initially there is just one reference to f
3370 }
3371#ifndef DOXYGEN_SKIP
3376 explicit function( double (*const f)(gsl::vector const volatile&) ){
3377 base_f = new FuvCr( f );
3378 params = base_f;
3379 gsl_movstat_function::function = base_f->function();
3380 // just plausibly we could fail to allocate count: no further action needed.
3381 count = new size_t;
3382 *count = 1; // initially there is just one reference to f
3383 }
3388 explicit function( double const (*const f)(gsl::vector const&) ){
3389 base_f = new Fcvcr( f );
3390 params = base_f;
3391 gsl_movstat_function::function = base_f->function();
3392 // just plausibly we could fail to allocate count: no further action needed.
3393 count = new size_t;
3394 *count = 1; // initially there is just one reference to f
3395 }
3400 explicit function( double const (*const f)(gsl::vector const volatile&) ){
3401 base_f = new FcvCr( f );
3402 params = base_f;
3403 gsl_movstat_function::function = base_f->function();
3404 // just plausibly we could fail to allocate count: no further action needed.
3405 count = new size_t;
3406 *count = 1; // initially there is just one reference to f
3407 }
3408#endif
3409#ifndef DOXYGEN_SKIP
3414 explicit function( double& (*const f)(gsl::vector const&) ){
3415 base_f = new Furcr( f );
3416 params = base_f;
3417 gsl_movstat_function::function = base_f->function();
3418 // just plausibly we could fail to allocate count: no further action needed.
3419 count = new size_t;
3420 *count = 1; // initially there is just one reference to f
3421 }
3426 explicit function( double& (*const f)(gsl::vector const volatile&) ){
3427 base_f = new FurCr( f );
3428 params = base_f;
3429 gsl_movstat_function::function = base_f->function();
3430 // just plausibly we could fail to allocate count: no further action needed.
3431 count = new size_t;
3432 *count = 1; // initially there is just one reference to f
3433 }
3434#endif
3435#ifndef DOXYGEN_SKIP
3440 explicit function( double const& (*const f)(gsl::vector const&) ){
3441 base_f = new Fcrcr( f );
3442 params = base_f;
3443 gsl_movstat_function::function = base_f->function();
3444 // just plausibly we could fail to allocate count: no further action needed.
3445 count = new size_t;
3446 *count = 1; // initially there is just one reference to f
3447 }
3452 explicit function( double const& (*const f)(gsl::vector const volatile&) ){
3453 base_f = new FcrCr( f );
3454 params = base_f;
3455 gsl_movstat_function::function = base_f->function();
3456 // just plausibly we could fail to allocate count: no further action needed.
3457 count = new size_t;
3458 *count = 1; // initially there is just one reference to f
3459 }
3460#endif
3461#ifndef DOXYGEN_SKIP
3466 explicit function( double volatile& (*const f)(gsl::vector const&) ){
3467 base_f = new FVrcr( f );
3468 params = base_f;
3469 gsl_movstat_function::function = base_f->function();
3470 // just plausibly we could fail to allocate count: no further action needed.
3471 count = new size_t;
3472 *count = 1; // initially there is just one reference to f
3473 }
3478 explicit function( double volatile& (*const f)(gsl::vector const volatile&) ){
3479 base_f = new FVrCr( f );
3480 params = base_f;
3481 gsl_movstat_function::function = base_f->function();
3482 // just plausibly we could fail to allocate count: no further action needed.
3483 count = new size_t;
3484 *count = 1; // initially there is just one reference to f
3485 }
3486#endif
3487#ifndef DOXYGEN_SKIP
3492 explicit function( double const volatile& (*const f)(gsl::vector const&) ){
3493 base_f = new FCrcr( f );
3494 params = base_f;
3495 gsl_movstat_function::function = base_f->function();
3496 // just plausibly we could fail to allocate count: no further action needed.
3497 count = new size_t;
3498 *count = 1; // initially there is just one reference to f
3499 }
3504 explicit function( double const volatile& (*const f)(gsl::vector const volatile&) ){
3505 base_f = new FCrCr( f );
3506 params = base_f;
3507 gsl_movstat_function::function = base_f->function();
3508 // just plausibly we could fail to allocate count: no further action needed.
3509 count = new size_t;
3510 *count = 1; // initially there is just one reference to f
3511 }
3512#endif
3518 template<typename T> function( T& c, double (T::*f)(gsl::vector const&) ){
3519 base_f = new Fuvcru<T>( c, f );
3520 params = base_f;
3521 gsl_movstat_function::function = base_f->function();
3522 // just plausibly we could fail to allocate count: no further action needed.
3523 count = new size_t;
3524 *count = 1; // initially there is just one reference to f
3525 }
3526#ifndef DOXYGEN_SKIP
3532 template<typename T> function( T& c, double (T::*f)(gsl::vector const volatile&) ){
3533 base_f = new FuvCru<T>( c, f );
3534 params = base_f;
3535 gsl_movstat_function::function = base_f->function();
3536 // just plausibly we could fail to allocate count: no further action needed.
3537 count = new size_t;
3538 *count = 1; // initially there is just one reference to f
3539 }
3545 template<typename T> function( T& c, double const (T::*f)(gsl::vector const&) ){
3546 base_f = new Fcvcru<T>( c, f );
3547 params = base_f;
3548 gsl_movstat_function::function = base_f->function();
3549 // just plausibly we could fail to allocate count: no further action needed.
3550 count = new size_t;
3551 *count = 1; // initially there is just one reference to f
3552 }
3558 template<typename T> function( T& c, double const (T::*f)(gsl::vector const volatile&) ){
3559 base_f = new FcvCru<T>( c, f );
3560 params = base_f;
3561 gsl_movstat_function::function = base_f->function();
3562 // just plausibly we could fail to allocate count: no further action needed.
3563 count = new size_t;
3564 *count = 1; // initially there is just one reference to f
3565 }
3566#endif
3567#ifndef DOXYGEN_SKIP
3573 template<typename T> function( T& c, double& (T::*f)(gsl::vector const&) ){
3574 base_f = new Furcru<T>( c, f );
3575 params = base_f;
3576 gsl_movstat_function::function = base_f->function();
3577 // just plausibly we could fail to allocate count: no further action needed.
3578 count = new size_t;
3579 *count = 1; // initially there is just one reference to f
3580 }
3586 template<typename T> function( T& c, double& (T::*f)(gsl::vector const volatile&) ){
3587 base_f = new FurCru<T>( c, f );
3588 params = base_f;
3589 gsl_movstat_function::function = base_f->function();
3590 // just plausibly we could fail to allocate count: no further action needed.
3591 count = new size_t;
3592 *count = 1; // initially there is just one reference to f
3593 }
3594#endif
3595#ifndef DOXYGEN_SKIP
3601 template<typename T> function( T& c, double const& (T::*f)(gsl::vector const&) ){
3602 base_f = new Fcrcru<T>( c, f );
3603 params = base_f;
3604 gsl_movstat_function::function = base_f->function();
3605 // just plausibly we could fail to allocate count: no further action needed.
3606 count = new size_t;
3607 *count = 1; // initially there is just one reference to f
3608 }
3614 template<typename T> function( T& c, double const& (T::*f)(gsl::vector const volatile&) ){
3615 base_f = new FcrCru<T>( c, f );
3616 params = base_f;
3617 gsl_movstat_function::function = base_f->function();
3618 // just plausibly we could fail to allocate count: no further action needed.
3619 count = new size_t;
3620 *count = 1; // initially there is just one reference to f
3621 }
3622#endif
3623#ifndef DOXYGEN_SKIP
3629 template<typename T> function( T& c, double volatile& (T::*f)(gsl::vector const&) ){
3630 base_f = new FVrcru<T>( c, f );
3631 params = base_f;
3632 gsl_movstat_function::function = base_f->function();
3633 // just plausibly we could fail to allocate count: no further action needed.
3634 count = new size_t;
3635 *count = 1; // initially there is just one reference to f
3636 }
3642 template<typename T> function( T& c, double volatile& (T::*f)(gsl::vector const volatile&) ){
3643 base_f = new FVrCru<T>( c, f );
3644 params = base_f;
3645 gsl_movstat_function::function = base_f->function();
3646 // just plausibly we could fail to allocate count: no further action needed.
3647 count = new size_t;
3648 *count = 1; // initially there is just one reference to f
3649 }
3650#endif
3651#ifndef DOXYGEN_SKIP
3657 template<typename T> function( T& c, double const volatile& (T::*f)(gsl::vector const&) ){
3658 base_f = new FCrcru<T>( c, f );
3659 params = base_f;
3660 gsl_movstat_function::function = base_f->function();
3661 // just plausibly we could fail to allocate count: no further action needed.
3662 count = new size_t;
3663 *count = 1; // initially there is just one reference to f
3664 }
3670 template<typename T> function( T& c, double const volatile& (T::*f)(gsl::vector const volatile&) ){
3671 base_f = new FCrCru<T>( c, f );
3672 params = base_f;
3673 gsl_movstat_function::function = base_f->function();
3674 // just plausibly we could fail to allocate count: no further action needed.
3675 count = new size_t;
3676 *count = 1; // initially there is just one reference to f
3677 }
3678#endif
3679#ifndef DOXYGEN_SKIP
3685 template<typename T> function( T& c, double (T::*f)(gsl::vector const&) const ){
3686 base_f = new Fuvcrc<T>( c, f );
3687 params = base_f;
3688 gsl_movstat_function::function = base_f->function();
3689 // just plausibly we could fail to allocate count: no further action needed.
3690 count = new size_t;
3691 *count = 1; // initially there is just one reference to f
3692 }
3698 template<typename T> function( T& c, double (T::*f)(gsl::vector const volatile&) const ){
3699 base_f = new FuvCrc<T>( c, f );
3700 params = base_f;
3701 gsl_movstat_function::function = base_f->function();
3702 // just plausibly we could fail to allocate count: no further action needed.
3703 count = new size_t;
3704 *count = 1; // initially there is just one reference to f
3705 }
3706#endif
3707#ifndef DOXYGEN_SKIP
3713 template<typename T> function( T& c, double const (T::*f)(gsl::vector const&) const ){
3714 base_f = new Fcvcrc<T>( c, f );
3715 params = base_f;
3716 gsl_movstat_function::function = base_f->function();
3717 // just plausibly we could fail to allocate count: no further action needed.
3718 count = new size_t;
3719 *count = 1; // initially there is just one reference to f
3720 }
3726 template<typename T> function( T& c, double const (T::*f)(gsl::vector const volatile&) const ){
3727 base_f = new FcvCrc<T>( c, f );
3728 params = base_f;
3729 gsl_movstat_function::function = base_f->function();
3730 // just plausibly we could fail to allocate count: no further action needed.
3731 count = new size_t;
3732 *count = 1; // initially there is just one reference to f
3733 }
3734#endif
3735#ifndef DOXYGEN_SKIP
3741 template<typename T> function( T& c, double& (T::*f)(gsl::vector const&) const ){
3742 base_f = new Furcrc<T>( c, f );
3743 params = base_f;
3744 gsl_movstat_function::function = base_f->function();
3745 // just plausibly we could fail to allocate count: no further action needed.
3746 count = new size_t;
3747 *count = 1; // initially there is just one reference to f
3748 }
3754 template<typename T> function( T& c, double& (T::*f)(gsl::vector const volatile&) const ){
3755 base_f = new FurCrc<T>( c, f );
3756 params = base_f;
3757 gsl_movstat_function::function = base_f->function();
3758 // just plausibly we could fail to allocate count: no further action needed.
3759 count = new size_t;
3760 *count = 1; // initially there is just one reference to f
3761 }
3762#endif
3763#ifndef DOXYGEN_SKIP
3769 template<typename T> function( T& c, double const& (T::*f)(gsl::vector const&) const ){
3770 base_f = new Fcrcrc<T>( c, f );
3771 params = base_f;
3772 gsl_movstat_function::function = base_f->function();
3773 // just plausibly we could fail to allocate count: no further action needed.
3774 count = new size_t;
3775 *count = 1; // initially there is just one reference to f
3776 }
3782 template<typename T> function( T& c, double const& (T::*f)(gsl::vector const volatile&) const ){
3783 base_f = new FcrCrc<T>( c, f );
3784 params = base_f;
3785 gsl_movstat_function::function = base_f->function();
3786 // just plausibly we could fail to allocate count: no further action needed.
3787 count = new size_t;
3788 *count = 1; // initially there is just one reference to f
3789 }
3790#endif
3791#ifndef DOXYGEN_SKIP
3797 template<typename T> function( T& c, double volatile& (T::*f)(gsl::vector const&) const ){
3798 base_f = new FVrcrc<T>( c, f );
3799 params = base_f;
3800 gsl_movstat_function::function = base_f->function();
3801 // just plausibly we could fail to allocate count: no further action needed.
3802 count = new size_t;
3803 *count = 1; // initially there is just one reference to f
3804 }
3810 template<typename T> function( T& c, double volatile& (T::*f)(gsl::vector const volatile&) const ){
3811 base_f = new FVrCrc<T>( c, f );
3812 params = base_f;
3813 gsl_movstat_function::function = base_f->function();
3814 // just plausibly we could fail to allocate count: no further action needed.
3815 count = new size_t;
3816 *count = 1; // initially there is just one reference to f
3817 }
3818#endif
3819#ifndef DOXYGEN_SKIP
3825 template<typename T> function( T& c, double const volatile& (T::*f)(gsl::vector const&) const ){
3826 base_f = new FCrcrc<T>( c, f );
3827 params = base_f;
3828 gsl_movstat_function::function = base_f->function();
3829 // just plausibly we could fail to allocate count: no further action needed.
3830 count = new size_t;
3831 *count = 1; // initially there is just one reference to f
3832 }
3838 template<typename T> function( T& c, double const volatile& (T::*f)(gsl::vector const volatile&) const ){
3839 base_f = new FCrCrc<T>( c, f );
3840 params = base_f;
3841 gsl_movstat_function::function = base_f->function();
3842 // just plausibly we could fail to allocate count: no further action needed.
3843 count = new size_t;
3844 *count = 1; // initially there is just one reference to f
3845 }
3846#endif
3847#ifndef DOXYGEN_SKIP
3853 template<typename T> function( T& c, double (T::*f)(gsl::vector const&) volatile ){
3854 base_f = new FuvcrV<T>( c, f );
3855 params = base_f;
3856 gsl_movstat_function::function = base_f->function();
3857 // just plausibly we could fail to allocate count: no further action needed.
3858 count = new size_t;
3859 *count = 1; // initially there is just one reference to f
3860 }
3866 template<typename T> function( T& c, double (T::*f)(gsl::vector const volatile&) volatile ){
3867 base_f = new FuvCrV<T>( c, f );
3868 params = base_f;
3869 gsl_movstat_function::function = base_f->function();
3870 // just plausibly we could fail to allocate count: no further action needed.
3871 count = new size_t;
3872 *count = 1; // initially there is just one reference to f
3873 }
3874#endif
3875#ifndef DOXYGEN_SKIP
3881 template<typename T> function( T& c, double const (T::*f)(gsl::vector const&) volatile ){
3882 base_f = new FcvcrV<T>( c, f );
3883 params = base_f;
3884 gsl_movstat_function::function = base_f->function();
3885 // just plausibly we could fail to allocate count: no further action needed.
3886 count = new size_t;
3887 *count = 1; // initially there is just one reference to f
3888 }
3894 template<typename T> function( T& c, double const (T::*f)(gsl::vector const volatile&) volatile ){
3895 base_f = new FcvCrV<T>( c, f );
3896 params = base_f;
3897 gsl_movstat_function::function = base_f->function();
3898 // just plausibly we could fail to allocate count: no further action needed.
3899 count = new size_t;
3900 *count = 1; // initially there is just one reference to f
3901 }
3902#endif
3903#ifndef DOXYGEN_SKIP
3909 template<typename T> function( T& c, double& (T::*f)(gsl::vector const&) volatile ){
3910 base_f = new FurcrV<T>( c, f );
3911 params = base_f;
3912 gsl_movstat_function::function = base_f->function();
3913 // just plausibly we could fail to allocate count: no further action needed.
3914 count = new size_t;
3915 *count = 1; // initially there is just one reference to f
3916 }
3922 template<typename T> function( T& c, double& (T::*f)(gsl::vector const volatile&) volatile ){
3923 base_f = new FurCrV<T>( c, f );
3924 params = base_f;
3925 gsl_movstat_function::function = base_f->function();
3926 // just plausibly we could fail to allocate count: no further action needed.
3927 count = new size_t;
3928 *count = 1; // initially there is just one reference to f
3929 }
3930#endif
3931#ifndef DOXYGEN_SKIP
3937 template<typename T> function( T& c, double const& (T::*f)(gsl::vector const&) volatile ){
3938 base_f = new FcrcrV<T>( c, f );
3939 params = base_f;
3940 gsl_movstat_function::function = base_f->function();
3941 // just plausibly we could fail to allocate count: no further action needed.
3942 count = new size_t;
3943 *count = 1; // initially there is just one reference to f
3944 }
3950 template<typename T> function( T& c, double const& (T::*f)(gsl::vector const volatile&) volatile ){
3951 base_f = new FcrCrV<T>( c, f );
3952 params = base_f;
3953 gsl_movstat_function::function = base_f->function();
3954 // just plausibly we could fail to allocate count: no further action needed.
3955 count = new size_t;
3956 *count = 1; // initially there is just one reference to f
3957 }
3958#endif
3959#ifndef DOXYGEN_SKIP
3965 template<typename T> function( T& c, double volatile& (T::*f)(gsl::vector const&) volatile ){
3966 base_f = new FVrcrV<T>( c, f );
3967 params = base_f;
3968 gsl_movstat_function::function = base_f->function();
3969 // just plausibly we could fail to allocate count: no further action needed.
3970 count = new size_t;
3971 *count = 1; // initially there is just one reference to f
3972 }
3978 template<typename T> function( T& c, double volatile& (T::*f)(gsl::vector const volatile&) volatile ){
3979 base_f = new FVrCrV<T>( c, f );
3980 params = base_f;
3981 gsl_movstat_function::function = base_f->function();
3982 // just plausibly we could fail to allocate count: no further action needed.
3983 count = new size_t;
3984 *count = 1; // initially there is just one reference to f
3985 }
3986#endif
3987#ifndef DOXYGEN_SKIP
3993 template<typename T> function( T& c, double const volatile& (T::*f)(gsl::vector const&) volatile ){
3994 base_f = new FCrcrV<T>( c, f );
3995 params = base_f;
3996 gsl_movstat_function::function = base_f->function();
3997 // just plausibly we could fail to allocate count: no further action needed.
3998 count = new size_t;
3999 *count = 1; // initially there is just one reference to f
4000 }
4006 template<typename T> function( T& c, double const volatile& (T::*f)(gsl::vector const volatile&) volatile ){
4007 base_f = new FCrCrV<T>( c, f );
4008 params = base_f;
4009 gsl_movstat_function::function = base_f->function();
4010 // just plausibly we could fail to allocate count: no further action needed.
4011 count = new size_t;
4012 *count = 1; // initially there is just one reference to f
4013 }
4014#endif
4015#ifndef DOXYGEN_SKIP
4021 template<typename T> function( T& c, double (T::*f)(gsl::vector const&) const volatile ){
4022 base_f = new FuvcrC<T>( c, f );
4023 params = base_f;
4024 gsl_movstat_function::function = base_f->function();
4025 // just plausibly we could fail to allocate count: no further action needed.
4026 count = new size_t;
4027 *count = 1; // initially there is just one reference to f
4028 }
4034 template<typename T> function( T& c, double (T::*f)(gsl::vector const volatile&) const volatile ){
4035 base_f = new FuvCrC<T>( c, f );
4036 params = base_f;
4037 gsl_movstat_function::function = base_f->function();
4038 // just plausibly we could fail to allocate count: no further action needed.
4039 count = new size_t;
4040 *count = 1; // initially there is just one reference to f
4041 }
4042#endif
4043#ifndef DOXYGEN_SKIP
4049 template<typename T> function( T& c, double const (T::*f)(gsl::vector const&) const volatile ){
4050 base_f = new FcvcrC<T>( c, f );
4051 params = base_f;
4052 gsl_movstat_function::function = base_f->function();
4053 // just plausibly we could fail to allocate count: no further action needed.
4054 count = new size_t;
4055 *count = 1; // initially there is just one reference to f
4056 }
4062 template<typename T> function( T& c, double const (T::*f)(gsl::vector const volatile&) const volatile ){
4063 base_f = new FcvCrC<T>( c, f );
4064 params = base_f;
4065 gsl_movstat_function::function = base_f->function();
4066 // just plausibly we could fail to allocate count: no further action needed.
4067 count = new size_t;
4068 *count = 1; // initially there is just one reference to f
4069 }
4070#endif
4071#ifndef DOXYGEN_SKIP
4077 template<typename T> function( T& c, double& (T::*f)(gsl::vector const&) const volatile ){
4078 base_f = new FurcrC<T>( c, f );
4079 params = base_f;
4080 gsl_movstat_function::function = base_f->function();
4081 // just plausibly we could fail to allocate count: no further action needed.
4082 count = new size_t;
4083 *count = 1; // initially there is just one reference to f
4084 }
4090 template<typename T> function( T& c, double& (T::*f)(gsl::vector const volatile&) const volatile ){
4091 base_f = new FurCrC<T>( c, f );
4092 params = base_f;
4093 gsl_movstat_function::function = base_f->function();
4094 // just plausibly we could fail to allocate count: no further action needed.
4095 count = new size_t;
4096 *count = 1; // initially there is just one reference to f
4097 }
4098#endif
4099#ifndef DOXYGEN_SKIP
4105 template<typename T> function( T& c, double const& (T::*f)(gsl::vector const&) const volatile ){
4106 base_f = new FcrcrC<T>( c, f );
4107 params = base_f;
4108 gsl_movstat_function::function = base_f->function();
4109 // just plausibly we could fail to allocate count: no further action needed.
4110 count = new size_t;
4111 *count = 1; // initially there is just one reference to f
4112 }
4118 template<typename T> function( T& c, double const& (T::*f)(gsl::vector const volatile&) const volatile ){
4119 base_f = new FcrCrC<T>( c, f );
4120 params = base_f;
4121 gsl_movstat_function::function = base_f->function();
4122 // just plausibly we could fail to allocate count: no further action needed.
4123 count = new size_t;
4124 *count = 1; // initially there is just one reference to f
4125 }
4126#endif
4127#ifndef DOXYGEN_SKIP
4133 template<typename T> function( T& c, double volatile& (T::*f)(gsl::vector const&) const volatile ){
4134 base_f = new FVrcrC<T>( c, f );
4135 params = base_f;
4136 gsl_movstat_function::function = base_f->function();
4137 // just plausibly we could fail to allocate count: no further action needed.
4138 count = new size_t;
4139 *count = 1; // initially there is just one reference to f
4140 }
4146 template<typename T> function( T& c, double volatile& (T::*f)(gsl::vector const volatile&) const volatile ){
4147 base_f = new FVrCrC<T>( c, f );
4148 params = base_f;
4149 gsl_movstat_function::function = base_f->function();
4150 // just plausibly we could fail to allocate count: no further action needed.
4151 count = new size_t;
4152 *count = 1; // initially there is just one reference to f
4153 }
4154#endif
4155#ifndef DOXYGEN_SKIP
4161 template<typename T> function( T& c, double const volatile& (T::*f)(gsl::vector const&) const volatile ){
4162 base_f = new FCrcrC<T>( c, f );
4163 params = base_f;
4164 gsl_movstat_function::function = base_f->function();
4165 // just plausibly we could fail to allocate count: no further action needed.
4166 count = new size_t;
4167 *count = 1; // initially there is just one reference to f
4168 }
4174 template<typename T> function( T& c, double const volatile& (T::*f)(gsl::vector const volatile&) const volatile ){
4175 base_f = new FCrCrC<T>( c, f );
4176 params = base_f;
4177 gsl_movstat_function::function = base_f->function();
4178 // just plausibly we could fail to allocate count: no further action needed.
4179 count = new size_t;
4180 *count = 1; // initially there is just one reference to f
4181 }
4182#endif
4183 // Copy and move constructors
4184 // copy constructor
4189 function( function const& v ) : base_f( v.base_f ), count( v.count ){
4190 gsl_movstat_function::function = v.gsl_movstat_function::function;
4191 params = v.params;
4192 if( count != 0 ) ++*count; // function is now shared.
4193 }
4194 // assignment operator
4199 function& operator=( function const& v ){
4200 // first, possibly delete anything pointed to by this
4201 if( count == 0 or --*count == 0 ){
4202 delete base_f;
4203 delete count;
4204 }
4205 // Then copy
4206 base_f = v.base_f;
4207 gsl_movstat_function::function = v.gsl_movstat_function::function;
4208 params = v.params;
4209 count = v.count;
4210 if( count != 0 ) ++*count; // function is now shared.
4211 return *this;
4212 }
4213#ifdef __GXX_EXPERIMENTAL_CXX0X__
4218 function( function&& v ) : base_f( v.base_f ), count( nullptr ){
4219 std::swap( gsl_movstat_function::function, v.gsl_movstat_function::function );
4220 std::swap( params, v.params );
4221 std::swap( count, v.count );
4222 v.base_f = nullptr;
4223 }
4229 function& operator=( function&& v ){
4230 std::swap( base_f, v.base_f );
4231 std::swap( gsl_movstat_function::function, v.gsl_movstat_function::function );
4232 std::swap( params, v.params );
4233 std::swap( count, v.count );
4234 return *this;
4235 }
4236#endif
4240 ~function(){
4241 // first, possibly delete anything pointed to by base_f
4242 if( count == 0 or --*count == 0 ){
4243 delete base_f;
4244 delete count;
4245 }
4246 }
4247 private:
4257 static double fn( size_t n, double* x, void* params ){
4258 base_F* const b = reinterpret_cast<base_F*>( params );
4259 return b->function()( n, x, params );
4260 }
4261 };
4267 template<typename T>
4268 inline function make_function( T& c, double (T::*f)(gsl::vector const&) ){
4269 function fn( c, f );
4270 return fn;
4271 }
4272#ifndef DOXYGEN_SKIP
4278 template<typename T>
4279 inline function make_function( T& c, double (T::*f)(gsl::vector const volatile&) ){
4280 function fn( c, f );
4281 return fn;
4282 }
4288 template<typename T>
4289 inline function make_function( T& c, double const (T::*f)(gsl::vector const&) ){
4290 function fn( c, f );
4291 return fn;
4292 }
4298 template<typename T>
4299 inline function make_function( T& c, double const (T::*f)(gsl::vector const volatile&) ){
4300 function fn( c, f );
4301 return fn;
4302 }
4303#endif
4304#ifndef DOXYGEN_SKIP
4310 template<typename T>
4311 inline function make_function( T& c, double& (T::*f)(gsl::vector const&) ){
4312 function fn( c, f );
4313 return fn;
4314 }
4320 template<typename T>
4321 inline function make_function( T& c, double& (T::*f)(gsl::vector const volatile&) ){
4322 function fn( c, f );
4323 return fn;
4324 }
4325#endif
4326#ifndef DOXYGEN_SKIP
4332 template<typename T>
4333 inline function make_function( T& c, double const& (T::*f)(gsl::vector const&) ){
4334 function fn( c, f );
4335 return fn;
4336 }
4342 template<typename T>
4343 inline function make_function( T& c, double const& (T::*f)(gsl::vector const volatile&) ){
4344 function fn( c, f );
4345 return fn;
4346 }
4347#endif
4348#ifndef DOXYGEN_SKIP
4354 template<typename T>
4355 inline function make_function( T& c, double volatile& (T::*f)(gsl::vector const&) ){
4356 function fn( c, f );
4357 return fn;
4358 }
4364 template<typename T>
4365 inline function make_function( T& c, double volatile& (T::*f)(gsl::vector const volatile&) ){
4366 function fn( c, f );
4367 return fn;
4368 }
4369#endif
4370#ifndef DOXYGEN_SKIP
4376 template<typename T>
4377 inline function make_function( T& c, double const volatile& (T::*f)(gsl::vector const&) ){
4378 function fn( c, f );
4379 return fn;
4380 }
4386 template<typename T>
4387 inline function make_function( T& c, double const volatile& (T::*f)(gsl::vector const volatile&) ){
4388 function fn( c, f );
4389 return fn;
4390 }
4391#endif
4392#ifndef DOXYGEN_SKIP
4398 template<typename T>
4399 inline function make_function( T& c, double (T::*f)(gsl::vector const&) const ){
4400 function fn( c, f );
4401 return fn;
4402 }
4408 template<typename T>
4409 inline function make_function( T& c, double (T::*f)(gsl::vector const volatile&) const ){
4410 function fn( c, f );
4411 return fn;
4412 }
4413#endif
4414#ifndef DOXYGEN_SKIP
4420 template<typename T>
4421 inline function make_function( T& c, double const (T::*f)(gsl::vector const&) const ){
4422 function fn( c, f );
4423 return fn;
4424 }
4430 template<typename T>
4431 inline function make_function( T& c, double const (T::*f)(gsl::vector const volatile&) const ){
4432 function fn( c, f );
4433 return fn;
4434 }
4435#endif
4436#ifndef DOXYGEN_SKIP
4442 template<typename T>
4443 inline function make_function( T& c, double& (T::*f)(gsl::vector const&) const ){
4444 function fn( c, f );
4445 return fn;
4446 }
4452 template<typename T>
4453 inline function make_function( T& c, double& (T::*f)(gsl::vector const volatile&) const ){
4454 function fn( c, f );
4455 return fn;
4456 }
4457#endif
4458#ifndef DOXYGEN_SKIP
4464 template<typename T>
4465 inline function make_function( T& c, double const& (T::*f)(gsl::vector const&) const ){
4466 function fn( c, f );
4467 return fn;
4468 }
4474 template<typename T>
4475 inline function make_function( T& c, double const& (T::*f)(gsl::vector const volatile&) const ){
4476 function fn( c, f );
4477 return fn;
4478 }
4479#endif
4480#ifndef DOXYGEN_SKIP
4486 template<typename T>
4487 inline function make_function( T& c, double volatile& (T::*f)(gsl::vector const&) const ){
4488 function fn( c, f );
4489 return fn;
4490 }
4496 template<typename T>
4497 inline function make_function( T& c, double volatile& (T::*f)(gsl::vector const volatile&) const ){
4498 function fn( c, f );
4499 return fn;
4500 }
4501#endif
4502#ifndef DOXYGEN_SKIP
4508 template<typename T>
4509 inline function make_function( T& c, double const volatile& (T::*f)(gsl::vector const&) const ){
4510 function fn( c, f );
4511 return fn;
4512 }
4518 template<typename T>
4519 inline function make_function( T& c, double const volatile& (T::*f)(gsl::vector const volatile&) const ){
4520 function fn( c, f );
4521 return fn;
4522 }
4523#endif
4524#ifndef DOXYGEN_SKIP
4530 template<typename T>
4531 inline function make_function( T& c, double (T::*f)(gsl::vector const&) volatile ){
4532 function fn( c, f );
4533 return fn;
4534 }
4540 template<typename T>
4541 inline function make_function( T& c, double (T::*f)(gsl::vector const volatile&) volatile ){
4542 function fn( c, f );
4543 return fn;
4544 }
4545#endif
4546#ifndef DOXYGEN_SKIP
4552 template<typename T>
4553 inline function make_function( T& c, double const (T::*f)(gsl::vector const&) volatile ){
4554 function fn( c, f );
4555 return fn;
4556 }
4562 template<typename T>
4563 inline function make_function( T& c, double const (T::*f)(gsl::vector const volatile&) volatile ){
4564 function fn( c, f );
4565 return fn;
4566 }
4567#endif
4568#ifndef DOXYGEN_SKIP
4574 template<typename T>
4575 inline function make_function( T& c, double& (T::*f)(gsl::vector const&) volatile ){
4576 function fn( c, f );
4577 return fn;
4578 }
4584 template<typename T>
4585 inline function make_function( T& c, double& (T::*f)(gsl::vector const volatile&) volatile ){
4586 function fn( c, f );
4587 return fn;
4588 }
4589#endif
4590#ifndef DOXYGEN_SKIP
4596 template<typename T>
4597 inline function make_function( T& c, double const& (T::*f)(gsl::vector const&) volatile ){
4598 function fn( c, f );
4599 return fn;
4600 }
4606 template<typename T>
4607 inline function make_function( T& c, double const& (T::*f)(gsl::vector const volatile&) volatile ){
4608 function fn( c, f );
4609 return fn;
4610 }
4611#endif
4612#ifndef DOXYGEN_SKIP
4618 template<typename T>
4619 inline function make_function( T& c, double volatile& (T::*f)(gsl::vector const&) volatile ){
4620 function fn( c, f );
4621 return fn;
4622 }
4628 template<typename T>
4629 inline function make_function( T& c, double volatile& (T::*f)(gsl::vector const volatile&) volatile ){
4630 function fn( c, f );
4631 return fn;
4632 }
4633#endif
4634#ifndef DOXYGEN_SKIP
4640 template<typename T>
4641 inline function make_function( T& c, double const volatile& (T::*f)(gsl::vector const&) volatile ){
4642 function fn( c, f );
4643 return fn;
4644 }
4650 template<typename T>
4651 inline function make_function( T& c, double const volatile& (T::*f)(gsl::vector const volatile&) volatile ){
4652 function fn( c, f );
4653 return fn;
4654 }
4655#endif
4656#ifndef DOXYGEN_SKIP
4662 template<typename T>
4663 inline function make_function( T& c, double (T::*f)(gsl::vector const&) const volatile ){
4664 function fn( c, f );
4665 return fn;
4666 }
4672 template<typename T>
4673 inline function make_function( T& c, double (T::*f)(gsl::vector const volatile&) const volatile ){
4674 function fn( c, f );
4675 return fn;
4676 }
4677#endif
4678#ifndef DOXYGEN_SKIP
4684 template<typename T>
4685 inline function make_function( T& c, double const (T::*f)(gsl::vector const&) const volatile ){
4686 function fn( c, f );
4687 return fn;
4688 }
4694 template<typename T>
4695 inline function make_function( T& c, double const (T::*f)(gsl::vector const volatile&) const volatile ){
4696 function fn( c, f );
4697 return fn;
4698 }
4699#endif
4700#ifndef DOXYGEN_SKIP
4706 template<typename T>
4707 inline function make_function( T& c, double& (T::*f)(gsl::vector const&) const volatile ){
4708 function fn( c, f );
4709 return fn;
4710 }
4716 template<typename T>
4717 inline function make_function( T& c, double& (T::*f)(gsl::vector const volatile&) const volatile ){
4718 function fn( c, f );
4719 return fn;
4720 }
4721#endif
4722#ifndef DOXYGEN_SKIP
4728 template<typename T>
4729 inline function make_function( T& c, double const& (T::*f)(gsl::vector const&) const volatile ){
4730 function fn( c, f );
4731 return fn;
4732 }
4738 template<typename T>
4739 inline function make_function( T& c, double const& (T::*f)(gsl::vector const volatile&) const volatile ){
4740 function fn( c, f );
4741 return fn;
4742 }
4743#endif
4744#ifndef DOXYGEN_SKIP
4750 template<typename T>
4751 inline function make_function( T& c, double volatile& (T::*f)(gsl::vector const&) const volatile ){
4752 function fn( c, f );
4753 return fn;
4754 }
4760 template<typename T>
4761 inline function make_function( T& c, double volatile& (T::*f)(gsl::vector const volatile&) const volatile ){
4762 function fn( c, f );
4763 return fn;
4764 }
4765#endif
4766#ifndef DOXYGEN_SKIP
4772 template<typename T>
4773 inline function make_function( T& c, double const volatile& (T::*f)(gsl::vector const&) const volatile ){
4774 function fn( c, f );
4775 return fn;
4776 }
4782 template<typename T>
4783 inline function make_function( T& c, double const volatile& (T::*f)(gsl::vector const volatile&) const volatile ){
4784 function fn( c, f );
4785 return fn;
4786 }
4787#endif
4788
4789 }
4790}
4791
4792#endif
gsl::movstat::function
Class that extends gsl_movstat_function so that it can be constructed from arbitrary function objects...
Definition: movstat_function.hpp:58
gsl::movstat::function::function
function(function &&v)
Move constructor.
Definition: movstat_function.hpp:4218
gsl::movstat::function::count
size_t * count
The shared reference count.
Definition: movstat_function.hpp:3348
gsl::movstat::function::~function
~function()
The destructor unshares any shared resource.
Definition: movstat_function.hpp:4240
gsl::movstat::function::function
function()
The default constructor is only really useful for assigning to.
Definition: movstat_function.hpp:3353
gsl::movstat::function::operator=
function & operator=(function &&v)
Move operator.
Definition: movstat_function.hpp:4229
gsl::movstat::function::function
function(double(*const f)(gsl::vector const &))
Construct from a function.
Definition: movstat_function.hpp:3363
gsl::movstat::function::operator=
function & operator=(function const &v)
The assignment operator.
Definition: movstat_function.hpp:4199
gsl::movstat::function::function
function(T &c, double(T::*f)(gsl::vector const &))
Construct from a function object and a suitable member function.
Definition: movstat_function.hpp:3518
gsl::movstat::function::fn
static double fn(size_t n, double *x, void *params)
This is the function that gsl_movstat_function points to if function is constructed from a function o...
Definition: movstat_function.hpp:4257
gsl::movstat::function::function
function(function const &v)
The copy constructor.
Definition: movstat_function.hpp:4189
gsl::vector
This class handles vector objects as shared handles.
Definition: vector.hpp:74
gsl::movstat::make_function
function make_function(T &c, double(T::*f)(gsl::vector const &))
Make a gsl::movstat::function from a function object and a suitable member function.
Definition: movstat_function.hpp:4268
gsl::rstat::n
size_t n(workspace const &w)
C++ version of gsl_rstat_n().
Definition: rstat.hpp:299
gsl::sf::mathieu::b
double b(int order, double qq)
C++ version of gsl_sf_mathieu_b().
Definition: sf_mathieu.hpp:298
gsl::sf::result
gsl_sf_result result
Typedef for gsl_sf_result.
Definition: sf_result.hpp:30
gsl
The gsl package creates an interface to the GNU Scientific Library for C++.
Definition: blas.hpp:34