コード例 #1
0
  /**
   * Evaluate all the non-evaluated points of the simplex.
   *
   * @param comparator comparator to use to sort simplex vertices from best to worst
   * @exception FunctionEvaluationException if no value can be computed for the parameters
   * @exception OptimizationException if the maximal number of evaluations is exceeded
   */
  protected void evaluateSimplex(final Comparator<RealPointValuePair> comparator)
      throws FunctionEvaluationException, OptimizationException {

    // evaluate the objective function at all non-evaluated simplex points
    for (int i = 0; i < simplex.length; ++i) {
      final RealPointValuePair vertex = simplex[i];
      final double[] point = vertex.getPointRef();
      if (Double.isNaN(vertex.getValue())) {
        simplex[i] = new RealPointValuePair(point, evaluate(point), false);
      }
    }

    // sort the simplex from best to worst
    Arrays.sort(simplex, comparator);
  }
コード例 #2
0
  /** {@inheritDoc} */
  @Override
  protected void iterateSimplex(final Comparator<RealPointValuePair> comparator)
      throws FunctionEvaluationException, OptimizationException {

    incrementIterationsCounter();

    // the simplex has n+1 point if dimension is n
    final int n = simplex.length - 1;

    // interesting values
    final RealPointValuePair best = simplex[0];
    final RealPointValuePair secondBest = simplex[n - 1];
    final RealPointValuePair worst = simplex[n];
    final double[] xWorst = worst.getPointRef();

    // compute the centroid of the best vertices
    // (dismissing the worst point at index n)
    final double[] centroid = new double[n];
    for (int i = 0; i < n; ++i) {
      final double[] x = simplex[i].getPointRef();
      for (int j = 0; j < n; ++j) {
        centroid[j] += x[j];
      }
    }
    final double scaling = 1.0 / n;
    for (int j = 0; j < n; ++j) {
      centroid[j] *= scaling;
    }

    // compute the reflection point
    final double[] xR = new double[n];
    for (int j = 0; j < n; ++j) {
      xR[j] = centroid[j] + rho * (centroid[j] - xWorst[j]);
    }
    final RealPointValuePair reflected = new RealPointValuePair(xR, evaluate(xR), false);

    if ((comparator.compare(best, reflected) <= 0)
        && (comparator.compare(reflected, secondBest) < 0)) {

      // accept the reflected point
      replaceWorstPoint(reflected, comparator);

    } else if (comparator.compare(reflected, best) < 0) {

      // compute the expansion point
      final double[] xE = new double[n];
      for (int j = 0; j < n; ++j) {
        xE[j] = centroid[j] + khi * (xR[j] - centroid[j]);
      }
      final RealPointValuePair expanded = new RealPointValuePair(xE, evaluate(xE), false);

      if (comparator.compare(expanded, reflected) < 0) {
        // accept the expansion point
        replaceWorstPoint(expanded, comparator);
      } else {
        // accept the reflected point
        replaceWorstPoint(reflected, comparator);
      }

    } else {

      if (comparator.compare(reflected, worst) < 0) {

        // perform an outside contraction
        final double[] xC = new double[n];
        for (int j = 0; j < n; ++j) {
          xC[j] = centroid[j] + gamma * (xR[j] - centroid[j]);
        }
        final RealPointValuePair outContracted = new RealPointValuePair(xC, evaluate(xC), false);

        if (comparator.compare(outContracted, reflected) <= 0) {
          // accept the contraction point
          replaceWorstPoint(outContracted, comparator);
          return;
        }

      } else {

        // perform an inside contraction
        final double[] xC = new double[n];
        for (int j = 0; j < n; ++j) {
          xC[j] = centroid[j] - gamma * (centroid[j] - xWorst[j]);
        }
        final RealPointValuePair inContracted = new RealPointValuePair(xC, evaluate(xC), false);

        if (comparator.compare(inContracted, worst) < 0) {
          // accept the contraction point
          replaceWorstPoint(inContracted, comparator);
          return;
        }
      }

      // perform a shrink
      final double[] xSmallest = simplex[0].getPointRef();
      for (int i = 1; i < simplex.length; ++i) {
        final double[] x = simplex[i].getPoint();
        for (int j = 0; j < n; ++j) {
          x[j] = xSmallest[j] + sigma * (x[j] - xSmallest[j]);
        }
        simplex[i] = new RealPointValuePair(x, Double.NaN, false);
      }
      evaluateSimplex(comparator);
    }
  }