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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
|
########################################################################
##
## Copyright (C) 2002-2025 The Octave Project Developers
##
## See the file COPYRIGHT.md in the top-level directory of this
## distribution or <https://octave.org/copyright/>.
##
## This file is part of Octave.
##
## Octave is free software: you can redistribute it and/or modify it
## under the terms of the GNU General Public License as published by
## the Free Software Foundation, either version 3 of the License, or
## (at your option) any later version.
##
## Octave is distributed in the hope that it will be useful, but
## WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with Octave; see the file COPYING. If not, see
## <https://www.gnu.org/licenses/>.
##
########################################################################
CLASS = "DASSL"
INCLUDE = "DAE.h"
OPTION
NAME = "absolute tolerance"
DOC_ITEM
Absolute tolerance. May be either vector or scalar. If a vector, it
must match the dimension of the state vector, and the relative
tolerance must also be a vector of the same length.
END_DOC_ITEM
TYPE = "Array<double>"
SET_ARG_TYPE = "const $TYPE&"
INIT_BODY
$OPTVAR.resize (dim_vector (1, 1));
$OPTVAR(0) = ::sqrt (std::numeric_limits<double>::epsilon ());
END_INIT_BODY
SET_CODE
void set_$OPT (double val)
{
$OPTVAR.resize (dim_vector (1, 1));
$OPTVAR(0) = (val > 0.0) ? val : ::sqrt (std::numeric_limits<double>::epsilon ());
m_reset = true;
}
void set_$OPT (const $TYPE& val)
{ $OPTVAR = val; m_reset = true; }
END_SET_CODE
END_OPTION
OPTION
NAME = "relative tolerance"
DOC_ITEM
Relative tolerance. May be either vector or scalar. If a vector, it
must match the dimension of the state vector, and the absolute
tolerance must also be a vector of the same length.
The local error test applied at each integration step is
@example
@group
abs (local error in x(i))
<= rtol(i) * abs (Y(i)) + atol(i)
@end group
@end example
END_DOC_ITEM
TYPE = "Array<double>"
SET_ARG_TYPE = "const $TYPE&"
INIT_BODY
$OPTVAR.resize (dim_vector (1, 1));
$OPTVAR(0) = ::sqrt (std::numeric_limits<double>::epsilon ());
END_INIT_BODY
SET_CODE
void set_$OPT (double val)
{
$OPTVAR.resize (dim_vector (1, 1));
$OPTVAR(0) = (val > 0.0) ? val : ::sqrt (std::numeric_limits<double>::epsilon ());
m_reset = true;
}
void set_$OPT (const $TYPE& val)
{ $OPTVAR = val; m_reset = true; }
END_SET_CODE
END_OPTION
OPTION
NAME = "compute consistent initial condition"
DOC_ITEM
If nonzero, @code{dassl} will attempt to compute a consistent set of initial
conditions. This is generally not reliable, so it is best to provide
a consistent set and leave this option set to zero.
END_DOC_ITEM
TYPE = "octave_idx_type"
INIT_VALUE = "0"
SET_EXPR = "val"
END_OPTION
OPTION
NAME = "enforce nonnegativity constraints"
DOC_ITEM
If you know that the solutions to your equations will always be
non-negative, it may help to set this parameter to a nonzero
value. However, it is probably best to try leaving this option set to
zero first, and only setting it to a nonzero value if that doesn't
work very well.
END_DOC_ITEM
TYPE = "octave_idx_type"
INIT_VALUE = "0"
SET_EXPR = "val"
END_OPTION
OPTION
NAME = "initial step size"
DOC_ITEM
Differential-algebraic problems may occasionally suffer from severe
scaling difficulties on the first step. If you know a great deal
about the scaling of your problem, you can help to alleviate this
problem by specifying an initial stepsize.
END_DOC_ITEM
TYPE = "double"
INIT_VALUE = "-1.0"
SET_EXPR = "(val >= 0.0) ? val : -1.0"
END_OPTION
OPTION
NAME = "maximum order"
DOC_ITEM
Restrict the maximum order of the solution method. This option must
be between 1 and 5, inclusive.
END_DOC_ITEM
TYPE = "octave_idx_type"
INIT_VALUE = "-1"
SET_EXPR = "val"
END_OPTION
OPTION
NAME = "maximum step size"
DOC_ITEM
Setting the maximum stepsize will avoid passing over very large
regions (default is not specified).
END_DOC_ITEM
TYPE = "double"
INIT_VALUE = "-1.0"
SET_EXPR = "(val >= 0.0) ? val : -1.0"
END_OPTION
OPTION
NAME = "step limit"
DOC_ITEM
Maximum number of integration steps to attempt on a single call to the
underlying Fortran code.
END_DOC_ITEM
TYPE = "octave_idx_type"
INIT_VALUE = "-1"
SET_EXPR = "(val >= 0) ? val : -1"
END_OPTION
|
