public double valueAt(Point point) { double[] ax = point.toArray(); double sum1 = 0.0; double sum2 = 0.0; for (int i = 0; i < n; i++) { sum1 += ax[i] * ax[i]; sum2 += Math.cos(2 * Math.PI * ax[i]); } return 20 + Math.exp(1) - 20 * Math.exp(-0.2 * Math.sqrt(sum1 / n)) - Math.exp(sum2 / n); }
@Override protected void reproduceInternal(Individual[] firstChildren, Individual[] secondChildren) { // make crossover for (int i = 0; i < firstChildren.length; i++) { double[] firstValues = firstChildren[i].getRepresentation().getDoubleValue(); double[] secondValues = secondChildren[i].getRepresentation().getDoubleValue(); double parentFitness = Math.max(firstChildren[i].getFitness(), secondChildren[i].getFitness()); firstChildren[i].setParentFitness(parentFitness); secondChildren[i].setParentFitness(parentFitness); double tmp; boolean[] cutPointFlags = this.makeCutPointFlags(this.crossPointCount, this.function.getDimension()); for (int j = 0; j < cutPointFlags.length; j++) { if (!cutPointFlags[j]) { tmp = firstValues[j]; firstValues[j] = secondValues[j]; secondValues[j] = tmp; } } // finally set the new values to the representation firstChildren[i].getRepresentation().setDoubleValue(firstValues); secondChildren[i].getRepresentation().setDoubleValue(secondValues); } }
public void init(ObjectiveFunction function) { this.function = function; dimension = function.getDimension(); min = Math.max(min, function.getMinimum()[0]); max = Math.min(max, function.getMaximum()[0]); xNew = new double[dimension]; xDelta = new double[dimension]; y = new double[dimension]; H = new double[dimension][dimension]; Hy = new double[dimension]; xH = new double[dimension]; direction = new double[dimension]; switch (lineSearch) { case BRENT_WITHOUT: this.lineSearchMethod = new LineSearchBrentNoDerivatives(function); break; case BRENT_WITH: this.lineSearchMethod = new LineSearchBrentWithDerivatives(function); break; default: throw new IllegalStateException("Unknown line search method"); } x = Point.random(dimension, min, max).toArray(); solution = ValuePoint.at(Point.at(x), function); this.stopCondition.setInitialValue(solution.getValue()); g = function.gradientAt(Point.at(x)).toArray(); for (int i = 0; i < dimension; i++) { direction[i] = -g[i]; H[i][i] = 1.0; y[i] = -1; } }
public Gradient gradientAt(Point point) { double[] ax = point.toArray(); double[] gradient = new double[n]; double sqrtSum = 0.0; double cosSum = 0.0; for (int i = 0; i < n; i++) { sqrtSum += ax[i] * ax[i]; cosSum += Math.cos(2 * Math.PI * ax[i]); } sqrtSum = Math.sqrt(sqrtSum); cosSum /= n; for (int i = 0; i < n; i++) gradient[i] = (2 * ax[i] * Math.exp(-0.1 * sqrtSum)) / sqrtSum + 0.5 * Math.exp(cosSum) * Math.PI * Math.sin(2 * Math.PI * ax[i]); return Gradient.valueOf(gradient); }
public void init(ObjectiveFunction function) { generator = new Random(); this.function = function; dimension = function.getDimension(); min = Math.max(min, function.getMinimum()[0]); max = Math.min(max, function.getMaximum()[0]); means = new double[dimension]; deviations = new double[dimension]; paths = new ValuePoint[populationSize]; best = ValuePoint.at(Point.getDefault(), Double.POSITIVE_INFINITY); stopCondition.setInitialValue(Double.POSITIVE_INFINITY); for (int i = 0; i < dimension; i++) { means[i] = (generator.nextDouble() * (max - min)) + min; deviations[i] = (max - min) / 2; } }
public void optimize() { for (int ant = 0; ant < populationSize; ant++) { // generate solution double[] newPoint = new double[dimension]; for (int d = 0; d < dimension; d++) newPoint[d] = (generator.nextGaussian() * deviations[d]) + means[d]; // improve solution using gradient if (gradientWeight != 0.0) { double[] gradient = function.gradientAt(Point.at(newPoint)).toArray(); for (int d = 0; d < dimension; d++) newPoint[d] -= gradientWeight * gradient[d]; } // get solution error (& update best solution double error = function.valueAt(Point.at(newPoint)); paths[ant] = ValuePoint.at(Point.at(newPoint), error); if (error < best.getValue()) best = paths[ant]; // ValuePoint.at(Point.at(newPoint), error); } // update pheromone double[] bestVect = best.getPoint().toArray(); for (int i = 0; i < dimension; i++) { deviations[i] = (1 - evaporationFactor) * deviations[i] + evaporationFactor * Math.abs(bestVect[i] - means[i]); means[i] = (1 - evaporationFactor) * means[i] + evaporationFactor * bestVect[i]; } telemetry = new ValuePointListTelemetry(Arrays.asList(paths)); if (consumer != null) consumer.notifyOf(this); stopCondition.setValue(best.getValue()); }
public void optimize() { System.arraycopy(x, 0, xNew, 0, dimension); lineSearchMethod.minimize(xNew, direction); for (int i = 0; i < dimension; i++) xDelta[i] = xNew[i] - x[i]; System.arraycopy(xNew, 0, x, 0, dimension); System.arraycopy(g, 0, y, 0, dimension); g = function.gradientAt(Point.at(x)).toArray(); for (int i = 0; i < dimension; i++) y[i] = g[i] - y[i]; for (int i = 0; i < dimension; i++) { Hy[i] = 0.0; for (int j = 0; j < dimension; j++) Hy[i] += H[i][j] * y[j]; } fac = 0.0; fae = 0.0; sumY = 0.0; sumXDelta = 0.0; for (int i = 0; i < dimension; i++) { fac += y[i] * xDelta[i]; fae += y[i] * Hy[i]; sumY += y[i] * y[i]; sumXDelta += xDelta[i] * xDelta[i]; } if (fac > Math.sqrt(MachineAccuracy.EPSILON * sumY * sumXDelta)) { fac = 1.0 / fac; fad = 1.0 / fae; switch (updateMethod) { case DFP: for (int i = 0; i < dimension; i++) for (int j = i; j < dimension; j++) { H[i][j] += fac * xDelta[i] * xDelta[j] - fad * Hy[i] * Hy[j]; H[j][i] = H[i][j]; } break; case BFGS: for (int i = 0; i < dimension; i++) y[i] = fac * xDelta[i] - fad * Hy[i]; for (int i = 0; i < dimension; i++) for (int j = i; j < dimension; j++) { H[i][j] += fac * xDelta[i] * xDelta[j] - fad * Hy[i] * Hy[j] + fae * y[i] * y[j]; H[j][i] = H[i][j]; } break; case BROYDEN_FAMILY: for (int i = 0; i < dimension; i++) y[i] = fac * xDelta[i] - fad * Hy[i]; for (int i = 0; i < dimension; i++) for (int j = i; j < dimension; j++) { H[i][j] += fac * xDelta[i] * xDelta[j] - fad * Hy[i] * Hy[j] + phi * (fae * y[i] * y[j]); H[j][i] = H[i][j]; } break; case BROYDEN: fae = 0.0; for (int i = 0; i < dimension; i++) { xH[i] = 0.0; for (int j = 0; j < dimension; j++) xH[i] += xDelta[j] * H[j][i]; fae += xDelta[i] * Hy[i]; } fae = 1.0 / fae; for (int i = 0; i < dimension; i++) { y[i] = xDelta[i] - Hy[i]; for (int j = i; j < dimension; j++) { H[i][j] += fae * y[i] * xH[j]; H[j][i] = H[i][j]; } } break; } } for (int i = 0; i < dimension; i++) { direction[i] = 0.0; for (int j = 0; j < dimension; j++) direction[i] -= H[i][j] * g[j]; } solution = ValuePoint.at(Point.at(x), function); telemetry = new ValuePointTelemetry(solution); if (consumer != null) consumer.notifyOf(this); stopCondition.setValue(solution.getValue()); }
public void init(final Function function) { xAxis.clear(); yAxis.clear(); if (function != lastFunction) { // need to reset Slot.CIRCLE.clearList(); Slot.CROSS.clearList(); Slot.SQUARE.clearList(); Slot.TRIANGLE.clearList(); } data = new GridPointData(resolution, resolution, 1); plot = new InterpolatedPlot(data); useSlot.clearList(); final List<List<ValuePointColored>> points = useSlot.getPoints(); for (Slot slot : Slot.values()) { if (slot.isShow()) { for (List<ValuePointColored> valuePoints : slot.getPoints()) { for (ValuePointColored valuePoint : valuePoints) { xAxis.add(valuePoint); yAxis.add(valuePoint); } } } } // clean drawing panel drawablePanel.removeDrawables(InterpolatedPlot.class); drawablePanel.addDrawable(plot); datasetRecreation = new Closure() { public void execute(Object input) { List<ValuePointColored> vps = (List<ValuePointColored>) input; points.add(vps); for (ValuePointColored vp : vps) { xAxis.add(vp); yAxis.add(vp); } if (points.size() > maxPoints) { List<ValuePointColored> removed = points.remove(0); for (ValuePointColored valuePoint : removed) { xAxis.remove(valuePoint); yAxis.remove(valuePoint); } } // for ilustration if (xAxis.size() > 0 && yAxis.size() > 0) { double lowerXBound = Math.min( data.getLeft(), Math.floor(xAxis.first().getPoint().toArray()[0] - buffer)); double upperXBound = Math.max( data.getRight(), Math.ceil(xAxis.last().getPoint().toArray()[0] + buffer)); double lowerYBound = Math.min( data.getBottom(), Math.floor(yAxis.first().getPoint().toArray()[1] - buffer)); double upperYBound = Math.max(data.getTop(), Math.ceil(yAxis.last().getPoint().toArray()[1] + buffer)); data.setScale(lowerXBound, upperXBound, lowerYBound, upperYBound); double[][][] xyz = data.getData(); for (int i = 0; i < resolution; i++) { for (int j = 0; j < resolution; j++) { Point p = Point.at(xyz[i][j]); // check the cached value of the point xyz[i][j][2] = /*cache.containsKey(p) ? cache.get(p) :*/ function.valueAt(p); } } } plot.setGridData(data); drawablePanel.repaint(); } }; lastFunction = function; // initialize to center point double lowerXBound = Math.floor(centerX - buffer); double upperXBound = Math.ceil(centerX + buffer); double lowerYBound = Math.floor(centerY - buffer); double upperYBound = Math.ceil(centerY + buffer); data.setScale(lowerXBound, upperXBound, lowerYBound, upperYBound); double[][][] xyz = data.getData(); for (int i = 0; i < resolution; i++) { for (int j = 0; j < resolution; j++) { Point p = Point.at(xyz[i][j]); // check the cached value of the point xyz[i][j][2] = /*cache.containsKey(p) ? cache.get(p) :*/ function.valueAt(p); } } plot.setGridData(data); drawablePanel.repaint(); }