Go to the documentation of this file.00001
00002
00003
00004 #if !defined (octave_DASPK_options_h)
00005 #define octave_DASPK_options_h 1
00006
00007 #include <cfloat>
00008 #include <cmath>
00009
00010 #include <DAE.h>
00011
00012
00013 class
00014 DASPK_options
00015 {
00016 public:
00017
00018 DASPK_options (void)
00019 : x_absolute_tolerance (),
00020 x_relative_tolerance (),
00021 x_compute_consistent_initial_condition (),
00022 x_use_initial_condition_heuristics (),
00023 x_initial_condition_heuristics (),
00024 x_print_initial_condition_info (),
00025 x_exclude_algebraic_variables_from_error_test (),
00026 x_algebraic_variables (),
00027 x_enforce_inequality_constraints (),
00028 x_inequality_constraint_types (),
00029 x_initial_step_size (),
00030 x_maximum_order (),
00031 x_maximum_step_size (),
00032 reset ()
00033 {
00034 init ();
00035 }
00036
00037 DASPK_options (const DASPK_options& opt)
00038 : x_absolute_tolerance (opt.x_absolute_tolerance),
00039 x_relative_tolerance (opt.x_relative_tolerance),
00040 x_compute_consistent_initial_condition (opt.x_compute_consistent_initial_condition),
00041 x_use_initial_condition_heuristics (opt.x_use_initial_condition_heuristics),
00042 x_initial_condition_heuristics (opt.x_initial_condition_heuristics),
00043 x_print_initial_condition_info (opt.x_print_initial_condition_info),
00044 x_exclude_algebraic_variables_from_error_test (opt.x_exclude_algebraic_variables_from_error_test),
00045 x_algebraic_variables (opt.x_algebraic_variables),
00046 x_enforce_inequality_constraints (opt.x_enforce_inequality_constraints),
00047 x_inequality_constraint_types (opt.x_inequality_constraint_types),
00048 x_initial_step_size (opt.x_initial_step_size),
00049 x_maximum_order (opt.x_maximum_order),
00050 x_maximum_step_size (opt.x_maximum_step_size),
00051 reset (opt.reset)
00052 { }
00053
00054 DASPK_options& operator = (const DASPK_options& opt)
00055 {
00056 if (this != &opt)
00057 {
00058 x_absolute_tolerance = opt.x_absolute_tolerance;
00059 x_relative_tolerance = opt.x_relative_tolerance;
00060 x_compute_consistent_initial_condition = opt.x_compute_consistent_initial_condition;
00061 x_use_initial_condition_heuristics = opt.x_use_initial_condition_heuristics;
00062 x_initial_condition_heuristics = opt.x_initial_condition_heuristics;
00063 x_print_initial_condition_info = opt.x_print_initial_condition_info;
00064 x_exclude_algebraic_variables_from_error_test = opt.x_exclude_algebraic_variables_from_error_test;
00065 x_algebraic_variables = opt.x_algebraic_variables;
00066 x_enforce_inequality_constraints = opt.x_enforce_inequality_constraints;
00067 x_inequality_constraint_types = opt.x_inequality_constraint_types;
00068 x_initial_step_size = opt.x_initial_step_size;
00069 x_maximum_order = opt.x_maximum_order;
00070 x_maximum_step_size = opt.x_maximum_step_size;
00071 reset = opt.reset;
00072 }
00073
00074 return *this;
00075 }
00076
00077 ~DASPK_options (void) { }
00078
00079 void init (void)
00080 {
00081 x_absolute_tolerance.resize (dim_vector (1, 1));
00082 x_absolute_tolerance(0) = ::sqrt (DBL_EPSILON);
00083 x_relative_tolerance.resize (dim_vector (1, 1));
00084 x_relative_tolerance(0) = ::sqrt (DBL_EPSILON);
00085 x_initial_condition_heuristics.resize (dim_vector (6, 1));
00086 x_initial_condition_heuristics(0) = 5.0;
00087 x_initial_condition_heuristics(1) = 6.0;
00088 x_initial_condition_heuristics(2) = 5.0;
00089 x_initial_condition_heuristics(3) = 0.0;
00090 x_initial_condition_heuristics(4) = ::pow (DBL_EPSILON, 2.0/3.0);
00091 x_initial_condition_heuristics(5) = 0.01;
00092 x_algebraic_variables.resize (dim_vector (1, 1));
00093 x_algebraic_variables(0) = 0;
00094 x_inequality_constraint_types.resize (dim_vector (1, 1));
00095 x_inequality_constraint_types(0) = 0;
00096 x_initial_step_size = -1.0;
00097 x_maximum_order = 5;
00098 x_maximum_step_size = -1.0;
00099 reset = true;
00100 }
00101
00102 void set_options (const DASPK_options& opt)
00103 {
00104 x_absolute_tolerance = opt.x_absolute_tolerance;
00105 x_relative_tolerance = opt.x_relative_tolerance;
00106 x_compute_consistent_initial_condition = opt.x_compute_consistent_initial_condition;
00107 x_use_initial_condition_heuristics = opt.x_use_initial_condition_heuristics;
00108 x_initial_condition_heuristics = opt.x_initial_condition_heuristics;
00109 x_print_initial_condition_info = opt.x_print_initial_condition_info;
00110 x_exclude_algebraic_variables_from_error_test = opt.x_exclude_algebraic_variables_from_error_test;
00111 x_algebraic_variables = opt.x_algebraic_variables;
00112 x_enforce_inequality_constraints = opt.x_enforce_inequality_constraints;
00113 x_inequality_constraint_types = opt.x_inequality_constraint_types;
00114 x_initial_step_size = opt.x_initial_step_size;
00115 x_maximum_order = opt.x_maximum_order;
00116 x_maximum_step_size = opt.x_maximum_step_size;
00117 reset = opt.reset;
00118 }
00119
00120 void set_default_options (void) { init (); }
00121
00122 void set_absolute_tolerance (double val)
00123 {
00124 x_absolute_tolerance.resize (dim_vector (1, 1));
00125 x_absolute_tolerance(0) = (val > 0.0) ? val : ::sqrt (DBL_EPSILON);
00126 reset = true;
00127 }
00128
00129 void set_absolute_tolerance (const Array<double>& val)
00130 { x_absolute_tolerance = val; reset = true; }
00131
00132 void set_relative_tolerance (double val)
00133 {
00134 x_relative_tolerance.resize (dim_vector (1, 1));
00135 x_relative_tolerance(0) = (val > 0.0) ? val : ::sqrt (DBL_EPSILON);
00136 reset = true;
00137 }
00138
00139 void set_relative_tolerance (const Array<double>& val)
00140 { x_relative_tolerance = val; reset = true; }
00141
00142 void set_compute_consistent_initial_condition (octave_idx_type val)
00143 { x_compute_consistent_initial_condition = val; reset = true; }
00144
00145 void set_use_initial_condition_heuristics (octave_idx_type val)
00146 { x_use_initial_condition_heuristics = val; reset = true; }
00147
00148 void set_initial_condition_heuristics (const Array<double>& val)
00149 { x_initial_condition_heuristics = val; reset = true; }
00150
00151 void set_print_initial_condition_info (octave_idx_type val)
00152 { x_print_initial_condition_info = val; reset = true; }
00153
00154 void set_exclude_algebraic_variables_from_error_test (octave_idx_type val)
00155 { x_exclude_algebraic_variables_from_error_test = val; reset = true; }
00156
00157 void set_algebraic_variables (int val)
00158 {
00159 x_algebraic_variables.resize (dim_vector (1, 1));
00160 x_algebraic_variables(0) = val;
00161 reset = true;
00162 }
00163
00164 void set_algebraic_variables (const Array<octave_idx_type>& val)
00165 { x_algebraic_variables = val; reset = true; }
00166
00167 void set_enforce_inequality_constraints (octave_idx_type val)
00168 { x_enforce_inequality_constraints = val; reset = true; }
00169
00170 void set_inequality_constraint_types (octave_idx_type val)
00171 {
00172 x_inequality_constraint_types.resize (dim_vector (1, 1));
00173 x_inequality_constraint_types(0) = val;
00174 reset = true;
00175 }
00176
00177 void set_inequality_constraint_types (const Array<octave_idx_type>& val)
00178 { x_inequality_constraint_types = val; reset = true; }
00179
00180 void set_initial_step_size (double val)
00181 { x_initial_step_size = (val >= 0.0) ? val : -1.0; reset = true; }
00182
00183 void set_maximum_order (octave_idx_type val)
00184 { x_maximum_order = val; reset = true; }
00185
00186 void set_maximum_step_size (double val)
00187 { x_maximum_step_size = (val >= 0.0) ? val : -1.0; reset = true; }
00188 Array<double> absolute_tolerance (void) const
00189 { return x_absolute_tolerance; }
00190
00191 Array<double> relative_tolerance (void) const
00192 { return x_relative_tolerance; }
00193
00194 octave_idx_type compute_consistent_initial_condition (void) const
00195 { return x_compute_consistent_initial_condition; }
00196
00197 octave_idx_type use_initial_condition_heuristics (void) const
00198 { return x_use_initial_condition_heuristics; }
00199
00200 Array<double> initial_condition_heuristics (void) const
00201 { return x_initial_condition_heuristics; }
00202
00203 octave_idx_type print_initial_condition_info (void) const
00204 { return x_print_initial_condition_info; }
00205
00206 octave_idx_type exclude_algebraic_variables_from_error_test (void) const
00207 { return x_exclude_algebraic_variables_from_error_test; }
00208
00209 Array<octave_idx_type> algebraic_variables (void) const
00210 { return x_algebraic_variables; }
00211
00212 octave_idx_type enforce_inequality_constraints (void) const
00213 { return x_enforce_inequality_constraints; }
00214
00215 Array<octave_idx_type> inequality_constraint_types (void) const
00216 { return x_inequality_constraint_types; }
00217
00218 double initial_step_size (void) const
00219 { return x_initial_step_size; }
00220
00221 octave_idx_type maximum_order (void) const
00222 { return x_maximum_order; }
00223
00224 double maximum_step_size (void) const
00225 { return x_maximum_step_size; }
00226
00227 private:
00228
00229 Array<double> x_absolute_tolerance;
00230 Array<double> x_relative_tolerance;
00231 octave_idx_type x_compute_consistent_initial_condition;
00232 octave_idx_type x_use_initial_condition_heuristics;
00233 Array<double> x_initial_condition_heuristics;
00234 octave_idx_type x_print_initial_condition_info;
00235 octave_idx_type x_exclude_algebraic_variables_from_error_test;
00236 Array<octave_idx_type> x_algebraic_variables;
00237 octave_idx_type x_enforce_inequality_constraints;
00238 Array<octave_idx_type> x_inequality_constraint_types;
00239 double x_initial_step_size;
00240 octave_idx_type x_maximum_order;
00241 double x_maximum_step_size;
00242
00243 protected:
00244
00245 bool reset;
00246 };
00247
00248 #endif