Go to the documentation of this file.00001
00002
00003
00004 #if !defined (octave_LSODE_options_h)
00005 #define octave_LSODE_options_h 1
00006
00007 #include <cfloat>
00008 #include <cmath>
00009
00010 #include <ODE.h>
00011
00012
00013 class
00014 LSODE_options
00015 {
00016 public:
00017
00018 LSODE_options (void)
00019 : x_absolute_tolerance (),
00020 x_relative_tolerance (),
00021 x_integration_method (),
00022 x_initial_step_size (),
00023 x_maximum_order (),
00024 x_maximum_step_size (),
00025 x_minimum_step_size (),
00026 x_step_limit (),
00027 reset ()
00028 {
00029 init ();
00030 }
00031
00032 LSODE_options (const LSODE_options& opt)
00033 : x_absolute_tolerance (opt.x_absolute_tolerance),
00034 x_relative_tolerance (opt.x_relative_tolerance),
00035 x_integration_method (opt.x_integration_method),
00036 x_initial_step_size (opt.x_initial_step_size),
00037 x_maximum_order (opt.x_maximum_order),
00038 x_maximum_step_size (opt.x_maximum_step_size),
00039 x_minimum_step_size (opt.x_minimum_step_size),
00040 x_step_limit (opt.x_step_limit),
00041 reset (opt.reset)
00042 { }
00043
00044 LSODE_options& operator = (const LSODE_options& opt)
00045 {
00046 if (this != &opt)
00047 {
00048 x_absolute_tolerance = opt.x_absolute_tolerance;
00049 x_relative_tolerance = opt.x_relative_tolerance;
00050 x_integration_method = opt.x_integration_method;
00051 x_initial_step_size = opt.x_initial_step_size;
00052 x_maximum_order = opt.x_maximum_order;
00053 x_maximum_step_size = opt.x_maximum_step_size;
00054 x_minimum_step_size = opt.x_minimum_step_size;
00055 x_step_limit = opt.x_step_limit;
00056 reset = opt.reset;
00057 }
00058
00059 return *this;
00060 }
00061
00062 ~LSODE_options (void) { }
00063
00064 void init (void)
00065 {
00066 x_absolute_tolerance.resize (dim_vector (1, 1));
00067 x_absolute_tolerance(0) = ::sqrt (DBL_EPSILON);
00068 x_relative_tolerance = ::sqrt (DBL_EPSILON);
00069 x_integration_method = "stiff";
00070 x_initial_step_size = -1.0;
00071 x_maximum_order = -1;
00072 x_maximum_step_size = -1.0;
00073 x_minimum_step_size = 0.0;
00074 x_step_limit = 100000;
00075 reset = true;
00076 }
00077
00078 void set_options (const LSODE_options& opt)
00079 {
00080 x_absolute_tolerance = opt.x_absolute_tolerance;
00081 x_relative_tolerance = opt.x_relative_tolerance;
00082 x_integration_method = opt.x_integration_method;
00083 x_initial_step_size = opt.x_initial_step_size;
00084 x_maximum_order = opt.x_maximum_order;
00085 x_maximum_step_size = opt.x_maximum_step_size;
00086 x_minimum_step_size = opt.x_minimum_step_size;
00087 x_step_limit = opt.x_step_limit;
00088 reset = opt.reset;
00089 }
00090
00091 void set_default_options (void) { init (); }
00092
00093 void set_absolute_tolerance (double val)
00094 {
00095 x_absolute_tolerance.resize (dim_vector (1, 1));
00096 x_absolute_tolerance(0) = (val > 0.0) ? val : ::sqrt (DBL_EPSILON);
00097 reset = true;
00098 }
00099
00100 void set_absolute_tolerance (const Array<double>& val)
00101 { x_absolute_tolerance = val; reset = true; }
00102
00103 void set_relative_tolerance (double val)
00104 { x_relative_tolerance = (val > 0.0) ? val : ::sqrt (DBL_EPSILON); reset = true; }
00105
00106 void set_integration_method (const std::string& val)
00107 {
00108 if (val == "stiff" || val == "bdf")
00109 x_integration_method = "stiff";
00110 else if (val == "non-stiff" || val == "adams")
00111 x_integration_method = "non-stiff";
00112 else
00113 (*current_liboctave_error_handler)
00114 ("lsode_options: method must be \"stiff\", \"bdf\", \"non-stiff\", or \"adams\"");
00115 reset = true;
00116 }
00117
00118 void set_initial_step_size (double val)
00119 { x_initial_step_size = (val >= 0.0) ? val : -1.0; reset = true; }
00120
00121 void set_maximum_order (octave_idx_type val)
00122 { x_maximum_order = val; reset = true; }
00123
00124 void set_maximum_step_size (double val)
00125 { x_maximum_step_size = (val >= 0.0) ? val : -1.0; reset = true; }
00126
00127 void set_minimum_step_size (double val)
00128 { x_minimum_step_size = (val >= 0.0) ? val : 0.0; reset = true; }
00129
00130 void set_step_limit (octave_idx_type val)
00131 { x_step_limit = val; reset = true; }
00132 Array<double> absolute_tolerance (void) const
00133 { return x_absolute_tolerance; }
00134
00135 double relative_tolerance (void) const
00136 { return x_relative_tolerance; }
00137
00138 std::string integration_method (void) const
00139 { return x_integration_method; }
00140
00141 double initial_step_size (void) const
00142 { return x_initial_step_size; }
00143
00144 octave_idx_type maximum_order (void) const
00145 { return x_maximum_order; }
00146
00147 double maximum_step_size (void) const
00148 { return x_maximum_step_size; }
00149
00150 double minimum_step_size (void) const
00151 { return x_minimum_step_size; }
00152
00153 octave_idx_type step_limit (void) const
00154 { return x_step_limit; }
00155
00156 private:
00157
00158 Array<double> x_absolute_tolerance;
00159 double x_relative_tolerance;
00160 std::string x_integration_method;
00161 double x_initial_step_size;
00162 octave_idx_type x_maximum_order;
00163 double x_maximum_step_size;
00164 double x_minimum_step_size;
00165 octave_idx_type x_step_limit;
00166
00167 protected:
00168
00169 bool reset;
00170 };
00171
00172 #endif