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 ) 
    {
      int  i,n = 8000;
      double p = 1.0;
      
      f[0]  = 0.0;

      for (i=0; i<n; i++)
      {
          f[0] = f[0] + x[i] * x[i];
          p = p * Math.Cos( x[i] / Math.Sqrt((double)i+1) );
      }
      
      f[0] = f[0] / 4000.0 - p + 1.0;
    }
} 
/***********************************************************************/
/************************   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 = "************************************************************";

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

      /* STEP 1.A: Problem dimensions
      ******************************/
      problem["o"]  = 1; /* Number of objectives                          */
      problem["n"]  = 8000; /* 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] = -600.0;
         xu[i] =  600.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"] = 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)    ***/
      /*****************************************************************/

      parameter["param1"]  = 0.0; /* ACCURACY  */
      parameter["param2"]  = 0.0; /* SEED      */
      parameter["param3"]  = 0.00000001; /* 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  ***************************/
      /*****************************************************************/        
  }
}