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
|
// DO NOT EDIT!
// Generated automatically from DASSL-opts.in.
#if !defined (octave_DASSL_options_h)
#define octave_DASSL_options_h 1
#include <cfloat>
#include <cmath>
#include <DAE.h>
class
DASSL_options
{
public:
DASSL_options (void) { init (); }
DASSL_options (const DASSL_options& opt) { copy (opt); }
DASSL_options& operator = (const DASSL_options& opt)
{
if (this != &opt)
copy (opt);
return *this;
}
~DASSL_options (void) { }
void init (void)
{
x_absolute_tolerance.resize (1);
x_absolute_tolerance(0) = ::sqrt (DBL_EPSILON);
x_relative_tolerance.resize (1);
x_relative_tolerance(0) = ::sqrt (DBL_EPSILON);
x_initial_step_size = -1.0;
x_maximum_order = -1;
x_maximum_step_size = -1.0;
x_step_limit = -1;
reset = true;
}
void copy (const DASSL_options& opt)
{
x_absolute_tolerance = opt.x_absolute_tolerance;
x_relative_tolerance = opt.x_relative_tolerance;
x_compute_consistent_initial_condition = opt.x_compute_consistent_initial_condition;
x_enforce_nonnegativity_constraints = opt.x_enforce_nonnegativity_constraints;
x_initial_step_size = opt.x_initial_step_size;
x_maximum_order = opt.x_maximum_order;
x_maximum_step_size = opt.x_maximum_step_size;
x_step_limit = opt.x_step_limit;
reset = opt.reset;
}
void set_options (const DASSL_options& opt) { copy (opt); }
void set_default_options (void) { init (); }
void set_absolute_tolerance (double val)
{
x_absolute_tolerance.resize (1);
x_absolute_tolerance(0) = (val > 0.0) ? val : ::sqrt (DBL_EPSILON);
reset = true;
}
void set_absolute_tolerance (const Array<double>& val)
{ x_absolute_tolerance = val; reset = true; }
void set_relative_tolerance (double val)
{
x_relative_tolerance.resize (1);
x_relative_tolerance(0) = (val > 0.0) ? val : ::sqrt (DBL_EPSILON);
reset = true;
}
void set_relative_tolerance (const Array<double>& val)
{ x_relative_tolerance = val; reset = true; }
void set_compute_consistent_initial_condition (int val)
{ x_compute_consistent_initial_condition = val; reset = true; }
void set_enforce_nonnegativity_constraints (int val)
{ x_enforce_nonnegativity_constraints = val; reset = true; }
void set_initial_step_size (double val)
{ x_initial_step_size = (val >= 0.0) ? val : -1.0; reset = true; }
void set_maximum_order (int val)
{ x_maximum_order = val; reset = true; }
void set_maximum_step_size (double val)
{ x_maximum_step_size = (val >= 0.0) ? val : -1.0; reset = true; }
void set_step_limit (int val)
{ x_step_limit = (val >= 0) ? val : -1; reset = true; }
Array<double> absolute_tolerance (void) const
{ return x_absolute_tolerance; }
Array<double> relative_tolerance (void) const
{ return x_relative_tolerance; }
int compute_consistent_initial_condition (void) const
{ return x_compute_consistent_initial_condition; }
int enforce_nonnegativity_constraints (void) const
{ return x_enforce_nonnegativity_constraints; }
double initial_step_size (void) const
{ return x_initial_step_size; }
int maximum_order (void) const
{ return x_maximum_order; }
double maximum_step_size (void) const
{ return x_maximum_step_size; }
int step_limit (void) const
{ return x_step_limit; }
private:
Array<double> x_absolute_tolerance;
Array<double> x_relative_tolerance;
int x_compute_consistent_initial_condition;
int x_enforce_nonnegativity_constraints;
double x_initial_step_size;
int x_maximum_order;
double x_maximum_step_size;
int x_step_limit;
protected:
bool reset;
};
#endif
|
