-
-
Notifications
You must be signed in to change notification settings - Fork 27
/
options.jl
131 lines (112 loc) · 3.58 KB
/
options.jl
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
default_rng_mh(seed=1223334444) = Random.default_rng(Int(seed))
#####################################################
#
# STRUCTURES FOR THE OPTIONS
#
#####################################################
mutable struct Options
x_tol::Float64
f_tol::Float64
g_tol::Float64
h_tol::Float64
f_tol_rel::Float64
f_calls_limit::Float64
time_limit::Float64
iterations::Int
store_convergence::Bool
debug::Bool
seed::UInt
parallel_evaluation::Bool
verbose::Bool
rng
end
"""
Options(;
x_tol::Real = 1e-8,
f_tol::Real = 1e-12,
f_tol_rel::Real = eps(),
f_tol_abs::Real = 0.0,
g_tol::Real = 0.0,
h_tol::Real = 0.0,
f_calls_limit::Real = 0,
time_limit::Real = Inf,
iterations::Int = 1,
store_convergence::Bool = false,
debug::Bool = false,
seed = rand(UInt),
parallel_evaluation = false,
verbose = false,
)
`Options` stores common settings for metaheuristics such as the maximum number of iterations
debug options, maximum number of function evaluations, etc.
Main properties:
- `x_tol` tolerance to the true minimizer if specified in `Information`.
- `f_tol` tolerance to the true minimum if specified in `Information`.
- `f_tol_rel` relative tolerance.
- `f_calls_limit` is the maximum number of function evaluations limit.
- `time_limit` is the maximum time that `optimize` can spend in seconds.
- `iterations` is the maximum number of allowed iterations.
- `store_convergence` if `true`, then push the current `State` in `State.convergence` at each generation/iteration
- `debug` if `true`, then `optimize` function reports the current `State` (and interest information) for each iterations.
- `seed` non-negative integer for the random generator seed.
- `parallel_evaluation` enables batch evaluations.
- `verbose` show simplified results each iteration.
- `rng` user-defined Random Number Generator.
# Example
```julia-repl
julia> options = Options(f_calls_limit = 1000, debug=false, seed=1);
julia> f(x) = sum(x.^2)
f (generic function with 1 method)
julia> bounds = [ -10.0 -10 -10; # lower bounds
10.0 10 10 ] # upper bounds
2×3 Array{Float64,2}:
-10.0 -10.0 -10.0
10.0 10.0 10.0
julia> state = optimize(f, bounds, ECA(options=options));
```
"""
function Options(;
x_tol = 1e-8,
f_tol = 1e-12,
g_tol = 0.0,
h_tol = 0.0,
f_tol_rel = eps(),
f_tol_abs = 0.0,
f_calls_limit = 0.0,
g_calls_limit = 0.0,
h_calls_limit = 0.0,
iterations::Int = 0,
time_limit::Float64 = Inf,
store_convergence = false,
show_results = true,
debug = false,
search_type = :minimize,
parallel_evaluation = false,
verbose = false,
seed = rand(UInt32),
rng = default_rng_mh(seed),
)
Options(
promote(x_tol, f_tol, g_tol, h_tol, f_tol_rel)...,
promote(f_calls_limit, time_limit)...,
promote(iterations)...,
# Results options
promote(store_convergence, debug)...,
UInt(seed),
Bool(parallel_evaluation),
Bool(verbose),
rng
)
end
function Base.show(io::IO, options::Options)
_print_title(io, "Options")
txt = String[]
ln = Int[]
for field in fieldnames(Options)
v = getfield(options, field)
fl = string(field) .* ":"
push!(txt, @sprintf(" %-16s %s\n", fl, string(v)))
push!(ln, length(fl))
end
println(io, join(txt[sortperm(ln)]))
end