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