File: SylvParams.h

package info (click to toggle)
dynare 4.3.0-2
  • links: PTS, VCS
  • area: main
  • in suites: wheezy
  • size: 40,640 kB
  • sloc: fortran: 82,231; cpp: 72,734; ansic: 28,874; pascal: 13,241; sh: 4,300; objc: 3,281; yacc: 2,833; makefile: 1,288; lex: 1,162; python: 162; lisp: 54; xml: 8
file content (162 lines) | stat: -rw-r--r-- 5,587 bytes parent folder | download | duplicates (4)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
/* $Header: /var/lib/cvs/dynare_cpp/sylv/cc/SylvParams.h,v 1.1.1.1 2004/06/04 13:00:54 kamenik Exp $ */

/* Tag $Name:  $ */

#ifndef SYLV_PARAMS_H
#define SYLV_PARAMS_H

#include <cstdio>
#include <cstring>

#if defined(MATLAB_MEX_FILE) || defined(OCTAVE_MEX_FILE)
# include <dynmex.h>
#endif

typedef enum {def, changed, undef} status;

template <class _Type>
struct ParamItem {
protected:
	typedef ParamItem<_Type> _Self;
	status s;
	_Type value;
public:
	ParamItem()
		{s = undef;}
	ParamItem(_Type val)
		{value = val; s = def;}
	ParamItem(const _Self& item)
		{value = item.value; s = item.s;}
	const _Self& operator=(const _Self& item)
		{value = item.value; s = item.s; return *this;}
	const _Self& operator=(const _Type& val)
		{value = val; s = changed; return *this;}
	_Type operator*() const
		{return value;}
	status getStatus() const
		{return s;}
	void print(FILE* f, const char* prefix, const char* str, const char* fmt) const
		{
			if (s == undef)
				return;
			char out[1000];
			strcpy(out, prefix);
			strcat(out, str);
			strcat(out, "= ");
			strcat(out, fmt);
			if (s == def)
				strcat(out, " <default>");
			strcat(out,"\n");
			fprintf(f, out, value);
		} 
};

class SylvParams {
public:
	typedef enum {iter, recurse} solve_method;

protected:
	class DoubleParamItem : public ParamItem<double> {
	public:
		DoubleParamItem() : ParamItem<double>() {}
		DoubleParamItem(double val) : ParamItem<double>(val) {}
		DoubleParamItem(const DoubleParamItem& item) : ParamItem<double>(item) {}
		const DoubleParamItem& operator=(const double& val)
			{ParamItem<double>::operator=(val); return *this;}
#if defined(MATLAB_MEX_FILE) || defined(OCTAVE_MEX_FILE)
		mxArray* createMatlabArray() const;
#endif
	};

	class IntParamItem : public ParamItem<int> {
	public:
		IntParamItem() : ParamItem<int>() {}
		IntParamItem(int val) : ParamItem<int>(val) {}
		IntParamItem(const IntParamItem& item) : ParamItem<int>(item) {}
		const IntParamItem& operator=(const int& val)
			{ParamItem<int>::operator=(val); return *this;}
#if defined(MATLAB_MEX_FILE) || defined(OCTAVE_MEX_FILE)
		mxArray* createMatlabArray() const;
#endif
	};

	class BoolParamItem : public ParamItem<bool> {
	public:
		BoolParamItem() : ParamItem<bool>() {}
		BoolParamItem(bool val) : ParamItem<bool>(val) {}
		BoolParamItem(const BoolParamItem& item) : ParamItem<bool>(item) {}
		const BoolParamItem& operator=(const bool& val)
			{ParamItem<bool>::operator=(val); return *this;}
#if defined(MATLAB_MEX_FILE) || defined(OCTAVE_MEX_FILE)
		mxArray* createMatlabArray() const;
#endif
	};

	class MethodParamItem : public ParamItem<solve_method> {
	public:
		MethodParamItem() : ParamItem<solve_method>() {}
		MethodParamItem(solve_method val) : ParamItem<solve_method>(val) {}
		MethodParamItem(const MethodParamItem& item) : ParamItem<solve_method>(item) {}
		const MethodParamItem operator=(const solve_method& val)
			{ParamItem<solve_method>::operator=(val); return *this;}
#if defined(MATLAB_MEX_FILE) || defined(OCTAVE_MEX_FILE)
		mxArray* createMatlabArray() const;
#endif
	};

public:
	// input parameters
	MethodParamItem method; // method of solution: iter/recurse
	DoubleParamItem convergence_tol; // norm for what we consider converged
	IntParamItem max_num_iter; // max number of iterations
	DoubleParamItem bs_norm; // Bavely Stewart log10 of norm for diagonalization
	BoolParamItem want_check; // true => allocate extra space for checks
	// output parameters
	BoolParamItem converged; // true if converged
	DoubleParamItem iter_last_norm; // norm of the last iteration
	IntParamItem num_iter; // number of iterations
	DoubleParamItem f_err1; // norm 1 of diagonalization abs. error C-V*F*inv(V)
	DoubleParamItem f_errI; // norm Inf of diagonalization abs. error C-V*F*inv(V)
	DoubleParamItem viv_err1; // norm 1 of error I-V*inv(V)
	DoubleParamItem viv_errI; // norm Inf of error I-V*inv(V)
	DoubleParamItem ivv_err1; // norm 1 of error I-inv(V)*V
	DoubleParamItem ivv_errI; // norm Inf of error I-inv(V)*V
	IntParamItem f_blocks; // number of diagonal blocks of F
	IntParamItem f_largest; // size of largest diagonal block in F
	IntParamItem f_zeros; // number of off diagonal zeros in F
	IntParamItem f_offdiag; // number of all off diagonal elements in F
	DoubleParamItem rcondA1; // reciprocal cond 1 number of A
	DoubleParamItem rcondAI; // reciprocal cond Inf number of A
	DoubleParamItem eig_min; // minimum eigenvalue of the solved system
	DoubleParamItem mat_err1; // rel. matrix 1 norm of A*X-B*X*kron(C,..,C)-D
	DoubleParamItem mat_errI; // rel. matrix Inf norm of A*X-B*X*kron(C,..,C)-D
	DoubleParamItem mat_errF; // rel. matrix Frob. norm of A*X-B*X*kron(C,..,C)-D
	DoubleParamItem vec_err1; // rel. vector 1 norm of A*X-B*X*kron(C,..,C)-D
	DoubleParamItem vec_errI; // rel. vector Inf norm of A*X-B*X*kron(C,..,C)-D
	DoubleParamItem cpu_time; // time of the job in CPU seconds
	// note: remember to change copy() if adding/removing member

	SylvParams(bool wc = false)
		: method(recurse), convergence_tol(1.e-30), max_num_iter(15),
		  bs_norm(1.3), want_check(wc) {}
	SylvParams(const SylvParams& p)
		{copy(p);}
	const SylvParams& operator=(const SylvParams& p)
		{copy(p); return *this;}
	~SylvParams() {}
	void print(const char* prefix) const;
	void print(FILE* fdesc, const char* prefix) const;
	void setArrayNames(int& num, const char** names) const;
#if defined(MATLAB_MEX_FILE) || defined(OCTAVE_MEX_FILE)
	mxArray* createStructArray() const;
#endif
private:
	void copy(const SylvParams& p);
};

#endif /* SYLV_PARAMS_H */


// Local Variables:
// mode:C++
// End: