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 (19 years, 7 months ago) by tim
File size:	2318 byte(s)
Log Message:	adding qulified name prefix std
#	Content
1	#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