00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012 #ifndef ITL_BASIC_ITERATION_INCLUDE
00013 #define ITL_BASIC_ITERATION_INCLUDE
00014
00015 #include <iostream>
00016 #include <complex>
00017 #include <string>
00018
00019 namespace itl {
00020
00021
00022 template <class Real>
00023 class basic_iteration
00024 {
00025 public:
00026
00027 typedef Real real;
00028
00029 template <class Vector>
00030 basic_iteration(const Vector& b, int max_iter_, Real t, Real a = Real(0))
00031 : error(0), i(0), normb_(std::abs(two_norm(b))),
00032 max_iter(max_iter_), rtol_(t), atol_(a), is_finished(false), my_quite(false) { }
00033
00034 basic_iteration(Real nb, int max_iter_, Real t, Real a = Real(0))
00035 : error(0), i(0), normb_(nb), max_iter(max_iter_), rtol_(t), atol_(a), is_finished(false), my_quite(false) {}
00036
00037 virtual ~basic_iteration() {}
00038
00039 template <class Vector>
00040 bool finished(const Vector& r) {
00041 Real normr_ = two_norm(r);
00042 if (converged(normr_)) {
00043 is_finished= true;
00044 return true;
00045 } else if (i < max_iter)
00046 return false;
00047 else {
00048 is_finished= true;
00049 error = 1;
00050 return true;
00051 }
00052 }
00053
00054
00055 bool finished(const Real& r)
00056 {
00057 if (converged(r)) {
00058 is_finished= true;
00059 return true;
00060 } else if (i < max_iter)
00061 return false;
00062 else {
00063 is_finished= true;
00064 error = 1;
00065 return true;
00066 }
00067 }
00068
00069 template <typename T>
00070 bool finished(const std::complex<T>& r)
00071 {
00072 if (converged(std::abs(r))) {
00073 is_finished= true;
00074 return true;
00075 } else if (i < max_iter)
00076 return false;
00077 else {
00078 is_finished= true;
00079 error = 1;
00080 return true;
00081 }
00082 }
00083
00084 bool finished() { return is_finished; }
00085
00086 inline bool converged(const Real& r)
00087 {
00088 if (normb_ == 0)
00089 return r < atol_;
00090 resid_ = r / normb_;
00091 return (resid_ <= rtol_ || r < atol_);
00092 }
00093
00094 inline void operator++() { ++i; }
00095
00096 inline void operator+=(int n) { i+= n; }
00097
00098 inline bool first() { return i == 0; }
00099
00100 virtual operator int() { return error; }
00101
00102 virtual int error_code() { return error; }
00103
00104 inline int iterations() { return i + 1; }
00105
00106 inline Real resid() { return resid_ * normb_; }
00107
00108 inline Real normb() const { return normb_; }
00109
00110 inline Real tol() { return rtol_; }
00111 inline Real atol() { return atol_; }
00112
00113 inline int fail(int err_code) { error = err_code; return error_code(); }
00114
00115 inline int fail(int err_code, const std::string& msg)
00116 { error = err_code; err_msg = msg; return error_code(); }
00117
00118 inline void set(Real v) { normb_ = v; }
00119
00120 void set_quite(bool q) { my_quite= q; }
00121
00122 bool is_quite() const { return my_quite; }
00123
00124 protected:
00125 int error, i;
00126 const Real normb_;
00127 int max_iter;
00128 Real rtol_, atol_, resid_;
00129 std::string err_msg;
00130 bool is_finished, my_quite;
00131 };
00132
00133
00134 }
00135
00136 #endif // ITL_BASIC_ITERATION_INCLUDE