src/minimizers/MinimizerParameterSet.hpp

#ifndef _MININIZERPARAMETERSET_H_

#define _MININIZERPARAMETERSET_H_


const double DEFAULTTOLERANCE = 1.0e-8;


// base class of minimizer's parameter set

class MinimizerParameterSet{

  public:


    MinimizerParameterSet() {setDefaultParameter();}

    MinimizerParameterSet(MinimizerParameterSet& param) {*this = param;}

    
    void operator= (MinimizerParameterSet& param) {


      maxIteration = param.maxIteration;

      stepSize = param.stepSize;

      stepTol = param.stepTol;

      fTol = param.fTol;

      gTol = param.gTol;


      writeFrq = param.writeFrq;


      lsMaxIteration = param.lsMaxIteration;

      lsTol = param.lsTol;


}

    
    virtual void setDefaultParameter(){

      maxIteration = 200;

      stepSize = 0.01;

      stepTol = DEFAULTTOLERANCE;

      fTol = DEFAULTTOLERANCE;

      gTol = DEFAULTTOLERANCE;


      writeFrq = maxIteration;

      
      lsMaxIteration = 50;

      lsTol = DEFAULTTOLERANCE;

    } 

      
    void setStepTol(double tol) { stepTol = tol;}

    double getStepTol() { return stepTol;}


    void setStepSize(double size) {  stepSize = size;}

    double getStepSize() { return stepSize;}


    void setMaxIteration(int iter) { maxIteration = iter;}

    int getMaxIteration() {return maxIteration;}


    void setFTol(double tol) {fTol = tol;} 

    double getFTol() {return fTol;}


    void setGTol(double tol) {gTol = tol;}

    double getGTol() {return gTol;}


    void setLineSearchTol(double tol) {lsTol = tol;}

    double getLineSearchTol() {return lsTol;}


    void setLineSearchMaxIteration(int iter) {lsMaxIteration = iter;}

    int getLineSearchMaxIteration() {return lsMaxIteration;}


    void setWriteFrq(int frq) {writeFrq = frq;}

    int getWriteFrq() {return writeFrq;}


  protected:    


    int maxIteration;

    double stepTol;

    double fTol;

    double gTol;

    double stepSize;


    int lsMaxIteration;

    double lsTol;


    int writeFrq;

    //int resetFrq;

/*

    // Absolute tolerance

     std::vector<double> absTol;


    // Relative tolerance

     std::vector<double> relTol;


    // Total specified tolerance at convergence 

     std::vector<double> totTol;


    // Tolerance achieved at convergence.

     std::vector<double> achTol;

*/

};


#endif

Revision:	1826
Committed:	Thu Dec 2 05:04:20 2004 UTC (20 years, 11 months ago) by tim
File size:	2318 byte(s)
Log Message:	adding qulified name prefix std
#	User	Rev	Content
1	tim	1826	#ifndef _MININIZERPARAMETERSET_H_
2
3			#define _MININIZERPARAMETERSET_H_
4
5
6
7			const double DEFAULTTOLERANCE = 1.0e-8;
8
9
10
11			// base class of minimizer's parameter set
12
13			class MinimizerParameterSet{
14
15			public:
16
17
18
19			MinimizerParameterSet() {setDefaultParameter();}
20
21			MinimizerParameterSet(MinimizerParameterSet& param) {*this = param;}
22
23
24
25			void operator= (MinimizerParameterSet& param) {
26
27
28
29			maxIteration = param.maxIteration;
30
31			stepSize = param.stepSize;
32
33			stepTol = param.stepTol;
34
35			fTol = param.fTol;
36
37			gTol = param.gTol;
38
39
40
41			writeFrq = param.writeFrq;
42
43
44
45			lsMaxIteration = param.lsMaxIteration;
46
47			lsTol = param.lsTol;
48
49
50
51			}
52
53
54
55			virtual void setDefaultParameter(){
56
57			maxIteration = 200;
58
59			stepSize = 0.01;
60
61			stepTol = DEFAULTTOLERANCE;
62
63			fTol = DEFAULTTOLERANCE;
64
65			gTol = DEFAULTTOLERANCE;
66
67
68
69			writeFrq = maxIteration;
70
71
72
73			lsMaxIteration = 50;
74
75			lsTol = DEFAULTTOLERANCE;
76
77			}
78
79
80
81			void setStepTol(double tol) { stepTol = tol;}
82
83			double getStepTol() { return stepTol;}
84
85
86
87			void setStepSize(double size) { stepSize = size;}
88
89			double getStepSize() { return stepSize;}
90
91
92
93			void setMaxIteration(int iter) { maxIteration = iter;}
94
95			int getMaxIteration() {return maxIteration;}
96
97
98
99			void setFTol(double tol) {fTol = tol;}
100
101			double getFTol() {return fTol;}
102
103
104
105			void setGTol(double tol) {gTol = tol;}
106
107			double getGTol() {return gTol;}
108
109
110
111			void setLineSearchTol(double tol) {lsTol = tol;}
112
113			double getLineSearchTol() {return lsTol;}
114
115
116
117			void setLineSearchMaxIteration(int iter) {lsMaxIteration = iter;}
118
119			int getLineSearchMaxIteration() {return lsMaxIteration;}
120
121
122
123			void setWriteFrq(int frq) {writeFrq = frq;}
124
125			int getWriteFrq() {return writeFrq;}
126
127
128
129			protected:
130
131
132
133			int maxIteration;
134
135			double stepTol;
136
137			double fTol;
138
139			double gTol;
140
141			double stepSize;
142
143
144
145			int lsMaxIteration;
146
147			double lsTol;
148
149
150
151			int writeFrq;
152
153			//int resetFrq;
154
155			/*
156
157			// Absolute tolerance
158
159			std::vector<double> absTol;
160
161
162
163			// Relative tolerance
164
165			std::vector<double> relTol;
166
167
168
169			// Total specified tolerance at convergence
170
171			std::vector<double> totTol;
172
173
174
175			// Tolerance achieved at convergence.
176
177			std::vector<double> achTol;
178
179			*/
180
181			};
182
183
184
185
186
187			#endif
188