######################################################################## # # This is an example call of MIDACO 6.0 # ------------------------------------- # # MIDACO solves Multi-Objective Mixed-Integer Non-Linear Problems: # # # Minimize F_1(X),... F_O(X) where X(1,...N-NI) is CONTINUOUS # and X(N-NI+1,...N) is DISCRETE # # subject to G_j(X) = 0 (j=1,...ME) equality constraints # G_j(X) >= 0 (j=ME+1,...M) inequality constraints # # and bounds XL <= X <= XU # # # The problem statement of this example is given below. You can use # this example as template to run your own problem. To do so: Replace # the objective functions 'F' (and in case the constraints 'G') given # here with your own problem and follow the below instruction steps. # ######################################################################## ###################### OPTIMIZATION PROBLEM ######################## ######################################################################## def problem_function(x): import math f = [0.0]*1 # Initialize array for objectives F(X) g = [0.0]*7 # Initialize array for constraints G(X) # Rename integer variables y = [0.0]*10 for i in range(0, 7): y[i] = x[3+i] # Objective function value F(X) (denoted here as 'f') f[0] = -x[0]*x[1]*x[2]; # Equality constraints G(X) = 0 MUST COME FIRST g[0] = math.log(abs(1 - x[0])) - math.log(0.1)*y[0] - math.log(0.2)*y[1] - math.log(0.15)*y[2]; g[1] = math.log(abs(1 - x[1])) - math.log(0.05)*y[3] - math.log(0.2)*y[4] - math.log(0.15)*y[5]; g[2] = math.log(abs(1 - x[2])) - math.log(0.02)*y[6] - math.log(0.06)*y[7]; # Inequality constraints G(X) >= 0 MUST COME SECOND g[3] =y[0] +y[1] +y[2] - 1; g[4] =y[3] +y[4] +y[5] - 1; g[5] =y[6] +y[7] - 1; g[6] = -(3*y[0] +y[1] + 2*y[2] + 3*y[3] + 2*y[4] +y[5] + 3*y[6] + 2*y[7]) + 10; return f,g ######################################################################## ######################### MAIN PROGRAM ############################# ######################################################################## key = b'************************************************************' problem = {} # Initialize dictionary containing problem specifications option = {} # Initialize dictionary containing MIDACO options problem['@'] = problem_function # Handle for problem function name ######################################################################## ### Step 1: Problem definition ##################################### ######################################################################## # STEP 1.A: Problem dimensions ############################## problem['o'] = 1 # Number of objectives problem['n'] = 11 # Number of variables (in total) problem['ni'] = 8 # Number of integer variables (0 <= ni <= n) problem['m'] = 7 # Number of constraints (in total) problem['me'] = 3 # Number of equality constraints (0 <= me <= m) # STEP 1.B: Lower and upper bounds 'xl' & 'xu' ############################################## problem['xl'] = [ 0.0 ] * 11 problem['xu'] = [ 1.0 ] * 11 problem['xu'][0] = 0.999 problem['xu'][1] = 0.999 problem['xu'][2] = 0.999 # STEP 1.C: Starting point 'x' ############################## import copy problem['x'] = copy.copy(problem['xl']) # Here for example: starting point = lower bounds ######################################################################## ### Step 2: Choose stopping criteria and printing options ########### ######################################################################## # STEP 2.A: Stopping criteria ############################# option['maxeval'] = 999999999 # Maximum number of function evaluation (e.g. 1000000) option['maxtime'] = 60*60*24 # Maximum time limit in Seconds (e.g. 1 Day = 60*60*24) # STEP 2.B: Printing options ############################ option['printeval'] = 50000 # Print-Frequency for current best solution (e.g. 1000) option['save2file'] = 1 # Save SCREEN and SOLUTION to TXT-files [0=NO/1=YES] ######################################################################## ### Step 3: Choose MIDACO parameters (FOR ADVANCED USERS) ########### ######################################################################## option['param1'] = 0.0 # ACCURACY option['param2'] = 2.0 # SEED option['param3'] = -0.9434705 # FSTOP option['param4'] = 0.0 # ALGOSTOP option['param5'] = 0.0 # EVALSTOP option['param6'] = 0.0 # FOCUS option['param7'] = 0.0 # ANTS option['param8'] = 0.0 # KERNEL option['param9'] = 0.0 # ORACLE option['param10'] = 0.0 # PARETOMAX option['param11'] = 0.0 # EPSILON option['param12'] = 0.0 # BALANCE option['param13'] = 0.0 # CHARACTER ######################################################################## ### Step 4: Choose Parallelization Factor ############################ ######################################################################## option['parallel'] = 0 # Serial: 0 or 1, Parallel: 2,3,4,5,6,7,8... ######################################################################## ############################ Run MIDACO ################################ ######################################################################## import midaco if __name__ == '__main__': solution = midaco.run( problem, option, key ) # print solution['f'] # print solution['g'] # print solution['x'] ######################################################################## ############################ END OF FILE ############################### ########################################################################