import java.util.HashMap;
/***********************************************************************/
/*
//     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   ************************/
/***********************************************************************/  
class Optimizationproblem {
    public void blackbox( double[] f, double[] g, double[] x ) 
    {
      /* Objective functions F(X) */
      f[0] = 0.5*(x[0]*x[0]+x[1]*x[1])+Math.sin(x[0]*x[0]+x[1]*x[1]);
      f[1] = (3*x[0]-2*x[1]+4)*(3*x[0]-2*x[1]+4) + (x[0]-x[1]+1)*(x[0]-x[1]+1) + 15;
      f[2] = 1/(x[0]*x[0]+x[1]*x[1]+1) - 1.1 * Math.exp(-1*(x[0]*x[0]+x[1]*x[1]));

      /* Define overall target function */
      f[3] = f[0]+f[1]+f[2];
    }
}
/***********************************************************************/
/************************   MAIN PROGRAM   *****************************/
/***********************************************************************/
class Example {
    public static void main(String args[]) 
    {
      int i,n; double[] x,xl,xu;
      HashMap<String, Integer>  problem   = new HashMap<String, Integer> ();    
      HashMap<String, Integer>  option    = new HashMap<String, Integer> ();
      HashMap<String, Double>   parameter = new HashMap<String, Double>  ();      
      HashMap<String, double[]> solution  = new HashMap<String, double[]>();  
      String key = "MIDACO_LIMITED_VERSION___[CREATIVE_COMMONS_BY-NC-ND_LICENSE]";

      /*****************************************************************/
      /***  Step 1: Problem definition  ********************************/
      /*****************************************************************/

      /* STEP 1.A: Problem dimensions
      ******************************/
      problem.put("o",  4); /* Number of objectives                          */
      problem.put("n",  2); /* Number of variables (in total)                */
      problem.put("ni", 0); /* Number of integer variables (0 <= ni <= n)    */
      problem.put("m",  0); /* Number of constraints (in total)              */
      problem.put("me", 0); /* Number of equality constraints (0 <= me <= m) */

      /* STEP 1.B: Lower and upper bounds 'xl' & 'xu'  
      **********************************************/ 
      n = problem.get("n"); 
      xl = new double[n]; 
      xu = new double[n]; 
      for(i=0;i<n;i++)
      { 
         xl[i] = -3.0;
         xu[i] =  3.0; 
      }

      /* STEP 1.C: Starting point 'x'  
      ******************************/          
      x  = new double[n]; 
      for(i=0;i<n;i++)
      { 
         x[i] = xl[i]; /* Here for example: starting point = lower bounds */ 
      } 

      /*****************************************************************/
      /***  Step 2: Choose stopping criteria and printing options   ****/
      /*****************************************************************/
                  
      /* STEP 2.A: Stopping criteria 
      *****************************/
      option.put("maxeval",  100000);    /* Maximum number of function evaluation (e.g. 1000000)  */
      option.put("maxtime",  60*60*24); /* Maximum time limit in Seconds (e.g. 1 Day = 60*60*24) */

      /* STEP 2.B: Printing options  
      ****************************/
      option.put("printeval",  10000); /* Print-Frequency for current best solution (e.g. 1000) */
      option.put("save2file",  1);    /* Save SCREEN and SOLUTION to TXT-files [ 0=NO/ 1=YES]  */          

      /*****************************************************************/
      /***  Step 3: Choose MIDACO parameters (FOR ADVANCED USERS)    ***/
      /*****************************************************************/

      parameter.put("param1",  0.0); /* ACCURACY  */
      parameter.put("param2",  0.0); /* SEED      */
      parameter.put("param3",  0.0); /* FSTOP     */
      parameter.put("param4",  0.0); /* ALGOSTOP  */
      parameter.put("param5",  0.0); /* EVALSTOP  */
      parameter.put("param6",  0.0); /* FOCUS     */
      parameter.put("param7",  0.0); /* ANTS      */
      parameter.put("param8",  0.0); /* KERNEL    */
      parameter.put("param9",  0.0); /* ORACLE    */
      parameter.put("param10", 10000.0); /* PARETOMAX */
      parameter.put("param11", 0.00000001); /* EPSILON   */
      parameter.put("param12", 4.0); /* BALANCE   */
      parameter.put("param13", 0.0); /* CHARACTER */   
      
      /*****************************************************************/
      /***  Step 4: Choose Parallelization Factor    *******************/
      /*****************************************************************/      

      option.put("parallel", 0); /* Serial: 0 or 1, Parallel: 2,3,4,... */

      /*****************************************************************/
      /***********************  Run MIDACO  ****************************/
      /*****************************************************************/

      Midaco midaco = new Midaco(); 

      solution = midaco.run( problem, x,xl,xu, option, parameter, key );

      // double[] f,g;
      // f = solution.get("f");  System.out.println("f[0] = " + f[0]); 
      // g = solution.get("g");  System.out.println("g[0] = " + g[0]); 
      // x = solution.get("x");  System.out.println("x[0] = " + x[0]); 

      /*****************************************************************/
      /***********************  END OF MAIN  ***************************/
      /*****************************************************************/                
    }       
}