SusyScan/Limits/solve.h

#ifndef TSOLVE_H
#define TSOLVE_H

#include <string>
#include <exception>


class TSolveException: public std::exception
{
 private:
  std::string except;
 public:
  TSolveException( const std::string& except_ = std::string() ) : except(except_){} 
  virtual const char* what() const throw()  {
    return except.c_str();
  }
  virtual ~TSolveException() throw(){}
};

//Klasse fuer die Extremwertbestimmung
template <class TClass> class TSolve{
 
 public:

  TSolve(TClass* pt2Object, double(TClass::*fpt)(double, const double*), const double*par=0, double l=0., double r=0.):
          _par(par),_left(l),_right(r),epsilon(0.0001)
         { _pt2Object = pt2Object; _function=fpt;};
  
  ~TSolve(){}; //Destructor

  double operator()();

  double GetLeft(){return _left;};
  double GetRight(){return _right;};
  void   SetLeft(double const left){_left=left;};
  void   SetRight(double const right){_right=right;};
  void   SetPar(double const *par){_par=par;};
  void   SetPrecision(double const eps){epsilon=eps;};
  void   BracketFunction(double l, double r);
  
  struct exception {
         std::string except;
         std::string what(){return except;}             
         exception( const std::string& except_ = std::string() )
                        : except(except_){} };
private:
  TClass* _pt2Object;                      // pointer to object

  bool   _isBracketed(double l, double r);
  double _bisection(int n=100);

  double (TClass::*_function)(double, const double*);  
  const double *_par;
  double _left, _right;
  double epsilon;
};


#endif
Revision:	1.1.1.1 (vendor branch)
Committed:	Wed Jan 26 14:37:51 2011 UTC (14 years, 3 months ago) by auterman
Content type:	text/plain
Branch:	Limits, MAIN
CVS Tags:	start, HEAD
Changes since 1.1:	+0 -0 lines
Log Message:	Limt calculation code
#	User	Rev	Content
1	auterman	1.1	#ifndef TSOLVE_H
2			#define TSOLVE_H
3
4			#include <string>
5			#include <exception>
6
7
8			class TSolveException: public std::exception
9			{
10			private:
11			std::string except;
12			public:
13			TSolveException( const std::string& except_ = std::string() ) : except(except_){}
14			virtual const char* what() const throw() {
15			return except.c_str();
16			}
17			virtual ~TSolveException() throw(){}
18			};
19
20			//Klasse fuer die Extremwertbestimmung
21			template <class TClass> class TSolve{
22
23			public:
24
25			TSolve(TClass* pt2Object, double(TClass::fpt)(double, const double), const double*par=0, double l=0., double r=0.):
26			_par(par),_left(l),_right(r),epsilon(0.0001)
27			{ _pt2Object = pt2Object; _function=fpt;};
28
29			~TSolve(){}; //Destructor
30
31			double operator()();
32
33			double GetLeft(){return _left;};
34			double GetRight(){return _right;};
35			void SetLeft(double const left){_left=left;};
36			void SetRight(double const right){_right=right;};
37			void SetPar(double const *par){_par=par;};
38			void SetPrecision(double const eps){epsilon=eps;};
39			void BracketFunction(double l, double r);
40
41			struct exception {
42			std::string except;
43			std::string what(){return except;}
44			exception( const std::string& except_ = std::string() )
45			: except(except_){} };
46			private:
47			TClass* _pt2Object; // pointer to object
48
49			bool _isBracketed(double l, double r);
50			double _bisection(int n=100);
51
52			double (TClass::_function)(double, const double);
53			const double *_par;
54			double _left, _right;
55			double epsilon;
56			};
57
58
59			#endif