dynare/dynare++/sylv/cc/SylvParams.h

/* $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: