How to use

RealPointValuePair

in

org.apache.commons.math.optimization

/** {@inheritDoc} */
public boolean converged(final int iteration,
             final RealPointValuePair previous,
             final RealPointValuePair current) {
  final double[] p        = previous.getPoint();
  final double[] c        = current.getPoint();
  for (int i = 0; i < p.length; ++i) {
    final double difference = Math.abs(p[i] - c[i]);
    final double size       = Math.max(Math.abs(p[i]), Math.abs(c[i]));
    if ((difference > (size * relativeThreshold)) && (difference > absoluteThreshold)) {
      return false;
    }
  }
  return true;
}

/** 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);
}

/** Compute and evaluate a new simplex.
 * @param original original simplex (to be preserved)
 * @param coeff linear coefficient
 * @param comparator comparator to use to sort simplex vertices from best to poorest
 * @return best point in the transformed simplex
 * @exception FunctionEvaluationException if the function cannot be evaluated at some point
 * @exception OptimizationException if the maximal number of evaluations is exceeded
 */
private RealPointValuePair evaluateNewSimplex(final RealPointValuePair[] original,
                     final double coeff,
                     final Comparator<RealPointValuePair> comparator)
  throws FunctionEvaluationException, OptimizationException {
  final double[] xSmallest = original[0].getPointRef();
  final int n = xSmallest.length;
  // create the linearly transformed simplex
  simplex = new RealPointValuePair[n + 1];
  simplex[0] = original[0];
  for (int i = 1; i <= n; ++i) {
    final double[] xOriginal    = original[i].getPointRef();
    final double[] xTransformed = new double[n];
    for (int j = 0; j < n; ++j) {
      xTransformed[j] = xSmallest[j] + coeff * (xSmallest[j] - xOriginal[j]);
    }
    simplex[i] = new RealPointValuePair(xTransformed, Double.NaN, false);
  }
  // evaluate it
  evaluateSimplex(comparator);
  return simplex[0];
}

final RealPointValuePair secondBest = simplex[n-1];
final RealPointValuePair worst      = simplex[n];
final double[] xWorst = worst.getPointRef();
  final double[] x = simplex[i].getPointRef();
  for (int j = 0; j < n; ++j) {
    centroid[j] += x[j];
  xR[j] = centroid[j] + rho * (centroid[j] - xWorst[j]);
final RealPointValuePair reflected = new RealPointValuePair(xR, evaluate(xR), false);
    xE[j] = centroid[j] + khi * (xR[j] - centroid[j]);
  final RealPointValuePair expanded = new RealPointValuePair(xE, evaluate(xE), false);
    final RealPointValuePair outContracted = new RealPointValuePair(xC, evaluate(xC), false);
    final RealPointValuePair inContracted = new RealPointValuePair(xC, evaluate(xC), false);
  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);

  public IValue llOptimize(IBool minimize, IBool nonNegative, ISet constraints, IConstructor f) {
    SimplexSolver solver = new SimplexSolver();
    ArrayList<LinearConstraint> constraintsJ =
        new ArrayList<LinearConstraint>(constraints.size());
    for(IValue v : constraints ){
      constraintsJ.add(convertConstraint((IConstructor)v));
    }
    LinearObjectiveFunction fJ = convertLinObjFun(f);
    GoalType goal = minimize.getValue() ? 
            GoalType.MINIMIZE : GoalType.MAXIMIZE;
    IValueFactory vf = values;
    boolean nonNegativeJ =  nonNegative.getValue();
    try {
      RealPointValuePair res = 
          solver.optimize(fJ, constraintsJ, goal,nonNegativeJ);
      return vf.constructor(Maybe_just, 
          vf.constructor(
              LLSolution_llSolution, convertToRealList(res.getPoint(), vf), 
              vf.real(res.getValue()) )
          );
    } catch (Exception e) {
      return  vf.constructor(Maybe_nothing); 
    }

  }
}

  public int compare(final RealPointValuePair o1, final RealPointValuePair o2) {
    if (o1 == null) {
      return (o2 == null) ? 0 : +1;
    } else if (o2 == null) {
      return -1;
    }
    final double v1 = o1.getValue();
    final double v2 = o2.getValue();
    return (goalType == GoalType.MINIMIZE) ?
        Double.compare(v1, v2) : Double.compare(v2, v1);
  }
});

/** Build an initial simplex.
 * @param startPoint the start point for optimization
 * @exception IllegalArgumentException if the start point does not match
 * simplex dimension
 */
private void buildSimplex(final double[] startPoint)
  throws IllegalArgumentException {
  final int n = startPoint.length;
  if (n != startConfiguration.length) {
    throw MathRuntimeException.createIllegalArgumentException(
       LocalizedFormats.DIMENSIONS_MISMATCH_SIMPLE, n, startConfiguration.length);
  }
  // set first vertex
  simplex = new RealPointValuePair[n + 1];
  simplex[0] = new RealPointValuePair(startPoint, Double.NaN);
  // set remaining vertices
  for (int i = 0; i < n; ++i) {
    final double[] confI   = startConfiguration[i];
    final double[] vertexI = new double[n];
    for (int k = 0; k < n; ++k) {
      vertexI[k] = startPoint[k] + confI[k];
    }
    simplex[i + 1] = new RealPointValuePair(vertexI, Double.NaN);
  }
}

final RealPointValuePair secondBest = simplex[n-1];
final RealPointValuePair worst      = simplex[n];
final double[] xWorst = worst.getPointRef();
  final double[] x = simplex[i].getPointRef();
  for (int j = 0; j < n; ++j) {
    centroid[j] += x[j];
  xR[j] = centroid[j] + rho * (centroid[j] - xWorst[j]);
final RealPointValuePair reflected = new RealPointValuePair(xR, evaluate(xR), false);
    xE[j] = centroid[j] + khi * (xR[j] - centroid[j]);
  final RealPointValuePair expanded = new RealPointValuePair(xE, evaluate(xE), false);
    final RealPointValuePair outContracted = new RealPointValuePair(xC, evaluate(xC), false);
    final RealPointValuePair inContracted = new RealPointValuePair(xC, evaluate(xC), false);
  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);

  public int compare(final RealPointValuePair o1, final RealPointValuePair o2) {
    if (o1 == null) {
      return (o2 == null) ? 0 : +1;
    } else if (o2 == null) {
      return -1;
    }
    final double v1 = o1.getValue();
    final double v2 = o2.getValue();
    return (goalType == GoalType.MINIMIZE) ?
        Double.compare(v1, v2) : Double.compare(v2, v1);
  }
});

/** Compute and evaluate a new simplex.
 * @param original original simplex (to be preserved)
 * @param coeff linear coefficient
 * @param comparator comparator to use to sort simplex vertices from best to poorest
 * @return best point in the transformed simplex
 * @exception FunctionEvaluationException if the function cannot be evaluated at
 * some point
 * @exception OptimizationException if the maximal number of evaluations is exceeded
 */
private RealPointValuePair evaluateNewSimplex(final RealPointValuePair[] original,
                     final double coeff,
                     final Comparator<RealPointValuePair> comparator)
  throws FunctionEvaluationException, OptimizationException {
  final double[] xSmallest = original[0].getPointRef();
  final int n = xSmallest.length;
  // create the linearly transformed simplex
  simplex = new RealPointValuePair[n + 1];
  simplex[0] = original[0];
  for (int i = 1; i <= n; ++i) {
    final double[] xOriginal    = original[i].getPointRef();
    final double[] xTransformed = new double[n];
    for (int j = 0; j < n; ++j) {
      xTransformed[j] = xSmallest[j] + coeff * (xSmallest[j] - xOriginal[j]);
    }
    simplex[i] = new RealPointValuePair(xTransformed, Double.NaN, false);
  }
  // evaluate it
  evaluateSimplex(comparator);
  return simplex[0];
}

/** Build an initial simplex.
 * @param startPoint the start point for optimization
 * @exception IllegalArgumentException if the start point does not match
 * simplex dimension
 */
private void buildSimplex(final double[] startPoint)
  throws IllegalArgumentException {
  final int n = startPoint.length;
  if (n != startConfiguration.length) {
    throw MathRuntimeException.createIllegalArgumentException(
       DIMENSION_MISMATCH_MESSAGE, n, startConfiguration.length);
  }
  // set first vertex
  simplex = new RealPointValuePair[n + 1];
  simplex[0] = new RealPointValuePair(startPoint, Double.NaN);
  // set remaining vertices
  for (int i = 0; i < n; ++i) {
    final double[] confI   = startConfiguration[i];
    final double[] vertexI = new double[n];
    for (int k = 0; k < n; ++k) {
      vertexI[k] = startPoint[k] + confI[k];
    }
    simplex[i + 1] = new RealPointValuePair(vertexI, Double.NaN);
  }
}

/** {@inheritDoc} */
public boolean converged(final int iteration,
             final RealPointValuePair previous,
             final RealPointValuePair current) {
  final double[] p        = previous.getPoint();
  final double[] c        = current.getPoint();
  for (int i = 0; i < p.length; ++i) {
    final double difference = FastMath.abs(p[i] - c[i]);
    final double size       = FastMath.max(FastMath.abs(p[i]), FastMath.abs(c[i]));
    if ((difference > (size * relativeThreshold)) && (difference > absoluteThreshold)) {
      return false;
    }
  }
  return true;
}

/** 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);
}

  public int compare(final RealPointValuePair o1,
            final RealPointValuePair o2) {
    final double v1 = o1.getValue();
    final double v2 = o2.getValue();
    return (goalType == GoalType.MINIMIZE) ?
        Double.compare(v1, v2) : Double.compare(v2, v1);
  }
};

return new RealPointValuePair(coefficients, f.getValue(coefficients));

  nelderMead.setConvergenceChecker(new SimpleRealPointChecker(0.0001, -1));
  ret = nelderMead.optimize(func, GoalType.MINIMIZE, t);
  return ret.getPoint()[0];
} catch (Exception e) {
  e.printStackTrace();

  public int compare(final RealPointValuePair o1, final RealPointValuePair o2) {
    if (o1 == null) {
      return (o2 == null) ? 0 : +1;
    } else if (o2 == null) {
      return -1;
    }
    final double v1 = o1.getValue();
    final double v2 = o2.getValue();
    return (goalType == GoalType.MINIMIZE) ?
        Double.compare(v1, v2) : Double.compare(v2, v1);
  }
});

return new RealPointValuePair(coefficients, f.getValue(coefficients));

  nelderMead.setConvergenceChecker(new SimpleRealPointChecker(0.0001, -1));
  ret = nelderMead.optimize(func, GoalType.MINIMIZE, t);
  return ret.getPoint()[0];
} catch (Exception e) {
  e.printStackTrace();

  public int compare(final RealPointValuePair o1,
            final RealPointValuePair o2) {
    final double v1 = o1.getValue();
    final double v2 = o2.getValue();
    return (goalType == GoalType.MINIMIZE) ?
        Double.compare(v1, v2) : Double.compare(v2, v1);
  }
};