using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
/***********************************************************************/
/*
//     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 static void blackbox( double[] f, double[] g, double[] x ) 
    {

      double sum_A = 0.0;
      for(int i=0;i<=1;i++)
      { 
        sum_A = sum_A - 10.0*Math.Exp(-0.2*Math.Sqrt(x[i]*x[i]+x[i+1]*x[i+1]));
      }    

      double sum_B = 0.0;
      for(int i=0;i<=2;i++)
      { 
        sum_B = sum_B + Math.Pow(Math.Abs(x[i]),0.8) + 5.0*Math.Sin(x[i]*x[i]*x[i]);
      }

      /*                                               
        Objective Functions F(X)
      */
      f[0] = sum_A;
      f[1] = sum_B;
    }
} 
/***********************************************************************/
/************************   MAIN PROGRAM   *****************************/
/***********************************************************************/
class Example {

  public static void Main() {

      long i,n; double[] x,xl,xu;
      Dictionary<string, long> problem = new Dictionary<string, long>();
      Dictionary<string, long> option  = new Dictionary<string, long>();
      Dictionary<string, double> parameter  = new Dictionary<string, double>();
      Dictionary<string, double[]> solution   = new Dictionary<string, double[]>();
      string key = "MIDACO_LIMITED_VERSION___[CREATIVE_COMMONS_BY-NC-ND_LICENSE]";

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

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

      /* STEP 1.B: Lower and upper bounds 'xl' & 'xu'  
      **********************************************/ 
      n = problem["n"]; 
      xl = new double[n]; 
      xu = new double[n]; 
      for(i=0;i<n;i++)
      { 
         xl[i] = -5.0;
         xu[i] =  5.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["maxeval"] = 1000000;    /* 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"] = 100000; /* 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)    ***/
      /*****************************************************************/

      parameter["param1"]  = 0.0; /* ACCURACY  */
      parameter["param2"]  = 0.0; /* SEED      */
      parameter["param3"]  = 0.0; /* FSTOP     */
      parameter["param4"]  = 0.0; /* ALGOSTOP  */
      parameter["param5"]  = 0.0; /* EVALSTOP  */
      parameter["param6"]  = 0.0; /* FOCUS     */
      parameter["param7"]  = 0.0; /* ANTS      */
      parameter["param8"]  = 0.0; /* KERNEL    */
      parameter["param9"]  = 0.0; /* ORACLE    */
      parameter["param10"] = 0.0; /* PARETOMAX */
      parameter["param11"] = 0.0; /* EPSILON   */
      parameter["param12"] = 0.0; /* BALANCE   */
      parameter["param13"] = 0.0; /* CHARACTER */   
 
      /*****************************************************************/
      /***  Step 4: Choose Parallelization Factor    *******************/
      /*****************************************************************/  

      option ["parallel"] = 0; /* Serial: 0 or 1, Parallel: 2,3,4,... */

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

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

      /* Print solution return arguments from MIDACO to console */
      
      double[] f,g;
      Console.WriteLine(" ");
      f = solution["f"]; Console.WriteLine("solution f[0]: " + f[0]);
      // g = solution["g"]; Console.WriteLine("solution g[0]: " + g[0]);
      x = solution["x"]; Console.WriteLine("solution x[0]: " + x[0]);
      Console.ReadKey(); /* pause */

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