//  Poloni.java
//
//  Author:
//       Antonio J. Nebro <antonio@lcc.uma.es>
//       Juan J. Durillo <durillo@lcc.uma.es>
//
//  Copyright (c) 2011 Antonio J. Nebro, Juan J. Durillo
//
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU Lesser General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU Lesser General Public License for more details.
// 
//  You should have received a copy of the GNU Lesser General Public License
//  along with this program.  If not, see <http://www.gnu.org/licenses/>.

package jmetal.problems;

import jmetal.core.Problem;
import jmetal.core.Solution;
import jmetal.core.Variable;
import jmetal.encodings.solutionType.BinaryRealSolutionType;
import jmetal.encodings.solutionType.RealSolutionType;
import jmetal.util.JMException;

/**
 * Class representing problem Poloni. This problem has two objectives to be
 * MAXIMIZED. As jMetal always minimizes, the rule Max(f(x)) = -Min(f(-x)) must
 * be applied.
 */
public class Poloni extends Problem{    
    
 /**
  * Constructor.
  * Creates a default instance of the Poloni problem
  * @param solutionType The solution type must "Real" or "BinaryReal".
  */
  public Poloni(String solutionType) {
    numberOfVariables_  = 2;
    numberOfObjectives_ = 2;
    numberOfConstraints_= 0;
    problemName_        = "Poloni";

    lowerLimit_ = new double[numberOfVariables_];
    upperLimit_ = new double[numberOfVariables_];        
    for (int var = 0; var < numberOfVariables_; var++){
      lowerLimit_[var] = -1* Math.PI;
      upperLimit_[var] =  Math.PI;
    } //for

    if (solutionType.compareTo("BinaryReal") == 0)
    	solutionType_ = new BinaryRealSolutionType(this) ;
    else if (solutionType.compareTo("Real") == 0)
    	solutionType_ = new RealSolutionType(this) ;
    else {
    	System.out.println("Error: solution type " + solutionType + " invalid") ;
    	System.exit(-1) ;
    }  
 } //Poloni
    
  /** 
  * Evaluates a solution 
  * @param solution The solution to evaluate
   * @throws jmetal.util.JMException
  */
  public void evaluate(Solution solution) throws JMException {
    final double A1 = 0.5 * Math.sin(1.0) - 2 * Math.cos(1.0) + 
                      Math.sin(2.0) - 1.5 * Math.cos(2.0) ; //!< Constant A1
    final double A2 = 1.5 * Math.sin(1.0) - Math.cos(1.0) + 
                      2 * Math.sin(2.0) - 0.5 * Math.cos(2.0) ; //!< Constant A2
    
    Variable[] decisionVariables  = solution.getDecisionVariables();
    
    double [] x = new double[numberOfVariables_] ;
    double [] f = new double[numberOfObjectives_];
    
    x[0] = decisionVariables[0].getValue();
    x[1] = decisionVariables[1].getValue();        
    
    double B1 = 0.5 * Math.sin(x[0]) - 2 * Math.cos(x[0]) + Math.sin(x[1]) - 
                1.5 * Math.cos(x[1]) ;
    double B2 = 1.5 * Math.sin(x[0]) - Math.cos(x[0]) + 2 * Math.sin(x[1]) - 
                0.5 * Math.cos(x[1]) ;
    
    f[0] = - (1 + Math.pow(A1 - B1, 2) + Math.pow(A2 - B2, 2)) ;
    f[1] = -(Math.pow(x[0]+3,2) + Math.pow(x[1]+1,2)) ;
      
    // The two objectives to be minimized. According to Max(f(x)) = -Min(f(-x)), 
    // they must be multiplied by -1. Consequently, the obtained solutions must
    // be also multiplied by -1 
    
    solution.setObjective(0,-1 * f[0]);
    solution.setObjective(1,-1 * f[1]);
  } // evaluate
} // Poloni

