"""
Reference: https://www-optima.amp.i.kyoto-u.ac.jp/member/student/hedar/Hedar_files/TestGO_files/Page422.htm
"""
import numpy as np
from smt_optim.benchmarks.base import BenchmarkProblem
[docs]
class G01(BenchmarkProblem):
def __init__(self):
super().__init__()
self.name = "G01"
self.num_dim: int = 13
self.num_obj = 1
self.num_cstr = 9
self.num_fidelity = 1
self.bounds = np.array(
[
[0, 1],
[0, 1],
[0, 1],
[0, 1],
[0, 1],
[0, 1],
[0, 1],
[0, 1],
[0, 1],
[0, 100],
[0, 100],
[0, 100],
[0, 1],
]
)
self.tags = [
"GOTestProblems",
]
self.constraints = [
self.g1,
self.g2,
self.g3,
self.g4,
self.g5,
self.g6,
self.g7,
self.g8,
self.g9,
]
# x* = (1,1,...,1,3,3,3,1), f(x*) = -15
[docs]
def objective(self, x):
x1 = x[0:5]
x2 = x[4:14]
return 5 * np.sum(x1) - 5 * np.sum(x1**2) - np.sum(x2)
[docs]
def g1(self, x):
return 2 * x[0] + 2 * x[1] + x[9] + x[10] - 10
[docs]
def g2(self, x):
return 2 * x[0] + 2 * x[2] + x[9] + x[11] - 10
[docs]
def g3(self, x):
return 2 * x[1] + 2 * x[2] + x[10] + x[11] - 10
[docs]
def g4(self, x):
return -8 * x[0] + x[9]
[docs]
def g5(self, x):
return -8 * x[1] + x[10]
[docs]
def g6(self, x):
return -8 * x[2] + x[11]
[docs]
def g7(self, x):
return -2 * x[3] - x[4] + x[9]
[docs]
def g8(self, x):
return -2 * x[5] - x[6] + x[10]
[docs]
def g9(self, x):
return -2 * x[7] - x[8] + x[11]
[docs]
class G02(BenchmarkProblem):
def __init__(self):
super().__init__()
self.name = "G02"
self.num_dim: int | str = 20
self.num_obj = 1
self.num_cstr = 2
self.num_fidelity = 1
self.bounds = np.array(
[
[0, 10],
]
* self.num_dim
)
self.tags = [
"GOTestProblems",
"n_variable",
]
self.constraints = [
self.g1,
self.g2,
]
# n = 20, f(x*) = 0.803619. Have not found this solution yet
# x_star = np.array([3.162460616, 3.128331428, 3.094792129, 3.061451495, 3.027929159,2.993826067,
# 2.958668718, 2.921842273, 0.494825115, 0.488357110,0.482316427, 0.476645751, 0.471295508, 0.466230993,
# 0.461420050,0.456836648, 0.452458769, 0.448267622, 0.444247010, 0.440382860])
[docs]
def objective(self, x):
cos_x = np.cos(x)
sum_jx = np.sum(np.linspace(1, self.num_dim, self.num_dim) * x**2)
return -np.abs((np.sum(cos_x**4) - 2 * np.prod(cos_x**2)) / np.sqrt(sum_jx))
[docs]
def g1(self, x):
return -np.prod(x) + 0.75
[docs]
def g2(self, x):
return np.sum(x) - 7.5 * self.num_dim
[docs]
class G03(BenchmarkProblem):
def __init__(self):
super().__init__()
self.name = "G03"
self.num_dim: int | str = 2
self.num_obj = 1
self.num_cstr = 1
self.num_fidelity = 1
self.cstr_types = ["eq"]
self.bounds = np.array(
[
[0, 1],
]
* self.num_dim
)
self.tags = [
"GOTestProblems",
"n_variable",
]
self.constraints = [
self.h1, # equality constraint
]
# x* = (1/n^0.5, …, 1/n^0.5), f(x*) = 1
[docs]
def objective(self, x):
cst = np.sqrt(self.num_dim) ** self.num_dim
return -cst * np.prod(x)
[docs]
def h1(self, x):
return np.sum(x**2) - 1
[docs]
class G04(BenchmarkProblem):
def __init__(self):
super().__init__()
self.name = "G04"
self.num_dim: int = 5
self.num_obj = 1
self.num_cstr = 6
self.num_fidelity = 1
self.bounds = np.array(
[
[78, 102],
[33, 45],
[27, 45],
[27, 45],
[27, 45],
]
)
self.tags = [
"GOTestProblems",
]
self.constraints = [
self.g1,
self.g2,
self.g3,
self.g4,
self.g5,
self.g6,
]
# x* = (78,33,29.995,45,36.7758), f(x*) = -30665.539
[docs]
def objective(self, x):
return (
5.3578547 * x[2] ** 2
+ 0.8356891 * x[0] * x[4]
+ 37.293239 * x[0]
- 40792.141
)
[docs]
def u(self, x):
return (
85.334407
+ 0.0056858 * x[1] * x[4]
+ 0.0006262 * x[0] * x[3]
- 0.0022053 * x[2] * x[4]
)
[docs]
def v(self, x):
return (
80.51249
+ 0.0071317 * x[1] * x[4]
+ 0.0029955 * x[0] * x[1]
+ 0.0021813 * x[2] ** 2
)
[docs]
def w(self, x):
return (
9.300961
+ 0.0047026 * x[2] * x[4]
+ 0.0012547 * x[0] * x[2]
+ 0.0019085 * x[2] * x[3]
)
[docs]
def g1(self, x):
return -self.u(x)
[docs]
def g2(self, x):
return self.u(x) - 92
[docs]
def g3(self, x):
return -self.v(x) + 90
[docs]
def g4(self, x):
return self.v(x) - 110
[docs]
def g5(self, x):
return -self.w(x) + 20
[docs]
def g6(self, x):
return self.w(x) - 25
[docs]
class G05(BenchmarkProblem):
def __init__(self):
super().__init__()
self.name = "G05"
self.num_dim: int = 4
self.num_obj = 1
self.num_cstr = 5
self.num_fidelity = 1
self.cstr_types = [
"ineq",
"ineq",
"eq",
"eq",
"eq",
]
self.bounds = np.array(
[
[0, 1200],
[0, 1200],
[-0.55, 0.55],
[-0.55, 0.55],
]
)
self.tags = [
"GOTestProblems",
]
self.constraints = [
self.g1,
self.g2,
self.h1,
self.h2,
self.h3,
]
# x* = (679.9453,1026,0.118876,-0.3962336), f(x*) = 5126.4981
[docs]
def objective(self, x):
return 3 * x[0] + 1e-6 * x[0] ** 3 + 2 * x[1] + 2e-6 / 3 * x[1] ** 3
[docs]
def g1(self, x):
return x[2] - x[3] - 0.55
[docs]
def g2(self, x):
return x[3] - x[2] - 0.55
[docs]
def h1(self, x):
return np.abs(
1000 * (np.sin(-x[2] - 0.25) + np.sin(-x[3] - 0.25)) + 894.8 - x[0]
)
[docs]
def h2(self, x):
return np.abs(
1000 * (np.sin(x[2] - 0.25) + np.sin(x[2] - x[3] - 0.25)) + 894.8 - x[1]
)
[docs]
def h3(self, x):
return np.abs(
1000 * (np.sin(x[3] - 0.25) + np.sin(x[3] - x[2] - 0.25)) + 1294.8
)
[docs]
class G06(BenchmarkProblem):
def __init__(self):
super().__init__()
self.name = "G06"
self.num_dim: int = 2
self.num_obj = 1
self.num_cstr = 2
self.num_fidelity = 1
self.bounds = np.array(
[
[13, 100],
[0, 100],
]
)
self.tags = [
"GOTestProblems",
]
self.constraints = [
self.g1,
self.g2,
]
# x* = (14.095,0.84296), f(x*) = -6961.81388
[docs]
def objective(self, x):
return (x[0] - 10) ** 3 + (x[1] - 20) ** 3
[docs]
def g1(self, x):
return -((x[0] - 5) ** 2) - (x[1] - 5) ** 2 + 100
[docs]
def g2(self, x):
return (x[0] - 6) ** 2 + (x[1] - 5) ** 2 - 82.81
[docs]
class G07(BenchmarkProblem):
def __init__(self):
super().__init__()
self.name = "G07"
self.num_dim: int = 10
self.num_obj = 1
self.num_cstr = 8
self.num_fidelity = 1
self.bounds = np.array(
[
[-10, 10],
]
* self.num_dim
)
self.tags = [
"GOTestProblems",
]
self.constraints = [
self.g1,
self.g2,
self.g3,
self.g4,
self.g5,
self.g6,
self.g7,
self.g8,
]
# x*=(2.171996, 2.363683, 8.773926, 5.095984, 0.9906548, 1.430574,1.321644, 9.828726, 8.280092, 8.375927),
# f(x*) = 24.3062091
[docs]
def objective(self, x):
return (
x[0] ** 2
+ x[1] ** 2
+ x[0] * x[1]
- 14 * x[0]
- 16 * x[1]
+ (x[2] - 10) ** 2
+ 4 * (x[3] - 5) ** 2
+ (x[4] - 3) ** 2
+ 2 * (x[5] - 1) ** 2
+ 5 * x[6] ** 2
+ 7 * (x[7] - 11) ** 2
+ 2 * (x[8] - 10) ** 2
+ (x[9] - 7) ** 2
+ 45
)
[docs]
def g1(self, x):
return 4 * x[0] + 5 * x[1] - 3 * x[6] + 9 * x[7] - 105
[docs]
def g2(self, x):
return 10 * x[0] - 8 * x[1] - 17 * x[6] + 2 * x[7]
[docs]
def g3(self, x):
return -8 * x[0] + 2 * x[1] + 5 * x[8] - 2 * x[9] - 12
[docs]
def g4(self, x):
return (
3 * (x[0] - 2) ** 2 + 4 * (x[1] - 3) ** 2 + 2 * x[2] ** 2 - 7 * x[3] - 120
)
[docs]
def g5(self, x):
return 5 * x[0] ** 2 + 8 * x[1] + (x[2] - 6) ** 2 - 2 * x[3] - 40
[docs]
def g6(self, x):
return 0.5 * (x[0] - 8) ** 2 + 2 * (x[1] - 4) ** 2 + 3 * x[4] ** 2 - x[5] - 30
[docs]
def g7(self, x):
return x[0] ** 2 + 2 * (x[1] - 2) ** 2 - 2 * x[0] * x[1] + 14 * x[4] - 6 * x[5]
[docs]
def g8(self, x):
return -3 * x[0] + 6 * x[1] + 12 * (x[8] - 8) ** 2 - 7 * x[9]
[docs]
class G08(BenchmarkProblem):
def __init__(self):
super().__init__()
self.name = "G08"
self.num_dim: int = 2
self.num_obj = 1
self.num_cstr = 2
self.num_fidelity = 1
self.bounds = np.array(
[
[0, 10],
]
* self.num_dim
)
self.tags = [
"GOTestProblems",
]
self.constraints = [
self.g1,
self.g2,
]
# x* = (1.2279713, 4.2453733) , f (x*) = 0.095825
[docs]
def objective(self, x):
return -(np.sin(2 * np.pi * x[0]) ** 3 * np.sin(2 * np.pi * x[1])) / (
x[0] ** 3 * (x[0] + x[1])
)
[docs]
def g1(self, x):
return x[0] ** 2 - x[1] + 1
[docs]
def g2(self, x):
return 1 - x[0] + (x[1] - 4) ** 2
[docs]
class G09(BenchmarkProblem):
def __init__(self):
super().__init__()
self.name = "G09"
self.num_dim: int = 7
self.num_obj = 1
self.num_cstr = 4
self.num_fidelity = 1
self.bounds = np.array(
[
[-10, 10],
]
* self.num_dim
)
self.tags = [
"GOTestProblems",
]
self.constraints = [
self.g1,
self.g2,
self.g3,
self.g4,
]
# x* = (2.330499, 1.951372,−0.4775414, 4.365726,−0.6244870, 1.038131,1.594227), f (x*) = 680.6300573
[docs]
def objective(self, x):
return (
(x[0] - 10) ** 2
+ 5 * (x[1] - 12) ** 2
+ x[2] ** 4
+ 3 * (x[3] - 11) ** 2
+ 10 * x[4] ** 6
+ 7 * x[5] ** 2
+ x[6] ** 4
- 4 * x[5] * x[6]
- 10 * x[5]
- 8 * x[6]
)
[docs]
def v1(self, x):
return 2 * x[0] ** 2
[docs]
def v2(self, x):
return x[1] ** 2
[docs]
def g1(self, x):
return self.v1(x) + 3 * self.v2(x) ** 2 + x[2] + 4 * x[3] ** 2 + 5 * x[4] - 127
[docs]
def g2(self, x):
return 7 * x[0] + 3 * x[1] + 10 * x[2] ** 2 + x[3] - x[4] - 282
[docs]
def g3(self, x):
return 23 * x[0] + self.v2(x) + 6 * x[5] ** 2 - 8 * x[6] - 196
[docs]
def g4(self, x):
return (
2 * self.v1(x)
+ self.v2(x)
- 3 * x[0] * x[1]
+ 2 * x[2] ** 2
+ 5 * x[5]
- 11 * x[6]
)
[docs]
class G10(BenchmarkProblem):
def __init__(self):
super().__init__()
self.name = "G10"
self.num_dim: int = 8
self.num_obj = 1
self.num_cstr = 6
self.num_fidelity = 1
self.bounds = np.array(
[
[100, 10_000],
[1_000, 10_000],
[1_000, 10_000],
[10, 1000],
[10, 1000],
[10, 1000],
[10, 1000],
[10, 1000],
]
)
self.tags = [
"GOTestProblems",
]
self.constraints = [
self.g1,
self.g2,
self.g3,
self.g4,
self.g5,
self.g6,
]
# x* = (579.3167, 1359.943, 5110.071, 182.0174, 295.5985, 217.9799, 286.4162,395.5979), f (x*) = 7049.3307
[docs]
def objective(self, x):
return x[0] + x[1] + x[2]
[docs]
def g1(self, x):
return -1 + 0.0025 * (x[3] + x[5])
[docs]
def g2(self, x):
return -1 + 0.0025 * (-x[3] + x[4] + x[6])
[docs]
def g3(self, x):
return -1 + 0.01 * (-x[4] + x[7])
[docs]
def g4(self, x):
return 100 * x[0] - x[0] * x[5] + 833.33252 * x[3] - 83333.333
[docs]
def g5(self, x):
return x[1] * x[3] - x[1] * x[6] - 1250 * x[3] + 1250 * x[4]
[docs]
def g6(self, x):
return x[2] * x[4] - x[2] * x[7] - 2500 * x[4] + 1250000
[docs]
class G11(BenchmarkProblem):
def __init__(self):
super().__init__()
self.name = "G11"
self.num_dim: int = 2
self.num_obj = 1
self.num_cstr = 1
self.num_fidelity = 1
self.cstr_types = ["eq"]
self.bounds = np.array(
[
[-1, 1],
]
* self.num_dim
)
self.tags = [
"GOTestProblems",
]
self.constraints = [
self.h1,
]
# x* = ±(1/(2^0.5), 1/2), f(x*) = 0.75
[docs]
def objective(self, x):
return x[0] ** 2 + (x[1] - 1) ** 2
[docs]
def h1(self, x):
return x[1] - x[0] ** 2
[docs]
class G12(BenchmarkProblem):
def __init__(self):
super().__init__()
self.name = "G12"
self.num_dim: int = 3
self.num_obj = 1
self.num_cstr = 1
self.num_fidelity = 1
self.bounds = np.array(
[
[0, 10],
]
* self.num_dim
)
self.tags = [
"GOTestProblems",
]
self.constraints = [
self.g1,
]
# x* = (5, 5, 5), f(x*) = 1
[docs]
def objective(self, x):
return -(1 - 0.01 * ((x[0] - 5) ** 2 + (x[1] - 5) ** 2 + (x[2] - 5) ** 2))
[docs]
def g1(self, x):
z = np.empty((9, 9, 9))
for i in range(9):
for j in range(9):
for k in range(9):
p = i + 1
q = j + 1
r = k + 1
z[i, j, k] = (
(x[0] - p) ** 2 + (x[1] - q) ** 2 + (x[2] - r) ** 2 - 0.0625
)
return np.min(z)
[docs]
class G13(BenchmarkProblem):
def __init__(self):
super().__init__()
self.name = "G13"
self.num_dim: int = 5
self.num_obj = 1
self.num_cstr = 3
self.num_fidelity = 1
self.cstr_types = [
"eq",
"eq",
"eq",
]
self.bounds = np.array(
[
[-2.3, 2.3],
[-2.3, 2.3],
[-3.2, 3.2],
[-3.2, 3.2],
[-3.2, 3.2],
]
)
self.tags = [
"GOTestProblems",
]
self.constraints = [
self.h1,
self.h2,
self.h3,
]
# x* = (−1.717143, 1.595709, 1.827247, −0.7636413, −0.763645), f (x*) = 0.0539498
[docs]
def objective(self, x):
return np.exp(np.prod(x))
[docs]
def h1(self, x):
return np.sum(x**2) - 10
[docs]
def h2(self, x):
return x[1] * x[2] - 5 * x[3] * x[4]
[docs]
def h3(self, x):
return x[0] ** 3 + x[1] ** 3 + 1
[docs]
class WeldedBeamDesign(BenchmarkProblem):
def __init__(self):
super().__init__()
# TODO: review implementation (different sources = different results)
self.name = "WeldedBeamDesign"
self.num_dim: int = 4
self.num_obj = 1
self.num_cstr = 6
self.num_fidelity = 1
self.bounds = np.array(
[
[0.125, 10],
[0.1, 10],
[0.1, 10],
[0.1, 10],
]
)
self.tags = [
"GOTestProblems",
]
self.constraints = [
self.g1,
self.g2,
self.g3,
self.g4,
self.g5,
self.g6,
]
self.P = 6_000
self.L = 14
self.E = 30e6
self.G = 12e6
self.t_max = 13_600
self.s_max = 30_000
self.d_max = 0.25
[docs]
def M(self, x):
return self.P * (self.L + x[1] / 2)
[docs]
def R(self, x):
return np.sqrt(0.25 * (x[1] ** 2 + (x[0] + x[2]) ** 2))
[docs]
def J(self, x):
# 2 ??? * ??? np.sqrt(2) * x[0] * x[1] * (x[1] ** 2 / 12 + 0.25 * (x[0] + x[2]) ** 2)
return (
2 / np.sqrt(2) * x[0] * x[1] * (x[1] ** 2 / 12 + 0.25 * (x[0] + x[2]) ** 2)
)
[docs]
def P_c(self, x):
return (
(4.013 * self.E / (6 * self.L**2))
* x[2]
* x[3] ** 3
* (1 - 0.25 * x[2] * np.sqrt(self.E / self.G) / self.L)
)
[docs]
def t1(self, x):
return self.P / (np.sqrt(2) * x[0] * x[1])
[docs]
def t2(self, x):
return self.M(x) * self.R(x) / self.J(x)
[docs]
def t(self, x):
return np.sqrt(
self.t1(x) ** 2
+ self.t1(x) * self.t2(x) * x[1] / self.R(x)
+ self.t2(x) ** 2
)
[docs]
def s(self, x):
return 6 * self.P * self.L / (x[3] * x[2] ** 2)
[docs]
def d(self, x):
return 4 * self.P * self.L**3 / (self.E * x[3] * x[2] ** 3)
[docs]
def objective(self, x):
return 1.10471 * x[0] ** 2 * x[1] + 0.04811 * x[2] * x[3] * (14.0 + x[1])
[docs]
def g1(self, x):
return self.t(x) - self.t_max
[docs]
def g2(self, x):
return self.s(x) - self.s_max
[docs]
def g3(self, x):
return x[0] - x[3]
[docs]
def g4(self, x):
return 0.10471 * x[0] ** 2 + 0.04811 * x[2] * x[3] * (14.0 + x[1]) - 5.0
[docs]
def g5(self, x):
return self.d(x) - self.d_max
[docs]
def g6(self, x):
return self.P - self.P_c(x)
if __name__ == "__main__":
from smt_optim.subsolvers.multistart import multistart_minimize
prob = WeldedBeamDesign()
# prob.set_dim(20)
print(prob.bounds)
sp_cstr = []
for j in range(prob.num_cstr):
sp_cstr.append(
{
"fun": lambda x, f=prob.constraints[j]: -f(x),
"type": prob.cstr_types[j] if hasattr(prob, "cstr_types") else "ineq",
}
)
res = multistart_minimize(
prob.objective, bounds=prob.bounds, constraints=sp_cstr, n_start=100, seed=0
)
print(res.x)
print(res.fun)
# G2 problem
# x_star = np.array([3.162460616, 3.128331428, 3.094792129, 3.061451495, 3.027929159,2.993826067, 2.958668718, 2.921842273, 0.494825115, 0.488357110,0.482316427, 0.476645751, 0.471295508, 0.466230993, 0.461420050,0.456836648, 0.452458769, 0.448267622, 0.444247010, 0.440382860])
# print(prob.objective(x_star))
# print(prob.constraints[0](x_star))
# print(prob.constraints[1](x_star))
x_star = np.array(
[0.18756483308730693, 4.053366828472939, 8.731994883504612, 0.2231022567643955]
)
print(prob.objective(x_star))
print(prob.constraints[0](x_star))
print(prob.constraints[1](x_star))
