def p19(x): out = constant.benchmark_function(19) D, g, h, xmin, xmax = out["D"], out["g"], out["h"], out["xmin"], out["xmax"] ## Welded beam design fx = 1.10471 * x[0] ** 2 * x[1] + 0.04811 * x[2] * x[3] * (14 + x[1]) hx = 0 P = 6000 L = 14 delta_max = 0.25 E = 30 * 1e6 G = 12 * 1e6 T_max = 13600 sigma_max = 30000 Pc = 4.013 * E * sqrt(x[2] ** 2 * x[3] ** 6 / 30) / L ** 2 * (1 - x[2] / (2 * L) * sqrt(E / (4 * G))) sigma = 6 * P * L / (x[3] * x[2] ** 2) delta = 6 * P * L ** 3 / (E * x[2] ** 2 * x[3]) J = 2 * (sqrt(2) * x[0] * x[1] * (x[1] ** 2 / 4 + (x[0] + x[2]) ** 2 / 4)) R = sqrt(x[1] ** 2 / 4 + (x[0] + x[2]) ** 2 / 4) M = P * (L + x[1] / 2) ttt = M * R / J tt = P / (sqrt(2) * x[0] * x[1]) t = sqrt(tt ** 2 + 2 * tt * ttt * x[1] / (2 * R) + ttt ** 2) ## constraints gx = zeros(g) gx[0] = t - T_max gx[1] = sigma - sigma_max gx[2] = x[0] - x[3] gx[3] = delta - delta_max gx[4] = P - Pc return fx, gx, hx
def p16(x): ## Optimal Design of Industrial refrigeration System out = constant.benchmark_function(16) D, g, h, xmin, xmax = out["D"], out["g"], out["h"], out["xmin"], out["xmax"] hx = 0 gx = zeros(g) fx = 63098.88 * x[1] * x[3] * x[11] + 5441.5 * x[1] ** 2 * x[11] + 115055.5 * x[1] ** 1.664 * x[5] + 6172.27 * x[1] ** 2 * x[5] + 63098.88 * x[0] * x[2] * \ x[10] + 5441.5 * x[0] ** 2 * x[10] + 115055.5 * x[0] ** 1.664 * x[4] + 6172.27 * x[0] ** 2 * x[4] + 140.53 * x[0] * x[10] + 281.29 * x[2] * x[10] \ + 70.26 * x[0] ** 2 + 281.29 * x[0] * x[2] + 281.29 * x[2] ** 2 + 14437 * x[7] ** 1.8812 * x[11] ** 0.3424 * x[9] * x[13] ** (-1) * x[0] ** 2 * \ x[6] * x[8] ** (-1) + 20470.2 * x[6] ** (2.893) * x[10] ** 0.316 * x[0] ** 2 gx[0] = 1.524 * x[6] ** (-1) - 1 gx[1] = 1.524 * x[7] ** (-1) - 1 gx[2] = 0.07789 * x[0] - 2 * x[6] ** (-1) * x[8] - 1 gx[3] = 7.05305 * x[8] ** (-1) * x[0] ** 2 * x[9] * x[7] ** (-1) * x[1] ** (-1) * x[13] ** (-1) - 1 gx[4] = 0.0833 / x[12] * x[13] - 1 gx[5] = 0.04771 * x[9] * x[7] ** 1.8812 * x[11] ** 0.3424 - 1 gx[6] = 0.0488 * x[8] * x[6] ** 1.893 * x[10] ** 0.316 - 1 gx[7] = 0.0099 * x[0] / x[2] - 1 gx[8] = 0.0193 * x[1] / x[3] - 1 gx[9] = 0.0298 * x[0] / x[4] - 1 gx[10] = 47.136 * x[1] ** 0.333 / x[9] * x[11] - 1.333 * x[7] * x[12] ** 2.1195 + 62.08 * x[12] ** 2.1195 * x[7] ** 0.2 / (x[11] * x[9]) - 1 gx[11] = 0.056 * x[1] / x[5] - 1 gx[12] = 2 / x[8] - 1 gx[13] = 2 / x[9] - 1 gx[14] = x[11] / x[10] - 1 return fx, gx, hx
def p11(x): # Two-reactor Problem out = constant.benchmark_function(11) D, g, h, xmin, xmax = out["D"], out["g"], out["h"], out["xmin"], out["xmax"] x1 = x[0] x2 = x[1] v1 = x[2] v2 = x[3] y1 = round(x[4]) y2 = round(x[5]) x_ = x[6] z1 = 0.9 * (1 - exp(-0.5 * v1)) * x1 z2 = 0.8 * (1 - exp(-0.4 * v2)) * x2 fx = 7.5 * y1 + 5.5 * y2 + 7 * v1 + 6 * v2 + 5 * x_ hx = zeros(h) gx = zeros(g) hx[0] = y1 + y2 - 1 hx[1] = z1 + z2 - 10 hx[2] = x1 + x2 - x_ hx[3] = z1 * y1 + z2 * y2 - 10 gx[0] = v1 - 10 * y1 gx[1] = v2 - 10 * y2 gx[2] = x1 - 20 * y1 gx[3] = x2 - 20 * y2 return fx, gx, hx
def p9(x): # Process synthesis and design problem out = constant.benchmark_function(9) D, g, h, xmin, xmax = out["D"], out["g"], out["h"], out["xmin"], out["xmax"] x[2] = round(x[2]) fx = -x[2] + 2 * x[0] + x[1] hx = x[0] - 2 * exp(-x[1]) gx = -x[0] + x[1] + x[2] return fx, gx, hx
def p20(x): out = constant.benchmark_function(20) D, g, h, xmin, xmax = out["D"], out["g"], out["h"], out["xmin"], out["xmax"] ## Three-bar truss design problem fx = (2 * sqrt(2) * x[0] + x[1]) * 100 gx = zeros(g) gx[0] = (sqrt(2) * x[0] + x[1]) / (sqrt(2) * x[0] ** 2 + 2 * x[0] * x[1]) * 2 - 2 gx[1] = x[1] / (sqrt(2) * x[0] ** 2 + 2 * x[0] * x[1]) * 2 - 2 gx[2] = 1 / (sqrt(2) * x[1] + x[0]) * 2 - 2 hx = 0 return fx, gx, hx
def p8(x): # Process synthesis problem out = constant.benchmark_function(8) D, g, h, xmin, xmax = out["D"], out["g"], out["h"], out["xmin"], out["xmax"] x[1] = round(x[1]) fx = 2 * x[0] + x[1] hx = 0 gx = zeros(g) gx[0] = 1.25 - x[0] ** 2 - x[1] gx[1] = x[0] + x[1] - 1.6 return fx, gx, hx
def p10(x): # Process flow sheeting problem out = constant.benchmark_function(10) D, g, h, xmin, xmax = out["D"], out["g"], out["h"], out["xmin"], out["xmax"] gx = zeros(g) x[2] = round(x[2]) fx = -0.7 * x[2] + 5 * (x[0] - 0.5) ** 2 + 0.8 gx[0] = -exp(x[0] - 0.2) - x[1] gx[1] = x[1] + 1.1 * x[2] + 1 gx[2] = x[0] - x[2] - 0.2 hx = 0 return fx, gx, hx
def p17(x): ## Tension/compression spring design (case 1) out = constant.benchmark_function(17) D, g, h, xmin, xmax = out["D"], out["g"], out["h"], out["xmin"], out["xmax"] hx = 0 fx = x[0] ** 2 * x[1] * (x[2] + 2) gx = zeros(g) gx[0] = 1 - (x[1] ** 3 * x[2]) / (71785 * x[0] ** 4) gx[1] = (4 * x[1] ** 2 - x[0] * x[1]) / (12566 * (x[1] * x[0] ** 3 - x[0] ** 4)) + 1 / (5108 * x[0] ** 2) - 1 gx[2] = 1 - 140.45 * x[0] / (x[1] ** 2 * x[2]) gx[3] = (x[0] + x[1]) / 1.5 - 1 return fx, gx, hx
def p22(x): ## Planetary gear train design optimization problem out = constant.benchmark_function(22) D, g, h, xmin, xmax = out["D"], out["g"], out["h"], out["xmin"], out["xmax"] ##parameter Initialization x = abs(x).astype(int) Pind = [3, 4, 5] mind = [1.75, 2, 2.25, 2.5, 2.75, 3.0] N1 = x[0] N2 = x[1] N3 = x[2] N4 = x[3] N5 = x[4] N6 = x[5] p = Pind[x[6]-1] m1 = mind[x[7]-1] m2 = mind[x[8]-1] ## objective function i1 = N6 / N4 i01 = 3.11 i2 = N6 * (N1 * N3 + N2 * N4) / (N1 * N3 * (N6 - N4)) i02 = 1.84 iR = -(N2 * N6 / (N1 * N3)) i0R = -3.11 fx = max([i1 - i01, i2 - i02, iR - i0R]) ## constraints Dmax = 220 dlt22 = 0.5 dlt33 = 0.5 dlt55 = 0.5 dlt35 = 0.5 dlt34 = 0.5 dlt56 = 0.5 beta = arccos(((N6 - N3) ** 2 + (N4 + N5) ** 2 - (N3 + N5) ** 2) / (2 * (N6 - N3) * (N4 + N5))) gx = zeros(g) gx[0] = m2 * (N6 + 2.5) - Dmax gx[1] = m1 * (N1 + N2) + m1 * (N2 + 2) - Dmax gx[2] = m2 * (N4 + N5) + m2 * (N5 + 2) - Dmax gx[3] = abs(m1 * (N1 + N2) - m2 * (N6 - N3)) - m1 - m2 gx[4] = -((N1 + N2) * sin(pi / p) - N2 - 2 - dlt22) gx[5] = -((N6 - N3) * sin(pi / p) - N3 - 2 - dlt33) gx[6] = -((N4 + N5) * sin(pi / p) - N5 - 2 - dlt55) if beta == beta.real: gx[7] = (N3 + N5 + 2 + dlt35) ** 2 - ((N6 - N3) ** 2 + (N4 + N5) ** 2 - 2 * (N6 - N3) * (N4 + N5) * cos(2 * pi / p - beta)) else: gx[7] = 1e6 gx[8] = -(N6 - 2 * N3 - N4 - 4 - 2 * dlt34) gx[9] = -(N6 - N4 - 2 * N5 - 4 - 2 * dlt56) hx = remainder(N6 - N4, p) return fx, gx, hx
def p7(x): # Propane, Isobutane, n-Butane Nonsharp Separation out = constant.benchmark_function(7) D, g, h, xmin, xmax = out["D"], out["g"], out["h"], out["xmin"], out["xmax"] c = array([[0.23947, 0.75835], [-0.0139904, -0.0661588], [0.0093514, 0.0338147], [0.0077308, 0.0373349], [-0.0005719, 0.0016371], [0.0042656, 0.0288996]]) fx = c[0, 0] + (c[1, 0] + c[2, 0] * x[23] + c[3, 0] * x[27] + c[4, 0] * x[32] + c[5, 0] * x[33]) * x[4] \ + c[0, 1] + (c[1, 1] + c[2, 1] * x[25] + c[3, 1] * x[30] + c[4, 1] * x[37] + c[5, 1] * x[38]) * x[12] gx = 0 hx = zeros(h) hx[0] = x[0] + x[1] + x[2] + x[3] - 300 hx[1] = x[5] - x[6] - x[7] hx[2] = x[8] - x[9] - x[10] - x[11] hx[3] = x[13] - x[14] - x[15] - x[16] hx[4] = x[17] - x[18] - x[19] hx[5] = x[5] * x[20] - x[23] * x[24] hx[6] = x[13] * x[21] - x[25] * x[26] hx[7] = x[8] * x[22] - x[27] * x[28] hx[8] = x[17] * x[29] - x[30] * x[31] hx[9] = x[24] - x[4] * x[32] hx[10] = x[28] - x[4] * x[33] hx[11] = x[34] - x[4] * x[35] hx[12] = x[36] - x[12] * x[37] hx[13] = x[26] - x[12] * x[38] hx[14] = x[31] - x[12] * x[39] hx[15] = x[24] - x[5] * x[20] - x[8] * x[40] hx[16] = x[28] - x[5] * x[41] - x[8] * x[22] hx[17] = x[34] - x[5] * x[42] - x[8] * x[43] hx[18] = x[36] - x[13] * x[44] - x[17] * x[45] hx[19] = x[26] - x[13] * x[21] - x[17] * x[46] hx[20] = x[31] - x[13] * x[47] - x[17] * x[29] hx[21] = 1 / 3 * x[0] + x[14] * x[44] - x[24] hx[22] = 1 / 3 * x[0] + x[14] * x[21] - x[28] hx[23] = 1 / 3 * x[0] + x[14] * x[47] - x[34] hx[24] = 1 / 3 * x[1] + x[9] * x[40] - x[36] hx[25] = 1 / 3 * x[1] + x[9] * x[22] - x[26] hx[26] = 1 / 3 * x[1] + x[9] * x[43] - x[31] hx[27] = x[32] + x[33] + x[35] - 1 hx[28] = x[20] + x[41] + x[42] - 1 hx[29] = x[40] + x[22] + x[43] - 1 hx[30] = x[37] + x[38] + x[39] - 1 hx[31] = x[44] + x[21] + x[47] - 1 hx[32] = x[45] + x[46] + x[29] - 1 hx[33] = x[42] hx[34] = x[45] hx[35] = 1 / 3 * x[2] + x[6] * x[20] + x[10] * x[40] + x[15] * x[44] + x[18] * x[45] - 30 hx[36] = 1 / 3 * x[2] + x[6] * x[41] + x[10] * x[22] + x[15] * x[21] + x[18] * x[46] - 50 hx[37] = 1 / 3 * x[2] + x[6] * x[42] + x[10] * x[43] + x[15] * x[47] + x[18] * x[29] - 30 return fx, gx, hx
def p5(x): # Haverly's Pooling Problem out = constant.benchmark_function(5) D, g, h, xmin, xmax = out["D"], out["g"], out["h"], out["xmin"], out["xmax"] fx = -(9 * x[0] + 15 * x[1] - 6 * x[2] - 16 * x[3] - 10 * (x[4] + x[5])) gx = zeros(g) hx = zeros(h) gx[0] = x[8] * x[6] + 2 * x[4] - 2.5 * x[0] gx[1] = x[8] * x[7] + 2 * x[5] - 1.5 * x[1] hx[0] = x[6] + x[7] - x[2] - x[3] hx[1] = x[0] - x[6] - x[4] hx[2] = x[1] - x[7] - x[5] hx[3] = x[8] * x[6] + x[8] * x[7] - 3 * x[2] - x[3] return fx, gx, hx
def p23(x): ## Step-cone pulley problem out = constant.benchmark_function(23) D, g, h, xmin, xmax = out["D"], out["g"], out["h"], out["xmin"], out["xmax"] gx = zeros(g) hx = zeros(h) ## parameter Initialization d1 = x[0] * 1e-3 d2 = x[1] * 1e-3 d3 = x[2] * 1e-3 d4 = x[3] * 1e-3 w = x[4] * 1e-3 N = 350 N1 = 750 N2 = 450 N3 = 250 N4 = 150 rho = 7200 a = 3 mu = 0.35 s = 1.75 * 1e6 t = 8 * 1e-3 ## objective function fx = rho * w * pi / 4 * (d1 ** 2 * (1 + (N1 / N) ** 2) + d2 ** 2 * (1 + (N2 / N) ** 2) + d3 ** 2 * (1 + (N3 / N) ** 2) + d4 ** 2 * (1 + (N4 / N) ** 2)) ## constraint C1 = pi * d1 / 2 * (1 + N1 / N) + (N1 / N - 1) ** 2 * d1 ** 2 / (4 * a) + 2 * a C2 = pi * d2 / 2 * (1 + N2 / N) + (N2 / N - 1) ** 2 * d2 ** 2 / (4 * a) + 2 * a C3 = pi * d3 / 2 * (1 + N3 / N) + (N3 / N - 1) ** 2 * d3 ** 2 / (4 * a) + 2 * a C4 = pi * d4 / 2 * (1 + N4 / N) + (N4 / N - 1) ** 2 * d4 ** 2 / (4 * a) + 2 * a R1 = exp(mu * (pi - 2 * arcsin((N1 / N - 1) * d1 / (2 * a)))) R2 = exp(mu * (pi - 2 * arcsin((N2 / N - 1) * d2 / (2 * a)))) R3 = exp(mu * (pi - 2 * arcsin((N3 / N - 1) * d3 / (2 * a)))) R4 = exp(mu * (pi - 2 * arcsin((N4 / N - 1) * d4 / (2 * a)))) P1 = s * t * w * (1 - exp(-mu * (pi - 2 * arcsin((N1 / N - 1) * d1 / (2 * a))))) * pi * d1 * N1 / 60 P2 = s * t * w * (1 - exp(-mu * (pi - 2 * arcsin((N2 / N - 1) * d2 / (2 * a))))) * pi * d2 * N2 / 60 P3 = s * t * w * (1 - exp(-mu * (pi - 2 * arcsin((N3 / N - 1) * d3 / (2 * a))))) * pi * d3 * N3 / 60 P4 = s * t * w * (1 - exp(-mu * (pi - 2 * arcsin((N4 / N - 1) * d4 / (2 * a))))) * pi * d4 * N4 / 60 gx[0] = -R1 + 2 gx[1] = -R2 + 2 gx[2] = -R3 + 2 gx[3] = -R4 + 2 gx[4] = -P1 + (0.75 * 745.6998) gx[5] = -P2 + (0.75 * 745.6998) gx[6] = -P3 + (0.75 * 745.6998) gx[7] = -P4 + (0.75 * 745.6998) hx[0] = C1 - C2 hx[1] = C1 - C3 hx[2] = C1 - C4 return fx, gx, hx
def p18(x): ## Update out = constant.benchmark_function(18) D, g, h, xmin, xmax = out["D"], out["g"], out["h"], out["xmin"], out["xmax"] x[0] = 0.0625 * round(x[0]) x[1] = 0.0625 * round(x[1]) ## Pressure vessel design hx = 0 gx = zeros(g) fx = 0.6224 * x[0] * x[2] * x[3] + 1.7781 * x[1] * x[2] ** 2 + 3.1661 * x[0] ** 2 * x[3] + 19.84 * x[0] ** 2 * x[2] gx[0] = -x[0] + 0.0193 * x[2] gx[1] = -x[1] + 0.00954 * x[2] gx[2] = -pi * x[2] ** 2 * x[3] - 4 / 3 * pi * x[2] ** 3 + 1296000 gx[3] = x[3] - 240 return fx, gx, hx
def p4(x): # Reactor Network Design (RND) out = constant.benchmark_function(4) D, g, h, xmin, xmax = out["D"], out["g"], out["h"], out["xmin"], out["xmax"] hx = zeros(h) k1 = 0.09755988 k2 = 0.99 * k1 k3 = 0.0391908 k4 = 0.9 * k3 fx = -x[3] hx[0] = x[0] + k1 * x[1] * x[4] - 1 hx[1] = x[1] - x[0] + k2 * x[1] * x[5] hx[2] = x[2] + x[0] + k3 * x[2] * x[4] - 1 hx[3] = x[3] - x[2] + x[1] - x[0] + k4 * x[3] * x[5] gx = x[4] ** 0.5 + x[5] ** 0.5 - 4 return fx, gx, hx
def p1(x): # Heat Exchanger Network Design (case 1) out = constant.benchmark_function(1) D, g, h, xmin, xmax = out["D"], out["g"], out["h"], out["xmin"], out["xmax"] fx = 35 * x[0] ** 0.6 + 35 * x[1] ** 0.6 gx = 0 hx = zeros(h) hx[0] = 200 * x[0] * x[3] - x[2] hx[1] = 200 * x[1] * x[5] - x[4] hx[2] = x[2] - 1000 * (x[6] - 100) hx[3] = x[4] - 10000 * (300 - x[6]) hx[4] = x[2] - 10000 * (600 - x[7]) hx[5] = x[4] - 10000 * (900 - x[8]) hx[6] = x[3] * log(abs(x[7] - 100) + 1e-8) - x[3] * log((600 - x[6]) + 1e-8) - x[7] + x[6] + 500 hx[7] = x[5] * log(abs(x[8] - x[6]) + 1e-8) - x[5] * log(600) - x[8] + x[6] + 600 return fx, gx, hx
def p13(x): # Process design Problem out = constant.benchmark_function(13) D, g, h, xmin, xmax = out["D"], out["g"], out["h"], out["xmin"], out["xmax"] x1 = x[0] x2 = x[1] x3 = x[2] y1 = round(x[3]) y2 = round(x[4]) fx = -5.357854 * x1 ** 2 - 0.835689 * y1 * x3 - 37.29329 * y1 + 40792.141 a = [85.334407, 0.0056858, 0.0006262, 0.0022053, 80.51249, 0.0071317, 0.0029955, 0.0021813, 9.300961, 0.0047026, 0.0012547, 0.0019085] gx = zeros(g) gx[0] = a[0] + a[1] * y2 * x3 + a[2] * y1 * x2 - a[3] * y1 * y1 * x3 - 92 gx[1] = a[4] + a[5] * y2 * x3 + a[6] * y1 * x2 + a[7] * x1 ** 2 - 90 - 20 gx[2] = a[8] + a[9] * y1 * x2 + a[10] * y1 * x1 + a[11] * x1 * x2 - 20 - 5 hx = 0 return fx, gx, hx
def p2(x): # Heat Exchanger Network Design (case 1) out = constant.benchmark_function(2) D, g, h, xmin, xmax = out["D"], out["g"], out["h"], out["xmin"], out["xmax"] fx = (x[0] / (120 * x[3])) ** 0.6 + (x[1] / (80 * x[4])) ** 0.6 + (x[2] / (40 * x[5])) * 0.6 gx = 0 hx = zeros(h) hx[0] = x[0] - 1e4 * (x[6] - 100) hx[1] = x[1] - 1e4 * (x[7] - x[6]) hx[2] = x[2] - 1e4 * (500 - x[7]) hx[3] = x[0] - 1e4 * (300 - x[8]) hx[4] = x[1] - 1e4 * (400 - x[9]) hx[5] = x[2] - 1e-4 * (600 - x[10]) hx[6] = x[3] * log(abs(x[8] - 100) + 1e-8) - x[3] * log(300 - x[6] + 1e-8) - x[8] - x[6] + 400 hx[7] = x[4] * log(abs(x[9] - x[6]) + 1e-8) - x[4] * log(abs(400 - x[7]) + 1e-8) - x[9] + x[6] - x[7] + 400 hx[8] = x[5] * log(abs(x[10] - x[7]) + 1e-8) - x[5] * log(100) - x[10] + x[7] + 100 return fx, gx, hx
def p24(x): ## Not done ### Robot gripper problem out = constant.benchmark_function(24) D, g, h, xmin, xmax = out["D"], out["g"], out["h"], out["xmin"], out["xmax"] a = x[0] b = x[1] c = x[2] e = x[3] ff = x[4] l = x[5] delta = x[6] Ymin = 50 Ymax = 100 YG = 150 Zmax = 99.9999 P = 100 alpha_0 = arccos((a ** 2 + l ** 2 + e ** 2 - b ** 2) / (2 * a * sqrt(l ** 2 + e ** 2))) + arctan(e / l) beta_0 = arccos((b ** 2 + l ** 2 + e ** 2 - a ** 2) / (2 * b * sqrt(l ** 2 + e ** 2))) - arctan(e / l) alpha_m = arccos((a ** 2 + (l - Zmax) ** 2 + e ** 2 - b ** 2) / (2 * a * sqrt((l - Zmax) ** 2 + e ** 2))) + arctan(e / (l - Zmax)) beta_m = arccos((b ** 2 + (l - Zmax) ** 2 + e ** 2 - a ** 2) / (2 * b * sqrt((l - Zmax) ** 2 + e ** 2))) - arctan(e / (l - Zmax)) ## objective function fx = zeros(D) for i in range(0, D): fx[i] = -1 * OBJ11(x, 2) + OBJ11(x, 1) ## constraints Yxmin = 2 * (e + ff + c * sin(beta_m + delta)) Yxmax = 2 * (e + ff + c * sin(beta_0 + delta)) gx = zeros(g) gx[0] = Yxmin - Ymin gx[1] = -Yxmin gx[2] = Ymax - Yxmax gx[3] = Yxmax - YG gx[4] = l ** 2 + e ** 2 - (a + b) ** 2 gx[5] = b ** 2 - (a - e) ** 2 - (l - Zmax) ** 2 gx[6] = Zmax - l hx = 0 tt = int(imag(fx[0]) != 0) fx[tt] = 1e4 tt = int(imag(gx[0]) != 0) gx[tt] = 1e4 return fx, gx, hx
def p6(x): # Blending-Pooling-Separation problem out = constant.benchmark_function(6) D, g, h, xmin, xmax = out["D"], out["g"], out["h"], out["xmin"], out["xmax"] fx = 0.9979 + 0.00432 * x[4] + 0.01517 * x[12] gx = 0 hx = zeros(h) hx[0] = x[0] + x[1] + x[2] + x[3] - 300 hx[1] = x[5] - x[6] - x[7] hx[2] = x[8] - x[9] - x[10] - x[11] hx[3] = x[13] - x[14] - x[15] - x[16] hx[4] = x[17] - x[18] - x[19] hx[5] = x[4] * x[20] - x[5] * x[21] - x[8] * x[22] hx[6] = x[4] * x[23] - x[5] * x[24] - x[8] * x[25] hx[7] = x[4] * x[26] - x[5] * x[27] - x[8] * x[28] hx[8] = x[12] * x[29] - x[13] * x[30] - x[17] * x[31] hx[9] = x[12] * x[32] - x[13] * x[33] - x[17] * x[34] hx[10] = x[12] * x[35] - x[13] * x[36] - x[17] * x[37] hx[11] = 1 / 3 * x[0] + x[14] * x[30] - x[4] * x[20] hx[12] = 1 / 3 * x[0] + x[14] * x[33] - x[4] * x[23] hx[13] = 1 / 3 * x[0] + x[14] * x[36] - x[4] * x[26] hx[14] = 1 / 3 * x[1] + x[9] * x[22] - x[12] * x[29] hx[15] = 1 / 3 * x[1] + x[9] * x[25] - x[12] * x[32] hx[16] = 1 / 3 * x[1] + x[9] * x[28] - x[12] * x[35] hx[17] = 1 / 3 * x[2] + x[6] * x[21] + x[10] * x[22] + x[15] * x[30] + x[18] * x[31] - 30 hx[18] = 1 / 3 * x[2] + x[6] * x[24] + x[10] * x[25] + x[15] * x[33] + x[18] * x[34] - 50 hx[19] = 1 / 3 * x[2] + x[6] * x[27] + x[10] * x[28] + x[15] * x[36] + x[18] * x[37] - 30 hx[20] = x[20] + x[23] + x[26] - 1 hx[21] = x[21] + x[24] + x[27] - 1 hx[22] = x[22] + x[25] + x[28] - 1 hx[23] = x[29] + x[32] + x[35] - 1 hx[24] = x[30] + x[33] + x[36] - 1 hx[25] = x[31] + x[34] + x[37] - 1 hx[26] = x[24] hx[27] = x[27] hx[28] = x[22] hx[29] = x[36] hx[30] = x[31] hx[31] = x[34] return fx, gx, hx
def p3(x): # Optimal Operation of Alkylation Unit out = constant.benchmark_function(3) D, g, h, xmin, xmax = out["D"], out["g"], out["h"], out["xmin"], out["xmax"] fx = -1.715 * x[0] - 0.035 * x[0] * x[5] - 4.0565 * x[2] - 10.0 * x[1] + 0.063 * x[2] * x[4] hx = 0 gx = zeros(g) gx[0] = 0.0059553571 * x[5] ** 2 * x[0] + 0.88392857 * x[2] - 0.1175625 * x[5] * x[0] - x[0] gx[1] = 1.1088 * x[0] + 0.1303533 * x[0] * x[5] - 0.0066033 * x[0] * x[5] ** 2 - x[2] gx[2] = 6.66173269 * x[5] ** 2 + 172.39878 * x[4] - 56.596669 * x[3] - 191.20592 * x[5] - 10000 gx[3] = 1.08702 * x[5] + 0.32175 * x[3] - 0.03762 * x[5] ** 2 - x[4] + 56.85075 gx[4] = 0.006198 * x[6] * x[3] * x[2] + 2462.3121 * x[1] - 25.125634 * x[1] * x[3] - x[2] * x[3] gx[5] = 161.18996 * x[2] * x[3] + 5000.0 * x[1] * x[3] - 489510.0 * x[1] - x[2] * x[3] * x[6] gx[6] = 0.33 * x[6] - x[4] + 44.333333 gx[7] = 0.022556 * x[4] - 0.007595 * x[6] - 1.0 gx[8] = 0.00061 * x[2] - 0.0005 * x[0] - 1.0 gx[9] = 0.819672 * x[0] - x[2] + 0.819672 gx[10] = 24500.0 * x[1] - 250.0 * x[1] * x[3] - x[2] * x[3] gx[11] = 1020.4082 * x[3] * x[1] + 1.2244898 * x[2] * x[3] - 100000 * x[1] gx[12] = 6.25 * x[0] * x[5] + 6.25 * x[0] - 7.625 * x[2] - 100000 gx[13] = 1.22 * x[2] - x[5] * x[0] - x[0] + 1.0 return fx, gx, hx
def p14(x): # Multi-product batch plant out = constant.benchmark_function(14) D, g, h, xmin, xmax = out["D"], out["g"], out["h"], out["xmin"], out["xmax"] gx = zeros(g) # constant S = array([[2, 3, 4], [4, 6, 3]]) t = array([[8, 20, 8], [16, 4, 4]]) H = 6000 alp = 250 beta = 0.6 Q1 = 40000 Q2 = 20000 ## Decision Variable N1 = round(x[0]) N2 = round(x[1]) N3 = round(x[2]) V1 = x[3] V2 = x[4] V3 = x[5] TL1 = x[6] TL2 = x[7] B1 = x[8] B2 = x[9] ## Objective function fx = alp * (N1 * V1 ** beta + N2 * V2 ** beta + N3 * V3 ** beta) ## constraints gx[0] = Q1 * TL1 / B1 + Q2 * TL2 / B2 - H gx[1] = S[0, 0] * B1 + S[1, 0] * B2 - V1 gx[2] = S[0, 1] * B1 + S[1, 1] * B2 - V2 gx[3] = S[0, 2] * B1 + S[1, 2] * B2 - V3 gx[4] = t[0, 0] - N1 * TL1 gx[5] = t[0, 1] - N2 * TL1 gx[6] = t[0, 2] - N3 * TL1 gx[7] = t[1, 0] - N1 * TL2 gx[8] = t[1, 1] - N2 * TL2 gx[9] = t[1, 2] - N3 * TL2 hx = 0 return fx, gx, hx
def p15(x): ## Weight Minimization of a Speed Reducer out = constant.benchmark_function(15) D, g, h, xmin, xmax = out["D"], out["g"], out["h"], out["xmin"], out["xmax"] hx = 0 gx = zeros(g) fx = 0.7854 * x[0] * x[1] ** 2 * (3.3333 * x[2] ** 2 + 14.9334 * x[2] - 43.0934) - 1.508 * x[0] * (x[5] ** 2 + x[6] ** 2) \ + 7.477 * (x[5] ** 3 + x[6] ** 3) + 0.7854 * (x[3] * x[5] ** 2 + x[4] * x[6] ** 2) gx[0] = -x[0] * x[1] ** 2 * x[2] + 27 gx[1] = -x[0] * x[1] ** 2 * x[2] ** 2 + 397.5 gx[2] = -x[1] * x[5] ** 4 * x[2] * x[3] ** (-3) + 1.93 gx[3] = -x[1] * x[6] ** 4 * x[2] / x[4] ** 3 + 1.93 gx[4] = 10 * x[5] ** (-3) * sqrt(16.91 * 10 ** 6 + (745 * x[3] / (x[1] * x[2])) ** 2) - 1100 gx[5] = 10 * x[6] ** (-3) * sqrt(157.5 * 10 ** 6 + (745 * x[4] / (x[1] * x[2])) ** 2) - 850 gx[6] = x[1] * x[2] - 40 gx[7] = -x[0] / x[1] + 5 gx[8] = x[0] / x[1] - 12 gx[9] = 1.5 * x[5] - x[3] + 1.9 gx[10] = 1.1 * x[6] - x[4] + 1.9 return fx, gx, hx
def p25(x): ## Hydro-static thrust bearing design problem out = constant.benchmark_function(25) D, g, h, xmin, xmax = out["D"], out["g"], out["h"], out["xmin"], out["xmax"] R = x[0] Ro = x[1] mu = x[2] Q = x[3] gamma = 0.0307 C = 0.5 n = -3.55 C1 = 10.04 Ws = 101000 Pmax = 1000 delTmax = 50 hmin = 0.001 gg = 386.4 N = 750 P = (log10(log10(8.122 * 1e6 * mu + 0.8)) - C1) / n delT = 2 * (10 ** P - 560) Ef = 9336 * Q * gamma * C * delT h = (2 * pi * N / 60) ** 2 * 2 * pi * mu / Ef * (R ** 4 / 4 - Ro ** 4 / 4) - 1e-5 Po = (6 * mu * Q / (pi * h ** 3)) * log(R / Ro) W = pi * Po / 2 * (R ** 2 - Ro ** 2) / (log(R / Ro) - 1e-5) ## objective function fx = (Q * Po / 0.7 + Ef) / 12 ## constraints gx = zeros(g) hx = 0 gx[0] = Ws - W gx[1] = Po - Pmax gx[2] = delT - delTmax gx[3] = hmin - h gx[4] = Ro - R gx[5] = gamma / (gg * Po) * (Q / (2 * pi * R * h)) - 0.001 gx[6] = W / (pi * (R ** 2 - Ro ** 2) + 1e-5) - 5000 return fx, gx, hx
def p21(x): ## Multiple disk clutch brake design problem out = constant.benchmark_function(21) D, g, h, xmin, xmax = out["D"], out["g"], out["h"], out["xmin"], out["xmax"] ## parameters Mf = 3 Ms = 40 Iz = 55 n = 250 Tmax = 15 s = 1.5 delta = 0.5 Vsrmax = 10 rho = 0.0000078 pmax = 1 mu = 0.6 Lmax = 30 delR = 20 Rsr = 2 / 3 * (x[1] ** 3 - x[0] ** 3) / (x[1] ** 2 * x[0] ** 2) Vsr = pi * Rsr * n / 30 A = pi * (x[1] ** 2 - x[0] ** 2) Prz = x[3] / A w = pi * n / 30 Mh = 2 / 3 * mu * x[3] * x[4] * (x[1] ** 3 - x[0] ** 3) / (x[1] ** 2 - x[0] ** 2) T = Iz * w / (Mh + Mf) hx = 0 gx = zeros(g) fx = pi * (x[1] ** 2 - x[0] ** 2) * x[2] * (x[4] + 1) * rho gx[0] = -x[1] + x[0] + delR gx[1] = (x[4] + 1) * (x[2] + delta) - Lmax gx[2] = Prz - pmax gx[3] = Prz * Vsr - pmax * Vsrmax gx[4] = Vsr - Vsrmax gx[5] = T - Tmax gx[6] = s * Ms - Mh gx[7] = -T return fx, gx, hx
def p12(x): # Process synthesis problem out = constant.benchmark_function(12) D, g, h, xmin, xmax = out["D"], out["g"], out["h"], out["xmin"], out["xmax"] x1 = x[0] x2 = x[1] x3 = x[2] y1 = round(x[3]) y2 = round(x[4]) y3 = round(x[5]) y4 = round(x[6]) fx = (y1 - 1) ** 2 + (y2 - 1) ** 2 + (y3 - 1) ** 2 - log(y4 + 1) + (x1 - 1) ** 22 + (x2 - 2) ** 2 + (x3 - 3) ** 2 gx = zeros(g) gx[0] = x1 + x2 + x3 + y1 + y2 + y3 - 5 gx[1] = y3 ** 2 + x1 ** 2 + x2 ** 2 + x3 ** 2 - 5.5 gx[2] = x1 + y1 - 1.2 gx[3] = x2 + y2 - 1.8 gx[4] = x3 + y3 - 2.5 gx[5] = x1 + y4 - 1.2 gx[6] = y2 ** 2 + x2 ** 2 - 1.64 gx[7] = y3 ** 2 + x3 ** 2 - 4.25 gx[8] = y2 ** 2 + x3 ** 2 - 4.64 hx = 0 return fx, gx, hx