Ejemplo n.º 1
0
  /**
   * Creates a LZ09_F2 problem instance
   *
   * @param solutionType The solution type must "Real" or "BinaryReal".
   */
  public LZ09_F2(String solutionType, Integer ptype, Integer dtype, Integer ltype)
      throws ClassNotFoundException {
    numberOfVariables_ = 30;
    numberOfObjectives_ = 2;
    numberOfConstraints_ = 0;
    problemName_ = "LZ09_F2";

    LZ09_ = new LZ09(numberOfVariables_, numberOfObjectives_, ptype, dtype, ltype);

    lowerLimit_ = new double[numberOfVariables_];
    upperLimit_ = new double[numberOfVariables_];
    lowerLimit_[0] = 0.0;
    upperLimit_[0] = 1.0;
    for (int var = 1; var < numberOfVariables_; var++) {
      lowerLimit_[var] = -1.0;
      upperLimit_[var] = 1.0;
    } // 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);
    }
  } // LZ09_F2
Ejemplo n.º 2
0
  double fitnessFunction(Solution individual, double[] lambda) {
    double fitness;
    fitness = 0.0;

    if (functionType_.equals("_TCHE1")) {
      double maxFun = -1.0e+30;

      for (int n = 0; n < problem_.getNumberOfObjectives(); n++) {
        double diff = Math.abs(individual.getObjective(n) - z_[n]);

        double feval;
        if (lambda[n] == 0) {
          feval = 0.0001 * diff;
        } else {
          feval = diff * lambda[n];
        }
        if (feval > maxFun) {
          maxFun = feval;
        }
      } // for

      fitness = maxFun;
    } // if
    else if (functionType_.equals("_AGG")) {
      double sum = 0.0;
      for (int n = 0; n < problem_.getNumberOfObjectives(); n++) {
        sum += (lambda[n]) * individual.getObjective(n);
      }

      fitness = sum;

    } else if (functionType_.equals("_PBI")) {
      double d1, d2, nl;
      double theta = 5.0;

      d1 = d2 = nl = 0.0;

      for (int i = 0; i < problem_.getNumberOfObjectives(); i++) {
        d1 += (individual.getObjective(i) - z_[i]) * lambda[i];
        nl += Math.pow(lambda[i], 2.0);
      }
      nl = Math.sqrt(nl);
      d1 = Math.abs(d1) / nl;

      for (int i = 0; i < problem_.getNumberOfObjectives(); i++) {
        d2 += Math.pow((individual.getObjective(i) - z_[i]) - d1 * (lambda[i] / nl), 2.0);
      }
      d2 = Math.sqrt(d2);

      fitness = (d1 + theta * d2);
    } else {
      System.out.println("MOEAD.fitnessFunction: unknown type " + functionType_);
      System.exit(-1);
    }
    return fitness;
  } // fitnessEvaluation
Ejemplo n.º 3
0
  public void readProblem(String fileName) throws FileNotFoundException, IOException {

    Reader inputFile = new BufferedReader(new InputStreamReader(new FileInputStream(fileName)));

    StreamTokenizer token = new StreamTokenizer(inputFile);
    try {
      token.nextToken();

      numberOfCities_ = (int) token.nval;

      distanceMatrix_ = new double[numberOfCities_][numberOfCities_];
      flujo1 = new double[numberOfCities_][numberOfCities_];
      flujo2 = new double[numberOfCities_][numberOfCities_];

      // Cargar objetivo 1
      for (int k = 0; k < numberOfCities_; k++) {
        for (int j = 0; j < numberOfCities_; j++) {
          token.nextToken();
          flujo1[k][j] = token.nval;
        }
      }

      // Cargar objetivo 2
      for (int k = 0; k < numberOfCities_; k++) {
        for (int j = 0; j < numberOfCities_; j++) {
          token.nextToken();
          flujo2[k][j] = token.nval;
        }
      }

      // Carga de distancias
      for (int k = 0; k < numberOfCities_; k++) {
        for (int j = 0; j < numberOfCities_; j++) {
          token.nextToken();
          distanceMatrix_[k][j] = token.nval;
        }
      }

    } // try
    catch (Exception e) {
      System.err.println("QAP.readProblem(): error when reading data file " + e);
      System.exit(1);
    } // catch
  } // readProblem
Ejemplo n.º 4
0
  /**
   * Constructor. Creates a default instance of the Srinivas problem
   *
   * @param solutionType The solution type must "Real" or "BinaryReal".
   */
  public Srinivas(String solutionType) throws ClassNotFoundException {
    numberOfVariables_ = 2;
    numberOfObjectives_ = 2;
    numberOfConstraints_ = 2;
    problemName_ = "Srinivas";

    lowerLimit_ = new double[numberOfVariables_];
    upperLimit_ = new double[numberOfVariables_];
    for (int var = 0; var < numberOfVariables_; var++) {
      lowerLimit_[var] = -20.0;
      upperLimit_[var] = 20.0;
    } // 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);
    }
  } // Srinivas
Ejemplo n.º 5
0
  /**
   * Creates a new DTLZ5 problem instance
   *
   * @param numberOfVariables Number of variables
   * @param numberOfObjectives Number of objective functions
   * @param solutionType The solution type must "Real" or "BinaryReal".
   */
  public DTLZ5(String solutionType, Integer numberOfVariables, Integer numberOfObjectives)
      throws ClassNotFoundException {
    numberOfVariables_ = numberOfVariables.intValue();
    numberOfObjectives_ = numberOfObjectives.intValue();
    numberOfConstraints_ = 0;
    problemName_ = "DTLZ5";

    lowerLimit_ = new double[numberOfVariables_];
    upperLimit_ = new double[numberOfVariables_];
    for (int var = 0; var < numberOfVariables_; var++) {
      lowerLimit_[var] = 0.0;
      upperLimit_[var] = 1.0;
    }

    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);
    }
  } // DTLZ5
Ejemplo n.º 6
0
  /**
   * Creates a new instance of problem CEC2009_UF10.
   *
   * @param numberOfVariables Number of variables.
   * @param solutionType The solution type must "Real" or "BinaryReal".
   */
  public CEC2009_UF10(String solutionType, Integer numberOfVariables)
      throws ClassNotFoundException {
    numberOfVariables_ = numberOfVariables.intValue();
    numberOfObjectives_ = 3;
    numberOfConstraints_ = 0;
    problemName_ = "CEC2009_UF10";

    upperLimit_ = new double[numberOfVariables_];
    lowerLimit_ = new double[numberOfVariables_];

    // Establishes upper and lower limits for the variables
    for (int var = 0; var < numberOfVariables_; var++) {
      lowerLimit_[var] = 0.0;
      upperLimit_[var] = 1.0;
    } // 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);
    }
  } // CEC2009_UF10