Beispiel #1
0
  /**
   * This method receives a normalized list of non-dominated solutions and return the inverted one.
   * This operation is needed for minimization problem
   *
   * @param solutionList The front to invert
   * @return The inverted front
   */
  public static <S extends Solution<?>> List<S> selectNRandomDifferentSolutions(
      int numberOfSolutionsToBeReturned, List<S> solutionList) {
    if (null == solutionList) {
      throw new JMetalException("The solution list is null");
    } else if (solutionList.size() == 0) {
      throw new JMetalException("The solution list is empty");
    } else if (solutionList.size() < numberOfSolutionsToBeReturned) {
      throw new JMetalException(
          "The solution list size ("
              + solutionList.size()
              + ") is less than "
              + "the number of requested solutions ("
              + numberOfSolutionsToBeReturned
              + ")");
    }

    JMetalRandom randomGenerator = JMetalRandom.getInstance();
    List<S> resultList = new ArrayList<>(numberOfSolutionsToBeReturned);

    if (solutionList.size() == 1) {
      resultList.add(solutionList.get(0));
    } else {
      Collection<Integer> positions = new HashSet<>(numberOfSolutionsToBeReturned);
      while (positions.size() < numberOfSolutionsToBeReturned) {
        int nextPosition = randomGenerator.nextInt(0, solutionList.size() - 1);
        if (!positions.contains(nextPosition)) {
          positions.add(nextPosition);
          resultList.add(solutionList.get(nextPosition));
        }
      }
    }

    return resultList;
  }
  @Before
  public void setup() {

    random = JMetalRandom.getInstance();
    random.setSeed(2);
    operator = new ExhaustiveSearchMutationOperator(1.0, random, aminoAcidSequence, 40);
    proteinBuilder = new ProteinBuilder();
  }
  /**
   * Checks if the value is between its bounds; if not, a random value between the limits is
   * returned
   *
   * @param value The value to be checked
   * @param lowerBound
   * @param upperBound
   * @return The same value if it is between the limits or a repaired value otherwise
   */
  public double repairSolutionVariableValue(double value, double lowerBound, double upperBound) {
    if (lowerBound > upperBound) {
      throw new JMetalException(
          "The lower bound ("
              + lowerBound
              + ") is greater than the "
              + "upper bound ("
              + upperBound
              + ")");
    }
    double result = value;
    if (value < lowerBound) {
      result = randomGenerator.nextDouble(lowerBound, upperBound);
    }
    if (value > upperBound) {
      result = randomGenerator.nextDouble(lowerBound, upperBound);
    }

    return result;
  }
  int FindNicheReferencePoint() {
    // find the minimal cluster size
    int min_size = Integer.MAX_VALUE;
    for (ReferencePoint<S> referencePoint : this.referencePoints)
      min_size = Math.min(min_size, referencePoint.MemberSize());

    // find the reference points with the minimal cluster size Jmin
    List<Integer> min_rps = new ArrayList<>();

    for (int r = 0; r < this.referencePoints.size(); r += 1) {
      if (this.referencePoints.get(r).MemberSize() == min_size) {
        min_rps.add(r);
      }
    }
    // return a random reference point (j-bar)
    return min_rps.get(
        min_rps.size() > 1 ? JMetalRandom.getInstance().nextInt(0, min_rps.size() - 1) : 0);
  }
 /** Constructor */
 public RepairDoubleSolutionAtRandom() {
   randomGenerator = JMetalRandom.getInstance();
 }