tests.test_parameters.test_simulated_annealing.test_start_temp_1() - Code Metrics - SimonBlanke/Gradient-Free-Optimizers - Measure and Improve Code Quality continuously with Scrutinizer

test_start_temp_1() A
last analyzed 2025-06-28 09:03 UTC

↳ Parent: tests.test_parameters.test_simulated_annealing

Complexity

Conditions

Size

Total Lines	42
Code Lines	32

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	32
nop	0
dl	0
loc	42
rs	9.112
c	0
b	0
f	0

# Author: Simon Blanke
# Email: [email protected]
# License: MIT License

import pytest
import numpy as np

from gradient_free_optimizers import SimulatedAnnealingOptimizer


def objective_function(para):
    score = -para["x1"] * para["x1"]
    return score


search_space = {
    "x1": np.arange(0, 10, 1),
}


n_iter = 1000


def test_start_temp_0():
    n_initialize = 1

    start_temp_0 = 0
    start_temp_1 = 0.1
    start_temp_10 = 1
    start_temp_100 = 100
    start_temp_inf = np.inf

    epsilon = 1 / np.inf

    opt = SimulatedAnnealingOptimizer(
        search_space,
        start_temp=start_temp_0,
        epsilon=epsilon,
        initialize={"random": n_initialize},
    )
    opt.search(objective_function, n_iter=n_iter)
    n_transitions_0 = opt.n_transitions

    opt = SimulatedAnnealingOptimizer(
        search_space,
        start_temp=start_temp_1,
        epsilon=epsilon,
        initialize={"random": n_initialize},
    )
    opt.search(objective_function, n_iter=n_iter)
    n_transitions_1 = opt.n_transitions

    opt = SimulatedAnnealingOptimizer(
        search_space,
        start_temp=start_temp_10,
        epsilon=epsilon,
        initialize={"random": n_initialize},
    )
    opt.search(objective_function, n_iter=n_iter)
    n_transitions_10 = opt.n_transitions

    opt = SimulatedAnnealingOptimizer(
        search_space,
        start_temp=start_temp_100,
        epsilon=epsilon,
        initialize={"random": n_initialize},
    )
    opt.search(objective_function, n_iter=n_iter)
    n_transitions_100 = opt.n_transitions

    opt = SimulatedAnnealingOptimizer(
        search_space,
        start_temp=start_temp_inf,
        epsilon=epsilon,
        initialize={"random": n_initialize},
    )
    opt.search(objective_function, n_iter=n_iter)
    n_transitions_inf = opt.n_transitions

    print("\n n_transitions_0", n_transitions_0)
    print("\n n_transitions_1", n_transitions_1)
    print("\n n_transitions_10", n_transitions_10)
    print("\n n_transitions_100", n_transitions_100)
    print("\n n_transitions_inf", n_transitions_inf)

    assert n_transitions_0 == start_temp_0
    assert (
        n_transitions_1
        == n_transitions_10
        == n_transitions_100
        == n_transitions_inf
        == n_iter - n_initialize
    )


def test_start_temp_1():
    n_initialize = 1

    start_temp_0 = 0
    start_temp_1 = 0.001
    start_temp_100 = 10000

    epsilon = 0.03

    opt = SimulatedAnnealingOptimizer(
        search_space,
        start_temp=start_temp_0,
        epsilon=epsilon,
        initialize={"random": n_initialize},
    )
    opt.search(objective_function, n_iter=n_iter)
    n_transitions_0 = opt.n_transitions

    opt = SimulatedAnnealingOptimizer(
        search_space,
        start_temp=start_temp_1,
        epsilon=epsilon,
        initialize={"random": n_initialize},
    )
    opt.search(objective_function, n_iter=n_iter)
    n_transitions_1 = opt.n_transitions

    opt = SimulatedAnnealingOptimizer(
        search_space,
        start_temp=start_temp_100,
        epsilon=epsilon,
        initialize={"random": n_initialize},
    )
    opt.search(objective_function, n_iter=n_iter)
    n_transitions_100 = opt.n_transitions

    print("\n n_transitions_0", n_transitions_0)
    print("\n n_transitions_1", n_transitions_1)
    print("\n n_transitions_100", n_transitions_100)

    assert n_transitions_0 == start_temp_0
    assert n_transitions_1 < n_transitions_100


def test_annealing_rate_0():
    n_initialize = 1

    annealing_rate_0 = 0
    annealing_rate_1 = 0.1
    annealing_rate_100 = 0.99

    epsilon = 0.03

    opt = SimulatedAnnealingOptimizer(
        search_space,
        annealing_rate=annealing_rate_0,
        epsilon=epsilon,
        initialize={"random": n_initialize},
    )
    opt.search(objective_function, n_iter=n_iter)
    n_transitions_0 = opt.n_transitions

    opt = SimulatedAnnealingOptimizer(
        search_space,
        annealing_rate=annealing_rate_1,
        epsilon=epsilon,
        initialize={"random": n_initialize},
    )
    opt.search(objective_function, n_iter=n_iter)
    n_transitions_1 = opt.n_transitions

    opt = SimulatedAnnealingOptimizer(
        search_space,
        annealing_rate=annealing_rate_100,
        epsilon=epsilon,
        initialize={"random": n_initialize},
    )
    opt.search(objective_function, n_iter=n_iter)
    n_transitions_100 = opt.n_transitions

    print("\n n_transitions_0", n_transitions_0)
    print("\n n_transitions_1", n_transitions_1)
    print("\n n_transitions_100", n_transitions_100)

    assert n_transitions_0 in [0, 1]
    assert n_transitions_1 < n_transitions_100


1			# Author: Simon Blanke
2			# Email: [email protected]
3			# License: MIT License
4
5			import pytest
6			import numpy as np
7
8			from gradient_free_optimizers import SimulatedAnnealingOptimizer
9
10
11			def objective_function(para):
12			score = -para["x1"] * para["x1"]
13			return score
14
15
16			search_space = {
17			"x1": np.arange(0, 10, 1),
18			}
19
20
21			n_iter = 1000
22
23
24			def test_start_temp_0():
25			n_initialize = 1
26
27			start_temp_0 = 0
28			start_temp_1 = 0.1
29			start_temp_10 = 1
30			start_temp_100 = 100
31			start_temp_inf = np.inf
32
33			epsilon = 1 / np.inf
34
35			opt = SimulatedAnnealingOptimizer(
36			search_space,
37			start_temp=start_temp_0,
38			epsilon=epsilon,
39			initialize={"random": n_initialize},
40			)
41			opt.search(objective_function, n_iter=n_iter)
42			n_transitions_0 = opt.n_transitions
43
44			opt = SimulatedAnnealingOptimizer(
45			search_space,
46			start_temp=start_temp_1,
47			epsilon=epsilon,
48			initialize={"random": n_initialize},
49			)
50			opt.search(objective_function, n_iter=n_iter)
51			n_transitions_1 = opt.n_transitions
52
53			opt = SimulatedAnnealingOptimizer(
54			search_space,
55			start_temp=start_temp_10,
56			epsilon=epsilon,
57			initialize={"random": n_initialize},
58			)
59			opt.search(objective_function, n_iter=n_iter)
60			n_transitions_10 = opt.n_transitions
61
62			opt = SimulatedAnnealingOptimizer(
63			search_space,
64			start_temp=start_temp_100,
65			epsilon=epsilon,
66			initialize={"random": n_initialize},
67			)
68			opt.search(objective_function, n_iter=n_iter)
69			n_transitions_100 = opt.n_transitions
70
71			opt = SimulatedAnnealingOptimizer(
72			search_space,
73			start_temp=start_temp_inf,
74			epsilon=epsilon,
75			initialize={"random": n_initialize},
76			)
77			opt.search(objective_function, n_iter=n_iter)
78			n_transitions_inf = opt.n_transitions
79
80			print("\n n_transitions_0", n_transitions_0)
81			print("\n n_transitions_1", n_transitions_1)
82			print("\n n_transitions_10", n_transitions_10)
83			print("\n n_transitions_100", n_transitions_100)
84			print("\n n_transitions_inf", n_transitions_inf)
85
86			assert n_transitions_0 == start_temp_0
87			assert (
88			n_transitions_1
89			== n_transitions_10
90			== n_transitions_100
91			== n_transitions_inf
92			== n_iter - n_initialize
93			)
94
95
96			def test_start_temp_1():
97			n_initialize = 1
98
99			start_temp_0 = 0
100			start_temp_1 = 0.001
101			start_temp_100 = 10000
102
103			epsilon = 0.03
104
105			opt = SimulatedAnnealingOptimizer(
106			search_space,
107			start_temp=start_temp_0,
108			epsilon=epsilon,
109			initialize={"random": n_initialize},
110			)
111			opt.search(objective_function, n_iter=n_iter)
112			n_transitions_0 = opt.n_transitions
113
114			opt = SimulatedAnnealingOptimizer(
115			search_space,
116			start_temp=start_temp_1,
117			epsilon=epsilon,
118			initialize={"random": n_initialize},
119			)
120			opt.search(objective_function, n_iter=n_iter)
121			n_transitions_1 = opt.n_transitions
122
123			opt = SimulatedAnnealingOptimizer(
124			search_space,
125			start_temp=start_temp_100,
126			epsilon=epsilon,
127			initialize={"random": n_initialize},
128			)
129			opt.search(objective_function, n_iter=n_iter)
130			n_transitions_100 = opt.n_transitions
131
132			print("\n n_transitions_0", n_transitions_0)
133			print("\n n_transitions_1", n_transitions_1)
134			print("\n n_transitions_100", n_transitions_100)
135
136			assert n_transitions_0 == start_temp_0
137			assert n_transitions_1 < n_transitions_100
138
139
140			def test_annealing_rate_0():
141			n_initialize = 1
142
143			annealing_rate_0 = 0
144			annealing_rate_1 = 0.1
145			annealing_rate_100 = 0.99
146
147			epsilon = 0.03
148
149			opt = SimulatedAnnealingOptimizer(
150			search_space,
151			annealing_rate=annealing_rate_0,
152			epsilon=epsilon,
153			initialize={"random": n_initialize},
154			)
155			opt.search(objective_function, n_iter=n_iter)
156			n_transitions_0 = opt.n_transitions
157
158			opt = SimulatedAnnealingOptimizer(
159			search_space,
160			annealing_rate=annealing_rate_1,
161			epsilon=epsilon,
162			initialize={"random": n_initialize},
163			)
164			opt.search(objective_function, n_iter=n_iter)
165			n_transitions_1 = opt.n_transitions
166
167			opt = SimulatedAnnealingOptimizer(
168			search_space,
169			annealing_rate=annealing_rate_100,
170			epsilon=epsilon,
171			initialize={"random": n_initialize},
172			)
173			opt.search(objective_function, n_iter=n_iter)
174			n_transitions_100 = opt.n_transitions
175
176			print("\n n_transitions_0", n_transitions_0)
177			print("\n n_transitions_1", n_transitions_1)
178			print("\n n_transitions_100", n_transitions_100)
179
180			assert n_transitions_0 in [0, 1]
181			assert n_transitions_1 < n_transitions_100
182

SimonBlanke / Gradient-Free-Optimizers

test_start_temp_1() A last analyzed 2025-06-28 09:03 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

test_start_temp_1() A
last analyzed 2025-06-28 09:03 UTC