NAG C Library Function Document
nag_opt_one_var_no_deriv (e04abc)
1 Purpose
nag_opt_one_var_no_deriv (e04abc) searches for a minimum, in a given finite interval, of a continuous function of a single variable, using function values only. The method (based on quadratic interpolation) is intended for functions which have a continuous first derivative (although it will usually work if the derivative has occasional discontinuities).
2 Specification
#include <nag.h>
#include <nage04.h>
|
|
void nag_opt_one_var_no_deriv | (double e1, double e2, double *a, double *b, Integer max_fun, double *x, double *f, Nag_Comm *comm, NagError *fail)
|
3 Description
nag_opt_one_var_no_deriv (e04abc) is applicable to problems of the form:
It normally computes a sequence of
x
values which tend in the limit to a minimum of
F
x
subject to the given bounds. It also progressively reduces the interval
a,b
in which the minimum is known to lie. It uses the safeguarded quadratic-interpolation method described in
Gill and Murray (1973).
The user must supply a function
funct to evaluate
F
x
. The parameters
e1 and
e2 together specify the accuracy
to which the position of the minimum is required. Note that
funct is never called at any point which is closer than
Tol
x
to a previous point.
If the original interval
a,b
contains more than one minimum, nag_opt_one_var_no_deriv (e04abc) will normally find one of the minima.
4 References
Gill P E and Murray W (1973) Safeguarded steplength algorithms for optimization using descent methods NPL Report NAC 37 National Physical Laboratory
5 Arguments
- 1:
funct – function, supplied by the user External Function
-
funct, supplied by the user, must calculate the value of
F
x
at any point
x
in
a,b
.
Its specification is:
|
void funct | (double xc, double *fc, Nag_Comm *comm)
|
- 1:
xc – double Input
-
On entry:
x
, the point at which the value of
F
x
is required.
- 2:
fc – double *Output
-
On exit: the value of the function
F
at the current point
x
.
- 3:
comm – Nag_Comm *
-
Pointer to structure of type
Nag_Comm; the following members are relevant to
funct.
- first – Nag_Boolean Input
-
On entry: will be set to
Nag_True on the first call to
funct and
Nag_False for all subsequent calls.
- nf – Integer Input
-
On entry: the number of calls made to
funct so far.
- user – double *
- iuser – Integer *
- p – Pointer
-
The type Pointer will be
void * with a C compiler that defines
void * and
char * otherwise. Before calling nag_opt_one_var_no_deriv (e04abc) these pointers may be allocated memory by the user and initialized with various quantities for use by
funct when called from nag_opt_one_var_no_deriv (e04abc).
Note: funct should be tested separately before being used in conjunction with nag_opt_one_var_no_deriv (e04abc).
- 2:
e1 – double Input
-
On entry: the relative accuracy to which the position of a minimum is required. (Note that since
e1 is a relative tolerance, the scaling of
x
is automatically taken into account.)
It is recommended that
e1 should be no smaller than
2
ε
, and preferably not much less than
ε
, where
ε
is the
machine precision.
If
e1 is set to a value less than
ε
, its value is ignored and the default value of
ε
is used instead. In particular, the user may set
e1=0.0
to ensure that the default value is used.
- 3:
e2 – double Input
-
On entry: the absolute accuracy to which the position of a minimum is required. It is recommended that
e2 should be no smaller than
2
ε
.
If
e2 is set to a value less than
ε
, its value is ignored and the default value of
ε
is used instead. In particular, the user may set
e2=0.0
to ensure that the default value is used.
- 4:
a – double *Input/Output
-
On entry: the lower bound
a
of the interval containing a minimum.
On exit: an improved lower bound on the position of the minimum.
- 5:
b – double *Input/Output
-
On entry: the upper bound
b
of the interval containing a minimum.
On exit: an improved upper bound on the position of the minimum.
Constraint:
b
>
a
+
e2
..
Note that the value
e2
=
ε
applies here if
e2<ε
on entry to nag_opt_one_var_no_deriv (e04abc).
- 6:
max_fun – Integer Input
-
On entry: the maximum number of function evaluations (calls to
funct) which the user is prepared to allow.
The number of evaluations actually performed by nag_opt_one_var_no_deriv (e04abc) may be determined by supplying a non-NULL parameter
comm (see below) and examining the structure member
nf on exit.
Constraint:
max_fun≥3
..
(Few problems will require more than 30 function evaluations.)
- 7:
x – double *Output
-
On exit: the estimated position of the minimum.
- 8:
f – double *Output
-
On exit: the value of
F
at the final point
x.
- 9:
comm – Nag_Comm *Input/Output
-
On entry/exit: structure containing pointers for communication to user-supplied functions; see the above description of
funct for details. The number of times the function
funct was called is returned in the member
nf.
If the user does not need to make use of this communication feature, the null pointer
NAGCOMM_NULL may be used in the call to nag_opt_one_var_no_deriv (e04abc);
comm will then be declared internally for use in calls to user-supplied functions.
- 10:
fail – NagError *Input/Output
-
The NAG error parameter, see the
Essential Introduction.
6 Error Indicators and Warnings
- NE_2_REAL_ARG_GE
On entry,
a
+
e2
=
value while
b=value
. These parameters must satisfy
a
+
e2
<
b
.
- NE_INT_ARG_LT
On entry,
max_fun must not be less than 3:
max_fun=value
.
- NW_MAX_FUN
The maximum number of function calls,
value, have been performed.
This may have happened simply because
max_fun was set too small for a particular problem, or may be due to a mistake in the user-supplied function,
funct. If no mistake can be found in
funct, restart nag_opt_one_var_no_deriv (e04abc) (preferably with the values of
a and
b given on exit from the previous call to nag_opt_one_var_no_deriv (e04abc)).
7 Accuracy
If
F
x
is
δ
-unimodal for some
δ
<
Tol
x
, where
Tol
x
=
e1
×
x
+
e2
, then, on exit,
x
approximates the minimum of
F
x
in the original interval
a,b
with an error less than
3
×
Tol
x
.
8 Further Comments
Timing depends on the behaviour of
F
x
, the accuracy demanded, and the length of the interval
a,b
. Unless
F
x
can be evaluated very quickly, the run time will usually be dominated by the time spent in
funct.
If
F
x
has more than one minimum in the original interval
a,b
, nag_opt_one_var_no_deriv (e04abc) will determine an approximation
x
(and improved bounds
a
and
b
) for one of the minima.
If nag_opt_one_var_no_deriv (e04abc) finds an
x
such that
F
x
-
δ
1
>
F
x
<
F
x
+
δ
2
for some
δ
1
,
δ
2
≥
Tol
x
, the interval
x
-
δ
1
,
x
+
δ
2
will be regarded as containing a minimum, even if
F
x
is less than
F
x
-
δ
1
and
F
x
+
δ
2
only due to rounding errors in the user-supplied function. Therefore
funct should be programmed to calculate
F
x
as accurately as possible, so that nag_opt_one_var_no_deriv (e04abc) will not be liable to find a spurious minimum.
9 Example
A sketch of the function
shows that it has a minimum somewhere in the range
3.5,5.0
. The example program below shows how nag_opt_one_var_no_deriv (e04abc) can be used to obtain a good approximation to the position of a minimum.
9.1 Program Text
Program Text (e04abce.c)
9.2 Program Data
None.
9.3 Program Results
Program Results (e04abce.r)
© The Numerical Algorithms Group Ltd, Oxford, UK. 2005