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 ) 
    {
      // Rename variables
      double x1,y1,y2;
      x1 = x[0];
      y1 = x[1];
      y2 = x[2];


      // Objective function value F(X)
      f[0] = 0.04712385*y2 * Math.sqrt(900 + y1*y1);


      // Equality constraints G(X) = 0 MUST COME FIRST in g(1:me)  
      g[0] = 420.169404664517 * Math.sqrt(900 + y1*y1) - x1*y1*y2;
      // Inequality constraints G(X) >= 0 MUST COME SECOND in g(me+1:m)
      g[1] = - x1 + 100;
      g[2] = 296087.631843 * (0.01+0.0625*y2*y2)/(7200+y1*y1) - x1;             
    }
}
/***********************************************************************/
/************************   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",  1); /* Number of objectives                          */
      problem.put("n",  3); /* Number of variables (in total)                */
      problem.put("ni", 2); /* Number of integer variables (0 <= ni <= n)    */
      problem.put("m",  3); /* Number of constraints (in total)              */
      problem.put("me", 1); /* 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] = 0.0;
         xu[i] = 200.0; 
      }
      xu[0] = 100.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",  1000000);    /* 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",  12.47); /* 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", 0.0); /* PARETOMAX */
      parameter.put("param11", 0.0); /* EPSILON   */
      parameter.put("param12", 0.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  ***************************/
      /*****************************************************************/                
    }       
}